chore: undo some of the unintentded changes

Author: Gozala

packages/ipfs/src/core/components/block/get.js

@@ -3,8 +3,32 @@
 const { cleanCid } = require('./utils')
 const { withTimeoutOption } = require('../../utils')
 
+/**
+ * @typedef {import('cids')} CID
+ * @typedef {import('ipld-block')} Block
+ * @typedef {import('ipfs-block-service')} BlockService
+ * @typedef {import('../init').PreloadService} Preload
+ */
+
+/**
+ * @param {Object} config
+ * @param {BlockService} config.blockService
+ * @param {Preload} config.preload
+ * @returns {Get}
+ */
 module.exports = ({ blockService, preload }) => {
-  return withTimeoutOption(async function get (cid, options) { // eslint-disable-line require-await
+  /**
+   * @typedef {Object} Options
+   * @property {boolean} [preload]
+   *
+   * @callback Get
+   * @param {CID} cid
+   * @param {Options} [options]
+   * @returns {Promise<Block>}
+   *
+   * @type {Get}
+   */
+  async function get (cid, options) { // eslint-disable-line require-await
     options = options || {}
     cid = cleanCid(cid)
 
@@ -13,5 +37,7 @@ module.exports = ({ blockService, preload }) => {
     }
 
     return blockService.get(cid)
-  })
+  }
+
+  return withTimeoutOption(get)
 }

packages/ipfs/src/core/components/block/put.js

@@ -7,18 +7,18 @@ const isIPFS = require('is-ipfs')
 const { withTimeoutOption } = require('../../utils')
 
 /**
- * @typedef {import("ipfs-interface").BlockService} BlockService
- * @typedef {import("ipfs-interface").GCLock} GCLock
- * @typedef {import("ipfs-interface").PreloadService} PreloadService
- * @typedef {import("ipfs-interface").PinService} PinService
+ * @typedef {import("ipfs-block-service")} BlockService
+ * @typedef {import("../init").GCLock} GCLock
+ * @typedef {import("../init").PreloadService} Preload
+ * @typedef {import("../index").Pin} Pin
  */
 
 /**
  * @typedef {Object} PutConfig
  * @property {BlockService} blockService
  * @property {GCLock} gcLock
- * @property {PreloadService} preload
- * @property {PinService} pin
+ * @property {Preload} preload
+ * @property {Pin} pin
  *
  * @param {PutConfig} config
  * @returns {Put}

packages/ipfs/src/core/components/id.js

@@ -5,13 +5,34 @@ const multiaddr = require('multiaddr')
 const { withTimeoutOption } = require('../utils')
 
 /**
- * @param {*} config
- * @returns {*}
+ * @typedef {import("peer-info")} PeerInfo
+ * @typedef {import('multiaddr')} Multiaddr
+ * @typedef {import("./init").LibP2P} LibP2P
+ */
+
+/**
+ * @param {Object} config
+ * @param {PeerInfo} config.peerInfo
+ * @param {LibP2P} config.libp2p
+ * @returns {ID}
  */
 module.exports = ({ peerInfo, libp2p }) => {
-  return withTimeoutOption(async function id () { // eslint-disable-line require-await
+  /**
+   * @typedef {Object} IDInfo
+   * @property {string} id
+   * @property {string} publicKey
+   * @property {Multiaddr[]} addresses
+   * @property {string} agentVersion
+   * @property {string} protocolVersion
+   *
+   * @callback ID
+   * @returns {IDInfo}
+   *
+   * @type {ID}
+   */
+  async function id () { // eslint-disable-line require-await
     const id = peerInfo.id.toB58String()
-    /** @type {Buffer[]} */
+    /** @type {Multiaddr[]} */
     let addresses = []
 
     if (libp2p) {
@@ -39,5 +60,7 @@ module.exports = ({ peerInfo, libp2p }) => {
       agentVersion: `js-ipfs/${pkgversion}`,
       protocolVersion: '9000'
     }
-  })
+  }
+
+  return withTimeoutOption(id)
 }

packages/ipfs/src/core/components/index.js

@@ -7,6 +7,10 @@ exports.add = require('./add')
 
 /**
  * @typedef {Object} Block
+ * @property {ReturnType<import('./block/get')>} get
+ * @property {ReturnType<import('./block/put')>} put
+ * @property {ReturnType<import('./block/rm')>} rm
+ * @property {ReturnType<import('./block/stat')>} stat
  */
 exports.block = {
   get: require('./block/get'),
@@ -60,8 +64,10 @@ exports.dht = require('./dht')
 exports.dns = require('./dns')
 exports.files = require('./files')
 exports.get = require('./get')
+/** @typedef {ReturnType<import('./id')>} ID */
 exports.id = require('./id')
 exports.init = require('./init')
+/** @typedef {ReturnType<import('./is-online')>} IsOnline */
 exports.isOnline = require('./is-online')
 exports.key = {
   export: require('./key/export'),
@@ -125,11 +131,15 @@ exports.repo = {
   stat: require('./repo/stat'),
   version: require('./repo/version')
 }
+
+/** @typedef {ReturnType<import('./ping')>} Resolve */
 exports.resolve = require('./resolve')
+/** @typedef {ReturnType<import('./start')>} Start */
 exports.start = require('./start')
 exports.stats = {
   bw: require('./stats/bw')
 }
+/** @typedef {ReturnType<import('./stop')>} Stop */
 exports.stop = require('./stop')
 exports.swarm = {
   addrs: require('./swarm/addrs'),

packages/ipfs/src/core/components/init.js

@@ -205,7 +205,7 @@ module.exports = ({
 
     const block = {
       get: Components.block.get({ blockService, preload }),
-      put: Components.block.put({ blockService, gcLock, preload, pin }),
+      put: Components.block.put({ blockService, pin, gcLock, preload }),
       rm: Components.block.rm({ blockService, gcLock, pinManager }),
       stat: Components.block.stat({ blockService, preload })
     }
@@ -494,7 +494,7 @@ function createApi ({
       bw: notStarted,
       repo: Components.repo.stat({ repo })
     },
-    stop: () => apiManager.api,
+    stop: () => {},
     swarm: {
       addrs: notStarted,
       connect: notStarted,

packages/ipfs/src/core/components/pin/add.js

@@ -7,13 +7,13 @@ const { resolvePath, withTimeoutOption } = require('../../utils')
  * @typedef {import('cids')} CID
  * @typedef {import('./pin-manager')} PinManager
  * @typedef {import('../init').GCLock} GCLock
- * @typedef {import('../index').DAGService} DAGService
+ * @typedef {import('../index').DAG} DAG
  */
 /**
  * @param {Object} config
  * @param {PinManager} config.pinManager
  * @param {GCLock} config.gcLock
- * @param {DAGService} config.dag
+ * @param {DAG} config.dag
  * @returns {Add}
  */
 module.exports = ({ pinManager, gcLock, dag }) => {
@@ -25,7 +25,7 @@ module.exports = ({ pinManager, gcLock, dag }) => {
    * @property {boolean} [preload]
    *
    * @callback Add
-   * @param {string[]} paths
+   * @param {string[]|CID} paths
    * @param {Options} [options]
    * @returns {Promise<{ cid:CID }[]>}
    *

packages/ipfs/src/core/components/repo/gc.js

@@ -13,7 +13,8 @@ const { parallelMerge, transform, map } = require('streaming-iterables')
 const BLOCK_RM_CONCURRENCY = 256
 
 /**
- * @typedef {import("interface-datastore").Key} Key
+ * @typedef {import('interface-datastore').Key} Key
+ * @typedef {import('../../utils').WithTimeoutOptions} WithTimeoutOptions
  * @typedef {Object} BlockID
  * @property {CID} cid
  * @property {err} [void]
@@ -27,13 +28,17 @@ const BLOCK_RM_CONCURRENCY = 256
 /**
  * Perform mark and sweep garbage collection
  * @param {*} config
- * @returns {function():AsyncIterable<Notification>}
+ * @returns {GC}
  */
 module.exports = ({ gcLock, pin, pinManager, refs, repo }) => {
   /**
+   * @callback GC
+   * @param {WithTimeoutOptions} [options]
    * @returns {AsyncIterable<Notification>}
+   *
+   * @type {GC}
    */
-  async function * gc () {
+  async function * gc (options) {
     const start = Date.now()
     log('Creating set of marked blocks')
 

packages/ipfs/src/core/components/repo/version.js

@@ -44,7 +44,7 @@ module.exports = ({ repo }) => {
       throw err
     }
 
-    return repo.version.get()
+    return repo.version.get(options)
   }
 
   return withTimeoutOption(version)

packages/ipfs/src/core/components/swarm/connect.js

@@ -6,6 +6,7 @@ const { withTimeoutOption } = require('../../utils')
  * @typedef {import('ipfs-interface').LibP2PService} LibP2PService
  * @typedef {import('ipfs-interface').Address} Address
  * @typedef {import('interface-connection').Connection} Connection
+ * @typedef {import('../../utils').WithTimeoutOptions} WithTimeoutOptions
  */
 
 /**
@@ -20,11 +21,12 @@ module.exports = ({ libp2p }) => {
   /**
    * @callback Connect
    * @param {Address} addr
+   * @param {WithTimeoutOptions} [options]
    * @returns {Promise<Connection>}
    * @type {Connect}
    */
-  function connect (addr) {
-    return libp2p.dial(addr)
+  function connect (addr, options) {
+    return libp2p.dial(addr, options)
   }
 
   return withTimeoutOption(connect)

packages/ipfs/src/core/components/swarm/disconnect.js

@@ -22,7 +22,7 @@ module.exports = ({ libp2p }) => {
    * @type {Disconnect}
    */
   function disconnect (addr, options) {
-    return libp2p.hangUp(addr)
+    return libp2p.hangUp(addr, options)
   }
 
   return withTimeoutOption(disconnect)

packages/ipfs/src/core/runtime/ipld-nodejs.js

@@ -59,6 +59,7 @@ const IpldFormats = {
  */
 module.exports = (blockService, options, log) => {
   options = options || {}
+
   return mergeOptions.call(
     // ensure we have the defaults formats even if the user overrides `formats: []`
     { concatArrays: true },

types/ipfs-block-service/ipfs-block-service-tests.ts

@@ -134,13 +134,16 @@ interface Metrics {
 }
 
 export interface LibP2PService {
+  transportManager: {
+    getAddrs():Multiaddr[]
+  }
   start():Promise<void>
   stop():Promise<void>
   connections:Map<string, Connection[]>
 
   dial(address:Address, options?:DialOptions):Promise<Connection>
   dialProtocol(address:Address, protocols:string[], options?:DialOptions):Promise<{stream:DuplexStream<Buffer, Buffer>, protocol:string}>
-  hangUp(peer:Address):Promise<void>
+  hangUp(peer:Address, options?:DialOptions):Promise<void>
   handler(protocols:string, handler:LibP2PHandler):void
   unhandle(protocols:string):void
   ping(address:Address):Promise<number>

types/ipfs-interface/index.d.ts

@@ -1,10 +1,3 @@
-// Type definitions for it-pipe 1.1
-// Project: https://github.com/alanshaw/it-pipe#readme
-// Definitions by: Irakli Gozalishvili <https://github.com/me>
-// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-
-
-
 type Source<T> =
   | Iterable<T>
   | AsyncIterable<T>
@@ -27,12 +20,4 @@ declare interface Pipe {
 
 declare var pipe:Pipe;
 
-// declare namespace pipe {
-//     // Circular reference from it_pipe
-//   const pipe: Pipe;
-//   function isDuplex(obj: any): void;
-//   function isIterable <T>(obj: any): obj is Source<T>;
-//   function rawPipe(fns: any): any;
-// }
-
 export = pipe;