chore: implement interface-store (#91)

We have datastores and blockstores and blockstores are like datastores
just with a different key/value types.

Instead of retyping them, make datastores generic so blockstores can
and datastores can be a specialisation of stores.

Author: achingbrain

package.json

@@ -11,7 +11,7 @@
   ],
   "scripts": {
     "prepare": "aegir build --no-bundle",
-    "lint": "aegir lint",
+    "lint": "aegir ts -p check && aegir lint",
     "test": "aegir test",
     "test:node": "aegir test --target node",
     "test:browser": "aegir test --target browser",
@@ -42,6 +42,7 @@
   },
   "dependencies": {
     "err-code": "^3.0.1",
+    "interface-store": "^0.0.2",
     "ipfs-utils": "^7.0.0",
     "iso-random-stream": "^2.0.0",
     "it-all": "^1.0.2",

src/adapter.js

@@ -6,18 +6,18 @@ const filter = require('it-filter')
 const take = require('it-take')
 
 /**
+ * @typedef {import('interface-store').Options} Options
  * @typedef {import('./key')} Key
  * @typedef {import('./types').Pair} Pair
  * @typedef {import('./types').Datastore} Datastore
- * @typedef {import('./types').Options} Options
  * @typedef {import('./types').Query} Query
  * @typedef {import('./types').KeyQuery} KeyQuery
  * @typedef {import('./types').Batch} Batch
  */
 
 /**
  * @template O
- * @typedef {import('./types').AwaitIterable<O>} AwaitIterable
+ * @typedef {import('interface-store').AwaitIterable<O>} AwaitIterable
  */
 
 /**

src/index.js

@@ -3,7 +3,7 @@
 /**
  * @typedef {import('./types').Datastore} Datastore
  * @typedef {import('./types').Batch} Batch
- * @typedef {import('./types').Options} Options
+ * @typedef {import('interface-store').Options} Options
  * @typedef {import('./types').Query} Query
  * @typedef {import('./types').QueryFilter} QueryFilter
  * @typedef {import('./types').QueryOrder} QueryOrder

src/memory.js

@@ -7,7 +7,7 @@ const Errors = require('./errors')
 /**
  * @typedef {import('./types').Pair} Pair
  * @typedef {import('./types').Datastore} Datastore
- * @typedef {import('./types').Options} Options
+ * @typedef {import('interface-store').Options} Options
  */
 
 /**

src/types.d.ts

@@ -1,185 +1,53 @@
+import {
+  Pair as StorePair,
+  Batch as StoreBatch,
+  QueryFilter as StoreQueryFilter,
+  QueryOrder as StoreQueryOrder,
+  Query as StoreQuery,
+  KeyQueryFilter as StoreKeyQueryFilter,
+  KeyQueryOrder as StoreKeyQueryOrder,
+  KeyQuery as StoreKeyQuery,
+  Options as StoreOptions,
+  Store
+} from 'interface-store'
 import type Key from './key'
 
-export type AwaitIterable<T> = Iterable<T> | AsyncIterable<T>
-export type Await<T> = Promise<T> | T
-export interface Pair {
-  key: Key
-  value: Uint8Array
+export interface Options extends StoreOptions{
+
+}
+
+export interface Pair extends StorePair<Key, Uint8Array> {
+
+}
+
+export interface Batch extends StoreBatch<Key, Uint8Array> {
+
+}
+
+export interface Datastore extends Store<Key, Uint8Array> {
+
 }
-/**
- * Options for async operations.
- */
-export interface Options {
-  signal?: AbortSignal
+
+export interface QueryFilter extends StoreQueryFilter<Key, Uint8Array> {
+
 }
 
-export interface Batch {
-  put: (key: Key, value: Uint8Array) => void
-  delete: (key: Key) => void
-  commit: (options?: Options) => Promise<void>
+export interface QueryOrder extends StoreQueryOrder<Key, Uint8Array> {
+
 }
-export interface Datastore {
-  open: () => Promise<void>
-  close: () => Promise<void>
-  /**
-   * Store the passed value under the passed key
-   *
-   * @example
-   *
-   * ```js
-   * await store.put([{ key: new Key('awesome'), value: new Uint8Array([0, 1, 2, 3]) }])
-   * ```
-   */
-  put: (key: Key, val: Uint8Array, options?: Options) => Promise<void>
-  /**
-   * Retrieve the value stored under the given key
-   *
-   * @example
-   * ```js
-   * const value = await store.get(new Key('awesome'))
-   * console.log('got content: %s', value.toString('utf8'))
-   * // => got content: datastore
-   * ```
-   */
-  get: (key: Key, options?: Options) => Promise<Uint8Array>
-  /**
-   * Check for the existence of a value for the passed key
-   *
-   * @example
-   * ```js
-   *const exists = await store.has(new Key('awesome'))
-   *
-   *if (exists) {
-   *  console.log('it is there')
-   *} else {
-   *  console.log('it is not there')
-   *}
-   *```
-   */
-  has: (key: Key, options?: Options) => Promise<boolean>
-  /**
-   * Remove the record for the passed key
-   *
-   * @example
-   *
-   * ```js
-   * await store.delete(new Key('awesome'))
-   * console.log('deleted awesome content :(')
-   * ```
-   */
-  delete: (key: Key, options?: Options) => Promise<void>
-  /**
-   * Store the given key/value pairs
-   *
-   * @example
-   * ```js
-   * const source = [{ key: new Key('awesome'), value: new Uint8Array([0, 1, 2, 3]) }]
-   *
-   * for await (const { key, value } of store.putMany(source)) {
-   *   console.info(`put content for key ${key}`)
-   * }
-   * ```
-   */
-  putMany: (
-    source: AwaitIterable<Pair>,
-    options?: Options
-  ) => AsyncIterable<Pair>
-  /**
-   * Retrieve values for the passed keys
-   *
-   * @example
-   * ```js
-   * for await (const value of store.getMany([new Key('awesome')])) {
-   *   console.log('got content:', new TextDecoder('utf8').decode(value))
-   *   // => got content: datastore
-   * }
-   * ```
-   */
-  getMany: (
-    source: AwaitIterable<Key>,
-    options?: Options
-  ) => AsyncIterable<Uint8Array>
-  /**
-   * Remove values for the passed keys
-   *
-   * @example
-   *
-   * ```js
-   * const source = [new Key('awesome')]
-   *
-   * for await (const key of store.deleteMany(source)) {
-   *   console.log(`deleted content with key ${key}`)
-   * }
-   * ```
-   */
-  deleteMany: (
-    source: AwaitIterable<Key>,
-    options?: Options
-  ) => AsyncIterable<Key>
-  /**
-   * This will return an object with which you can chain multiple operations together, with them only being executed on calling `commit`.
-   *
-   * @example
-   * ```js
-   * const b = store.batch()
-   *
-   * for (let i = 0; i < 100; i++) {
-   *   b.put(new Key(`hello${i}`), new TextEncoder('utf8').encode(`hello world ${i}`))
-   * }
-   *
-   * await b.commit()
-   * console.log('put 100 values')
-   * ```
-   */
-  batch: () => Batch
-  /**
-   * Query the store.
-   *
-   * @example
-   * ```js
-   * // retrieve __all__ key/value pairs from the store
-   * let list = []
-   * for await (const { key, value } of store.query({})) {
-   *   list.push(value)
-   * }
-   * console.log('ALL THE VALUES', list)
-   * ```
-   */
-   query: (query: Query, options?: Options) => AsyncIterable<Pair>
-   /**
-   * Query the store.
-   *
-   * @example
-   * ```js
-   * // retrieve __all__ keys from the store
-   * let list = []
-   * for await (const key of store.queryKeys({})) {
-   *   list.push(key)
-   * }
-   * console.log('ALL THE KEYS', key)
-   * ```
-   */
-   queryKeys: (query: KeyQuery, options?: Options) => AsyncIterable<Key>
+
+export interface Query extends StoreQuery<Key, Uint8Array> {
+
+}
+
+export interface KeyQueryFilter extends StoreKeyQueryFilter<Key> {
+
 }
 
-export type QueryFilter = (item: Pair) => boolean
-export type QueryOrder = (a: Pair, b: Pair) => -1 | 0 | 1
+export interface KeyQueryOrder extends StoreKeyQueryOrder<Key> {
 
-export interface Query {
-  prefix?: string
-  filters?: QueryFilter[]
-  orders?: QueryOrder[]
-  limit?: number
-  offset?: number
 }
 
-export type KeyQueryFilter = (item: Key) => boolean
-export type KeyQueryOrder = (a: Key, b: Key) => -1 | 0 | 1
+export interface KeyQuery extends StoreKeyQuery<Key> {
 
-export interface KeyQuery {
-  prefix?: string
-  filters?: KeyQueryFilter[]
-  orders?: KeyQueryOrder[]
-  limit?: number
-  offset?: number
 }

src/utils.js

@@ -3,22 +3,12 @@
 const tempdir = require('ipfs-utils/src/temp-dir')
 const all = require('it-all')
 
-/**
- * @template T
- * @typedef {import("./types").Await<T>} PromiseOrValue
- */
-
-/**
- * @template T
- * @typedef {import("./types").AwaitIterable<T>} AnyIterable
- */
-
 /**
  * Collect all values from the iterable and sort them using
  * the passed sorter function
  *
  * @template T
- * @param {AnyIterable<T>} iterable
+ * @param {AsyncIterable<T> | Iterable<T>} iterable
  * @param {(a: T, b: T) => -1 | 0 | 1} sorter
  * @returns {AsyncIterable<T>}
  */