feat: Add pin.add to ipfs-message-port

packages/ipfs-core-types/src/pin/index.d.ts

@@ -1,6 +1,6 @@
 import type { AbortOptions, AwaitIterable } from '../utils'
 import type CID from 'cids'
-import type { API as Remote } from './remote'
+import type { API as RemoteAPI } from './remote'
 
 export interface API<OptionExtension = {}> {
   /**
@@ -32,7 +32,7 @@ export interface API<OptionExtension = {}> {
    * // CID('QmWATWQ7fVPP2EFGu71UkfnqhYXDYH566qy47CnJDgvs8u')
    * ```
    */
-  addAll: (source: AwaitIterable<AddInput>, options?: AddAllOptions & OptionExtension) => AsyncIterable<CID>
+  addAll: (source: PinSource, options?: AddAllOptions & OptionExtension) => AsyncIterable<CID>
 
   /**
    * List all the objects pinned to local storage
@@ -90,9 +90,9 @@ export interface API<OptionExtension = {}> {
    * // CID('QmWATWQ7fVPP2EFGu71UkfnqhYXDYH566qy47CnJDgvs8u')
    * ```
    */
-  rmAll: (source: AwaitIterable<RmAllInput>, options?: AbortOptions & OptionExtension) => AsyncIterable<CID>
+  rmAll: (source: PinSource, options?: AbortOptions & OptionExtension) => AsyncIterable<CID>
 
-  remote: Remote<OptionExtension>
+  remote: RemoteAPI<OptionExtension>
 }
 
 export interface AddOptions extends AbortOptions {
@@ -124,50 +124,62 @@ export interface AddAllOptions extends AbortOptions {
   lock?: boolean
 }
 
-export interface AddInput {
-  /**
-   * A CID to pin - nb. you must pass either `cid` or `path`, not both
-   */
-  cid?: CID
+export type Metadata = Record<string, any>
+export type ToPin =
+  | CID
+  | string
+  | ToPinWithCID
+  | ToPinWithPath
 
+export interface ToPinWithPath extends PinDetails {
   /**
-   * An IPFS path to pin - nb. you must pass either `cid` or `path`, not both
-   */
-  path?: string
+   * An IPFS path to pin.
+  */
+  path: string
+
+  cid?: undefined
+}
+
+export interface ToPinWithCID extends PinDetails {
+  path?: undefined
+  cid: CID
+}
 
+export interface PinDetails {
   /**
    * If true, pin all blocked linked to from the pinned CID
    */
   recursive?: boolean
 
+  metadata?: Metadata
+
   /**
    * A human readable string to store with this pin
    */
   comments?: string
 }
 
-export type PinType = 'recursive' | 'direct' | 'indirect' | 'all'
-
-export type PinQueryType = 'recursive' | 'direct' | 'indirect' | 'all'
-
-export interface LsOptions  extends AbortOptions {
-  paths?: CID | CID[] | string | string[]
+export type PinSource = AwaitIterable<ToPin>
+
+export type PinType =
+  | 'recursive'
+  | 'direct'
+  | 'indirect'
+export type PinQueryType =
+  | PinType
+  | 'all'
+export interface LsOptions extends AbortOptions {
+  paths?: CID | string | Array<CID | string>
   type?: PinQueryType
 }
 
 export interface LsResult {
   cid: CID
   type: PinType | string
-  metadata?: Record<string, any>
+  metadata?: Metadata
 }
 
 export interface RmOptions extends AbortOptions {
   recursive?: boolean
 }
 
-export interface RmAllInput {
-  cid?: CID
-  path?: string
-  recursive?: boolean
-}
-

packages/ipfs-core-types/src/utils.d.ts

@@ -133,3 +133,57 @@ export interface BufferStore {
   get: (key: Uint8Array) => Promise<Uint8Array>
   stores: any[]
 }
+
+export interface Blockstore {
+  open: () => Promise<Void>
+
+  /**
+   * Query the store
+   */
+  query: (Query, options?: DatastoreOptions) => AsyncIterable<Block>
+
+  /**
+   * Query the store, returning only keys
+   */
+   queryKeys: (query: KeyQuery, options?: DatastoreOptions) => AsyncIterable<CID>
+
+  /**
+   * Get a single block by CID
+   */
+  get: (cid: CID, options?: DatastoreOptions) => Promise<Block>
+
+  /**
+   * Like get, but for more
+   */
+  getMany: (cids: AwaitIterable<CID>, options?: DatastoreOptions) => AsyncIterable<Block>
+
+  /**
+   * Write a single block to the store
+   */
+  put: (block: Block, options?: DatastoreOptions) => Promise<Block>
+
+  /**
+   * Like put, but for more
+   */
+  putMany: (blocks: AwaitIterable<Block>, options?: DatastoreOptions) => AsyncIterable<Block>
+
+  /**
+   * Does the store contain block with this CID?
+   */
+  has: (cid: CID, options?: DatastoreOptions) => Promise<boolean>
+
+  /**
+   * Delete a block from the store
+   */
+  delete: (cid: CID, options?: DatastoreOptions) => Promise<Void>
+
+  /**
+   * Delete a block from the store
+   */
+  deleteMany: (cids: AwaitIterable<any>, options?: DatastoreOptions) => AsyncIterable<Key>
+
+  /**
+   * Close the store
+   */
+  close: () => Promise<Void>
+}

packages/ipfs-core-utils/src/iterable.js

@@ -0,0 +1,23 @@
+'use strict'
+
+/**
+ * @template {Iterable<any>} T
+ * @template U
+ * @param {T|U} value
+ * @returns {value is T}
+ */
+const isIterable = (value) =>
+  // @ts-ignore
+  value && value[Symbol.iterator]
+
+/**
+ * @template {AsyncIterable<any>} T
+ * @template U
+ * @param {T|U} value
+ * @returns {value is T}
+ */
+const isAsyncIterable = value =>
+  // @ts-ignore
+  value && value[Symbol.asyncIterator]
+
+module.exports = { isIterable, isAsyncIterable }

packages/ipfs-core-utils/src/pins/normalise-input.js

@@ -2,6 +2,7 @@
 
 const errCode = require('err-code')
 const CID = require('cids')
+const { isIterable, isAsyncIterable } = require('../iterable')
 
 /**
  * @typedef {Object} Pinnable
@@ -42,24 +43,33 @@ const CID = require('cids')
  * AsyncIterable<{ path: CID|String, recursive:boolean, metadata }>
  * ```
  *
- * @param {Source} input
- * @returns {AsyncIterable<Pin>}
+ * @param {import('ipfs-core-types/src/pin').ToPin|import('ipfs-core-types/src/pin').PinSource} input
+ * @returns {AsyncIterable<import('ipfs-core-types/src/pin').ToPinWithPath>}
  */
-// eslint-disable-next-line complexity
-module.exports = async function * normaliseInput (input) {
+async function * normaliseInput (input) {
   // must give us something
   if (input === null || input === undefined) {
     throw errCode(new Error(`Unexpected input: ${input}`), 'ERR_UNEXPECTED_INPUT')
   }
 
   // CID|String
-  if (CID.isCID(input)) {
-    yield toPin({ cid: input })
+  if (CID.isCID(input) || typeof input === 'string' || input instanceof String) {
+    return yield toPin(input)
+  }
+
+  // Iterable<?>
+  if (isIterable(input)) {
+    for (const each of input) {
+      yield toPin(each)
+    }
     return
   }
 
-  if (input instanceof String || typeof input === 'string') {
-    yield toPin({ path: input })
+  // AsyncIterable<?>
+  if (isAsyncIterable(input)) {
+    for await (const each of input) {
+      yield toPin(each)
+    }
     return
   }
 
@@ -70,84 +80,30 @@ module.exports = async function * normaliseInput (input) {
     return yield toPin(input)
   }
 
-  // Iterable<?>
-  if (Symbol.iterator in input) {
-    // @ts-ignore
-    const iterator = input[Symbol.iterator]()
-    const first = iterator.next()
-    if (first.done) return iterator
-
-    // Iterable<CID|String>
-    if (CID.isCID(first.value) || first.value instanceof String || typeof first.value === 'string') {
-      yield toPin({ cid: first.value })
-      for (const cid of iterator) {
-        yield toPin({ cid })
-      }
-      return
-    }
-
-    // Iterable<{ cid: CID recursive, metadata }>
-    if (first.value.cid != null || first.value.path != null) {
-      yield toPin(first.value)
-      for (const obj of iterator) {
-        yield toPin(obj)
-      }
-      return
-    }
-
-    throw errCode(new Error('Unexpected input: ' + typeof input), 'ERR_UNEXPECTED_INPUT')
-  }
-
-  // AsyncIterable<?>
-  if (Symbol.asyncIterator in input) {
-    // @ts-ignore
-    const iterator = input[Symbol.asyncIterator]()
-    const first = await iterator.next()
-    if (first.done) return iterator
-
-    // AsyncIterable<CID|String>
-    if (CID.isCID(first.value) || first.value instanceof String || typeof first.value === 'string') {
-      yield toPin({ cid: first.value })
-      for await (const cid of iterator) {
-        yield toPin({ cid })
-      }
-      return
-    }
-
-    // AsyncIterable<{ cid: CID|String recursive, metadata }>
-    if (first.value.cid != null || first.value.path != null) {
-      yield toPin(first.value)
-      for await (const obj of iterator) {
-        yield toPin(obj)
-      }
-      return
-    }
-
-    throw errCode(new Error('Unexpected input: ' + typeof input), 'ERR_UNEXPECTED_INPUT')
-  }
-
   throw errCode(new Error('Unexpected input: ' + typeof input), 'ERR_UNEXPECTED_INPUT')
 }
 
 /**
- * @param {Pinnable} input
+ * @param {import('ipfs-core-types/src/pin').ToPin | InstanceType<typeof window.String>} input
+ * @returns {import('ipfs-core-types/src/pin').ToPinWithPath}
  */
-function toPin (input) {
-  const path = input.cid || `${input.path}`
-
-  if (!path) {
-    throw errCode(new Error('Unexpected input: Please path either a CID or an IPFS path'), 'ERR_UNEXPECTED_INPUT')
-  }
-
-  /** @type {Pin} */
-  const pin = {
-    path,
-    recursive: input.recursive !== false
-  }
-
-  if (input.metadata != null) {
-    pin.metadata = input.metadata
+const toPin = (input) => {
+  if (typeof input === 'string') {
+    return { path: input, recursive: true }
+  } else if (input instanceof String) {
+    return { path: input.toString(), recursive: true }
+  } else if (CID.isCID(input)) {
+    return { path: input.toString(), recursive: true }
+  } else {
+    return {
+      path: `${input.path == null ? input.cid : input.path}`,
+      recursive: input.recursive !== false,
+      ...(input.metadata && { metadata: input.metadata })
+    }
   }
+}
 
-  return pin
+module.exports = {
+  normaliseInput,
+  toPin
 }

packages/ipfs-core-utils/test/pins/normalise-input.spec.js

@@ -3,7 +3,7 @@
 /* eslint-env mocha */
 
 const { expect } = require('aegir/utils/chai')
-const normalise = require('../../src/pins/normalise-input')
+const { normaliseInput: normalise } = require('../../src/pins/normalise-input')
 const all = require('it-all')
 const CID = require('cids')