From 78f39b8ff8f46c7da7860653960061f49a7867ff Mon Sep 17 00:00:00 2001 From: Irakli Gozalishvili Date: Tue, 2 Jun 2020 13:16:18 -0700 Subject: [PATCH 01/63] chore: reset f584f06f5046c9ce234ba6f0832bf5a6aec9b702 to 5e0a18aa07c1852d2a7589899661761db50eeda9 --- .../ipfs-message-port-client/package.json | 180 ++++++++++ .../ipfs-message-port-client/src/client.js | 257 ++++++++++++++ packages/ipfs-message-port-client/src/core.js | 164 +++++++++ packages/ipfs-message-port-client/src/dag.js | 144 ++++++++ .../ipfs-message-port-client/src/errors.js | 6 + .../ipfs-message-port-client/src/files.js | 334 ++++++++++++++++++ .../ipfs-message-port-client/src/index.js | 74 ++++ .../ipfs-message-port-client/test/.aegir.js | 47 +++ .../ipfs-message-port-client/test/dag.spec.js | 71 ++++ .../test/util/client.js | 18 + .../test/util/webpack.config.js | 13 + .../test/util/worker.js | 34 ++ .../ipfs-message-port-client/tsconfig.json | 24 ++ .../ipfs-message-port-protocol/package.json | 180 ++++++++++ .../ipfs-message-port-protocol/src/core.ts | 115 ++++++ .../ipfs-message-port-protocol/src/dag.ts | 42 +++ .../ipfs-message-port-protocol/src/data.ts | 49 +++ .../ipfs-message-port-protocol/src/files.ts | 155 ++++++++ .../ipfs-message-port-protocol/src/rpc.ts | 130 +++++++ .../ipfs-message-port-protocol/tsconfig.json | 21 ++ .../ipfs-message-port-server/package.json | 184 ++++++++++ packages/ipfs-message-port-server/src/core.js | 180 ++++++++++ packages/ipfs-message-port-server/src/dag.js | 77 ++++ .../ipfs-message-port-server/src/files.js | 239 +++++++++++++ .../ipfs-message-port-server/src/index.js | 72 ++++ packages/ipfs-message-port-server/src/ipfs.ts | 196 ++++++++++ .../ipfs-message-port-server/src/server.js | 282 +++++++++++++++ packages/ipfs-message-port-server/src/util.js | 120 +++++++ .../ipfs-message-port-server/tsconfig.json | 24 ++ 29 files changed, 3432 insertions(+) create mode 100644 packages/ipfs-message-port-client/package.json create mode 100644 packages/ipfs-message-port-client/src/client.js create mode 100644 packages/ipfs-message-port-client/src/core.js create mode 100644 packages/ipfs-message-port-client/src/dag.js create mode 100644 packages/ipfs-message-port-client/src/errors.js create mode 100644 packages/ipfs-message-port-client/src/files.js create mode 100644 packages/ipfs-message-port-client/src/index.js create mode 100644 packages/ipfs-message-port-client/test/.aegir.js create mode 100644 packages/ipfs-message-port-client/test/dag.spec.js create mode 100644 packages/ipfs-message-port-client/test/util/client.js create mode 100644 packages/ipfs-message-port-client/test/util/webpack.config.js create mode 100644 packages/ipfs-message-port-client/test/util/worker.js create mode 100644 packages/ipfs-message-port-client/tsconfig.json create mode 100644 packages/ipfs-message-port-protocol/package.json create mode 100644 packages/ipfs-message-port-protocol/src/core.ts create mode 100644 packages/ipfs-message-port-protocol/src/dag.ts create mode 100644 packages/ipfs-message-port-protocol/src/data.ts create mode 100644 packages/ipfs-message-port-protocol/src/files.ts create mode 100644 packages/ipfs-message-port-protocol/src/rpc.ts create mode 100644 packages/ipfs-message-port-protocol/tsconfig.json create mode 100644 packages/ipfs-message-port-server/package.json create mode 100644 packages/ipfs-message-port-server/src/core.js create mode 100644 packages/ipfs-message-port-server/src/dag.js create mode 100644 packages/ipfs-message-port-server/src/files.js create mode 100644 packages/ipfs-message-port-server/src/index.js create mode 100644 packages/ipfs-message-port-server/src/ipfs.ts create mode 100644 packages/ipfs-message-port-server/src/server.js create mode 100644 packages/ipfs-message-port-server/src/util.js create mode 100644 packages/ipfs-message-port-server/tsconfig.json diff --git a/packages/ipfs-message-port-client/package.json b/packages/ipfs-message-port-client/package.json new file mode 100644 index 0000000000..4873065044 --- /dev/null +++ b/packages/ipfs-message-port-client/package.json @@ -0,0 +1,180 @@ +{ + "name": "ipfs-message-port-client", + "version": "0.0.1", + "description": "A client library for the IPFS across message port", + "keywords": ["ipfs"], + "homepage": "https://github.com/ipfs/js-ipfs/tree/master/packages/ipfs-message-port-client#readme", + "bugs": "https://github.com/ipfs/js-ipfs/issues", + "license": "(Apache-2.0 OR MIT)", + "leadMaintainer": "Alex Potsides ", + "files": ["src", "dist"], + "main": "src/index.js", + "browser": {}, + "repository": { + "type": "git", + "url": "git+https://github.com/ipfs/js-ipfs.git" + }, + "scripts": { + "test": "aegir build -- cross-env ECHO_SERVER_PORT=37490 aegir test -t browser", + "test:browser": "cross-env ECHO_SERVER_PORT=37492 aegir test -t browser", + "test:electron-main": "cross-env ECHO_SERVER_PORT=37494 aegir test -t electron-main", + "test:electron-renderer": "cross-env ECHO_SERVER_PORT=37495 aegir test -t electron-renderer", + "test:chrome": "cross-env ECHO_SERVER_PORT=37496 aegir test -t browser -- --browsers ChromeHeadless", + "test:firefox": "cross-env ECHO_SERVER_PORT=37497 aegir test -t browser -- --browsers FirefoxHeadless", + "lint": "aegir lint", + "build": "aegir build", + "coverage": "npx nyc -r html npm run test:node -- --bail", + "clean": "rm -rf ./dist", + "dep-check": "aegir dep-check" + }, + "dependencies": { + "abort-controller": "^3.0.0", + "bignumber.js": "^9.0.0", + "bs58": "^4.0.1", + "buffer": "^5.4.2", + "cids": "^0.8.0", + "debug": "^4.1.0", + "form-data": "^3.0.0", + "ipfs-block": "^0.8.1", + "ipfs-core-utils": "^0.2.2", + "ipfs-utils": "^2.2.2", + "ipld-dag-cbor": "^0.15.1", + "ipld-dag-pb": "^0.18.3", + "ipld-raw": "^4.0.1", + "iso-url": "^0.4.7", + "it-tar": "^1.2.1", + "it-to-buffer": "^1.0.0", + "it-to-stream": "^0.1.1", + "merge-options": "^2.0.0", + "multiaddr": "^7.2.1", + "multiaddr-to-uri": "^5.1.0", + "multibase": "^0.7.0", + "multicodec": "^1.0.0", + "multihashes": "^0.4.14", + "nanoid": "^3.0.2", + "node-fetch": "^2.6.0", + "parse-duration": "^0.1.2", + "stream-to-it": "^0.2.0" + }, + "devDependencies": { + "aegir": "^21.10.1", + "browser-process-platform": "^0.1.1", + "cross-env": "^7.0.0", + "go-ipfs-dep": "0.4.23-3", + "interface-ipfs-core": "^0.134.3", + "ipfsd-ctl": "^3.0.0", + "it-all": "^1.0.1", + "it-concat": "^1.0.0", + "it-pipe": "^1.1.0", + "nock": "^12.0.3", + "ipfs-message-port-protocol": "^0", + "ipfs-message-port-server": "^0", + "ipfs": "^0.43.3" + }, + "engines": { + "node": ">=10.3.0", + "npm": ">=3.0.0" + }, + "contributors": [ + "Alan Shaw ", + "Alan Shaw ", + "Alex Mingoia ", + "Alex Potsides ", + "Antonio Tenorio-Fornés ", + "Bruno Barbieri ", + "Clemo ", + "Connor Keenan ", + "Daniel Constantin ", + "Danny ", + "David Braun ", + "David Dias ", + "Dietrich Ayala ", + "Diogo Silva ", + "Dmitriy Ryajov ", + "Dmitry Nikulin ", + "Donatas Stundys ", + "Fil ", + "Filip Š ", + "Francisco Baio Dias ", + "Friedel Ziegelmayer ", + "Gar ", + "Gavin McDermott ", + "Gopalakrishna Palem ", + "Greenkeeper ", + "Haad ", + "Harlan T Wood ", + "Harlan T Wood ", + "Henrique Dias ", + "Holodisc ", + "Hugo Dias ", + "Hugo Dias ", + "JGAntunes ", + "Jacob Heun ", + "James Halliday ", + "Jason Carver ", + "Jason Papakostas ", + "Jeff Downie ", + "Jeromy ", + "Jeromy ", + "Jim Pick ", + "Joe Turgeon ", + "Jonathan ", + "Juan Batiz-Benet ", + "Kevin Wang ", + "Kristoffer Ström ", + "Marcin Rataj ", + "Matt Bell ", + "Matt Ober ", + "Maxime Lathuilière ", + "Michael Bradley ", + "Michael Muré ", + "Michael Muré ", + "Mikeal Rogers ", + "Mitar ", + "Mithgol ", + "Mohamed Abdulaziz ", + "Nitin Patel <31539366+niinpatel@users.noreply.github.com>", + "Nuno Nogueira ", + "Níckolas Goline ", + "Oli Evans ", + "Orie Steele ", + "Paul Cowgill ", + "Pedro Santos ", + "Pedro Santos ", + "Pedro Teixeira ", + "Pete Thomas ", + "Richard Littauer ", + "Richard Schneider ", + "Roman Khafizianov ", + "SeungWon ", + "Stephen Whitmore ", + "Tara Vancil ", + "Teri Chadbourne ", + "Travis Person ", + "Travis Person ", + "Vasco Santos ", + "Vasco Santos ", + "Victor Bjelkholm ", + "Volker Mische ", + "Zhiyuan Lin ", + "dirkmc ", + "dmitriy ryajov ", + "elsehow ", + "ethers ", + "greenkeeper[bot] <23040076+greenkeeper[bot]@users.noreply.github.com>", + "greenkeeper[bot] ", + "haad ", + "kumavis ", + "leekt216 ", + "nginnever ", + "noah the goodra ", + "phillmac ", + "priecint ", + "samuli ", + "sarthak khandelwal ", + "shunkin ", + "victorbjelkholm ", + "Łukasz Magiera ", + "Łukasz Magiera " + ] +} diff --git a/packages/ipfs-message-port-client/src/client.js b/packages/ipfs-message-port-client/src/client.js new file mode 100644 index 0000000000..1e393bb766 --- /dev/null +++ b/packages/ipfs-message-port-client/src/client.js @@ -0,0 +1,257 @@ +'use strict' + +/* eslint-env browser */ + +class RemoteError extends Error {} + +class TimeoutError extends Error {} + +class AbortError extends Error {} + +class DisconnectError extends Error {} + +/** + * @template T + * @typedef {import('ipfs-message-port-protocol/src/rpc').Remote} Remote + */ + +/** + * @template T + * @typedef {import('ipfs-message-port-protocol/src/rpc').ProcedureNames} ProcedureNames + */ + +/** + * @typedef {Object} QueryOptions + * @property {AbortSignal} [signal] + * @property {number} [timeout] + * @property {Transferable[]} [transfer] + */ + +/** + * @template I + * @typedef {I & QueryOptions} QueryInput + */ + +/** + * @template I,O + * @extends {Promise} + */ +class Query extends Promise { + /** + * @param {string} namespace + * @param {string} method + * @param {QueryInput} input + */ + constructor (namespace, method, input) { + super((succeed, fail) => { + this.succeed = succeed + this.fail = fail + this.abortController = new AbortController() + this.signal = this.abortController.signal + this.input = input + this.namespace = namespace + this.method = method + this.timeout = Infinity + }) + } + + /** + * @returns {Object} + */ + toJSON () { + return this.input + } + + /** + * @returns {Transferable[]} + */ + transfer () { + return this.input.transfer + } + + abort () { + this.abortController.abort() + this.fail(new AbortError()) + } +} + +/** @typedef {Transport} ClientTransport */ +class Transport { + /** + * Create transport for the underlying message port. + * @param {MessagePort} [port] + */ + constructor (port) { + this.port = null + this.nextID = 0 + /** @type {Record>} */ + this.queries = Object.create(null) + if (port) { + this.connect(port) + } + } + + /** + * @template I, O + * @param {Query} query + * @returns {Query} + */ + execute (query) { + const id = `@${this.nextID++}` + this.queries[id] = query + + if (query.timeout > 0 && query.timeout < Infinity) { + setTimeout(Transport.timeout, query.timeout, this, id) + } + + query.signal.addEventListener('abort', () => this.abort(id), { once: true }) + + if (this.port) { + Transport.postQuery(this.port, id, query) + } + + return query + } + + /** + * @param {Transport} self + * @param {string} id + */ + static timeout (self, id) { + const { queries } = self + const query = queries[id] + if (query) { + self.abort(id) + query.fail(new TimeoutError()) + } + } + + /** + * + * @param {string} id + */ + abort (id) { + const query = this.queries[id] + if (query) { + delete this.queries[id] + if (this.port) { + this.port.postMessage({ type: 'abort', id }) + } + } + } + + /** + * @param {MessagePort} port + * @param {string} id + * @param {Query} query + */ + static postQuery (port, id, query) { + port.postMessage( + { + type: 'query', + method: query.method, + id, + query: query.toJSON() + }, + query.transfer() + ) + } + + /** + * @param {MessagePort} port + */ + connect (port) { + if (this.port) { + throw new RangeError('Transport is already open') + } else { + this.port = port + this.port.addEventListener('message', this) + this.port.start() + for (const [id, query] of Object.entries(this.queries)) { + Transport.postQuery(port, id, query) + } + } + } + + disconnect () { + if (this.port) { + const error = new DisconnectError() + for (const [id, query] of Object.entries(this.queries)) { + query.fail(error) + this.abort(id) + } + this.port.removeEventListener('message', this) + this.port.close() + } + } + + /** + * @param {MessageEvent} event + */ + handleEvent (event) { + const { id, result } = event.data + const query = this.queries[id] + if (query) { + delete this.queries[id] + if (result.ok) { + query.succeed(result.value) + } else { + query.fail(new RemoteError(result.error)) + } + } else { + throw new RangeError(`Received response${id} for unknown query`) + } + } +} + +/** + * @template T + * @typedef {Array} Keys + */ + +/** + * @template T + * @typedef {Remote & Service} RemoteService + */ + +/** + * @template T + */ +class Service { + /** + * @param {string} namespace + * @param {ProcedureNames} methods + * @param {Transport} transport + */ + constructor (namespace, methods, transport) { + this.transport = transport + /** @type {any} */ + const self = (this) + for (const method of methods) { + /** + * @template I, O + * @param {I} input + * @returns {Query} + */ + self[method] = input => + this.transport.execute(new Query(namespace, method.toString(), input)) + } + } +} + +/** + * @template T + */ +class Client { + /** + * @param {string} namespace + * @param {ProcedureNames} methods + * @param {Transport} transport + */ + constructor (namespace, methods, transport) { + /** @type {RemoteService} */ + this.remote = (new Service(namespace, methods, transport)) + } +} + +module.exports = { Client, Transport, RemoteError, AbortError, DisconnectError } diff --git a/packages/ipfs-message-port-client/src/core.js b/packages/ipfs-message-port-client/src/core.js new file mode 100644 index 0000000000..fb4649967b --- /dev/null +++ b/packages/ipfs-message-port-client/src/core.js @@ -0,0 +1,164 @@ +'use strict' + +const CID = require('cids') +const { AbortError } = require('./errors') +/** + * @typedef {Object} NoramilzedFileInput + * @property {string} path + * @property {AsyncIterable} content + * + * @typedef {Int8Array|Uint8Array|Uint8ClampedArray|Int16Array|Int32Array|Uint32Array|Float32Array|Float64Array|BigInt64Array|BigUint64Array} TypedArray + * @typedef {ArrayBuffer|ArrayBufferView} Bytes + * + * @typedef {Bytes|Blob|string|Iterable|Iterable|AsyncIterable} FileContent + * @typedef {Object} FileObject + * @property {string} [path] + * @property {FileContent} [content] + * @property {string|number} [mode] + * @property {UnixTime} [mtime] + * + * @typedef {Date|Time|[number, number]} UnixTime + * @typedef {Bytes|Blob|string|FileObject|Iterable|Iterable|Iterable|Iterable|Iterable|AsyncIterable|AsyncIterable|AsyncIterable|AsyncIterable} AnyFileInput + * + */ +/** @type {(input:AnyFileInput) => AsyncIterable} */ +// @ts-ignore +const normaliseInput = require('ipfs-core-utils/src/files/normalise-input') + +/** + * @typedef {import("./connection")} RPCConnection + * @typedef {import("./connection").RPCRequestOptions} RPCRequestOptions + * @typedef {import("./files").Time} Time + * + * @typedef {Object} AddOptions + * @property {chunker} [string="size-262144"] + * @property {number} [cidVersion=0] + * @property {boolean} [enableShardingExperiment] + * @property {string} [hashAlg="sha2-256"] + * @property {boolean} [onlyHash=false] + * @property {boolean} [pin=true] + * @property {(added:number) => void} [progress] + * @property {boolean} [rawLeaves=false] + * @property {number} [shardSplitThreshold=1000] + * @property {boolean} [trickle=false] + * @property {boolean} [wrapWithDirectory=false] + * + * @typedef {Object} AddedData + * @property {string} path + * @property {CID} cid + * @property {number} mode + * @property {Time} mtime + * + * @typedef {Object} EncodedAddedData + * @property {string} path + * @property {string} cid + * @property {number} mode + * @property {Time} mtime + * + * @typedef {Object} Cat + * @property {number} [offset] + * @property {number} [length] + */ + +/** + * @template T + * @typedef {T & RPCRequestOptions} Options + */ + +class FilesTopClient { + /** + * + * @param {RPCConnection} connection + */ + constructor (connection) { + this.connection = connection + } + + /** + * @param {AnyFileInput} input + * @param {Options} [options] + * @returns {AsyncIterable} + */ + async * add (input, options = {}) { + const { progress, timeout, signal } = options + const entries = normaliseInput(input) + + for await (const { path, content } of entries) { + for await (const chunk of content) { + const chunks = await collect(content) + /** @type EncodedAddedData */ + const data = await this.connection.call( + 'add', + { + path, + content: chunks + }, + { + transfer: chunks, + signal + } + ) + + if (signal && signal.aborted) { + throw new AbortError() + } + yield decode(data) + } + } + } + + /** + * @param {string|CID|ArrayBuffer} inputPath + * @param {Options} [options] + * @returns {AsyncIterable} + */ + async * cat (inputPath, options = {}) { + const input = CID.isCID(inputPath) ? inputPath.toString() : inputPath + const transfer = input instanceof ArrayBuffer ? [input] : [] + const { signal, timeout, offset, length } = options + /** @type ArrayBuffer[] */ + const chunks = await this.connection.call( + 'cat', + { + input, + offset, + length + }, + { + signal, + timeout, + transfer + } + ) + yield * chunks + } +} + +/** + * @template T + * @param {AsyncIterable} content + * @returns {Promise} + */ +const collect = async content => { + const chunks = [] + for await (const chunk of content) { + chunks.push(chunk) + } + return chunks +} + +/** + * + * @param {EncodedAddedData} data + * @returns {AddedData} + */ +const decode = ({ path, cid, mode, mtime }) => { + return { + path, + cid: new CID(cid), + mode, + mtime + } +} + +module.exports = FilesTopClient diff --git a/packages/ipfs-message-port-client/src/dag.js b/packages/ipfs-message-port-client/src/dag.js new file mode 100644 index 0000000000..34b3fdc029 --- /dev/null +++ b/packages/ipfs-message-port-client/src/dag.js @@ -0,0 +1,144 @@ +'use strict' + +const { Client } = require('./client') +const CID = require('cids') + +/** + * @typedef {import('ipfs-message-port-protocol/src/data').JSONValue} JSONValue + * @typedef {import('ipfs-message-port-protocol/src/dag').DAGAPI} API + * @typedef {import('./client').ClientTransport} Transport + */ + +/** + * @typedef {PutWithFormat|PutWithCID} PutOptions + * + * @typedef {Object} PutWithFormat + * An optional object which may be passed to `ipfs.dag.put`. + * @property {string} [format="dag-cbor"] - The IPLD format multicodec + * @property {string} [hashAlg="sha2-256"] - The hash algorithm to be used over the serialized DAG node + * @property {boolean} [pin=false] - Pin this node when adding to the blockstore + * @property {boolean} [preload=true] + * @property {number} [timeout] - A timeout in ms + * @property {void} [cid] + * @property {AbortSignal} [signal] - Can be used to cancel any long running requests started as a result of this call. + * + * @typedef {Object} PutWithCID + * @property {CID} cid - The IPLD format multicodec + * @property {boolean} [pin=false] - Pin this node when adding to the blockstore + * @property {boolean} [preload=true] + * @property {number} [timeout] - A timeout in ms + * @property {AbortSignal} [signal] - Can be used to cancel any long running requests started as a result of this call. + */ + +/** + * @class + * @extends {Client} + */ +class DAG extends Client { + /** + * @param {Transport} transport + */ + constructor (transport) { + super('dag', ['put', 'get', 'tree'], transport) + } + + /** + * @param {JSONValue} dagNode + * @param {Object} [options] + * @param {string} [options.format="dag-cbor"] - The IPLD format multicodec + * @param {string} [options.hashAlg="sha2-256"] - The hash algorithm to be used over the serialized DAG node + * @param {CID} [options.cid] + * @param {boolean} [options.pin=false] - Pin this node when adding to the blockstore + * @param {boolean} [options.preload=true] + * @param {number} [options.timeout] - A timeout in ms + * @param {AbortSignal} [options.signal] - Can be used to cancel any long running requests started as a result of this call. + * @returns {Promise} + */ + async put (dagNode, options = {}) { + const { format, hashAlg, cid, pin, preload, timeout, signal } = options + + const encodedCID = await this.remote.put({ + dagNode, + format, + hashAlg, + cid: cid != null ? cid.toString() : undefined, + pin, + preload, + timeout, + signal + }) + + return new CID(encodedCID) + } + + /** + * @param {CID} cid + * @param {string} [path] + * @param {Object} [options] + * @param {boolean} [options.localResolve] + * @param {number} [options.timeout] + * @param {AbortSignal} [options.signal] + * @returns {Promise<{value:JSONValue, remainderPath:string}>} + */ + get (cid, path, options = {}) { + const [nodePath, { localResolve, timeout, signal }] = read(path, options) + + return this.remote.get({ + cid: cid.toString(), + path: nodePath, + localResolve, + timeout, + signal + }) + } + + /** + * Enumerate all the entries in a graph + * @param {CID} cid - CID of the DAG node to enumerate + * @param {string} [path] + * @param {Object} [options] + * @param {boolean} [options.recursive] + * @param {number} [options.timeout] + * @param {AbortSignal} [options.signal] + * @returns {AsyncIterable} + */ + async * tree (cid, path, options = {}) { + const [nodePath, { recursive, timeout, signal }] = read(path, options) + + const paths = await this.remote.tree({ + cid: cid.toString(), + path: nodePath, + recursive, + timeout, + signal + }) + + yield * paths + } +} + +/** + * @template T + * @typedef {T|void|null} Maybe + */ + +/** + * Takes logical parameters in form of [path, options] where both `path` and + * `options` may be absent and returns normilized version where both `path` + * and `options` are present. Uses `/` for `path` when missing and uses + * `defaultOptions` when `options` are missing. + * @template T + * param {[Maybe, T]|[NonNullable, T]} params + * @param {Maybe|NonNullable} path + * @param {T} options + * @returns {[string, T]} + */ +const read = (path, options) => { + if (typeof path === 'string') { + return [path, options] + } else { + return ['/', path == null ? options : path] + } +} + +module.exports = DAG diff --git a/packages/ipfs-message-port-client/src/errors.js b/packages/ipfs-message-port-client/src/errors.js new file mode 100644 index 0000000000..e28a8feeb4 --- /dev/null +++ b/packages/ipfs-message-port-client/src/errors.js @@ -0,0 +1,6 @@ +'use strict' + +class AbortError extends Error {} +class ClosedError extends Error {} + +module.exports = { AbortError, ClosedError } diff --git a/packages/ipfs-message-port-client/src/files.js b/packages/ipfs-message-port-client/src/files.js new file mode 100644 index 0000000000..1be8039819 --- /dev/null +++ b/packages/ipfs-message-port-client/src/files.js @@ -0,0 +1,334 @@ +'use strict' + +/* eslint-env browser */ + +const CID = require('cids') +const { Client } = require('./client') +const { + decodeRemoteIterable, + encodeAsyncIterable +} = require('ipfs-message-port-server/src/util') + +/** + * @typedef {import('ipfs-message-port-server/src/files').Files} API + * @typedef {import('ipfs-message-port-server/src/files').EncodedContent} EncodedContent + * @typedef {import('ipfs-message-port-protocol/src/data').UnixFSTime} UnixFSTime + * @typedef {import('ipfs-message-port-protocol/src/data').FileType} FileType + * @typedef {import('ipfs-message-port-protocol/src/data').Time} Time + * @typedef {import('ipfs-message-port-protocol/src/data').Mode} Mode + * @typedef {import('ipfs-message-port-protocol/src/data').HashAlg} HashAlg + * @typedef {import('ipfs-message-port-protocol/src/data').CIDVersion} CIDVersion + * @typedef {import('./client').ClientTransport} Transport + */ + +/** + * @class + * @extends {Client} + */ +class Files extends Client { + /** + * @param {Transport} transport + */ + constructor (transport) { + super('files', ['chmod'], transport) + } + + /** + * Change mode for files and directories + * @param {ContentAddress} path - The path to the entry to modify + * @param {Mode} mode + * @param {ChmodOptions} [options] + * @returns {Promise} + */ + chmod (path, mode, options = {}) { + const { recursive, hashAlg, flush, cidVersion, signal, timeout } = options + return this.remote.chmod({ + path: toPath(path), + mode, + recursive, + hashAlg, + flush, + cidVersion, + signal, + timeout + }) + } + + /** + * Write to an MFS path + * @typedef {string|ArrayBufferView|ArrayBuffer|AsyncIterable|Blob} WriteContent + * + * @param {string} path - The path of the file to write to. + * @param {WriteContent} content - The content to write to the path + * @param {Object} [options] + * @param {number} [options.offset] - An offset to start writing to file at. + * @param {number} [options.length] - Amount ofbytes to write from the content. + * @param {boolean} [options.create=false] - Create the MFS path if it does not exist + * @param {boolean} [options.parents=false] - Create intermediate MFS paths if they do not exist + * @param {boolean} [options.truncate=false] - Truncate the file at the MFS path if it would have been larger than the passed content. + * @param {boolean} [options.rawLeaves=false] - If true, DAG leaves will contain raw file data and not be wrapped in a protobuf + * @param {number} [options.mode] - An integer that represents the file mode + * @param {Time} [options.mtime] - Modififaction time of the file. + * @param {boolean} [options.flush=true] - If true the changes will be immediately flushed to disk + * @param {HashAlg} [options.hashAlg='sha2-256'] -The hash algorithm to use for any updated entries + * @param {CIDVersion} [options.cidVersion] - The CID version to use for any updated entries + * @param {number} [options.timeout] - A timeout in ms + * @param {AbortSignal} [options.signal] - Can be used to cancel any long running requests started as a result of this call + * @returns {Promise<{cid: CID, size:number}>} + */ + async write (path, content, options = {}) { + const [data, transfer] = encodeContent(content) + const { cid, size } = await this.remote.write({ + ...options, + path, + content: data, + transfer: transfer + }) + + return { cid: new CID(cid), size } + } + + /** + * + * @param {string} [path='/'] + * @param {LsOptions} [options] + * @returns {AsyncIterable} + */ + async * ls (path = '/', options = {}) { + const { sort, timeout, signal } = options + const entries = await this.remote.ls({ + path, + sort, + timeout, + signal + }) + + for await (const entry of decodeRemoteIterable(entries)) { + const cid = new CID(entry.cid) + yield { ...entry, cid } + } + } +} +exports.Files = Files + +/** + * @param {WriteContent} content - The content to write to the path + * @returns {[EncodedContent] | [EncodedContent, Transferable[]]} + */ +const encodeContent = content => { + if (typeof content === 'string') { + return [content] + } else if (ArrayBuffer.isView(content)) { + return [content, [content.buffer]] + } else if (content instanceof ArrayBuffer) { + return [content, [content]] + } else if (content instanceof Blob) { + return [content] + } else { + const data = encodeAsyncIterable(content) + return [data, [data.port]] + } +} + +/** + * + * @typedef {string|CID} ContentAddress + * + * @typedef {Object} ChmodOptions + * @property {boolean} [recursive=false] + * @property {string} [hashAlg] + * @property {boolean} [flush=true] + * @property {number} [cidVersion=0] + * @property {number} [timeout] + * @property {AbortSignal} [signal] + * + * @typedef {Object} LsOptions + * @property {boolean} [sort=false] + * @property {number} [timeout] + * @property {AbortSignal} [signal] + * @typedef {Object} LsEntry + * @property {string} name + * @property {FileType} type + * @property {number} size + * @property {CID} cid + * @property {number} mode + * @property {UnixFSTime} mtime + */ + +// /** +// * @typedef {import('./connection')} RPCConnection +// * @typedef {import('./connection').RPCRequestOptions} RPCRequestOptions +// * +// * @typedef {number|string} Mode +// * @typedef {{ secs:number, nsecs:number }} Time +// * +// * @typedef {string|CID} ContentAddress +// * +// * @typedef {Object} Chmod +// * @property {boolean} [recursive=false] +// * @property {string} [hashAlg] +// * @property {boolean} [flush=true] +// * @property {number} [cidVersion=0] +// * +// * @typedef {Object} CP +// * @property {boolean} [parents=false] +// * @property {string} [hashAlg] +// * @property {boolean} [flush=true] +// * +// * @typedef {Object} Mkdir +// * @property {boolean} [parents=false] +// * @property {string} [hashAlg] +// * @property {boolean} [flush=true] +// * @property {Mode} [mode] +// * @property {Time|Date} [mtime] +// * +// * @typedef {Object} StatQuery +// * @property {boolean} [hash=false] If true will only return hash +// * @property {boolean} [size=false] If true will only return size +// * @property {boolean} [withLocal=false] If true computes size of the dag that is local, and total size when possible +// * +// * @typedef {Object} Stat +// * @property {CID} cid Content identifier. +// * @property {number} size File size in bytes. +// * @property {number} cumulativeSize Size of the DAGNodes making up the file in bytes. +// * @property {"directory"|"file"} type +// * @property {number} blocks Number of files making up directory (when a direcotry) +// * or number of blocks that make up the file (when a file) +// * @property {boolean} withLocality True when locality information is present +// * @property {boolean} local True if the queried dag is fully present locally +// * @property {number} sizeLocal Cumulative size of the data present locally +// */ + +// /** +// * @template T +// * @typedef {T & RPCRequestOptions} Options +// */ + +// class FilesClient { +// /** +// * +// * @param {RPCConnection} connection +// */ +// constructor (connection) { +// this.connection = connection +// } + +// /** +// * Change mode for files and directories +// * @param {ContentAddress} path The path to the entry to modify +// * @param {Mode} mode +// * @param {Options} [options] +// * @returns {Promise} +// */ +// chmod (path, mode, options = {}) { +// const { recursive, hashAlg, flush, cidVersion, signal, timeout } = options +// return this.connection.call( +// 'files/chmod', +// { +// path: toPath(path), +// mode, +// recursive, +// hashAlg, +// flush, +// cidVersion, +// timeout +// }, +// { +// signal +// } +// ) +// } +// /** +// * Copy files. +// * // @ts-ignore +// * @param {ContentAddress} from +// * @param {string} to +// * @param {Options} [options] +// * @returns {Promise} +// */ +// // @ts-ignore +// cp (from, to, options, ...etc) { +// const args = [from, to, options, ...etc] +// const last = args.pop() +// /** @type [string[], string, Options] */ +// const [sources, destination, opts] = +// typeof last === 'string' ? [args, last, {}] : [args, args.pop(), last] + +// const { parents, hashAlg, flush } = opts +// return this.connection.call( +// 'files/cp', +// { +// // @ts-ignore could be called without any arguments. +// from: sources.map(toPath), +// to: destination, +// parents, +// hashAlg, +// flush +// }, +// options +// ) +// } +// /** +// * Make a directory. +// * @param {string} path The path to the directory to make +// * @param {Options} [options] +// * @returns {Promise} +// */ +// mkdir (path, options = {}) { +// const { mtime, parents, flush, hashAlg, mode } = options + +// return this.connection.call( +// 'files/mkdir', +// { +// path: toPath(path), +// mtime, +// parents, +// flush, +// hashAlg, +// mode +// }, +// options +// ) +// } + +// /** +// * +// * @param {ContentAddress} path +// * @param {Options} options +// * @returns {Promise} +// */ +// async stat (path, options = {}) { +// const { size, hash, withLocal } = options +// const data = await this.connection.call( +// 'files/stat', +// { +// path: toPath(path), +// size, +// hash, +// withLocal +// }, +// options +// ) +// return decodeStat(data) +// } +// } + +/** + * Turns content address (path or CID) into path. + * @param {ContentAddress} address + * @returns {string} + */ +const toPath = address => + CID.isCID(address) ? `/ipfs/${address.toString()}` : address.toString() + +// /** +// * +// * @param {Stat} data +// * @returns {Stat} +// */ +// const decodeStat = data => { +// data.cid = new CID(data.cid) +// return data +// } + +// module.exports = FilesClient diff --git a/packages/ipfs-message-port-client/src/index.js b/packages/ipfs-message-port-client/src/index.js new file mode 100644 index 0000000000..fd6074605e --- /dev/null +++ b/packages/ipfs-message-port-client/src/index.js @@ -0,0 +1,74 @@ +// @ts-nocheck +'use strict' +/* eslint-env browser */ + +const DAG = require('./dag') +const { Transport } = require('./client') + +/** + * @typedef {Object} ClientOptions + * @property {MessagePort} port + */ + +class IPFSClient { + /** + * @param {Transport} [transport] + */ + constructor (transport) { + this.transport = transport + this.dag = new DAG(this.transport) + } + + /** + * Attaches IPFS client to the given message port. Throws + * exception if client is already attached. + * @param {IPFSClient} self + * @param {MessagePort} port + */ + static attach (self, port) { + self.transport.connect(port) + } + + /** + * Creates IPFS client that is detached from the `ipfs-message-port-service`. + * This can be useful when in a scenario where obtaining message port happens + * later on in the application logic. Datached IPFS client will queue all the + * API calls and flush them once client is attached. + * @returns {IPFSClient} + */ + static detached () { + return new IPFSClient(new Transport(null)) + } + + /** + * Creates IPFS client from the message port (assumes that + * `ipfs-message-port-service` is instantiated on the other end) + * @param {MessagePort} port + * @returns {IPFSClient} + */ + static from (port) { + return new IPFSClient(new Transport(port)) + } +} +/** + * + */ +// class IPFSClient { +// /** +// * @param {ClientOptions} options +// */ +// constructor (options) { +// this.connection = new RPCConnection(options.port) +// } +// get files () { +// const value = new FilesClient(this.connection) +// Object.defineProperty(this, 'files', { value }) +// return value +// } +// } +// Object.assign(IPFSClient.prototype, FilesTopClient.prototype) +// Object.assign(IPFSClient.prototype, FilesClient.prototype) + +// // Object.assign(ipfsClient, { Buffer, CID, multiaddr, multibase, multicodec, multihash, globSource, urlSource }) + +module.exports = IPFSClient diff --git a/packages/ipfs-message-port-client/test/.aegir.js b/packages/ipfs-message-port-client/test/.aegir.js new file mode 100644 index 0000000000..2dbe62c5fa --- /dev/null +++ b/packages/ipfs-message-port-client/test/.aegir.js @@ -0,0 +1,47 @@ +'use strict' + +const EchoServer = require('aegir/utils/echo-server') + +let echoServer = new EchoServer() + +module.exports = { + bundlesize: { maxSize: '89kB' }, + karma: { + files: [ + { + pattern: 'node_modules/interface-ipfs-core/test/fixtures/**/*', + watched: false, + served: true, + included: false + } + ], + browserNoActivityTimeout: 210 * 1000, + singleRun: true + }, + hooks: { + node: { + pre: async () => { + await echoServer.start() + return { + env: { + ECHO_SERVER: `http://${echoServer.host}:${echoServer.port}` + } + } + }, + post: () => echoServer.stop() + }, + browser: { + pre: async () => { + await Promise.all([server.start(), echoServer.start()]) + return { + env: { + ECHO_SERVER: `http://${echoServer.host}:${echoServer.port}` + } + } + }, + post: () => { + return Promise.all([server.stop(), echoServer.stop()]) + } + } + } +} diff --git a/packages/ipfs-message-port-client/test/dag.spec.js b/packages/ipfs-message-port-client/test/dag.spec.js new file mode 100644 index 0000000000..318db43f91 --- /dev/null +++ b/packages/ipfs-message-port-client/test/dag.spec.js @@ -0,0 +1,71 @@ +/* eslint-env mocha */ +/* eslint max-nested-callbacks: ["error", 8] */ + +'use strict' + +const { Buffer } = require('buffer') +const { expect } = require('interface-ipfs-core/src/utils/mocha') +const { DAGNode } = require('ipld-dag-pb') +const CID = require('cids') +const { activate } = require('./client') + +let ipfs = null + +describe('.dag', () => { + this.timeout(20 * 1000) + before(() => { + ipfs = activate() + }) + + after(() => { + ipfs = null + }) + + it('should be able to put and get a DAG node with format dag-pb', async () => { + const data = Buffer.from('some data') + const node = new DAGNode(data) + + let cid = await ipfs.dag.put(node, { + format: 'dag-pb', + hashAlg: 'sha2-256' + }) + expect(cid).to.be.instanceOf(CID) + cid = cid.toV0() + expect(cid.codec).to.equal('dag-pb') + cid = cid.toBaseEncodedString('base58btc') + // expect(cid).to.equal('bafybeig3t3eugdchignsgkou3ly2mmy4ic4gtfor7inftnqn3yq4ws3a5u') + expect(cid).to.equal('Qmd7xRhW5f29QuBFtqu3oSD27iVy35NRB91XFjmKFhtgMr') + + const result = await ipfs.dag.get(cid) + + expect(result.value.Data).to.deep.equal(data) + }) + + // it('should be able to put and get a DAG node with format dag-cbor', async () => { + // const cbor = { foo: 'dag-cbor-bar' } + // let cid = await ipfs.dag.put(cbor, { + // format: 'dag-cbor', + // hashAlg: 'sha2-256' + // }) + + // expect(cid.codec).to.equal('dag-cbor') + // cid = cid.toBaseEncodedString('base32') + // expect(cid).to.equal( + // 'bafyreic6f672hnponukaacmk2mmt7vs324zkagvu4hcww6yba6kby25zce' + // ) + + // const result = await ipfs.dag.get(cid) + + // expect(result.value).to.deep.equal(cbor) + // }) + + // it('should error when missing DAG resolver for multicodec from requested CID', async () => { + // const block = await ipfs.block.put(Buffer.from([0, 1, 2, 3]), { + // cid: new CID('z8mWaJ1dZ9fH5EetPuRsj8jj26pXsgpsr') + // }) + + // await expect(ipfs.dag.get(block.cid)).to.be.rejectedWith( + // 'Missing IPLD format "git-raw"' + // ) + // }) +}) diff --git a/packages/ipfs-message-port-client/test/util/client.js b/packages/ipfs-message-port-client/test/util/client.js new file mode 100644 index 0000000000..663dab1f9f --- /dev/null +++ b/packages/ipfs-message-port-client/test/util/client.js @@ -0,0 +1,18 @@ +/* eslint-env browser */ + +'use strict' + +const IPFSClient = require('../../src/index') + +const activate = () => { + const worker = new SharedWorker(process.env.WORKER_SERVICE) + const client = IPFSClient.from(worker.port) + return client +} +exports.activate = activate + +const detached = () => { + const client = IPFSClient.detached() + return client +} +exports.detached = detached diff --git a/packages/ipfs-message-port-client/test/util/webpack.config.js b/packages/ipfs-message-port-client/test/util/webpack.config.js new file mode 100644 index 0000000000..e3581a5752 --- /dev/null +++ b/packages/ipfs-message-port-client/test/util/webpack.config.js @@ -0,0 +1,13 @@ +'use strict' + +const path = require('path') + +module.exports = { + mode: 'development', + devtool: 'source-map', + entry: [path.join(__dirname, './worker.js')], + output: { + path: __dirname, + filename: 'worker.bundle.js' + } +} diff --git a/packages/ipfs-message-port-client/test/util/worker.js b/packages/ipfs-message-port-client/test/util/worker.js new file mode 100644 index 0000000000..7ad218c059 --- /dev/null +++ b/packages/ipfs-message-port-client/test/util/worker.js @@ -0,0 +1,34 @@ +'use strict' + +const IPFS = require('ipfs') +const { IPFSService } = require('ipfs-message-port-server') +const { Server } = require('ipfs-message-port-server/src/server') + +const main = async context => { + const ipfs = await IPFS.create({ offline: true, start: false }) + const service = new IPFSService(ipfs) + const server = new Server(service) + + for (const event of listen(context, 'connect')) { + const port = event.ports[0] + if (port) { + server.connect(port) + } + } +} + +const listen = async function * (target, type, options) { + let next = () => {} + const read = () => new Promise(resolve => (next = resolve)) + const write = event => next(event) + target.addEventListener(type, write, options) + try { + while (true) { + yield * await read() + } + } finally { + target.removeEventListener(type, write, options) + } +} + +main(self) diff --git a/packages/ipfs-message-port-client/tsconfig.json b/packages/ipfs-message-port-client/tsconfig.json new file mode 100644 index 0000000000..893e7fa923 --- /dev/null +++ b/packages/ipfs-message-port-client/tsconfig.json @@ -0,0 +1,24 @@ +{ + "compilerOptions": { + "allowJs": true, + "checkJs": true, + "forceConsistentCasingInFileNames": true, + "noImplicitReturns": true, + "noImplicitAny": true, + "noImplicitThis": true, + "noFallthroughCasesInSwitch": true, + "noUnusedLocals": true, + "noUnusedParameters": true, + "strictFunctionTypes": true, + "strictNullChecks": true, + "strictPropertyInitialization": true, + "strict": true, + "alwaysStrict": true, + "esModuleInterop": true, + "target": "ES5", + "noEmit": true + }, + "exclude": ["dist", "node_modules"], + "include": ["src/**/*.js", "../ipfs-message-port-server/src/**/*.js"], + "compileOnSave": false +} diff --git a/packages/ipfs-message-port-protocol/package.json b/packages/ipfs-message-port-protocol/package.json new file mode 100644 index 0000000000..e25b1b3d77 --- /dev/null +++ b/packages/ipfs-message-port-protocol/package.json @@ -0,0 +1,180 @@ +{ + "name": "ipfs-message-port-protocol", + "version": "0.1", + "description": "A client library for the IPFS across message port", + "keywords": ["ipfs"], + "homepage": "https://github.com/ipfs/js-ipfs/tree/master/packages/ipfs-message-port-client#readme", + "bugs": "https://github.com/ipfs/js-ipfs/issues", + "license": "(Apache-2.0 OR MIT)", + "leadMaintainer": "Alex Potsides ", + "files": ["src", "dist"], + "main": "src/index", + "browser": {}, + "repository": { + "type": "git", + "url": "git+https://github.com/ipfs/js-ipfs.git" + }, + "scripts": { + "test": "cross-env ECHO_SERVER_PORT=37490 aegir test", + "test:node": "cross-env ECHO_SERVER_PORT=37491 aegir test -t node", + "test:browser": "cross-env ECHO_SERVER_PORT=37492 aegir test -t browser", + "test:webworker": "cross-env ECHO_SERVER_PORT=37493 aegir test -t webworker", + "test:electron-main": "cross-env ECHO_SERVER_PORT=37494 aegir test -t electron-main", + "test:electron-renderer": "cross-env ECHO_SERVER_PORT=37495 aegir test -t electron-renderer", + "test:chrome": "cross-env ECHO_SERVER_PORT=37496 aegir test -t browser -t webworker -- --browsers ChromeHeadless", + "test:firefox": "cross-env ECHO_SERVER_PORT=37497 aegir test -t browser -t webworker -- --browsers FirefoxHeadless", + "lint": "aegir lint", + "build": "aegir build", + "coverage": "npx nyc -r html npm run test:node -- --bail", + "clean": "rm -rf ./dist", + "dep-check": "aegir dep-check" + }, + "dependencies": { + "abort-controller": "^3.0.0", + "bignumber.js": "^9.0.0", + "bs58": "^4.0.1", + "buffer": "^5.4.2", + "cids": "^0.8.0", + "debug": "^4.1.0", + "form-data": "^3.0.0", + "ipfs-block": "^0.8.1", + "ipfs-core-utils": "^0.2.2", + "ipfs-utils": "^2.2.2", + "ipld-dag-cbor": "^0.15.1", + "ipld-dag-pb": "^0.18.3", + "ipld-raw": "^4.0.1", + "iso-url": "^0.4.7", + "it-tar": "^1.2.1", + "it-to-buffer": "^1.0.0", + "it-to-stream": "^0.1.1", + "merge-options": "^2.0.0", + "multiaddr": "^7.2.1", + "multiaddr-to-uri": "^5.1.0", + "multibase": "^0.7.0", + "multicodec": "^1.0.0", + "multihashes": "^0.4.14", + "nanoid": "^3.0.2", + "node-fetch": "^2.6.0", + "parse-duration": "^0.1.2", + "stream-to-it": "^0.2.0" + }, + "devDependencies": { + "aegir": "^21.10.1", + "browser-process-platform": "^0.1.1", + "cross-env": "^7.0.0", + "go-ipfs-dep": "0.4.23-3", + "interface-ipfs-core": "^0.134.3", + "ipfsd-ctl": "^3.0.0", + "it-all": "^1.0.1", + "it-concat": "^1.0.0", + "it-pipe": "^1.1.0", + "nock": "^12.0.3", + "ipfs-message-port-protocol": "^0" + }, + "engines": { + "node": ">=10.3.0", + "npm": ">=3.0.0" + }, + "contributors": [ + "Alan Shaw ", + "Alan Shaw ", + "Alex Mingoia ", + "Alex Potsides ", + "Antonio Tenorio-Fornés ", + "Bruno Barbieri ", + "Clemo ", + "Connor Keenan ", + "Daniel Constantin ", + "Danny ", + "David Braun ", + "David Dias ", + "Dietrich Ayala ", + "Diogo Silva ", + "Dmitriy Ryajov ", + "Dmitry Nikulin ", + "Donatas Stundys ", + "Fil ", + "Filip Š ", + "Francisco Baio Dias ", + "Friedel Ziegelmayer ", + "Gar ", + "Gavin McDermott ", + "Gopalakrishna Palem ", + "Greenkeeper ", + "Haad ", + "Harlan T Wood ", + "Harlan T Wood ", + "Henrique Dias ", + "Holodisc ", + "Hugo Dias ", + "Hugo Dias ", + "JGAntunes ", + "Jacob Heun ", + "James Halliday ", + "Jason Carver ", + "Jason Papakostas ", + "Jeff Downie ", + "Jeromy ", + "Jeromy ", + "Jim Pick ", + "Joe Turgeon ", + "Jonathan ", + "Juan Batiz-Benet ", + "Kevin Wang ", + "Kristoffer Ström ", + "Marcin Rataj ", + "Matt Bell ", + "Matt Ober ", + "Maxime Lathuilière ", + "Michael Bradley ", + "Michael Muré ", + "Michael Muré ", + "Mikeal Rogers ", + "Mitar ", + "Mithgol ", + "Mohamed Abdulaziz ", + "Nitin Patel <31539366+niinpatel@users.noreply.github.com>", + "Nuno Nogueira ", + "Níckolas Goline ", + "Oli Evans ", + "Orie Steele ", + "Paul Cowgill ", + "Pedro Santos ", + "Pedro Santos ", + "Pedro Teixeira ", + "Pete Thomas ", + "Richard Littauer ", + "Richard Schneider ", + "Roman Khafizianov ", + "SeungWon ", + "Stephen Whitmore ", + "Tara Vancil ", + "Teri Chadbourne ", + "Travis Person ", + "Travis Person ", + "Vasco Santos ", + "Vasco Santos ", + "Victor Bjelkholm ", + "Volker Mische ", + "Zhiyuan Lin ", + "dirkmc ", + "dmitriy ryajov ", + "elsehow ", + "ethers ", + "greenkeeper[bot] <23040076+greenkeeper[bot]@users.noreply.github.com>", + "greenkeeper[bot] ", + "haad ", + "kumavis ", + "leekt216 ", + "nginnever ", + "noah the goodra ", + "phillmac ", + "priecint ", + "samuli ", + "sarthak khandelwal ", + "shunkin ", + "victorbjelkholm ", + "Łukasz Magiera ", + "Łukasz Magiera " + ] +} diff --git a/packages/ipfs-message-port-protocol/src/core.ts b/packages/ipfs-message-port-protocol/src/core.ts new file mode 100644 index 0000000000..62286e0a82 --- /dev/null +++ b/packages/ipfs-message-port-protocol/src/core.ts @@ -0,0 +1,115 @@ +import { + HashAlg, + RemoteCallback, + RemoteIterable, + Time, + Mode, + StringEncoded, + UnixFSTime, + FileType +} from './data' +import CID from 'cids' + +export interface Core { + add(input: AddQuery): AddResult + cat(input: CatQuery): CatResult + get(input: GetQuery): GetResult + ls(input: LsQuery): LsResult +} + +export type AddQuery = { + input: AddInput + + chunker?: string + cidVersion?: number + enableShardingExperiment?: boolean + hashAlg?: HashAlg + onlyHash?: boolean + pin?: boolean + progress?: RemoteCallback + rawLeaves?: boolean + shardSplitThreshold?: boolean + trickle?: boolean + wrapWithDirectory?: boolean + + timeout?: number + signal?: AbortSignal +} + +export type AddInput = SingleFileInput | MultiFileInput + +type SingleFileInput = + | ArrayBuffer + | ArrayBufferView + | Blob + | string + | RemoteIterable + | RemoteIterable + +type MultiFileInput = + | RemoteIterable + | RemoteIterable + | RemoteIterable + +export type FileInput = { + path?: string + content: FileContent + mode?: Mode + mtime?: Time +} + +export type FileContent = + | ArrayBufferView + | ArrayBuffer + | string + | RemoteIterable + | RemoteIterable + +type AddedEntry = { + path: string + cid: StringEncoded + mode: number + mtime: UnixFSTime + size: number +} + +export type AddResult = RemoteIterable + +export type CatQuery = { + path: string + + offset?: number + length?: number +} + +export type CatResult = RemoteIterable + +export type GetQuery = { + path: string +} + +export type GetResult = RemoteIterable + +type FileEntry = { + path: string + content: RemoteIterable + mode: number + mtime: UnixFSTime +} + +export type LsQuery = { + path: string +} + +export type LsResult = RemoteIterable + +type LsEntry = { + depth: number + name: string + path: string + size: number + cid: StringEncoded + type: FileType + mode: number + mtime: UnixFSTime +} diff --git a/packages/ipfs-message-port-protocol/src/dag.ts b/packages/ipfs-message-port-protocol/src/dag.ts new file mode 100644 index 0000000000..fb994553c3 --- /dev/null +++ b/packages/ipfs-message-port-protocol/src/dag.ts @@ -0,0 +1,42 @@ +import CID from 'cids' +import { JSONValue, StringEncoded } from './data' + +export type DAGNode = JSONValue + +export type PutDAG = { + dagNode: DAGNode + format?: string + hashAlg?: string + cid?: StringEncoded + pin?: boolean + preload?: boolean + timeout?: number + signal?: AbortSignal +} + +export type GetDAG = { + cid: StringEncoded + path: string + localResolve: boolean + timeout?: number + signal?: AbortSignal +} + +export type DAGEntry = { + value: DAGNode + remainderPath: string +} + +export type EnumerateDAG = { + cid: StringEncoded + path: string + recursive: boolean + timeout?: number + signal?: AbortSignal +} + +export interface DAGAPI { + put(input: PutDAG): Promise> + get(input: GetDAG): Promise + tree(input: EnumerateDAG): Promise +} diff --git a/packages/ipfs-message-port-protocol/src/data.ts b/packages/ipfs-message-port-protocol/src/data.ts new file mode 100644 index 0000000000..6fca8446e9 --- /dev/null +++ b/packages/ipfs-message-port-protocol/src/data.ts @@ -0,0 +1,49 @@ +export type JSONObject = { [key: string]: JSONValue } +export type JSONArray = Array +export type JSONValue = + | null + | boolean + | number + | string + | JSONArray + | JSONObject + +export type Encoded<_Data, Representation> = Representation +export type StringEncoded = Encoded + +export type UnixFSTime = { + secs: number + nsecs: number +} + +export type LooseUnixFSTime = { + secs: number + nsecs?: number +} + +export type HRTime = [number, number] + +export type Time = Date | LooseUnixFSTime | HRTime +export type Mode = string | number +export type HashAlg = string +export type FileType = 'directory' | 'file' +export type CIDVersion = 0 | 1 + +export type RemoteIterable<_T> = { + type: 'RemoteIterable' + port: MessagePort + transfer: [MessagePort] +} + +export type RemoteCallback<_T> = { + type: 'RemoteCallback' + port: MessagePort +} + +export type Result = { ok: true; value: T } | { ok: false; error: X } + +export type EncodedError = { + message: string + name: string + stack: string +} diff --git a/packages/ipfs-message-port-protocol/src/files.ts b/packages/ipfs-message-port-protocol/src/files.ts new file mode 100644 index 0000000000..183b67186c --- /dev/null +++ b/packages/ipfs-message-port-protocol/src/files.ts @@ -0,0 +1,155 @@ +import { + StringEncoded, + Time, + Mode, + HashAlg, + RemoteIterable, + FileType +} from './data' +import CID from 'cids' + +interface Files { + chmod(input: ChmodQuery): Promise + cp(input: CpQuery): Promise + mkdir(input: MkdirQuery): Promise + stat(input: StatQuery): Promise + touch(input: TouchQuery): Promise + rm(input: RmQuery): Promise + read(input: ReadQuery): Promise + write(input: WriteQuery): Promise + mv(input: MvQuery): Promise + flush(input: FlushQuery): Promise> + ls(input: LsQuery): Promise +} + +type ChmodQuery = { + path: string + mode: Mode + recursive?: boolean + hashAlg?: HashAlg + flush?: boolean + cidVersion?: number +} + +type CpQuery = { + from: string | StringEncoded + to: string | StringEncoded + parents?: boolean + hashAlg?: HashAlg + flush?: boolean +} + +type MkdirQuery = { + path: string + // Note: Date objects seem to get copied over message port preserving + // Date type. + mtime?: Time + parents?: boolean + flush?: boolean + hashAlg?: HashAlg + mode?: Mode +} + +type StatQuery = { + path: string + size?: boolean + hash?: HashAlg + withLocal?: boolean +} + +type Stat = { + type: FileType + cid: StringEncoded + size: number + cumulativeSize: number + blocks: number + withLocality: boolean + local: boolean + sizeLocal: number +} + +type TouchQuery = { + path: string + mtime?: Time + flush?: boolean + hashAlg?: HashAlg + cidVersion?: number +} + +type RmQuery = { + paths: string[] + recursive?: boolean + flush?: boolean + hashAlg?: HashAlg + cidVersion?: number +} + +type ReadQuery = { + path: string + + offset?: number + length?: number +} + +type ReadOutput = { + content: RemoteIterable +} + +type WriteContent = + | string + | ArrayBufferView + | ArrayBuffer + | Blob + | RemoteIterable + +type WriteQuery = { + path: string + content: WriteContent + offset?: number + length?: number + create?: boolean + parents?: boolean + truncate?: boolean + rawLeaves?: boolean + mode?: Mode + mtime?: Time + flush?: boolean + hashAlg?: HashAlg + cidVersion?: number +} + +type WriteOutput = { + cid: StringEncoded + size: number +} + +type MvQuery = { + from: string | string[] + to: string + + parents: boolean + flush: boolean + hashAlg: HashAlg + cidVersion: number +} + +type FlushQuery = { + path: string +} + +type LsQuery = { + path: string +} + +type Entry = { + name: string + type: FileType + size: number + cid: StringEncoded + mode: Mode + mtime: Time +} + +type LsOutput = { + entries: RemoteIterable +} diff --git a/packages/ipfs-message-port-protocol/src/rpc.ts b/packages/ipfs-message-port-protocol/src/rpc.ts new file mode 100644 index 0000000000..2d4c058ecb --- /dev/null +++ b/packages/ipfs-message-port-protocol/src/rpc.ts @@ -0,0 +1,130 @@ +export type Procedure = T extends (arg: infer I) => infer O + ? (query: I & QueryOptions) => Return + : void + +export type Remote = { + [K in keyof T]: Procedure +} + +type Return = T extends Promise + ? Promise + : Promise + +export type QueryOptions = { + signal?: AbortSignal + timeout?: number + transfer?: Transferable[] +} + +export type TransferOptions = { + transfer?: Transferable[] +} + +// export type ServiceProvider = { +// [K in keyof T]: ProcedureProvider +// } + +// export type ProcedureProvider = T extends (arg: infer I) => infer O +// ? (input: I & CallOptions) => O +// : never + +export type NonUndefined = A extends undefined ? never : A + +export type ProcedureNames = { + [K in keyof T]-?: NonUndefined extends Function ? K : never +}[keyof T][] + +export type Input = Values< + { + [K in keyof T]: T[K] extends (input: infer I) => infer _O + ? I & { method: K } & QueryOptions + : never + } +> + +export type Output = Values< + { + [K in keyof T]: T[K] extends (input: infer _I) => infer O + ? Return + : never + } +> + +export type Service = { + [K in keyof T]: T[K] +} + +export type ProcedureProvider = T extends (arg: infer I) => infer O + ? (input: I & QueryOptions) => O + : never + +export type AsProcedure = T extends (arg: infer I) => infer O + ? (query: I & QueryOptions) => Return + : never + +/** + * Any method name of the associated with RPC service. + */ +export type Method = ServiceQuery['method'] + +/** + * Namespace of the RCP service + */ +export type Namespace = ServiceQuery['namespace'] + +export type Values = T[keyof T] +export type Keys = keyof T + +export type Inn = ServiceQuery['input'] +export type Out = ServiceQuery['result'] + +export type RPCQuery = Pick< + ServiceQuery, + 'method' | 'namespace' | 'input' | 'timeout' | 'signal' +> + +export type ProcedureName = Values< + { + [K in keyof T]-?: NonUndefined extends (input: any) => any ? K : never + } +> + +export type ServiceQuery = Values< + { + [K in keyof T]: T[K] extends (input: infer I) => infer O + ? Query + : NamespacedQuery + } +> + +export type Query = Values< + { + [K in keyof T]-?: T[K] extends (input: infer I) => infer O + ? { + namespace?: void + method: K + input: I + result: R + } & QueryOptions + : never + } +> + +export type NamespacedQuery = Values< + { + [K in keyof T]-?: T[K] extends (input: infer I) => infer O + ? { + namespace: NS + method: K + input: I + result: R + } & QueryOptions + : never + } +> + +type R = O extends Promise + ? Promise> + : Promise> + +type WithTransferOptions = O extends object ? O & TransferOptions : O diff --git a/packages/ipfs-message-port-protocol/tsconfig.json b/packages/ipfs-message-port-protocol/tsconfig.json new file mode 100644 index 0000000000..fd2a1f1991 --- /dev/null +++ b/packages/ipfs-message-port-protocol/tsconfig.json @@ -0,0 +1,21 @@ +{ + "compilerOptions": { + "allowJs": true, + "checkJs": true, + "noImplicitReturns": true, + "noImplicitAny": true, + "noImplicitThis": true, + "noEmitHelpers": true, + "strictFunctionTypes": true, + "strictNullChecks": true, + "strictPropertyInitialization": true, + "strict": true, + "esModuleInterop": true, + "alwaysStrict": true, + "target": "ES5", + "outDir": "./dist/" + }, + "exclude": ["dist"], + "include": ["src"], + "compileOnSave": false +} diff --git a/packages/ipfs-message-port-server/package.json b/packages/ipfs-message-port-server/package.json new file mode 100644 index 0000000000..041f785ff7 --- /dev/null +++ b/packages/ipfs-message-port-server/package.json @@ -0,0 +1,184 @@ +{ + "name": "ipfs-message-port-server", + "version": "0.1", + "description": "A server library for the IPFS across message port", + "keywords": ["ipfs"], + "homepage": "https://github.com/ipfs/js-ipfs/tree/master/packages/ipfs-message-port-client#readme", + "bugs": "https://github.com/ipfs/js-ipfs/issues", + "license": "(Apache-2.0 OR MIT)", + "leadMaintainer": "Alex Potsides ", + "files": ["src", "dist"], + "main": "src/index.js", + "browser": { + "./src/lib/to-stream.js": "./src/lib/to-stream.browser.js", + "ipfs-utils/src/files/glob-source": false + }, + "repository": { + "type": "git", + "url": "git+https://github.com/ipfs/js-ipfs.git" + }, + "scripts": { + "test": "cross-env ECHO_SERVER_PORT=37490 aegir test", + "test:node": "cross-env ECHO_SERVER_PORT=37491 aegir test -t node", + "test:browser": "cross-env ECHO_SERVER_PORT=37492 aegir test -t browser", + "test:webworker": "cross-env ECHO_SERVER_PORT=37493 aegir test -t webworker", + "test:electron-main": "cross-env ECHO_SERVER_PORT=37494 aegir test -t electron-main", + "test:electron-renderer": "cross-env ECHO_SERVER_PORT=37495 aegir test -t electron-renderer", + "test:chrome": "cross-env ECHO_SERVER_PORT=37496 aegir test -t browser -t webworker -- --browsers ChromeHeadless", + "test:firefox": "cross-env ECHO_SERVER_PORT=37497 aegir test -t browser -t webworker -- --browsers FirefoxHeadless", + "lint": "aegir lint", + "build": "aegir build", + "coverage": "npx nyc -r html npm run test:node -- --bail", + "clean": "rm -rf ./dist", + "dep-check": "aegir dep-check" + }, + "dependencies": { + "ipfs": "0.43.3", + "abort-controller": "^3.0.0", + "bignumber.js": "^9.0.0", + "bs58": "^4.0.1", + "buffer": "^5.4.2", + "cids": "^0.8.0", + "debug": "^4.1.0", + "form-data": "^3.0.0", + "ipfs-block": "^0.8.1", + "ipfs-core-utils": "^0.2.2", + "ipfs-utils": "^2.2.2", + "ipld-dag-cbor": "^0.15.1", + "ipld-dag-pb": "^0.18.3", + "ipld-raw": "^4.0.1", + "iso-url": "^0.4.7", + "it-tar": "^1.2.1", + "it-to-buffer": "^1.0.0", + "it-to-stream": "^0.1.1", + "merge-options": "^2.0.0", + "multiaddr": "^7.2.1", + "multiaddr-to-uri": "^5.1.0", + "multibase": "^0.7.0", + "multicodec": "^1.0.0", + "multihashes": "^0.4.14", + "nanoid": "^3.0.2", + "node-fetch": "^2.6.0", + "parse-duration": "^0.1.2", + "stream-to-it": "^0.2.0" + }, + "devDependencies": { + "aegir": "^21.10.1", + "browser-process-platform": "^0.1.1", + "cross-env": "^7.0.0", + "go-ipfs-dep": "0.4.23-3", + "interface-ipfs-core": "^0.134.3", + "ipfsd-ctl": "^3.0.0", + "it-all": "^1.0.1", + "it-concat": "^1.0.0", + "it-pipe": "^1.1.0", + "nock": "^12.0.3", + "ipfs-message-port-protocol": "^0" + }, + "engines": { + "node": ">=10.3.0", + "npm": ">=3.0.0" + }, + "contributors": [ + "Alan Shaw ", + "Alan Shaw ", + "Alex Mingoia ", + "Alex Potsides ", + "Antonio Tenorio-Fornés ", + "Bruno Barbieri ", + "Clemo ", + "Connor Keenan ", + "Daniel Constantin ", + "Danny ", + "David Braun ", + "David Dias ", + "Dietrich Ayala ", + "Diogo Silva ", + "Dmitriy Ryajov ", + "Dmitry Nikulin ", + "Donatas Stundys ", + "Fil ", + "Filip Š ", + "Francisco Baio Dias ", + "Friedel Ziegelmayer ", + "Gar ", + "Gavin McDermott ", + "Gopalakrishna Palem ", + "Greenkeeper ", + "Haad ", + "Harlan T Wood ", + "Harlan T Wood ", + "Henrique Dias ", + "Holodisc ", + "Hugo Dias ", + "Hugo Dias ", + "JGAntunes ", + "Jacob Heun ", + "James Halliday ", + "Jason Carver ", + "Jason Papakostas ", + "Jeff Downie ", + "Jeromy ", + "Jeromy ", + "Jim Pick ", + "Joe Turgeon ", + "Jonathan ", + "Juan Batiz-Benet ", + "Kevin Wang ", + "Kristoffer Ström ", + "Marcin Rataj ", + "Matt Bell ", + "Matt Ober ", + "Maxime Lathuilière ", + "Michael Bradley ", + "Michael Muré ", + "Michael Muré ", + "Mikeal Rogers ", + "Mitar ", + "Mithgol ", + "Mohamed Abdulaziz ", + "Nitin Patel <31539366+niinpatel@users.noreply.github.com>", + "Nuno Nogueira ", + "Níckolas Goline ", + "Oli Evans ", + "Orie Steele ", + "Paul Cowgill ", + "Pedro Santos ", + "Pedro Santos ", + "Pedro Teixeira ", + "Pete Thomas ", + "Richard Littauer ", + "Richard Schneider ", + "Roman Khafizianov ", + "SeungWon ", + "Stephen Whitmore ", + "Tara Vancil ", + "Teri Chadbourne ", + "Travis Person ", + "Travis Person ", + "Vasco Santos ", + "Vasco Santos ", + "Victor Bjelkholm ", + "Volker Mische ", + "Zhiyuan Lin ", + "dirkmc ", + "dmitriy ryajov ", + "elsehow ", + "ethers ", + "greenkeeper[bot] <23040076+greenkeeper[bot]@users.noreply.github.com>", + "greenkeeper[bot] ", + "haad ", + "kumavis ", + "leekt216 ", + "nginnever ", + "noah the goodra ", + "phillmac ", + "priecint ", + "samuli ", + "sarthak khandelwal ", + "shunkin ", + "victorbjelkholm ", + "Łukasz Magiera ", + "Łukasz Magiera " + ] +} diff --git a/packages/ipfs-message-port-server/src/core.js b/packages/ipfs-message-port-server/src/core.js new file mode 100644 index 0000000000..e52f61d72d --- /dev/null +++ b/packages/ipfs-message-port-server/src/core.js @@ -0,0 +1,180 @@ +'use strict' + +/* eslint-env browser */ + +const { + decodeRemoteIterable, + encodeAsyncIterable, + mapAsyncIterable +} = require('./util') + +/** + +/** + * @typedef {import("./ipfs").IPFS} IPFS + * @typedef {import("ipfs-message-port-protocol/src/data").Time} Time + * @typedef {import("ipfs-message-port-protocol/src/data").Mode} Mode + * @typedef {import("ipfs-message-port-protocol/src/core").AddInput} AddInput + * @typedef {import("ipfs-message-port-protocol/src/core").FileInput} EncodedFileInput + * @typedef {import("ipfs-message-port-protocol/src/core").FileContent} EncodedFileContent + * @typedef {import("ipfs-message-port-protocol/src/core").AddQuery} AddQuery + * @typedef {import("ipfs-message-port-protocol/src/core").AddResult} AddResult + * @typedef {import("./ipfs").FileOutput} FileOutput + * @typedef {import('./ipfs').FileObject} FileObject + * @typedef {import('./ipfs').FileContent} DecodedFileContent + * @typedef {import('./ipfs').FileInput} DecodedFileInput + + */ + +/** + * @template T + * @typedef {import('ipfs-message-port-protocol/src/data').RemoteIterable} RemoteIterable + */ + +/** + * @class + */ +class Core { + /** + * + * @param {IPFS} ipfs + */ + constructor (ipfs) { + this.ipfs = ipfs + } + + /** + * + * @param {AddQuery} query + * @returns {AddResult} + */ + add (query) { + const { input } = query + const { + chunker, + cidVersion, + enableShardingExperiment, + hashAlg, + onlyHash, + pin, + // progress, + rawLeaves, + shardSplitThreshold, + trickle, + wrapWithDirectory, + timeout, + signal + } = query + + const options = { + chunker, + cidVersion, + enableShardingExperiment, + hashAlg, + onlyHash, + pin, + rawLeaves, + shardSplitThreshold, + trickle, + wrapWithDirectory, + timeout, + signal + } + + const content = decodeAddInput(input) + return encodeAddResult(this.ipfs.add(content, options)) + } + + /** + * @param {Object} query + * @param {string} query.path + * @param {number} [query.offset] + * @param {number} [query.length] + * @param {number} [query.timeout] + * @param {AbortSignal} [query.signal] + * @returns {RemoteIterable} + */ + cat (query) { + const { path, offset, length, timeout, signal } = query + const content = this.ipfs.cat(path, { offset, length, timeout, signal }) + return encodeAsyncIterable(content) + } +} + +/** + * @param {AddInput} input + * @returns {string|ArrayBufferView|ArrayBuffer|Blob|AsyncIterable|AsyncIterable|AsyncIterable|AsyncIterable|AsyncIterable} + */ +const decodeAddInput = input => + matchInput( + input, + /** + * @param {*} data + * @returns {*} + */ + data => { + const iterable = decodeRemoteIterable(data) + const decoded = mapAsyncIterable(iterable, decodFileInput) + return decoded + } + ) + +/** + * @property {string|void} [path] + * @property {DecodedFileContent} content + * @property {Mode|void} [mode] + * @property {Time|void} [mtime] + + * @param {ArrayBufferView|ArrayBuffer|string|Blob|EncodedFileInput} input + * @returns {string|ArrayBuffer|ArrayBufferView|Blob|FileObject} + */ +const decodFileInput = input => + matchInput(input, file => ({ + ...file, + content: decodeFileContent(file.content) + })) + +/** + * @param {EncodedFileContent} content + * @returns {DecodedFileContent} + */ +const decodeFileContent = content => matchInput(content, decodeRemoteIterable) + +/** + * @template I,O + * @param {string|ArrayBuffer|ArrayBufferView|Blob|I} input + * @param {function(I):O} decode + * @returns {string|ArrayBuffer|ArrayBufferView|Blob|O} + */ +const matchInput = (input, decode) => { + if ( + typeof input === 'string' || + input instanceof ArrayBuffer || + input instanceof Blob || + ArrayBuffer.isView(input) + ) { + return input + } else { + return decode(input) + } +} + +/** + * + * @param {AsyncIterable} out + * @returns {RemoteIterable} + */ +const encodeAddResult = out => + encodeAsyncIterable(mapAsyncIterable(out, encodeFileOutput)) + +/** + * + * @param {FileOutput} file + */ + +const encodeFileOutput = file => ({ + ...file, + cid: file.cid.toString() +}) + +exports.Core = Core diff --git a/packages/ipfs-message-port-server/src/dag.js b/packages/ipfs-message-port-server/src/dag.js new file mode 100644 index 0000000000..9e73dd1ba1 --- /dev/null +++ b/packages/ipfs-message-port-server/src/dag.js @@ -0,0 +1,77 @@ +'use strict' + +const CID = require('cids') +const { collect } = require('./util') + +/** + * @template T + * @typedef {import('ipfs-message-port-protocol/src/data').StringEncoded} StringEncoded + */ +/** + * @typedef {import('./ipfs').IPFS} IPFS + * @typedef {import('ipfs-message-port-protocol/src/dag').DAGAPI} DAGAPI + * @typedef {import('ipfs-message-port-protocol/src/dag').DAGNode} DAGNode + * @typedef {import('ipfs-message-port-protocol/src/dag').PutDAG} PutDAG + * @typedef {import('ipfs-message-port-protocol/src/dag').GetDAG} GetDAG + * @typedef {import('ipfs-message-port-protocol/src/dag').DAGEntry} DAGEntry + * @typedef {import('ipfs-message-port-protocol/src/dag').EnumerateDAG} EnumerateDAG + */ + +/** + * @class + */ +class DAG { + /** + * @param {IPFS} ipfs + */ + constructor (ipfs) { + this.ipfs = ipfs + } + + /** + * + * @param {PutDAG} query + * @returns {Promise>} + */ + async put (query) { + const { dagNode, format, hashAlg, pin, preload, timeout, signal } = query + const cid = await this.ipfs.dag.put(dagNode, { + format, + hashAlg, + pin, + preload, + timeout, + signal + }) + return cid.toString() + } + + /** + * @param {GetDAG} query + * @returns {Promise} + */ + async get (query) { + const { cid, path, localResolve, timeout, signal } = query + const result = await this.ipfs.dag.get(new CID(cid), path, { + localResolve, + timeout, + signal + }) + return result + } + + /** + * @param {EnumerateDAG} query + * @returns {Promise} + */ + async tree (query) { + const { cid, path, recursive, timeout, signal } = query + const result = await this.ipfs.dag.tree(new CID(cid), path, { + recursive, + timeout, + signal + }) + return await collect(result) + } +} +exports.DAG = DAG diff --git a/packages/ipfs-message-port-server/src/files.js b/packages/ipfs-message-port-server/src/files.js new file mode 100644 index 0000000000..aef964556f --- /dev/null +++ b/packages/ipfs-message-port-server/src/files.js @@ -0,0 +1,239 @@ +'use strict' + +/* eslint-env browser */ + +const CID = require('cids') +const { encodeAsyncIterable, decodeRemoteIterable } = require('./util') + +/** + * @template T + * @typedef {import('ipfs-message-port-protocol/src/data').StringEncoded} StringEncoded + */ +/** + * @template T + * @typedef {import('ipfs-message-port-protocol/src/data').RemoteIterable} RemoteIterable + */ +/** + * @typedef {import('ipfs-message-port-protocol/src/data').HashAlg} HashAlg + * @typedef {import('ipfs-message-port-protocol/src/data').Mode} Mode + * @typedef {import('ipfs-message-port-protocol/src/data').Time} Time + * @typedef {import('ipfs-message-port-protocol/src/data').UnixFSTime} UnixFSTime + * @typedef {import('ipfs-message-port-protocol/src/data').FileType} FileType + * @typedef {import('ipfs-message-port-protocol/src/data').CIDVersion} CIDVersion + + * @typedef {import('./ipfs').IPFS} IPFS + */ + +/** + * @class + */ +class Files { + /** + * + * @param {IPFS} ipfs + */ + constructor (ipfs) { + this.ipfs = ipfs + } + + /** + * @param {ChmodQuery} query + * @returns {Promise} + */ + async chmod (query) { + const cid = await new CID(query.path) + throw new Error(cid.toString()) + } + + // cp(input: CpQuery): Promise + // mkdir(input: MkdirQuery): Promise + // stat(input: StatQuery): Promise + // touch(input: TouchQuery): Promise + // rm(input: RmQuery): Promise + // read(input: ReadQuery): Promise + /** + * @param {WriteQuery} query + * @returns {Promise} + */ + async write (query) { + const { path, content } = query + const { cid, size } = await this.ipfs.files.write( + path, + decodeContent(content), + query + ) + return { cid: cid.toString(), size } + } + // mv(input: MvQuery): Promise + // flush(input: FlushQuery): Promise> + + /** + * @param {LsQuery} query + * @returns {LsResult} + */ + ls (query) { + const { sort, timeout, signal } = query + const entries = this.ipfs.files.ls(query.path, { + sort, + timeout, + signal + }) + return encodeAsyncIterable(entries) + } +} +exports.Files = Files + +/** + * @param {EncodedContent} content + * @returns {DecodedContent} + */ +const decodeContent = content => { + if (typeof content === 'string') { + return content + } else if (ArrayBuffer.isView(content)) { + return content + } else if (content instanceof ArrayBuffer) { + return content + } else if (content instanceof Blob) { + return content + } else { + return decodeRemoteIterable(content) + } +} + +/** + * @typedef {Object} ChmodQuery + * @prop {string} path + * @prop {Mode} mode + * @prop {boolean} [recursive] + * @prop {HashAlg} [hashAlg] + * @prop {boolean} [flush] + * @prop {number} [cidVersion] + */ + +// type CpQuery = { +// from: string | StringEncoded +// to: string | StringEncoded +// parents?: boolean +// hashAlg?: HashAlg +// flush?: boolean +// } + +// type MkdirQuery = { +// path: string +// // Note: Date objects seem to get copied over message port preserving +// // Date type. +// mtime?: Time +// parents?: boolean +// flush?: boolean +// hashAlg?: HashAlg +// mode?: Mode +// } + +// type StatQuery = { +// path: string +// size?: boolean +// hash?: HashAlg +// withLocal?: boolean +// } + +// type Stat = { +// type: FileType +// cid: StringEncoded +// size: number +// cumulativeSize: number +// blocks: number +// withLocality: boolean +// local: boolean +// sizeLocal: number +// } + +// type TouchQuery = { +// path: string +// mtime?: Time +// flush?: boolean +// hashAlg?: HashAlg +// cidVersion?: number +// } + +// type RmQuery = { +// paths: string[] +// recursive?: boolean +// flush?: boolean +// hashAlg?: HashAlg +// cidVersion?: number +// } + +// type ReadQuery = { +// path: string + +// offset?: number +// length?: number +// } + +// type ReadOutput = { +// content: RemoteIterable +// } + +// type WriteContent = +// | string +// | ArrayBufferView +// | ArrayBuffer +// | Blob +// | RemoteIterable + +/** + * @typedef {string|ArrayBufferView|ArrayBuffer|Blob|RemoteIterable} EncodedContent + * @typedef {string|ArrayBuffer|ArrayBufferView|Blob|AsyncIterable} DecodedContent + * @typedef {Object} WriteQuery + * @property {string} path + * @property {EncodedContent} content + * @property {number} [offset] + * @property {number} [length] + * @property {boolean} [create] + * @property {boolean} [parents] + * @property {boolean} [options] + * @property {boolean} [rawLeaves] + * @property {number} [mode] + * @property {Time} [mtime] + * @property {boolean} [flush] + * @property {HashAlg} [hashAlg] + * @property {CIDVersion} [cidVersion] + * @property {number} [timeout] + * @property {AbortSignal} [signal] + * + * @typedef {Object} WriteResult + * @property {StringEncoded} cid + * @property {number} size + */ + +// type MvQuery = { +// from: string | string[] +// to: string + +// parents: boolean +// flush: boolean +// hashAlg: HashAlg +// cidVersion: number +// } + +// type FlushQuery = { +// path: string +// } + +/** + * @typedef {Object} LsQuery + * @property {string} path + * @property {boolean} [sort] + * @property {number} [timeout] + * @property {AbortSignal} [signal] + * + * @typedef {Object} Entry + * @property {string} name + * @property {FileType} type + * @property {number} size + * @property {StringEncoded} cid + * @property {number} mode + * @property {UnixFSTime} mtime + * @typedef {RemoteIterable} LsResult + */ diff --git a/packages/ipfs-message-port-server/src/index.js b/packages/ipfs-message-port-server/src/index.js new file mode 100644 index 0000000000..0d3723b1cb --- /dev/null +++ b/packages/ipfs-message-port-server/src/index.js @@ -0,0 +1,72 @@ +'use strict' + +/* eslint-env browser */ + +const { Server } = require('./server') +const { DAG } = require('./dag') +const { Core } = require('./core') +const { Files } = require('./files') + +/** + * @typedef {import('./ipfs').IPFS} IPFS + */ + +class IPFSService extends Core { + /** + * + * @param {IPFS} ipfs + */ + constructor (ipfs) { + super(ipfs) + this.dag = new DAG(ipfs) + this.files = new Files(ipfs) + } +} + +exports.IPFSService = IPFSService + +/** + * @param {IPFS} ipfs + * @returns {Promise} + */ +const main = async function (ipfs) { + const service = new IPFSService(ipfs) + const server = new Server(service) + + const controller = new AbortController() + + const result = await server.execute({ + namespace: 'dag', + method: 'get', + input: { + cid: 'foo', + path: '/foo', + localResolve: true + }, + signal: controller.signal + }) + // eslint-disable-next-line no-console + console.log(result) + + const added = await server.execute({ + method: 'add', + input: { + input: 'hello' + } + }) + // eslint-disable-next-line no-console + console.log(added) + + const dag = new Server(service.dag) + dag.execute({ + method: 'get', + input: { + cid: 'foo', + path: '/foo', + localResolve: true + }, + signal: controller.signal + }) +} + +exports.main = main diff --git a/packages/ipfs-message-port-server/src/ipfs.ts b/packages/ipfs-message-port-server/src/ipfs.ts new file mode 100644 index 0000000000..eb71ccdae5 --- /dev/null +++ b/packages/ipfs-message-port-server/src/ipfs.ts @@ -0,0 +1,196 @@ +import { DAGNode } from 'ipfs-message-port-protocol/src/dag' +import CID from 'cids' +import { + FileType, + UnixFSTime, + HashAlg, + Time, + CIDVersion +} from 'ipfs-message-port-protocol/src/data' + +type Mode = string | number +export interface IPFS extends Core { + dag: DAG + files: Files +} + +export interface IPFSFactory { + create(): Promise +} + +type PutOptions = { + format?: string | void + hashAlg?: string | void + preload?: boolean + pin?: boolean + timeout?: number + signal?: AbortSignal +} + +type GetOptions = { + localResolve?: boolean + timeout?: number + signal?: AbortSignal +} + +type TreeOptions = { + recursive?: boolean + timeout?: number + signal?: AbortSignal | void +} + +export interface DAG { + put(dagNode: DAGNode, options: PutOptions): Promise + get( + cid: CID, + path: string, + options: GetOptions + ): Promise<{ value: DAGNode; remainderPath: string }> + tree(cid: CID, path: string, options: TreeOptions): AsyncIterable +} + +export interface Core { + add(inputs: AddInput, options: AddOptions): AsyncIterable + cat(ipfsPath: CID | string, options: CatOptions): AsyncIterable +} + +type AddOptions = { + chunker?: string + cidVersion?: number + enableShardingExperiment?: boolean + hashAlg?: HashAlg + onlyHash?: boolean + pin?: boolean + progress?: (progress: number) => void + rawLeaves?: boolean + shardSplitThreshold?: boolean + trickle?: boolean + wrapWithDirectory?: boolean + + timeout?: number + signal?: AbortSignal +} + +export type FileInput = { + path: string + content: string | AsyncIterable + mode: string | number | void + mtime: { secs: number; nsecs?: number } | void +} + +export type FileOutput = { + path: string + cid: CID + mode: number + mtime: { secs: number; nsecs: number } + size: number +} + +export type CatOptions = { + offset?: number + length?: number + timeout?: number + signal?: AbortSignal +} + +export interface Files { + chmod(path: string | CID, mode: Mode, options?: ChmodOptions): Promise + + write( + path: string, + content: WriteContent, + options?: WriteOptions + ): Promise + + ls(path?: string, opitons?: LsOptions): AsyncIterable +} + +type ChmodOptions = { + recursive: boolean + flush: boolean + hashAlg: string + cidVersion: number + timeout: number + signal: AbortSignal +} + +type LsOptions = { + sort?: boolean + timeout?: number + signal?: AbortSignal +} + +type LsEntry = { + name: string + type: FileType + size: number + cid: CID + mode: Mode + mtime: UnixFSTime +} + +type WriteContent = + | string + | ArrayBufferView + | ArrayBuffer + | Blob + | AsyncIterable + +type AddInput = SingleFileInput | MultiFileInput + +type SingleFileInput = + | string + | ArrayBufferView + | ArrayBuffer + | Blob + | FileObject + | Iterable + | Iterable + | Iterable + | AsyncIterable + | AsyncIterable + +type MultiFileInput = + | Iterable + | Iterable + | Iterable + | AsyncIterable + | AsyncIterable + | AsyncIterable + +export type FileObject = { + path?: string + content?: FileContent + mode?: Mode + mtime?: Time +} + +export type FileContent = + | string + | ArrayBufferView + | ArrayBuffer + | Blob + | Iterable + | Iterable + | Iterable + | AsyncIterable + | AsyncIterable + +type WriteOptions = { + offset?: number + length?: number + create?: boolean + parents?: boolean + truncate?: boolean + rawLeaves?: boolean + mode?: Mode + mtime?: Time + flush?: boolean + hashAlg?: HashAlg + cidVersion?: CIDVersion +} + +type WriteResult = { + cid: CID + size: number +} diff --git a/packages/ipfs-message-port-server/src/server.js b/packages/ipfs-message-port-server/src/server.js new file mode 100644 index 0000000000..e8a59b1bc8 --- /dev/null +++ b/packages/ipfs-message-port-server/src/server.js @@ -0,0 +1,282 @@ +'use strict' + +/* eslint-env browser */ + +// const CID = require('cids') + +/** + * @typedef {import('./ipfs').IPFS} IPFS + * @typedef {import('ipfs-message-port-protocol/src/data').EncodedError} EncodedError + */ + +/** + * @template X, T + * @typedef {import('ipfs-message-port-protocol/src/data').Result} Result + */ + +/** + * @template T + * @typedef {import('ipfs-message-port-protocol/src/rpc').Input} Input + */ + +/** + * @template T + * @typedef {import('ipfs-message-port-protocol/src/rpc').ProcedureNames} ProcedureNames + */ + +/** + * @template T + * @typedef {import('ipfs-message-port-protocol/src/rpc').Method} Method + */ + +/** + * @template T + * @typedef {import('ipfs-message-port-protocol/src/rpc').Namespace} Namespace + */ + +/** + * @template T + * @typedef {import('ipfs-message-port-protocol/src/rpc').ServiceQuery} ServiceQuery + */ + +/** + * @template T + * @typedef {import('ipfs-message-port-protocol/src/rpc').RPCQuery} RPCQuery + + */ + +/** + * @template T + * @typedef {import('ipfs-message-port-protocol/src/rpc').Inn} Inn + */ + +/** + * @template T + * @typedef {import('ipfs-message-port-protocol/src/rpc').Out} Out + */ + +/** + * @template T + * @typedef {Object} QueryMessage + * @property {'query'} type + * @property {Namespace} namespace + * @property {Method} method + * @property {string} id + * @property {Inn} input + */ + +/** + * @typedef {Object} AbortMessage + * @property {'abort'} type + * @property {string} id + */ + +/** + * @typedef {Object} TransferOptions + * @property {Transferable[]} [transfer] + */ + +/** + * @template O + * @typedef {O & TransferOptions} QueryResult + */ + +/** + * @template T + * @typedef {AbortMessage|QueryMessage} Message + */ + +/** + * @template T + * @typedef {import('ipfs-message-port-protocol/src/rpc').Service} Service + */ + +/** + * @template T, K + * @typedef {import('ipfs-message-port-protocol/src/rpc').NamespacedQuery} NamespacedQuery + */ +/** + * @template T + * @extends {ServiceQuery} + * @implements {ServiceQuery} + */ +class Query { + /** + * @param {Namespace} namespace + * @param {Method} method + * @param {Inn} input + */ + constructor (namespace, method, input) { + this.result = new Promise((resolve, reject) => { + this.succeed = resolve + this.fail = reject + this.namespace = namespace + this.method = method + this.input = input + + this.abortController = new AbortController() + this.signal = this.abortController.signal + }) + } + + /** + * @template T + * @param {RPCQuery} value + * @returns {Query} + */ + static from (value) { + return new Query(value.namespace, value.method, value.input) + } + + abort () { + this.abortController.abort() + this.fail(new AbortError()) + } +} + +/** + * @template T + */ + +class Server { + /** + * @param {Service} services + */ + constructor (services) { + this.services = services + /** @type {Record>} */ + this.queries = Object.create(null) + } + + /** + * @param {MessagePort} port + */ + connect (port) { + port.addEventListener('message', this) + port.start() + } + + /** + * @param {MessagePort} port + */ + disconnect (port) { + port.removeEventListener('message', this) + port.close() + } + + /** + * @param {MessageEvent} event + * @returns {void} + */ + handleEvent (event) { + /** @type {Message} */ + const data = event.data + switch (data.type) { + case 'query': { + this.handleQuery( + data.id, + new Query(data.namespace, data.method, data.input), + /** @type {MessagePort} */ + (event.source) + ) + return undefined + } + case 'abort': { + return this.abort(data.id) + } + default: { + throw new UnsupportedMessageError(event) + } + } + } + + /** + * @param {string} id + */ + abort (id) { + const query = this.queries[id] + if (query) { + delete this.queries[id] + query.abort() + } + } + + /** + * @param {string} id + * @param {Query} query + * @param {MessagePort} port + */ + async handleQuery (id, query, port) { + this.queries[id] = query + await this.run(query) + delete this.queries[id] + if (!query.signal.aborted) { + try { + const value = await query.result + port.postMessage( + { type: 'result', id, result: { ok: true, value } }, + value.transfer || [] + ) + } catch ({ name, message, stack }) { + const error = { name, message, stack } + port.postMessage({ type: 'result', id, result: { ok: false, error } }) + } + } + } + + /** + * @param {Query} query + * @returns {void} + */ + run (query) { + const { services } = this + const { namespace, method } = query + + // @ts-ignore - seems to fail to infer + const service = namespace == null ? services : services[namespace] + if (service) { + const procedure = service[method] + if (typeof procedure === 'function') { + try { + Promise.resolve(procedure.call(service, query)).then( + query.succeed, + query.fail + ) + } catch (error) { + query.fail(error) + } + } else { + query.fail(new RangeError(`Method '${method}' is not found`)) + } + } else { + query.fail(new RangeError(`Namespace '${namespace}' is not found`)) + } + } + + /** + * @param {RPCQuery} data + * @returns {Out} + */ + execute (data) { + const query = Query.from(data) + this.execute(query) + + return query.result + } +} + +class UnsupportedMessageError extends RangeError { + /** + * @param {MessageEvent} event + */ + constructor (event) { + super('Unexpected message was received by the server') + this.event = event + } +} + +class AbortError extends Error {} + +exports.Query = Query +exports.Server = Server +exports.AbortError = AbortError diff --git a/packages/ipfs-message-port-server/src/util.js b/packages/ipfs-message-port-server/src/util.js new file mode 100644 index 0000000000..035d8335f3 --- /dev/null +++ b/packages/ipfs-message-port-server/src/util.js @@ -0,0 +1,120 @@ +'use strict' + +/** + * @template T + * @param {AsyncIterable} input + * @returns {Promise} + */ +const collect = async input => { + const values = [] + for await (const value of input) { + values.push(value) + } + return values +} + +/** + * @template T + * @typedef {import("ipfs-message-port-protocol/src/data").RemoteIterable} RemoteIterable + */ + +/** + * @template T + * @param {RemoteIterable} remote + * @returns {AsyncIterable} + */ +const decodeRemoteIterable = async function * ({ port }) { + /** + * @param {{done:false, value:T}|{done:true, value:void}} _data + * @returns {void} + */ + let receive = _data => {} + const wait = () => new Promise(resolve => (receive = resolve)) + const next = () => { + port.postMessage({ method: 'next' }) + return wait() + } + + /** + * @param {MessageEvent} event + * @returns {void} + */ + port.onmessage = event => receive(event.data) + + const abort = () => { + port.postMessage({ method: 'return' }) + port.close() + } + + let isDone = false + try { + while (!isDone) { + const { done, value } = await next() + isDone = done + if (!done) { + yield value + } + } + } finally { + if (!isDone) { + abort() + } + } +} + +/** + * @template T + * @param {AsyncIterable} iterable + * @returns {RemoteIterable} + */ +const encodeAsyncIterable = iterable => { + // eslint-disable-next-line no-undef + const { port1: port, port2: remote } = new MessageChannel() + const iterator = iterable[Symbol.asyncIterator]() + port.onmessage = async ({ data: { method } }) => { + switch (method) { + case 'next': { + const { done, value } = await iterator.next() + if (done) { + port.postMessage({ done: true }) + port.close() + } else { + port.postMessage({ done: false, value }) + } + break + } + case 'return': { + port.close() + if (iterator.return) { + iterator.return() + } + break + } + default: { + break + } + } + } + port.start() + + return { type: 'RemoteIterable', port: remote, transfer: [remote] } +} + +/** + * @template A,B + * @param {AsyncIterable} source + * @param {function(A): B} f + * @returns {AsyncIterable} + */ +const mapAsyncIterable = async function * (source, f) { + for await (const item of source) { + yield f(item) + } +} + +module.exports = { + collect, + decodeRemoteIterable, + encodeAsyncIterable, + mapAsyncIterable +} diff --git a/packages/ipfs-message-port-server/tsconfig.json b/packages/ipfs-message-port-server/tsconfig.json new file mode 100644 index 0000000000..3cab5aa04e --- /dev/null +++ b/packages/ipfs-message-port-server/tsconfig.json @@ -0,0 +1,24 @@ +{ + "compilerOptions": { + "allowJs": true, + "checkJs": true, + "forceConsistentCasingInFileNames": true, + "noImplicitReturns": true, + "noImplicitAny": true, + "noImplicitThis": true, + "noFallthroughCasesInSwitch": true, + "noUnusedLocals": true, + "noUnusedParameters": true, + "strictFunctionTypes": true, + "strictNullChecks": true, + "strictPropertyInitialization": true, + "strict": true, + "alwaysStrict": true, + "esModuleInterop": true, + "target": "ES5", + "noEmit": true + }, + "exclude": ["dist", "node_modules"], + "include": ["src/**/*.js"], + "compileOnSave": false +} From 5099f209dce0526ec373bd00c0f55ac4750948ea Mon Sep 17 00:00:00 2001 From: Irakli Gozalishvili Date: Thu, 4 Jun 2020 01:00:48 -0700 Subject: [PATCH 02/63] Make changes to get tests running. --- packages/ipfs-message-port-client/.aegir.js | 40 +++++++++ .../ipfs-message-port-client/package.json | 51 ++--------- .../ipfs-message-port-client/src/client.js | 44 +++++++--- packages/ipfs-message-port-client/src/dag.js | 28 ++++-- .../ipfs-message-port-client/test/.aegir.js | 47 ---------- .../ipfs-message-port-client/test/dag.spec.js | 88 +++++++++---------- .../test/util/client.js | 2 +- .../test/util/webpack.config.js | 2 +- .../test/util/worker.js | 41 ++++++--- .../ipfs-message-port-protocol/package.json | 50 ++--------- .../ipfs-message-port-server/package.json | 56 +++--------- packages/ipfs-message-port-server/src/dag.js | 48 +++++++--- .../ipfs-message-port-server/src/server.js | 8 +- 13 files changed, 235 insertions(+), 270 deletions(-) create mode 100644 packages/ipfs-message-port-client/.aegir.js delete mode 100644 packages/ipfs-message-port-client/test/.aegir.js diff --git a/packages/ipfs-message-port-client/.aegir.js b/packages/ipfs-message-port-client/.aegir.js new file mode 100644 index 0000000000..833ffa08e7 --- /dev/null +++ b/packages/ipfs-message-port-client/.aegir.js @@ -0,0 +1,40 @@ +'use strict' + +module.exports = { + bundlesize: { maxSize: '89kB' }, + karma: { + files: [ + { + pattern: 'node_modules/interface-ipfs-core/test/fixtures/**/*', + watched: false, + served: true, + included: false + }, + { + pattern: 'dist/**/*', + watched: true, + served: true, + included: false + } + ], + browserNoActivityTimeout: 210 * 1000, + singleRun: true, + captureConsole: true, + logLevel: 'LOG_DEBUG', + mocha: { + bail: true + } + }, + hooks: { + browser: { + pre: async () => { + return { + env: { + IPFS_WORKER_URL: `/base/dist/worker.bundle.js`, + ECHO_SERVER: `http://localhost:8080` + } + } + } + } + } +} diff --git a/packages/ipfs-message-port-client/package.json b/packages/ipfs-message-port-client/package.json index 4873065044..2946297422 100644 --- a/packages/ipfs-message-port-client/package.json +++ b/packages/ipfs-message-port-client/package.json @@ -1,8 +1,8 @@ { "name": "ipfs-message-port-client", "version": "0.0.1", - "description": "A client library for the IPFS across message port", - "keywords": ["ipfs"], + "description": "IPFS client library for accessing IPFS node over message port", + "keywords": ["ipfs", "message-port", "worker"], "homepage": "https://github.com/ipfs/js-ipfs/tree/master/packages/ipfs-message-port-client#readme", "bugs": "https://github.com/ipfs/js-ipfs/issues", "license": "(Apache-2.0 OR MIT)", @@ -15,7 +15,7 @@ "url": "git+https://github.com/ipfs/js-ipfs.git" }, "scripts": { - "test": "aegir build -- cross-env ECHO_SERVER_PORT=37490 aegir test -t browser", + "test": "aegir build -- --config ./test/util/webpack.config.js && aegir build -- cross-env ECHO_SERVER_PORT=37490 aegir test -t browser", "test:browser": "cross-env ECHO_SERVER_PORT=37492 aegir test -t browser", "test:electron-main": "cross-env ECHO_SERVER_PORT=37494 aegir test -t electron-main", "test:electron-renderer": "cross-env ECHO_SERVER_PORT=37495 aegir test -t electron-renderer", @@ -28,48 +28,15 @@ "dep-check": "aegir dep-check" }, "dependencies": { - "abort-controller": "^3.0.0", - "bignumber.js": "^9.0.0", - "bs58": "^4.0.1", - "buffer": "^5.4.2", - "cids": "^0.8.0", - "debug": "^4.1.0", - "form-data": "^3.0.0", - "ipfs-block": "^0.8.1", - "ipfs-core-utils": "^0.2.2", - "ipfs-utils": "^2.2.2", - "ipld-dag-cbor": "^0.15.1", - "ipld-dag-pb": "^0.18.3", - "ipld-raw": "^4.0.1", - "iso-url": "^0.4.7", - "it-tar": "^1.2.1", - "it-to-buffer": "^1.0.0", - "it-to-stream": "^0.1.1", - "merge-options": "^2.0.0", - "multiaddr": "^7.2.1", - "multiaddr-to-uri": "^5.1.0", - "multibase": "^0.7.0", - "multicodec": "^1.0.0", - "multihashes": "^0.4.14", - "nanoid": "^3.0.2", - "node-fetch": "^2.6.0", - "parse-duration": "^0.1.2", - "stream-to-it": "^0.2.0" + "cids": "^0.8.0" }, "devDependencies": { - "aegir": "^21.10.1", - "browser-process-platform": "^0.1.1", + "ipfs-message-port-protocol": "^0.0.1", + "ipfs-message-port-server": "^0.0.1", + "ipfs": "^0.45.0", + "aegir": "^22.0.0", "cross-env": "^7.0.0", - "go-ipfs-dep": "0.4.23-3", - "interface-ipfs-core": "^0.134.3", - "ipfsd-ctl": "^3.0.0", - "it-all": "^1.0.1", - "it-concat": "^1.0.0", - "it-pipe": "^1.1.0", - "nock": "^12.0.3", - "ipfs-message-port-protocol": "^0", - "ipfs-message-port-server": "^0", - "ipfs": "^0.43.3" + "interface-ipfs-core": "^0.135.1" }, "engines": { "node": ">=10.3.0", diff --git a/packages/ipfs-message-port-client/src/client.js b/packages/ipfs-message-port-client/src/client.js index 1e393bb766..bc91cf7ffe 100644 --- a/packages/ipfs-message-port-client/src/client.js +++ b/packages/ipfs-message-port-client/src/client.js @@ -2,7 +2,24 @@ /* eslint-env browser */ -class RemoteError extends Error {} +class RemoteError extends Error { + /** + * + * @param {Object} info + * @param {string} info.message + * @param {string} info.stack + * @param {string} info.name + * @param {string} [info.code] + */ + constructor ({ message, stack, name, code }) { + super(message) + this.stack = stack + this.name = name + if (code) { + this.code = code + } + } +} class TimeoutError extends Error {} @@ -34,18 +51,19 @@ class DisconnectError extends Error {} /** * @template I,O - * @extends {Promise} + * @class */ -class Query extends Promise { +class Query { /** * @param {string} namespace * @param {string} method * @param {QueryInput} input */ constructor (namespace, method, input) { - super((succeed, fail) => { - this.succeed = succeed - this.fail = fail + /** @type {Promise} */ + this.result = new Promise((resolve, reject) => { + this.succeed = resolve + this.fail = reject this.abortController = new AbortController() this.signal = this.abortController.signal this.input = input @@ -84,6 +102,9 @@ class Transport { constructor (port) { this.port = null this.nextID = 0 + this.id = Math.random() + .toString(32) + .slice(2) /** @type {Record>} */ this.queries = Object.create(null) if (port) { @@ -94,10 +115,10 @@ class Transport { /** * @template I, O * @param {Query} query - * @returns {Query} + * @returns {Promise} */ execute (query) { - const id = `@${this.nextID++}` + const id = `${this.id}@${this.nextID++}` this.queries[id] = query if (query.timeout > 0 && query.timeout < Infinity) { @@ -110,7 +131,7 @@ class Transport { Transport.postQuery(this.port, id, query) } - return query + return query.result } /** @@ -149,9 +170,10 @@ class Transport { port.postMessage( { type: 'query', + namespace: query.namespace, method: query.method, id, - query: query.toJSON() + input: query.toJSON() }, query.transfer() ) @@ -231,7 +253,7 @@ class Service { /** * @template I, O * @param {I} input - * @returns {Query} + * @returns {Promise} */ self[method] = input => this.transport.execute(new Query(namespace, method.toString(), input)) diff --git a/packages/ipfs-message-port-client/src/dag.js b/packages/ipfs-message-port-client/src/dag.js index 34b3fdc029..10d2ecb952 100644 --- a/packages/ipfs-message-port-client/src/dag.js +++ b/packages/ipfs-message-port-client/src/dag.js @@ -5,7 +5,9 @@ const CID = require('cids') /** * @typedef {import('ipfs-message-port-protocol/src/data').JSONValue} JSONValue - * @typedef {import('ipfs-message-port-protocol/src/dag').DAGAPI} API + * @typedef {import('ipfs-message-port-server/src/dag').DAGNode} DAGNode + * @typedef {import('ipfs-message-port-server/src/dag').DAGEntry} DAGEntry + * @typedef {import('ipfs-message-port-server/src/dag').DAG} API * @typedef {import('./client').ClientTransport} Transport */ @@ -43,7 +45,7 @@ class DAG extends Client { } /** - * @param {JSONValue} dagNode + * @param {DAGNode} dagNode * @param {Object} [options] * @param {string} [options.format="dag-cbor"] - The IPLD format multicodec * @param {string} [options.hashAlg="sha2-256"] - The hash algorithm to be used over the serialized DAG node @@ -56,16 +58,18 @@ class DAG extends Client { */ async put (dagNode, options = {}) { const { format, hashAlg, cid, pin, preload, timeout, signal } = options + const transfer = ArrayBuffer.isView(dagNode) ? [dagNode.buffer] : [] const encodedCID = await this.remote.put({ - dagNode, + dagNode: encodeDAGNode(dagNode), format, hashAlg, cid: cid != null ? cid.toString() : undefined, pin, preload, timeout, - signal + signal, + transfer }) return new CID(encodedCID) @@ -78,7 +82,7 @@ class DAG extends Client { * @param {boolean} [options.localResolve] * @param {number} [options.timeout] * @param {AbortSignal} [options.signal] - * @returns {Promise<{value:JSONValue, remainderPath:string}>} + * @returns {Promise} */ get (cid, path, options = {}) { const [nodePath, { localResolve, timeout, signal }] = read(path, options) @@ -141,4 +145,18 @@ const read = (path, options) => { } } +/** + * @param {DAGNode} dagNode + * @returns {JSONValue} + */ +const encodeDAGNode = dagNode => { + /** @type {any|null} */ + const object = (dagNode != null ? dagNode : null) + if (object && typeof object.toJSON === 'function') { + return object.toJSON() + } else { + return object + } +} + module.exports = DAG diff --git a/packages/ipfs-message-port-client/test/.aegir.js b/packages/ipfs-message-port-client/test/.aegir.js deleted file mode 100644 index 2dbe62c5fa..0000000000 --- a/packages/ipfs-message-port-client/test/.aegir.js +++ /dev/null @@ -1,47 +0,0 @@ -'use strict' - -const EchoServer = require('aegir/utils/echo-server') - -let echoServer = new EchoServer() - -module.exports = { - bundlesize: { maxSize: '89kB' }, - karma: { - files: [ - { - pattern: 'node_modules/interface-ipfs-core/test/fixtures/**/*', - watched: false, - served: true, - included: false - } - ], - browserNoActivityTimeout: 210 * 1000, - singleRun: true - }, - hooks: { - node: { - pre: async () => { - await echoServer.start() - return { - env: { - ECHO_SERVER: `http://${echoServer.host}:${echoServer.port}` - } - } - }, - post: () => echoServer.stop() - }, - browser: { - pre: async () => { - await Promise.all([server.start(), echoServer.start()]) - return { - env: { - ECHO_SERVER: `http://${echoServer.host}:${echoServer.port}` - } - } - }, - post: () => { - return Promise.all([server.stop(), echoServer.stop()]) - } - } - } -} diff --git a/packages/ipfs-message-port-client/test/dag.spec.js b/packages/ipfs-message-port-client/test/dag.spec.js index 318db43f91..57dabd7b0a 100644 --- a/packages/ipfs-message-port-client/test/dag.spec.js +++ b/packages/ipfs-message-port-client/test/dag.spec.js @@ -7,12 +7,11 @@ const { Buffer } = require('buffer') const { expect } = require('interface-ipfs-core/src/utils/mocha') const { DAGNode } = require('ipld-dag-pb') const CID = require('cids') -const { activate } = require('./client') +const { activate } = require('./util/client') -let ipfs = null - -describe('.dag', () => { - this.timeout(20 * 1000) +describe('dag', function () { + this.timeout(10 * 1000) + let ipfs = null before(() => { ipfs = activate() }) @@ -21,51 +20,50 @@ describe('.dag', () => { ipfs = null }) - it('should be able to put and get a DAG node with format dag-pb', async () => { - const data = Buffer.from('some data') - const node = new DAGNode(data) - - let cid = await ipfs.dag.put(node, { - format: 'dag-pb', - hashAlg: 'sha2-256' - }) - expect(cid).to.be.instanceOf(CID) - cid = cid.toV0() - expect(cid.codec).to.equal('dag-pb') - cid = cid.toBaseEncodedString('base58btc') - // expect(cid).to.equal('bafybeig3t3eugdchignsgkou3ly2mmy4ic4gtfor7inftnqn3yq4ws3a5u') - expect(cid).to.equal('Qmd7xRhW5f29QuBFtqu3oSD27iVy35NRB91XFjmKFhtgMr') - - const result = await ipfs.dag.get(cid) + // describe('get', () => { + // it('should throw error for invalid string CID input', () => { + // return expect(ipfs.dag.get('INVALID CID')) + // .to.eventually.be.rejected() + // .and.to.have.property('code') + // .that.equals('ERR_INVALID_CID') + // }) - expect(result.value.Data).to.deep.equal(data) - }) + // // it('should throw error for invalid buffer CID input', () => { + // // return expect(ipfs.dag.get(Buffer.from('INVALID CID'))) + // // .to.eventually.be.rejected() + // // .and.to.have.property('code') + // // .that.equals('ERR_INVALID_CID') + // // }) + // }) - // it('should be able to put and get a DAG node with format dag-cbor', async () => { - // const cbor = { foo: 'dag-cbor-bar' } - // let cid = await ipfs.dag.put(cbor, { - // format: 'dag-cbor', - // hashAlg: 'sha2-256' + // describe('tree', () => { + // it('should throw error for invalid CID input', () => { + // return expect(all(ipfs.dag.tree('INVALID CID'))) + // .to.eventually.be.rejected() + // .and.to.have.property('code') + // .that.equals('ERR_INVALID_CID') // }) + // }) - // expect(cid.codec).to.equal('dag-cbor') - // cid = cid.toBaseEncodedString('base32') - // expect(cid).to.equal( - // 'bafyreic6f672hnponukaacmk2mmt7vs324zkagvu4hcww6yba6kby25zce' - // ) - - // const result = await ipfs.dag.get(cid) + describe('ipfs.dag', () => { + it('should be able to put and get a DAG node with format dag-pb', async () => { + const data = Buffer.from('some data') + const { Data, Links } = new DAGNode(data) + const node = { Data, Links } - // expect(result.value).to.deep.equal(cbor) - // }) + let cid = await ipfs.dag.put(node, { + format: 'dag-pb', + hashAlg: 'sha2-256' + }) + cid = cid.toV0() + expect(cid.codec).to.equal('dag-pb') + cid = cid.toBaseEncodedString('base58btc') + // expect(cid).to.equal('bafybeig3t3eugdchignsgkou3ly2mmy4ic4gtfor7inftnqn3yq4ws3a5u') + expect(cid).to.equal('Qmd7xRhW5f29QuBFtqu3oSD27iVy35NRB91XFjmKFhtgMr') - // it('should error when missing DAG resolver for multicodec from requested CID', async () => { - // const block = await ipfs.block.put(Buffer.from([0, 1, 2, 3]), { - // cid: new CID('z8mWaJ1dZ9fH5EetPuRsj8jj26pXsgpsr') - // }) + const result = await ipfs.dag.get(cid) - // await expect(ipfs.dag.get(block.cid)).to.be.rejectedWith( - // 'Missing IPLD format "git-raw"' - // ) - // }) + expect(result.value.Data).to.deep.equal(data) + }) + }) }) diff --git a/packages/ipfs-message-port-client/test/util/client.js b/packages/ipfs-message-port-client/test/util/client.js index 663dab1f9f..a71e3e8a58 100644 --- a/packages/ipfs-message-port-client/test/util/client.js +++ b/packages/ipfs-message-port-client/test/util/client.js @@ -5,7 +5,7 @@ const IPFSClient = require('../../src/index') const activate = () => { - const worker = new SharedWorker(process.env.WORKER_SERVICE) + const worker = new SharedWorker(process.env.IPFS_WORKER_URL, 'IPFSService') const client = IPFSClient.from(worker.port) return client } diff --git a/packages/ipfs-message-port-client/test/util/webpack.config.js b/packages/ipfs-message-port-client/test/util/webpack.config.js index e3581a5752..6613f75972 100644 --- a/packages/ipfs-message-port-client/test/util/webpack.config.js +++ b/packages/ipfs-message-port-client/test/util/webpack.config.js @@ -7,7 +7,7 @@ module.exports = { devtool: 'source-map', entry: [path.join(__dirname, './worker.js')], output: { - path: __dirname, + path: path.join(__dirname, '../../dist/'), filename: 'worker.bundle.js' } } diff --git a/packages/ipfs-message-port-client/test/util/worker.js b/packages/ipfs-message-port-client/test/util/worker.js index 7ad218c059..8bb65065b9 100644 --- a/packages/ipfs-message-port-client/test/util/worker.js +++ b/packages/ipfs-message-port-client/test/util/worker.js @@ -4,12 +4,12 @@ const IPFS = require('ipfs') const { IPFSService } = require('ipfs-message-port-server') const { Server } = require('ipfs-message-port-server/src/server') -const main = async context => { +const main = async connections => { const ipfs = await IPFS.create({ offline: true, start: false }) const service = new IPFSService(ipfs) const server = new Server(service) - for (const event of listen(context, 'connect')) { + for await (const event of connections) { const port = event.ports[0] if (port) { server.connect(port) @@ -17,18 +17,33 @@ const main = async context => { } } -const listen = async function * (target, type, options) { - let next = () => {} - const read = () => new Promise(resolve => (next = resolve)) - const write = event => next(event) - target.addEventListener(type, write, options) - try { - while (true) { - yield * await read() +const listen = function (target, type, options) { + const events = [] + let resume + let ready = new Promise(resolve => (resume = resolve)) + + const write = event => { + events.push(event) + resume() + } + const read = async () => { + await ready + ready = new Promise(resolve => (resume = resolve)) + return events.splice(0) + } + + const reader = async function * () { + try { + while (true) { + yield * await read() + } + } finally { + target.removeEventListener(type, write, options) } - } finally { - target.removeEventListener(type, write, options) } + + target.addEventListener(type, write, options) + return reader() } -main(self) +main(listen(self, 'connect')) diff --git a/packages/ipfs-message-port-protocol/package.json b/packages/ipfs-message-port-protocol/package.json index e25b1b3d77..f3b424ef02 100644 --- a/packages/ipfs-message-port-protocol/package.json +++ b/packages/ipfs-message-port-protocol/package.json @@ -1,14 +1,13 @@ { "name": "ipfs-message-port-protocol", - "version": "0.1", - "description": "A client library for the IPFS across message port", + "version": "0.0.1", + "description": "IPFS client/server protocol over message port", "keywords": ["ipfs"], - "homepage": "https://github.com/ipfs/js-ipfs/tree/master/packages/ipfs-message-port-client#readme", + "homepage": "https://github.com/ipfs/js-ipfs/tree/master/packages/ipfs-message-port-protocol#readme", "bugs": "https://github.com/ipfs/js-ipfs/issues", "license": "(Apache-2.0 OR MIT)", "leadMaintainer": "Alex Potsides ", "files": ["src", "dist"], - "main": "src/index", "browser": {}, "repository": { "type": "git", @@ -29,47 +28,10 @@ "clean": "rm -rf ./dist", "dep-check": "aegir dep-check" }, - "dependencies": { - "abort-controller": "^3.0.0", - "bignumber.js": "^9.0.0", - "bs58": "^4.0.1", - "buffer": "^5.4.2", - "cids": "^0.8.0", - "debug": "^4.1.0", - "form-data": "^3.0.0", - "ipfs-block": "^0.8.1", - "ipfs-core-utils": "^0.2.2", - "ipfs-utils": "^2.2.2", - "ipld-dag-cbor": "^0.15.1", - "ipld-dag-pb": "^0.18.3", - "ipld-raw": "^4.0.1", - "iso-url": "^0.4.7", - "it-tar": "^1.2.1", - "it-to-buffer": "^1.0.0", - "it-to-stream": "^0.1.1", - "merge-options": "^2.0.0", - "multiaddr": "^7.2.1", - "multiaddr-to-uri": "^5.1.0", - "multibase": "^0.7.0", - "multicodec": "^1.0.0", - "multihashes": "^0.4.14", - "nanoid": "^3.0.2", - "node-fetch": "^2.6.0", - "parse-duration": "^0.1.2", - "stream-to-it": "^0.2.0" - }, + "dependencies": {}, "devDependencies": { - "aegir": "^21.10.1", - "browser-process-platform": "^0.1.1", - "cross-env": "^7.0.0", - "go-ipfs-dep": "0.4.23-3", - "interface-ipfs-core": "^0.134.3", - "ipfsd-ctl": "^3.0.0", - "it-all": "^1.0.1", - "it-concat": "^1.0.0", - "it-pipe": "^1.1.0", - "nock": "^12.0.3", - "ipfs-message-port-protocol": "^0" + "aegir": "^22.0.0", + "cross-env": "^7.0.0" }, "engines": { "node": ">=10.3.0", diff --git a/packages/ipfs-message-port-server/package.json b/packages/ipfs-message-port-server/package.json index 041f785ff7..04b1ced9e5 100644 --- a/packages/ipfs-message-port-server/package.json +++ b/packages/ipfs-message-port-server/package.json @@ -1,18 +1,15 @@ { "name": "ipfs-message-port-server", - "version": "0.1", - "description": "A server library for the IPFS across message port", - "keywords": ["ipfs"], - "homepage": "https://github.com/ipfs/js-ipfs/tree/master/packages/ipfs-message-port-client#readme", + "version": "0.0.1", + "description": "IPFS server library for exposing IPFS node over message port", + "keywords": ["ipfs", "message-port", "worker"], + "homepage": "https://github.com/ipfs/js-ipfs/tree/master/packages/ipfs-message-port-server#readme", "bugs": "https://github.com/ipfs/js-ipfs/issues", "license": "(Apache-2.0 OR MIT)", "leadMaintainer": "Alex Potsides ", "files": ["src", "dist"], "main": "src/index.js", - "browser": { - "./src/lib/to-stream.js": "./src/lib/to-stream.browser.js", - "ipfs-utils/src/files/glob-source": false - }, + "browser": {}, "repository": { "type": "git", "url": "git+https://github.com/ipfs/js-ipfs.git" @@ -33,47 +30,14 @@ "dep-check": "aegir dep-check" }, "dependencies": { - "ipfs": "0.43.3", - "abort-controller": "^3.0.0", - "bignumber.js": "^9.0.0", - "bs58": "^4.0.1", - "buffer": "^5.4.2", - "cids": "^0.8.0", - "debug": "^4.1.0", - "form-data": "^3.0.0", - "ipfs-block": "^0.8.1", - "ipfs-core-utils": "^0.2.2", - "ipfs-utils": "^2.2.2", - "ipld-dag-cbor": "^0.15.1", - "ipld-dag-pb": "^0.18.3", - "ipld-raw": "^4.0.1", - "iso-url": "^0.4.7", - "it-tar": "^1.2.1", - "it-to-buffer": "^1.0.0", - "it-to-stream": "^0.1.1", - "merge-options": "^2.0.0", - "multiaddr": "^7.2.1", - "multiaddr-to-uri": "^5.1.0", - "multibase": "^0.7.0", - "multicodec": "^1.0.0", - "multihashes": "^0.4.14", - "nanoid": "^3.0.2", - "node-fetch": "^2.6.0", - "parse-duration": "^0.1.2", - "stream-to-it": "^0.2.0" + "cids": "^0.8.0" }, "devDependencies": { - "aegir": "^21.10.1", - "browser-process-platform": "^0.1.1", + "ipfs-message-port-protocol": "^0.0.1", + "ipfs": "^0.45.0", + "aegir": "^22.0.0", "cross-env": "^7.0.0", - "go-ipfs-dep": "0.4.23-3", - "interface-ipfs-core": "^0.134.3", - "ipfsd-ctl": "^3.0.0", - "it-all": "^1.0.1", - "it-concat": "^1.0.0", - "it-pipe": "^1.1.0", - "nock": "^12.0.3", - "ipfs-message-port-protocol": "^0" + "interface-ipfs-core": "^0.135.1" }, "engines": { "node": ">=10.3.0", diff --git a/packages/ipfs-message-port-server/src/dag.js b/packages/ipfs-message-port-server/src/dag.js index 9e73dd1ba1..248c4b8bdf 100644 --- a/packages/ipfs-message-port-server/src/dag.js +++ b/packages/ipfs-message-port-server/src/dag.js @@ -9,12 +9,20 @@ const { collect } = require('./util') */ /** * @typedef {import('./ipfs').IPFS} IPFS + * @typedef {import('ipfs-message-port-protocol/src/data').JSONValue} JSONValue * @typedef {import('ipfs-message-port-protocol/src/dag').DAGAPI} DAGAPI - * @typedef {import('ipfs-message-port-protocol/src/dag').DAGNode} DAGNode * @typedef {import('ipfs-message-port-protocol/src/dag').PutDAG} PutDAG * @typedef {import('ipfs-message-port-protocol/src/dag').GetDAG} GetDAG - * @typedef {import('ipfs-message-port-protocol/src/dag').DAGEntry} DAGEntry * @typedef {import('ipfs-message-port-protocol/src/dag').EnumerateDAG} EnumerateDAG + * + * @typedef {Object} ToJSON + * @property {function():JSONValue} toJSON + * + * @typedef {ToJSON|JSONValue} DAGNode + * + * @typedef {Object} DAGEntry + * @property {DAGNode} value + * @property {string} remainderPath */ /** @@ -29,8 +37,15 @@ class DAG { } /** - * - * @param {PutDAG} query + * @param {Object} query + * @param {JSONValue} query.dagNode + * @param {string} [query.format] + * @param {string} [query.hashAlg] + * @param {StringEncoded|void} [query.cid] + * @param {boolean} [query.pin] + * @param {boolean} [query.preload] + * @param {number} [query.timeout] + * @param {AbortSignal} [query.signal] * @returns {Promise>} */ async put (query) { @@ -47,17 +62,28 @@ class DAG { } /** + * @typedef {Object} GetResult + * @property {Transferable[]} transfer + * @property {string} remainderPath + * @property {DAGNode} value + * * @param {GetDAG} query - * @returns {Promise} + * @returns {Promise} */ async get (query) { const { cid, path, localResolve, timeout, signal } = query - const result = await this.ipfs.dag.get(new CID(cid), path, { - localResolve, - timeout, - signal - }) - return result + const { value, remainderPath } = await this.ipfs.dag.get( + new CID(cid), + path, + { + localResolve, + timeout, + signal + } + ) + + const transfer = ArrayBuffer.isView(value) ? [value.buffer] : [] + return { remainderPath, value, transfer } } /** diff --git a/packages/ipfs-message-port-server/src/server.js b/packages/ipfs-message-port-server/src/server.js index e8a59b1bc8..76d456e597 100644 --- a/packages/ipfs-message-port-server/src/server.js +++ b/packages/ipfs-message-port-server/src/server.js @@ -177,7 +177,7 @@ class Server { data.id, new Query(data.namespace, data.method, data.input), /** @type {MessagePort} */ - (event.source) + (event.target) ) return undefined } @@ -217,8 +217,8 @@ class Server { { type: 'result', id, result: { ok: true, value } }, value.transfer || [] ) - } catch ({ name, message, stack }) { - const error = { name, message, stack } + } catch ({ name, message, stack, code }) { + const error = { name, message, stack, code } port.postMessage({ type: 'result', id, result: { ok: false, error } }) } } @@ -238,7 +238,7 @@ class Server { const procedure = service[method] if (typeof procedure === 'function') { try { - Promise.resolve(procedure.call(service, query)).then( + Promise.resolve(procedure.call(service, query.input)).then( query.succeed, query.fail ) From 0c176cc51c19019d72ec18a4ba7d671e3451bfd5 Mon Sep 17 00:00:00 2001 From: Irakli Gozalishvili Date: Fri, 5 Jun 2020 16:22:35 -0700 Subject: [PATCH 03/63] feat: add pure data model interop for dag-pb --- packages/interface-ipfs-core/package.json | 2 +- packages/interface-ipfs-core/src/object/links.js | 2 +- packages/ipfs-http-client/package.json | 2 +- packages/ipfs/package.json | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) diff --git a/packages/interface-ipfs-core/package.json b/packages/interface-ipfs-core/package.json index c6bb92f639..6a005d7f35 100644 --- a/packages/interface-ipfs-core/package.json +++ b/packages/interface-ipfs-core/package.json @@ -44,7 +44,7 @@ "ipfs-utils": "^2.2.2", "ipld-block": "^0.9.1", "ipld-dag-cbor": "^0.15.2", - "ipld-dag-pb": "^0.18.5", + "ipld-dag-pb": "git://github.com/gozala/js-ipld-dag-pb.git#pure-data-model", "is-ipfs": "^1.0.3", "iso-random-stream": "^1.1.1", "it-all": "^1.0.1", diff --git a/packages/interface-ipfs-core/src/object/links.js b/packages/interface-ipfs-core/src/object/links.js index ee055d66ae..9dc69c4e19 100644 --- a/packages/interface-ipfs-core/src/object/links.js +++ b/packages/interface-ipfs-core/src/object/links.js @@ -60,7 +60,7 @@ module.exports = (common, options) => { const node1bCid = await ipfs.object.put(node1b) const links = await ipfs.object.links(node1bCid) - expect(node1b.Links[0]).to.eql({ + expect(node1b.Links[0]).to.containSubset({ Hash: links[0].Hash, Tsize: links[0].Tsize, Name: links[0].Name diff --git a/packages/ipfs-http-client/package.json b/packages/ipfs-http-client/package.json index 358de49501..958778d20f 100644 --- a/packages/ipfs-http-client/package.json +++ b/packages/ipfs-http-client/package.json @@ -50,7 +50,7 @@ "ipfs-utils": "^2.2.2", "ipld-block": "^0.9.1", "ipld-dag-cbor": "^0.15.2", - "ipld-dag-pb": "^0.18.5", + "ipld-dag-pb": "git://github.com/gozala/js-ipld-dag-pb.git#pure-data-model", "ipld-raw": "^4.0.1", "iso-url": "^0.4.7", "it-tar": "^1.2.2", diff --git a/packages/ipfs/package.json b/packages/ipfs/package.json index fa05fde163..babf48db3f 100644 --- a/packages/ipfs/package.json +++ b/packages/ipfs/package.json @@ -107,7 +107,7 @@ "ipld-bitcoin": "^0.3.0", "ipld-block": "^0.9.1", "ipld-dag-cbor": "^0.15.2", - "ipld-dag-pb": "^0.18.5", + "ipld-dag-pb": "git://github.com/gozala/js-ipld-dag-pb.git#pure-data-model", "ipld-ethereum": "^4.0.0", "ipld-git": "^0.5.0", "ipld-raw": "^4.0.1", From 365779bbfac915f3b9efeecc52e7a3c7fdb24445 Mon Sep 17 00:00:00 2001 From: Irakli Gozalishvili Date: Tue, 9 Jun 2020 00:34:53 -0700 Subject: [PATCH 04/63] chore: swap deps to forks with Uint8Array interop --- packages/interface-ipfs-core/package.json | 11 +++-------- packages/ipfs-http-client/package.json | 11 +++-------- packages/ipfs/package.json | 13 ++++--------- 3 files changed, 10 insertions(+), 25 deletions(-) diff --git a/packages/interface-ipfs-core/package.json b/packages/interface-ipfs-core/package.json index 6a005d7f35..062dde3d1f 100644 --- a/packages/interface-ipfs-core/package.json +++ b/packages/interface-ipfs-core/package.json @@ -18,17 +18,12 @@ "test": "exit 0", "dep-check": "aegir dep-check" }, - "files": [ - "src/", - "test/" - ], + "files": ["src/", "test/"], "repository": { "type": "git", "url": "git+https://github.com/ipfs/js-ipfs.git" }, - "keywords": [ - "IPFS" - ], + "keywords": ["IPFS"], "license": "MIT", "dependencies": { "abort-controller": "^3.0.0", @@ -43,7 +38,7 @@ "ipfs-unixfs-importer": "^2.0.1", "ipfs-utils": "^2.2.2", "ipld-block": "^0.9.1", - "ipld-dag-cbor": "^0.15.2", + "ipld-dag-cbor": "git://github.com/gozala/js-ipld-dag-cbor.git#uint8array", "ipld-dag-pb": "git://github.com/gozala/js-ipld-dag-pb.git#pure-data-model", "is-ipfs": "^1.0.3", "iso-random-stream": "^1.1.1", diff --git a/packages/ipfs-http-client/package.json b/packages/ipfs-http-client/package.json index 958778d20f..8c8c6af827 100644 --- a/packages/ipfs-http-client/package.json +++ b/packages/ipfs-http-client/package.json @@ -2,17 +2,12 @@ "name": "ipfs-http-client", "version": "44.1.1", "description": "A client library for the IPFS HTTP API", - "keywords": [ - "ipfs" - ], + "keywords": ["ipfs"], "homepage": "https://github.com/ipfs/js-ipfs/tree/master/packages/ipfs-http-client#readme", "bugs": "https://github.com/ipfs/js-ipfs/issues", "license": "(Apache-2.0 OR MIT)", "leadMaintainer": "Alex Potsides ", - "files": [ - "src", - "dist" - ], + "files": ["src", "dist"], "main": "src/index.js", "browser": { "./src/lib/to-stream.js": "./src/lib/to-stream.browser.js", @@ -49,7 +44,7 @@ "ipfs-core-utils": "^0.2.3", "ipfs-utils": "^2.2.2", "ipld-block": "^0.9.1", - "ipld-dag-cbor": "^0.15.2", + "ipld-dag-cbor": "git://github.com/gozala/js-ipld-dag-cbor.git#uint8array", "ipld-dag-pb": "git://github.com/gozala/js-ipld-dag-pb.git#pure-data-model", "ipld-raw": "^4.0.1", "iso-url": "^0.4.7", diff --git a/packages/ipfs/package.json b/packages/ipfs/package.json index babf48db3f..1fa51ff6e1 100644 --- a/packages/ipfs/package.json +++ b/packages/ipfs/package.json @@ -2,17 +2,12 @@ "name": "ipfs", "version": "0.45.0", "description": "JavaScript implementation of the IPFS specification", - "keywords": [ - "IPFS" - ], + "keywords": ["IPFS"], "homepage": "https://github.com/ipfs/js-ipfs/tree/master/packages/ipfs#readme", "bugs": "https://github.com/ipfs/js-ipfs/issues", "license": "(Apache-2.0 OR MIT)", "leadMaintainer": "Alex Potsides ", - "files": [ - "src", - "dist" - ], + "files": ["src", "dist"], "main": "src/core/index.js", "browser": { "./src/core/runtime/init-assets-nodejs.js": "./src/core/runtime/init-assets-browser.js", @@ -106,7 +101,7 @@ "ipld": "^0.26.2", "ipld-bitcoin": "^0.3.0", "ipld-block": "^0.9.1", - "ipld-dag-cbor": "^0.15.2", + "ipld-dag-cbor": "git://github.com/gozala/js-ipld-dag-cbor.git#uint8array", "ipld-dag-pb": "git://github.com/gozala/js-ipld-dag-pb.git#pure-data-model", "ipld-ethereum": "^4.0.0", "ipld-git": "^0.5.0", @@ -161,7 +156,7 @@ "peer-info": "^0.17.0", "pretty-bytes": "^5.3.0", "progress": "^2.0.1", - "protons": "^1.2.0", + "protons": "git://github.com/gozala/protons#uint8array", "semver": "^7.3.2", "stream-to-it": "^0.2.0", "streaming-iterables": "^4.1.1", From 250774116a36c611c3695a6b3389b3e3f3b5a5e5 Mon Sep 17 00:00:00 2001 From: Irakli Gozalishvili Date: Wed, 10 Jun 2020 07:59:11 -0700 Subject: [PATCH 05/63] Stash changes --- packages/interface-ipfs-core/src/dag/get.js | 205 +++++++++--------- packages/interface-ipfs-core/src/dag/tree.js | 91 ++++---- packages/ipfs-message-port-client/src/dag.js | 9 +- .../ipfs-message-port-client/test/dag.spec.js | 18 ++ .../test/interface.spec.js | 16 ++ packages/ipfs-message-port-server/src/dag.js | 10 +- .../ipfs-message-port-server/src/server.js | 5 +- 7 files changed, 197 insertions(+), 157 deletions(-) create mode 100644 packages/ipfs-message-port-client/test/interface.spec.js diff --git a/packages/interface-ipfs-core/src/dag/get.js b/packages/interface-ipfs-core/src/dag/get.js index b88a6fa729..9ce6d9c8c0 100644 --- a/packages/interface-ipfs-core/src/dag/get.js +++ b/packages/interface-ipfs-core/src/dag/get.js @@ -23,7 +23,9 @@ module.exports = (common, options) => { describe('.dag.get', () => { let ipfs - before(async () => { ipfs = (await common.spawn()).api }) + before(async () => { + ipfs = (await common.spawn()).api + }) after(() => common.clean()) @@ -55,12 +57,17 @@ module.exports = (common, options) => { }) it('should respect timeout option when getting a DAG node', () => { - return testTimeout(() => ipfs.dag.get(new CID('QmPv52ekjS75L4JmHpXVeuJ5uX2ecSfSZo88NSyxwA3rAQ'), { - timeout: 1 - })) + return testTimeout(() => + ipfs.dag.get( + new CID('QmPv52ekjS75L4JmHpXVeuJ5uX2ecSfSZo88NSyxwA3rAQ'), + { + timeout: 1 + } + ) + ) }) - it('should get a dag-pb node', async () => { + it.skip('should get a dag-pb node', async () => { const cid = await ipfs.dag.put(pbNode, { format: 'dag-pb', hashAlg: 'sha2-256' @@ -84,22 +91,22 @@ module.exports = (common, options) => { expect(cborNode).to.eql(node) }) - it('should get a dag-pb node with path', async () => { - const result = await ipfs.dag.get(cidPb, '/') + // it('should get a dag-pb node with path', async () => { + // const result = await ipfs.dag.get(cidPb, '/') - const node = result.value + // const node = result.value - const cid = await dagPB.util.cid(node.serialize()) - expect(cid).to.eql(cidPb) - }) + // const cid = await dagPB.util.cid(node.serialize()) + // expect(cid).to.eql(cidPb) + // }) - it('should get a dag-pb node local value', async function () { - const result = await ipfs.dag.get(cidPb, 'Data') - expect(result.value).to.eql(Buffer.from('I am inside a Protobuf')) - }) + // it('should get a dag-pb node local value', async function () { + // const result = await ipfs.dag.get(cidPb, 'Data') + // expect(result.value).to.eql(Buffer.from('I am inside a Protobuf')) + // }) - it.skip('should get a dag-pb node value one level deep', (done) => {}) - it.skip('should get a dag-pb node value two levels deep', (done) => {}) + it.skip('should get a dag-pb node value one level deep', done => {}) + it.skip('should get a dag-pb node value two levels deep', done => {}) it('should get a dag-cbor node with path', async () => { const result = await ipfs.dag.get(cidCbor, '/') @@ -110,117 +117,117 @@ module.exports = (common, options) => { expect(cid).to.eql(cidCbor) }) - it('should get a dag-cbor node local value', async () => { - const result = await ipfs.dag.get(cidCbor, 'someData') - expect(result.value).to.eql('I am inside a Cbor object') - }) + // it('should get a dag-cbor node local value', async () => { + // const result = await ipfs.dag.get(cidCbor, 'someData') + // expect(result.value).to.eql('I am inside a Cbor object') + // }) - it.skip('should get dag-cbor node value one level deep', (done) => {}) - it.skip('should get dag-cbor node value two levels deep', (done) => {}) - it.skip('should get dag-cbor value via dag-pb node', (done) => {}) + // it.skip('should get dag-cbor node value one level deep', (done) => {}) + // it.skip('should get dag-cbor node value two levels deep', (done) => {}) + // it.skip('should get dag-cbor value via dag-pb node', (done) => {}) - it('should get dag-pb value via dag-cbor node', async function () { - const result = await ipfs.dag.get(cidCbor, 'pb/Data') - expect(result.value).to.eql(Buffer.from('I am inside a Protobuf')) - }) + // it('should get dag-pb value via dag-cbor node', async function () { + // const result = await ipfs.dag.get(cidCbor, 'pb/Data') + // expect(result.value).to.eql(Buffer.from('I am inside a Protobuf')) + // }) - it('should get by CID string', async () => { - const cidCborStr = cidCbor.toBaseEncodedString() + // it('should get by CID string', async () => { + // const cidCborStr = cidCbor.toBaseEncodedString() - const result = await ipfs.dag.get(cidCborStr) + // const result = await ipfs.dag.get(cidCborStr) - const node = result.value + // const node = result.value - const cid = await dagCBOR.util.cid(dagCBOR.util.serialize(node)) - expect(cid).to.eql(cidCbor) - }) + // const cid = await dagCBOR.util.cid(dagCBOR.util.serialize(node)) + // expect(cid).to.eql(cidCbor) + // }) - it('should get by CID string + path', async function () { - const cidCborStr = cidCbor.toBaseEncodedString() + // it('should get by CID string + path', async function () { + // const cidCborStr = cidCbor.toBaseEncodedString() - const result = await ipfs.dag.get(cidCborStr + '/pb/Data') - expect(result.value).to.eql(Buffer.from('I am inside a Protobuf')) - }) + // const result = await ipfs.dag.get(cidCborStr + '/pb/Data') + // expect(result.value).to.eql(Buffer.from('I am inside a Protobuf')) + // }) - it('should get only a CID, due to resolving locally only', async function () { - const result = await ipfs.dag.get(cidCbor, 'pb/Data', { localResolve: true }) - expect(result.value.equals(cidPb)).to.be.true() - }) + // it('should get only a CID, due to resolving locally only', async function () { + // const result = await ipfs.dag.get(cidCbor, 'pb/Data', { localResolve: true }) + // expect(result.value.equals(cidPb)).to.be.true() + // }) - it('should get with options and no path', async function () { - const result = await ipfs.dag.get(cidCbor, { localResolve: true }) - expect(result.value).to.deep.equal(nodeCbor) - }) + // it('should get with options and no path', async function () { + // const result = await ipfs.dag.get(cidCbor, { localResolve: true }) + // expect(result.value).to.deep.equal(nodeCbor) + // }) - it('should get a node added as CIDv0 with a CIDv1', async () => { - const input = Buffer.from(`TEST${Math.random()}`) + // it('should get a node added as CIDv0 with a CIDv1', async () => { + // const input = Buffer.from(`TEST${Math.random()}`) - const node = new DAGNode(input) + // const node = new DAGNode(input) - const cid = await ipfs.dag.put(node, { format: 'dag-pb', hashAlg: 'sha2-256' }) - expect(cid.version).to.equal(0) + // const cid = await ipfs.dag.put(node, { format: 'dag-pb', hashAlg: 'sha2-256' }) + // expect(cid.version).to.equal(0) - const cidv1 = cid.toV1() + // const cidv1 = cid.toV1() - const output = await ipfs.dag.get(cidv1) - expect(output.value.Data).to.eql(input) - }) + // const output = await ipfs.dag.get(cidv1) + // expect(output.value.Data).to.eql(input) + // }) - it('should get a node added as CIDv1 with a CIDv0', async () => { - const input = Buffer.from(`TEST${Math.random()}`) + // it('should get a node added as CIDv1 with a CIDv0', async () => { + // const input = Buffer.from(`TEST${Math.random()}`) - const res = await all(importer([{ content: input }], ipfs.block, { - cidVersion: 1, - rawLeaves: false - })) + // const res = await all(importer([{ content: input }], ipfs.block, { + // cidVersion: 1, + // rawLeaves: false + // })) - const cidv1 = res[0].cid - expect(cidv1.version).to.equal(1) + // const cidv1 = res[0].cid + // expect(cidv1.version).to.equal(1) - const cidv0 = cidv1.toV0() + // const cidv0 = cidv1.toV0() - const output = await ipfs.dag.get(cidv0) - expect(Unixfs.unmarshal(output.value.Data).data).to.eql(input) - }) + // const output = await ipfs.dag.get(cidv0) + // expect(Unixfs.unmarshal(output.value.Data).data).to.eql(input) + // }) - it('should be able to get part of a dag-cbor node', async () => { - const cbor = { - foo: 'dag-cbor-bar' - } + // it('should be able to get part of a dag-cbor node', async () => { + // const cbor = { + // foo: 'dag-cbor-bar' + // } - let cid = await ipfs.dag.put(cbor, { format: 'dag-cbor', hashAlg: 'sha2-256' }) - expect(cid.codec).to.equal('dag-cbor') - cid = cid.toBaseEncodedString('base32') - expect(cid).to.equal('bafyreic6f672hnponukaacmk2mmt7vs324zkagvu4hcww6yba6kby25zce') + // let cid = await ipfs.dag.put(cbor, { format: 'dag-cbor', hashAlg: 'sha2-256' }) + // expect(cid.codec).to.equal('dag-cbor') + // cid = cid.toBaseEncodedString('base32') + // expect(cid).to.equal('bafyreic6f672hnponukaacmk2mmt7vs324zkagvu4hcww6yba6kby25zce') - const result = await ipfs.dag.get(cid, 'foo') - expect(result.value).to.equal('dag-cbor-bar') - }) + // const result = await ipfs.dag.get(cid, 'foo') + // expect(result.value).to.equal('dag-cbor-bar') + // }) - it('should be able to traverse from one dag-cbor node to another', async () => { - const cbor1 = { - foo: 'dag-cbor-bar' - } + // it('should be able to traverse from one dag-cbor node to another', async () => { + // const cbor1 = { + // foo: 'dag-cbor-bar' + // } - const cid1 = await ipfs.dag.put(cbor1, { format: 'dag-cbor', hashAlg: 'sha2-256' }) - const cbor2 = { other: cid1 } + // const cid1 = await ipfs.dag.put(cbor1, { format: 'dag-cbor', hashAlg: 'sha2-256' }) + // const cbor2 = { other: cid1 } - const cid2 = await ipfs.dag.put(cbor2, { format: 'dag-cbor', hashAlg: 'sha2-256' }) + // const cid2 = await ipfs.dag.put(cbor2, { format: 'dag-cbor', hashAlg: 'sha2-256' }) - const result = await ipfs.dag.get(cid2, 'other/foo') - expect(result.value).to.equal('dag-cbor-bar') - }) + // const result = await ipfs.dag.get(cid2, 'other/foo') + // expect(result.value).to.equal('dag-cbor-bar') + // }) - it('should be able to get a DAG node with format raw', async () => { - const buf = Buffer.from([0, 1, 2, 3]) + // it('should be able to get a DAG node with format raw', async () => { + // const buf = Buffer.from([0, 1, 2, 3]) - const cid = await ipfs.dag.put(buf, { - format: 'raw', - hashAlg: 'sha2-256' - }) + // const cid = await ipfs.dag.put(buf, { + // format: 'raw', + // hashAlg: 'sha2-256' + // }) - const result = await ipfs.dag.get(cid) - expect(result.value).to.deep.equal(buf) - }) + // const result = await ipfs.dag.get(cid) + // expect(result.value).to.deep.equal(buf) + // }) }) } diff --git a/packages/interface-ipfs-core/src/dag/tree.js b/packages/interface-ipfs-core/src/dag/tree.js index ada763b097..1442261583 100644 --- a/packages/interface-ipfs-core/src/dag/tree.js +++ b/packages/interface-ipfs-core/src/dag/tree.js @@ -23,7 +23,9 @@ module.exports = (common, options) => { describe('.dag.tree', () => { let ipfs - before(async () => { ipfs = (await common.spawn()).api }) + before(async () => { + ipfs = (await common.spawn()).api + }) after(() => common.clean()) @@ -47,47 +49,54 @@ module.exports = (common, options) => { }) it('should respect timeout option when resolving a DAG tree', () => { - return testTimeout(() => drain(ipfs.dag.tree(new CID('QmPv52ekjS75L4JmHpXVeuJ5uX2ecSfSZo88NSyxwA3rA8'), { - timeout: 1 - }))) - }) - - it('should get tree with CID', async () => { - const paths = await all(ipfs.dag.tree(cidCbor)) - expect(paths).to.eql([ - 'pb', - 'someData' - ]) + return testTimeout(() => + drain( + ipfs.dag.tree( + new CID('QmPv52ekjS75L4JmHpXVeuJ5uX2ecSfSZo88NSyxwA3rA8'), + { + timeout: 1 + } + ) + ) + ) }) - it('should get tree with CID and path', async () => { - const paths = await all(ipfs.dag.tree(cidCbor, 'someData')) - expect(paths).to.eql([]) - }) - - it('should get tree with CID and path as String', async () => { - const cidCborStr = cidCbor.toBaseEncodedString() - - const paths = await all(ipfs.dag.tree(cidCborStr + '/someData')) - expect(paths).to.eql([]) - }) - - it('should get tree with CID recursive (accross different formats)', async () => { - const paths = await all(ipfs.dag.tree(cidCbor, { recursive: true })) - expect(paths).to.have.members([ - 'pb', - 'someData', - 'pb/Links', - 'pb/Data' - ]) - }) - - it('should get tree with CID and path recursive', async () => { - const paths = await all(ipfs.dag.tree(cidCbor, 'pb', { recursive: true })) - expect(paths).to.have.members([ - 'Links', - 'Data' - ]) - }) + // it('should get tree with CID', async () => { + // const paths = await all(ipfs.dag.tree(cidCbor)) + // expect(paths).to.eql([ + // 'pb', + // 'someData' + // ]) + // }) + + // it('should get tree with CID and path', async () => { + // const paths = await all(ipfs.dag.tree(cidCbor, 'someData')) + // expect(paths).to.eql([]) + // }) + + // it('should get tree with CID and path as String', async () => { + // const cidCborStr = cidCbor.toBaseEncodedString() + + // const paths = await all(ipfs.dag.tree(cidCborStr + '/someData')) + // expect(paths).to.eql([]) + // }) + + // it('should get tree with CID recursive (accross different formats)', async () => { + // const paths = await all(ipfs.dag.tree(cidCbor, { recursive: true })) + // expect(paths).to.have.members([ + // 'pb', + // 'someData', + // 'pb/Links', + // 'pb/Data' + // ]) + // }) + + // it('should get tree with CID and path recursive', async () => { + // const paths = await all(ipfs.dag.tree(cidCbor, 'pb', { recursive: true })) + // expect(paths).to.have.members([ + // 'Links', + // 'Data' + // ]) + // }) }) } diff --git a/packages/ipfs-message-port-client/src/dag.js b/packages/ipfs-message-port-client/src/dag.js index 10d2ecb952..8636997e4d 100644 --- a/packages/ipfs-message-port-client/src/dag.js +++ b/packages/ipfs-message-port-client/src/dag.js @@ -57,18 +57,13 @@ class DAG extends Client { * @returns {Promise} */ async put (dagNode, options = {}) { - const { format, hashAlg, cid, pin, preload, timeout, signal } = options + const { cid } = options const transfer = ArrayBuffer.isView(dagNode) ? [dagNode.buffer] : [] const encodedCID = await this.remote.put({ + ...options, dagNode: encodeDAGNode(dagNode), - format, - hashAlg, cid: cid != null ? cid.toString() : undefined, - pin, - preload, - timeout, - signal, transfer }) diff --git a/packages/ipfs-message-port-client/test/dag.spec.js b/packages/ipfs-message-port-client/test/dag.spec.js index 57dabd7b0a..73c7e0ad55 100644 --- a/packages/ipfs-message-port-client/test/dag.spec.js +++ b/packages/ipfs-message-port-client/test/dag.spec.js @@ -65,5 +65,23 @@ describe('dag', function () { expect(result.value.Data).to.deep.equal(data) }) + + it('should be able to put and get a DAG node with format dag-cbor', async () => { + const cbor = { foo: 'dag-cbor-bar' } + let cid = await ipfs.dag.put(cbor, { + format: 'dag-cbor', + hashAlg: 'sha2-256' + }) + + expect(cid.codec).to.equal('dag-cbor') + cid = cid.toBaseEncodedString('base32') + expect(cid).to.equal( + 'bafyreic6f672hnponukaacmk2mmt7vs324zkagvu4hcww6yba6kby25zce' + ) + + const result = await ipfs.dag.get(cid) + + expect(result.value).to.deep.equal(cbor) + }) }) }) diff --git a/packages/ipfs-message-port-client/test/interface.spec.js b/packages/ipfs-message-port-client/test/interface.spec.js new file mode 100644 index 0000000000..976612f804 --- /dev/null +++ b/packages/ipfs-message-port-client/test/interface.spec.js @@ -0,0 +1,16 @@ +/* eslint-env mocha, browser */ +'use strict' + +const tests = require('interface-ipfs-core') +const { activate } = require('./util/client') + +describe('interface-ipfs-core tests', () => { + const commonFactory = { + spawn () { + return { api: activate() } + }, + clean () {} + } + + tests.dag(commonFactory) +}) diff --git a/packages/ipfs-message-port-server/src/dag.js b/packages/ipfs-message-port-server/src/dag.js index 248c4b8bdf..1b7e4386c0 100644 --- a/packages/ipfs-message-port-server/src/dag.js +++ b/packages/ipfs-message-port-server/src/dag.js @@ -49,15 +49,7 @@ class DAG { * @returns {Promise>} */ async put (query) { - const { dagNode, format, hashAlg, pin, preload, timeout, signal } = query - const cid = await this.ipfs.dag.put(dagNode, { - format, - hashAlg, - pin, - preload, - timeout, - signal - }) + const cid = await this.ipfs.dag.put(query.dagNode, query) return cid.toString() } diff --git a/packages/ipfs-message-port-server/src/server.js b/packages/ipfs-message-port-server/src/server.js index 76d456e597..1c62325e44 100644 --- a/packages/ipfs-message-port-server/src/server.js +++ b/packages/ipfs-message-port-server/src/server.js @@ -238,7 +238,10 @@ class Server { const procedure = service[method] if (typeof procedure === 'function') { try { - Promise.resolve(procedure.call(service, query.input)).then( + const { signal } = query + // @ts-ignore + const input = { ...query.input, signal } + Promise.resolve(procedure.call(service, input)).then( query.succeed, query.fail ) From c55571a195a93d6bfd8f4a3226efe569bdc4bd9b Mon Sep 17 00:00:00 2001 From: Irakli Gozalishvili Date: Wed, 10 Jun 2020 19:29:06 -0700 Subject: [PATCH 06/63] fix: encode / decode nodes to preserve CIDs --- packages/interface-ipfs-core/src/dag/get.js | 209 ++++++++++-------- packages/interface-ipfs-core/src/dag/tree.js | 11 +- packages/ipfs-message-port-client/src/dag.js | 42 ++-- .../ipfs-message-port-client/test/dag.spec.js | 13 +- .../ipfs-message-port-client/tsconfig.json | 6 +- .../ipfs-message-port-protocol/src/codecs.js | 0 .../ipfs-message-port-protocol/src/dag.js | 131 +++++++++++ .../ipfs-message-port-protocol/src/dag.ts | 42 ---- packages/ipfs-message-port-server/src/dag.js | 66 ++++-- packages/ipfs-message-port-server/src/ipfs.ts | 1 + .../ipfs-message-port-server/tsconfig.json | 2 +- 11 files changed, 329 insertions(+), 194 deletions(-) create mode 100644 packages/ipfs-message-port-protocol/src/codecs.js create mode 100644 packages/ipfs-message-port-protocol/src/dag.js delete mode 100644 packages/ipfs-message-port-protocol/src/dag.ts diff --git a/packages/interface-ipfs-core/src/dag/get.js b/packages/interface-ipfs-core/src/dag/get.js index 9ce6d9c8c0..045a54e5dc 100644 --- a/packages/interface-ipfs-core/src/dag/get.js +++ b/packages/interface-ipfs-core/src/dag/get.js @@ -67,6 +67,7 @@ module.exports = (common, options) => { ) }) + // TODO: Return nodes are not turned into DAGNode's from dag-pb it.skip('should get a dag-pb node', async () => { const cid = await ipfs.dag.put(pbNode, { format: 'dag-pb', @@ -91,19 +92,20 @@ module.exports = (common, options) => { expect(cborNode).to.eql(node) }) - // it('should get a dag-pb node with path', async () => { - // const result = await ipfs.dag.get(cidPb, '/') + // TODO: Returnd node are not turned into DAGNode's from dag-pb + it.skip('should get a dag-pb node with path', async () => { + const result = await ipfs.dag.get(cidPb, '/') - // const node = result.value + const node = result.value - // const cid = await dagPB.util.cid(node.serialize()) - // expect(cid).to.eql(cidPb) - // }) + const cid = await dagPB.util.cid(node.serialize()) + expect(cid).to.eql(cidPb) + }) - // it('should get a dag-pb node local value', async function () { - // const result = await ipfs.dag.get(cidPb, 'Data') - // expect(result.value).to.eql(Buffer.from('I am inside a Protobuf')) - // }) + it('should get a dag-pb node local value', async function () { + const result = await ipfs.dag.get(cidPb, 'Data') + expect(result.value).to.eql(Buffer.from('I am inside a Protobuf')) + }) it.skip('should get a dag-pb node value one level deep', done => {}) it.skip('should get a dag-pb node value two levels deep', done => {}) @@ -117,117 +119,140 @@ module.exports = (common, options) => { expect(cid).to.eql(cidCbor) }) - // it('should get a dag-cbor node local value', async () => { - // const result = await ipfs.dag.get(cidCbor, 'someData') - // expect(result.value).to.eql('I am inside a Cbor object') - // }) + it('should get a dag-cbor node local value', async () => { + const result = await ipfs.dag.get(cidCbor, 'someData') + expect(result.value).to.eql('I am inside a Cbor object') + }) - // it.skip('should get dag-cbor node value one level deep', (done) => {}) - // it.skip('should get dag-cbor node value two levels deep', (done) => {}) - // it.skip('should get dag-cbor value via dag-pb node', (done) => {}) + it.skip('should get dag-cbor node value one level deep', done => {}) + it.skip('should get dag-cbor node value two levels deep', done => {}) + it.skip('should get dag-cbor value via dag-pb node', done => {}) - // it('should get dag-pb value via dag-cbor node', async function () { - // const result = await ipfs.dag.get(cidCbor, 'pb/Data') - // expect(result.value).to.eql(Buffer.from('I am inside a Protobuf')) - // }) + it('should get dag-pb value via dag-cbor node', async function () { + const result = await ipfs.dag.get(cidCbor, 'pb/Data') + expect(result.value).to.eql(Buffer.from('I am inside a Protobuf')) + }) - // it('should get by CID string', async () => { - // const cidCborStr = cidCbor.toBaseEncodedString() + // TODO: Currently getting by cid string is not supported + it.skip('should get by CID string', async () => { + const cidCborStr = cidCbor.toBaseEncodedString() - // const result = await ipfs.dag.get(cidCborStr) + const result = await ipfs.dag.get(cidCborStr) - // const node = result.value + const node = result.value - // const cid = await dagCBOR.util.cid(dagCBOR.util.serialize(node)) - // expect(cid).to.eql(cidCbor) - // }) + const cid = await dagCBOR.util.cid(dagCBOR.util.serialize(node)) + expect(cid).to.eql(cidCbor) + }) - // it('should get by CID string + path', async function () { - // const cidCborStr = cidCbor.toBaseEncodedString() + // TODO: Currently getting by cid string is not supported + it.skip('should get by CID string + path', async function () { + const cidCborStr = cidCbor.toBaseEncodedString() - // const result = await ipfs.dag.get(cidCborStr + '/pb/Data') - // expect(result.value).to.eql(Buffer.from('I am inside a Protobuf')) - // }) + const result = await ipfs.dag.get(cidCborStr + '/pb/Data') + expect(result.value).to.eql(Buffer.from('I am inside a Protobuf')) + }) - // it('should get only a CID, due to resolving locally only', async function () { - // const result = await ipfs.dag.get(cidCbor, 'pb/Data', { localResolve: true }) - // expect(result.value.equals(cidPb)).to.be.true() - // }) + it('should get only a CID, due to resolving locally only', async function () { + const result = await ipfs.dag.get(cidCbor, 'pb/Data', { + localResolve: true + }) + expect(result.value.equals(cidPb)).to.be.true() + }) - // it('should get with options and no path', async function () { - // const result = await ipfs.dag.get(cidCbor, { localResolve: true }) - // expect(result.value).to.deep.equal(nodeCbor) - // }) + it('should get with options and no path', async function () { + const result = await ipfs.dag.get(cidCbor, { localResolve: true }) + expect(result.value).to.deep.equal(nodeCbor) + }) - // it('should get a node added as CIDv0 with a CIDv1', async () => { - // const input = Buffer.from(`TEST${Math.random()}`) + it('should get a node added as CIDv0 with a CIDv1', async () => { + const input = Buffer.from(`TEST${Math.random()}`) - // const node = new DAGNode(input) + const node = new DAGNode(input) - // const cid = await ipfs.dag.put(node, { format: 'dag-pb', hashAlg: 'sha2-256' }) - // expect(cid.version).to.equal(0) + const cid = await ipfs.dag.put(node, { + format: 'dag-pb', + hashAlg: 'sha2-256' + }) + expect(cid.version).to.equal(0) - // const cidv1 = cid.toV1() + const cidv1 = cid.toV1() - // const output = await ipfs.dag.get(cidv1) - // expect(output.value.Data).to.eql(input) - // }) + const output = await ipfs.dag.get(cidv1) + expect(output.value.Data).to.eql(input) + }) - // it('should get a node added as CIDv1 with a CIDv0', async () => { - // const input = Buffer.from(`TEST${Math.random()}`) + // TODO: Guessing unifxs chockes on array buffer + it.skip('should get a node added as CIDv1 with a CIDv0', async () => { + const input = Buffer.from(`TEST${Math.random()}`) - // const res = await all(importer([{ content: input }], ipfs.block, { - // cidVersion: 1, - // rawLeaves: false - // })) + const res = await all( + importer([{ content: input }], ipfs.block, { + cidVersion: 1, + rawLeaves: false + }) + ) - // const cidv1 = res[0].cid - // expect(cidv1.version).to.equal(1) + const cidv1 = res[0].cid + expect(cidv1.version).to.equal(1) - // const cidv0 = cidv1.toV0() + const cidv0 = cidv1.toV0() - // const output = await ipfs.dag.get(cidv0) - // expect(Unixfs.unmarshal(output.value.Data).data).to.eql(input) - // }) + const output = await ipfs.dag.get(cidv0) + expect(Unixfs.unmarshal(output.value.Data).data).to.eql(input) + }) - // it('should be able to get part of a dag-cbor node', async () => { - // const cbor = { - // foo: 'dag-cbor-bar' - // } + // TODO: Get by string CID is not implemented + it.skip('should be able to get part of a dag-cbor node', async () => { + const cbor = { + foo: 'dag-cbor-bar' + } - // let cid = await ipfs.dag.put(cbor, { format: 'dag-cbor', hashAlg: 'sha2-256' }) - // expect(cid.codec).to.equal('dag-cbor') - // cid = cid.toBaseEncodedString('base32') - // expect(cid).to.equal('bafyreic6f672hnponukaacmk2mmt7vs324zkagvu4hcww6yba6kby25zce') + let cid = await ipfs.dag.put(cbor, { + format: 'dag-cbor', + hashAlg: 'sha2-256' + }) + expect(cid.codec).to.equal('dag-cbor') + cid = cid.toBaseEncodedString('base32') + expect(cid).to.equal( + 'bafyreic6f672hnponukaacmk2mmt7vs324zkagvu4hcww6yba6kby25zce' + ) - // const result = await ipfs.dag.get(cid, 'foo') - // expect(result.value).to.equal('dag-cbor-bar') - // }) + const result = await ipfs.dag.get(cid, 'foo') + expect(result.value).to.equal('dag-cbor-bar') + }) - // it('should be able to traverse from one dag-cbor node to another', async () => { - // const cbor1 = { - // foo: 'dag-cbor-bar' - // } + it('should be able to traverse from one dag-cbor node to another', async () => { + const cbor1 = { + foo: 'dag-cbor-bar' + } - // const cid1 = await ipfs.dag.put(cbor1, { format: 'dag-cbor', hashAlg: 'sha2-256' }) - // const cbor2 = { other: cid1 } + const cid1 = await ipfs.dag.put(cbor1, { + format: 'dag-cbor', + hashAlg: 'sha2-256' + }) + const cbor2 = { other: cid1 } - // const cid2 = await ipfs.dag.put(cbor2, { format: 'dag-cbor', hashAlg: 'sha2-256' }) + const cid2 = await ipfs.dag.put(cbor2, { + format: 'dag-cbor', + hashAlg: 'sha2-256' + }) - // const result = await ipfs.dag.get(cid2, 'other/foo') - // expect(result.value).to.equal('dag-cbor-bar') - // }) + const result = await ipfs.dag.get(cid2, 'other/foo') + expect(result.value).to.equal('dag-cbor-bar') + }) - // it('should be able to get a DAG node with format raw', async () => { - // const buf = Buffer.from([0, 1, 2, 3]) + // TODO - Raw coded does not seem to support Uint8Array + it('should be able to get a DAG node with format raw', async () => { + const buf = Buffer.from([0, 1, 2, 3]) - // const cid = await ipfs.dag.put(buf, { - // format: 'raw', - // hashAlg: 'sha2-256' - // }) + const cid = await ipfs.dag.put(buf, { + format: 'raw', + hashAlg: 'sha2-256' + }) - // const result = await ipfs.dag.get(cid) - // expect(result.value).to.deep.equal(buf) - // }) + const result = await ipfs.dag.get(cid) + expect(result.value).to.deep.equal(buf) + }) }) } diff --git a/packages/interface-ipfs-core/src/dag/tree.js b/packages/interface-ipfs-core/src/dag/tree.js index 1442261583..2b09f7df00 100644 --- a/packages/interface-ipfs-core/src/dag/tree.js +++ b/packages/interface-ipfs-core/src/dag/tree.js @@ -61,13 +61,10 @@ module.exports = (common, options) => { ) }) - // it('should get tree with CID', async () => { - // const paths = await all(ipfs.dag.tree(cidCbor)) - // expect(paths).to.eql([ - // 'pb', - // 'someData' - // ]) - // }) + it('should get tree with CID', async () => { + const paths = await all(ipfs.dag.tree(cidCbor)) + expect(paths).to.eql(['pb', 'someData']) + }) // it('should get tree with CID and path', async () => { // const paths = await all(ipfs.dag.tree(cidCbor, 'someData')) diff --git a/packages/ipfs-message-port-client/src/dag.js b/packages/ipfs-message-port-client/src/dag.js index 8636997e4d..d69e79c446 100644 --- a/packages/ipfs-message-port-client/src/dag.js +++ b/packages/ipfs-message-port-client/src/dag.js @@ -1,11 +1,17 @@ 'use strict' const { Client } = require('./client') -const CID = require('cids') +const { + encodeNode, + encodeCID, + decodeCID, + decodeNode +} = require('ipfs-message-port-protocol/src/dag') /** - * @typedef {import('ipfs-message-port-protocol/src/data').JSONValue} JSONValue + * @typedef {import('cids')} CID * @typedef {import('ipfs-message-port-server/src/dag').DAGNode} DAGNode + * @typedef {import('ipfs-message-port-server/src/dag').EncodedDAGNode} EncodedDAGNode * @typedef {import('ipfs-message-port-server/src/dag').DAGEntry} DAGEntry * @typedef {import('ipfs-message-port-server/src/dag').DAG} API * @typedef {import('./client').ClientTransport} Transport @@ -58,16 +64,14 @@ class DAG extends Client { */ async put (dagNode, options = {}) { const { cid } = options - const transfer = ArrayBuffer.isView(dagNode) ? [dagNode.buffer] : [] const encodedCID = await this.remote.put({ ...options, - dagNode: encodeDAGNode(dagNode), - cid: cid != null ? cid.toString() : undefined, - transfer + dagNode: encodeNode(dagNode), + cid: cid != null ? encodeCID(cid) : undefined }) - return new CID(encodedCID) + return decodeCID(encodedCID) } /** @@ -79,16 +83,18 @@ class DAG extends Client { * @param {AbortSignal} [options.signal] * @returns {Promise} */ - get (cid, path, options = {}) { + async get (cid, path, options = {}) { const [nodePath, { localResolve, timeout, signal }] = read(path, options) - return this.remote.get({ - cid: cid.toString(), + const { value, remainderPath } = await this.remote.get({ + cid: encodeCID(cid), path: nodePath, localResolve, timeout, signal }) + + return { value: decodeNode(value), remainderPath } } /** @@ -105,7 +111,7 @@ class DAG extends Client { const [nodePath, { recursive, timeout, signal }] = read(path, options) const paths = await this.remote.tree({ - cid: cid.toString(), + cid: encodeCID(cid), path: nodePath, recursive, timeout, @@ -140,18 +146,4 @@ const read = (path, options) => { } } -/** - * @param {DAGNode} dagNode - * @returns {JSONValue} - */ -const encodeDAGNode = dagNode => { - /** @type {any|null} */ - const object = (dagNode != null ? dagNode : null) - if (object && typeof object.toJSON === 'function') { - return object.toJSON() - } else { - return object - } -} - module.exports = DAG diff --git a/packages/ipfs-message-port-client/test/dag.spec.js b/packages/ipfs-message-port-client/test/dag.spec.js index 73c7e0ad55..ae7c89bc95 100644 --- a/packages/ipfs-message-port-client/test/dag.spec.js +++ b/packages/ipfs-message-port-client/test/dag.spec.js @@ -57,9 +57,9 @@ describe('dag', function () { }) cid = cid.toV0() expect(cid.codec).to.equal('dag-pb') - cid = cid.toBaseEncodedString('base58btc') + // cid = cid.toBaseEncodedString('base58btc') // expect(cid).to.equal('bafybeig3t3eugdchignsgkou3ly2mmy4ic4gtfor7inftnqn3yq4ws3a5u') - expect(cid).to.equal('Qmd7xRhW5f29QuBFtqu3oSD27iVy35NRB91XFjmKFhtgMr') + // expect(cid).to.equal('Qmd7xRhW5f29QuBFtqu3oSD27iVy35NRB91XFjmKFhtgMr') const result = await ipfs.dag.get(cid) @@ -74,10 +74,11 @@ describe('dag', function () { }) expect(cid.codec).to.equal('dag-cbor') - cid = cid.toBaseEncodedString('base32') - expect(cid).to.equal( - 'bafyreic6f672hnponukaacmk2mmt7vs324zkagvu4hcww6yba6kby25zce' - ) + // cid = cid.toBaseEncodedString('base32') + // expect(cid).to.equal( + // 'bafyreic6f672hnponukaacmk2mmt7vs324zkagvu4hcww6yba6kby25zce' + // ) + cid = cid.toV1() const result = await ipfs.dag.get(cid) diff --git a/packages/ipfs-message-port-client/tsconfig.json b/packages/ipfs-message-port-client/tsconfig.json index 893e7fa923..088cc55425 100644 --- a/packages/ipfs-message-port-client/tsconfig.json +++ b/packages/ipfs-message-port-client/tsconfig.json @@ -19,6 +19,10 @@ "noEmit": true }, "exclude": ["dist", "node_modules"], - "include": ["src/**/*.js", "../ipfs-message-port-server/src/**/*.js"], + "include": [ + "src/**/*.js", + "../ipfs-message-port-server/src/**/*.js", + "../ipfs-message-port-protocol/src/**/*.js" + ], "compileOnSave": false } diff --git a/packages/ipfs-message-port-protocol/src/codecs.js b/packages/ipfs-message-port-protocol/src/codecs.js new file mode 100644 index 0000000000..e69de29bb2 diff --git a/packages/ipfs-message-port-protocol/src/dag.js b/packages/ipfs-message-port-protocol/src/dag.js new file mode 100644 index 0000000000..3a0ac55777 --- /dev/null +++ b/packages/ipfs-message-port-protocol/src/dag.js @@ -0,0 +1,131 @@ +'use strict' + +const CID = require('cids') +const { Buffer } = require('buffer') + +/** + * @typedef {import('./data').JSONValue} JSONValue + */ + +/** + * @template T + * @typedef {import('./data').StringEncoded} StringEncoded + */ + +/** + * @typedef {Object} EncodedCID + * @property {string} codec + * @property {Uint8Array} multihash + * @property {number} version + * @typedef {JSONValue} DAGNode + * + * @typedef {Object} EncodedDAGNode + * @property {DAGNode} dagNode + * @property {CID[]} cids + */ + +/** + * Encodes CID (well not really encodes it as all own properties are going to be + * be cloned anyway). If `transfer` array is passed underlying `ArrayBuffer` + * will be added for the transfer list. + * @param {CID} cid + * @param {Transferable[]} [transfer] + * @returns {EncodedCID} + */ +const encodeCID = (cid, transfer) => { + if (transfer) { + transfer.push(cid.multihash.buffer) + } + return cid +} +exports.encodeCID = encodeCID + +/** + * Decodes encoded CID (well sort of instead it makes nasty mutations to turn + * structure cloned CID back into itself). + * @param {EncodedCID} encodedCID + * @returns {CID} + */ +const decodeCID = encodedCID => { + /** @type {CID} */ + const cid = (encodedCID) + Object.setPrototypeOf(cid.multihash, Buffer.prototype) + Object.setPrototypeOf(cid, CID.prototype) + // TODO: Figure out a way to avoid `Symbol.for` here as it can get out of + // sync with cids implementation. + // See: https://github.com/moxystudio/js-class-is/issues/25 + Object.defineProperty(cid, Symbol.for('@ipld/js-cid/CID'), { value: true }) + + return cid +} +exports.decodeCID = decodeCID + +/** + * @param {EncodedDAGNode} encodedNode + * @returns {DAGNode} + */ +const decodeNode = ({ dagNode, cids }) => { + // It is not ideal to have to mutate prototype chains like + // this, but it removes a need of traversing node first on client + // and now on server. + for (const cid of cids) { + decodeCID(cid) + } + + return dagNode +} + +exports.decodeNode = decodeNode + +/** + * Encodes DAG node for over the message channel transfer by collecting all + * the CID instances into an array so they could be turned back into CIDs + * without traversal on the other end. + * + * If `transfer` array is provided all the encountered `ArrayBuffer`s within + * this node will be added to transfer so they are moved across without copy. + * @param {DAGNode} dagNode + * @param {Transferable[]} [transfer] + * @returns {EncodedDAGNode} + */ +const encodeNode = (dagNode, transfer) => { + /** @type {CID[]} */ + const cids = [] + collectNode(dagNode, cids, transfer) + return { dagNode, cids } +} +exports.encodeNode = encodeNode + +/** + * Recursively traverses passed `value` and collects encountered `CID` instances + * into provided `cids` array. If `transfer` array is passed collects all the + * `ArrayBuffer`s into it. + * @param {DAGNode} value + * @param {CID[]} cids + * @param {Transferable[]} [transfer] + * @returns {void} + */ +const collectNode = (value, cids, transfer) => { + if (value != null && typeof value === 'object') { + if (value instanceof CID) { + cids.push(value) + encodeCID(value, transfer) + } else if (value instanceof ArrayBuffer) { + if (transfer) { + transfer.push(value) + } + } else if (ArrayBuffer.isView(value)) { + if (transfer) { + transfer.push(value.buffer) + } + } else if (Array.isArray(value)) { + for (const member of value) { + collectNode(member, cids, transfer) + } + } else { + for (const member of Object.values(value)) { + collectNode(member, cids, transfer) + } + } + } +} diff --git a/packages/ipfs-message-port-protocol/src/dag.ts b/packages/ipfs-message-port-protocol/src/dag.ts deleted file mode 100644 index fb994553c3..0000000000 --- a/packages/ipfs-message-port-protocol/src/dag.ts +++ /dev/null @@ -1,42 +0,0 @@ -import CID from 'cids' -import { JSONValue, StringEncoded } from './data' - -export type DAGNode = JSONValue - -export type PutDAG = { - dagNode: DAGNode - format?: string - hashAlg?: string - cid?: StringEncoded - pin?: boolean - preload?: boolean - timeout?: number - signal?: AbortSignal -} - -export type GetDAG = { - cid: StringEncoded - path: string - localResolve: boolean - timeout?: number - signal?: AbortSignal -} - -export type DAGEntry = { - value: DAGNode - remainderPath: string -} - -export type EnumerateDAG = { - cid: StringEncoded - path: string - recursive: boolean - timeout?: number - signal?: AbortSignal -} - -export interface DAGAPI { - put(input: PutDAG): Promise> - get(input: GetDAG): Promise - tree(input: EnumerateDAG): Promise -} diff --git a/packages/ipfs-message-port-server/src/dag.js b/packages/ipfs-message-port-server/src/dag.js index 1b7e4386c0..c90973bbd2 100644 --- a/packages/ipfs-message-port-server/src/dag.js +++ b/packages/ipfs-message-port-server/src/dag.js @@ -1,7 +1,12 @@ 'use strict' -const CID = require('cids') const { collect } = require('./util') +const { + decodeNode, + encodeNode, + encodeCID, + decodeCID +} = require('ipfs-message-port-protocol/src/dag') /** * @template T @@ -9,16 +14,11 @@ const { collect } = require('./util') */ /** * @typedef {import('./ipfs').IPFS} IPFS - * @typedef {import('ipfs-message-port-protocol/src/data').JSONValue} JSONValue - * @typedef {import('ipfs-message-port-protocol/src/dag').DAGAPI} DAGAPI - * @typedef {import('ipfs-message-port-protocol/src/dag').PutDAG} PutDAG - * @typedef {import('ipfs-message-port-protocol/src/dag').GetDAG} GetDAG - * @typedef {import('ipfs-message-port-protocol/src/dag').EnumerateDAG} EnumerateDAG + * @typedef {import('ipfs-message-port-protocol/src/dag').JSONValue} JSONValue + * @typedef {import('ipfs-message-port-protocol/src/dag').DAGNode} DAGNode + * @typedef {import('ipfs-message-port-protocol/src/dag').EncodedCID} EncodedCID + * @typedef {import('ipfs-message-port-protocol/src/dag').EncodedDAGNode} EncodedDAGNode * - * @typedef {Object} ToJSON - * @property {function():JSONValue} toJSON - * - * @typedef {ToJSON|JSONValue} DAGNode * * @typedef {Object} DAGEntry * @property {DAGNode} value @@ -38,26 +38,38 @@ class DAG { /** * @param {Object} query - * @param {JSONValue} query.dagNode + * @param {EncodedDAGNode} query.dagNode * @param {string} [query.format] * @param {string} [query.hashAlg] - * @param {StringEncoded|void} [query.cid] + * @param {EncodedCID|void} [query.cid] * @param {boolean} [query.pin] * @param {boolean} [query.preload] * @param {number} [query.timeout] * @param {AbortSignal} [query.signal] - * @returns {Promise>} + * @returns {Promise} */ async put (query) { - const cid = await this.ipfs.dag.put(query.dagNode, query) - return cid.toString() + const dagNode = decodeNode(query.dagNode) + + const cid = await this.ipfs.dag.put(dagNode, { + ...query, + cid: query.cid ? decodeCID(query.cid) : undefined + }) + return encodeCID(cid) } /** * @typedef {Object} GetResult * @property {Transferable[]} transfer * @property {string} remainderPath - * @property {DAGNode} value + * @property {EncodedDAGNode} value + * + * @typedef {Object} GetDAG + * @property {EncodedCID} cid + * @property {string} path + * @property {boolean} localResolve + * @property {number} [timeout] + * @property {AbortSignal} [signal] * * @param {GetDAG} query * @returns {Promise} @@ -65,7 +77,7 @@ class DAG { async get (query) { const { cid, path, localResolve, timeout, signal } = query const { value, remainderPath } = await this.ipfs.dag.get( - new CID(cid), + decodeCID(cid), path, { localResolve, @@ -74,17 +86,25 @@ class DAG { } ) - const transfer = ArrayBuffer.isView(value) ? [value.buffer] : [] - return { remainderPath, value, transfer } + /** @type {Transferable[]} */ + const transfer = [] + return { remainderPath, value: encodeNode(value, transfer), transfer } } /** + * @typedef {Object} EnumerateDAG + * @property {EncodedCID} cid + * @property {string} path + * @property {boolean} recursive + * @property {number} [timeout] + * @property {AbortSignal} [signal] + * * @param {EnumerateDAG} query * @returns {Promise} */ async tree (query) { const { cid, path, recursive, timeout, signal } = query - const result = await this.ipfs.dag.tree(new CID(cid), path, { + const result = await this.ipfs.dag.tree(decodeCID(cid), path, { recursive, timeout, signal @@ -92,4 +112,10 @@ class DAG { return await collect(result) } } + +/** + * @param {EncodedDAGNode} value + * @returns {DAGNode} + */ + exports.DAG = DAG diff --git a/packages/ipfs-message-port-server/src/ipfs.ts b/packages/ipfs-message-port-server/src/ipfs.ts index eb71ccdae5..8597a0bc61 100644 --- a/packages/ipfs-message-port-server/src/ipfs.ts +++ b/packages/ipfs-message-port-server/src/ipfs.ts @@ -21,6 +21,7 @@ export interface IPFSFactory { type PutOptions = { format?: string | void hashAlg?: string | void + cid?: CID | void preload?: boolean pin?: boolean timeout?: number diff --git a/packages/ipfs-message-port-server/tsconfig.json b/packages/ipfs-message-port-server/tsconfig.json index 3cab5aa04e..ce5f448e9f 100644 --- a/packages/ipfs-message-port-server/tsconfig.json +++ b/packages/ipfs-message-port-server/tsconfig.json @@ -19,6 +19,6 @@ "noEmit": true }, "exclude": ["dist", "node_modules"], - "include": ["src/**/*.js"], + "include": ["src/**/*.js", "../ipfs-message-port-protocol/src/**/*.js"], "compileOnSave": false } From 92fa23937865e0701032d4b53272d161481aeb60 Mon Sep 17 00:00:00 2001 From: Irakli Gozalishvili Date: Wed, 10 Jun 2020 19:31:49 -0700 Subject: [PATCH 07/63] chore: swap ipld-block with a fork --- packages/interface-ipfs-core/package.json | 2 +- packages/ipfs-http-client/package.json | 2 +- packages/ipfs/package.json | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/packages/interface-ipfs-core/package.json b/packages/interface-ipfs-core/package.json index 062dde3d1f..da6031cd4f 100644 --- a/packages/interface-ipfs-core/package.json +++ b/packages/interface-ipfs-core/package.json @@ -37,7 +37,7 @@ "ipfs-unixfs": "^1.0.2", "ipfs-unixfs-importer": "^2.0.1", "ipfs-utils": "^2.2.2", - "ipld-block": "^0.9.1", + "ipld-block": "git://github.com/gozala/js-ipld-block.git#uint8array", "ipld-dag-cbor": "git://github.com/gozala/js-ipld-dag-cbor.git#uint8array", "ipld-dag-pb": "git://github.com/gozala/js-ipld-dag-pb.git#pure-data-model", "is-ipfs": "^1.0.3", diff --git a/packages/ipfs-http-client/package.json b/packages/ipfs-http-client/package.json index 8c8c6af827..b552da2ee3 100644 --- a/packages/ipfs-http-client/package.json +++ b/packages/ipfs-http-client/package.json @@ -43,7 +43,7 @@ "form-data": "^3.0.0", "ipfs-core-utils": "^0.2.3", "ipfs-utils": "^2.2.2", - "ipld-block": "^0.9.1", + "ipld-block": "git://github.com/gozala/js-ipld-block.git#uint8array", "ipld-dag-cbor": "git://github.com/gozala/js-ipld-dag-cbor.git#uint8array", "ipld-dag-pb": "git://github.com/gozala/js-ipld-dag-pb.git#pure-data-model", "ipld-raw": "^4.0.1", diff --git a/packages/ipfs/package.json b/packages/ipfs/package.json index 1fa51ff6e1..1351acea98 100644 --- a/packages/ipfs/package.json +++ b/packages/ipfs/package.json @@ -100,7 +100,7 @@ "ipfs-utils": "^2.2.2", "ipld": "^0.26.2", "ipld-bitcoin": "^0.3.0", - "ipld-block": "^0.9.1", + "ipld-block": "git://github.com/gozala/js-ipld-block.git#uint8array", "ipld-dag-cbor": "git://github.com/gozala/js-ipld-dag-cbor.git#uint8array", "ipld-dag-pb": "git://github.com/gozala/js-ipld-dag-pb.git#pure-data-model", "ipld-ethereum": "^4.0.0", From 7ec2aff54050530c7f32047ee8d44db820f16b96 Mon Sep 17 00:00:00 2001 From: Irakli Gozalishvili Date: Wed, 10 Jun 2020 20:16:41 -0700 Subject: [PATCH 08/63] chore: activate dag.tree tests --- packages/interface-ipfs-core/src/dag/tree.js | 51 ++++----- .../ipfs-message-port-client/package.json | 103 +---------------- packages/ipfs-message-port-client/src/dag.js | 2 +- .../ipfs-message-port-protocol/package.json | 108 +----------------- .../ipfs-message-port-server/package.json | 103 +---------------- packages/ipfs-message-port-server/src/dag.js | 4 +- 6 files changed, 33 insertions(+), 338 deletions(-) diff --git a/packages/interface-ipfs-core/src/dag/tree.js b/packages/interface-ipfs-core/src/dag/tree.js index 2b09f7df00..3251dbc587 100644 --- a/packages/interface-ipfs-core/src/dag/tree.js +++ b/packages/interface-ipfs-core/src/dag/tree.js @@ -66,34 +66,27 @@ module.exports = (common, options) => { expect(paths).to.eql(['pb', 'someData']) }) - // it('should get tree with CID and path', async () => { - // const paths = await all(ipfs.dag.tree(cidCbor, 'someData')) - // expect(paths).to.eql([]) - // }) - - // it('should get tree with CID and path as String', async () => { - // const cidCborStr = cidCbor.toBaseEncodedString() - - // const paths = await all(ipfs.dag.tree(cidCborStr + '/someData')) - // expect(paths).to.eql([]) - // }) - - // it('should get tree with CID recursive (accross different formats)', async () => { - // const paths = await all(ipfs.dag.tree(cidCbor, { recursive: true })) - // expect(paths).to.have.members([ - // 'pb', - // 'someData', - // 'pb/Links', - // 'pb/Data' - // ]) - // }) - - // it('should get tree with CID and path recursive', async () => { - // const paths = await all(ipfs.dag.tree(cidCbor, 'pb', { recursive: true })) - // expect(paths).to.have.members([ - // 'Links', - // 'Data' - // ]) - // }) + it('should get tree with CID and path', async () => { + const paths = await all(ipfs.dag.tree(cidCbor, 'someData')) + expect(paths).to.eql([]) + }) + + // TODO: CID as string isn't supported yet + it.skip('should get tree with CID and path as String', async () => { + const cidCborStr = cidCbor.toBaseEncodedString() + + const paths = await all(ipfs.dag.tree(cidCborStr + '/someData')) + expect(paths).to.eql([]) + }) + + it('should get tree with CID recursive (accross different formats)', async () => { + const paths = await all(ipfs.dag.tree(cidCbor, { recursive: true })) + expect(paths).to.have.members(['pb', 'someData', 'pb/Links', 'pb/Data']) + }) + + it('should get tree with CID and path recursive', async () => { + const paths = await all(ipfs.dag.tree(cidCbor, 'pb', { recursive: true })) + expect(paths).to.have.members(['Links', 'Data']) + }) }) } diff --git a/packages/ipfs-message-port-client/package.json b/packages/ipfs-message-port-client/package.json index 2946297422..949ccdadff 100644 --- a/packages/ipfs-message-port-client/package.json +++ b/packages/ipfs-message-port-client/package.json @@ -42,106 +42,5 @@ "node": ">=10.3.0", "npm": ">=3.0.0" }, - "contributors": [ - "Alan Shaw ", - "Alan Shaw ", - "Alex Mingoia ", - "Alex Potsides ", - "Antonio Tenorio-Fornés ", - "Bruno Barbieri ", - "Clemo ", - "Connor Keenan ", - "Daniel Constantin ", - "Danny ", - "David Braun ", - "David Dias ", - "Dietrich Ayala ", - "Diogo Silva ", - "Dmitriy Ryajov ", - "Dmitry Nikulin ", - "Donatas Stundys ", - "Fil ", - "Filip Š ", - "Francisco Baio Dias ", - "Friedel Ziegelmayer ", - "Gar ", - "Gavin McDermott ", - "Gopalakrishna Palem ", - "Greenkeeper ", - "Haad ", - "Harlan T Wood ", - "Harlan T Wood ", - "Henrique Dias ", - "Holodisc ", - "Hugo Dias ", - "Hugo Dias ", - "JGAntunes ", - "Jacob Heun ", - "James Halliday ", - "Jason Carver ", - "Jason Papakostas ", - "Jeff Downie ", - "Jeromy ", - "Jeromy ", - "Jim Pick ", - "Joe Turgeon ", - "Jonathan ", - "Juan Batiz-Benet ", - "Kevin Wang ", - "Kristoffer Ström ", - "Marcin Rataj ", - "Matt Bell ", - "Matt Ober ", - "Maxime Lathuilière ", - "Michael Bradley ", - "Michael Muré ", - "Michael Muré ", - "Mikeal Rogers ", - "Mitar ", - "Mithgol ", - "Mohamed Abdulaziz ", - "Nitin Patel <31539366+niinpatel@users.noreply.github.com>", - "Nuno Nogueira ", - "Níckolas Goline ", - "Oli Evans ", - "Orie Steele ", - "Paul Cowgill ", - "Pedro Santos ", - "Pedro Santos ", - "Pedro Teixeira ", - "Pete Thomas ", - "Richard Littauer ", - "Richard Schneider ", - "Roman Khafizianov ", - "SeungWon ", - "Stephen Whitmore ", - "Tara Vancil ", - "Teri Chadbourne ", - "Travis Person ", - "Travis Person ", - "Vasco Santos ", - "Vasco Santos ", - "Victor Bjelkholm ", - "Volker Mische ", - "Zhiyuan Lin ", - "dirkmc ", - "dmitriy ryajov ", - "elsehow ", - "ethers ", - "greenkeeper[bot] <23040076+greenkeeper[bot]@users.noreply.github.com>", - "greenkeeper[bot] ", - "haad ", - "kumavis ", - "leekt216 ", - "nginnever ", - "noah the goodra ", - "phillmac ", - "priecint ", - "samuli ", - "sarthak khandelwal ", - "shunkin ", - "victorbjelkholm ", - "Łukasz Magiera ", - "Łukasz Magiera " - ] + "contributors": ["Irakli Gozalishvili "] } diff --git a/packages/ipfs-message-port-client/src/dag.js b/packages/ipfs-message-port-client/src/dag.js index d69e79c446..4f4b019c8e 100644 --- a/packages/ipfs-message-port-client/src/dag.js +++ b/packages/ipfs-message-port-client/src/dag.js @@ -142,7 +142,7 @@ const read = (path, options) => { if (typeof path === 'string') { return [path, options] } else { - return ['/', path == null ? options : path] + return ['', path == null ? options : path] } } diff --git a/packages/ipfs-message-port-protocol/package.json b/packages/ipfs-message-port-protocol/package.json index f3b424ef02..469f668a06 100644 --- a/packages/ipfs-message-port-protocol/package.json +++ b/packages/ipfs-message-port-protocol/package.json @@ -28,7 +28,10 @@ "clean": "rm -rf ./dist", "dep-check": "aegir dep-check" }, - "dependencies": {}, + "dependencies": { + "buffer": "^5.6.0", + "cids": "^0.8.0" + }, "devDependencies": { "aegir": "^22.0.0", "cross-env": "^7.0.0" @@ -37,106 +40,5 @@ "node": ">=10.3.0", "npm": ">=3.0.0" }, - "contributors": [ - "Alan Shaw ", - "Alan Shaw ", - "Alex Mingoia ", - "Alex Potsides ", - "Antonio Tenorio-Fornés ", - "Bruno Barbieri ", - "Clemo ", - "Connor Keenan ", - "Daniel Constantin ", - "Danny ", - "David Braun ", - "David Dias ", - "Dietrich Ayala ", - "Diogo Silva ", - "Dmitriy Ryajov ", - "Dmitry Nikulin ", - "Donatas Stundys ", - "Fil ", - "Filip Š ", - "Francisco Baio Dias ", - "Friedel Ziegelmayer ", - "Gar ", - "Gavin McDermott ", - "Gopalakrishna Palem ", - "Greenkeeper ", - "Haad ", - "Harlan T Wood ", - "Harlan T Wood ", - "Henrique Dias ", - "Holodisc ", - "Hugo Dias ", - "Hugo Dias ", - "JGAntunes ", - "Jacob Heun ", - "James Halliday ", - "Jason Carver ", - "Jason Papakostas ", - "Jeff Downie ", - "Jeromy ", - "Jeromy ", - "Jim Pick ", - "Joe Turgeon ", - "Jonathan ", - "Juan Batiz-Benet ", - "Kevin Wang ", - "Kristoffer Ström ", - "Marcin Rataj ", - "Matt Bell ", - "Matt Ober ", - "Maxime Lathuilière ", - "Michael Bradley ", - "Michael Muré ", - "Michael Muré ", - "Mikeal Rogers ", - "Mitar ", - "Mithgol ", - "Mohamed Abdulaziz ", - "Nitin Patel <31539366+niinpatel@users.noreply.github.com>", - "Nuno Nogueira ", - "Níckolas Goline ", - "Oli Evans ", - "Orie Steele ", - "Paul Cowgill ", - "Pedro Santos ", - "Pedro Santos ", - "Pedro Teixeira ", - "Pete Thomas ", - "Richard Littauer ", - "Richard Schneider ", - "Roman Khafizianov ", - "SeungWon ", - "Stephen Whitmore ", - "Tara Vancil ", - "Teri Chadbourne ", - "Travis Person ", - "Travis Person ", - "Vasco Santos ", - "Vasco Santos ", - "Victor Bjelkholm ", - "Volker Mische ", - "Zhiyuan Lin ", - "dirkmc ", - "dmitriy ryajov ", - "elsehow ", - "ethers ", - "greenkeeper[bot] <23040076+greenkeeper[bot]@users.noreply.github.com>", - "greenkeeper[bot] ", - "haad ", - "kumavis ", - "leekt216 ", - "nginnever ", - "noah the goodra ", - "phillmac ", - "priecint ", - "samuli ", - "sarthak khandelwal ", - "shunkin ", - "victorbjelkholm ", - "Łukasz Magiera ", - "Łukasz Magiera " - ] + "contributors": ["Irakli Gozalishvili "] } diff --git a/packages/ipfs-message-port-server/package.json b/packages/ipfs-message-port-server/package.json index 04b1ced9e5..d9b1dbcc5f 100644 --- a/packages/ipfs-message-port-server/package.json +++ b/packages/ipfs-message-port-server/package.json @@ -43,106 +43,5 @@ "node": ">=10.3.0", "npm": ">=3.0.0" }, - "contributors": [ - "Alan Shaw ", - "Alan Shaw ", - "Alex Mingoia ", - "Alex Potsides ", - "Antonio Tenorio-Fornés ", - "Bruno Barbieri ", - "Clemo ", - "Connor Keenan ", - "Daniel Constantin ", - "Danny ", - "David Braun ", - "David Dias ", - "Dietrich Ayala ", - "Diogo Silva ", - "Dmitriy Ryajov ", - "Dmitry Nikulin ", - "Donatas Stundys ", - "Fil ", - "Filip Š ", - "Francisco Baio Dias ", - "Friedel Ziegelmayer ", - "Gar ", - "Gavin McDermott ", - "Gopalakrishna Palem ", - "Greenkeeper ", - "Haad ", - "Harlan T Wood ", - "Harlan T Wood ", - "Henrique Dias ", - "Holodisc ", - "Hugo Dias ", - "Hugo Dias ", - "JGAntunes ", - "Jacob Heun ", - "James Halliday ", - "Jason Carver ", - "Jason Papakostas ", - "Jeff Downie ", - "Jeromy ", - "Jeromy ", - "Jim Pick ", - "Joe Turgeon ", - "Jonathan ", - "Juan Batiz-Benet ", - "Kevin Wang ", - "Kristoffer Ström ", - "Marcin Rataj ", - "Matt Bell ", - "Matt Ober ", - "Maxime Lathuilière ", - "Michael Bradley ", - "Michael Muré ", - "Michael Muré ", - "Mikeal Rogers ", - "Mitar ", - "Mithgol ", - "Mohamed Abdulaziz ", - "Nitin Patel <31539366+niinpatel@users.noreply.github.com>", - "Nuno Nogueira ", - "Níckolas Goline ", - "Oli Evans ", - "Orie Steele ", - "Paul Cowgill ", - "Pedro Santos ", - "Pedro Santos ", - "Pedro Teixeira ", - "Pete Thomas ", - "Richard Littauer ", - "Richard Schneider ", - "Roman Khafizianov ", - "SeungWon ", - "Stephen Whitmore ", - "Tara Vancil ", - "Teri Chadbourne ", - "Travis Person ", - "Travis Person ", - "Vasco Santos ", - "Vasco Santos ", - "Victor Bjelkholm ", - "Volker Mische ", - "Zhiyuan Lin ", - "dirkmc ", - "dmitriy ryajov ", - "elsehow ", - "ethers ", - "greenkeeper[bot] <23040076+greenkeeper[bot]@users.noreply.github.com>", - "greenkeeper[bot] ", - "haad ", - "kumavis ", - "leekt216 ", - "nginnever ", - "noah the goodra ", - "phillmac ", - "priecint ", - "samuli ", - "sarthak khandelwal ", - "shunkin ", - "victorbjelkholm ", - "Łukasz Magiera ", - "Łukasz Magiera " - ] + "contributors": ["Irakli Gozalishvili "] } diff --git a/packages/ipfs-message-port-server/src/dag.js b/packages/ipfs-message-port-server/src/dag.js index c90973bbd2..6fb5569225 100644 --- a/packages/ipfs-message-port-server/src/dag.js +++ b/packages/ipfs-message-port-server/src/dag.js @@ -109,7 +109,9 @@ class DAG { timeout, signal }) - return await collect(result) + const entries = await collect(result) + + return entries } } From 9e6ad6c95fa0985abf8a16b3326fe79c669b8eb2 Mon Sep 17 00:00:00 2001 From: Irakli Gozalishvili Date: Thu, 11 Jun 2020 02:09:57 -0700 Subject: [PATCH 09/63] chore: resolve lint issues --- .../ipfs-message-port-client/package.json | 5 +- packages/ipfs-message-port-client/src/core.js | 137 +++++++----------- .../ipfs-message-port-client/test/dag.spec.js | 1 - .../ipfs-message-port-protocol/src/codecs.js | 0 .../ipfs-message-port-protocol/src/core.js | 131 +++++++++++++++++ .../ipfs-message-port-protocol/src/core.ts | 115 --------------- packages/ipfs-message-port-server/src/core.js | 90 ++++++++++-- packages/ipfs-message-port-server/src/util.js | 106 +------------- 8 files changed, 269 insertions(+), 316 deletions(-) delete mode 100644 packages/ipfs-message-port-protocol/src/codecs.js create mode 100644 packages/ipfs-message-port-protocol/src/core.js delete mode 100644 packages/ipfs-message-port-protocol/src/core.ts diff --git a/packages/ipfs-message-port-client/package.json b/packages/ipfs-message-port-client/package.json index 949ccdadff..e9eef14c89 100644 --- a/packages/ipfs-message-port-client/package.json +++ b/packages/ipfs-message-port-client/package.json @@ -31,8 +31,9 @@ "cids": "^0.8.0" }, "devDependencies": { - "ipfs-message-port-protocol": "^0.0.1", - "ipfs-message-port-server": "^0.0.1", + "ipfs-message-port-protocol": "~0.0.1", + "ipfs-message-port-server": "~0.0.1", + "ipld-dag-pb": "git://github.com/gozala/js-ipld-dag-pb.git#pure-data-model", "ipfs": "^0.45.0", "aegir": "^22.0.0", "cross-env": "^7.0.0", diff --git a/packages/ipfs-message-port-client/src/core.js b/packages/ipfs-message-port-client/src/core.js index fb4649967b..9e4a078c93 100644 --- a/packages/ipfs-message-port-client/src/core.js +++ b/packages/ipfs-message-port-client/src/core.js @@ -1,8 +1,19 @@ 'use strict' +/* eslint-env browser */ + const CID = require('cids') -const { AbortError } = require('./errors') +const { Client } = require('./client') +const { encodeCID, decodeCID } = require('ipfs-message-port-protocol/src/dag') +const { + decodeRemoteIterable, + mapAsyncIterable, + encodeCallback +} = require('ipfs-message-port-protocol/src/core') + /** + * @typedef {import('ipfs-message-port-protocol/src/dag').EncodedCID} EncodedCID + * * @typedef {Object} NoramilzedFileInput * @property {string} path * @property {AsyncIterable} content @@ -22,16 +33,12 @@ const { AbortError } = require('./errors') * */ /** @type {(input:AnyFileInput) => AsyncIterable} */ -// @ts-ignore -const normaliseInput = require('ipfs-core-utils/src/files/normalise-input') /** - * @typedef {import("./connection")} RPCConnection - * @typedef {import("./connection").RPCRequestOptions} RPCRequestOptions * @typedef {import("./files").Time} Time * * @typedef {Object} AddOptions - * @property {chunker} [string="size-262144"] + * @property {string} [chunker="size-262144"] * @property {number} [cidVersion=0] * @property {boolean} [enableShardingExperiment] * @property {string} [hashAlg="sha2-256"] @@ -42,123 +49,87 @@ const normaliseInput = require('ipfs-core-utils/src/files/normalise-input') * @property {number} [shardSplitThreshold=1000] * @property {boolean} [trickle=false] * @property {boolean} [wrapWithDirectory=false] + * @property {number} [timeout] + * @property {AbortSignal} [signal] * * @typedef {Object} AddedData * @property {string} path * @property {CID} cid * @property {number} mode * @property {Time} mtime - * - * @typedef {Object} EncodedAddedData - * @property {string} path - * @property {string} cid - * @property {number} mode - * @property {Time} mtime - * - * @typedef {Object} Cat - * @property {number} [offset] - * @property {number} [length] */ /** - * @template T - * @typedef {T & RPCRequestOptions} Options + * @typedef {import('ipfs-message-port-server/src/core').Core} API + * @typedef {import('ipfs-message-port-server/src/core').AddedEntry} AddedEntry + * @typedef {import('./client').ClientTransport} Transport */ -class FilesTopClient { +/** + * @class + * @extends {Client} + */ +class CoreService extends Client { /** - * - * @param {RPCConnection} connection + * @param {Transport} transport */ - constructor (connection) { - this.connection = connection + constructor (transport) { + super('core', ['add', 'cat'], transport) } /** * @param {AnyFileInput} input - * @param {Options} [options] + * @param {AddOptions} [options] * @returns {AsyncIterable} */ async * add (input, options = {}) { - const { progress, timeout, signal } = options - const entries = normaliseInput(input) + const { timeout, signal } = options + const progress = options.progress + ? encodeCallback(options.progress) + : undefined - for await (const { path, content } of entries) { - for await (const chunk of content) { - const chunks = await collect(content) - /** @type EncodedAddedData */ - const data = await this.connection.call( - 'add', - { - path, - content: chunks - }, - { - transfer: chunks, - signal - } - ) - - if (signal && signal.aborted) { - throw new AbortError() - } - yield decode(data) - } + if (input instanceof Blob) { + const result = await this.remote.add({ + ...options, + input, + progress, + timeout, + signal + }) + yield * mapAsyncIterable(decodeRemoteIterable(result), decode) + } else { + throw Error('Input type is not supported') } } /** - * @param {string|CID|ArrayBuffer} inputPath - * @param {Options} [options] + * @param {string|CID} inputPath + * @param {Object} [options] + * @param {number} [options.offset] + * @param {number} [options.length] + * @param {number} [options.timeout] + * @param {AbortSignal} [options.signal] * @returns {AsyncIterable} */ async * cat (inputPath, options = {}) { - const input = CID.isCID(inputPath) ? inputPath.toString() : inputPath - const transfer = input instanceof ArrayBuffer ? [input] : [] - const { signal, timeout, offset, length } = options - /** @type ArrayBuffer[] */ - const chunks = await this.connection.call( - 'cat', - { - input, - offset, - length - }, - { - signal, - timeout, - transfer - } - ) - yield * chunks - } -} - -/** - * @template T - * @param {AsyncIterable} content - * @returns {Promise} - */ -const collect = async content => { - const chunks = [] - for await (const chunk of content) { - chunks.push(chunk) + const input = CID.isCID(inputPath) ? encodeCID(inputPath) : inputPath + const result = await this.remote.cat({ ...options, path: input }) + yield * decodeRemoteIterable(result) } - return chunks } /** * - * @param {EncodedAddedData} data + * @param {AddedEntry} data * @returns {AddedData} */ const decode = ({ path, cid, mode, mtime }) => { return { path, - cid: new CID(cid), + cid: decodeCID(cid), mode, mtime } } -module.exports = FilesTopClient +module.exports = CoreService diff --git a/packages/ipfs-message-port-client/test/dag.spec.js b/packages/ipfs-message-port-client/test/dag.spec.js index ae7c89bc95..aa2a612283 100644 --- a/packages/ipfs-message-port-client/test/dag.spec.js +++ b/packages/ipfs-message-port-client/test/dag.spec.js @@ -6,7 +6,6 @@ const { Buffer } = require('buffer') const { expect } = require('interface-ipfs-core/src/utils/mocha') const { DAGNode } = require('ipld-dag-pb') -const CID = require('cids') const { activate } = require('./util/client') describe('dag', function () { diff --git a/packages/ipfs-message-port-protocol/src/codecs.js b/packages/ipfs-message-port-protocol/src/codecs.js deleted file mode 100644 index e69de29bb2..0000000000 diff --git a/packages/ipfs-message-port-protocol/src/core.js b/packages/ipfs-message-port-protocol/src/core.js new file mode 100644 index 0000000000..5b77a47b7a --- /dev/null +++ b/packages/ipfs-message-port-protocol/src/core.js @@ -0,0 +1,131 @@ +'use strict' + +// import { +// HashAlg, +// RemoteCallback, +// Time, +// Mode, +// StringEncoded, +// UnixFSTime, +// FileType +// } from 'ipfs-message-port-protocol/src/data' + +/** + * @template T + * @typedef {import("./data").RemoteIterable} RemoteIterable + */ + +/** + * @template T + * @typedef {import('./data').RemoteCallback} RemoteCallback + */ + +/** + * @template T + * @param {RemoteIterable} remote + * @returns {AsyncIterable} + */ +const decodeRemoteIterable = async function * ({ port }) { + /** + * @param {{done:false, value:T}|{done:true, value:void}} _data + * @returns {void} + */ + let receive = _data => {} + const wait = () => new Promise(resolve => (receive = resolve)) + const next = () => { + port.postMessage({ method: 'next' }) + return wait() + } + + /** + * @param {MessageEvent} event + * @returns {void} + */ + port.onmessage = event => receive(event.data) + + const abort = () => { + port.postMessage({ method: 'return' }) + port.close() + } + + let isDone = false + try { + while (!isDone) { + const { done, value } = await next() + isDone = done + if (!done) { + yield value + } + } + } finally { + if (!isDone) { + abort() + } + } +} +exports.decodeRemoteIterable = decodeRemoteIterable + +/** + * @template T + * @param {AsyncIterable} iterable + * @returns {RemoteIterable} + */ +const encodeAsyncIterable = iterable => { + // eslint-disable-next-line no-undef + const { port1: port, port2: remote } = new MessageChannel() + const iterator = iterable[Symbol.asyncIterator]() + port.onmessage = async ({ data: { method } }) => { + switch (method) { + case 'next': { + const { done, value } = await iterator.next() + if (done) { + port.postMessage({ done: true }) + port.close() + } else { + port.postMessage({ done: false, value }) + } + break + } + case 'return': { + port.close() + if (iterator.return) { + iterator.return() + } + break + } + default: { + break + } + } + } + port.start() + + return { type: 'RemoteIterable', port: remote, transfer: [remote] } +} +exports.encodeAsyncIterable = encodeAsyncIterable + +/** + * @template T + * @param {function(T):void} callback + * @returns {RemoteCalback} + */ +const encodeCallback = callback => { + // eslint-disable-next-line no-undef + const { port1: port, port2: remote } = new MessageChannel() + port.onmessage = ({ data }) => callback(data) + return { type: 'RemoteCallback', port: remote } +} +exports.encodeCallback = encodeCallback + +/** + * @template A,B + * @param {AsyncIterable} source + * @param {function(A): B} f + * @returns {AsyncIterable} + */ +const mapAsyncIterable = async function * (source, f) { + for await (const item of source) { + yield f(item) + } +} +exports.mapAsyncIterable = mapAsyncIterable diff --git a/packages/ipfs-message-port-protocol/src/core.ts b/packages/ipfs-message-port-protocol/src/core.ts deleted file mode 100644 index 62286e0a82..0000000000 --- a/packages/ipfs-message-port-protocol/src/core.ts +++ /dev/null @@ -1,115 +0,0 @@ -import { - HashAlg, - RemoteCallback, - RemoteIterable, - Time, - Mode, - StringEncoded, - UnixFSTime, - FileType -} from './data' -import CID from 'cids' - -export interface Core { - add(input: AddQuery): AddResult - cat(input: CatQuery): CatResult - get(input: GetQuery): GetResult - ls(input: LsQuery): LsResult -} - -export type AddQuery = { - input: AddInput - - chunker?: string - cidVersion?: number - enableShardingExperiment?: boolean - hashAlg?: HashAlg - onlyHash?: boolean - pin?: boolean - progress?: RemoteCallback - rawLeaves?: boolean - shardSplitThreshold?: boolean - trickle?: boolean - wrapWithDirectory?: boolean - - timeout?: number - signal?: AbortSignal -} - -export type AddInput = SingleFileInput | MultiFileInput - -type SingleFileInput = - | ArrayBuffer - | ArrayBufferView - | Blob - | string - | RemoteIterable - | RemoteIterable - -type MultiFileInput = - | RemoteIterable - | RemoteIterable - | RemoteIterable - -export type FileInput = { - path?: string - content: FileContent - mode?: Mode - mtime?: Time -} - -export type FileContent = - | ArrayBufferView - | ArrayBuffer - | string - | RemoteIterable - | RemoteIterable - -type AddedEntry = { - path: string - cid: StringEncoded - mode: number - mtime: UnixFSTime - size: number -} - -export type AddResult = RemoteIterable - -export type CatQuery = { - path: string - - offset?: number - length?: number -} - -export type CatResult = RemoteIterable - -export type GetQuery = { - path: string -} - -export type GetResult = RemoteIterable - -type FileEntry = { - path: string - content: RemoteIterable - mode: number - mtime: UnixFSTime -} - -export type LsQuery = { - path: string -} - -export type LsResult = RemoteIterable - -type LsEntry = { - depth: number - name: string - path: string - size: number - cid: StringEncoded - type: FileType - mode: number - mtime: UnixFSTime -} diff --git a/packages/ipfs-message-port-server/src/core.js b/packages/ipfs-message-port-server/src/core.js index e52f61d72d..ab8873efdd 100644 --- a/packages/ipfs-message-port-server/src/core.js +++ b/packages/ipfs-message-port-server/src/core.js @@ -6,7 +6,8 @@ const { decodeRemoteIterable, encodeAsyncIterable, mapAsyncIterable -} = require('./util') +} = require('ipfs-message-port-protocol/src/core') +const { decodeCID } = require('ipfs-message-port-protocol/src/dag') /** @@ -14,16 +15,84 @@ const { * @typedef {import("./ipfs").IPFS} IPFS * @typedef {import("ipfs-message-port-protocol/src/data").Time} Time * @typedef {import("ipfs-message-port-protocol/src/data").Mode} Mode - * @typedef {import("ipfs-message-port-protocol/src/core").AddInput} AddInput - * @typedef {import("ipfs-message-port-protocol/src/core").FileInput} EncodedFileInput - * @typedef {import("ipfs-message-port-protocol/src/core").FileContent} EncodedFileContent - * @typedef {import("ipfs-message-port-protocol/src/core").AddQuery} AddQuery - * @typedef {import("ipfs-message-port-protocol/src/core").AddResult} AddResult + * @typedef {import("ipfs-message-port-protocol/src/data").HashAlg} HashAlg + * @typedef {import('ipfs-message-port-protocol/src/dag').EncodedCID} EncodedCID * @typedef {import("./ipfs").FileOutput} FileOutput * @typedef {import('./ipfs').FileObject} FileObject * @typedef {import('./ipfs').FileContent} DecodedFileContent * @typedef {import('./ipfs').FileInput} DecodedFileInput + */ +/** + * @typedef {Object} AddQuery + * @property {AddInput} input + * @property {string} [chunker] + * @property {number} [cidVersion] + * @property {boolean} [enableShardingExperiment] + * @property {HashAlg} [hashAlg] + * @property {boolean} [onlyHash] + * @property {boolean} [pin] + * @property {RemoteCallback} [progress] + * @property {boolean} [rawLeaves] + * @property {number} [shardSplitThreshold] + * @property {boolean} [trickle] + * @property {boolean} [wrapWithDirectory] + * @property {number} [timeout] + * @property {AbortSignal} [signal] + * + * @typedef {SingleFileInput | MultiFileInput} AddInput + * @typedef {ArrayBuffer|ArrayBufferView|Blob|string|RemoteIterable|RemoteIterable} SingleFileInput + * @typedef {RemoteIterable|RemoteIterable|RemoteIterable} MultiFileInput + * + * @typedef {Object} FileInput + * @property {string} [path] + * @property {FileContent} content + * @property {Mode} mode + * @property {Time} mtim + * + * @typedef {ArrayBufferView|ArrayBuffer|string|RemoteIterable|RemoteIterable} FileContent + * + * @typedef {Object} AddedEntry + * @property {string} path + * @property {EncodedCID} cid + * @property {number} mode + * @property {UnixFSTime} mtime + * @property {number} size + * + * @typedef {RemoteIterable} AddResult + * + * @typedef {Object} CatQuery + * @property {string} path + * @property {number} [offset] + * @property {number} [length] + * + * @typedef {RemoteIterable} CatResult + * + * @typedef {Object} GetQuery + * @property {string} path + * + * @typedef {RemoteIterable} GetResult + * + * @typedef {Object} FileEntry + * @property {string} path + * @property {RemoteIterable} content + * @property {Mtime} [mode] + * @property {UnixFSTime} [mtime] + * + * @typedef {Object} LsQuery + * @property {string} path + * + * @typedef {RemoteIterable} LsResult + * + * @typedef {Object} LsEntry + * @property {number} depth + * @property {string} name + * @property {string} path + * @property {number} size + * @property {EncodedCID} cid + * @property {FileType} type + * @property {Mode} mode + * @property {UnixFSTime} mtime */ /** @@ -87,7 +156,7 @@ class Core { /** * @param {Object} query - * @param {string} query.path + * @param {string|EncodedCID} query.path * @param {number} [query.offset] * @param {number} [query.length] * @param {number} [query.timeout] @@ -96,7 +165,8 @@ class Core { */ cat (query) { const { path, offset, length, timeout, signal } = query - const content = this.ipfs.cat(path, { offset, length, timeout, signal }) + const location = typeof path === 'string' ? path : decodeCID(path) + const content = this.ipfs.cat(location, { offset, length, timeout, signal }) return encodeAsyncIterable(content) } } @@ -125,7 +195,7 @@ const decodeAddInput = input => * @property {Mode|void} [mode] * @property {Time|void} [mtime] - * @param {ArrayBufferView|ArrayBuffer|string|Blob|EncodedFileInput} input + * @param {ArrayBufferView|ArrayBuffer|string|Blob|FileInput} input * @returns {string|ArrayBuffer|ArrayBufferView|Blob|FileObject} */ const decodFileInput = input => @@ -135,7 +205,7 @@ const decodFileInput = input => })) /** - * @param {EncodedFileContent} content + * @param {FileContent} content * @returns {DecodedFileContent} */ const decodeFileContent = content => matchInput(content, decodeRemoteIterable) diff --git a/packages/ipfs-message-port-server/src/util.js b/packages/ipfs-message-port-server/src/util.js index 035d8335f3..9bdcf86052 100644 --- a/packages/ipfs-message-port-server/src/util.js +++ b/packages/ipfs-message-port-server/src/util.js @@ -13,108 +13,4 @@ const collect = async input => { return values } -/** - * @template T - * @typedef {import("ipfs-message-port-protocol/src/data").RemoteIterable} RemoteIterable - */ - -/** - * @template T - * @param {RemoteIterable} remote - * @returns {AsyncIterable} - */ -const decodeRemoteIterable = async function * ({ port }) { - /** - * @param {{done:false, value:T}|{done:true, value:void}} _data - * @returns {void} - */ - let receive = _data => {} - const wait = () => new Promise(resolve => (receive = resolve)) - const next = () => { - port.postMessage({ method: 'next' }) - return wait() - } - - /** - * @param {MessageEvent} event - * @returns {void} - */ - port.onmessage = event => receive(event.data) - - const abort = () => { - port.postMessage({ method: 'return' }) - port.close() - } - - let isDone = false - try { - while (!isDone) { - const { done, value } = await next() - isDone = done - if (!done) { - yield value - } - } - } finally { - if (!isDone) { - abort() - } - } -} - -/** - * @template T - * @param {AsyncIterable} iterable - * @returns {RemoteIterable} - */ -const encodeAsyncIterable = iterable => { - // eslint-disable-next-line no-undef - const { port1: port, port2: remote } = new MessageChannel() - const iterator = iterable[Symbol.asyncIterator]() - port.onmessage = async ({ data: { method } }) => { - switch (method) { - case 'next': { - const { done, value } = await iterator.next() - if (done) { - port.postMessage({ done: true }) - port.close() - } else { - port.postMessage({ done: false, value }) - } - break - } - case 'return': { - port.close() - if (iterator.return) { - iterator.return() - } - break - } - default: { - break - } - } - } - port.start() - - return { type: 'RemoteIterable', port: remote, transfer: [remote] } -} - -/** - * @template A,B - * @param {AsyncIterable} source - * @param {function(A): B} f - * @returns {AsyncIterable} - */ -const mapAsyncIterable = async function * (source, f) { - for await (const item of source) { - yield f(item) - } -} - -module.exports = { - collect, - decodeRemoteIterable, - encodeAsyncIterable, - mapAsyncIterable -} +exports.collect = collect From 139cb26e34c10dfb1a957d0865c2d217d2d6f662 Mon Sep 17 00:00:00 2001 From: Irakli Gozalishvili Date: Fri, 12 Jun 2020 14:29:56 -0700 Subject: [PATCH 10/63] chore: move server/client shared code to protocol --- .../ipfs-message-port-client/src/client.js | 2 + packages/ipfs-message-port-client/src/core.js | 23 +- .../ipfs-message-port-protocol/package.json | 18 +- .../ipfs-message-port-protocol/src/core.js | 141 ++++++--- .../ipfs-message-port-protocol/src/data.ts | 11 - .../test/browser.js | 4 + .../test/core.browser.js | 282 ++++++++++++++++++ .../test/dag.browser.js | 120 ++++++++ .../test/dag.spec.js | 133 +++++++++ .../ipfs-message-port-protocol/test/node.js | 3 + .../ipfs-message-port-protocol/test/util.js | 42 +++ .../ipfs-message-port-server/package.json | 17 +- packages/ipfs-message-port-server/src/core.js | 100 +++++-- packages/ipfs-message-port-server/src/ipfs.ts | 2 +- .../ipfs-message-port-server/src/server.js | 1 - .../test/basic.spec.js | 46 +++ .../ipfs-message-port-server/test/node.js | 1 + 17 files changed, 833 insertions(+), 113 deletions(-) create mode 100644 packages/ipfs-message-port-protocol/test/browser.js create mode 100644 packages/ipfs-message-port-protocol/test/core.browser.js create mode 100644 packages/ipfs-message-port-protocol/test/dag.browser.js create mode 100644 packages/ipfs-message-port-protocol/test/dag.spec.js create mode 100644 packages/ipfs-message-port-protocol/test/node.js create mode 100644 packages/ipfs-message-port-protocol/test/util.js create mode 100644 packages/ipfs-message-port-server/test/basic.spec.js create mode 100644 packages/ipfs-message-port-server/test/node.js diff --git a/packages/ipfs-message-port-client/src/client.js b/packages/ipfs-message-port-client/src/client.js index bc91cf7ffe..790765c373 100644 --- a/packages/ipfs-message-port-client/src/client.js +++ b/packages/ipfs-message-port-client/src/client.js @@ -4,6 +4,8 @@ class RemoteError extends Error { /** + * Represents error that occured in the worker thread which was structure + * cloned over the message channel. * * @param {Object} info * @param {string} info.message diff --git a/packages/ipfs-message-port-client/src/core.js b/packages/ipfs-message-port-client/src/core.js index 9e4a078c93..1619e50181 100644 --- a/packages/ipfs-message-port-client/src/core.js +++ b/packages/ipfs-message-port-client/src/core.js @@ -6,8 +6,7 @@ const CID = require('cids') const { Client } = require('./client') const { encodeCID, decodeCID } = require('ipfs-message-port-protocol/src/dag') const { - decodeRemoteIterable, - mapAsyncIterable, + decodeAsyncIterable, encodeCallback } = require('ipfs-message-port-protocol/src/core') @@ -84,8 +83,10 @@ class CoreService extends Client { */ async * add (input, options = {}) { const { timeout, signal } = options + /** @type {Transferable[]} */ + const transfer = [] const progress = options.progress - ? encodeCallback(options.progress) + ? encodeCallback(options.progress, transfer) : undefined if (input instanceof Blob) { @@ -93,10 +94,11 @@ class CoreService extends Client { ...options, input, progress, + transfer, timeout, signal }) - yield * mapAsyncIterable(decodeRemoteIterable(result), decode) + yield * decodeAsyncIterable(result.data, decodeAddedData) } else { throw Error('Input type is not supported') } @@ -109,12 +111,12 @@ class CoreService extends Client { * @param {number} [options.length] * @param {number} [options.timeout] * @param {AbortSignal} [options.signal] - * @returns {AsyncIterable} + * @returns {AsyncIterable} */ async * cat (inputPath, options = {}) { const input = CID.isCID(inputPath) ? encodeCID(inputPath) : inputPath const result = await this.remote.cat({ ...options, path: input }) - yield * decodeRemoteIterable(result) + yield * decodeAsyncIterable(result.data, identity) } } @@ -123,7 +125,7 @@ class CoreService extends Client { * @param {AddedEntry} data * @returns {AddedData} */ -const decode = ({ path, cid, mode, mtime }) => { +const decodeAddedData = ({ path, cid, mode, mtime }) => { return { path, cid: decodeCID(cid), @@ -132,4 +134,11 @@ const decode = ({ path, cid, mode, mtime }) => { } } +/** + * @template T + * @param {T} v + * @returns {T} + */ +const identity = v => v + module.exports = CoreService diff --git a/packages/ipfs-message-port-protocol/package.json b/packages/ipfs-message-port-protocol/package.json index 469f668a06..a56f8b2881 100644 --- a/packages/ipfs-message-port-protocol/package.json +++ b/packages/ipfs-message-port-protocol/package.json @@ -14,14 +14,14 @@ "url": "git+https://github.com/ipfs/js-ipfs.git" }, "scripts": { - "test": "cross-env ECHO_SERVER_PORT=37490 aegir test", - "test:node": "cross-env ECHO_SERVER_PORT=37491 aegir test -t node", - "test:browser": "cross-env ECHO_SERVER_PORT=37492 aegir test -t browser", - "test:webworker": "cross-env ECHO_SERVER_PORT=37493 aegir test -t webworker", - "test:electron-main": "cross-env ECHO_SERVER_PORT=37494 aegir test -t electron-main", - "test:electron-renderer": "cross-env ECHO_SERVER_PORT=37495 aegir test -t electron-renderer", - "test:chrome": "cross-env ECHO_SERVER_PORT=37496 aegir test -t browser -t webworker -- --browsers ChromeHeadless", - "test:firefox": "cross-env ECHO_SERVER_PORT=37497 aegir test -t browser -t webworker -- --browsers FirefoxHeadless", + "test": "aegir test", + "test:node": "aegir test -t node", + "test:browser": "aegir test -t browser", + "test:webworker": "aegir test -t webworker", + "test:electron-main": "aegir test -t electron-main", + "test:electron-renderer": "aegir test -t electron-renderer", + "test:chrome": "aegir test -t browser -t webworker -- --browsers ChromeHeadless", + "test:firefox": "aegir test -t browser -t webworker -- --browsers FirefoxHeadless", "lint": "aegir lint", "build": "aegir build", "coverage": "npx nyc -r html npm run test:node -- --bail", @@ -34,7 +34,7 @@ }, "devDependencies": { "aegir": "^22.0.0", - "cross-env": "^7.0.0" + "interface-ipfs-core": "^0.135.1" }, "engines": { "node": ">=10.3.0", diff --git a/packages/ipfs-message-port-protocol/src/core.js b/packages/ipfs-message-port-protocol/src/core.js index 5b77a47b7a..0393a4b696 100644 --- a/packages/ipfs-message-port-protocol/src/core.js +++ b/packages/ipfs-message-port-protocol/src/core.js @@ -1,36 +1,61 @@ 'use strict' -// import { -// HashAlg, -// RemoteCallback, -// Time, -// Mode, -// StringEncoded, -// UnixFSTime, -// FileType -// } from 'ipfs-message-port-protocol/src/data' +/** + * @template T + * @typedef {Object} RemoteIterable + * @property {'RemoteIterable'} type + * @property {MessagePort} port + */ /** * @template T - * @typedef {import("./data").RemoteIterable} RemoteIterable + * @typedef {Object} RemoteCallback + * @property {'RemoteCallback'} type + * @property {MessagePort} port */ /** * @template T - * @typedef {import('./data').RemoteCallback} RemoteCallback + * @typedef {Object} RemoteYield + * @property {false} done + * @property {T} value + * @property {void} error */ /** * @template T - * @param {RemoteIterable} remote - * @returns {AsyncIterable} + * @typedef {Object} RemoteDone + * @property {true} done + * @property {T|void} value + * @property {void} error + */ + +/** + * @typedef {Object} RemoteError + * @property {true} done + * @property {void} value + * @property {Error} error + */ + +/** + * @template T + * @typedef {RemoteYield|RemoteDone|RemoteError} RemoteNext + */ + +/** + * @template I, O + * @param {RemoteIterable} remote + * @param {function(I):O} decode + * @returns {AsyncIterable} */ -const decodeRemoteIterable = async function * ({ port }) { +const decodeAsyncIterable = async function * ({ port }, decode) { /** - * @param {{done:false, value:T}|{done:true, value:void}} _data - * @returns {void} + * @param {RemoteNext} _data */ let receive = _data => {} + /** + * @returns {Promise>} + */ const wait = () => new Promise(resolve => (receive = resolve)) const next = () => { port.postMessage({ method: 'next' }) @@ -43,46 +68,61 @@ const decodeRemoteIterable = async function * ({ port }) { */ port.onmessage = event => receive(event.data) - const abort = () => { - port.postMessage({ method: 'return' }) - port.close() - } - let isDone = false try { while (!isDone) { - const { done, value } = await next() + const { done, value, error } = await next() isDone = done - if (!done) { - yield value + if (error != null) { + throw error + } else if (value != null) { + yield decode(value) } } } finally { if (!isDone) { - abort() + port.postMessage({ method: 'return' }) } + port.close() } } -exports.decodeRemoteIterable = decodeRemoteIterable +exports.decodeAsyncIterable = decodeAsyncIterable /** - * @template T - * @param {AsyncIterable} iterable - * @returns {RemoteIterable} + * @template I,O + * @param {AsyncIterable} iterable + * @param {function(I, Transferable[]):O} encode + * @param {Transferable[]} transfer + * @returns {RemoteIterable} */ -const encodeAsyncIterable = iterable => { +const encodeAsyncIterable = (iterable, encode, transfer) => { // eslint-disable-next-line no-undef const { port1: port, port2: remote } = new MessageChannel() const iterator = iterable[Symbol.asyncIterator]() + /** @type {Transferable[]} */ + const itemTransfer = [] port.onmessage = async ({ data: { method } }) => { switch (method) { case 'next': { - const { done, value } = await iterator.next() - if (done) { - port.postMessage({ done: true }) + try { + const { done, value } = await iterator.next() + if (done) { + port.postMessage({ type: 'next', done: true }) + port.close() + } else { + itemTransfer.length = 0 + port.postMessage( + { + type: 'next', + done: false, + value: encode(value, itemTransfer) + }, + itemTransfer + ) + } + } catch (error) { + port.postMessage({ type: 'throw', error }) port.close() - } else { - port.postMessage({ done: false, value }) } break } @@ -99,33 +139,42 @@ const encodeAsyncIterable = iterable => { } } port.start() + transfer.push(remote) - return { type: 'RemoteIterable', port: remote, transfer: [remote] } + return { type: 'RemoteIterable', port: remote } } exports.encodeAsyncIterable = encodeAsyncIterable /** * @template T * @param {function(T):void} callback - * @returns {RemoteCalback} + * @param {Transferable[]} transfer + * @returns {RemoteCallback} */ -const encodeCallback = callback => { +const encodeCallback = (callback, transfer) => { // eslint-disable-next-line no-undef const { port1: port, port2: remote } = new MessageChannel() port.onmessage = ({ data }) => callback(data) + transfer.push(remote) return { type: 'RemoteCallback', port: remote } } exports.encodeCallback = encodeCallback /** - * @template A,B - * @param {AsyncIterable} source - * @param {function(A): B} f - * @returns {AsyncIterable} + * @template T + * @param {RemoteCallback} remote + * @returns {function(T):void | function(T, Transferable[]):void} */ -const mapAsyncIterable = async function * (source, f) { - for await (const item of source) { - yield f(item) +const decodeCallback = ({ port }) => { + /** + * @param {T} value + * @param {Transferable[]} [transfer] + * @returns {void} + */ + const callback = (value, transfer = []) => { + port.postMessage(value, transfer) } + + return callback } -exports.mapAsyncIterable = mapAsyncIterable +exports.decodeCallback = decodeCallback diff --git a/packages/ipfs-message-port-protocol/src/data.ts b/packages/ipfs-message-port-protocol/src/data.ts index 6fca8446e9..91b31b04e5 100644 --- a/packages/ipfs-message-port-protocol/src/data.ts +++ b/packages/ipfs-message-port-protocol/src/data.ts @@ -29,17 +29,6 @@ export type HashAlg = string export type FileType = 'directory' | 'file' export type CIDVersion = 0 | 1 -export type RemoteIterable<_T> = { - type: 'RemoteIterable' - port: MessagePort - transfer: [MessagePort] -} - -export type RemoteCallback<_T> = { - type: 'RemoteCallback' - port: MessagePort -} - export type Result = { ok: true; value: T } | { ok: false; error: X } export type EncodedError = { diff --git a/packages/ipfs-message-port-protocol/test/browser.js b/packages/ipfs-message-port-protocol/test/browser.js new file mode 100644 index 0000000000..9f9438ba43 --- /dev/null +++ b/packages/ipfs-message-port-protocol/test/browser.js @@ -0,0 +1,4 @@ +'use strict' + +require('./dag.browser') +require('./core.browser') diff --git a/packages/ipfs-message-port-protocol/test/core.browser.js b/packages/ipfs-message-port-protocol/test/core.browser.js new file mode 100644 index 0000000000..33be795284 --- /dev/null +++ b/packages/ipfs-message-port-protocol/test/core.browser.js @@ -0,0 +1,282 @@ +'use strict' + +/* eslint-env mocha */ + +const { + encodeCallback, + decodeCallback, + encodeAsyncIterable, + decodeAsyncIterable +} = require('../src/core') +const { ipc } = require('./util') +const { expect } = require('interface-ipfs-core/src/utils/mocha') +const { Buffer } = require('buffer') + +describe('core', function () { + this.timeout(10 * 1000) + const move = ipc() + + describe('remote callback', () => { + it('remote callback copies arguments', async () => { + let deliver = null + const callback = progress => { + deliver(progress) + } + const receive = () => + new Promise(resolve => { + deliver = resolve + }) + + const transfer = [] + const remote = decodeCallback( + await move(encodeCallback(callback, transfer), transfer) + ) + + remote(54) + expect(await receive()).to.be.equal(54) + + remote({ hello: 'world' }) + + expect(await receive()).to.be.deep.equal({ hello: 'world' }) + }) + + it('remote callback transfers buffers', async () => { + let deliver = null + const callback = progress => { + deliver(progress) + } + const receive = () => + new Promise(resolve => { + deliver = resolve + }) + + const transfer = [] + const remote = decodeCallback( + await move(encodeCallback(callback, transfer), transfer) + ) + + remote({ hello: Buffer.from('world') }) + expect(await receive()).to.be.deep.equal({ hello: Buffer.from('world') }) + + const world = Buffer.from('world') + remote({ hello: world }, [world.buffer]) + + expect(await receive()).to.be.deep.equal({ hello: Buffer.from('world') }) + expect(world.buffer).property('byteLength', 0, 'buffer was cleared') + }) + }) + + describe('remote async iterable', () => { + it('remote iterable copies yielded data', async () => { + const iterate = async function * () { + yield 1 + await null + yield { hello: Buffer.from('world') } + yield { items: [Buffer.from('bla'), Buffer.from('bla')] } + } + + const transfer = [] + + const remote = decodeAsyncIterable( + await move( + encodeAsyncIterable( + iterate(), + (data, transfer) => { + return data + }, + transfer + ), + transfer + ), + a => a + ) + + const incoming = [ + 1, + { hello: Buffer.from('world') }, + { items: [Buffer.from('bla'), Buffer.from('bla')] } + ] + + for await (const item of remote) { + expect(item).to.be.deep.equal(incoming.shift()) + } + + expect(incoming).to.have.property('length', 0, 'all items were received') + }) + + it('break in consumer loop propagates to producer loop', async () => { + const outgoing = [ + 1, + { hello: Buffer.from('world') }, + { items: [Buffer.from('bla'), Buffer.from('bla')] }, + { bye: 'Goodbye' } + ] + + const iterate = async function * () { + await null + while (true) { + yield outgoing.shift() + } + } + + const transfer = [] + + const remote = decodeAsyncIterable( + await move( + encodeAsyncIterable( + iterate(), + (data, transfer) => { + return data + }, + transfer + ), + transfer + ), + a => a + ) + + const incoming = [ + 1, + { hello: Buffer.from('world') }, + { items: [Buffer.from('bla'), Buffer.from('bla')] } + ] + + for await (const item of remote) { + expect(item).to.be.deep.equal(incoming.shift()) + if (incoming.length === 0) { + break + } + } + + expect(incoming).to.have.property('length', 0, 'all items were received') + expect(outgoing).to.have.property('length', 1, 'one item remained') + }) + + it('execption in producer propagate to consumer', async () => { + const iterate = async function * () { + await null + yield 1 + yield 2 + throw Error('Producer Boom!') + } + + const transfer = [] + + const remote = decodeAsyncIterable( + await move( + encodeAsyncIterable( + iterate(), + (data, transfer) => { + return data + }, + transfer + ), + transfer + ), + a => a + ) + + const incoming = [1, 2] + + const consume = async () => { + for await (const item of remote) { + expect(item).to.be.deep.equal(incoming.shift()) + } + } + + const result = await consume().catch(error => error) + + expect(result).to.an.instanceOf(Error) + expect(result).to.have.property('message', 'Producer Boom!') + expect(incoming).to.have.property('length', 0, 'all items were recieved') + }) + + it('execption in consumer propagate to producer', async () => { + const outgoing = [1, 2, 3] + + const iterate = async function * () { + await null + while (true) { + yield outgoing.shift() + } + } + + const transfer = [] + + const remote = decodeAsyncIterable( + await move( + encodeAsyncIterable( + iterate(), + (data, transfer) => { + return data + }, + transfer + ), + transfer + ), + a => a + ) + + const incoming = [1, 2] + + const consume = async () => { + for await (const item of remote) { + expect(item).to.be.deep.equal(incoming.shift()) + if (incoming.length === 0) { + throw new Error('Consumer Boom!') + } + } + } + + const result = await consume().catch(error => error) + + expect(result).to.an.instanceOf(Error) + expect(result).to.have.property('message', 'Consumer Boom!') + + expect(outgoing).to.be.deep.equal([3], 'Producer loop was broken') + }) + + it('iterable transfers yield data', async () => { + const hi = Buffer.from('hello world') + const body = Buffer.from('how are you') + const bye = Buffer.from('Bye') + const outgoing = [hi, body, bye] + const iterate = async function * () { + await null + yield * outgoing + } + + const transfer = [] + + const remote = decodeAsyncIterable( + await move( + encodeAsyncIterable( + iterate(), + (data, transfer) => { + transfer.push(data.buffer) + return data + }, + transfer + ), + transfer + ), + a => a + ) + + const incoming = [ + Buffer.from('hello world'), + Buffer.from('how are you'), + Buffer.from('Bye') + ] + + for await (const data of remote) { + expect(data).to.be.deep.equal(incoming.shift()) + } + + expect(outgoing).property('length', 3) + expect(hi).property('byteLength', 0) + expect(body).property('byteLength', 0) + expect(bye).property('byteLength', 0) + }) + }) +}) diff --git a/packages/ipfs-message-port-protocol/test/dag.browser.js b/packages/ipfs-message-port-protocol/test/dag.browser.js new file mode 100644 index 0000000000..c7fc26c3d1 --- /dev/null +++ b/packages/ipfs-message-port-protocol/test/dag.browser.js @@ -0,0 +1,120 @@ +'use strict' + +/* eslint-env mocha */ + +const CID = require('cids') +const { encodeCID, decodeCID, encodeNode, decodeNode } = require('../src/dag') +const { ipc } = require('./util') +const { expect } = require('interface-ipfs-core/src/utils/mocha') +const { Buffer } = require('buffer') + +describe('dag (browser)', function () { + this.timeout(10 * 1000) + const move = ipc() + + describe('encodeCID / decodeCID', () => { + it('should decode to CID over message channel', async () => { + const cidIn = new CID('Qmd7xRhW5f29QuBFtqu3oSD27iVy35NRB91XFjmKFhtgMr') + const cidDataIn = encodeCID(cidIn) + const cidDataOut = await move(cidDataIn) + const cidOut = decodeCID(cidDataOut) + + expect(cidOut).to.be.an.instanceof(CID) + expect(CID.isCID(cidOut)).to.be.true() + expect(cidOut.equals(cidIn)).to.be.true() + expect(cidIn.multihash) + .property('byteLength') + .not.be.equal(0) + }) + + it('should decode CID and transfer bytes', async () => { + const cidIn = new CID('Qmd7xRhW5f29QuBFtqu3oSD27iVy35NRB91XFjmKFhtgMr') + const transfer = [] + const cidDataIn = encodeCID(cidIn, transfer) + const cidDataOut = await move(cidDataIn, transfer) + const cidOut = decodeCID(cidDataOut) + + expect(cidOut).to.be.an.instanceof(CID) + expect(CID.isCID(cidOut)).to.be.true() + expect(cidIn.multihash).property('byteLength', 0) + expect(cidOut.multihash) + .property('byteLength') + .to.not.be.equal(0) + expect(cidOut.toString()).to.be.equal( + 'Qmd7xRhW5f29QuBFtqu3oSD27iVy35NRB91XFjmKFhtgMr' + ) + }) + + it('should decode dagNode over message channel', async () => { + const cid1 = new CID( + 'bafyreic6f672hnponukaacmk2mmt7vs324zkagvu4hcww6yba6kby25zce' + ) + const cid2 = new CID('QmPv52ekjS75L4JmHpXVeuJ5uX2ecSfSZo88NSyxwA3rAQ') + + const hi = Buffer.from('hello world') + const nodeIn = { + hi, + nested: { + structure: { + with: { + links: [cid1] + } + } + }, + other: { + link: cid2 + } + } + + const nodeOut = decodeNode(await move(encodeNode(nodeIn))) + + expect(nodeOut).to.be.deep.equal(nodeIn) + }) + + it('should decode dagNode over message channel & transfer bytes', async () => { + const cid1 = new CID( + 'bafyreic6f672hnponukaacmk2mmt7vs324zkagvu4hcww6yba6kby25zce' + ) + const cid2 = new CID('QmPv52ekjS75L4JmHpXVeuJ5uX2ecSfSZo88NSyxwA3rAQ') + + const hi = Buffer.from('hello world') + const nodeIn = { + hi: Buffer.from(hi), + nested: { + structure: { + with: { + links: [new CID(cid1)] + } + } + }, + other: { + link: new CID(cid2) + } + } + const transfer = [] + + const nodeOut = decodeNode( + await move(encodeNode(nodeIn, transfer), transfer) + ) + + expect(nodeOut).to.be.deep.equal({ + hi, + nested: { + structure: { + with: { + links: [cid1] + } + } + }, + other: { + link: cid2 + } + }) + + expect(transfer).to.containSubset( + [{ byteLength: 0 }, { byteLength: 0 }, { byteLength: 0 }], + 'tarnsferred buffers were cleared' + ) + }) + }) +}) diff --git a/packages/ipfs-message-port-protocol/test/dag.spec.js b/packages/ipfs-message-port-protocol/test/dag.spec.js new file mode 100644 index 0000000000..a2b570788f --- /dev/null +++ b/packages/ipfs-message-port-protocol/test/dag.spec.js @@ -0,0 +1,133 @@ +'use strict' + +/* eslint-env mocha */ + +const CID = require('cids') +const { encodeCID, decodeCID, encodeNode } = require('../src/dag') +const { expect } = require('interface-ipfs-core/src/utils/mocha') +const { Buffer } = require('buffer') + +describe('dag', function () { + this.timeout(10 * 1000) + + describe('encodeCID / decodeCID', () => { + it('should encode CID', () => { + const { multihash, codec, version } = encodeCID( + new CID('Qmd7xRhW5f29QuBFtqu3oSD27iVy35NRB91XFjmKFhtgMr') + ) + expect(multihash).to.be.an.instanceof(Uint8Array) + expect(version).to.be.a('number') + expect(codec).to.be.a('string') + }) + + it('should decode CID', () => { + const { multihash, codec, version } = encodeCID( + new CID('Qmd7xRhW5f29QuBFtqu3oSD27iVy35NRB91XFjmKFhtgMr') + ) + const cid = new CID('Qmd7xRhW5f29QuBFtqu3oSD27iVy35NRB91XFjmKFhtgMr') + const decodecCID = decodeCID({ multihash, codec, version }) + + expect(cid.equals(decodecCID)).to.be.true() + }) + }) + + describe('encodeNode / decodeNode', () => { + it('shoud encode node', () => { + const cid1 = new CID( + 'bafyreic6f672hnponukaacmk2mmt7vs324zkagvu4hcww6yba6kby25zce' + ) + const cid2 = new CID('QmPv52ekjS75L4JmHpXVeuJ5uX2ecSfSZo88NSyxwA3rAQ') + const dagNode = { + hi: 'hello', + link: cid1, + nested: { + struff: { + here: cid2 + } + } + } + + const data = encodeNode(dagNode) + + expect(data.dagNode).to.be.equal(dagNode) + expect(data.cids).to.be.an.instanceOf(Array) + expect(data.cids).to.have.property('length', 2) + expect(data.cids).to.include(cid1) + expect(data.cids).to.include(cid2) + }) + + it('shoud encode and add buffers to transfer list', () => { + const cid1 = new CID( + 'bafyreic6f672hnponukaacmk2mmt7vs324zkagvu4hcww6yba6kby25zce' + ) + const cid2 = new CID('QmPv52ekjS75L4JmHpXVeuJ5uX2ecSfSZo88NSyxwA3rAQ') + + const hi = Buffer.from('hello world') + const dagNode = { + hi, + nested: { + structure: { + with: { + links: [cid1] + } + } + }, + other: { + link: cid2 + } + } + + const transfer = [] + const data = encodeNode(dagNode, transfer) + + expect(data.dagNode).to.be.equal(dagNode) + expect(data.cids).to.be.an.instanceOf(Array) + expect(data.cids).to.have.property('length', 2) + expect(data.cids).to.include(cid1) + expect(data.cids).to.include(cid2) + + expect(transfer).to.be.an.instanceOf(Array) + expect(transfer).to.have.property('length', 3) + expect(transfer).to.include(cid1.multihash.buffer) + expect(transfer).to.include(cid2.multihash.buffer) + expect(transfer).to.include(hi.buffer) + }) + + it('shoud decode node', () => { + const cid1 = new CID( + 'bafyreic6f672hnponukaacmk2mmt7vs324zkagvu4hcww6yba6kby25zce' + ) + const cid2 = new CID('QmPv52ekjS75L4JmHpXVeuJ5uX2ecSfSZo88NSyxwA3rAQ') + + const hi = Buffer.from('hello world') + const dagNode = { + hi, + nested: { + structure: { + with: { + links: [cid1] + } + } + }, + other: { + link: cid2 + } + } + + const transfer = [] + const data = encodeNode(dagNode, transfer) + + expect(data.dagNode).to.be.equal(dagNode) + expect(data.cids).to.be.an.instanceOf(Array) + expect(data.cids).to.have.property('length', 2) + expect(data.cids).to.include(cid1) + expect(data.cids).to.include(cid2) + + expect(transfer).to.be.an.instanceOf(Array) + expect(transfer).to.have.property('length', 3) + expect(transfer).to.include(cid1.multihash.buffer) + expect(transfer).to.include(cid2.multihash.buffer) + expect(transfer).to.include(hi.buffer) + }) + }) +}) diff --git a/packages/ipfs-message-port-protocol/test/node.js b/packages/ipfs-message-port-protocol/test/node.js new file mode 100644 index 0000000000..2ef7c78345 --- /dev/null +++ b/packages/ipfs-message-port-protocol/test/node.js @@ -0,0 +1,3 @@ +'use strict' + +require('./dag.spec') diff --git a/packages/ipfs-message-port-protocol/test/util.js b/packages/ipfs-message-port-protocol/test/util.js new file mode 100644 index 0000000000..299ce49445 --- /dev/null +++ b/packages/ipfs-message-port-protocol/test/util.js @@ -0,0 +1,42 @@ +'use strict' +/* eslint-env browser */ + +const ipc = () => { + const { port1: sender, port2: receiver } = new MessageChannel() + let out = true + const move = async (data, transfer) => { + await out + return await new Promise(resolve => { + receiver.onmessage = event => resolve(event.data) + sender.postMessage(data, transfer) + }) + } + + /** + * @template T + * @param {T} data + * @param {Transferable[]} [transfer] + * @returns {Promise} + */ + const ipcMove = async (data, transfer = []) => { + out = move(data, transfer) + return await out + } + + return ipcMove +} +exports.ipc = ipc + +/** + * @returns {[Promise, function(T):void, function(any):void]} + */ +const defer = () => { + const result = [] + result.unshift( + new Promise((resolve, reject) => { + result.push(resolve, reject) + }) + ) + return result +} +exports.defer = defer diff --git a/packages/ipfs-message-port-server/package.json b/packages/ipfs-message-port-server/package.json index d9b1dbcc5f..b0e703500c 100644 --- a/packages/ipfs-message-port-server/package.json +++ b/packages/ipfs-message-port-server/package.json @@ -15,14 +15,13 @@ "url": "git+https://github.com/ipfs/js-ipfs.git" }, "scripts": { - "test": "cross-env ECHO_SERVER_PORT=37490 aegir test", - "test:node": "cross-env ECHO_SERVER_PORT=37491 aegir test -t node", - "test:browser": "cross-env ECHO_SERVER_PORT=37492 aegir test -t browser", - "test:webworker": "cross-env ECHO_SERVER_PORT=37493 aegir test -t webworker", - "test:electron-main": "cross-env ECHO_SERVER_PORT=37494 aegir test -t electron-main", - "test:electron-renderer": "cross-env ECHO_SERVER_PORT=37495 aegir test -t electron-renderer", - "test:chrome": "cross-env ECHO_SERVER_PORT=37496 aegir test -t browser -t webworker -- --browsers ChromeHeadless", - "test:firefox": "cross-env ECHO_SERVER_PORT=37497 aegir test -t browser -t webworker -- --browsers FirefoxHeadless", + "test": "aegir test", + "test:browser": "aegir test -t browser", + "test:webworker": "aegir test -t webworker", + "test:electron-main": "aegir test -t electron-main", + "test:electron-renderer": "aegir test -t electron-renderer", + "test:chrome": "aegir test -t browser -t webworker -- --browsers ChromeHeadless", + "test:firefox": "aegir test -t browser -t webworker -- --browsers FirefoxHeadless", "lint": "aegir lint", "build": "aegir build", "coverage": "npx nyc -r html npm run test:node -- --bail", @@ -33,7 +32,7 @@ "cids": "^0.8.0" }, "devDependencies": { - "ipfs-message-port-protocol": "^0.0.1", + "ipfs-message-port-protocol": "~0.0.1", "ipfs": "^0.45.0", "aegir": "^22.0.0", "cross-env": "^7.0.0", diff --git a/packages/ipfs-message-port-server/src/core.js b/packages/ipfs-message-port-server/src/core.js index ab8873efdd..0bd04c4c45 100644 --- a/packages/ipfs-message-port-server/src/core.js +++ b/packages/ipfs-message-port-server/src/core.js @@ -3,19 +3,20 @@ /* eslint-env browser */ const { - decodeRemoteIterable, - encodeAsyncIterable, - mapAsyncIterable + decodeAsyncIterable, + encodeAsyncIterable } = require('ipfs-message-port-protocol/src/core') -const { decodeCID } = require('ipfs-message-port-protocol/src/dag') +const { decodeCID, encodeCID } = require('ipfs-message-port-protocol/src/dag') /** /** * @typedef {import("./ipfs").IPFS} IPFS * @typedef {import("ipfs-message-port-protocol/src/data").Time} Time + * @typedef {import("ipfs-message-port-protocol/src/data").UnixFSTime} UnixFSTime * @typedef {import("ipfs-message-port-protocol/src/data").Mode} Mode * @typedef {import("ipfs-message-port-protocol/src/data").HashAlg} HashAlg + * @typedef {import('ipfs-message-port-protocol/src/data').FileType} FileType * @typedef {import('ipfs-message-port-protocol/src/dag').EncodedCID} EncodedCID * @typedef {import("./ipfs").FileOutput} FileOutput * @typedef {import('./ipfs').FileObject} FileObject @@ -23,6 +24,16 @@ const { decodeCID } = require('ipfs-message-port-protocol/src/dag') * @typedef {import('./ipfs').FileInput} DecodedFileInput */ +/** + * @template T + * @typedef {import('ipfs-message-port-protocol/src/core').RemoteCallback} RemoteCallback + */ + +/** + * @template T + * @typedef {import('ipfs-message-port-protocol/src/core').RemoteIterable} RemoteIterable + */ + /** * @typedef {Object} AddQuery * @property {AddInput} input @@ -32,7 +43,7 @@ const { decodeCID } = require('ipfs-message-port-protocol/src/dag') * @property {HashAlg} [hashAlg] * @property {boolean} [onlyHash] * @property {boolean} [pin] - * @property {RemoteCallback} [progress] + * @property {RemoteCallback|void} [progress] * @property {boolean} [rawLeaves] * @property {number} [shardSplitThreshold] * @property {boolean} [trickle] @@ -59,15 +70,11 @@ const { decodeCID } = require('ipfs-message-port-protocol/src/dag') * @property {UnixFSTime} mtime * @property {number} size * - * @typedef {RemoteIterable} AddResult - * * @typedef {Object} CatQuery * @property {string} path * @property {number} [offset] * @property {number} [length] * - * @typedef {RemoteIterable} CatResult - * * @typedef {Object} GetQuery * @property {string} path * @@ -76,7 +83,7 @@ const { decodeCID } = require('ipfs-message-port-protocol/src/dag') * @typedef {Object} FileEntry * @property {string} path * @property {RemoteIterable} content - * @property {Mtime} [mode] + * @property {Mode} [mode] * @property {UnixFSTime} [mtime] * * @typedef {Object} LsQuery @@ -95,11 +102,6 @@ const { decodeCID } = require('ipfs-message-port-protocol/src/dag') * @property {UnixFSTime} mtime */ -/** - * @template T - * @typedef {import('ipfs-message-port-protocol/src/data').RemoteIterable} RemoteIterable - */ - /** * @class */ @@ -113,7 +115,10 @@ class Core { } /** - * + * @typedef {Object} AddResult + * @property {RemoteIterable} data + * @property {Transferable[]} transfer + * @param {AddQuery} query * @returns {AddResult} */ @@ -155,19 +160,23 @@ class Core { } /** + * @typedef {Object} CatResult + * @property {RemoteIterable} data + * @property {Transferable[]} transfer + * * @param {Object} query * @param {string|EncodedCID} query.path * @param {number} [query.offset] * @param {number} [query.length] * @param {number} [query.timeout] * @param {AbortSignal} [query.signal] - * @returns {RemoteIterable} + * @returns {CatResult} */ cat (query) { const { path, offset, length, timeout, signal } = query const location = typeof path === 'string' ? path : decodeCID(path) const content = this.ipfs.cat(location, { offset, length, timeout, signal }) - return encodeAsyncIterable(content) + return encodeCatResult(content) } } @@ -182,11 +191,7 @@ const decodeAddInput = input => * @param {*} data * @returns {*} */ - data => { - const iterable = decodeRemoteIterable(data) - const decoded = mapAsyncIterable(iterable, decodFileInput) - return decoded - } + data => decodeAsyncIterable(data, decodFileInput) ) /** @@ -208,7 +213,8 @@ const decodFileInput = input => * @param {FileContent} content * @returns {DecodedFileContent} */ -const decodeFileContent = content => matchInput(content, decodeRemoteIterable) +const decodeFileContent = content => + matchInput(content, input => decodeAsyncIterable(input, identity)) /** * @template I,O @@ -232,19 +238,55 @@ const matchInput = (input, decode) => { /** * * @param {AsyncIterable} out - * @returns {RemoteIterable} + * @returns {AddResult} + */ +const encodeAddResult = out => { + /** @type {Transferable[]} */ + const transfer = [] + return { + data: encodeAsyncIterable(out, encodeFileOutput, transfer), + transfer + } +} + +/** + * + * @param {AsyncIterable} content + * @returns {CatResult} + */ +const encodeCatResult = content => { + /** @type {Transferable[]} */ + const transfer = [] + return { data: encodeAsyncIterable(content, moveBuffer, transfer), transfer } +} + +/** + * Adds underlying `ArrayBuffer` to the transfer list. + * @param {Buffer} buffer + * @param {Transferable[]} transfer + * @returns {Buffer} */ -const encodeAddResult = out => - encodeAsyncIterable(mapAsyncIterable(out, encodeFileOutput)) +const moveBuffer = (buffer, transfer) => { + transfer.push(buffer.buffer) + return buffer +} /** * * @param {FileOutput} file + * @param {Transferable[]} _transfer */ -const encodeFileOutput = file => ({ +const encodeFileOutput = (file, _transfer) => ({ ...file, - cid: file.cid.toString() + cid: encodeCID(file.cid) }) +/** + * @template T + * @param {T} v + * @returns {T} + */ +const identity = v => v + exports.Core = Core diff --git a/packages/ipfs-message-port-server/src/ipfs.ts b/packages/ipfs-message-port-server/src/ipfs.ts index 8597a0bc61..c82831756c 100644 --- a/packages/ipfs-message-port-server/src/ipfs.ts +++ b/packages/ipfs-message-port-server/src/ipfs.ts @@ -64,7 +64,7 @@ type AddOptions = { pin?: boolean progress?: (progress: number) => void rawLeaves?: boolean - shardSplitThreshold?: boolean + shardSplitThreshold?: number trickle?: boolean wrapWithDirectory?: boolean diff --git a/packages/ipfs-message-port-server/src/server.js b/packages/ipfs-message-port-server/src/server.js index 1c62325e44..92891bb2b7 100644 --- a/packages/ipfs-message-port-server/src/server.js +++ b/packages/ipfs-message-port-server/src/server.js @@ -98,7 +98,6 @@ /** * @template T * @extends {ServiceQuery} - * @implements {ServiceQuery} */ class Query { /** diff --git a/packages/ipfs-message-port-server/test/basic.spec.js b/packages/ipfs-message-port-server/test/basic.spec.js new file mode 100644 index 0000000000..424e4c90e5 --- /dev/null +++ b/packages/ipfs-message-port-server/test/basic.spec.js @@ -0,0 +1,46 @@ +'use strict' + +/* eslint-env mocha */ +const { Server } = require('../src/server') +const { IPFSService } = require('../src/index') +const { expect } = require('interface-ipfs-core/src/utils/mocha') + +describe('dag', function () { + this.timeout(10 * 1000) + + describe('Server', () => { + it('IPFSService', () => { + expect(IPFSService).to.be.a('function') + const service = new IPFSService() + expect(service).to.be.an.instanceOf(IPFSService) + expect(service).to.have.property('dag') + expect(service) + .to.have.nested.property('dag.put') + .be.a('function') + expect(service) + .to.have.nested.property('dag.get') + .be.a('function') + expect(service) + .to.have.nested.property('dag.tree') + .be.a('function') + }) + it('Server', () => { + expect(Server).to.be.a('function') + const service = new IPFSService() + const server = new Server(service) + + expect(server).to.be.an.instanceOf(Server) + expect(server) + .to.have.property('connect') + .be.a('function') + + expect(server) + .to.have.property('disconnect') + .be.a('function') + + expect(server) + .to.have.property('execute') + .to.be.a('function') + }) + }) +}) diff --git a/packages/ipfs-message-port-server/test/node.js b/packages/ipfs-message-port-server/test/node.js new file mode 100644 index 0000000000..ccacec309b --- /dev/null +++ b/packages/ipfs-message-port-server/test/node.js @@ -0,0 +1 @@ +'use strict' From 102b1ae6d5ac6f80382db3990f08e19476c35f7d Mon Sep 17 00:00:00 2001 From: Irakli Gozalishvili Date: Fri, 12 Jun 2020 17:43:09 -0700 Subject: [PATCH 11/63] chore: fix test scripts --- packages/ipfs-message-port-client/package.json | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-) diff --git a/packages/ipfs-message-port-client/package.json b/packages/ipfs-message-port-client/package.json index e9eef14c89..042928e82d 100644 --- a/packages/ipfs-message-port-client/package.json +++ b/packages/ipfs-message-port-client/package.json @@ -15,13 +15,12 @@ "url": "git+https://github.com/ipfs/js-ipfs.git" }, "scripts": { - "test": "aegir build -- --config ./test/util/webpack.config.js && aegir build -- cross-env ECHO_SERVER_PORT=37490 aegir test -t browser", - "test:browser": "cross-env ECHO_SERVER_PORT=37492 aegir test -t browser", - "test:electron-main": "cross-env ECHO_SERVER_PORT=37494 aegir test -t electron-main", - "test:electron-renderer": "cross-env ECHO_SERVER_PORT=37495 aegir test -t electron-renderer", - "test:chrome": "cross-env ECHO_SERVER_PORT=37496 aegir test -t browser -- --browsers ChromeHeadless", - "test:firefox": "cross-env ECHO_SERVER_PORT=37497 aegir test -t browser -- --browsers FirefoxHeadless", + "test": "npm run test:browser", + "test:browser": "npm run build:test-worker && aegir test -t browser", + "test:chrome": "aegir test -t browser -- --browsers ChromeHeadless", + "test:firefox": "aegir test -t browser -- --browsers FirefoxHeadless", "lint": "aegir lint", + "build:test-worker": "aegir build -- --config ./test/util/webpack.config.js", "build": "aegir build", "coverage": "npx nyc -r html npm run test:node -- --bail", "clean": "rm -rf ./dist", From a37fd8e827f8ad7993dc50f9e7705f9ae2de8a30 Mon Sep 17 00:00:00 2001 From: Irakli Gozalishvili Date: Mon, 15 Jun 2020 14:57:09 -0700 Subject: [PATCH 12/63] chore: propagated dependency changes --- packages/interface-ipfs-core/package.json | 4 ++-- packages/ipfs-http-client/package.json | 4 ++-- packages/ipfs-message-port-client/package.json | 4 ++-- packages/ipfs-message-port-protocol/package.json | 2 +- packages/ipfs-message-port-server/package.json | 4 ++-- packages/ipfs/package.json | 4 ++-- 6 files changed, 11 insertions(+), 11 deletions(-) diff --git a/packages/interface-ipfs-core/package.json b/packages/interface-ipfs-core/package.json index 12898c51dc..7de4adab0e 100644 --- a/packages/interface-ipfs-core/package.json +++ b/packages/interface-ipfs-core/package.json @@ -37,8 +37,8 @@ "ipfs-unixfs": "^1.0.3", "ipfs-unixfs-importer": "^2.0.2", "ipfs-utils": "^2.2.2", - "ipld-block": "git://github.com/gozala/js-ipld-block.git#uint8array", - "ipld-dag-cbor": "git://github.com/gozala/js-ipld-dag-cbor.git#uint8array", + "ipld-block": "^0.9.2", + "ipld-dag-cbor": "^0.15.3", "ipld-dag-pb": "git://github.com/gozala/js-ipld-dag-pb.git#pure-data-model", "is-ipfs": "^1.0.3", "iso-random-stream": "^1.1.1", diff --git a/packages/ipfs-http-client/package.json b/packages/ipfs-http-client/package.json index 3c2e36822c..be22a31c61 100644 --- a/packages/ipfs-http-client/package.json +++ b/packages/ipfs-http-client/package.json @@ -43,8 +43,8 @@ "form-data": "^3.0.0", "ipfs-core-utils": "^0.2.3", "ipfs-utils": "^2.2.2", - "ipld-block": "git://github.com/gozala/js-ipld-block.git#uint8array", - "ipld-dag-cbor": "git://github.com/gozala/js-ipld-dag-cbor.git#uint8array", + "ipld-block": "^0.9.2", + "ipld-dag-cbor": "^0.15.3", "ipld-dag-pb": "git://github.com/gozala/js-ipld-dag-pb.git#pure-data-model", "ipld-raw": "^4.0.1", "iso-url": "^0.4.7", diff --git a/packages/ipfs-message-port-client/package.json b/packages/ipfs-message-port-client/package.json index 042928e82d..76eebc2738 100644 --- a/packages/ipfs-message-port-client/package.json +++ b/packages/ipfs-message-port-client/package.json @@ -33,10 +33,10 @@ "ipfs-message-port-protocol": "~0.0.1", "ipfs-message-port-server": "~0.0.1", "ipld-dag-pb": "git://github.com/gozala/js-ipld-dag-pb.git#pure-data-model", - "ipfs": "^0.45.0", + "ipfs": "^0.46.0", "aegir": "^22.0.0", "cross-env": "^7.0.0", - "interface-ipfs-core": "^0.135.1" + "interface-ipfs-core": "^0.136.0" }, "engines": { "node": ">=10.3.0", diff --git a/packages/ipfs-message-port-protocol/package.json b/packages/ipfs-message-port-protocol/package.json index a56f8b2881..1a66e5d9f1 100644 --- a/packages/ipfs-message-port-protocol/package.json +++ b/packages/ipfs-message-port-protocol/package.json @@ -34,7 +34,7 @@ }, "devDependencies": { "aegir": "^22.0.0", - "interface-ipfs-core": "^0.135.1" + "interface-ipfs-core": "^0.136.0" }, "engines": { "node": ">=10.3.0", diff --git a/packages/ipfs-message-port-server/package.json b/packages/ipfs-message-port-server/package.json index b0e703500c..bee0b0e802 100644 --- a/packages/ipfs-message-port-server/package.json +++ b/packages/ipfs-message-port-server/package.json @@ -33,10 +33,10 @@ }, "devDependencies": { "ipfs-message-port-protocol": "~0.0.1", - "ipfs": "^0.45.0", + "ipfs": "^0.46.0", "aegir": "^22.0.0", "cross-env": "^7.0.0", - "interface-ipfs-core": "^0.135.1" + "interface-ipfs-core": "^0.136.0" }, "engines": { "node": ">=10.3.0", diff --git a/packages/ipfs/package.json b/packages/ipfs/package.json index 68d47d5dcc..9d21f1c56b 100644 --- a/packages/ipfs/package.json +++ b/packages/ipfs/package.json @@ -98,8 +98,8 @@ "ipfs-utils": "^2.2.2", "ipld": "^0.26.2", "ipld-bitcoin": "^0.3.0", - "ipld-block": "git://github.com/gozala/js-ipld-block.git#uint8array", - "ipld-dag-cbor": "git://github.com/gozala/js-ipld-dag-cbor.git#uint8array", + "ipld-block": "^0.9.2", + "ipld-dag-cbor": "^0.15.3", "ipld-dag-pb": "git://github.com/gozala/js-ipld-dag-pb.git#pure-data-model", "ipld-ethereum": "^4.0.0", "ipld-git": "^0.5.0", From 1e4f5833340e883630e760099b8a70d25b542008 Mon Sep 17 00:00:00 2001 From: Irakli Gozalishvili Date: Mon, 15 Jun 2020 18:31:32 -0700 Subject: [PATCH 13/63] chore: rever unecessary changes in interface-tests --- packages/interface-ipfs-core/src/dag/get.js | 82 ++++++------------- packages/interface-ipfs-core/src/dag/tree.js | 37 +++++---- .../test/interface.spec.js | 33 +++++++- 3 files changed, 76 insertions(+), 76 deletions(-) diff --git a/packages/interface-ipfs-core/src/dag/get.js b/packages/interface-ipfs-core/src/dag/get.js index 045a54e5dc..b88a6fa729 100644 --- a/packages/interface-ipfs-core/src/dag/get.js +++ b/packages/interface-ipfs-core/src/dag/get.js @@ -23,9 +23,7 @@ module.exports = (common, options) => { describe('.dag.get', () => { let ipfs - before(async () => { - ipfs = (await common.spawn()).api - }) + before(async () => { ipfs = (await common.spawn()).api }) after(() => common.clean()) @@ -57,18 +55,12 @@ module.exports = (common, options) => { }) it('should respect timeout option when getting a DAG node', () => { - return testTimeout(() => - ipfs.dag.get( - new CID('QmPv52ekjS75L4JmHpXVeuJ5uX2ecSfSZo88NSyxwA3rAQ'), - { - timeout: 1 - } - ) - ) + return testTimeout(() => ipfs.dag.get(new CID('QmPv52ekjS75L4JmHpXVeuJ5uX2ecSfSZo88NSyxwA3rAQ'), { + timeout: 1 + })) }) - // TODO: Return nodes are not turned into DAGNode's from dag-pb - it.skip('should get a dag-pb node', async () => { + it('should get a dag-pb node', async () => { const cid = await ipfs.dag.put(pbNode, { format: 'dag-pb', hashAlg: 'sha2-256' @@ -92,8 +84,7 @@ module.exports = (common, options) => { expect(cborNode).to.eql(node) }) - // TODO: Returnd node are not turned into DAGNode's from dag-pb - it.skip('should get a dag-pb node with path', async () => { + it('should get a dag-pb node with path', async () => { const result = await ipfs.dag.get(cidPb, '/') const node = result.value @@ -107,8 +98,8 @@ module.exports = (common, options) => { expect(result.value).to.eql(Buffer.from('I am inside a Protobuf')) }) - it.skip('should get a dag-pb node value one level deep', done => {}) - it.skip('should get a dag-pb node value two levels deep', done => {}) + it.skip('should get a dag-pb node value one level deep', (done) => {}) + it.skip('should get a dag-pb node value two levels deep', (done) => {}) it('should get a dag-cbor node with path', async () => { const result = await ipfs.dag.get(cidCbor, '/') @@ -124,17 +115,16 @@ module.exports = (common, options) => { expect(result.value).to.eql('I am inside a Cbor object') }) - it.skip('should get dag-cbor node value one level deep', done => {}) - it.skip('should get dag-cbor node value two levels deep', done => {}) - it.skip('should get dag-cbor value via dag-pb node', done => {}) + it.skip('should get dag-cbor node value one level deep', (done) => {}) + it.skip('should get dag-cbor node value two levels deep', (done) => {}) + it.skip('should get dag-cbor value via dag-pb node', (done) => {}) it('should get dag-pb value via dag-cbor node', async function () { const result = await ipfs.dag.get(cidCbor, 'pb/Data') expect(result.value).to.eql(Buffer.from('I am inside a Protobuf')) }) - // TODO: Currently getting by cid string is not supported - it.skip('should get by CID string', async () => { + it('should get by CID string', async () => { const cidCborStr = cidCbor.toBaseEncodedString() const result = await ipfs.dag.get(cidCborStr) @@ -145,8 +135,7 @@ module.exports = (common, options) => { expect(cid).to.eql(cidCbor) }) - // TODO: Currently getting by cid string is not supported - it.skip('should get by CID string + path', async function () { + it('should get by CID string + path', async function () { const cidCborStr = cidCbor.toBaseEncodedString() const result = await ipfs.dag.get(cidCborStr + '/pb/Data') @@ -154,9 +143,7 @@ module.exports = (common, options) => { }) it('should get only a CID, due to resolving locally only', async function () { - const result = await ipfs.dag.get(cidCbor, 'pb/Data', { - localResolve: true - }) + const result = await ipfs.dag.get(cidCbor, 'pb/Data', { localResolve: true }) expect(result.value.equals(cidPb)).to.be.true() }) @@ -170,10 +157,7 @@ module.exports = (common, options) => { const node = new DAGNode(input) - const cid = await ipfs.dag.put(node, { - format: 'dag-pb', - hashAlg: 'sha2-256' - }) + const cid = await ipfs.dag.put(node, { format: 'dag-pb', hashAlg: 'sha2-256' }) expect(cid.version).to.equal(0) const cidv1 = cid.toV1() @@ -182,16 +166,13 @@ module.exports = (common, options) => { expect(output.value.Data).to.eql(input) }) - // TODO: Guessing unifxs chockes on array buffer - it.skip('should get a node added as CIDv1 with a CIDv0', async () => { + it('should get a node added as CIDv1 with a CIDv0', async () => { const input = Buffer.from(`TEST${Math.random()}`) - const res = await all( - importer([{ content: input }], ipfs.block, { - cidVersion: 1, - rawLeaves: false - }) - ) + const res = await all(importer([{ content: input }], ipfs.block, { + cidVersion: 1, + rawLeaves: false + })) const cidv1 = res[0].cid expect(cidv1.version).to.equal(1) @@ -202,21 +183,15 @@ module.exports = (common, options) => { expect(Unixfs.unmarshal(output.value.Data).data).to.eql(input) }) - // TODO: Get by string CID is not implemented - it.skip('should be able to get part of a dag-cbor node', async () => { + it('should be able to get part of a dag-cbor node', async () => { const cbor = { foo: 'dag-cbor-bar' } - let cid = await ipfs.dag.put(cbor, { - format: 'dag-cbor', - hashAlg: 'sha2-256' - }) + let cid = await ipfs.dag.put(cbor, { format: 'dag-cbor', hashAlg: 'sha2-256' }) expect(cid.codec).to.equal('dag-cbor') cid = cid.toBaseEncodedString('base32') - expect(cid).to.equal( - 'bafyreic6f672hnponukaacmk2mmt7vs324zkagvu4hcww6yba6kby25zce' - ) + expect(cid).to.equal('bafyreic6f672hnponukaacmk2mmt7vs324zkagvu4hcww6yba6kby25zce') const result = await ipfs.dag.get(cid, 'foo') expect(result.value).to.equal('dag-cbor-bar') @@ -227,22 +202,15 @@ module.exports = (common, options) => { foo: 'dag-cbor-bar' } - const cid1 = await ipfs.dag.put(cbor1, { - format: 'dag-cbor', - hashAlg: 'sha2-256' - }) + const cid1 = await ipfs.dag.put(cbor1, { format: 'dag-cbor', hashAlg: 'sha2-256' }) const cbor2 = { other: cid1 } - const cid2 = await ipfs.dag.put(cbor2, { - format: 'dag-cbor', - hashAlg: 'sha2-256' - }) + const cid2 = await ipfs.dag.put(cbor2, { format: 'dag-cbor', hashAlg: 'sha2-256' }) const result = await ipfs.dag.get(cid2, 'other/foo') expect(result.value).to.equal('dag-cbor-bar') }) - // TODO - Raw coded does not seem to support Uint8Array it('should be able to get a DAG node with format raw', async () => { const buf = Buffer.from([0, 1, 2, 3]) diff --git a/packages/interface-ipfs-core/src/dag/tree.js b/packages/interface-ipfs-core/src/dag/tree.js index 3251dbc587..ada763b097 100644 --- a/packages/interface-ipfs-core/src/dag/tree.js +++ b/packages/interface-ipfs-core/src/dag/tree.js @@ -23,9 +23,7 @@ module.exports = (common, options) => { describe('.dag.tree', () => { let ipfs - before(async () => { - ipfs = (await common.spawn()).api - }) + before(async () => { ipfs = (await common.spawn()).api }) after(() => common.clean()) @@ -49,21 +47,17 @@ module.exports = (common, options) => { }) it('should respect timeout option when resolving a DAG tree', () => { - return testTimeout(() => - drain( - ipfs.dag.tree( - new CID('QmPv52ekjS75L4JmHpXVeuJ5uX2ecSfSZo88NSyxwA3rA8'), - { - timeout: 1 - } - ) - ) - ) + return testTimeout(() => drain(ipfs.dag.tree(new CID('QmPv52ekjS75L4JmHpXVeuJ5uX2ecSfSZo88NSyxwA3rA8'), { + timeout: 1 + }))) }) it('should get tree with CID', async () => { const paths = await all(ipfs.dag.tree(cidCbor)) - expect(paths).to.eql(['pb', 'someData']) + expect(paths).to.eql([ + 'pb', + 'someData' + ]) }) it('should get tree with CID and path', async () => { @@ -71,8 +65,7 @@ module.exports = (common, options) => { expect(paths).to.eql([]) }) - // TODO: CID as string isn't supported yet - it.skip('should get tree with CID and path as String', async () => { + it('should get tree with CID and path as String', async () => { const cidCborStr = cidCbor.toBaseEncodedString() const paths = await all(ipfs.dag.tree(cidCborStr + '/someData')) @@ -81,12 +74,20 @@ module.exports = (common, options) => { it('should get tree with CID recursive (accross different formats)', async () => { const paths = await all(ipfs.dag.tree(cidCbor, { recursive: true })) - expect(paths).to.have.members(['pb', 'someData', 'pb/Links', 'pb/Data']) + expect(paths).to.have.members([ + 'pb', + 'someData', + 'pb/Links', + 'pb/Data' + ]) }) it('should get tree with CID and path recursive', async () => { const paths = await all(ipfs.dag.tree(cidCbor, 'pb', { recursive: true })) - expect(paths).to.have.members(['Links', 'Data']) + expect(paths).to.have.members([ + 'Links', + 'Data' + ]) }) }) } diff --git a/packages/ipfs-message-port-client/test/interface.spec.js b/packages/ipfs-message-port-client/test/interface.spec.js index 976612f804..b0d731f390 100644 --- a/packages/ipfs-message-port-client/test/interface.spec.js +++ b/packages/ipfs-message-port-client/test/interface.spec.js @@ -12,5 +12,36 @@ describe('interface-ipfs-core tests', () => { clean () {} } - tests.dag(commonFactory) + tests.dag(commonFactory, { + skip: [ + { + name: 'should get a dag-pb node', + reason: 'Nodes are not turned into dag-pb DAGNode instances' + }, + { + name: 'should get a dag-pb node with path', + reason: 'Nodes are not turned into dag-pb DAGNode instances' + }, + { + name: 'should get by CID string', + reason: 'Passing CID as strings is not supported' + }, + { + name: 'should get by CID string + path', + reason: 'Passing CID as strings is not supported' + }, + { + name: 'should get a node added as CIDv1 with a CIDv0', + reason: 'TODO: Guessing unifxs expects Buffer and fails on Uint8Array' + }, + { + name: 'should be able to get part of a dag-cbor node', + reason: 'Passing CID as strings is not supported' + }, + { + name: 'should get tree with CID and path as String', + reason: 'Passing CID as strings is not supported' + } + ] + }) }) From f93c402cc2024e2714217cb2365ef7bf626e29d5 Mon Sep 17 00:00:00 2001 From: Irakli Gozalishvili Date: Mon, 15 Jun 2020 20:37:05 -0700 Subject: [PATCH 14/63] chore: update reason for disabling test --- packages/ipfs-message-port-client/test/interface.spec.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/ipfs-message-port-client/test/interface.spec.js b/packages/ipfs-message-port-client/test/interface.spec.js index b0d731f390..270ce17cd0 100644 --- a/packages/ipfs-message-port-client/test/interface.spec.js +++ b/packages/ipfs-message-port-client/test/interface.spec.js @@ -32,7 +32,7 @@ describe('interface-ipfs-core tests', () => { }, { name: 'should get a node added as CIDv1 with a CIDv0', - reason: 'TODO: Guessing unifxs expects Buffer and fails on Uint8Array' + reason: 'ipfs.block API is not implemented' }, { name: 'should be able to get part of a dag-cbor node', From e2cd66dfdb0497d007d4ae55f1a2fc8cfd264e31 Mon Sep 17 00:00:00 2001 From: Irakli Gozalishvili Date: Tue, 16 Jun 2020 00:24:29 -0700 Subject: [PATCH 15/63] fix: tests for ipfs.add --- .../ipfs-message-port-client/package.json | 2 + packages/ipfs-message-port-client/src/core.js | 282 ++++++++++++++++-- .../ipfs-message-port-client/src/index.js | 24 +- .../test/interface.core.js | 9 + .../test/interface.spec.js | 60 ++++ .../ipfs-message-port-protocol/src/core.js | 36 ++- .../test/core.browser.js | 234 ++++++++++++++- packages/ipfs-message-port-server/src/core.js | 32 +- .../ipfs-message-port-server/src/index.js | 51 +--- 9 files changed, 603 insertions(+), 127 deletions(-) create mode 100644 packages/ipfs-message-port-client/test/interface.core.js diff --git a/packages/ipfs-message-port-client/package.json b/packages/ipfs-message-port-client/package.json index 76eebc2738..8b7ff188d1 100644 --- a/packages/ipfs-message-port-client/package.json +++ b/packages/ipfs-message-port-client/package.json @@ -34,6 +34,8 @@ "ipfs-message-port-server": "~0.0.1", "ipld-dag-pb": "git://github.com/gozala/js-ipld-dag-pb.git#pure-data-model", "ipfs": "^0.46.0", + "it-all": "^1.0.1", + "it-drain": "^1.0.1", "aegir": "^22.0.0", "cross-env": "^7.0.0", "interface-ipfs-core": "^0.136.0" diff --git a/packages/ipfs-message-port-client/src/core.js b/packages/ipfs-message-port-client/src/core.js index 1619e50181..ebe6da8476 100644 --- a/packages/ipfs-message-port-client/src/core.js +++ b/packages/ipfs-message-port-client/src/core.js @@ -6,21 +6,29 @@ const CID = require('cids') const { Client } = require('./client') const { encodeCID, decodeCID } = require('ipfs-message-port-protocol/src/dag') const { - decodeAsyncIterable, + decodeIterable, + encodeIterable, encodeCallback } = require('ipfs-message-port-protocol/src/core') +/** + * @template T + * @typedef {import('ipfs-message-port-protocol/src/core').RemoteIterable} RemoteIterable + */ /** * @typedef {import('ipfs-message-port-protocol/src/dag').EncodedCID} EncodedCID + * @typedef {import('ipfs-message-port-server/src/core').AddInput} EncodedAddInput + * @typedef {import('ipfs-message-port-server/src/core').FileInput} FileInput + * @typedef {import('ipfs-message-port-server/src/core').FileContent} EncodedFileContent * * @typedef {Object} NoramilzedFileInput * @property {string} path * @property {AsyncIterable} content * - * @typedef {Int8Array|Uint8Array|Uint8ClampedArray|Int16Array|Int32Array|Uint32Array|Float32Array|Float64Array|BigInt64Array|BigUint64Array} TypedArray * @typedef {ArrayBuffer|ArrayBufferView} Bytes * - * @typedef {Bytes|Blob|string|Iterable|Iterable|AsyncIterable} FileContent + * @typedef {Blob|Bytes|string|Iterable|Iterable|AsyncIterable|ReadableStream} FileContent + * * @typedef {Object} FileObject * @property {string} [path] * @property {FileContent} [content] @@ -28,10 +36,15 @@ const { * @property {UnixTime} [mtime] * * @typedef {Date|Time|[number, number]} UnixTime - * @typedef {Bytes|Blob|string|FileObject|Iterable|Iterable|Iterable|Iterable|Iterable|AsyncIterable|AsyncIterable|AsyncIterable|AsyncIterable} AnyFileInput + * + * @typedef {Blob|Bytes|string|FileObject|Iterable|Iterable|AsyncIterable|ReadableStream} SingleFileInput + * + * @typedef {Iterable|Iterable|Iterable|AsyncIterable|AsyncIterable|AsyncIterable} MultiFileInput + * + * @typedef {SingleFileInput | MultiFileInput} AddInput * */ -/** @type {(input:AnyFileInput) => AsyncIterable} */ +/** @type {(input:AddInput) => AsyncIterable} */ /** * @typedef {import("./files").Time} Time @@ -49,12 +62,14 @@ const { * @property {boolean} [trickle=false] * @property {boolean} [wrapWithDirectory=false] * @property {number} [timeout] + * @property {Transferable[]} [transfer] * @property {AbortSignal} [signal] * * @typedef {Object} AddedData * @property {string} path * @property {CID} cid * @property {number} mode + * @property {number} size * @property {Time} mtime */ @@ -68,7 +83,7 @@ const { * @class * @extends {Client} */ -class CoreService extends Client { +class Core extends Client { /** * @param {Transport} transport */ @@ -77,31 +92,26 @@ class CoreService extends Client { } /** - * @param {AnyFileInput} input + * @param {AddInput} input * @param {AddOptions} [options] * @returns {AsyncIterable} */ async * add (input, options = {}) { const { timeout, signal } = options - /** @type {Transferable[]} */ - const transfer = [] + const transfer = [...(options.transfer || [])] const progress = options.progress ? encodeCallback(options.progress, transfer) : undefined - if (input instanceof Blob) { - const result = await this.remote.add({ - ...options, - input, - progress, - transfer, - timeout, - signal - }) - yield * decodeAsyncIterable(result.data, decodeAddedData) - } else { - throw Error('Input type is not supported') - } + const result = await this.remote.add({ + ...options, + input: encodeAddInput(input, transfer), + progress, + transfer, + timeout, + signal + }) + yield * decodeIterable(result.data, decodeAddedData) } /** @@ -116,7 +126,7 @@ class CoreService extends Client { async * cat (inputPath, options = {}) { const input = CID.isCID(inputPath) ? encodeCID(inputPath) : inputPath const result = await this.remote.cat({ ...options, path: input }) - yield * decodeAsyncIterable(result.data, identity) + yield * decodeIterable(result.data, identity) } } @@ -125,12 +135,13 @@ class CoreService extends Client { * @param {AddedEntry} data * @returns {AddedData} */ -const decodeAddedData = ({ path, cid, mode, mtime }) => { +const decodeAddedData = ({ path, cid, mode, mtime, size }) => { return { path, cid: decodeCID(cid), mode, - mtime + mtime, + size } } @@ -141,4 +152,223 @@ const decodeAddedData = ({ path, cid, mode, mtime }) => { */ const identity = v => v -module.exports = CoreService +/** + * @param {AddInput} input + * @param {Transferable[]} transfer + * @returns {EncodedAddInput} + */ +const encodeAddInput = (input, transfer) => { + // We want to get a Blob as input + if (input instanceof Blob) { + return input + } else if (typeof input === 'string') { + return input + } else if (input instanceof ArrayBuffer) { + return input + } else if (ArrayBuffer.isView(input)) { + return input + } else { + const iterable = asIterable(input) + if (iterable) { + return encodeIterable(iterable, encodeIterableContent, transfer) + } + + const asyncIterable = asAsyncIterable(input) + if (asyncIterable) { + return encodeIterable(asyncIterable, encodeAsyncIterableContent, transfer) + } + + const readableStream = asReadableStream(input) + if (readableStream) { + return encodeIterable( + iterateReadableStream(readableStream), + encodeAsyncIterableContent, + transfer + ) + } + + const file = asFileObject(input) + if (file) { + return encodeFileObject(file, transfer) + } + + throw TypeError('Unexpected input: ' + typeof input) + } +} + +/** + * @param {ArrayBuffer|ArrayBufferView|Blob|string|FileObject} content + * @param {Transferable[]} transfer + * @returns {FileInput|ArrayBuffer|ArrayBufferView} + */ +const encodeAsyncIterableContent = (content, transfer) => { + if (content instanceof ArrayBuffer) { + return content + } else if (ArrayBuffer.isView(content)) { + return content + } else if (content instanceof Blob) { + return { path: '', content } + } else if (typeof content === 'string') { + return { path: '', content } + } else { + const file = asFileObject(content) + if (file) { + return encodeFileObject(file, transfer) + } else { + throw TypeError('Unexpected input: ' + typeof content) + } + } +} + +/** + * @param {number|Bytes|Blob|string|FileObject} content + * @param {Transferable[]} transfer + * @returns {FileInput|ArrayBuffer|ArrayBufferView} + */ +const encodeIterableContent = (content, transfer) => { + if (typeof content === 'number') { + throw TypeError('Iterable of numbers is not supported') + } else if (content instanceof ArrayBuffer) { + return content + } else if (ArrayBuffer.isView(content)) { + return content + } else if (content instanceof Blob) { + return { path: '', content } + } else if (typeof content === 'string') { + return { path: '', content } + } else { + const file = asFileObject(content) + if (file) { + return encodeFileObject(file, transfer) + } else { + throw TypeError('Unexpected input: ' + typeof content) + } + } +} + +/** + * @param {FileObject} file + * @param {Transferable[]} transfer + * @returns {FileInput} + */ +const encodeFileObject = ({ path, mode, mtime, content }, transfer) => { + return { + path, + mode, + mtime, + content: encodeFileContent(content, transfer) + } +} + +/** + * + * @param {FileContent} [content] + * @param {Transferable[]} transfer + * @returns {EncodedFileContent} + */ +const encodeFileContent = (content, transfer) => { + if (content == null) { + return '' + } else if (content instanceof ArrayBuffer || ArrayBuffer.isView(content)) { + return content + } else if (content instanceof Blob) { + return content + } else { + const iterable = asIterable(content) + if (iterable) { + return encodeIterable(iterable, encodeIterableContent, transfer) + } + + const asyncIterable = asAsyncIterable(content) + if (asyncIterable) { + return encodeIterable(asyncIterable, encodeAsyncIterableContent, transfer) + } + + const readableStream = asReadableStream(content) + if (readableStream) { + return encodeIterable( + iterateReadableStream(readableStream), + encodeAsyncIterableContent, + transfer + ) + } + + throw TypeError('Unexpected input: ' + typeof content) + } +} + +/** + * @template T + * @param {ReadableStream} stream + * @returns {AsyncIterable} + */ + +const iterateReadableStream = async function * (stream) { + const reader = stream.getReader() + + while (true) { + const result = await reader.read() + + if (result.done) { + return + } + + yield result.value + } +} + +/** + * @template I + * @param {Iterable|AddInput} input + * @returns {Iterable|null} + */ +const asIterable = input => { + /** @type {*} */ + const object = input + if (object && typeof object[Symbol.iterator] === 'function') { + return object + } else { + return null + } +} + +/** + * @template I + * @param {AsyncIterable|AddInput} input + * @returns {AsyncIterable|null} + */ +const asAsyncIterable = input => { + /** @type {*} */ + const object = input + if (object && typeof object[Symbol.asyncIterator] === 'function') { + return object + } else { + return null + } +} + +/** + * @param {any} input + * @returns {ReadableStream|null} + */ +const asReadableStream = input => { + if (input && typeof input.getReader === 'function') { + return input + } else { + return null + } +} + +/** + * @param {*} input + * @returns {FileObject|null} + */ +const asFileObject = input => { + if (typeof input === 'object' && (input.path || input.content)) { + return input + } else { + return null + } +} + +module.exports = Core diff --git a/packages/ipfs-message-port-client/src/index.js b/packages/ipfs-message-port-client/src/index.js index fd6074605e..0311bd5f26 100644 --- a/packages/ipfs-message-port-client/src/index.js +++ b/packages/ipfs-message-port-client/src/index.js @@ -3,6 +3,7 @@ /* eslint-env browser */ const DAG = require('./dag') +const Core = require('./core') const { Transport } = require('./client') /** @@ -10,11 +11,12 @@ const { Transport } = require('./client') * @property {MessagePort} port */ -class IPFSClient { +class IPFSClient extends Core { /** * @param {Transport} [transport] */ constructor (transport) { + super(transport) this.transport = transport this.dag = new DAG(this.transport) } @@ -50,25 +52,5 @@ class IPFSClient { return new IPFSClient(new Transport(port)) } } -/** - * - */ -// class IPFSClient { -// /** -// * @param {ClientOptions} options -// */ -// constructor (options) { -// this.connection = new RPCConnection(options.port) -// } -// get files () { -// const value = new FilesClient(this.connection) -// Object.defineProperty(this, 'files', { value }) -// return value -// } -// } -// Object.assign(IPFSClient.prototype, FilesTopClient.prototype) -// Object.assign(IPFSClient.prototype, FilesClient.prototype) - -// // Object.assign(ipfsClient, { Buffer, CID, multiaddr, multibase, multicodec, multihash, globSource, urlSource }) module.exports = IPFSClient diff --git a/packages/ipfs-message-port-client/test/interface.core.js b/packages/ipfs-message-port-client/test/interface.core.js new file mode 100644 index 0000000000..9c81f916a2 --- /dev/null +++ b/packages/ipfs-message-port-client/test/interface.core.js @@ -0,0 +1,9 @@ +/* eslint-env mocha, browser */ +'use strict' + +const { createSuite } = require('interface-ipfs-core/src/utils/suite') + +exports.core = createSuite({ + add: require('interface-ipfs-core/src/add') + // cat: require('interface-ipfs-core/src/cat') +}) diff --git a/packages/ipfs-message-port-client/test/interface.spec.js b/packages/ipfs-message-port-client/test/interface.spec.js index 270ce17cd0..f24c1b7df9 100644 --- a/packages/ipfs-message-port-client/test/interface.spec.js +++ b/packages/ipfs-message-port-client/test/interface.spec.js @@ -2,6 +2,7 @@ 'use strict' const tests = require('interface-ipfs-core') +const { core } = require('./interface.core') const { activate } = require('./util/client') describe('interface-ipfs-core tests', () => { @@ -44,4 +45,63 @@ describe('interface-ipfs-core tests', () => { } ] }) + + core(commonFactory, { + skip: [ + { + name: 'should add with only-hash=true', + reason: 'ipfs.object.get is not implemented' + }, + { + name: 'should add a directory with only-hash=true', + reason: 'ipfs.object.get is not implemented' + }, + { + name: 'should add with mode as string', + reason: 'ipfs.files.stat is not implemented' + }, + { + name: 'should add with mode as number', + reason: 'ipfs.files.stat is not implemented' + }, + { + name: 'should add with mtime as Date', + reason: 'ipfs.files.stat is not implemented' + }, + { + name: 'should add with mtime as { nsecs, secs }', + reason: 'ipfs.files.stat is not implemented' + }, + { + name: 'should add with mtime as timespec', + reason: 'ipfs.files.stat is not implemented' + }, + { + name: 'should add with mtime as hrtime', + reason: 'ipfs.files.stat is not implemented' + }, + + { + name: 'should add from a HTTP URL', + reason: 'echo server is not enabled' + }, + { + name: 'should add from a HTTP URL with redirection', + reason: 'echo server is not enabled' + }, + { + name: 'should add from a URL with only-hash=true', + reason: 'echo server is not enabled' + }, + { + name: 'should add from a URL with wrap-with-directory=true', + reason: 'echo server is not enabled' + }, + { + name: + 'should add from a URL with wrap-with-directory=true and URL-escaped file name', + reason: 'echo server is not enabled' + } + ] + }) }) diff --git a/packages/ipfs-message-port-protocol/src/core.js b/packages/ipfs-message-port-protocol/src/core.js index 0393a4b696..e31d55f9a3 100644 --- a/packages/ipfs-message-port-protocol/src/core.js +++ b/packages/ipfs-message-port-protocol/src/core.js @@ -1,5 +1,7 @@ 'use strict' +/* eslint-env browser */ + /** * @template T * @typedef {Object} RemoteIterable @@ -48,7 +50,7 @@ * @param {function(I):O} decode * @returns {AsyncIterable} */ -const decodeAsyncIterable = async function * ({ port }, decode) { +const decodeIterable = async function * ({ port }, decode) { /** * @param {RemoteNext} _data */ @@ -86,21 +88,22 @@ const decodeAsyncIterable = async function * ({ port }, decode) { port.close() } } -exports.decodeAsyncIterable = decodeAsyncIterable +exports.decodeIterable = decodeIterable /** * @template I,O - * @param {AsyncIterable} iterable + * @param {AsyncIterable|Iterable} iterable * @param {function(I, Transferable[]):O} encode * @param {Transferable[]} transfer * @returns {RemoteIterable} */ -const encodeAsyncIterable = (iterable, encode, transfer) => { - // eslint-disable-next-line no-undef +const encodeIterable = (iterable, encode, transfer) => { const { port1: port, port2: remote } = new MessageChannel() - const iterator = iterable[Symbol.asyncIterator]() /** @type {Transferable[]} */ const itemTransfer = [] + /** @type {Iterator|AsyncIterator} */ + const iterator = toIterator(iterable) + port.onmessage = async ({ data: { method } }) => { switch (method) { case 'next': { @@ -143,7 +146,26 @@ const encodeAsyncIterable = (iterable, encode, transfer) => { return { type: 'RemoteIterable', port: remote } } -exports.encodeAsyncIterable = encodeAsyncIterable +exports.encodeIterable = encodeIterable + +/** + * @template I + * @param {any} iterable + * @returns {Iterator|AsyncIterator} + */ +const toIterator = iterable => { + if (iterable != null) { + if (typeof iterable[Symbol.asyncIterator] === 'function') { + return iterable[Symbol.asyncIterator]() + } + + if (typeof iterable[Symbol.iterator] === 'function') { + return iterable[Symbol.iterator]() + } + } + + throw TypeError('Value must be async or sync iterable') +} /** * @template T diff --git a/packages/ipfs-message-port-protocol/test/core.browser.js b/packages/ipfs-message-port-protocol/test/core.browser.js index 33be795284..3f49a977d6 100644 --- a/packages/ipfs-message-port-protocol/test/core.browser.js +++ b/packages/ipfs-message-port-protocol/test/core.browser.js @@ -5,8 +5,8 @@ const { encodeCallback, decodeCallback, - encodeAsyncIterable, - decodeAsyncIterable + encodeIterable, + decodeIterable } = require('../src/core') const { ipc } = require('./util') const { expect } = require('interface-ipfs-core/src/utils/mocha') @@ -77,9 +77,9 @@ describe('core', function () { const transfer = [] - const remote = decodeAsyncIterable( + const remote = decodeIterable( await move( - encodeAsyncIterable( + encodeIterable( iterate(), (data, transfer) => { return data @@ -121,9 +121,9 @@ describe('core', function () { const transfer = [] - const remote = decodeAsyncIterable( + const remote = decodeIterable( await move( - encodeAsyncIterable( + encodeIterable( iterate(), (data, transfer) => { return data @@ -162,9 +162,9 @@ describe('core', function () { const transfer = [] - const remote = decodeAsyncIterable( + const remote = decodeIterable( await move( - encodeAsyncIterable( + encodeIterable( iterate(), (data, transfer) => { return data @@ -203,9 +203,9 @@ describe('core', function () { const transfer = [] - const remote = decodeAsyncIterable( + const remote = decodeIterable( await move( - encodeAsyncIterable( + encodeIterable( iterate(), (data, transfer) => { return data @@ -248,9 +248,219 @@ describe('core', function () { const transfer = [] - const remote = decodeAsyncIterable( + const remote = decodeIterable( await move( - encodeAsyncIterable( + encodeIterable( + iterate(), + (data, transfer) => { + transfer.push(data.buffer) + return data + }, + transfer + ), + transfer + ), + a => a + ) + + const incoming = [ + Buffer.from('hello world'), + Buffer.from('how are you'), + Buffer.from('Bye') + ] + + for await (const data of remote) { + expect(data).to.be.deep.equal(incoming.shift()) + } + + expect(outgoing).property('length', 3) + expect(hi).property('byteLength', 0) + expect(body).property('byteLength', 0) + expect(bye).property('byteLength', 0) + }) + }) + + describe('remote sync iterable', () => { + it('remote iterable copies yielded data', async () => { + const iterate = function * () { + yield 1 + yield { hello: Buffer.from('world') } + yield { items: [Buffer.from('bla'), Buffer.from('bla')] } + } + + const transfer = [] + + const remote = decodeIterable( + await move( + encodeIterable( + iterate(), + (data, transfer) => { + return data + }, + transfer + ), + transfer + ), + a => a + ) + + const incoming = [ + 1, + { hello: Buffer.from('world') }, + { items: [Buffer.from('bla'), Buffer.from('bla')] } + ] + + for await (const item of remote) { + expect(item).to.be.deep.equal(incoming.shift()) + } + + expect(incoming).to.have.property('length', 0, 'all items were received') + }) + + it('break in consumer loop propagates to producer loop', async () => { + const outgoing = [ + 1, + { hello: Buffer.from('world') }, + { items: [Buffer.from('bla'), Buffer.from('bla')] }, + { bye: 'Goodbye' } + ] + + const iterate = async function * () { + await null + while (true) { + yield outgoing.shift() + } + } + + const transfer = [] + + const remote = decodeIterable( + await move( + encodeIterable( + iterate(), + (data, transfer) => { + return data + }, + transfer + ), + transfer + ), + a => a + ) + + const incoming = [ + 1, + { hello: Buffer.from('world') }, + { items: [Buffer.from('bla'), Buffer.from('bla')] } + ] + + for await (const item of remote) { + expect(item).to.be.deep.equal(incoming.shift()) + if (incoming.length === 0) { + break + } + } + + expect(incoming).to.have.property('length', 0, 'all items were received') + expect(outgoing).to.have.property('length', 1, 'one item remained') + }) + + it('execption in producer propagate to consumer', async () => { + const iterate = function * () { + yield 1 + yield 2 + throw Error('Producer Boom!') + } + + const transfer = [] + + const remote = decodeIterable( + await move( + encodeIterable( + iterate(), + (data, transfer) => { + return data + }, + transfer + ), + transfer + ), + a => a + ) + + const incoming = [1, 2] + + const consume = async () => { + for await (const item of remote) { + expect(item).to.be.deep.equal(incoming.shift()) + } + } + + const result = await consume().catch(error => error) + + expect(result).to.an.instanceOf(Error) + expect(result).to.have.property('message', 'Producer Boom!') + expect(incoming).to.have.property('length', 0, 'all items were recieved') + }) + + it('execption in consumer propagate to producer', async () => { + const outgoing = [1, 2, 3] + + const iterate = function * () { + while (true) { + yield outgoing.shift() + } + } + + const transfer = [] + + const remote = decodeIterable( + await move( + encodeIterable( + iterate(), + (data, transfer) => { + return data + }, + transfer + ), + transfer + ), + a => a + ) + + const incoming = [1, 2] + + const consume = async () => { + for await (const item of remote) { + expect(item).to.be.deep.equal(incoming.shift()) + if (incoming.length === 0) { + throw new Error('Consumer Boom!') + } + } + } + + const result = await consume().catch(error => error) + + expect(result).to.an.instanceOf(Error) + expect(result).to.have.property('message', 'Consumer Boom!') + + expect(outgoing).to.be.deep.equal([3], 'Producer loop was broken') + }) + + it('iterable transfers yield data', async () => { + const hi = Buffer.from('hello world') + const body = Buffer.from('how are you') + const bye = Buffer.from('Bye') + const outgoing = [hi, body, bye] + const iterate = function * () { + yield * outgoing + } + + const transfer = [] + + const remote = decodeIterable( + await move( + encodeIterable( iterate(), (data, transfer) => { transfer.push(data.buffer) diff --git a/packages/ipfs-message-port-server/src/core.js b/packages/ipfs-message-port-server/src/core.js index 0bd04c4c45..c1ff916662 100644 --- a/packages/ipfs-message-port-server/src/core.js +++ b/packages/ipfs-message-port-server/src/core.js @@ -3,8 +3,9 @@ /* eslint-env browser */ const { - decodeAsyncIterable, - encodeAsyncIterable + decodeIterable, + encodeIterable, + decodeCallback } = require('ipfs-message-port-protocol/src/core') const { decodeCID, encodeCID } = require('ipfs-message-port-protocol/src/dag') @@ -52,16 +53,16 @@ const { decodeCID, encodeCID } = require('ipfs-message-port-protocol/src/dag') * @property {AbortSignal} [signal] * * @typedef {SingleFileInput | MultiFileInput} AddInput - * @typedef {ArrayBuffer|ArrayBufferView|Blob|string|RemoteIterable|RemoteIterable} SingleFileInput + * @typedef {ArrayBuffer|ArrayBufferView|Blob|string|FileInput|RemoteIterable|RemoteIterable} SingleFileInput * @typedef {RemoteIterable|RemoteIterable|RemoteIterable} MultiFileInput * * @typedef {Object} FileInput * @property {string} [path] * @property {FileContent} content - * @property {Mode} mode - * @property {Time} mtim + * @property {Mode} [mode] + * @property {Time} [mtime] * - * @typedef {ArrayBufferView|ArrayBuffer|string|RemoteIterable|RemoteIterable} FileContent + * @typedef {ArrayBufferView|ArrayBuffer|Blob|string|RemoteIterable|RemoteIterable} FileContent * * @typedef {Object} AddedEntry * @property {string} path @@ -131,7 +132,7 @@ class Core { hashAlg, onlyHash, pin, - // progress, + progress, rawLeaves, shardSplitThreshold, trickle, @@ -152,6 +153,7 @@ class Core { trickle, wrapWithDirectory, timeout, + progress: progress != null ? decodeCallback(progress) : undefined, signal } @@ -191,7 +193,13 @@ const decodeAddInput = input => * @param {*} data * @returns {*} */ - data => decodeAsyncIterable(data, decodFileInput) + data => { + if (data.type === 'RemoteIterable') { + return decodeIterable(data, decodeFileInput) + } else { + return decodeFileInput(data) + } + } ) /** @@ -203,7 +211,7 @@ const decodeAddInput = input => * @param {ArrayBufferView|ArrayBuffer|string|Blob|FileInput} input * @returns {string|ArrayBuffer|ArrayBufferView|Blob|FileObject} */ -const decodFileInput = input => +const decodeFileInput = input => matchInput(input, file => ({ ...file, content: decodeFileContent(file.content) @@ -214,7 +222,7 @@ const decodFileInput = input => * @returns {DecodedFileContent} */ const decodeFileContent = content => - matchInput(content, input => decodeAsyncIterable(input, identity)) + matchInput(content, input => decodeIterable(input, identity)) /** * @template I,O @@ -244,7 +252,7 @@ const encodeAddResult = out => { /** @type {Transferable[]} */ const transfer = [] return { - data: encodeAsyncIterable(out, encodeFileOutput, transfer), + data: encodeIterable(out, encodeFileOutput, transfer), transfer } } @@ -257,7 +265,7 @@ const encodeAddResult = out => { const encodeCatResult = content => { /** @type {Transferable[]} */ const transfer = [] - return { data: encodeAsyncIterable(content, moveBuffer, transfer), transfer } + return { data: encodeIterable(content, moveBuffer, transfer), transfer } } /** diff --git a/packages/ipfs-message-port-server/src/index.js b/packages/ipfs-message-port-server/src/index.js index 0d3723b1cb..21dc160f27 100644 --- a/packages/ipfs-message-port-server/src/index.js +++ b/packages/ipfs-message-port-server/src/index.js @@ -2,7 +2,6 @@ /* eslint-env browser */ -const { Server } = require('./server') const { DAG } = require('./dag') const { Core } = require('./core') const { Files } = require('./files') @@ -11,62 +10,16 @@ const { Files } = require('./files') * @typedef {import('./ipfs').IPFS} IPFS */ -class IPFSService extends Core { +class IPFSService { /** * * @param {IPFS} ipfs */ constructor (ipfs) { - super(ipfs) this.dag = new DAG(ipfs) + this.core = new Core(ipfs) this.files = new Files(ipfs) } } exports.IPFSService = IPFSService - -/** - * @param {IPFS} ipfs - * @returns {Promise} - */ -const main = async function (ipfs) { - const service = new IPFSService(ipfs) - const server = new Server(service) - - const controller = new AbortController() - - const result = await server.execute({ - namespace: 'dag', - method: 'get', - input: { - cid: 'foo', - path: '/foo', - localResolve: true - }, - signal: controller.signal - }) - // eslint-disable-next-line no-console - console.log(result) - - const added = await server.execute({ - method: 'add', - input: { - input: 'hello' - } - }) - // eslint-disable-next-line no-console - console.log(added) - - const dag = new Server(service.dag) - dag.execute({ - method: 'get', - input: { - cid: 'foo', - path: '/foo', - localResolve: true - }, - signal: controller.signal - }) -} - -exports.main = main From f43a03a8962453b39ee2c3b44c0e941507baaf64 Mon Sep 17 00:00:00 2001 From: Irakli Gozalishvili Date: Tue, 16 Jun 2020 15:44:59 -0700 Subject: [PATCH 16/63] fix: add files.stat to enable more ipfs.add tests --- .../ipfs-message-port-client/src/client.js | 8 +- .../ipfs-message-port-client/src/files.js | 368 ++++++++---------- .../ipfs-message-port-client/src/index.js | 9 +- .../test/interface.spec.js | 22 +- .../ipfs-message-port-server/src/files.js | 99 +++-- packages/ipfs-message-port-server/src/ipfs.ts | 21 + 6 files changed, 272 insertions(+), 255 deletions(-) diff --git a/packages/ipfs-message-port-client/src/client.js b/packages/ipfs-message-port-client/src/client.js index 790765c373..1a665a34bc 100644 --- a/packages/ipfs-message-port-client/src/client.js +++ b/packages/ipfs-message-port-client/src/client.js @@ -22,12 +22,16 @@ class RemoteError extends Error { } } } +exports.RemoteError = RemoteError class TimeoutError extends Error {} +exports.TimeoutError = TimeoutError class AbortError extends Error {} +exports.AbortError = AbortError class DisconnectError extends Error {} +exports.DisconnectError = DisconnectError /** * @template T @@ -227,6 +231,7 @@ class Transport { } } } +exports.Transport = Transport /** * @template T @@ -277,5 +282,4 @@ class Client { this.remote = (new Service(namespace, methods, transport)) } } - -module.exports = { Client, Transport, RemoteError, AbortError, DisconnectError } +exports.Client = Client diff --git a/packages/ipfs-message-port-client/src/files.js b/packages/ipfs-message-port-client/src/files.js index 1be8039819..ec3b1fd402 100644 --- a/packages/ipfs-message-port-client/src/files.js +++ b/packages/ipfs-message-port-client/src/files.js @@ -5,13 +5,16 @@ const CID = require('cids') const { Client } = require('./client') const { - decodeRemoteIterable, - encodeAsyncIterable -} = require('ipfs-message-port-server/src/util') + decodeIterable, + encodeIterable +} = require('ipfs-message-port-protocol/src/core') +const { decodeCID } = require('ipfs-message-port-protocol/src/dag') /** * @typedef {import('ipfs-message-port-server/src/files').Files} API * @typedef {import('ipfs-message-port-server/src/files').EncodedContent} EncodedContent + * @typedef {import('ipfs-message-port-server/src/files').Entry} EncodedEntry + * @typedef {import('ipfs-message-port-server/src/files').EncodedStat} EncodedStat * @typedef {import('ipfs-message-port-protocol/src/data').UnixFSTime} UnixFSTime * @typedef {import('ipfs-message-port-protocol/src/data').FileType} FileType * @typedef {import('ipfs-message-port-protocol/src/data').Time} Time @@ -30,14 +33,20 @@ class Files extends Client { * @param {Transport} transport */ constructor (transport) { - super('files', ['chmod'], transport) + super('files', ['chmod', 'stat'], transport) } /** * Change mode for files and directories * @param {ContentAddress} path - The path to the entry to modify * @param {Mode} mode - * @param {ChmodOptions} [options] + * @param {Object} [options] + * @param {boolean} [options.recursive=false] + * @param {string} [options.hashAlg] + * @param {boolean} [options.flush=true] + * @param {number} [options.cidVersion=0] + * @param {number} [options.timeout] + * @param {AbortSignal} [options.signal] * @returns {Promise} */ chmod (path, mode, options = {}) { @@ -74,59 +83,173 @@ class Files extends Client { * @param {CIDVersion} [options.cidVersion] - The CID version to use for any updated entries * @param {number} [options.timeout] - A timeout in ms * @param {AbortSignal} [options.signal] - Can be used to cancel any long running requests started as a result of this call + * @param {Transferable[]} [options.transfer] - Provide transferables for transfer * @returns {Promise<{cid: CID, size:number}>} */ async write (path, content, options = {}) { - const [data, transfer] = encodeContent(content) - const { cid, size } = await this.remote.write({ + const transfer = [...options.transfer] + const result = await this.remote.write({ ...options, path, - content: data, - transfer: transfer + content: encodeContent(content, transfer), + transfer }) - return { cid: new CID(cid), size } + return { ...result, cid: decodeCID(result.cid) } } /** + * @typedef {Object} Entry + * @property {string} name + * @property {FileType} type + * @property {number} size + * @property {CID} cid + * @property {number} mode + * @property {UnixFSTime} mtime * * @param {string} [path='/'] - * @param {LsOptions} [options] - * @returns {AsyncIterable} + * @param {Object} [options] + * @param {boolean} [options.sort=false] + * @param {number} [options.timeout] + * @param {AbortSignal} [options.signal] + * @returns {AsyncIterable} */ async * ls (path = '/', options = {}) { const { sort, timeout, signal } = options - const entries = await this.remote.ls({ + const { entries } = await this.remote.ls({ path, sort, timeout, signal }) - for await (const entry of decodeRemoteIterable(entries)) { - const cid = new CID(entry.cid) - yield { ...entry, cid } - } + yield * decodeIterable(entries, decodeLsEntry) + } + + // /** + // * Copy files. + // * @param {ContentAddress} from + // * @param {string} to + // * @param {Object} [options] + // * @param {boolean} [options.parents=false] + // * @param {string} [options.hashAlg] + // * @param {boolean} [options.flush=true] + // * @param {number} [options.timeout] + // * @param {AbortSignal} [options.signal] + // * @returns {Promise} + // */ + // // @ts-ignore + // cp (from, to, options, ...etc) { + // const args = [from, to, options, ...etc] + // const last = args.pop() + // const [sources, destination, opts] = + // typeof last === 'string' ? [args, last, {}] : [args, args.pop(), last] + + // const { parents, hashAlg, flush } = opts + // return this.remote.cp( + // { + // // @ts-ignore could be called without any arguments. + // from: sources.map(toPath), + // to: destination, + // parents, + // hashAlg, + // flush + // }, + // options + // ) + // } + // /** + // * Make a directory. + // * @param {string} path The path to the directory to make + // * @param {Object} [options] + // * @param {boolean} [options.parents=false] + // * @param {string} [options.hashAlg] + // * @param {boolean} [options.flush=true] + // * @param {Mode} [options.mode] + // * @param {Time|Date} [options.mtime] + // * @param {number} [options.timeout] + // * @param {AbortSignal} [options.signal] + // * @returns {Promise} + // */ + // mkdir (path, options = {}) { + // const { mtime, parents, flush, hashAlg, mode } = options + + // return this.remote.mkdir( + // { + // path: toPath(path), + // mtime, + // parents, + // flush, + // hashAlg, + // mode + // }, + // options + // ) + // } + + /** + * @typedef {Object} Stat + * @property {CID} cid Content identifier. + * @property {number} size File size in bytes. + * @property {number} cumulativeSize Size of the DAGNodes making up the file in bytes. + * @property {"directory"|"file"} type + * @property {number} blocks Number of files making up directory (when a direcotry) + * or number of blocks that make up the file (when a file) + * @property {boolean} withLocality True when locality information is present + * @property {boolean} local True if the queried dag is fully present locally + * @property {number} sizeLocal Cumulative size of the data present locally + * + * @param {ContentAddress} path + * @param {Object} [options] + * @param {boolean} [options.hash=false] If true will only return hash + * @param {boolean} [options.size=false] If true will only return size + * @param {boolean} [options.withLocal=false] If true computes size of the dag that is local, and total size when possible + * @param {number} [options.timeout] + * @param {AbortSignal} [options.signal] + * @returns {Promise} + */ + async stat (path, options = {}) { + const { size, hash, withLocal, timeout, signal } = options + const { stat } = await this.remote.stat({ + path: toPath(path), + size, + hash, + withLocal, + timeout, + signal + }) + return decodeStat(stat) + } +} +module.exports = Files + +/** + * @param {EncodedEntry} entry + * @returns {Entry} + */ +const decodeLsEntry = entry => { + return { + ...entry, + cid: decodeCID(entry.cid) } } -exports.Files = Files /** * @param {WriteContent} content - The content to write to the path - * @returns {[EncodedContent] | [EncodedContent, Transferable[]]} + * @param {Transferable[]} transfer + * @returns {EncodedContent} */ -const encodeContent = content => { +const encodeContent = (content, transfer) => { if (typeof content === 'string') { - return [content] + return content } else if (ArrayBuffer.isView(content)) { - return [content, [content.buffer]] + return content } else if (content instanceof ArrayBuffer) { - return [content, [content]] + return content } else if (content instanceof Blob) { - return [content] + return content } else { - const data = encodeAsyncIterable(content) - return [data, [data.port]] + return encodeIterable(content, identity, transfer) } } @@ -134,18 +257,7 @@ const encodeContent = content => { * * @typedef {string|CID} ContentAddress * - * @typedef {Object} ChmodOptions - * @property {boolean} [recursive=false] - * @property {string} [hashAlg] - * @property {boolean} [flush=true] - * @property {number} [cidVersion=0] - * @property {number} [timeout] - * @property {AbortSignal} [signal] * - * @typedef {Object} LsOptions - * @property {boolean} [sort=false] - * @property {number} [timeout] - * @property {AbortSignal} [signal] * @typedef {Object} LsEntry * @property {string} name * @property {FileType} type @@ -155,164 +267,6 @@ const encodeContent = content => { * @property {UnixFSTime} mtime */ -// /** -// * @typedef {import('./connection')} RPCConnection -// * @typedef {import('./connection').RPCRequestOptions} RPCRequestOptions -// * -// * @typedef {number|string} Mode -// * @typedef {{ secs:number, nsecs:number }} Time -// * -// * @typedef {string|CID} ContentAddress -// * -// * @typedef {Object} Chmod -// * @property {boolean} [recursive=false] -// * @property {string} [hashAlg] -// * @property {boolean} [flush=true] -// * @property {number} [cidVersion=0] -// * -// * @typedef {Object} CP -// * @property {boolean} [parents=false] -// * @property {string} [hashAlg] -// * @property {boolean} [flush=true] -// * -// * @typedef {Object} Mkdir -// * @property {boolean} [parents=false] -// * @property {string} [hashAlg] -// * @property {boolean} [flush=true] -// * @property {Mode} [mode] -// * @property {Time|Date} [mtime] -// * -// * @typedef {Object} StatQuery -// * @property {boolean} [hash=false] If true will only return hash -// * @property {boolean} [size=false] If true will only return size -// * @property {boolean} [withLocal=false] If true computes size of the dag that is local, and total size when possible -// * -// * @typedef {Object} Stat -// * @property {CID} cid Content identifier. -// * @property {number} size File size in bytes. -// * @property {number} cumulativeSize Size of the DAGNodes making up the file in bytes. -// * @property {"directory"|"file"} type -// * @property {number} blocks Number of files making up directory (when a direcotry) -// * or number of blocks that make up the file (when a file) -// * @property {boolean} withLocality True when locality information is present -// * @property {boolean} local True if the queried dag is fully present locally -// * @property {number} sizeLocal Cumulative size of the data present locally -// */ - -// /** -// * @template T -// * @typedef {T & RPCRequestOptions} Options -// */ - -// class FilesClient { -// /** -// * -// * @param {RPCConnection} connection -// */ -// constructor (connection) { -// this.connection = connection -// } - -// /** -// * Change mode for files and directories -// * @param {ContentAddress} path The path to the entry to modify -// * @param {Mode} mode -// * @param {Options} [options] -// * @returns {Promise} -// */ -// chmod (path, mode, options = {}) { -// const { recursive, hashAlg, flush, cidVersion, signal, timeout } = options -// return this.connection.call( -// 'files/chmod', -// { -// path: toPath(path), -// mode, -// recursive, -// hashAlg, -// flush, -// cidVersion, -// timeout -// }, -// { -// signal -// } -// ) -// } -// /** -// * Copy files. -// * // @ts-ignore -// * @param {ContentAddress} from -// * @param {string} to -// * @param {Options} [options] -// * @returns {Promise} -// */ -// // @ts-ignore -// cp (from, to, options, ...etc) { -// const args = [from, to, options, ...etc] -// const last = args.pop() -// /** @type [string[], string, Options] */ -// const [sources, destination, opts] = -// typeof last === 'string' ? [args, last, {}] : [args, args.pop(), last] - -// const { parents, hashAlg, flush } = opts -// return this.connection.call( -// 'files/cp', -// { -// // @ts-ignore could be called without any arguments. -// from: sources.map(toPath), -// to: destination, -// parents, -// hashAlg, -// flush -// }, -// options -// ) -// } -// /** -// * Make a directory. -// * @param {string} path The path to the directory to make -// * @param {Options} [options] -// * @returns {Promise} -// */ -// mkdir (path, options = {}) { -// const { mtime, parents, flush, hashAlg, mode } = options - -// return this.connection.call( -// 'files/mkdir', -// { -// path: toPath(path), -// mtime, -// parents, -// flush, -// hashAlg, -// mode -// }, -// options -// ) -// } - -// /** -// * -// * @param {ContentAddress} path -// * @param {Options} options -// * @returns {Promise} -// */ -// async stat (path, options = {}) { -// const { size, hash, withLocal } = options -// const data = await this.connection.call( -// 'files/stat', -// { -// path: toPath(path), -// size, -// hash, -// withLocal -// }, -// options -// ) -// return decodeStat(data) -// } -// } - /** * Turns content address (path or CID) into path. * @param {ContentAddress} address @@ -321,14 +275,18 @@ const encodeContent = content => { const toPath = address => CID.isCID(address) ? `/ipfs/${address.toString()}` : address.toString() -// /** -// * -// * @param {Stat} data -// * @returns {Stat} -// */ -// const decodeStat = data => { -// data.cid = new CID(data.cid) -// return data -// } +/** + * + * @param {EncodedStat} data + * @returns {Stat} + */ +const decodeStat = data => { + return { ...data, cid: decodeCID(data.cid) } +} -// module.exports = FilesClient +/** + * @template T + * @param {T} a + * @returns {T} + */ +const identity = a => a diff --git a/packages/ipfs-message-port-client/src/index.js b/packages/ipfs-message-port-client/src/index.js index 0311bd5f26..6bbcffe5b1 100644 --- a/packages/ipfs-message-port-client/src/index.js +++ b/packages/ipfs-message-port-client/src/index.js @@ -1,24 +1,27 @@ -// @ts-nocheck 'use strict' /* eslint-env browser */ const DAG = require('./dag') const Core = require('./core') +const Files = require('./files') const { Transport } = require('./client') /** + * @typedef {import('./client').Transport} ClientTransport + * * @typedef {Object} ClientOptions * @property {MessagePort} port */ class IPFSClient extends Core { /** - * @param {Transport} [transport] + * @param {ClientTransport} transport */ constructor (transport) { super(transport) this.transport = transport this.dag = new DAG(this.transport) + this.files = new Files(this.transport) } /** @@ -39,7 +42,7 @@ class IPFSClient extends Core { * @returns {IPFSClient} */ static detached () { - return new IPFSClient(new Transport(null)) + return new IPFSClient(new Transport(undefined)) } /** diff --git a/packages/ipfs-message-port-client/test/interface.spec.js b/packages/ipfs-message-port-client/test/interface.spec.js index f24c1b7df9..2c6d7fb110 100644 --- a/packages/ipfs-message-port-client/test/interface.spec.js +++ b/packages/ipfs-message-port-client/test/interface.spec.js @@ -56,29 +56,9 @@ describe('interface-ipfs-core tests', () => { name: 'should add a directory with only-hash=true', reason: 'ipfs.object.get is not implemented' }, - { - name: 'should add with mode as string', - reason: 'ipfs.files.stat is not implemented' - }, - { - name: 'should add with mode as number', - reason: 'ipfs.files.stat is not implemented' - }, - { - name: 'should add with mtime as Date', - reason: 'ipfs.files.stat is not implemented' - }, - { - name: 'should add with mtime as { nsecs, secs }', - reason: 'ipfs.files.stat is not implemented' - }, - { - name: 'should add with mtime as timespec', - reason: 'ipfs.files.stat is not implemented' - }, { name: 'should add with mtime as hrtime', - reason: 'ipfs.files.stat is not implemented' + reason: 'process.hrtime is not a function in browser' }, { diff --git a/packages/ipfs-message-port-server/src/files.js b/packages/ipfs-message-port-server/src/files.js index aef964556f..f1a40a5dab 100644 --- a/packages/ipfs-message-port-server/src/files.js +++ b/packages/ipfs-message-port-server/src/files.js @@ -3,15 +3,18 @@ /* eslint-env browser */ const CID = require('cids') -const { encodeAsyncIterable, decodeRemoteIterable } = require('./util') +const { + encodeIterable, + decodeIterable +} = require('ipfs-message-port-protocol/src/core') +const { encodeCID } = require('ipfs-message-port-protocol/src/dag') /** - * @template T - * @typedef {import('ipfs-message-port-protocol/src/data').StringEncoded} StringEncoded + * @typedef {import('ipfs-message-port-protocol/src/dag').EncodedCID} EncodedCID */ /** * @template T - * @typedef {import('ipfs-message-port-protocol/src/data').RemoteIterable} RemoteIterable + * @typedef {import('ipfs-message-port-protocol/src/core').RemoteIterable} RemoteIterable */ /** * @typedef {import('ipfs-message-port-protocol/src/data').HashAlg} HashAlg @@ -22,6 +25,7 @@ const { encodeAsyncIterable, decodeRemoteIterable } = require('./util') * @typedef {import('ipfs-message-port-protocol/src/data').CIDVersion} CIDVersion * @typedef {import('./ipfs').IPFS} IPFS + * @typedef {Stat} EncodedStat */ /** @@ -47,7 +51,39 @@ class Files { // cp(input: CpQuery): Promise // mkdir(input: MkdirQuery): Promise - // stat(input: StatQuery): Promise + /** + * @typedef {Object} StatQuery + * @property {string} path + * @property {boolean} [hash=false] + * @property {boolean} [size=false] + * @property {boolean} [withLocal=false] + * @property {number} [timeout] + * @property {AbortSignal} [signal] + * + * @typedef {Object} Stat + * @property {EncodedCID} cid + * @property {number} size + * @property {number} cumulativeSize + * @property {'file'|'directory'} type + * @property {number} blocks + * @property {boolean} withLocality + * @property {boolean} local + * @property {number} sizeLocal + * + * @typedef {Object} StatResult + * @property {Stat} stat + * @property {Transferable[]} transfer + * + * @param {StatQuery} input + * @returns {Promise} + */ + async stat (input) { + const stat = await this.ipfs.files.stat(input.path, input) + /** @type {Transferable[]} */ + const transfer = [] + return { stat: { ...stat, cid: encodeCID(stat.cid, transfer) }, transfer } + } + // touch(input: TouchQuery): Promise // rm(input: RmQuery): Promise // read(input: ReadQuery): Promise @@ -57,32 +93,57 @@ class Files { */ async write (query) { const { path, content } = query - const { cid, size } = await this.ipfs.files.write( + const result = await this.ipfs.files.write( path, decodeContent(content), query ) - return { cid: cid.toString(), size } + return { ...result, cid: encodeCID(result.cid) } } // mv(input: MvQuery): Promise // flush(input: FlushQuery): Promise> /** + * @typedef {Object} LsQuery + * @property {string} path + * @property {boolean} [sort] + * @property {number} [timeout] + * @property {AbortSignal} [signal] + * + * @typedef {Object} LsResult + * @property {RemoteIterable} entries + * @property {Transferable[]} transfer + * * @param {LsQuery} query * @returns {LsResult} */ ls (query) { const { sort, timeout, signal } = query + /** @type {Transferable[]} */ + const transfer = [] const entries = this.ipfs.files.ls(query.path, { sort, timeout, signal }) - return encodeAsyncIterable(entries) + return { + entries: encodeIterable(entries, identity, transfer), + transfer + } } } exports.Files = Files +/** + * @typedef {Object} Entry + * @property {string} name + * @property {FileType} type + * @property {number} size + * @property {EncodedCID} cid + * @property {number} mode + * @property {UnixFSTime} mtime + */ + /** * @param {EncodedContent} content * @returns {DecodedContent} @@ -97,7 +158,7 @@ const decodeContent = content => { } else if (content instanceof Blob) { return content } else { - return decodeRemoteIterable(content) + return decodeIterable(content, identity) } } @@ -203,7 +264,7 @@ const decodeContent = content => { * @property {AbortSignal} [signal] * * @typedef {Object} WriteResult - * @property {StringEncoded} cid + * @property {EncodedCID} cid * @property {number} size */ @@ -222,18 +283,8 @@ const decodeContent = content => { // } /** - * @typedef {Object} LsQuery - * @property {string} path - * @property {boolean} [sort] - * @property {number} [timeout] - * @property {AbortSignal} [signal] - * - * @typedef {Object} Entry - * @property {string} name - * @property {FileType} type - * @property {number} size - * @property {StringEncoded} cid - * @property {number} mode - * @property {UnixFSTime} mtime - * @typedef {RemoteIterable} LsResult + * @template T + * @param {T} a + * @returns {T} */ +const identity = a => a diff --git a/packages/ipfs-message-port-server/src/ipfs.ts b/packages/ipfs-message-port-server/src/ipfs.ts index c82831756c..507f84a309 100644 --- a/packages/ipfs-message-port-server/src/ipfs.ts +++ b/packages/ipfs-message-port-server/src/ipfs.ts @@ -104,6 +104,8 @@ export interface Files { ): Promise ls(path?: string, opitons?: LsOptions): AsyncIterable + + stat(path: string, options?: StatOptions): Promise } type ChmodOptions = { @@ -130,6 +132,25 @@ type LsEntry = { mtime: UnixFSTime } +type StatOptions = { + hash?: boolean + size?: boolean + withLocal?: boolean + timeout?: number + signal?: AbortSignal +} + +type Stat = { + cid: CID + size: number + cumulativeSize: number + type: 'file' | 'directory' + blocks: number + withLocality: boolean + local: boolean + sizeLocal: number +} + type WriteContent = | string | ArrayBufferView From 2bf80b2848a855725212456c88b16d09b9b0b399 Mon Sep 17 00:00:00 2001 From: Irakli Gozalishvili Date: Tue, 16 Jun 2020 15:58:11 -0700 Subject: [PATCH 17/63] chore: add echoserver & enable more ipfs.add tests --- packages/ipfs-message-port-client/.aegir.js | 10 +++++++++- .../test/interface.spec.js | 20 +------------------ 2 files changed, 10 insertions(+), 20 deletions(-) diff --git a/packages/ipfs-message-port-client/.aegir.js b/packages/ipfs-message-port-client/.aegir.js index 833ffa08e7..f3a31bb607 100644 --- a/packages/ipfs-message-port-client/.aegir.js +++ b/packages/ipfs-message-port-client/.aegir.js @@ -1,5 +1,8 @@ 'use strict' +const EchoServer = require('aegir/utils/echo-server') +const echoServer = new EchoServer() + module.exports = { bundlesize: { maxSize: '89kB' }, karma: { @@ -28,12 +31,17 @@ module.exports = { hooks: { browser: { pre: async () => { + await echoServer.start() + return { env: { IPFS_WORKER_URL: `/base/dist/worker.bundle.js`, - ECHO_SERVER: `http://localhost:8080` + ECHO_SERVER: `http://${echoServer.host}:${echoServer.port}` } } + }, + post: async () => { + await echoServer.stop() } } } diff --git a/packages/ipfs-message-port-client/test/interface.spec.js b/packages/ipfs-message-port-client/test/interface.spec.js index 2c6d7fb110..9fd286abdd 100644 --- a/packages/ipfs-message-port-client/test/interface.spec.js +++ b/packages/ipfs-message-port-client/test/interface.spec.js @@ -60,27 +60,9 @@ describe('interface-ipfs-core tests', () => { name: 'should add with mtime as hrtime', reason: 'process.hrtime is not a function in browser' }, - - { - name: 'should add from a HTTP URL', - reason: 'echo server is not enabled' - }, - { - name: 'should add from a HTTP URL with redirection', - reason: 'echo server is not enabled' - }, { name: 'should add from a URL with only-hash=true', - reason: 'echo server is not enabled' - }, - { - name: 'should add from a URL with wrap-with-directory=true', - reason: 'echo server is not enabled' - }, - { - name: - 'should add from a URL with wrap-with-directory=true and URL-escaped file name', - reason: 'echo server is not enabled' + reason: 'ipfs.object.get is not implemented' } ] }) From 3c78c140fb83cb6ab4acef0fa8ca0d462d658b07 Mon Sep 17 00:00:00 2001 From: Irakli Gozalishvili Date: Thu, 18 Jun 2020 13:18:56 -0700 Subject: [PATCH 18/63] chore: disable intermittent failing test --- packages/ipfs-http-client/test/interface.spec.js | 15 +++++++++++---- packages/ipfs/test/http-api/interface.js | 10 +++++++++- 2 files changed, 20 insertions(+), 5 deletions(-) diff --git a/packages/ipfs-http-client/test/interface.spec.js b/packages/ipfs-http-client/test/interface.spec.js index f5be737c80..a59f19be52 100644 --- a/packages/ipfs-http-client/test/interface.spec.js +++ b/packages/ipfs-http-client/test/interface.spec.js @@ -59,10 +59,17 @@ describe('interface-ipfs-core tests', () => { }) tests.block(commonFactory, { - skip: [{ - name: 'should get a block added as CIDv1 with a CIDv0', - reason: 'go-ipfs does not support the `version` param' - }] + skip: [ + { + name: 'should get a block added as CIDv1 with a CIDv0', + reason: 'go-ipfs does not support the `version` param' + }, + { + name: 'should return an error for an invalid CID', + reason: + 'Intermittent failure: https://github.com/ipfs/js-ipfs/issues/3100' + } + ] }) tests.bootstrap(commonFactory, { diff --git a/packages/ipfs/test/http-api/interface.js b/packages/ipfs/test/http-api/interface.js index 2797b0b98c..a287a1d207 100644 --- a/packages/ipfs/test/http-api/interface.js +++ b/packages/ipfs/test/http-api/interface.js @@ -31,7 +31,15 @@ describe('interface-ipfs-core over ipfs-http-client tests', function () { tests.bitswap(commonFactory) - tests.block(commonFactory) + tests.block(commonFactory, { + skip: [ + { + name: 'should return an error for an invalid CID', + reason: + 'Intermittent failure: https://github.com/ipfs/js-ipfs/issues/3100' + } + ] + }) tests.bootstrap(commonFactory) From 3947c5497cafeb112b68a1e77afe7edf6fde4ba9 Mon Sep 17 00:00:00 2001 From: Irakli Gozalishvili Date: Thu, 18 Jun 2020 16:47:30 -0700 Subject: [PATCH 19/63] fix: add ipfs.block to test ipfs.cat --- .../ipfs-message-port-client/src/block.js | 138 ++++++++++++++++++ packages/ipfs-message-port-client/src/core.js | 6 +- packages/ipfs-message-port-client/src/dag.js | 12 +- .../ipfs-message-port-client/src/files.js | 6 +- .../ipfs-message-port-client/src/index.js | 14 +- .../test/interface.core.js | 4 +- .../test/interface.spec.js | 41 ++++++ .../ipfs-message-port-protocol/package.json | 3 +- .../ipfs-message-port-protocol/src/block.js | 41 ++++++ .../ipfs-message-port-protocol/src/cid.js | 47 ++++++ .../ipfs-message-port-protocol/src/dag.js | 38 +---- .../ipfs-message-port-protocol/src/files.ts | 10 +- .../test/block.browser.js | 51 +++++++ .../test/browser.js | 3 + .../test/cid.browser.js | 47 ++++++ .../test/cid.spec.js | 32 ++++ .../test/dag.browser.js | 36 +---- .../test/dag.spec.js | 23 +-- .../ipfs-message-port-protocol/test/node.js | 1 + .../ipfs-message-port-protocol/tsconfig.json | 2 +- .../ipfs-message-port-server/src/block.js | 125 ++++++++++++++++ packages/ipfs-message-port-server/src/core.js | 4 +- packages/ipfs-message-port-server/src/dag.js | 15 +- .../ipfs-message-port-server/src/files.js | 2 +- .../ipfs-message-port-server/src/index.js | 2 + packages/ipfs-message-port-server/src/ipfs.ts | 88 +++++++---- 26 files changed, 621 insertions(+), 170 deletions(-) create mode 100644 packages/ipfs-message-port-client/src/block.js create mode 100644 packages/ipfs-message-port-protocol/src/block.js create mode 100644 packages/ipfs-message-port-protocol/src/cid.js create mode 100644 packages/ipfs-message-port-protocol/test/block.browser.js create mode 100644 packages/ipfs-message-port-protocol/test/cid.browser.js create mode 100644 packages/ipfs-message-port-protocol/test/cid.spec.js create mode 100644 packages/ipfs-message-port-server/src/block.js diff --git a/packages/ipfs-message-port-client/src/block.js b/packages/ipfs-message-port-client/src/block.js new file mode 100644 index 0000000000..ab425a86c0 --- /dev/null +++ b/packages/ipfs-message-port-client/src/block.js @@ -0,0 +1,138 @@ +'use strict' + +const { Client } = require('./client') +const { encodeCID, decodeCID } = require('ipfs-message-port-protocol/src/cid') +const { + encodeBlock, + decodeBlock +} = require('ipfs-message-port-protocol/src/block') + +/** + * @typedef {import('cids')} CID + * @typedef {import('ipfs-message-port-server/src/block').Block} Block + * @typedef {import('ipfs-message-port-server/src/block').EncodedBlock} EncodedBlock + * @typedef {import('ipfs-message-port-server/src/block').BlockService} API + * @typedef {import('./client').ClientTransport} Transport + */ + +/** + * @class + * @extends {Client} + */ +class BlockClient extends Client { + /** + * @param {Transport} transport + */ + constructor (transport) { + super('block', ['put', 'get', 'rm', 'stat'], transport) + } + + /** + * Get a raw IPFS block. + * @param {CID} cid - A CID that corresponds to the desired block + * @param {Object} [options] + * @param {number} [options.timeout] - A timeout in ms + * @param {AbortSignal} [options.signal] - Can be used to cancel any long + * running requests started as a result of this call + * @param {Transferable[]} [options.tranfer] - References to transfer to the + * worker if passed. + * @returns {Promise} + */ + async get (cid, options = {}) { + const { block } = await this.remote.get({ + ...options, + cid: encodeCID(cid) + }) + return decodeBlock(block) + } + + /** + * Stores input as an IPFS block. + * @param {Block|Uint8Array} block - A Block or Uint8Array of block data + * @param {Object} [options] + * @param {CID} [options.cid] - A CID to store the block under (if block is + * `Uint8Array`) + * @param {string} [options.format='dag-pb'] - The codec to use to create the + * CID (if block is `Uint8Array`) + * @param {string} [options.mhtype='sha2-256'] - The hashing algorithm to use + * to create the CID (if block is `Uint8Array`) + * @param {0|1} [options.version=0] - The version to use to create the CID + * (if block is `Uint8Array`) + * @param {number} [options.mhlen] + * @param {boolean} [options.pin=false] - If true, pin added blocks recursively + * @param {number} [options.timeout] - A timeout in ms + * @param {AbortSignal} [options.signal] - Can be used to cancel any long + * running requests started as a result of this call + * @param {Transferable[]} [options.tranfer] - References to transfer to the + * worker if passed. + * @returns {Promise} + */ + async put (block, options = {}) { + // @ts-ignore - ipfs-unixfs-importer passes this causing errors + delete options.progress + const result = await this.remote.put({ + ...options, + cid: options.cid == null ? undefined : encodeCID(options.cid), + block: block instanceof Uint8Array ? block : encodeBlock(block) + }) + return decodeBlock(result.block) + } + + /** + * Remove one or more IPFS block(s). + * @param {CID|CID[]} cids - Block(s) to be removed + * @param {Object} [options] + * @param {boolean} [options.force=false] - Ignores nonexistent blocks + * @param {boolean} [options.quiet=false] - Write minimal output + * @param {number} [options.timeout] - A timeout in ms + * @param {AbortSignal} [options.signal] - Can be used to cancel any long + * running requests started as a result of this call + * @param {Transferable[]} [options.tranfer] - References to transfer to the + * worker if passed. + * @returns {AsyncIterable} + * + * @typedef {Object} RmEntry + * @property {CID} cid + * @property {Error|void} [error] + */ + async * rm (cids, options = {}) { + const entries = await this.remote.rm({ + ...options, + cids: Array.isArray(cids) + ? cids.map(cid => encodeCID(cid)) + : [encodeCID(cids)] + }) + + for (const entry of entries) { + yield { + ...entry, + cid: decodeCID(entry.cid) + } + } + } + + /** + * Returns information about a raw IPFS block. + * @param {CID} cid - Block to get information about. + * @param {Object} [options] + * @param {number} [options.timeout] - A timeout in ms + * @param {AbortSignal} [options.signal] - Can be used to cancel any long + * running requests started as a result of this call + * @param {Transferable[]} [options.tranfer] - References to transfer to the + * worker if passed. + * @returns {Promise} + * + * @typedef {Object} Stat + * @property {CID} cid + * @property {number} size + */ + async stat (cid, options = {}) { + const result = await this.remote.stat({ + ...options, + cid: encodeCID(cid) + }) + + return { ...result, cid: decodeCID(result.cid) } + } +} +module.exports = BlockClient diff --git a/packages/ipfs-message-port-client/src/core.js b/packages/ipfs-message-port-client/src/core.js index ebe6da8476..1480d26621 100644 --- a/packages/ipfs-message-port-client/src/core.js +++ b/packages/ipfs-message-port-client/src/core.js @@ -4,7 +4,7 @@ const CID = require('cids') const { Client } = require('./client') -const { encodeCID, decodeCID } = require('ipfs-message-port-protocol/src/dag') +const { encodeCID, decodeCID } = require('ipfs-message-port-protocol/src/cid') const { decodeIterable, encodeIterable, @@ -83,7 +83,7 @@ const { * @class * @extends {Client} */ -class Core extends Client { +class CoreClient extends Client { /** * @param {Transport} transport */ @@ -371,4 +371,4 @@ const asFileObject = input => { } } -module.exports = Core +module.exports = CoreClient diff --git a/packages/ipfs-message-port-client/src/dag.js b/packages/ipfs-message-port-client/src/dag.js index 4f4b019c8e..e06d8c058b 100644 --- a/packages/ipfs-message-port-client/src/dag.js +++ b/packages/ipfs-message-port-client/src/dag.js @@ -1,12 +1,8 @@ 'use strict' const { Client } = require('./client') -const { - encodeNode, - encodeCID, - decodeCID, - decodeNode -} = require('ipfs-message-port-protocol/src/dag') +const { encodeCID, decodeCID } = require('ipfs-message-port-protocol/src/cid') +const { encodeNode, decodeNode } = require('ipfs-message-port-protocol/src/dag') /** * @typedef {import('cids')} CID @@ -42,7 +38,7 @@ const { * @class * @extends {Client} */ -class DAG extends Client { +class DAGClient extends Client { /** * @param {Transport} transport */ @@ -146,4 +142,4 @@ const read = (path, options) => { } } -module.exports = DAG +module.exports = DAGClient diff --git a/packages/ipfs-message-port-client/src/files.js b/packages/ipfs-message-port-client/src/files.js index ec3b1fd402..16e3b41a0a 100644 --- a/packages/ipfs-message-port-client/src/files.js +++ b/packages/ipfs-message-port-client/src/files.js @@ -8,7 +8,7 @@ const { decodeIterable, encodeIterable } = require('ipfs-message-port-protocol/src/core') -const { decodeCID } = require('ipfs-message-port-protocol/src/dag') +const { decodeCID } = require('ipfs-message-port-protocol/src/cid') /** * @typedef {import('ipfs-message-port-server/src/files').Files} API @@ -28,7 +28,7 @@ const { decodeCID } = require('ipfs-message-port-protocol/src/dag') * @class * @extends {Client} */ -class Files extends Client { +class FilesClient extends Client { /** * @param {Transport} transport */ @@ -221,7 +221,7 @@ class Files extends Client { return decodeStat(stat) } } -module.exports = Files +module.exports = FilesClient /** * @param {EncodedEntry} entry diff --git a/packages/ipfs-message-port-client/src/index.js b/packages/ipfs-message-port-client/src/index.js index 6bbcffe5b1..bc174e49c1 100644 --- a/packages/ipfs-message-port-client/src/index.js +++ b/packages/ipfs-message-port-client/src/index.js @@ -1,10 +1,11 @@ 'use strict' /* eslint-env browser */ -const DAG = require('./dag') -const Core = require('./core') -const Files = require('./files') const { Transport } = require('./client') +const BlockClient = require('./block') +const DAGClient = require('./dag') +const CoreClient = require('./core') +const FilesClient = require('./files') /** * @typedef {import('./client').Transport} ClientTransport @@ -13,15 +14,16 @@ const { Transport } = require('./client') * @property {MessagePort} port */ -class IPFSClient extends Core { +class IPFSClient extends CoreClient { /** * @param {ClientTransport} transport */ constructor (transport) { super(transport) this.transport = transport - this.dag = new DAG(this.transport) - this.files = new Files(this.transport) + this.dag = new DAGClient(this.transport) + this.files = new FilesClient(this.transport) + this.block = new BlockClient(this.transport) } /** diff --git a/packages/ipfs-message-port-client/test/interface.core.js b/packages/ipfs-message-port-client/test/interface.core.js index 9c81f916a2..a57b54ba55 100644 --- a/packages/ipfs-message-port-client/test/interface.core.js +++ b/packages/ipfs-message-port-client/test/interface.core.js @@ -4,6 +4,6 @@ const { createSuite } = require('interface-ipfs-core/src/utils/suite') exports.core = createSuite({ - add: require('interface-ipfs-core/src/add') - // cat: require('interface-ipfs-core/src/cat') + add: require('interface-ipfs-core/src/add'), + cat: require('interface-ipfs-core/src/cat') }) diff --git a/packages/ipfs-message-port-client/test/interface.spec.js b/packages/ipfs-message-port-client/test/interface.spec.js index 9fd286abdd..e01cd40828 100644 --- a/packages/ipfs-message-port-client/test/interface.spec.js +++ b/packages/ipfs-message-port-client/test/interface.spec.js @@ -63,6 +63,47 @@ describe('interface-ipfs-core tests', () => { { name: 'should add from a URL with only-hash=true', reason: 'ipfs.object.get is not implemented' + }, + { + name: 'should cat with a Buffer multihash', + reason: 'Passing CID as Buffer is not supported' + } + ] + }) + + tests.block(commonFactory, { + skip: [ + { + name: 'should get by CID in string', + reason: 'Passing CID as strings is not supported' + }, + { + name: 'should return an error for an invalid CID', + reason: 'Passing CID as strings is not supported' + }, + { + name: 'should put a buffer, using CID string', + reason: 'Passing CID as strings is not supported' + }, + { + name: 'should put a buffer, using options', + reason: 'ipfs.pin.ls is not implemented' + }, + { + name: 'should remove by CID object', + reason: 'ipfs.refs.local is not implemented' + }, + { + name: 'should remove by CID in string', + reason: 'Passing CID as strings is not supported' + }, + { + name: 'should remove by CID in buffer', + reason: 'Passing CID as Buffer is not supported' + }, + { + name: 'should error when removing pinned blocks', + reason: 'ipfs.pin.add is not implemented' } ] }) diff --git a/packages/ipfs-message-port-protocol/package.json b/packages/ipfs-message-port-protocol/package.json index 1a66e5d9f1..b6995b7af9 100644 --- a/packages/ipfs-message-port-protocol/package.json +++ b/packages/ipfs-message-port-protocol/package.json @@ -30,7 +30,8 @@ }, "dependencies": { "buffer": "^5.6.0", - "cids": "^0.8.0" + "cids": "^0.8.0", + "ipld-block": "^0.9.2" }, "devDependencies": { "aegir": "^22.0.0", diff --git a/packages/ipfs-message-port-protocol/src/block.js b/packages/ipfs-message-port-protocol/src/block.js new file mode 100644 index 0000000000..e1e321cef9 --- /dev/null +++ b/packages/ipfs-message-port-protocol/src/block.js @@ -0,0 +1,41 @@ +'use strict' + +const { encodeCID, decodeCID } = require('./cid') +const Block = require('ipld-block') + +/** + * @typedef {import('./cid').EncodedCID} EncodedCID + * @typedef {Object} EncodedBlock + * @property {Uint8Array} data + * @property {EncodedCID} cid + */ + +/** + * Encodes Block for over the message channel transfer. + * + * If `transfer` array is provided all the encountered `ArrayBuffer`s within + * this block will be added to the transfer so they are moved across without + * copy. + * @param {Block} block + * @param {Transferable[]} [transfer] + * @returns {EncodedBlock} + */ +const encodeBlock = ({ cid, data }, transfer) => { + if (transfer) { + transfer.push(data.buffer) + } + return { cid: encodeCID(cid, transfer), data } +} +exports.encodeBlock = encodeBlock + +/** + * @param {EncodedBlock} encodedBlock + * @returns {Block} + */ +const decodeBlock = ({ cid, data }) => { + return new Block(data, decodeCID(cid)) +} + +exports.decodeBlock = decodeBlock + +exports.Block = Block diff --git a/packages/ipfs-message-port-protocol/src/cid.js b/packages/ipfs-message-port-protocol/src/cid.js new file mode 100644 index 0000000000..43a044557e --- /dev/null +++ b/packages/ipfs-message-port-protocol/src/cid.js @@ -0,0 +1,47 @@ +'use strict' + +const CID = require('cids') +const { Buffer } = require('buffer') + +/** + * @typedef {Object} EncodedCID + * @property {string} codec + * @property {Uint8Array} multihash + * @property {number} version + */ + +/** + * Encodes CID (well not really encodes it as all own properties are going to be + * be cloned anyway). If `transfer` array is passed underlying `ArrayBuffer` + * will be added for the transfer list. + * @param {CID} cid + * @param {Transferable[]} [transfer] + * @returns {EncodedCID} + */ +const encodeCID = (cid, transfer) => { + if (transfer) { + transfer.push(cid.multihash.buffer) + } + return cid +} +exports.encodeCID = encodeCID + +/** + * Decodes encoded CID (well sort of instead it makes nasty mutations to turn + * structure cloned CID back into itself). + * @param {EncodedCID} encodedCID + * @returns {CID} + */ +const decodeCID = encodedCID => { + /** @type {CID} */ + const cid = (encodedCID) + Object.setPrototypeOf(cid.multihash, Buffer.prototype) + Object.setPrototypeOf(cid, CID.prototype) + // TODO: Figure out a way to avoid `Symbol.for` here as it can get out of + // sync with cids implementation. + // See: https://github.com/moxystudio/js-class-is/issues/25 + Object.defineProperty(cid, Symbol.for('@ipld/js-cid/CID'), { value: true }) + + return cid +} +exports.decodeCID = decodeCID diff --git a/packages/ipfs-message-port-protocol/src/dag.js b/packages/ipfs-message-port-protocol/src/dag.js index 3a0ac55777..cb3e921998 100644 --- a/packages/ipfs-message-port-protocol/src/dag.js +++ b/packages/ipfs-message-port-protocol/src/dag.js @@ -1,7 +1,7 @@ 'use strict' const CID = require('cids') -const { Buffer } = require('buffer') +const { encodeCID, decodeCID } = require('./cid') /** * @typedef {import('./data').JSONValue} JSONValue @@ -24,42 +24,6 @@ const { Buffer } = require('buffer') * @property {CID[]} cids */ -/** - * Encodes CID (well not really encodes it as all own properties are going to be - * be cloned anyway). If `transfer` array is passed underlying `ArrayBuffer` - * will be added for the transfer list. - * @param {CID} cid - * @param {Transferable[]} [transfer] - * @returns {EncodedCID} - */ -const encodeCID = (cid, transfer) => { - if (transfer) { - transfer.push(cid.multihash.buffer) - } - return cid -} -exports.encodeCID = encodeCID - -/** - * Decodes encoded CID (well sort of instead it makes nasty mutations to turn - * structure cloned CID back into itself). - * @param {EncodedCID} encodedCID - * @returns {CID} - */ -const decodeCID = encodedCID => { - /** @type {CID} */ - const cid = (encodedCID) - Object.setPrototypeOf(cid.multihash, Buffer.prototype) - Object.setPrototypeOf(cid, CID.prototype) - // TODO: Figure out a way to avoid `Symbol.for` here as it can get out of - // sync with cids implementation. - // See: https://github.com/moxystudio/js-class-is/issues/25 - Object.defineProperty(cid, Symbol.for('@ipld/js-cid/CID'), { value: true }) - - return cid -} -exports.decodeCID = decodeCID - /** * @param {EncodedDAGNode} encodedNode * @returns {DAGNode} diff --git a/packages/ipfs-message-port-protocol/src/files.ts b/packages/ipfs-message-port-protocol/src/files.ts index 183b67186c..f7ff427e2e 100644 --- a/packages/ipfs-message-port-protocol/src/files.ts +++ b/packages/ipfs-message-port-protocol/src/files.ts @@ -1,11 +1,5 @@ -import { - StringEncoded, - Time, - Mode, - HashAlg, - RemoteIterable, - FileType -} from './data' +import { StringEncoded, Time, Mode, HashAlg, FileType } from './data' +import { RemoteIterable } from './core' import CID from 'cids' interface Files { diff --git a/packages/ipfs-message-port-protocol/test/block.browser.js b/packages/ipfs-message-port-protocol/test/block.browser.js new file mode 100644 index 0000000000..e769f5c0c3 --- /dev/null +++ b/packages/ipfs-message-port-protocol/test/block.browser.js @@ -0,0 +1,51 @@ +'use strict' + +/* eslint-env mocha */ + +const CID = require('cids') +const { encodeBlock, decodeBlock } = require('../src/block') +const { ipc } = require('./util') +const { expect } = require('interface-ipfs-core/src/utils/mocha') +const { Buffer } = require('buffer') +const Block = require('ipld-block') + +describe('block (browser)', function () { + this.timeout(10 * 1000) + const move = ipc() + + describe('encodeBlock / decodeBlock', () => { + it('should decode Block over message channel', async () => { + const blockIn = new Block( + Buffer.from('hello'), + new CID('QmdfTbBqBPQ7VNxZEYEj14VmRuZBkqFbiwReogJgS1zR1n') + ) + + const blockOut = decodeBlock(await move(encodeBlock(blockIn))) + + expect(blockOut).to.be.deep.equal(blockIn) + }) + + it('should decode Block over message channel & transfer bytes', async () => { + const cid = new CID('QmdfTbBqBPQ7VNxZEYEj14VmRuZBkqFbiwReogJgS1zR1n') + const data = Buffer.from('hello') + const blockIn = new Block(data, cid) + + const transfer = [] + + const blockOut = decodeBlock( + await move(encodeBlock(blockIn, transfer), transfer) + ) + + expect(blockOut).to.be.instanceOf(Block) + expect(blockOut).to.be.deep.equal( + new Block( + Buffer.from('hello'), + new CID('QmdfTbBqBPQ7VNxZEYEj14VmRuZBkqFbiwReogJgS1zR1n') + ) + ) + + expect(data).to.have.property('byteLength', 0, 'data was cleared') + expect(cid.multihash).to.have.property('byteLength', 0, 'cid was cleared') + }) + }) +}) diff --git a/packages/ipfs-message-port-protocol/test/browser.js b/packages/ipfs-message-port-protocol/test/browser.js index 9f9438ba43..2bcacfbe20 100644 --- a/packages/ipfs-message-port-protocol/test/browser.js +++ b/packages/ipfs-message-port-protocol/test/browser.js @@ -1,4 +1,7 @@ 'use strict' +require('./cid.browser') +require('./block.browser') + require('./dag.browser') require('./core.browser') diff --git a/packages/ipfs-message-port-protocol/test/cid.browser.js b/packages/ipfs-message-port-protocol/test/cid.browser.js new file mode 100644 index 0000000000..ece6fd75ec --- /dev/null +++ b/packages/ipfs-message-port-protocol/test/cid.browser.js @@ -0,0 +1,47 @@ +'use strict' + +/* eslint-env mocha */ + +const CID = require('cids') +const { encodeCID, decodeCID } = require('../src/cid') +const { ipc } = require('./util') +const { expect } = require('interface-ipfs-core/src/utils/mocha') + +describe('cid (browser)', function () { + this.timeout(10 * 1000) + const move = ipc() + + describe('encodeCID / decodeCID', () => { + it('should decode to CID over message channel', async () => { + const cidIn = new CID('Qmd7xRhW5f29QuBFtqu3oSD27iVy35NRB91XFjmKFhtgMr') + const cidDataIn = encodeCID(cidIn) + const cidDataOut = await move(cidDataIn) + const cidOut = decodeCID(cidDataOut) + + expect(cidOut).to.be.an.instanceof(CID) + expect(CID.isCID(cidOut)).to.be.true() + expect(cidOut.equals(cidIn)).to.be.true() + expect(cidIn.multihash) + .property('byteLength') + .not.be.equal(0) + }) + + it('should decode CID and transfer bytes', async () => { + const cidIn = new CID('Qmd7xRhW5f29QuBFtqu3oSD27iVy35NRB91XFjmKFhtgMr') + const transfer = [] + const cidDataIn = encodeCID(cidIn, transfer) + const cidDataOut = await move(cidDataIn, transfer) + const cidOut = decodeCID(cidDataOut) + + expect(cidOut).to.be.an.instanceof(CID) + expect(CID.isCID(cidOut)).to.be.true() + expect(cidIn.multihash).property('byteLength', 0) + expect(cidOut.multihash) + .property('byteLength') + .to.not.be.equal(0) + expect(cidOut.toString()).to.be.equal( + 'Qmd7xRhW5f29QuBFtqu3oSD27iVy35NRB91XFjmKFhtgMr' + ) + }) + }) +}) diff --git a/packages/ipfs-message-port-protocol/test/cid.spec.js b/packages/ipfs-message-port-protocol/test/cid.spec.js new file mode 100644 index 0000000000..d6aec85304 --- /dev/null +++ b/packages/ipfs-message-port-protocol/test/cid.spec.js @@ -0,0 +1,32 @@ +'use strict' + +/* eslint-env mocha */ + +const CID = require('cids') +const { encodeCID, decodeCID } = require('../src/cid') +const { expect } = require('interface-ipfs-core/src/utils/mocha') + +describe('cid', function () { + this.timeout(10 * 1000) + + describe('encodeCID / decodeCID', () => { + it('should encode CID', () => { + const { multihash, codec, version } = encodeCID( + new CID('Qmd7xRhW5f29QuBFtqu3oSD27iVy35NRB91XFjmKFhtgMr') + ) + expect(multihash).to.be.an.instanceof(Uint8Array) + expect(version).to.be.a('number') + expect(codec).to.be.a('string') + }) + + it('should decode CID', () => { + const { multihash, codec, version } = encodeCID( + new CID('Qmd7xRhW5f29QuBFtqu3oSD27iVy35NRB91XFjmKFhtgMr') + ) + const cid = new CID('Qmd7xRhW5f29QuBFtqu3oSD27iVy35NRB91XFjmKFhtgMr') + const decodecCID = decodeCID({ multihash, codec, version }) + + expect(cid.equals(decodecCID)).to.be.true() + }) + }) +}) diff --git a/packages/ipfs-message-port-protocol/test/dag.browser.js b/packages/ipfs-message-port-protocol/test/dag.browser.js index c7fc26c3d1..a522b3c1d6 100644 --- a/packages/ipfs-message-port-protocol/test/dag.browser.js +++ b/packages/ipfs-message-port-protocol/test/dag.browser.js @@ -3,7 +3,7 @@ /* eslint-env mocha */ const CID = require('cids') -const { encodeCID, decodeCID, encodeNode, decodeNode } = require('../src/dag') +const { encodeNode, decodeNode } = require('../src/dag') const { ipc } = require('./util') const { expect } = require('interface-ipfs-core/src/utils/mocha') const { Buffer } = require('buffer') @@ -12,39 +12,7 @@ describe('dag (browser)', function () { this.timeout(10 * 1000) const move = ipc() - describe('encodeCID / decodeCID', () => { - it('should decode to CID over message channel', async () => { - const cidIn = new CID('Qmd7xRhW5f29QuBFtqu3oSD27iVy35NRB91XFjmKFhtgMr') - const cidDataIn = encodeCID(cidIn) - const cidDataOut = await move(cidDataIn) - const cidOut = decodeCID(cidDataOut) - - expect(cidOut).to.be.an.instanceof(CID) - expect(CID.isCID(cidOut)).to.be.true() - expect(cidOut.equals(cidIn)).to.be.true() - expect(cidIn.multihash) - .property('byteLength') - .not.be.equal(0) - }) - - it('should decode CID and transfer bytes', async () => { - const cidIn = new CID('Qmd7xRhW5f29QuBFtqu3oSD27iVy35NRB91XFjmKFhtgMr') - const transfer = [] - const cidDataIn = encodeCID(cidIn, transfer) - const cidDataOut = await move(cidDataIn, transfer) - const cidOut = decodeCID(cidDataOut) - - expect(cidOut).to.be.an.instanceof(CID) - expect(CID.isCID(cidOut)).to.be.true() - expect(cidIn.multihash).property('byteLength', 0) - expect(cidOut.multihash) - .property('byteLength') - .to.not.be.equal(0) - expect(cidOut.toString()).to.be.equal( - 'Qmd7xRhW5f29QuBFtqu3oSD27iVy35NRB91XFjmKFhtgMr' - ) - }) - + describe('encodeNode / decodeNode', () => { it('should decode dagNode over message channel', async () => { const cid1 = new CID( 'bafyreic6f672hnponukaacmk2mmt7vs324zkagvu4hcww6yba6kby25zce' diff --git a/packages/ipfs-message-port-protocol/test/dag.spec.js b/packages/ipfs-message-port-protocol/test/dag.spec.js index a2b570788f..53c0388ac3 100644 --- a/packages/ipfs-message-port-protocol/test/dag.spec.js +++ b/packages/ipfs-message-port-protocol/test/dag.spec.js @@ -3,34 +3,13 @@ /* eslint-env mocha */ const CID = require('cids') -const { encodeCID, decodeCID, encodeNode } = require('../src/dag') +const { encodeNode } = require('../src/dag') const { expect } = require('interface-ipfs-core/src/utils/mocha') const { Buffer } = require('buffer') describe('dag', function () { this.timeout(10 * 1000) - describe('encodeCID / decodeCID', () => { - it('should encode CID', () => { - const { multihash, codec, version } = encodeCID( - new CID('Qmd7xRhW5f29QuBFtqu3oSD27iVy35NRB91XFjmKFhtgMr') - ) - expect(multihash).to.be.an.instanceof(Uint8Array) - expect(version).to.be.a('number') - expect(codec).to.be.a('string') - }) - - it('should decode CID', () => { - const { multihash, codec, version } = encodeCID( - new CID('Qmd7xRhW5f29QuBFtqu3oSD27iVy35NRB91XFjmKFhtgMr') - ) - const cid = new CID('Qmd7xRhW5f29QuBFtqu3oSD27iVy35NRB91XFjmKFhtgMr') - const decodecCID = decodeCID({ multihash, codec, version }) - - expect(cid.equals(decodecCID)).to.be.true() - }) - }) - describe('encodeNode / decodeNode', () => { it('shoud encode node', () => { const cid1 = new CID( diff --git a/packages/ipfs-message-port-protocol/test/node.js b/packages/ipfs-message-port-protocol/test/node.js index 2ef7c78345..c6600875fa 100644 --- a/packages/ipfs-message-port-protocol/test/node.js +++ b/packages/ipfs-message-port-protocol/test/node.js @@ -1,3 +1,4 @@ 'use strict' +require('./cid.spec') require('./dag.spec') diff --git a/packages/ipfs-message-port-protocol/tsconfig.json b/packages/ipfs-message-port-protocol/tsconfig.json index fd2a1f1991..4c65e6338b 100644 --- a/packages/ipfs-message-port-protocol/tsconfig.json +++ b/packages/ipfs-message-port-protocol/tsconfig.json @@ -16,6 +16,6 @@ "outDir": "./dist/" }, "exclude": ["dist"], - "include": ["src"], + "include": ["src", "../../node_modules/ipld-block/src/index.js"], "compileOnSave": false } diff --git a/packages/ipfs-message-port-server/src/block.js b/packages/ipfs-message-port-server/src/block.js new file mode 100644 index 0000000000..a6636c9514 --- /dev/null +++ b/packages/ipfs-message-port-server/src/block.js @@ -0,0 +1,125 @@ +'use strict' + +const { Buffer } = require('buffer') +const { collect } = require('./util') +const { decodeCID, encodeCID } = require('ipfs-message-port-protocol/src/cid') +const { + decodeBlock, + encodeBlock +} = require('ipfs-message-port-protocol/src/block') + +/** + * @typedef {import('./ipfs').IPFS} IPFS + * @typedef {import('cids')} CID + * @typedef {import('ipfs-message-port-protocol/src/block').Block} Block + * @typedef {import('ipfs-message-port-protocol/src/cid').EncodedCID} EncodedCID + * @typedef {import('ipfs-message-port-protocol/src/block').EncodedBlock} EncodedBlock + * @typedef {RmEntry} Rm + * @typedef {StatResult} Stat + */ + +/** + * @class + */ +class BlockService { + /** + * @param {IPFS} ipfs + */ + constructor (ipfs) { + this.ipfs = ipfs + } + + /** + * @typedef {Object} GetResult + * @property {EncodedBlock} block + * @property {Transferable[]} transfer + * + * @param {Object} query + * @param {EncodedCID} query.cid + * @param {number} [query.timeout] + * @param {AbortSignal} [query.signal] + * @returns {Promise} + */ + async get (query) { + const cid = decodeCID(query.cid) + const block = await this.ipfs.block.get(cid, query) + /** @type {Transferable[]} */ + const transfer = [] + return { transfer, block: encodeBlock(block, transfer) } + } + + /** + * @typedef {Object} PutResult + * @property {EncodedBlock} block + * @property {Transferable[]} transfer + * + * Stores input as an IPFS block. + * @param {Object} query + * @param {EncodedBlock|Uint8Array} query.block + * @param {EncodedCID|void} [query.cid] + * @param {string} [query.format] + * @param {string} [query.mhtype] + * @param {number} [query.mhlen] + * @param {number} [query.version] + * @param {boolean} [query.pin] + * @param {number} [query.timeout] + * @param {AbortSignal} [query.signal] + * @returns {Promise} + */ + async put (query) { + const input = query.block + /** @type {Buffer|Block} */ + const block = + input instanceof Uint8Array + ? Buffer.from(input.buffer, input.byteOffset, input.byteLength) + : decodeBlock(input) + const result = await this.ipfs.block.put(block, { + ...query, + cid: query.cid ? decodeCID(query.cid) : query.cid + }) + + /** @type {Transferable[]} */ + const transfer = [] + return { transfer, block: encodeBlock(result, transfer) } + } + + /** + * Remove one or more IPFS block(s). + * @param {Object} query + * @param {EncodedCID[]} query.cids + * @param {boolean} [query.force] + * @param {boolean} [query.quiet] + * @param {number} [query.timeout] + * @param {AbortSignal} [query.signal] + * @returns {Promise} + * + * @typedef {RmEntry[]} RmResult + * + * @typedef {Object} RmEntry + * @property {CID} cid + * @property {Error|undefined} [error] + */ + rm (query) { + return collect(this.ipfs.block.rm(query.cids.map(decodeCID), query)) + } + + /** + * Gets information of a raw IPFS block. + * @param {Object} query + * @param {EncodedCID} query.cid + * @param {number} [query.timeout] + * @param {AbortSignal} [query.signal] + * @returns {Promise} + * + * @typedef {Object} StatResult + * @property {EncodedCID} cid + * @property {number} size + */ + async stat (query) { + const cid = decodeCID(query.cid) + const result = await this.ipfs.block.stat(cid, query) + return { ...result, cid: encodeCID(result.cid) } + } +} + +exports.BlockService = BlockService diff --git a/packages/ipfs-message-port-server/src/core.js b/packages/ipfs-message-port-server/src/core.js index c1ff916662..75110e41aa 100644 --- a/packages/ipfs-message-port-server/src/core.js +++ b/packages/ipfs-message-port-server/src/core.js @@ -7,7 +7,7 @@ const { encodeIterable, decodeCallback } = require('ipfs-message-port-protocol/src/core') -const { decodeCID, encodeCID } = require('ipfs-message-port-protocol/src/dag') +const { decodeCID, encodeCID } = require('ipfs-message-port-protocol/src/cid') /** @@ -18,7 +18,7 @@ const { decodeCID, encodeCID } = require('ipfs-message-port-protocol/src/dag') * @typedef {import("ipfs-message-port-protocol/src/data").Mode} Mode * @typedef {import("ipfs-message-port-protocol/src/data").HashAlg} HashAlg * @typedef {import('ipfs-message-port-protocol/src/data').FileType} FileType - * @typedef {import('ipfs-message-port-protocol/src/dag').EncodedCID} EncodedCID + * @typedef {import('ipfs-message-port-protocol/src/cid').EncodedCID} EncodedCID * @typedef {import("./ipfs").FileOutput} FileOutput * @typedef {import('./ipfs').FileObject} FileObject * @typedef {import('./ipfs').FileContent} DecodedFileContent diff --git a/packages/ipfs-message-port-server/src/dag.js b/packages/ipfs-message-port-server/src/dag.js index 6fb5569225..55e754c43a 100644 --- a/packages/ipfs-message-port-server/src/dag.js +++ b/packages/ipfs-message-port-server/src/dag.js @@ -1,22 +1,13 @@ 'use strict' const { collect } = require('./util') -const { - decodeNode, - encodeNode, - encodeCID, - decodeCID -} = require('ipfs-message-port-protocol/src/dag') +const { encodeCID, decodeCID } = require('ipfs-message-port-protocol/src/cid') +const { decodeNode, encodeNode } = require('ipfs-message-port-protocol/src/dag') -/** - * @template T - * @typedef {import('ipfs-message-port-protocol/src/data').StringEncoded} StringEncoded - */ /** * @typedef {import('./ipfs').IPFS} IPFS - * @typedef {import('ipfs-message-port-protocol/src/dag').JSONValue} JSONValue + * @typedef {import('ipfs-message-port-protocol/src/cid').EncodedCID} EncodedCID * @typedef {import('ipfs-message-port-protocol/src/dag').DAGNode} DAGNode - * @typedef {import('ipfs-message-port-protocol/src/dag').EncodedCID} EncodedCID * @typedef {import('ipfs-message-port-protocol/src/dag').EncodedDAGNode} EncodedDAGNode * * diff --git a/packages/ipfs-message-port-server/src/files.js b/packages/ipfs-message-port-server/src/files.js index f1a40a5dab..46137f842c 100644 --- a/packages/ipfs-message-port-server/src/files.js +++ b/packages/ipfs-message-port-server/src/files.js @@ -7,7 +7,7 @@ const { encodeIterable, decodeIterable } = require('ipfs-message-port-protocol/src/core') -const { encodeCID } = require('ipfs-message-port-protocol/src/dag') +const { encodeCID } = require('ipfs-message-port-protocol/src/cid') /** * @typedef {import('ipfs-message-port-protocol/src/dag').EncodedCID} EncodedCID diff --git a/packages/ipfs-message-port-server/src/index.js b/packages/ipfs-message-port-server/src/index.js index 21dc160f27..f5ee518aae 100644 --- a/packages/ipfs-message-port-server/src/index.js +++ b/packages/ipfs-message-port-server/src/index.js @@ -5,6 +5,7 @@ const { DAG } = require('./dag') const { Core } = require('./core') const { Files } = require('./files') +const { BlockService } = require('./block') /** * @typedef {import('./ipfs').IPFS} IPFS @@ -19,6 +20,7 @@ class IPFSService { this.dag = new DAG(ipfs) this.core = new Core(ipfs) this.files = new Files(ipfs) + this.block = new BlockService(ipfs) } } diff --git a/packages/ipfs-message-port-server/src/ipfs.ts b/packages/ipfs-message-port-server/src/ipfs.ts index 507f84a309..13524b81fb 100644 --- a/packages/ipfs-message-port-server/src/ipfs.ts +++ b/packages/ipfs-message-port-server/src/ipfs.ts @@ -7,37 +7,38 @@ import { Time, CIDVersion } from 'ipfs-message-port-protocol/src/data' +import { EncodedCID } from './block' type Mode = string | number export interface IPFS extends Core { dag: DAG files: Files + block: BlockService } export interface IPFSFactory { create(): Promise } -type PutOptions = { +interface AbortOptions { + timeout?: number + signal?: AbortSignal +} + +interface PutOptions extends AbortOptions { format?: string | void hashAlg?: string | void cid?: CID | void preload?: boolean pin?: boolean - timeout?: number - signal?: AbortSignal } -type GetOptions = { +interface GetOptions extends AbortOptions { localResolve?: boolean - timeout?: number - signal?: AbortSignal } -type TreeOptions = { +interface TreeOptions extends AbortOptions { recursive?: boolean - timeout?: number - signal?: AbortSignal | void } export interface DAG { @@ -55,7 +56,7 @@ export interface Core { cat(ipfsPath: CID | string, options: CatOptions): AsyncIterable } -type AddOptions = { +interface AddOptions extends AbortOptions { chunker?: string cidVersion?: number enableShardingExperiment?: boolean @@ -67,9 +68,6 @@ type AddOptions = { shardSplitThreshold?: number trickle?: boolean wrapWithDirectory?: boolean - - timeout?: number - signal?: AbortSignal } export type FileInput = { @@ -87,11 +85,9 @@ export type FileOutput = { size: number } -export type CatOptions = { +interface CatOptions extends AbortOptions { offset?: number length?: number - timeout?: number - signal?: AbortSignal } export interface Files { @@ -108,19 +104,15 @@ export interface Files { stat(path: string, options?: StatOptions): Promise } -type ChmodOptions = { - recursive: boolean - flush: boolean - hashAlg: string - cidVersion: number - timeout: number - signal: AbortSignal +interface ChmodOptions extends AbortOptions { + recursive?: boolean + flush?: boolean + hashAlg?: string + cidVersion?: number } -type LsOptions = { +interface LsOptions extends AbortOptions { sort?: boolean - timeout?: number - signal?: AbortSignal } type LsEntry = { @@ -132,12 +124,10 @@ type LsEntry = { mtime: UnixFSTime } -type StatOptions = { +interface StatOptions extends AbortOptions { hash?: boolean size?: boolean withLocal?: boolean - timeout?: number - signal?: AbortSignal } type Stat = { @@ -198,7 +188,7 @@ export type FileContent = | AsyncIterable | AsyncIterable -type WriteOptions = { +interface WriteOptions extends AbortOptions { offset?: number length?: number create?: boolean @@ -216,3 +206,41 @@ type WriteResult = { cid: CID size: number } + +interface Block { + cid: CID + data: Buffer +} + +interface BlockService { + get(cid: CID, options?: GetBlockOptions): Promise + put(block: Block, options?: PutBlockOptions): Promise + put(buffer: Buffer, options?: PutBufferOptions): Promise + rm( + cid: CID | CID[], + options?: RmBlockOptions + ): AsyncIterable<{ cid: CID; error?: Error }> + stat( + cid: CID, + options?: StatBlockOptions + ): Promise<{ cid: CID; size: number }> +} + +interface GetBlockOptions extends AbortOptions {} +interface PutBlockOptions extends AbortOptions { + format?: string + mhtype?: string + mhlen?: number + version?: number + pin?: boolean +} +interface PutBufferOptions extends PutBlockOptions { + cid?: EncodedCID | void +} + +interface RmBlockOptions extends AbortOptions { + force?: boolean + quiet?: boolean +} + +interface StatBlockOptions extends AbortOptions {} From bfede92adba7990ae38d5a221620b936c7fad0ec Mon Sep 17 00:00:00 2001 From: Irakli Gozalishvili Date: Fri, 19 Jun 2020 06:22:49 -0700 Subject: [PATCH 20/63] chore: disable intermittent failing test --- packages/ipfs/test/gateway/index.js | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/packages/ipfs/test/gateway/index.js b/packages/ipfs/test/gateway/index.js index 892b2d207d..23eb0226d9 100644 --- a/packages/ipfs/test/gateway/index.js +++ b/packages/ipfs/test/gateway/index.js @@ -106,7 +106,9 @@ describe('HTTP Gateway', function () { expect(res.headers.suborigin).to.equal(undefined) }) - it('returns 400 for request with invalid argument', async () => { + // Produces intermittent failures + // https://github.com/ipfs/js-ipfs/issues/3101 + it.skip('returns 400 for request with invalid argument', async () => { const res = await gateway.inject({ method: 'GET', url: '/ipfs/invalid' From 108f8c95d3d3515492cac94cdcaa334acb6f0796 Mon Sep 17 00:00:00 2001 From: Irakli Gozalishvili Date: Fri, 19 Jun 2020 08:10:51 -0700 Subject: [PATCH 21/63] chore: disable intermittent failing interface test --- packages/ipfs/test/core/interface.spec.js | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/packages/ipfs/test/core/interface.spec.js b/packages/ipfs/test/core/interface.spec.js index 8f3778e15a..2166d26d9d 100644 --- a/packages/ipfs/test/core/interface.spec.js +++ b/packages/ipfs/test/core/interface.spec.js @@ -19,7 +19,14 @@ describe('interface-ipfs-core tests', function () { tests.bitswap(commonFactory) - tests.block(commonFactory) + tests.block(commonFactory, { + skip: [ + { + name: 'should return an error for an invalid CID', + reason: 'Intermittent failure: https://github.com/ipfs/js-ipfs/issues/3100' + } + ] + }) tests.bootstrap(commonFactory) From fe85bff10ee3c877ed8b56feab41c9a516bc06d0 Mon Sep 17 00:00:00 2001 From: Irakli Gozalishvili Date: Fri, 19 Jun 2020 09:51:02 -0700 Subject: [PATCH 22/63] chore: disable intermittent failing test --- packages/ipfs/test/http-api/inject/block.js | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/packages/ipfs/test/http-api/inject/block.js b/packages/ipfs/test/http-api/inject/block.js index 592a05f9ad..4411efbd07 100644 --- a/packages/ipfs/test/http-api/inject/block.js +++ b/packages/ipfs/test/http-api/inject/block.js @@ -60,7 +60,9 @@ describe('/block', () => { return testHttpMethod('/api/v0/block/put') }) - it('returns 400 if no node is provided', async () => { + // Intermittent timeouts + // https://github.com/ipfs/js-ipfs/issues/3105 + it.skip('returns 400 if no node is provided', async () => { const form = new FormData() const headers = form.getHeaders() const payload = await streamToPromise(form) From 132e8e665ebf1cac0d48a58b13767ffd91e756a3 Mon Sep 17 00:00:00 2001 From: Irakli Gozalishvili Date: Fri, 19 Jun 2020 14:03:05 -0700 Subject: [PATCH 23/63] fix: remote error transfer in firefox --- .../ipfs-message-port-client/src/block.js | 24 +++-- .../ipfs-message-port-client/src/client.js | 56 ++++------- .../ipfs-message-port-protocol/src/core.js | 11 ++- .../ipfs-message-port-protocol/src/error.js | 92 +++++++++++++++++++ .../ipfs-message-port-server/src/block.js | 32 ++++++- .../ipfs-message-port-server/src/server.js | 13 ++- 6 files changed, 173 insertions(+), 55 deletions(-) create mode 100644 packages/ipfs-message-port-protocol/src/error.js diff --git a/packages/ipfs-message-port-client/src/block.js b/packages/ipfs-message-port-client/src/block.js index ab425a86c0..23b52bf9f7 100644 --- a/packages/ipfs-message-port-client/src/block.js +++ b/packages/ipfs-message-port-client/src/block.js @@ -2,6 +2,7 @@ const { Client } = require('./client') const { encodeCID, decodeCID } = require('ipfs-message-port-protocol/src/cid') +const { decodeError } = require('ipfs-message-port-protocol/src/error') const { encodeBlock, decodeBlock @@ -11,6 +12,7 @@ const { * @typedef {import('cids')} CID * @typedef {import('ipfs-message-port-server/src/block').Block} Block * @typedef {import('ipfs-message-port-server/src/block').EncodedBlock} EncodedBlock + * @typedef {import('ipfs-message-port-server/src/block').Rm} EncodedRmEntry * @typedef {import('ipfs-message-port-server/src/block').BlockService} API * @typedef {import('./client').ClientTransport} Transport */ @@ -103,12 +105,7 @@ class BlockClient extends Client { : [encodeCID(cids)] }) - for (const entry of entries) { - yield { - ...entry, - cid: decodeCID(entry.cid) - } - } + yield * entries.map(decodeRmEntry) } /** @@ -135,4 +132,19 @@ class BlockClient extends Client { return { ...result, cid: decodeCID(result.cid) } } } + +/** + * + * @param {EncodedRmEntry} entry + * @returns {RmEntry} + */ +const decodeRmEntry = entry => { + const cid = decodeCID(entry.cid) + if (entry.error) { + return { cid, error: decodeError(entry.error) } + } else { + return { cid } + } +} + module.exports = BlockClient diff --git a/packages/ipfs-message-port-client/src/client.js b/packages/ipfs-message-port-client/src/client.js index 1a665a34bc..69e3af14b5 100644 --- a/packages/ipfs-message-port-client/src/client.js +++ b/packages/ipfs-message-port-client/src/client.js @@ -1,28 +1,7 @@ 'use strict' /* eslint-env browser */ - -class RemoteError extends Error { - /** - * Represents error that occured in the worker thread which was structure - * cloned over the message channel. - * - * @param {Object} info - * @param {string} info.message - * @param {string} info.stack - * @param {string} info.name - * @param {string} [info.code] - */ - constructor ({ message, stack, name, code }) { - super(message) - this.stack = stack - this.name = name - if (code) { - this.code = code - } - } -} -exports.RemoteError = RemoteError +const { decodeError } = require('ipfs-message-port-protocol/src/error') class TimeoutError extends Error {} exports.TimeoutError = TimeoutError @@ -70,12 +49,11 @@ class Query { this.result = new Promise((resolve, reject) => { this.succeed = resolve this.fail = reject - this.abortController = new AbortController() - this.signal = this.abortController.signal + this.signal = input.signal this.input = input this.namespace = namespace this.method = method - this.timeout = Infinity + this.timeout = input.timeout == null ? Infinity : input.timeout }) } @@ -92,11 +70,6 @@ class Query { transfer () { return this.input.transfer } - - abort () { - this.abortController.abort() - this.fail(new AbortError()) - } } /** @typedef {Transport} ClientTransport */ @@ -131,7 +104,11 @@ class Transport { setTimeout(Transport.timeout, query.timeout, this, id) } - query.signal.addEventListener('abort', () => this.abort(id), { once: true }) + if (query.signal) { + query.signal.addEventListener('abort', () => this.abort(id), { + once: true + }) + } if (this.port) { Transport.postQuery(this.port, id, query) @@ -148,8 +125,11 @@ class Transport { const { queries } = self const query = queries[id] if (query) { - self.abort(id) - query.fail(new TimeoutError()) + delete queries[id] + query.fail(new TimeoutError('request timed out')) + if (self.port) { + self.port.postMessage({ type: 'abort', id }) + } } } @@ -158,9 +138,11 @@ class Transport { * @param {string} id */ abort (id) { - const query = this.queries[id] + const { queries } = this + const query = queries[id] if (query) { - delete this.queries[id] + delete queries[id] + query.fail(new AbortError()) if (this.port) { this.port.postMessage({ type: 'abort', id }) } @@ -224,10 +206,10 @@ class Transport { if (result.ok) { query.succeed(result.value) } else { - query.fail(new RemoteError(result.error)) + query.fail(decodeError(result.error)) } } else { - throw new RangeError(`Received response${id} for unknown query`) + // throw new RangeError(`Received response${id} for unknown query`) } } } diff --git a/packages/ipfs-message-port-protocol/src/core.js b/packages/ipfs-message-port-protocol/src/core.js index e31d55f9a3..56e7552978 100644 --- a/packages/ipfs-message-port-protocol/src/core.js +++ b/packages/ipfs-message-port-protocol/src/core.js @@ -1,6 +1,7 @@ 'use strict' /* eslint-env browser */ +const { encodeError, decodeError } = require('./error') /** * @template T @@ -33,10 +34,11 @@ */ /** + * @typedef {import('./error').EncodedError} EncodedError * @typedef {Object} RemoteError * @property {true} done * @property {void} value - * @property {Error} error + * @property {EncodedError} error */ /** @@ -76,7 +78,7 @@ const decodeIterable = async function * ({ port }, decode) { const { done, value, error } = await next() isDone = done if (error != null) { - throw error + throw decodeError(error) } else if (value != null) { yield decode(value) } @@ -124,7 +126,10 @@ const encodeIterable = (iterable, encode, transfer) => { ) } } catch (error) { - port.postMessage({ type: 'throw', error }) + port.postMessage({ + type: 'throw', + error: encodeError(error) + }) port.close() } break diff --git a/packages/ipfs-message-port-protocol/src/error.js b/packages/ipfs-message-port-protocol/src/error.js new file mode 100644 index 0000000000..2c1e2d33ee --- /dev/null +++ b/packages/ipfs-message-port-protocol/src/error.js @@ -0,0 +1,92 @@ +'use strict' + +/* eslint-env browser */ + +// Chrome implements structure clonning of native error types, +// Firefox does not https://bugzilla.mozilla.org/show_bug.cgi?id=1556604 +// This does a runtime check to detect if cloning is supported. +const isErrorCloningSupported = (() => { + try { + new MessageChannel().port1.postMessage(new Error()) + return true + } catch (error) { + return false + } +})() + +/** + * @typedef {Error|ErrorData} EncodedError + * + * Properties added by err-code library + * @typedef {Object} ErrorExtension + * @property {string} [code] + * @property {string} [detail] + */ + +/** + * @typedef {Error & ErrorExtension} ExtendedError + */ + +/** + * @typedef {Object} ErrorData + * @property {string} name + * @property {string} message + * @property {string|undefined} stack + * @property {string|undefined} code + * @property {string|undefined} detail + * + * @param {ExtendedError} error + * @returns {EncodedError} + */ +const encodeError = error => { + if (isErrorCloningSupported) { + return error + } else { + const { name, message, stack, code, detail } = error + return { name, message, stack, code, detail } + } +} +exports.encodeError = encodeError + +/** + * @param {EncodedError} error + * @returns {Error} + */ +const decodeError = error => { + if (error instanceof Error) { + return error + } else { + const { name, message, stack, code } = error + return Object.assign(createError(name, message), { name, stack, code }) + } +} +exports.decodeError = decodeError + +/** + * Create error by error name. + * @param {string} name + * @param {string} message + * @returns {Error} + */ +const createError = (name, message) => { + switch (name) { + case 'RangeError': { + return new RangeError(message) + } + case 'ReferenceError': { + return ReferenceError(message) + } + case 'SyntaxError': { + return new SyntaxError(message) + } + case 'TypeError': { + return new TypeError(message) + } + case 'URIError': { + return new URIError(message) + } + default: { + return new Error(message) + } + } +} diff --git a/packages/ipfs-message-port-server/src/block.js b/packages/ipfs-message-port-server/src/block.js index a6636c9514..f669a10bae 100644 --- a/packages/ipfs-message-port-server/src/block.js +++ b/packages/ipfs-message-port-server/src/block.js @@ -2,6 +2,7 @@ const { Buffer } = require('buffer') const { collect } = require('./util') +const { encodeError } = require('ipfs-message-port-protocol/src/error') const { decodeCID, encodeCID } = require('ipfs-message-port-protocol/src/cid') const { decodeBlock, @@ -11,6 +12,7 @@ const { /** * @typedef {import('./ipfs').IPFS} IPFS * @typedef {import('cids')} CID + * @typedef {import('ipfs-message-port-protocol/src/error').EncodedError} EncodedError * @typedef {import('ipfs-message-port-protocol/src/block').Block} Block * @typedef {import('ipfs-message-port-protocol/src/cid').EncodedCID} EncodedCID * @typedef {import('ipfs-message-port-protocol/src/block').EncodedBlock} EncodedBlock @@ -96,11 +98,17 @@ class BlockService { * @typedef {RmEntry[]} RmResult * * @typedef {Object} RmEntry - * @property {CID} cid - * @property {Error|undefined} [error] + * @property {EncodedCID} cid + * @property {EncodedError|undefined} [error] */ - rm (query) { - return collect(this.ipfs.block.rm(query.cids.map(decodeCID), query)) + async rm (query) { + /** @type {Transferable[]} */ + const transfer = [] + const result = await collect( + this.ipfs.block.rm(query.cids.map(decodeCID), query) + ) + + return result.map(entry => encodeRmEntry(entry, transfer)) } /** @@ -122,4 +130,20 @@ class BlockService { } } +/** + * @param {Object} entry + * @param {CID} entry.cid + * @param {Error|void} [entry.error] + * @param {Transferable[]} transfer + * @returns {RmEntry} + */ +const encodeRmEntry = (entry, transfer) => { + const cid = encodeCID(entry.cid, transfer) + if (entry.error) { + return { cid, error: encodeError(entry.error) } + } else { + return { cid } + } +} + exports.BlockService = BlockService diff --git a/packages/ipfs-message-port-server/src/server.js b/packages/ipfs-message-port-server/src/server.js index 92891bb2b7..f8173997f7 100644 --- a/packages/ipfs-message-port-server/src/server.js +++ b/packages/ipfs-message-port-server/src/server.js @@ -2,7 +2,7 @@ /* eslint-env browser */ -// const CID = require('cids') +const { encodeError } = require('ipfs-message-port-protocol/src/error') /** * @typedef {import('./ipfs').IPFS} IPFS @@ -216,9 +216,12 @@ class Server { { type: 'result', id, result: { ok: true, value } }, value.transfer || [] ) - } catch ({ name, message, stack, code }) { - const error = { name, message, stack, code } - port.postMessage({ type: 'result', id, result: { ok: false, error } }) + } catch (error) { + port.postMessage({ + type: 'result', + id, + result: { ok: false, error: encodeError(error) } + }) } } } @@ -261,7 +264,7 @@ class Server { */ execute (data) { const query = Query.from(data) - this.execute(query) + this.run(query) return query.result } From dc5aaf3b7a878c1e82946b1af02d322245bb3b96 Mon Sep 17 00:00:00 2001 From: Irakli Gozalishvili Date: Fri, 19 Jun 2020 14:27:19 -0700 Subject: [PATCH 24/63] chore: enable test that was fixed by 8808abc --- packages/ipfs/test/http-api/inject/block.js | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/packages/ipfs/test/http-api/inject/block.js b/packages/ipfs/test/http-api/inject/block.js index 4411efbd07..592a05f9ad 100644 --- a/packages/ipfs/test/http-api/inject/block.js +++ b/packages/ipfs/test/http-api/inject/block.js @@ -60,9 +60,7 @@ describe('/block', () => { return testHttpMethod('/api/v0/block/put') }) - // Intermittent timeouts - // https://github.com/ipfs/js-ipfs/issues/3105 - it.skip('returns 400 if no node is provided', async () => { + it('returns 400 if no node is provided', async () => { const form = new FormData() const headers = form.getHeaders() const payload = await streamToPromise(form) From b1350eb6dbfb31112591b56e11cc62f3b8b70091 Mon Sep 17 00:00:00 2001 From: Irakli Gozalishvili Date: Fri, 19 Jun 2020 14:56:04 -0700 Subject: [PATCH 25/63] chore: workaround mysterious bundle size changes --- packages/ipfs-http-client/.aegir.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/ipfs-http-client/.aegir.js b/packages/ipfs-http-client/.aegir.js index 4db8c2cc23..4e874f4c77 100644 --- a/packages/ipfs-http-client/.aegir.js +++ b/packages/ipfs-http-client/.aegir.js @@ -16,7 +16,7 @@ const server = createServer({ let echoServer = new EchoServer() module.exports = { - bundlesize: { maxSize: '89kB' }, + bundlesize: { maxSize: '90kB' }, karma: { files: [{ pattern: 'node_modules/interface-ipfs-core/test/fixtures/**/*', From a3ca1ae868e230bb4dff151514e3989b2f3e2be2 Mon Sep 17 00:00:00 2001 From: Irakli Gozalishvili Date: Mon, 22 Jun 2020 10:29:10 -0700 Subject: [PATCH 26/63] chore: disable electron tests until #587 is fixed --- .../ipfs-message-port-protocol/package.json | 17 +++++++++++------ 1 file changed, 11 insertions(+), 6 deletions(-) diff --git a/packages/ipfs-message-port-protocol/package.json b/packages/ipfs-message-port-protocol/package.json index b6995b7af9..599db67585 100644 --- a/packages/ipfs-message-port-protocol/package.json +++ b/packages/ipfs-message-port-protocol/package.json @@ -2,12 +2,17 @@ "name": "ipfs-message-port-protocol", "version": "0.0.1", "description": "IPFS client/server protocol over message port", - "keywords": ["ipfs"], + "keywords": [ + "ipfs" + ], "homepage": "https://github.com/ipfs/js-ipfs/tree/master/packages/ipfs-message-port-protocol#readme", "bugs": "https://github.com/ipfs/js-ipfs/issues", "license": "(Apache-2.0 OR MIT)", "leadMaintainer": "Alex Potsides ", - "files": ["src", "dist"], + "files": [ + "src", + "dist" + ], "browser": {}, "repository": { "type": "git", @@ -18,8 +23,6 @@ "test:node": "aegir test -t node", "test:browser": "aegir test -t browser", "test:webworker": "aegir test -t webworker", - "test:electron-main": "aegir test -t electron-main", - "test:electron-renderer": "aegir test -t electron-renderer", "test:chrome": "aegir test -t browser -t webworker -- --browsers ChromeHeadless", "test:firefox": "aegir test -t browser -t webworker -- --browsers FirefoxHeadless", "lint": "aegir lint", @@ -41,5 +44,7 @@ "node": ">=10.3.0", "npm": ">=3.0.0" }, - "contributors": ["Irakli Gozalishvili "] -} + "contributors": [ + "Irakli Gozalishvili " + ] +} \ No newline at end of file From 099557c471227099b53571ce34f14e6f2a628940 Mon Sep 17 00:00:00 2001 From: Irakli Gozalishvili Date: Mon, 22 Jun 2020 14:02:27 -0700 Subject: [PATCH 27/63] chore: expose CID from encoder --- packages/ipfs-message-port-protocol/src/cid.js | 2 ++ 1 file changed, 2 insertions(+) diff --git a/packages/ipfs-message-port-protocol/src/cid.js b/packages/ipfs-message-port-protocol/src/cid.js index 43a044557e..a17f60bc67 100644 --- a/packages/ipfs-message-port-protocol/src/cid.js +++ b/packages/ipfs-message-port-protocol/src/cid.js @@ -45,3 +45,5 @@ const decodeCID = encodedCID => { return cid } exports.decodeCID = decodeCID + +exports.CID = CID From 0483db7ac27914ad8d7c3f20dc1b798cc4a592ec Mon Sep 17 00:00:00 2001 From: Irakli Gozalishvili Date: Mon, 22 Jun 2020 14:04:48 -0700 Subject: [PATCH 28/63] chore: add readme documents --- packages/ipfs-message-port-client/README.md | 141 ++++++++++++ packages/ipfs-message-port-protocol/README.md | 208 ++++++++++++++++++ packages/ipfs-message-port-server/README.md | 103 +++++++++ 3 files changed, 452 insertions(+) create mode 100644 packages/ipfs-message-port-client/README.md create mode 100644 packages/ipfs-message-port-protocol/README.md create mode 100644 packages/ipfs-message-port-server/README.md diff --git a/packages/ipfs-message-port-client/README.md b/packages/ipfs-message-port-client/README.md new file mode 100644 index 0000000000..c75da4a79b --- /dev/null +++ b/packages/ipfs-message-port-client/README.md @@ -0,0 +1,141 @@ +# ipfs-message-port-client + +[![](https://img.shields.io/badge/made%20by-Protocol%20Labs-blue.svg?style=flat-square)](http://protocol.ai) +[![](https://img.shields.io/badge/project-IPFS-blue.svg?style=flat-square)](http://ipfs.io/) +[![](https://img.shields.io/badge/freenode-%23ipfs-blue.svg?style=flat-square)](http://webchat.freenode.net/?channels=%23ipfs) +[![Travis CI](https://flat.badgen.net/travis/ipfs/js-ipfs)](https://travis-ci.com/ipfs/js-ipfs) +[![Codecov branch](https://img.shields.io/codecov/c/github/ipfs/js-ipfs/master.svg?style=flat-square)](https://codecov.io/gh/ipfs/js-ipfs) +[![Dependency Status](https://david-dm.org/ipfs/js-ipfs/status.svg?path=packages/ipfs-message-port-client)](https://david-dm.org/ipfs/js-ipfs?path=packages/ipfs-message-port-client) +[![js-standard-style](https://img.shields.io/badge/code%20style-standard-brightgreen.svg?style=flat-square)](https://github.com/feross/standard) + +> A client library for the IPFS API over [message channel][]. This client library provides (subset) of [IPFS API](https://github.com/ipfs/js-ipfs/tree/master/docs/api) enabling applications to work with js-ipfs running in the different JS e.g. [SharedWorker][]. + + +## Lead Maintainer + +[Alex Potsides](https://github.com/achingbrain) + +## Table of Contentens + +- [Install](#install) +- [Contribute](#contribute) +- [License](#license) + +## Install + +```bash +$ npm install --save ipfs-message-port-client +``` + +## Usage + +This client library works with IPFS node over the [message channel][] and assumes that IPFS node is provided via `ipfs-message-port-server` on the other end. + +It provides following API subseset: + +- [`ipfs.dag`](https://github.com/ipfs/js-ipfs/blob/master/docs/core-api/DAG.md) +- [`ipfs.block`](https://github.com/ipfs/js-ipfs/blob/master/docs/core-api/BLOCK.md) +- [`ipfs.add`](https://github.com/ipfs/js-ipfs/blob/master/docs/core-api/FILES.md#ipfsadddata-options) +- [`ipfs.cat`](https://github.com/ipfs/js-ipfs/blob/master/docs/core-api/FILES.md#ipfscatipfspath-options) +- [`ipfs.files.stat`](https://github.com/ipfs/js-ipfs/blob/master/docs/core-api/FILES.md#ipfsfilesstatpath-options) + +Client can be instantiated from the [`MessagePort`][] instance + + +```js +const IPFSClient = require('ipfs-message-port-client') + + +const main = async () => { + const worker = new SharedWorker(IPFS_SERVER_URL) + const ipfs = IPFSClient.from(worker.port) + const data = ipfs.cat('/ipfs/QmdfTbBqBPQ7VNxZEYEj14VmRuZBkqFbiwReogJgS1zR1n') + + for await (const chunk of data) { + console.log(chunk) + } +} +``` + +It is also possible to instantiate detached client, which can be attach it to +the server later on. This is useful when server port is received via message +from other JS context (e.g. iframe) + +> Note: Client will queue all API calls and only execute them once it is +> attached (unless they timeout or are aborted in the meantime). + +```js +const IPFSClient = require('ipfs-message-port-client') + + +const ipfs = IPFSClient.detached() + +const main = async () => { + const data = ipfs.cat('/ipfs/QmdfTbBqBPQ7VNxZEYEj14VmRuZBkqFbiwReogJgS1zR1n') + + for await (const chunk of data) { + console.log(chunk) + } +} + +window.onload = main +window.onmessage = ({ports}) => { + IPFSClient.attach(ports[0]) +} +``` + +### Additional Options + +Since client works with IPFS node over [message channel][] all the data passed +is copied via [structured cloning algorithm][], which may lead to suboptimal +results (espacially with large binary data). In order to avoid unecessary +copying all API options have being extended with optional `transfer` property +that can be supplied [Transferable][]s which will be used to move corresponding +values instead of copying. + +> **Note:** Transferring data will empty it on the sender side which can lead to +> errors if that data is used again later. To avoid these errors transfer option +> was added so user can explicitily give up reference when it is safe to do so. + +```js +/** + * @param {Uint8Array} data - Large data chunk + */ +const example = async (data) => { + // Passing `data.buffer` will cause underlying `ArrayBuffer` to be + // transferred emptying `data` in JS context. + ipfs.add(data, { transfer: [data.buffer] }) +} +``` + +It is however recommended to prefer web native [Blob][] / [File][] intances as +most web APIs provide them as option & can be send across without copying +underyling memory. + +```js +const example = async (url) => { + const request = await fetch(url) + const blob = await request.blob() + ipfs.add(blob) +} +``` + +[message channel]:https://developer.mozilla.org/en-US/docs/Web/API/MessageChannel +[SharedWorker]:https://developer.mozilla.org/en-US/docs/Web/API/SharedWorker +[`MessagePort`]:https://developer.mozilla.org/en-US/docs/Web/API/MessagePort +[structured cloning algorithm]:https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Structured_clone_algorithm +[Transferable]:https://developer.mozilla.org/en-US/docs/Web/API/Transferable +[Blob]:https://developer.mozilla.org/en-US/docs/Web/API/Blob/Blob +[File]:https://developer.mozilla.org/en-US/docs/Web/API/File + + +## Contribute + +Contributions welcome. Please check out [the issues](https://github.com/ipfs/js-ipfs/issues). + +Check out our [contributing document](https://github.com/ipfs/community/blob/master/CONTRIBUTING_JS.md) for more information on how we work, and about contributing in general. Please be aware that all interactions related to this repo are subject to the IPFS [Code of Conduct](https://github.com/ipfs/community/blob/master/code-of-conduct.md). + +## License + +[![FOSSA Status](https://app.fossa.io/api/projects/git%2Bgithub.com%2Fipfs%2Fjs-ipfs.svg?type=large)](https://app.fossa.io/projects/git%2Bgithub.com%2Fipfs%2Fjs-ipfs?ref=badge_large) + diff --git a/packages/ipfs-message-port-protocol/README.md b/packages/ipfs-message-port-protocol/README.md new file mode 100644 index 0000000000..b32ddab51f --- /dev/null +++ b/packages/ipfs-message-port-protocol/README.md @@ -0,0 +1,208 @@ +# ipfs-message-port-protocol + +[![](https://img.shields.io/badge/made%20by-Protocol%20Labs-blue.svg?style=flat-square)](http://protocol.ai) +[![](https://img.shields.io/badge/project-IPFS-blue.svg?style=flat-square)](http://ipfs.io/) +[![](https://img.shields.io/badge/freenode-%23ipfs-blue.svg?style=flat-square)](http://webchat.freenode.net/?channels=%23ipfs) +[![Travis CI](https://flat.badgen.net/travis/ipfs/js-ipfs)](https://travis-ci.com/ipfs/js-ipfs) +[![Codecov branch](https://img.shields.io/codecov/c/github/ipfs/js-ipfs/master.svg?style=flat-square)](https://codecov.io/gh/ipfs/js-ipfs) +[![Dependency Status](https://david-dm.org/ipfs/js-ipfs/status.svg?path=packages/ipfs-message-port-protocol)](https://david-dm.org/ipfs/js-ipfs?path=packages/ipfs-message-port-protocol) +[![js-standard-style](https://img.shields.io/badge/code%20style-standard-brightgreen.svg?style=flat-square)](https://github.com/feross/standard) + +> This package serves as a repository code shared between the core `ipfs-message-port-client` and the `ipfs-message-port-server` + +## Lead Maintainer + +[Alex Potsides](https://github.com/achingbrain) + +## Table of Contentens + +- [Install](#install) +- [Contribute](#contribute) +- [License](#license) + +## Install + +```bash +$ npm install --save ipfs-message-port-protocol +``` + +## Usage + +## Wire protocol codecs + +Library provides encode / decode functions for types that are not supported by [structured cloning algorithm][] and therefore need to be encoded before posted over [message channel][] and decoded on the other end. + +All encoders take optional `transfer` array. If provided, encoder will add all `Transferable` fields of the given value so the they could be moved across threads without copying. + +### `CID` + +Codecs for [CID][] implementation in JavaScript. + +```js +const { CID, encodeCID, decodeCID } = require('ipfs-message-port-protocol/src/cid') + +const cid = new CID('bafybeig6xv5nwphfmvcnektpnojts33jqcuam7bmye2pb54adnrtccjlsu') + +const { port1, port2 } = new MessageChannel() + +// Will copy underyling memory +port1.postMessage(encodeCID(cid)) + +// Will transfer underlying memory (cid is corrupt on this thread) +const transfer = [] +port1.postMessage(encodeCID(cid, transfer), transfer) + +// On the receiver thread +port2.onmessage = ({data}) => { + const cid = decodeCID(data) + data instanceof CID // => true +} +``` + +### `Block` + +Codecs for [IPLD Block][] implementation in JavaScript. + +```js +const { Block, encodeBlock, decodeBlock } = require('ipfs-message-port-protocol/src/block') + +const data = Buffer.from('hello') +const cid = new CID('QmdfTbBqBPQ7VNxZEYEj14VmRuZBkqFbiwReogJgS1zR1n') +const block = new Block(data, cid) + +const { port1, port2 } = new MessageChannel() + +// Will copy underyling memory +port1.postMessage(encodeBlock(block)) + +// Will transfer underlying memory (block & cid will be corrupt on this thread) +const transfer = [] +port1.postMessage(encodeBlock(block, transfer), transfer) + + +// On the receiver thread +port2.onmessage = ({data}) => { + const block = decodeBlock(data) + block instanceof Block // true +} +``` + +### `DAGNode` + +Codec for DAGNodes accepted by `ipfs.dag.put` API. + +```js +const { encodeNode, decodeNode } = require('ipfs-message-port-protocol/src/dag') + + +const cid = CID('QmdfTbBqBPQ7VNxZEYEj14VmRuZBkqFbiwReogJgS1zR1n') +const dagNode = { hi: 'hello', link: cid } + +const { port1, port2 } = new MessageChannel() + +// Will copy underyling memory +port1.postMessage(encodeNode(dagNode)) + +// Will transfer underlying memory (`dagNode.link` will be corrupt on this thread) +const transfer = [] +port1.postMessage(encodeNode(dagNode, transfer), transfer) + + +// On the receiver thread +port2.onmessage = ({data}) => { + const dagNode = decodeNode(data) + dagNode.link instanceof CID // true +} +``` + +### `AsyncIterable` + +Encoder allows producer to encode [async iterables][] such that it can be transferred across threads and decoded by a consumer on the other end and take care of all the IO coordination between two. Unlike other encoders `transfer` argument is mandatory (because value is encoded to a [MessagePort][] that can only be transferred). Additionally encoder / decoder take item encoder / decoder functions to encode each item of the async iterable. + + +```js +const { encodeIterable, decodeIterable } = require('ipfs-message-port-protocol/src/core') + +const data = ipfs.cat('/ipfs/QmdfTbBqBPQ7VNxZEYEj14VmRuZBkqFbiwReogJgS1zR1n') + +const { port1, port2 } = new MessageChannel() + +// Will copy each chunk to the receiver thread +{ + const transfer = [] + port1.postMessage( + encodeIterable(content, chunk => chunk, transfer), + transfer + ) +} + + +// Will transfer each chunk to the reciever thread (corrupting it on this thread) +{ + const transfer = [] + port1.postMessage( + encodeIterable( + content, + (chunk, transfer) => { + transfer.push(chunk.buffer) + return chunk + }, + transfer + ), + transfer + ) +} + + +// On the receiver thread +port2.onmessage = async ({data}) => { + for await (const chunk of decodeIterable(data)) { + chunk instanceof Uint8Array + } +} +``` + +### Callback + +Primitive callbacks that take single parameter supported by [structured cloning algorithm][] like progress callback used across IPFS APIs can be encoded / decoded. Unilke most encoders `transfer` argument is required (because value is encoded to a [MessagePort][] that can only be transferred) + +```js +const { encodeCallback, decodeCallback } = require('ipfs-message-port-protocol/src/core') + +const { port1, port2 } = new MessageChannel() + +const progress = (value) => console.log(progress) + +const transfer = [] +port1.postMessage(encodeCallback(progress, transfer)) + + +// On the receiver thread +port2.onmessage = ({data}) => { + const progress = decodeCallback(data) + // Invokes `progress` on the other end + progress(20) +} +``` + + +[structured cloning algorithm]:https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Structured_clone_algorithm +[message channel]:https://developer.mozilla.org/en-US/docs/Web/API/MessageChannel +[MessagePort]:https://developer.mozilla.org/en-US/docs/Web/API/MessagePort +[Transferable]:https://developer.mozilla.org/en-US/docs/Web/API/Transferable + +[IPLD Block]:https://github.com/ipld/js-ipld-block +[CID]:https://github.com/multiformats/js-cid + +[async iterables]:https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for-await...of + +## Contribute + +Contributions welcome. Please check out [the issues](https://github.com/ipfs/js-ipfs/issues). + +Check out our [contributing document](https://github.com/ipfs/community/blob/master/CONTRIBUTING_JS.md) for more information on how we work, and about contributing in general. Please be aware that all interactions related to this repo are subject to the IPFS [Code of Conduct](https://github.com/ipfs/community/blob/master/code-of-conduct.md). + +## License + +[![FOSSA Status](https://app.fossa.io/api/projects/git%2Bgithub.com%2Fipfs%2Fjs-ipfs.svg?type=large)](https://app.fossa.io/projects/git%2Bgithub.com%2Fipfs%2Fjs-ipfs?ref=badge_large) + diff --git a/packages/ipfs-message-port-server/README.md b/packages/ipfs-message-port-server/README.md new file mode 100644 index 0000000000..1e52da1931 --- /dev/null +++ b/packages/ipfs-message-port-server/README.md @@ -0,0 +1,103 @@ +# ipfs-message-port-server + +[![](https://img.shields.io/badge/made%20by-Protocol%20Labs-blue.svg?style=flat-square)](http://protocol.ai) +[![](https://img.shields.io/badge/project-IPFS-blue.svg?style=flat-square)](http://ipfs.io/) +[![](https://img.shields.io/badge/freenode-%23ipfs-blue.svg?style=flat-square)](http://webchat.freenode.net/?channels=%23ipfs) +[![Travis CI](https://flat.badgen.net/travis/ipfs/js-ipfs)](https://travis-ci.com/ipfs/js-ipfs) +[![Codecov branch](https://img.shields.io/codecov/c/github/ipfs/js-ipfs/master.svg?style=flat-square)](https://codecov.io/gh/ipfs/js-ipfs) +[![Dependency Status](https://david-dm.org/ipfs/js-ipfs/status.svg?path=packages/ipfs-message-port-server)](https://david-dm.org/ipfs/js-ipfs?path=packages/ipfs-message-port-server) +[![js-standard-style](https://img.shields.io/badge/code%20style-standard-brightgreen.svg?style=flat-square)](https://github.com/feross/standard) + +> A library for providing IPFS node over [message channel][]. This library enables +applications running in the different JS context to use [IPFS API](https://github.com/ipfs/js-ipfs/tree/master/docs/api) (subset) via `ipfs-message-port-client`. + + +## Lead Maintainer + +[Alex Potsides](https://github.com/achingbrain) + +## Table of Contentens + +- [Install](#install) +- [Contribute](#contribute) +- [License](#license) + +## Install + +```bash +$ npm install --save ipfs-message-port-server +``` + +## Usage + +This library can wrap JS IPFS node and expose it over the [message channel][]. +It assumes `ipfs-message-port-client` on the other end, however it is not +strictly necessary anything compling with wire protocol will do. + +It provides following API subseset: + +- [`ipfs.dag`](https://github.com/ipfs/js-ipfs/blob/master/docs/core-api/DAG.md) +- [`ipfs.block`](https://github.com/ipfs/js-ipfs/blob/master/docs/core-api/BLOCK.md) +- [`ipfs.add`](https://github.com/ipfs/js-ipfs/blob/master/docs/core-api/FILES.md#ipfsadddata-options) +- [`ipfs.cat`](https://github.com/ipfs/js-ipfs/blob/master/docs/core-api/FILES.md#ipfscatipfspath-options) +- [`ipfs.files.stat`](https://github.com/ipfs/js-ipfs/blob/master/docs/core-api/FILES.md#ipfsfilesstatpath-options) + +Server is designed to run in the [SharedWorker][] (although it is possible to +run it in the other JS contexts). Example below illustrates running js-ipfs +node in [SharedWorkr][] and exposing it to all connected ports + +```js +const IPFS = require('ipfs') +const { IPFSService } = require('ipfs-message-port-server') +const { Server } = require('ipfs-message-port-server/src/server') + +const main = async () => { + const ports = [] + // queue connections that occur while node was starting. + self.onconnect = ({ports}) => connections.push(...ports) + + const ipfs = await IPFS.create() + const service = new IPFSService(ipfs) + const server = new Server(service) + + // connect new ports and queued ports with the server. + self.onconnect = ({ports}) => server.connect(ports[0]) + for (const port of ports.splice(0)) { + server.connect(port) + } +} + +main() +``` + + +### Additional Consideration + +Since the data over [message channel][] is copied via +[structured cloning algorithm][] it may lead to suboptimal +results (espacially with large binary data). In order to avoid unecessary +copying server will transfer all the [Transferable][] which will be emptied +on the server side. This should not be a problem in general as IPFS node itself +does not retain references to returned values, but is something to keep in mind +when doig something custom. + + +[message channel]:https://developer.mozilla.org/en-US/docs/Web/API/MessageChannel +[SharedWorker]:https://developer.mozilla.org/en-US/docs/Web/API/SharedWorker +[`MessagePort`]:https://developer.mozilla.org/en-US/docs/Web/API/MessagePort +[structured cloning algorithm]:https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Structured_clone_algorithm +[Transferable]:https://developer.mozilla.org/en-US/docs/Web/API/Transferable +[Blob]:https://developer.mozilla.org/en-US/docs/Web/API/Blob/Blob +[File]:https://developer.mozilla.org/en-US/docs/Web/API/File + + +## Contribute + +Contributions welcome. Please check out [the issues](https://github.com/ipfs/js-ipfs/issues). + +Check out our [contributing document](https://github.com/ipfs/community/blob/master/CONTRIBUTING_JS.md) for more information on how we work, and about contributing in general. Please be aware that all interactions related to this repo are subject to the IPFS [Code of Conduct](https://github.com/ipfs/community/blob/master/code-of-conduct.md). + +## License + +[![FOSSA Status](https://app.fossa.io/api/projects/git%2Bgithub.com%2Fipfs%2Fjs-ipfs.svg?type=large)](https://app.fossa.io/projects/git%2Bgithub.com%2Fipfs%2Fjs-ipfs?ref=badge_large) + From f7f8104985e5b0033587897777b7b729d36a9e0d Mon Sep 17 00:00:00 2001 From: Irakli Gozalishvili Date: Mon, 22 Jun 2020 22:21:01 -0700 Subject: [PATCH 29/63] chore: cleanup client code --- .../ipfs-message-port-client/src/block.js | 28 +-- .../ipfs-message-port-client/src/client.js | 169 ++++++++++++------ packages/ipfs-message-port-client/src/core.js | 76 +++++--- packages/ipfs-message-port-client/src/dag.js | 21 --- .../ipfs-message-port-client/src/errors.js | 6 - .../ipfs-message-port-client/src/files.js | 70 -------- 6 files changed, 184 insertions(+), 186 deletions(-) delete mode 100644 packages/ipfs-message-port-client/src/errors.js diff --git a/packages/ipfs-message-port-client/src/block.js b/packages/ipfs-message-port-client/src/block.js index 23b52bf9f7..744974eb39 100644 --- a/packages/ipfs-message-port-client/src/block.js +++ b/packages/ipfs-message-port-client/src/block.js @@ -36,14 +36,15 @@ class BlockClient extends Client { * @param {number} [options.timeout] - A timeout in ms * @param {AbortSignal} [options.signal] - Can be used to cancel any long * running requests started as a result of this call - * @param {Transferable[]} [options.tranfer] - References to transfer to the + * @param {Transferable[]} [options.transfer] - References to transfer to the * worker if passed. * @returns {Promise} */ async get (cid, options = {}) { + const { transfer } = options const { block } = await this.remote.get({ ...options, - cid: encodeCID(cid) + cid: encodeCID(cid, transfer) }) return decodeBlock(block) } @@ -65,17 +66,19 @@ class BlockClient extends Client { * @param {number} [options.timeout] - A timeout in ms * @param {AbortSignal} [options.signal] - Can be used to cancel any long * running requests started as a result of this call - * @param {Transferable[]} [options.tranfer] - References to transfer to the + * @param {Transferable[]} [options.transfer] - References to transfer to the * worker if passed. * @returns {Promise} */ async put (block, options = {}) { - // @ts-ignore - ipfs-unixfs-importer passes this causing errors + const { transfer } = options + // @ts-ignore - ipfs-unixfs-importer passes `progress` which causing errors + // because functions can't be transferred. delete options.progress const result = await this.remote.put({ ...options, - cid: options.cid == null ? undefined : encodeCID(options.cid), - block: block instanceof Uint8Array ? block : encodeBlock(block) + cid: options.cid == null ? undefined : encodeCID(options.cid, transfer), + block: block instanceof Uint8Array ? block : encodeBlock(block, transfer) }) return decodeBlock(result.block) } @@ -89,7 +92,7 @@ class BlockClient extends Client { * @param {number} [options.timeout] - A timeout in ms * @param {AbortSignal} [options.signal] - Can be used to cancel any long * running requests started as a result of this call - * @param {Transferable[]} [options.tranfer] - References to transfer to the + * @param {Transferable[]} [options.transfer] - References to transfer to the * worker if passed. * @returns {AsyncIterable} * @@ -98,11 +101,12 @@ class BlockClient extends Client { * @property {Error|void} [error] */ async * rm (cids, options = {}) { + const { transfer } = options const entries = await this.remote.rm({ ...options, cids: Array.isArray(cids) - ? cids.map(cid => encodeCID(cid)) - : [encodeCID(cids)] + ? cids.map(cid => encodeCID(cid, transfer)) + : [encodeCID(cids, transfer)] }) yield * entries.map(decodeRmEntry) @@ -115,7 +119,7 @@ class BlockClient extends Client { * @param {number} [options.timeout] - A timeout in ms * @param {AbortSignal} [options.signal] - Can be used to cancel any long * running requests started as a result of this call - * @param {Transferable[]} [options.tranfer] - References to transfer to the + * @param {Transferable[]} [options.transfer] - References to transfer to the * worker if passed. * @returns {Promise} * @@ -124,9 +128,10 @@ class BlockClient extends Client { * @property {number} size */ async stat (cid, options = {}) { + const { transfer } = options const result = await this.remote.stat({ ...options, - cid: encodeCID(cid) + cid: encodeCID(cid, transfer) }) return { ...result, cid: decodeCID(result.cid) } @@ -134,7 +139,6 @@ class BlockClient extends Client { } /** - * * @param {EncodedRmEntry} entry * @returns {RmEntry} */ diff --git a/packages/ipfs-message-port-client/src/client.js b/packages/ipfs-message-port-client/src/client.js index 69e3af14b5..d4847216e5 100644 --- a/packages/ipfs-message-port-client/src/client.js +++ b/packages/ipfs-message-port-client/src/client.js @@ -3,15 +3,6 @@ /* eslint-env browser */ const { decodeError } = require('ipfs-message-port-protocol/src/error') -class TimeoutError extends Error {} -exports.TimeoutError = TimeoutError - -class AbortError extends Error {} -exports.AbortError = AbortError - -class DisconnectError extends Error {} -exports.DisconnectError = DisconnectError - /** * @template T * @typedef {import('ipfs-message-port-protocol/src/rpc').Remote} Remote @@ -35,14 +26,17 @@ exports.DisconnectError = DisconnectError */ /** + * Represents server query, encapsulating inputs to the server endpoint and + * promise of it's result. + * * @template I,O * @class */ class Query { /** - * @param {string} namespace - * @param {string} method - * @param {QueryInput} input + * @param {string} namespace - component namespace on the server. + * @param {string} method - remote method this is a query of. + * @param {QueryInput} input - query input. */ constructor (namespace, method, input) { /** @type {Promise} */ @@ -58,6 +52,7 @@ class Query { } /** + * Data that will be structure cloned over message channel. * @returns {Object} */ toJSON () { @@ -65,6 +60,7 @@ class Query { } /** + * Data that will be transferred over message channel. * @returns {Transferable[]} */ transfer () { @@ -73,6 +69,17 @@ class Query { } /** @typedef {Transport} ClientTransport */ + +/** + * RPC Transport over `MessagePort` that can execute queries. It takes care of + * executing queries by issuing a message with unique ID and fullfilling a + * query when corresponding response message is received. It also makes sure + * that aborted / timed out queries are calcelled out as needed. + * + * It is expected that there will be at most one transport for a message port + * instance. + * @class + */ class Transport { /** * Create transport for the underlying message port. @@ -80,18 +87,31 @@ class Transport { */ constructor (port) { this.port = null - this.nextID = 0 + // Assigining a random enough identifier to the transport, to ensure that + // query.id will be unique when multiple tabs are communicating with a + // a server in the SharedWorker. this.id = Math.random() .toString(32) .slice(2) + + // Local unique id on the transport which is incremented for each query. + this.nextID = 0 + + // Dictionary of pending requests /** @type {Record>} */ this.queries = Object.create(null) + + // If port is provided connect this transport to it. If not transport can + // queue queries and execute those once it's connected. if (port) { this.connect(port) } } /** + * Executes given query with this transport and returns promise for it's + * result. Promise fails with an error if query fails. + * * @template I, O * @param {Query} query * @returns {Promise} @@ -100,6 +120,7 @@ class Transport { const id = `${this.id}@${this.nextID++}` this.queries[id] = query + // If query has a timeout is a timer. if (query.timeout > 0 && query.timeout < Infinity) { setTimeout(Transport.timeout, query.timeout, this, id) } @@ -110,6 +131,8 @@ class Transport { }) } + // If transport is connected (it has port) post a query, otherwise it + // will remain in the pending queries queue. if (this.port) { Transport.postQuery(this.port, id, query) } @@ -118,6 +141,54 @@ class Transport { } /** + * Connects this transport to the given message port. Throws `RangeError` if + * transport is already connected. All the pending queries will be executed + * as connection occurs. + * + * @param {MessagePort} port + */ + connect (port) { + if (this.port) { + throw new RangeError('Transport is already open') + } else { + this.port = port + this.port.addEventListener('message', this) + this.port.start() + + // Go ever pending queries (that were submitted before transport was + // connected) and post them. This loop is safe because messages will not + // arrive while this loop is running so no mutation can occur. + for (const [id, query] of Object.entries(this.queries)) { + Transport.postQuery(port, id, query) + } + } + } + + /** + * Disconnects this transport. This will cause all the pending queries + * to be aborted and undelying message port to be closed. + * + * Once disconnected transport can not be reconnected back. + */ + disconnect () { + const error = new DisconnectError() + for (const [id, query] of Object.entries(this.queries)) { + query.fail(error) + this.abort(id) + } + + // Note that reference to port is kept that ensures that attempt to + // reconnect will throw an error. + if (this.port) { + this.port.removeEventListener('message', this) + this.port.close() + } + } + + /** + * Invoked on query timeout. If query is still pending it will fail and + * abort message will be send to a the server. + * * @param {Transport} self * @param {string} id */ @@ -134,7 +205,8 @@ class Transport { } /** - * + * Aborts this query by failing with `AbortError` and sending an abort message + * to the server. If query is no longen pending this has no effect. * @param {string} id */ abort (id) { @@ -150,6 +222,7 @@ class Transport { } /** + * Sends a given `query` with a given `id` over the message channel. * @param {MessagePort} port * @param {string} id * @param {Query} query @@ -168,39 +241,16 @@ class Transport { } /** - * @param {MessagePort} port - */ - connect (port) { - if (this.port) { - throw new RangeError('Transport is already open') - } else { - this.port = port - this.port.addEventListener('message', this) - this.port.start() - for (const [id, query] of Object.entries(this.queries)) { - Transport.postQuery(port, id, query) - } - } - } - - disconnect () { - if (this.port) { - const error = new DisconnectError() - for (const [id, query] of Object.entries(this.queries)) { - query.fail(error) - this.abort(id) - } - this.port.removeEventListener('message', this) - this.port.close() - } - } - - /** + * Handler is invoked when message on the message port is received. * @param {MessageEvent} event */ handleEvent (event) { const { id, result } = event.data const query = this.queries[id] + // If query with a the given ID is found it is completed with the result, + // otherwise it is cancelled. + // Note: query may not be found when it was aborted on the client and at the + // same time server posted response. if (query) { delete this.queries[id] if (result.ok) { @@ -208,8 +258,6 @@ class Transport { } else { query.fail(decodeError(result.error)) } - } else { - // throw new RangeError(`Received response${id} for unknown query`) } } } @@ -226,31 +274,43 @@ exports.Transport = Transport */ /** + * Service represents an API to a remote service `T`. It will have all the + * methods with the same signatures as `T`. + * + * @class * @template T */ class Service { /** - * @param {string} namespace - * @param {ProcedureNames} methods - * @param {Transport} transport + * @param {string} namespace - Namespace that remote API is served under. + * @param {ProcedureNames} methods - Method names of the remote API. + * @param {Transport} transport - Transport to issue queries over. */ constructor (namespace, methods, transport) { this.transport = transport - /** @type {any} */ - const self = (this) + // Type script does not like using classes as some dicitionaries, so + // we explicitly type it as dictionary. + /** @type {Object., Function>} */ + const api = this for (const method of methods) { /** * @template I, O * @param {I} input * @returns {Promise} */ - self[method] = input => + api[method] = input => this.transport.execute(new Query(namespace, method.toString(), input)) } } } /** + * Client represents the client to remote `T` service. It is a base clase that + * specific API clients will subclass to provide a higher level API for end + * user. Client implementations take care of encoding arguments into quries + * and issing those to `remote` service. + * + * @class * @template T */ class Client { @@ -265,3 +325,12 @@ class Client { } } exports.Client = Client + +class TimeoutError extends Error {} +exports.TimeoutError = TimeoutError + +class AbortError extends Error {} +exports.AbortError = AbortError + +class DisconnectError extends Error {} +exports.DisconnectError = DisconnectError diff --git a/packages/ipfs-message-port-client/src/core.js b/packages/ipfs-message-port-client/src/core.js index 1480d26621..abc64c0c90 100644 --- a/packages/ipfs-message-port-client/src/core.js +++ b/packages/ipfs-message-port-client/src/core.js @@ -44,33 +44,9 @@ const { * @typedef {SingleFileInput | MultiFileInput} AddInput * */ -/** @type {(input:AddInput) => AsyncIterable} */ /** * @typedef {import("./files").Time} Time - * - * @typedef {Object} AddOptions - * @property {string} [chunker="size-262144"] - * @property {number} [cidVersion=0] - * @property {boolean} [enableShardingExperiment] - * @property {string} [hashAlg="sha2-256"] - * @property {boolean} [onlyHash=false] - * @property {boolean} [pin=true] - * @property {(added:number) => void} [progress] - * @property {boolean} [rawLeaves=false] - * @property {number} [shardSplitThreshold=1000] - * @property {boolean} [trickle=false] - * @property {boolean} [wrapWithDirectory=false] - * @property {number} [timeout] - * @property {Transferable[]} [transfer] - * @property {AbortSignal} [signal] - * - * @typedef {Object} AddedData - * @property {string} path - * @property {CID} cid - * @property {number} mode - * @property {number} size - * @property {Time} mtime */ /** @@ -92,9 +68,36 @@ class CoreClient extends Client { } /** + * Import files and data into IPFS. + * + * If you pass binary data like `Uint8Array` it is recommended to provide + * `transfer: [input.buffer]` which would allow transferring it instead of + * copying. + * * @param {AddInput} input - * @param {AddOptions} [options] + * @param {Object} [options] + * @param {string} [options.chunker="size-262144"] + * @param {number} [options.cidVersion=0] + * @param {boolean} [options.enableShardingExperiment] + * @param {string} [options.hashAlg="sha2-256"] + * @param {boolean} [options.onlyHash=false] + * @param {boolean} [options.pin=true] + * @param {function(number):void} [options.progress] + * @param {boolean} [options.rawLeaves=false] + * @param {number} [options.shardSplitThreshold=1000] + * @param {boolean} [options.trickle=false] + * @param {boolean} [options.wrapWithDirectory=false] + * @param {number} [options.timeout] + * @param {Transferable[]} [options.transfer] + * @param {AbortSignal} [options.signal] * @returns {AsyncIterable} + * + * @typedef {Object} AddedData + * @property {string} path + * @property {CID} cid + * @property {number} mode + * @property {number} size + * @property {Time} mtime */ async * add (input, options = {}) { const { timeout, signal } = options @@ -115,6 +118,7 @@ class CoreClient extends Client { } /** + * Returns content addressed by a valid IPFS Path. * @param {string|CID} inputPath * @param {Object} [options] * @param {number} [options.offset] @@ -131,7 +135,7 @@ class CoreClient extends Client { } /** - * + * Decodes values yield by `ipfs.add`. * @param {AddedEntry} data * @returns {AddedData} */ @@ -153,12 +157,15 @@ const decodeAddedData = ({ path, cid, mode, mtime, size }) => { const identity = v => v /** + * Encodes input passed to the `ipfs.add` via the best possible strategy for the + * given input. + * * @param {AddInput} input * @param {Transferable[]} transfer * @returns {EncodedAddInput} */ const encodeAddInput = (input, transfer) => { - // We want to get a Blob as input + // We want to get a Blob as input. If we got it we're set. if (input instanceof Blob) { return input } else if (typeof input === 'string') { @@ -166,8 +173,12 @@ const encodeAddInput = (input, transfer) => { } else if (input instanceof ArrayBuffer) { return input } else if (ArrayBuffer.isView(input)) { + // Note we are not adding `input.buffer` into transfer list, it's on user. return input } else { + // If input is (async) iterable or `ReadableStream` or "FileObject" it will + // be encoded via own specific encoder. + const iterable = asIterable(input) if (iterable) { return encodeIterable(iterable, encodeIterableContent, transfer) @@ -197,6 +208,8 @@ const encodeAddInput = (input, transfer) => { } /** + * Function encodes individual item of some `AsyncIterable` by choosing most + * effective strategy. * @param {ArrayBuffer|ArrayBufferView|Blob|string|FileObject} content * @param {Transferable[]} transfer * @returns {FileInput|ArrayBuffer|ArrayBufferView} @@ -318,6 +331,8 @@ const iterateReadableStream = async function * (stream) { } /** + * Pattern matches given input as `Iterable` and returns back either matched + * iterable or `null`. * @template I * @param {Iterable|AddInput} input * @returns {Iterable|null} @@ -333,6 +348,8 @@ const asIterable = input => { } /** + * Pattern matches given `input` as `AsyncIterable` and returns back either + * matched `AsyncIterable` or `null`. * @template I * @param {AsyncIterable|AddInput} input * @returns {AsyncIterable|null} @@ -348,6 +365,9 @@ const asAsyncIterable = input => { } /** + * Pattern matches given `input` as `ReadableStream` and return back either + * matched input or `null`. + * * @param {any} input * @returns {ReadableStream|null} */ @@ -360,6 +380,8 @@ const asReadableStream = input => { } /** + * Pattern matches given input as "FileObject" and returns back eithr matched + * input or `null`. * @param {*} input * @returns {FileObject|null} */ diff --git a/packages/ipfs-message-port-client/src/dag.js b/packages/ipfs-message-port-client/src/dag.js index e06d8c058b..acad30214c 100644 --- a/packages/ipfs-message-port-client/src/dag.js +++ b/packages/ipfs-message-port-client/src/dag.js @@ -13,27 +13,6 @@ const { encodeNode, decodeNode } = require('ipfs-message-port-protocol/src/dag') * @typedef {import('./client').ClientTransport} Transport */ -/** - * @typedef {PutWithFormat|PutWithCID} PutOptions - * - * @typedef {Object} PutWithFormat - * An optional object which may be passed to `ipfs.dag.put`. - * @property {string} [format="dag-cbor"] - The IPLD format multicodec - * @property {string} [hashAlg="sha2-256"] - The hash algorithm to be used over the serialized DAG node - * @property {boolean} [pin=false] - Pin this node when adding to the blockstore - * @property {boolean} [preload=true] - * @property {number} [timeout] - A timeout in ms - * @property {void} [cid] - * @property {AbortSignal} [signal] - Can be used to cancel any long running requests started as a result of this call. - * - * @typedef {Object} PutWithCID - * @property {CID} cid - The IPLD format multicodec - * @property {boolean} [pin=false] - Pin this node when adding to the blockstore - * @property {boolean} [preload=true] - * @property {number} [timeout] - A timeout in ms - * @property {AbortSignal} [signal] - Can be used to cancel any long running requests started as a result of this call. - */ - /** * @class * @extends {Client} diff --git a/packages/ipfs-message-port-client/src/errors.js b/packages/ipfs-message-port-client/src/errors.js deleted file mode 100644 index e28a8feeb4..0000000000 --- a/packages/ipfs-message-port-client/src/errors.js +++ /dev/null @@ -1,6 +0,0 @@ -'use strict' - -class AbortError extends Error {} -class ClosedError extends Error {} - -module.exports = { AbortError, ClosedError } diff --git a/packages/ipfs-message-port-client/src/files.js b/packages/ipfs-message-port-client/src/files.js index 16e3b41a0a..ee9fd109f8 100644 --- a/packages/ipfs-message-port-client/src/files.js +++ b/packages/ipfs-message-port-client/src/files.js @@ -126,67 +126,6 @@ class FilesClient extends Client { yield * decodeIterable(entries, decodeLsEntry) } - // /** - // * Copy files. - // * @param {ContentAddress} from - // * @param {string} to - // * @param {Object} [options] - // * @param {boolean} [options.parents=false] - // * @param {string} [options.hashAlg] - // * @param {boolean} [options.flush=true] - // * @param {number} [options.timeout] - // * @param {AbortSignal} [options.signal] - // * @returns {Promise} - // */ - // // @ts-ignore - // cp (from, to, options, ...etc) { - // const args = [from, to, options, ...etc] - // const last = args.pop() - // const [sources, destination, opts] = - // typeof last === 'string' ? [args, last, {}] : [args, args.pop(), last] - - // const { parents, hashAlg, flush } = opts - // return this.remote.cp( - // { - // // @ts-ignore could be called without any arguments. - // from: sources.map(toPath), - // to: destination, - // parents, - // hashAlg, - // flush - // }, - // options - // ) - // } - // /** - // * Make a directory. - // * @param {string} path The path to the directory to make - // * @param {Object} [options] - // * @param {boolean} [options.parents=false] - // * @param {string} [options.hashAlg] - // * @param {boolean} [options.flush=true] - // * @param {Mode} [options.mode] - // * @param {Time|Date} [options.mtime] - // * @param {number} [options.timeout] - // * @param {AbortSignal} [options.signal] - // * @returns {Promise} - // */ - // mkdir (path, options = {}) { - // const { mtime, parents, flush, hashAlg, mode } = options - - // return this.remote.mkdir( - // { - // path: toPath(path), - // mtime, - // parents, - // flush, - // hashAlg, - // mode - // }, - // options - // ) - // } - /** * @typedef {Object} Stat * @property {CID} cid Content identifier. @@ -256,15 +195,6 @@ const encodeContent = (content, transfer) => { /** * * @typedef {string|CID} ContentAddress - * - * - * @typedef {Object} LsEntry - * @property {string} name - * @property {FileType} type - * @property {number} size - * @property {CID} cid - * @property {number} mode - * @property {UnixFSTime} mtime */ /** From 5285cf2d791ff0765954cd268040a1e58461d19c Mon Sep 17 00:00:00 2001 From: Irakli Gozalishvili Date: Mon, 22 Jun 2020 22:55:06 -0700 Subject: [PATCH 30/63] chore: cleanup server & protocol code --- packages/ipfs-message-port-client/src/core.js | 13 +- packages/ipfs-message-port-client/src/dag.js | 4 +- .../ipfs-message-port-client/src/files.js | 162 +----------- .../ipfs-message-port-protocol/src/files.ts | 149 ----------- .../ipfs-message-port-protocol/src/rpc.ts | 8 - packages/ipfs-message-port-server/src/core.js | 4 +- packages/ipfs-message-port-server/src/dag.js | 4 +- .../ipfs-message-port-server/src/files.js | 232 +----------------- .../ipfs-message-port-server/src/index.js | 12 +- .../ipfs-message-port-server/src/server.js | 19 +- 10 files changed, 37 insertions(+), 570 deletions(-) delete mode 100644 packages/ipfs-message-port-protocol/src/files.ts diff --git a/packages/ipfs-message-port-client/src/core.js b/packages/ipfs-message-port-client/src/core.js index abc64c0c90..aea66fbcb0 100644 --- a/packages/ipfs-message-port-client/src/core.js +++ b/packages/ipfs-message-port-client/src/core.js @@ -16,6 +16,8 @@ const { * @typedef {import('ipfs-message-port-protocol/src/core').RemoteIterable} RemoteIterable */ /** + * @typedef {import('ipfs-message-port-protocol/src/data').Time} Time + * @typedef {import('ipfs-message-port-protocol/src/data').UnixFSTime} UnixFSTime * @typedef {import('ipfs-message-port-protocol/src/dag').EncodedCID} EncodedCID * @typedef {import('ipfs-message-port-server/src/core').AddInput} EncodedAddInput * @typedef {import('ipfs-message-port-server/src/core').FileInput} FileInput @@ -33,9 +35,8 @@ const { * @property {string} [path] * @property {FileContent} [content] * @property {string|number} [mode] - * @property {UnixTime} [mtime] + * @property {UnixFSTime} [mtime] * - * @typedef {Date|Time|[number, number]} UnixTime * * @typedef {Blob|Bytes|string|FileObject|Iterable|Iterable|AsyncIterable|ReadableStream} SingleFileInput * @@ -46,18 +47,14 @@ const { */ /** - * @typedef {import("./files").Time} Time - */ - -/** - * @typedef {import('ipfs-message-port-server/src/core').Core} API + * @typedef {import('ipfs-message-port-server/src/core').CoreService} CoreService * @typedef {import('ipfs-message-port-server/src/core').AddedEntry} AddedEntry * @typedef {import('./client').ClientTransport} Transport */ /** * @class - * @extends {Client} + * @extends {Client} */ class CoreClient extends Client { /** diff --git a/packages/ipfs-message-port-client/src/dag.js b/packages/ipfs-message-port-client/src/dag.js index acad30214c..432296ecc6 100644 --- a/packages/ipfs-message-port-client/src/dag.js +++ b/packages/ipfs-message-port-client/src/dag.js @@ -9,13 +9,13 @@ const { encodeNode, decodeNode } = require('ipfs-message-port-protocol/src/dag') * @typedef {import('ipfs-message-port-server/src/dag').DAGNode} DAGNode * @typedef {import('ipfs-message-port-server/src/dag').EncodedDAGNode} EncodedDAGNode * @typedef {import('ipfs-message-port-server/src/dag').DAGEntry} DAGEntry - * @typedef {import('ipfs-message-port-server/src/dag').DAG} API + * @typedef {import('ipfs-message-port-server/src/dag').DAGService} DagService * @typedef {import('./client').ClientTransport} Transport */ /** * @class - * @extends {Client} + * @extends {Client} */ class DAGClient extends Client { /** diff --git a/packages/ipfs-message-port-client/src/files.js b/packages/ipfs-message-port-client/src/files.js index ee9fd109f8..9053ff322d 100644 --- a/packages/ipfs-message-port-client/src/files.js +++ b/packages/ipfs-message-port-client/src/files.js @@ -4,126 +4,24 @@ const CID = require('cids') const { Client } = require('./client') -const { - decodeIterable, - encodeIterable -} = require('ipfs-message-port-protocol/src/core') const { decodeCID } = require('ipfs-message-port-protocol/src/cid') /** - * @typedef {import('ipfs-message-port-server/src/files').Files} API - * @typedef {import('ipfs-message-port-server/src/files').EncodedContent} EncodedContent - * @typedef {import('ipfs-message-port-server/src/files').Entry} EncodedEntry + * @typedef {import('ipfs-message-port-server/src/files').FilesService} FilesService * @typedef {import('ipfs-message-port-server/src/files').EncodedStat} EncodedStat - * @typedef {import('ipfs-message-port-protocol/src/data').UnixFSTime} UnixFSTime - * @typedef {import('ipfs-message-port-protocol/src/data').FileType} FileType - * @typedef {import('ipfs-message-port-protocol/src/data').Time} Time - * @typedef {import('ipfs-message-port-protocol/src/data').Mode} Mode - * @typedef {import('ipfs-message-port-protocol/src/data').HashAlg} HashAlg - * @typedef {import('ipfs-message-port-protocol/src/data').CIDVersion} CIDVersion * @typedef {import('./client').ClientTransport} Transport */ /** * @class - * @extends {Client} + * @extends {Client} */ class FilesClient extends Client { /** * @param {Transport} transport */ constructor (transport) { - super('files', ['chmod', 'stat'], transport) - } - - /** - * Change mode for files and directories - * @param {ContentAddress} path - The path to the entry to modify - * @param {Mode} mode - * @param {Object} [options] - * @param {boolean} [options.recursive=false] - * @param {string} [options.hashAlg] - * @param {boolean} [options.flush=true] - * @param {number} [options.cidVersion=0] - * @param {number} [options.timeout] - * @param {AbortSignal} [options.signal] - * @returns {Promise} - */ - chmod (path, mode, options = {}) { - const { recursive, hashAlg, flush, cidVersion, signal, timeout } = options - return this.remote.chmod({ - path: toPath(path), - mode, - recursive, - hashAlg, - flush, - cidVersion, - signal, - timeout - }) - } - - /** - * Write to an MFS path - * @typedef {string|ArrayBufferView|ArrayBuffer|AsyncIterable|Blob} WriteContent - * - * @param {string} path - The path of the file to write to. - * @param {WriteContent} content - The content to write to the path - * @param {Object} [options] - * @param {number} [options.offset] - An offset to start writing to file at. - * @param {number} [options.length] - Amount ofbytes to write from the content. - * @param {boolean} [options.create=false] - Create the MFS path if it does not exist - * @param {boolean} [options.parents=false] - Create intermediate MFS paths if they do not exist - * @param {boolean} [options.truncate=false] - Truncate the file at the MFS path if it would have been larger than the passed content. - * @param {boolean} [options.rawLeaves=false] - If true, DAG leaves will contain raw file data and not be wrapped in a protobuf - * @param {number} [options.mode] - An integer that represents the file mode - * @param {Time} [options.mtime] - Modififaction time of the file. - * @param {boolean} [options.flush=true] - If true the changes will be immediately flushed to disk - * @param {HashAlg} [options.hashAlg='sha2-256'] -The hash algorithm to use for any updated entries - * @param {CIDVersion} [options.cidVersion] - The CID version to use for any updated entries - * @param {number} [options.timeout] - A timeout in ms - * @param {AbortSignal} [options.signal] - Can be used to cancel any long running requests started as a result of this call - * @param {Transferable[]} [options.transfer] - Provide transferables for transfer - * @returns {Promise<{cid: CID, size:number}>} - */ - async write (path, content, options = {}) { - const transfer = [...options.transfer] - const result = await this.remote.write({ - ...options, - path, - content: encodeContent(content, transfer), - transfer - }) - - return { ...result, cid: decodeCID(result.cid) } - } - - /** - * @typedef {Object} Entry - * @property {string} name - * @property {FileType} type - * @property {number} size - * @property {CID} cid - * @property {number} mode - * @property {UnixFSTime} mtime - * - * @param {string} [path='/'] - * @param {Object} [options] - * @param {boolean} [options.sort=false] - * @param {number} [options.timeout] - * @param {AbortSignal} [options.signal] - * @returns {AsyncIterable} - */ - async * ls (path = '/', options = {}) { - const { sort, timeout, signal } = options - const { entries } = await this.remote.ls({ - path, - sort, - timeout, - signal - }) - - yield * decodeIterable(entries, decodeLsEntry) + super('files', ['stat'], transport) } /** @@ -138,7 +36,7 @@ class FilesClient extends Client { * @property {boolean} local True if the queried dag is fully present locally * @property {number} sizeLocal Cumulative size of the data present locally * - * @param {ContentAddress} path + * @param {string|CID} pathOrCID * @param {Object} [options] * @param {boolean} [options.hash=false] If true will only return hash * @param {boolean} [options.size=false] If true will only return size @@ -147,10 +45,10 @@ class FilesClient extends Client { * @param {AbortSignal} [options.signal] * @returns {Promise} */ - async stat (path, options = {}) { + async stat (pathOrCID, options = {}) { const { size, hash, withLocal, timeout, signal } = options const { stat } = await this.remote.stat({ - path: toPath(path), + path: encodeLocation(pathOrCID), size, hash, withLocal, @@ -162,48 +60,13 @@ class FilesClient extends Client { } module.exports = FilesClient -/** - * @param {EncodedEntry} entry - * @returns {Entry} - */ -const decodeLsEntry = entry => { - return { - ...entry, - cid: decodeCID(entry.cid) - } -} - -/** - * @param {WriteContent} content - The content to write to the path - * @param {Transferable[]} transfer - * @returns {EncodedContent} - */ -const encodeContent = (content, transfer) => { - if (typeof content === 'string') { - return content - } else if (ArrayBuffer.isView(content)) { - return content - } else if (content instanceof ArrayBuffer) { - return content - } else if (content instanceof Blob) { - return content - } else { - return encodeIterable(content, identity, transfer) - } -} - -/** - * - * @typedef {string|CID} ContentAddress - */ - /** * Turns content address (path or CID) into path. - * @param {ContentAddress} address + * @param {string|CID} pathOrCID * @returns {string} */ -const toPath = address => - CID.isCID(address) ? `/ipfs/${address.toString()}` : address.toString() +const encodeLocation = pathOrCID => + CID.isCID(pathOrCID) ? `/ipfs/${pathOrCID.toString()}` : pathOrCID /** * @@ -213,10 +76,3 @@ const toPath = address => const decodeStat = data => { return { ...data, cid: decodeCID(data.cid) } } - -/** - * @template T - * @param {T} a - * @returns {T} - */ -const identity = a => a diff --git a/packages/ipfs-message-port-protocol/src/files.ts b/packages/ipfs-message-port-protocol/src/files.ts deleted file mode 100644 index f7ff427e2e..0000000000 --- a/packages/ipfs-message-port-protocol/src/files.ts +++ /dev/null @@ -1,149 +0,0 @@ -import { StringEncoded, Time, Mode, HashAlg, FileType } from './data' -import { RemoteIterable } from './core' -import CID from 'cids' - -interface Files { - chmod(input: ChmodQuery): Promise - cp(input: CpQuery): Promise - mkdir(input: MkdirQuery): Promise - stat(input: StatQuery): Promise - touch(input: TouchQuery): Promise - rm(input: RmQuery): Promise - read(input: ReadQuery): Promise - write(input: WriteQuery): Promise - mv(input: MvQuery): Promise - flush(input: FlushQuery): Promise> - ls(input: LsQuery): Promise -} - -type ChmodQuery = { - path: string - mode: Mode - recursive?: boolean - hashAlg?: HashAlg - flush?: boolean - cidVersion?: number -} - -type CpQuery = { - from: string | StringEncoded - to: string | StringEncoded - parents?: boolean - hashAlg?: HashAlg - flush?: boolean -} - -type MkdirQuery = { - path: string - // Note: Date objects seem to get copied over message port preserving - // Date type. - mtime?: Time - parents?: boolean - flush?: boolean - hashAlg?: HashAlg - mode?: Mode -} - -type StatQuery = { - path: string - size?: boolean - hash?: HashAlg - withLocal?: boolean -} - -type Stat = { - type: FileType - cid: StringEncoded - size: number - cumulativeSize: number - blocks: number - withLocality: boolean - local: boolean - sizeLocal: number -} - -type TouchQuery = { - path: string - mtime?: Time - flush?: boolean - hashAlg?: HashAlg - cidVersion?: number -} - -type RmQuery = { - paths: string[] - recursive?: boolean - flush?: boolean - hashAlg?: HashAlg - cidVersion?: number -} - -type ReadQuery = { - path: string - - offset?: number - length?: number -} - -type ReadOutput = { - content: RemoteIterable -} - -type WriteContent = - | string - | ArrayBufferView - | ArrayBuffer - | Blob - | RemoteIterable - -type WriteQuery = { - path: string - content: WriteContent - offset?: number - length?: number - create?: boolean - parents?: boolean - truncate?: boolean - rawLeaves?: boolean - mode?: Mode - mtime?: Time - flush?: boolean - hashAlg?: HashAlg - cidVersion?: number -} - -type WriteOutput = { - cid: StringEncoded - size: number -} - -type MvQuery = { - from: string | string[] - to: string - - parents: boolean - flush: boolean - hashAlg: HashAlg - cidVersion: number -} - -type FlushQuery = { - path: string -} - -type LsQuery = { - path: string -} - -type Entry = { - name: string - type: FileType - size: number - cid: StringEncoded - mode: Mode - mtime: Time -} - -type LsOutput = { - entries: RemoteIterable -} diff --git a/packages/ipfs-message-port-protocol/src/rpc.ts b/packages/ipfs-message-port-protocol/src/rpc.ts index 2d4c058ecb..5ccaf775d1 100644 --- a/packages/ipfs-message-port-protocol/src/rpc.ts +++ b/packages/ipfs-message-port-protocol/src/rpc.ts @@ -20,14 +20,6 @@ export type TransferOptions = { transfer?: Transferable[] } -// export type ServiceProvider = { -// [K in keyof T]: ProcedureProvider -// } - -// export type ProcedureProvider = T extends (arg: infer I) => infer O -// ? (input: I & CallOptions) => O -// : never - export type NonUndefined = A extends undefined ? never : A export type ProcedureNames = { diff --git a/packages/ipfs-message-port-server/src/core.js b/packages/ipfs-message-port-server/src/core.js index 75110e41aa..c3fd949677 100644 --- a/packages/ipfs-message-port-server/src/core.js +++ b/packages/ipfs-message-port-server/src/core.js @@ -106,7 +106,7 @@ const { decodeCID, encodeCID } = require('ipfs-message-port-protocol/src/cid') /** * @class */ -class Core { +class CoreService { /** * * @param {IPFS} ipfs @@ -297,4 +297,4 @@ const encodeFileOutput = (file, _transfer) => ({ */ const identity = v => v -exports.Core = Core +exports.CoreService = CoreService diff --git a/packages/ipfs-message-port-server/src/dag.js b/packages/ipfs-message-port-server/src/dag.js index 55e754c43a..59b54a7fb4 100644 --- a/packages/ipfs-message-port-server/src/dag.js +++ b/packages/ipfs-message-port-server/src/dag.js @@ -19,7 +19,7 @@ const { decodeNode, encodeNode } = require('ipfs-message-port-protocol/src/dag') /** * @class */ -class DAG { +class DAGService { /** * @param {IPFS} ipfs */ @@ -111,4 +111,4 @@ class DAG { * @returns {DAGNode} */ -exports.DAG = DAG +exports.DAGService = DAGService diff --git a/packages/ipfs-message-port-server/src/files.js b/packages/ipfs-message-port-server/src/files.js index 46137f842c..e88a724d2a 100644 --- a/packages/ipfs-message-port-server/src/files.js +++ b/packages/ipfs-message-port-server/src/files.js @@ -2,28 +2,14 @@ /* eslint-env browser */ -const CID = require('cids') -const { - encodeIterable, - decodeIterable -} = require('ipfs-message-port-protocol/src/core') const { encodeCID } = require('ipfs-message-port-protocol/src/cid') /** * @typedef {import('ipfs-message-port-protocol/src/dag').EncodedCID} EncodedCID */ -/** - * @template T - * @typedef {import('ipfs-message-port-protocol/src/core').RemoteIterable} RemoteIterable - */ /** * @typedef {import('ipfs-message-port-protocol/src/data').HashAlg} HashAlg * @typedef {import('ipfs-message-port-protocol/src/data').Mode} Mode - * @typedef {import('ipfs-message-port-protocol/src/data').Time} Time - * @typedef {import('ipfs-message-port-protocol/src/data').UnixFSTime} UnixFSTime - * @typedef {import('ipfs-message-port-protocol/src/data').FileType} FileType - * @typedef {import('ipfs-message-port-protocol/src/data').CIDVersion} CIDVersion - * @typedef {import('./ipfs').IPFS} IPFS * @typedef {Stat} EncodedStat */ @@ -31,7 +17,7 @@ const { encodeCID } = require('ipfs-message-port-protocol/src/cid') /** * @class */ -class Files { +class FilesService { /** * * @param {IPFS} ipfs @@ -40,17 +26,6 @@ class Files { this.ipfs = ipfs } - /** - * @param {ChmodQuery} query - * @returns {Promise} - */ - async chmod (query) { - const cid = await new CID(query.path) - throw new Error(cid.toString()) - } - - // cp(input: CpQuery): Promise - // mkdir(input: MkdirQuery): Promise /** * @typedef {Object} StatQuery * @property {string} path @@ -83,208 +58,5 @@ class Files { const transfer = [] return { stat: { ...stat, cid: encodeCID(stat.cid, transfer) }, transfer } } - - // touch(input: TouchQuery): Promise - // rm(input: RmQuery): Promise - // read(input: ReadQuery): Promise - /** - * @param {WriteQuery} query - * @returns {Promise} - */ - async write (query) { - const { path, content } = query - const result = await this.ipfs.files.write( - path, - decodeContent(content), - query - ) - return { ...result, cid: encodeCID(result.cid) } - } - // mv(input: MvQuery): Promise - // flush(input: FlushQuery): Promise> - - /** - * @typedef {Object} LsQuery - * @property {string} path - * @property {boolean} [sort] - * @property {number} [timeout] - * @property {AbortSignal} [signal] - * - * @typedef {Object} LsResult - * @property {RemoteIterable} entries - * @property {Transferable[]} transfer - * - * @param {LsQuery} query - * @returns {LsResult} - */ - ls (query) { - const { sort, timeout, signal } = query - /** @type {Transferable[]} */ - const transfer = [] - const entries = this.ipfs.files.ls(query.path, { - sort, - timeout, - signal - }) - return { - entries: encodeIterable(entries, identity, transfer), - transfer - } - } } -exports.Files = Files - -/** - * @typedef {Object} Entry - * @property {string} name - * @property {FileType} type - * @property {number} size - * @property {EncodedCID} cid - * @property {number} mode - * @property {UnixFSTime} mtime - */ - -/** - * @param {EncodedContent} content - * @returns {DecodedContent} - */ -const decodeContent = content => { - if (typeof content === 'string') { - return content - } else if (ArrayBuffer.isView(content)) { - return content - } else if (content instanceof ArrayBuffer) { - return content - } else if (content instanceof Blob) { - return content - } else { - return decodeIterable(content, identity) - } -} - -/** - * @typedef {Object} ChmodQuery - * @prop {string} path - * @prop {Mode} mode - * @prop {boolean} [recursive] - * @prop {HashAlg} [hashAlg] - * @prop {boolean} [flush] - * @prop {number} [cidVersion] - */ - -// type CpQuery = { -// from: string | StringEncoded -// to: string | StringEncoded -// parents?: boolean -// hashAlg?: HashAlg -// flush?: boolean -// } - -// type MkdirQuery = { -// path: string -// // Note: Date objects seem to get copied over message port preserving -// // Date type. -// mtime?: Time -// parents?: boolean -// flush?: boolean -// hashAlg?: HashAlg -// mode?: Mode -// } - -// type StatQuery = { -// path: string -// size?: boolean -// hash?: HashAlg -// withLocal?: boolean -// } - -// type Stat = { -// type: FileType -// cid: StringEncoded -// size: number -// cumulativeSize: number -// blocks: number -// withLocality: boolean -// local: boolean -// sizeLocal: number -// } - -// type TouchQuery = { -// path: string -// mtime?: Time -// flush?: boolean -// hashAlg?: HashAlg -// cidVersion?: number -// } - -// type RmQuery = { -// paths: string[] -// recursive?: boolean -// flush?: boolean -// hashAlg?: HashAlg -// cidVersion?: number -// } - -// type ReadQuery = { -// path: string - -// offset?: number -// length?: number -// } - -// type ReadOutput = { -// content: RemoteIterable -// } - -// type WriteContent = -// | string -// | ArrayBufferView -// | ArrayBuffer -// | Blob -// | RemoteIterable - -/** - * @typedef {string|ArrayBufferView|ArrayBuffer|Blob|RemoteIterable} EncodedContent - * @typedef {string|ArrayBuffer|ArrayBufferView|Blob|AsyncIterable} DecodedContent - * @typedef {Object} WriteQuery - * @property {string} path - * @property {EncodedContent} content - * @property {number} [offset] - * @property {number} [length] - * @property {boolean} [create] - * @property {boolean} [parents] - * @property {boolean} [options] - * @property {boolean} [rawLeaves] - * @property {number} [mode] - * @property {Time} [mtime] - * @property {boolean} [flush] - * @property {HashAlg} [hashAlg] - * @property {CIDVersion} [cidVersion] - * @property {number} [timeout] - * @property {AbortSignal} [signal] - * - * @typedef {Object} WriteResult - * @property {EncodedCID} cid - * @property {number} size - */ - -// type MvQuery = { -// from: string | string[] -// to: string - -// parents: boolean -// flush: boolean -// hashAlg: HashAlg -// cidVersion: number -// } - -// type FlushQuery = { -// path: string -// } - -/** - * @template T - * @param {T} a - * @returns {T} - */ -const identity = a => a +exports.FilesService = FilesService diff --git a/packages/ipfs-message-port-server/src/index.js b/packages/ipfs-message-port-server/src/index.js index f5ee518aae..c4820acfce 100644 --- a/packages/ipfs-message-port-server/src/index.js +++ b/packages/ipfs-message-port-server/src/index.js @@ -2,9 +2,9 @@ /* eslint-env browser */ -const { DAG } = require('./dag') -const { Core } = require('./core') -const { Files } = require('./files') +const { DAGService } = require('./dag') +const { CoreService } = require('./core') +const { FilesService } = require('./files') const { BlockService } = require('./block') /** @@ -17,9 +17,9 @@ class IPFSService { * @param {IPFS} ipfs */ constructor (ipfs) { - this.dag = new DAG(ipfs) - this.core = new Core(ipfs) - this.files = new Files(ipfs) + this.dag = new DAGService(ipfs) + this.core = new CoreService(ipfs) + this.files = new FilesService(ipfs) this.block = new BlockService(ipfs) } } diff --git a/packages/ipfs-message-port-server/src/server.js b/packages/ipfs-message-port-server/src/server.js index f8173997f7..583b47f26c 100644 --- a/packages/ipfs-message-port-server/src/server.js +++ b/packages/ipfs-message-port-server/src/server.js @@ -5,7 +5,6 @@ const { encodeError } = require('ipfs-message-port-protocol/src/error') /** - * @typedef {import('./ipfs').IPFS} IPFS * @typedef {import('ipfs-message-port-protocol/src/data').EncodedError} EncodedError */ @@ -95,7 +94,9 @@ const { encodeError } = require('ipfs-message-port-protocol/src/error') * @template T, K * @typedef {import('ipfs-message-port-protocol/src/rpc').NamespacedQuery} NamespacedQuery */ + /** + * Represents a client query received on the server. * @template T * @extends {ServiceQuery} */ @@ -119,14 +120,8 @@ class Query { } /** - * @template T - * @param {RPCQuery} value - * @returns {Query} + * Aborts this query if it is still pending. */ - static from (value) { - return new Query(value.namespace, value.method, value.input) - } - abort () { this.abortController.abort() this.fail(new AbortError()) @@ -134,6 +129,7 @@ class Query { } /** + * Server wraps `T` service and executes queries received from connected ports. * @template T */ @@ -164,6 +160,7 @@ class Server { } /** + * Handles messages received from connected clients * @param {MessageEvent} event * @returns {void} */ @@ -190,6 +187,7 @@ class Server { } /** + * Abort query for the given id. * @param {string} id */ abort (id) { @@ -201,6 +199,7 @@ class Server { } /** + * Handles query received from the client. * @param {string} id * @param {Query} query * @param {MessagePort} port @@ -241,7 +240,7 @@ class Server { if (typeof procedure === 'function') { try { const { signal } = query - // @ts-ignore + // @ts-ignore - TS doesn't know qury.input is an object const input = { ...query.input, signal } Promise.resolve(procedure.call(service, input)).then( query.succeed, @@ -263,7 +262,7 @@ class Server { * @returns {Out} */ execute (data) { - const query = Query.from(data) + const query = new Query(data.namespace, data.method, data.input) this.run(query) return query.result From 5bfb1d402a0240e11415f2d106ef3fd237e20e69 Mon Sep 17 00:00:00 2001 From: Irakli Gozalishvili Date: Tue, 23 Jun 2020 00:32:44 -0700 Subject: [PATCH 31/63] chore: remove redundunt code --- .../ipfs-message-port-client/src/block.js | 4 +- .../ipfs-message-port-protocol/src/rpc.ts | 68 +++++-------------- .../ipfs-message-port-server/src/server.js | 32 +++------ 3 files changed, 30 insertions(+), 74 deletions(-) diff --git a/packages/ipfs-message-port-client/src/block.js b/packages/ipfs-message-port-client/src/block.js index 744974eb39..ef8fba8636 100644 --- a/packages/ipfs-message-port-client/src/block.js +++ b/packages/ipfs-message-port-client/src/block.js @@ -13,13 +13,13 @@ const { * @typedef {import('ipfs-message-port-server/src/block').Block} Block * @typedef {import('ipfs-message-port-server/src/block').EncodedBlock} EncodedBlock * @typedef {import('ipfs-message-port-server/src/block').Rm} EncodedRmEntry - * @typedef {import('ipfs-message-port-server/src/block').BlockService} API + * @typedef {import('ipfs-message-port-server/src/block').BlockService} BlockService * @typedef {import('./client').ClientTransport} Transport */ /** * @class - * @extends {Client} + * @extends {Client} */ class BlockClient extends Client { /** diff --git a/packages/ipfs-message-port-protocol/src/rpc.ts b/packages/ipfs-message-port-protocol/src/rpc.ts index 5ccaf775d1..1b9dd836de 100644 --- a/packages/ipfs-message-port-protocol/src/rpc.ts +++ b/packages/ipfs-message-port-protocol/src/rpc.ts @@ -26,33 +26,7 @@ export type ProcedureNames = { [K in keyof T]-?: NonUndefined extends Function ? K : never }[keyof T][] -export type Input = Values< - { - [K in keyof T]: T[K] extends (input: infer I) => infer _O - ? I & { method: K } & QueryOptions - : never - } -> -export type Output = Values< - { - [K in keyof T]: T[K] extends (input: infer _I) => infer O - ? Return - : never - } -> - -export type Service = { - [K in keyof T]: T[K] -} - -export type ProcedureProvider = T extends (arg: infer I) => infer O - ? (input: I & QueryOptions) => O - : never - -export type AsProcedure = T extends (arg: infer I) => infer O - ? (query: I & QueryOptions) => Return - : never /** * Any method name of the associated with RPC service. @@ -75,40 +49,21 @@ export type RPCQuery = Pick< 'method' | 'namespace' | 'input' | 'timeout' | 'signal' > -export type ProcedureName = Values< - { - [K in keyof T]-?: NonUndefined extends (input: any) => any ? K : never - } -> export type ServiceQuery = Values< { - [K in keyof T]: T[K] extends (input: infer I) => infer O - ? Query - : NamespacedQuery + [NS in keyof T]: NamespacedQuery } > -export type Query = Values< - { - [K in keyof T]-?: T[K] extends (input: infer I) => infer O - ? { - namespace?: void - method: K - input: I - result: R - } & QueryOptions - : never - } -> -export type NamespacedQuery = Values< +export type NamespacedQuery = Values< { - [K in keyof T]-?: T[K] extends (input: infer I) => infer O + [M in keyof S]-?: S[M] extends (input: infer I) => infer O ? { namespace: NS - method: K - input: I + method: M + input: I & QueryOptions result: R } & QueryOptions : never @@ -120,3 +75,16 @@ type R = O extends Promise : Promise> type WithTransferOptions = O extends object ? O & TransferOptions : O + + +export type MultiService = { + [NS in keyof T]: NamespacedService +} + +type NamespacedService = { + [M in keyof S]: NamespacedMethod +} + +export type NamespacedMethod = T extends (arg: infer I) => infer O + ? (query: I & QueryOptions) => Return + : never diff --git a/packages/ipfs-message-port-server/src/server.js b/packages/ipfs-message-port-server/src/server.js index 583b47f26c..cd0ac49e03 100644 --- a/packages/ipfs-message-port-server/src/server.js +++ b/packages/ipfs-message-port-server/src/server.js @@ -13,11 +13,6 @@ const { encodeError } = require('ipfs-message-port-protocol/src/error') * @typedef {import('ipfs-message-port-protocol/src/data').Result} Result */ -/** - * @template T - * @typedef {import('ipfs-message-port-protocol/src/rpc').Input} Input - */ - /** * @template T * @typedef {import('ipfs-message-port-protocol/src/rpc').ProcedureNames} ProcedureNames @@ -85,11 +80,6 @@ const { encodeError } = require('ipfs-message-port-protocol/src/error') * @typedef {AbortMessage|QueryMessage} Message */ -/** - * @template T - * @typedef {import('ipfs-message-port-protocol/src/rpc').Service} Service - */ - /** * @template T, K * @typedef {import('ipfs-message-port-protocol/src/rpc').NamespacedQuery} NamespacedQuery @@ -128,6 +118,11 @@ class Query { } } +/** + * @template T + * @typedef {import('ipfs-message-port-protocol/src/rpc').MultiService} MultiService + */ + /** * Server wraps `T` service and executes queries received from connected ports. * @template T @@ -135,7 +130,7 @@ class Query { class Server { /** - * @param {Service} services + * @param {MultiService} services */ constructor (services) { this.services = services @@ -233,19 +228,12 @@ class Server { const { services } = this const { namespace, method } = query - // @ts-ignore - seems to fail to infer - const service = namespace == null ? services : services[namespace] + const service = services[namespace] if (service) { - const procedure = service[method] - if (typeof procedure === 'function') { + if (typeof service[method] === 'function') { try { - const { signal } = query - // @ts-ignore - TS doesn't know qury.input is an object - const input = { ...query.input, signal } - Promise.resolve(procedure.call(service, input)).then( - query.succeed, - query.fail - ) + const result = service[method]({ ...query.input, signal: query.signal }) + Promise.resolve(result).then(query.succeed, query.fail) } catch (error) { query.fail(error) } From 81269c7019a322e1f00c0bd9487b3bc4d1c31b2f Mon Sep 17 00:00:00 2001 From: Irakli Gozalishvili Date: Tue, 23 Jun 2020 01:43:09 -0700 Subject: [PATCH 32/63] fix: add name to custom error types --- .../ipfs-message-port-client/src/client.js | 18 +++++++++++++++--- .../ipfs-message-port-server/src/server.js | 10 +++++++++- 2 files changed, 24 insertions(+), 4 deletions(-) diff --git a/packages/ipfs-message-port-client/src/client.js b/packages/ipfs-message-port-client/src/client.js index d4847216e5..70b46ddb50 100644 --- a/packages/ipfs-message-port-client/src/client.js +++ b/packages/ipfs-message-port-client/src/client.js @@ -326,11 +326,23 @@ class Client { } exports.Client = Client -class TimeoutError extends Error {} +class TimeoutError extends Error { + get name () { + return this.constructor.name + } +} exports.TimeoutError = TimeoutError -class AbortError extends Error {} +class AbortError extends Error { + get name () { + return this.constructor.name + } +} exports.AbortError = AbortError -class DisconnectError extends Error {} +class DisconnectError extends Error { + get name () { + return this.constructor.name + } +} exports.DisconnectError = DisconnectError diff --git a/packages/ipfs-message-port-server/src/server.js b/packages/ipfs-message-port-server/src/server.js index cd0ac49e03..294abbd7c3 100644 --- a/packages/ipfs-message-port-server/src/server.js +++ b/packages/ipfs-message-port-server/src/server.js @@ -265,9 +265,17 @@ class UnsupportedMessageError extends RangeError { super('Unexpected message was received by the server') this.event = event } + + get name () { + return this.constructor.name + } } -class AbortError extends Error {} +class AbortError extends Error { + get name () { + return this.constructor.name + } +} exports.Query = Query exports.Server = Server From d08ab3d2956ae999ce572e611ab58d9fb0295ee9 Mon Sep 17 00:00:00 2001 From: Irakli Gozalishvili Date: Tue, 23 Jun 2020 11:03:30 -0700 Subject: [PATCH 33/63] fix: error names normalization across threads --- .../ipfs-message-port-protocol/src/error.js | 20 ++----------------- 1 file changed, 2 insertions(+), 18 deletions(-) diff --git a/packages/ipfs-message-port-protocol/src/error.js b/packages/ipfs-message-port-protocol/src/error.js index 2c1e2d33ee..3e299db827 100644 --- a/packages/ipfs-message-port-protocol/src/error.js +++ b/packages/ipfs-message-port-protocol/src/error.js @@ -2,18 +2,6 @@ /* eslint-env browser */ -// Chrome implements structure clonning of native error types, -// Firefox does not https://bugzilla.mozilla.org/show_bug.cgi?id=1556604 -// This does a runtime check to detect if cloning is supported. -const isErrorCloningSupported = (() => { - try { - new MessageChannel().port1.postMessage(new Error()) - return true - } catch (error) { - return false - } -})() - /** * @typedef {Error|ErrorData} EncodedError * @@ -39,12 +27,8 @@ const isErrorCloningSupported = (() => { * @returns {EncodedError} */ const encodeError = error => { - if (isErrorCloningSupported) { - return error - } else { - const { name, message, stack, code, detail } = error - return { name, message, stack, code, detail } - } + const { name, message, stack, code, detail } = error + return { name, message, stack, code, detail } } exports.encodeError = encodeError From 98db58b294d94dac6d6bb81586c25198e817292e Mon Sep 17 00:00:00 2001 From: Irakli Gozalishvili Date: Tue, 23 Jun 2020 13:23:49 -0700 Subject: [PATCH 34/63] fix: regression introduced by c487207 --- packages/ipfs-message-port-client/src/dag.js | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/packages/ipfs-message-port-client/src/dag.js b/packages/ipfs-message-port-client/src/dag.js index 432296ecc6..9b3af8f9ab 100644 --- a/packages/ipfs-message-port-client/src/dag.js +++ b/packages/ipfs-message-port-client/src/dag.js @@ -59,7 +59,7 @@ class DAGClient extends Client { * @returns {Promise} */ async get (cid, path, options = {}) { - const [nodePath, { localResolve, timeout, signal }] = read(path, options) + const [nodePath, { localResolve, timeout, signal }] = read(path, options, '/') const { value, remainderPath } = await this.remote.get({ cid: encodeCID(cid), @@ -83,7 +83,7 @@ class DAGClient extends Client { * @returns {AsyncIterable} */ async * tree (cid, path, options = {}) { - const [nodePath, { recursive, timeout, signal }] = read(path, options) + const [nodePath, { recursive, timeout, signal }] = read(path, options, '') const paths = await this.remote.tree({ cid: encodeCID(cid), @@ -111,13 +111,14 @@ class DAGClient extends Client { * param {[Maybe, T]|[NonNullable, T]} params * @param {Maybe|NonNullable} path * @param {T} options + * @param {string} defaultPath * @returns {[string, T]} */ -const read = (path, options) => { +const read = (path, options, defaultPath) => { if (typeof path === 'string') { return [path, options] } else { - return ['', path == null ? options : path] + return [defaultPath, path == null ? options : path] } } From dc5f10db700d77090b625e1b00cefa26fc2350fe Mon Sep 17 00:00:00 2001 From: Irakli Gozalishvili Date: Mon, 6 Jul 2020 10:37:58 -0700 Subject: [PATCH 35/63] fix: link to the core APIs Co-authored-by: Marcin Rataj --- packages/ipfs-message-port-client/README.md | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/packages/ipfs-message-port-client/README.md b/packages/ipfs-message-port-client/README.md index c75da4a79b..31abe9da04 100644 --- a/packages/ipfs-message-port-client/README.md +++ b/packages/ipfs-message-port-client/README.md @@ -8,7 +8,7 @@ [![Dependency Status](https://david-dm.org/ipfs/js-ipfs/status.svg?path=packages/ipfs-message-port-client)](https://david-dm.org/ipfs/js-ipfs?path=packages/ipfs-message-port-client) [![js-standard-style](https://img.shields.io/badge/code%20style-standard-brightgreen.svg?style=flat-square)](https://github.com/feross/standard) -> A client library for the IPFS API over [message channel][]. This client library provides (subset) of [IPFS API](https://github.com/ipfs/js-ipfs/tree/master/docs/api) enabling applications to work with js-ipfs running in the different JS e.g. [SharedWorker][]. +> A client library for the IPFS API over [message channel][]. This client library provides (subset) of [IPFS API](https://github.com/ipfs/js-ipfs/tree/master/docs/core-api) enabling applications to work with js-ipfs running in the different JS e.g. [SharedWorker][]. ## Lead Maintainer @@ -138,4 +138,3 @@ Check out our [contributing document](https://github.com/ipfs/community/blob/mas ## License [![FOSSA Status](https://app.fossa.io/api/projects/git%2Bgithub.com%2Fipfs%2Fjs-ipfs.svg?type=large)](https://app.fossa.io/projects/git%2Bgithub.com%2Fipfs%2Fjs-ipfs?ref=badge_large) - From cbb3e5bc80aa65218c4e0733c3fd09b051a0ecec Mon Sep 17 00:00:00 2001 From: Irakli Gozalishvili Date: Mon, 6 Jul 2020 10:38:28 -0700 Subject: [PATCH 36/63] fix: typo Co-authored-by: Marcin Rataj --- packages/ipfs-message-port-server/README.md | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/packages/ipfs-message-port-server/README.md b/packages/ipfs-message-port-server/README.md index 1e52da1931..a83fbc26b2 100644 --- a/packages/ipfs-message-port-server/README.md +++ b/packages/ipfs-message-port-server/README.md @@ -44,7 +44,7 @@ It provides following API subseset: Server is designed to run in the [SharedWorker][] (although it is possible to run it in the other JS contexts). Example below illustrates running js-ipfs -node in [SharedWorkr][] and exposing it to all connected ports +node in [SharedWorker][] and exposing it to all connected ports ```js const IPFS = require('ipfs') @@ -100,4 +100,3 @@ Check out our [contributing document](https://github.com/ipfs/community/blob/mas ## License [![FOSSA Status](https://app.fossa.io/api/projects/git%2Bgithub.com%2Fipfs%2Fjs-ipfs.svg?type=large)](https://app.fossa.io/projects/git%2Bgithub.com%2Fipfs%2Fjs-ipfs?ref=badge_large) - From 574d30a70234ce160f426c547cc3778a198c5202 Mon Sep 17 00:00:00 2001 From: Irakli Gozalishvili Date: Mon, 6 Jul 2020 10:38:42 -0700 Subject: [PATCH 37/63] fix: typo Co-authored-by: Marcin Rataj --- packages/ipfs-message-port-client/README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/ipfs-message-port-client/README.md b/packages/ipfs-message-port-client/README.md index 31abe9da04..b55f018c99 100644 --- a/packages/ipfs-message-port-client/README.md +++ b/packages/ipfs-message-port-client/README.md @@ -31,7 +31,7 @@ $ npm install --save ipfs-message-port-client This client library works with IPFS node over the [message channel][] and assumes that IPFS node is provided via `ipfs-message-port-server` on the other end. -It provides following API subseset: +It provides following API subset: - [`ipfs.dag`](https://github.com/ipfs/js-ipfs/blob/master/docs/core-api/DAG.md) - [`ipfs.block`](https://github.com/ipfs/js-ipfs/blob/master/docs/core-api/BLOCK.md) From 7b2c7f23e3e8d7babf4fa3ee4eb5b64c52ba65d7 Mon Sep 17 00:00:00 2001 From: Irakli Gozalishvili Date: Mon, 6 Jul 2020 10:39:11 -0700 Subject: [PATCH 38/63] fix: link to core API docs Co-authored-by: Marcin Rataj --- packages/ipfs-message-port-server/README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/ipfs-message-port-server/README.md b/packages/ipfs-message-port-server/README.md index a83fbc26b2..e254a66c1c 100644 --- a/packages/ipfs-message-port-server/README.md +++ b/packages/ipfs-message-port-server/README.md @@ -9,7 +9,7 @@ [![js-standard-style](https://img.shields.io/badge/code%20style-standard-brightgreen.svg?style=flat-square)](https://github.com/feross/standard) > A library for providing IPFS node over [message channel][]. This library enables -applications running in the different JS context to use [IPFS API](https://github.com/ipfs/js-ipfs/tree/master/docs/api) (subset) via `ipfs-message-port-client`. +applications running in the different JS context to use [IPFS API](https://github.com/ipfs/js-ipfs/tree/master/docs/core-api) (subset) via `ipfs-message-port-client`. ## Lead Maintainer From 54de1be95351cc78f95910170573c5a8903af5ba Mon Sep 17 00:00:00 2001 From: Irakli Gozalishvili Date: Tue, 14 Jul 2020 15:48:08 -0700 Subject: [PATCH 39/63] chore: update dependencies from forks to releases --- packages/interface-ipfs-core/package.json | 2 +- packages/ipfs-http-client/package.json | 2 +- packages/ipfs-message-port-client/package.json | 2 +- packages/ipfs/package.json | 4 ++-- 4 files changed, 5 insertions(+), 5 deletions(-) diff --git a/packages/interface-ipfs-core/package.json b/packages/interface-ipfs-core/package.json index 47dcad6b9b..cc03d8acd7 100644 --- a/packages/interface-ipfs-core/package.json +++ b/packages/interface-ipfs-core/package.json @@ -39,7 +39,7 @@ "ipfs-utils": "^2.2.2", "ipld-block": "^0.9.2", "ipld-dag-cbor": "^0.15.3", - "ipld-dag-pb": "git://github.com/gozala/js-ipld-dag-pb.git#pure-data-model", + "ipld-dag-pb": "^0.19.0", "is-ipfs": "^1.0.3", "iso-random-stream": "^1.1.1", "it-all": "^1.0.1", diff --git a/packages/ipfs-http-client/package.json b/packages/ipfs-http-client/package.json index fe179a7d37..ae84d2a4de 100644 --- a/packages/ipfs-http-client/package.json +++ b/packages/ipfs-http-client/package.json @@ -45,7 +45,7 @@ "ipfs-utils": "^2.2.2", "ipld-block": "^0.9.2", "ipld-dag-cbor": "^0.15.3", - "ipld-dag-pb": "git://github.com/gozala/js-ipld-dag-pb.git#pure-data-model", + "ipld-dag-pb": "^0.19.0", "ipld-raw": "^5.0.0", "iso-url": "^0.4.7", "it-tar": "^1.2.2", diff --git a/packages/ipfs-message-port-client/package.json b/packages/ipfs-message-port-client/package.json index 8b7ff188d1..c2540a6daf 100644 --- a/packages/ipfs-message-port-client/package.json +++ b/packages/ipfs-message-port-client/package.json @@ -32,7 +32,7 @@ "devDependencies": { "ipfs-message-port-protocol": "~0.0.1", "ipfs-message-port-server": "~0.0.1", - "ipld-dag-pb": "git://github.com/gozala/js-ipld-dag-pb.git#pure-data-model", + "ipld-dag-pb": "^0.19.0", "ipfs": "^0.46.0", "it-all": "^1.0.1", "it-drain": "^1.0.1", diff --git a/packages/ipfs/package.json b/packages/ipfs/package.json index d86de9054f..c585f99386 100644 --- a/packages/ipfs/package.json +++ b/packages/ipfs/package.json @@ -100,7 +100,7 @@ "ipld-bitcoin": "^0.3.0", "ipld-block": "^0.9.2", "ipld-dag-cbor": "^0.15.3", - "ipld-dag-pb": "git://github.com/gozala/js-ipld-dag-pb.git#pure-data-model", + "ipld-dag-pb": "^0.19.0", "ipld-ethereum": "^4.0.0", "ipld-git": "^0.5.0", "ipld-raw": "^5.0.0", @@ -153,7 +153,7 @@ "peer-id": "^0.13.12", "pretty-bytes": "^5.3.0", "progress": "^2.0.1", - "protons": "git://github.com/gozala/protons#uint8array", + "protons": "^1.2.1", "semver": "^7.3.2", "stream-to-it": "^0.2.0", "streaming-iterables": "^4.1.1", From 6e795b40a39524852c7a34b7bb22584a3ff2cfdb Mon Sep 17 00:00:00 2001 From: Irakli Gozalishvili Date: Tue, 14 Jul 2020 16:34:20 -0700 Subject: [PATCH 40/63] fix: typo in the readme --- packages/ipfs-message-port-server/README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/packages/ipfs-message-port-server/README.md b/packages/ipfs-message-port-server/README.md index 1e52da1931..7299c6bfd7 100644 --- a/packages/ipfs-message-port-server/README.md +++ b/packages/ipfs-message-port-server/README.md @@ -52,7 +52,7 @@ const { IPFSService } = require('ipfs-message-port-server') const { Server } = require('ipfs-message-port-server/src/server') const main = async () => { - const ports = [] + const connections = [] // queue connections that occur while node was starting. self.onconnect = ({ports}) => connections.push(...ports) @@ -62,7 +62,7 @@ const main = async () => { // connect new ports and queued ports with the server. self.onconnect = ({ports}) => server.connect(ports[0]) - for (const port of ports.splice(0)) { + for (const port of connections.splice(0)) { server.connect(port) } } From 57ac87495725c9938f8bc28c9ce6a3f4294954c8 Mon Sep 17 00:00:00 2001 From: Irakli Gozalishvili Date: Tue, 14 Jul 2020 16:58:26 -0700 Subject: [PATCH 41/63] fix: address review comments --- packages/ipfs-message-port-client/README.md | 14 ++++++++++---- packages/ipfs-message-port-protocol/README.md | 12 +++++++++--- packages/ipfs-message-port-server/README.md | 6 ++++-- 3 files changed, 23 insertions(+), 9 deletions(-) diff --git a/packages/ipfs-message-port-client/README.md b/packages/ipfs-message-port-client/README.md index c75da4a79b..8366a61d3d 100644 --- a/packages/ipfs-message-port-client/README.md +++ b/packages/ipfs-message-port-client/README.md @@ -18,6 +18,8 @@ ## Table of Contentens - [Install](#install) +- [Usage](#usage) +- [Notes on Performance](#notes-on-performance) - [Contribute](#contribute) - [License](#license) @@ -31,7 +33,7 @@ $ npm install --save ipfs-message-port-client This client library works with IPFS node over the [message channel][] and assumes that IPFS node is provided via `ipfs-message-port-server` on the other end. -It provides following API subseset: +It provides following API subset: - [`ipfs.dag`](https://github.com/ipfs/js-ipfs/blob/master/docs/core-api/DAG.md) - [`ipfs.block`](https://github.com/ipfs/js-ipfs/blob/master/docs/core-api/BLOCK.md) @@ -39,12 +41,16 @@ It provides following API subseset: - [`ipfs.cat`](https://github.com/ipfs/js-ipfs/blob/master/docs/core-api/FILES.md#ipfscatipfspath-options) - [`ipfs.files.stat`](https://github.com/ipfs/js-ipfs/blob/master/docs/core-api/FILES.md#ipfsfilesstatpath-options) -Client can be instantiated from the [`MessagePort`][] instance +Client can be instantiated from the [`MessagePort`][] instance. Primary goal of +this library is to allow sharing a node across browsing contexts (tabs, iframes) +and therefore most likely `ipfs-message-port-server` will be in the separate JS +bundle and loaded in the [SharedWorker][]. ```js const IPFSClient = require('ipfs-message-port-client') - +// URL to the script containing ipfs-message-port-server. +const IPFS_SERVER_URL = '/bundle/ipfs-worker.js' const main = async () => { const worker = new SharedWorker(IPFS_SERVER_URL) @@ -84,7 +90,7 @@ window.onmessage = ({ports}) => { } ``` -### Additional Options +### Notes on Performance Since client works with IPFS node over [message channel][] all the data passed is copied via [structured cloning algorithm][], which may lead to suboptimal diff --git a/packages/ipfs-message-port-protocol/README.md b/packages/ipfs-message-port-protocol/README.md index b32ddab51f..f136be378c 100644 --- a/packages/ipfs-message-port-protocol/README.md +++ b/packages/ipfs-message-port-protocol/README.md @@ -17,6 +17,12 @@ ## Table of Contentens - [Install](#install) +- [Usage](#usage) + - [Wire protocol codecs](#wire-protocol-codecs) + - [Block](#block) + - [DAGNode](#dagnode) + - [AsyncIterable](#asynciterable) + - [Callback][#callback] - [Contribute](#contribute) - [License](#license) @@ -59,7 +65,7 @@ port2.onmessage = ({data}) => { } ``` -### `Block` +### Block Codecs for [IPLD Block][] implementation in JavaScript. @@ -87,7 +93,7 @@ port2.onmessage = ({data}) => { } ``` -### `DAGNode` +### DAGNode Codec for DAGNodes accepted by `ipfs.dag.put` API. @@ -115,7 +121,7 @@ port2.onmessage = ({data}) => { } ``` -### `AsyncIterable` +### AsyncIterable Encoder allows producer to encode [async iterables][] such that it can be transferred across threads and decoded by a consumer on the other end and take care of all the IO coordination between two. Unlike other encoders `transfer` argument is mandatory (because value is encoded to a [MessagePort][] that can only be transferred). Additionally encoder / decoder take item encoder / decoder functions to encode each item of the async iterable. diff --git a/packages/ipfs-message-port-server/README.md b/packages/ipfs-message-port-server/README.md index 7299c6bfd7..9442e4e213 100644 --- a/packages/ipfs-message-port-server/README.md +++ b/packages/ipfs-message-port-server/README.md @@ -19,6 +19,8 @@ applications running in the different JS context to use [IPFS API](https://githu ## Table of Contentens - [Install](#install) +- [Usage](#usage) +- [Notes on Performance](#notes-on-performance) - [Contribute](#contribute) - [License](#license) @@ -34,7 +36,7 @@ This library can wrap JS IPFS node and expose it over the [message channel][]. It assumes `ipfs-message-port-client` on the other end, however it is not strictly necessary anything compling with wire protocol will do. -It provides following API subseset: +It provides following API subset: - [`ipfs.dag`](https://github.com/ipfs/js-ipfs/blob/master/docs/core-api/DAG.md) - [`ipfs.block`](https://github.com/ipfs/js-ipfs/blob/master/docs/core-api/BLOCK.md) @@ -71,7 +73,7 @@ main() ``` -### Additional Consideration +### Notes on Performance Since the data over [message channel][] is copied via [structured cloning algorithm][] it may lead to suboptimal From 1e3acde6e3d74e4b0313d11c24fab91a0a882309 Mon Sep 17 00:00:00 2001 From: Irakli Gozalishvili Date: Tue, 14 Jul 2020 17:10:31 -0700 Subject: [PATCH 42/63] chore: revert temporary changes to code base --- packages/interface-ipfs-core/package.json | 9 +++++++-- packages/ipfs-http-client/package.json | 9 +++++++-- packages/ipfs-http-client/test/interface.spec.js | 15 ++++----------- packages/ipfs/package.json | 9 +++++++-- packages/ipfs/test/core/interface.spec.js | 9 +-------- packages/ipfs/test/gateway/index.js | 4 +--- packages/ipfs/test/http-api/interface.js | 10 +--------- 7 files changed, 28 insertions(+), 37 deletions(-) diff --git a/packages/interface-ipfs-core/package.json b/packages/interface-ipfs-core/package.json index 0b50434f97..3d1d36bb91 100644 --- a/packages/interface-ipfs-core/package.json +++ b/packages/interface-ipfs-core/package.json @@ -18,12 +18,17 @@ "test": "exit 0", "dep-check": "aegir dep-check" }, - "files": ["src/", "test/"], + "files": [ + "src/", + "test/" + ], "repository": { "type": "git", "url": "git+https://github.com/ipfs/js-ipfs.git" }, - "keywords": ["IPFS"], + "keywords": [ + "IPFS" + ], "license": "MIT", "dependencies": { "abort-controller": "^3.0.0", diff --git a/packages/ipfs-http-client/package.json b/packages/ipfs-http-client/package.json index b589052782..c2845f500a 100644 --- a/packages/ipfs-http-client/package.json +++ b/packages/ipfs-http-client/package.json @@ -2,12 +2,17 @@ "name": "ipfs-http-client", "version": "44.3.0", "description": "A client library for the IPFS HTTP API", - "keywords": ["ipfs"], + "keywords": [ + "ipfs" + ], "homepage": "https://github.com/ipfs/js-ipfs/tree/master/packages/ipfs-http-client#readme", "bugs": "https://github.com/ipfs/js-ipfs/issues", "license": "(Apache-2.0 OR MIT)", "leadMaintainer": "Alex Potsides ", - "files": ["src", "dist"], + "files": [ + "src", + "dist" + ], "main": "src/index.js", "browser": { "./src/lib/to-stream.js": "./src/lib/to-stream.browser.js", diff --git a/packages/ipfs-http-client/test/interface.spec.js b/packages/ipfs-http-client/test/interface.spec.js index 2a68bee598..9e367c160d 100644 --- a/packages/ipfs-http-client/test/interface.spec.js +++ b/packages/ipfs-http-client/test/interface.spec.js @@ -54,17 +54,10 @@ describe('interface-ipfs-core tests', () => { tests.bitswap(commonFactory) tests.block(commonFactory, { - skip: [ - { - name: 'should get a block added as CIDv1 with a CIDv0', - reason: 'go-ipfs does not support the `version` param' - }, - { - name: 'should return an error for an invalid CID', - reason: - 'Intermittent failure: https://github.com/ipfs/js-ipfs/issues/3100' - } - ] + skip: [{ + name: 'should get a block added as CIDv1 with a CIDv0', + reason: 'go-ipfs does not support the `version` param' + }] }) tests.bootstrap(commonFactory) diff --git a/packages/ipfs/package.json b/packages/ipfs/package.json index cbc1c0d204..23825c5d50 100644 --- a/packages/ipfs/package.json +++ b/packages/ipfs/package.json @@ -2,12 +2,17 @@ "name": "ipfs", "version": "0.47.0", "description": "JavaScript implementation of the IPFS specification", - "keywords": ["IPFS"], + "keywords": [ + "IPFS" + ], "homepage": "https://github.com/ipfs/js-ipfs/tree/master/packages/ipfs#readme", "bugs": "https://github.com/ipfs/js-ipfs/issues", "license": "(Apache-2.0 OR MIT)", "leadMaintainer": "Alex Potsides ", - "files": ["src", "dist"], + "files": [ + "src", + "dist" + ], "main": "src/core/index.js", "browser": { "./src/core/runtime/init-assets-nodejs.js": "./src/core/runtime/init-assets-browser.js", diff --git a/packages/ipfs/test/core/interface.spec.js b/packages/ipfs/test/core/interface.spec.js index 2166d26d9d..8f3778e15a 100644 --- a/packages/ipfs/test/core/interface.spec.js +++ b/packages/ipfs/test/core/interface.spec.js @@ -19,14 +19,7 @@ describe('interface-ipfs-core tests', function () { tests.bitswap(commonFactory) - tests.block(commonFactory, { - skip: [ - { - name: 'should return an error for an invalid CID', - reason: 'Intermittent failure: https://github.com/ipfs/js-ipfs/issues/3100' - } - ] - }) + tests.block(commonFactory) tests.bootstrap(commonFactory) diff --git a/packages/ipfs/test/gateway/index.js b/packages/ipfs/test/gateway/index.js index 23eb0226d9..892b2d207d 100644 --- a/packages/ipfs/test/gateway/index.js +++ b/packages/ipfs/test/gateway/index.js @@ -106,9 +106,7 @@ describe('HTTP Gateway', function () { expect(res.headers.suborigin).to.equal(undefined) }) - // Produces intermittent failures - // https://github.com/ipfs/js-ipfs/issues/3101 - it.skip('returns 400 for request with invalid argument', async () => { + it('returns 400 for request with invalid argument', async () => { const res = await gateway.inject({ method: 'GET', url: '/ipfs/invalid' diff --git a/packages/ipfs/test/http-api/interface.js b/packages/ipfs/test/http-api/interface.js index a287a1d207..2797b0b98c 100644 --- a/packages/ipfs/test/http-api/interface.js +++ b/packages/ipfs/test/http-api/interface.js @@ -31,15 +31,7 @@ describe('interface-ipfs-core over ipfs-http-client tests', function () { tests.bitswap(commonFactory) - tests.block(commonFactory, { - skip: [ - { - name: 'should return an error for an invalid CID', - reason: - 'Intermittent failure: https://github.com/ipfs/js-ipfs/issues/3100' - } - ] - }) + tests.block(commonFactory) tests.bootstrap(commonFactory) From a126d22d93d5051b1b28b132f3ffa7f12dfea16a Mon Sep 17 00:00:00 2001 From: Irakli Gozalishvili Date: Tue, 14 Jul 2020 17:27:07 -0700 Subject: [PATCH 43/63] fix: typo Co-authored-by: Marcin Rataj --- packages/ipfs-message-port-client/README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/ipfs-message-port-client/README.md b/packages/ipfs-message-port-client/README.md index 51329efc54..b6f1b612b5 100644 --- a/packages/ipfs-message-port-client/README.md +++ b/packages/ipfs-message-port-client/README.md @@ -94,7 +94,7 @@ window.onmessage = ({ports}) => { Since client works with IPFS node over [message channel][] all the data passed is copied via [structured cloning algorithm][], which may lead to suboptimal -results (espacially with large binary data). In order to avoid unecessary +results (especially with large binary data). In order to avoid unnecessary copying all API options have being extended with optional `transfer` property that can be supplied [Transferable][]s which will be used to move corresponding values instead of copying. From e21b5fa9893347446309c16642683f90aa7ea790 Mon Sep 17 00:00:00 2001 From: Irakli Gozalishvili Date: Tue, 14 Jul 2020 17:29:04 -0700 Subject: [PATCH 44/63] fix: apply suggestions from code review Co-authored-by: Marcin Rataj --- packages/ipfs-message-port-client/README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/ipfs-message-port-client/README.md b/packages/ipfs-message-port-client/README.md index b6f1b612b5..136bd3e8a0 100644 --- a/packages/ipfs-message-port-client/README.md +++ b/packages/ipfs-message-port-client/README.md @@ -116,7 +116,7 @@ const example = async (data) => { It is however recommended to prefer web native [Blob][] / [File][] intances as most web APIs provide them as option & can be send across without copying -underyling memory. +underlying memory. ```js const example = async (url) => { From a4b5ffc80d42b28f77123af946ddc4757fec3b45 Mon Sep 17 00:00:00 2001 From: Irakli Gozalishvili Date: Wed, 15 Jul 2020 21:24:53 -0700 Subject: [PATCH 45/63] chore: add shared worker example --- .../README.md | 38 ++++++++++ .../Screen Shot.png | Bin 0 -> 300167 bytes .../index.html | 12 ++++ .../lerna.json | 8 +++ .../package.json | 36 ++++++++++ .../server.js | 18 +++++ .../src/main.js | 53 ++++++++++++++ .../src/worker.js | 65 ++++++++++++++++++ .../browser-sharing-node-across-tabs/test.js | 33 +++++++++ .../webpack.config.js | 44 ++++++++++++ .../test/util/worker.js | 3 +- packages/ipfs-message-port-server/README.md | 3 +- .../ipfs-message-port-server/src/index.js | 29 +++----- .../ipfs-message-port-server/src/service.js | 27 ++++++++ 14 files changed, 347 insertions(+), 22 deletions(-) create mode 100644 examples/browser-sharing-node-across-tabs/README.md create mode 100644 examples/browser-sharing-node-across-tabs/Screen Shot.png create mode 100644 examples/browser-sharing-node-across-tabs/index.html create mode 100644 examples/browser-sharing-node-across-tabs/lerna.json create mode 100644 examples/browser-sharing-node-across-tabs/package.json create mode 100644 examples/browser-sharing-node-across-tabs/server.js create mode 100644 examples/browser-sharing-node-across-tabs/src/main.js create mode 100644 examples/browser-sharing-node-across-tabs/src/worker.js create mode 100644 examples/browser-sharing-node-across-tabs/test.js create mode 100644 examples/browser-sharing-node-across-tabs/webpack.config.js create mode 100644 packages/ipfs-message-port-server/src/service.js diff --git a/examples/browser-sharing-node-across-tabs/README.md b/examples/browser-sharing-node-across-tabs/README.md new file mode 100644 index 0000000000..039bc7b99a --- /dev/null +++ b/examples/browser-sharing-node-across-tabs/README.md @@ -0,0 +1,38 @@ +# Sharing js-ipfs node across browsing contexts (tabs) using [SharedWorker][] + +> In this example, you will find a boilerplate you can use to set up a js-ipfs +> node in the [SharedWorker] and use it from multiple tabs. + +## Before you start + +First clone this repo, install dependencies in the project root and build the project. + +```bash +git clone https://github.com/ipfs/js-ipfs.git +cd js-ipfs/examples/browser-sharing-node-across-tabs +npm install +``` + +## Running the example + +Run the following command within this folder: + +```bash +npm start +``` + +Now open your browser at `http://localhost:3000` + +You should see the following: + +![Screen Shot](./Screen Shot.png) + + +### Run tests + +```bash +npm test +``` + + +[SharedWorker]:https://developer.mozilla.org/en-US/docs/Web/API/SharedWorker \ No newline at end of file diff --git a/examples/browser-sharing-node-across-tabs/Screen Shot.png b/examples/browser-sharing-node-across-tabs/Screen Shot.png new file mode 100644 index 0000000000000000000000000000000000000000..38cf03585f0a0a85bc5e8d80f686885cfb506e78 GIT binary patch literal 300167 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 z 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
&(wDpYdtm2MvfM+~3u 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 Q7x1xX*MXhcJ5JvCKL?ULCIA2c literal 0 HcmV?d00001 diff --git a/examples/browser-sharing-node-across-tabs/index.html b/examples/browser-sharing-node-across-tabs/index.html new file mode 100644 index 0000000000..8a19ba7c21 --- /dev/null +++ b/examples/browser-sharing-node-across-tabs/index.html @@ -0,0 +1,12 @@ + + + + Sample App + + + +

+ + + + \ No newline at end of file diff --git a/examples/browser-sharing-node-across-tabs/lerna.json b/examples/browser-sharing-node-across-tabs/lerna.json new file mode 100644 index 0000000000..12ef44e049 --- /dev/null +++ b/examples/browser-sharing-node-across-tabs/lerna.json @@ -0,0 +1,8 @@ +{ + "packages": [ + "../test-ipfs-example", + "../../packages/*", + "." + ], + "version": "independent" +} \ No newline at end of file diff --git a/examples/browser-sharing-node-across-tabs/package.json b/examples/browser-sharing-node-across-tabs/package.json new file mode 100644 index 0000000000..17f7fe65df --- /dev/null +++ b/examples/browser-sharing-node-across-tabs/package.json @@ -0,0 +1,36 @@ +{ + "name": "expample-browser-sharing-node-across-tabs", + "description": "Sharing IPFS node across browsing contexts", + "version": "1.0.0", + "private": true, + "scripts": { + "clean": "rm -rf ./dist", + "build": "webpack", + "start": "node server.js", + "test": "test-ipfs-example" + }, + "license": "MIT", + "keywords": [], + "devDependencies": { + "@babel/core": "^7.2.2", + "@babel/preset-env": "^7.3.1", + "babel-loader": "^8.0.5", + "copy-webpack-plugin": "^5.0.4", + "test-ipfs-example": "^2.0.3", + "webpack": "^4.28.4", + "webpack-cli": "^3.3.11", + "webpack-dev-server": "^3.1.14", + "worker-plugin": "4.0.3" + }, + "dependencies": { + "ipfs": "^0.47.0", + "ipfs-message-port-client": "^0.0.1", + "ipfs-message-port-server": "^0.0.1" + }, + "browserslist": [ + ">1%", + "not dead", + "not ie <= 11", + "not op_mini all" + ] +} \ No newline at end of file diff --git a/examples/browser-sharing-node-across-tabs/server.js b/examples/browser-sharing-node-across-tabs/server.js new file mode 100644 index 0000000000..4a1a8ebdfb --- /dev/null +++ b/examples/browser-sharing-node-across-tabs/server.js @@ -0,0 +1,18 @@ +'use strict' + +const webpack = require('webpack') +const WebpackDevServer = require('webpack-dev-server') +const config = require('./webpack.config') + +const wds = new WebpackDevServer(webpack(config), { + hot: true, + historyApiFallback: true +}) + +wds.listen(3000, 'localhost', (err) => { + if (err) { + throw err + } + + console.log('Listening at localhost:3000') +}) diff --git a/examples/browser-sharing-node-across-tabs/src/main.js b/examples/browser-sharing-node-across-tabs/src/main.js new file mode 100644 index 0000000000..b787ac4fb8 --- /dev/null +++ b/examples/browser-sharing-node-across-tabs/src/main.js @@ -0,0 +1,53 @@ +'use strict' + +import IPFSClient from "ipfs-message-port-client" + + +const main = async () => { + // connect / spawn shared ipfs worker & create a client. + const worker = new SharedWorker('./worker.js', { type: 'module' }) + const ipfs = IPFSClient.from(worker.port) + + const path = location.hash.slice(1) + if (path.startsWith('/ipfs/')) { + await viewer(ipfs, path) + } else { + await uploader(ipfs) + } +} + +const uploader = async (ipfs) => { + document.body.outerHTML += '
Adding "hello world!" to shared IPFS node
' + const entry = await add(ipfs, new Blob(['hello world!'], { type: "text/plain" })) + const path = `/ipfs/${entry.cid}/` + document.body.outerHTML += `
File was added: + ${path} +
` +} + +const viewer = async (ipfs, path) => { + document.body.outerHTML += `
Loading ${path}
` + try { + const chunks = [] + for await (const chunk of await ipfs.cat(path)) { + chunks.push(chunk) + } + const blob = new Blob(chunks) + const url = URL.createObjectURL(blob) + document.body.outerHTML += + `` + + } catch(error) { + document.body.outerHTML += `
${error}
` + } +} + +const add = async (ipfs, blob) => { + let result = null + for await (const entry of ipfs.add(blob)) { + result = entry + } + return result +} + +onload = main \ No newline at end of file diff --git a/examples/browser-sharing-node-across-tabs/src/worker.js b/examples/browser-sharing-node-across-tabs/src/worker.js new file mode 100644 index 0000000000..e39c5d9b89 --- /dev/null +++ b/examples/browser-sharing-node-across-tabs/src/worker.js @@ -0,0 +1,65 @@ +'use strict' + +import IPFS from 'ipfs' +import { Server, IPFSService } from 'ipfs-message-port-server' + +const main = async () => { + // start listening to all the incoming connections (browsing contexts that + // which run new SharedWorker...) + // Note: It is important to start listening before we do any await to ensure + // that connections aren't missed while awaiting. + const connections = listen(self, 'connect') + + // Start an IPFS node & create server that will expose it's API to all clients + // over message channel. + const ipfs = await IPFS.create() + const service = new IPFSService(ipfs) + const server = new Server(service) + + // connect every queued and future connection to the server. + for await (const event of connections) { + const port = event.ports[0] + if (port) { + server.connect(port) + } + } +} + +/** + * Creates an AsyncIterable for all the events on the given `target` for + * the given event `type`. It is like `target.addEventListener(type, listener, options)` + * but instead of passing listener you get `AsyncIterable` instead. + * @param {EventTarget} target + * @param {string} type + * @param {AddEventListenerOptions} options + */ +const listen = function (target, type, options) { + const events = [] + let resume + let ready = new Promise(resolve => (resume = resolve)) + + const write = event => { + events.push(event) + resume() + } + const read = async () => { + await ready + ready = new Promise(resolve => (resume = resolve)) + return events.splice(0) + } + + const reader = async function * () { + try { + while (true) { + yield * await read() + } + } finally { + target.removeEventListener(type, write, options) + } + } + + target.addEventListener(type, write, options) + return reader() +} + +main() \ No newline at end of file diff --git a/examples/browser-sharing-node-across-tabs/test.js b/examples/browser-sharing-node-across-tabs/test.js new file mode 100644 index 0000000000..0f73bb20de --- /dev/null +++ b/examples/browser-sharing-node-across-tabs/test.js @@ -0,0 +1,33 @@ +'use strict' + +const pkg = require('./package.json') + +module.exports = { + [pkg.name]: (browser) => { + browser + .url(process.env.IPFS_EXAMPLE_TEST_URL) + .waitForElementVisible('.ipfs-add') + + browser.expect.element('.ipfs-add a').text.to.contain('/ipfs/') + browser.click('.ipfs-add a') + + browser.windowHandle(({ value }) => { + browser.windowHandles(({ value: handles }) => { + const [handle] = handles.filter(handle => handle != value) + browser.switchWindow(handle) + }) + }) + + browser.waitForElementVisible('.loading') + browser.expect.element('.loading').text.to.contain('Loading /ipfs/') + + browser.waitForElementVisible('#content').pause(5000) + browser.element('css selector', '#content', frame => { + browser.frame({ ELEMENT: frame.value.ELEMENT }, () => { + browser.waitForElementPresent('body') + browser.expect.element('body').text.to.contain('hello world!') + browser.end() + }) + }) + } +} diff --git a/examples/browser-sharing-node-across-tabs/webpack.config.js b/examples/browser-sharing-node-across-tabs/webpack.config.js new file mode 100644 index 0000000000..a9b412db3a --- /dev/null +++ b/examples/browser-sharing-node-across-tabs/webpack.config.js @@ -0,0 +1,44 @@ +'use strict' + +var path = require('path') +var webpack = require('webpack') +const WorkerPlugin = require('worker-plugin') + +module.exports = { + devtool: 'source-map', + entry: [ + 'webpack-dev-server/client?http://localhost:3000', + 'webpack/hot/only-dev-server', + './src/main' + ], + output: { + path: path.join(__dirname, 'dist'), + filename: 'static/bundle.js' + }, + plugins: [ + new WorkerPlugin({ + sharedWorker: true, + globalObject: 'self' + }), + new webpack.HotModuleReplacementPlugin() + ], + module: { + rules: [ + { + test: /\.js$/, + exclude: /node_modules/, + use: { + loader: 'babel-loader', + options: { + presets: ['@babel/preset-env'] + } + } + } + ] + }, + node: { + fs: 'empty', + net: 'empty', + tls: 'empty' + } +} diff --git a/packages/ipfs-message-port-client/test/util/worker.js b/packages/ipfs-message-port-client/test/util/worker.js index 8bb65065b9..93b81cc3a3 100644 --- a/packages/ipfs-message-port-client/test/util/worker.js +++ b/packages/ipfs-message-port-client/test/util/worker.js @@ -1,8 +1,7 @@ 'use strict' const IPFS = require('ipfs') -const { IPFSService } = require('ipfs-message-port-server') -const { Server } = require('ipfs-message-port-server/src/server') +const { IPFSService, Server } = require('ipfs-message-port-server') const main = async connections => { const ipfs = await IPFS.create({ offline: true, start: false }) diff --git a/packages/ipfs-message-port-server/README.md b/packages/ipfs-message-port-server/README.md index 7ae5b5a4c6..0189c02a00 100644 --- a/packages/ipfs-message-port-server/README.md +++ b/packages/ipfs-message-port-server/README.md @@ -50,8 +50,7 @@ node in [SharedWorker][] and exposing it to all connected ports ```js const IPFS = require('ipfs') -const { IPFSService } = require('ipfs-message-port-server') -const { Server } = require('ipfs-message-port-server/src/server') +const { IPFSService, Server } = require('ipfs-message-port-server') const main = async () => { const connections = [] diff --git a/packages/ipfs-message-port-server/src/index.js b/packages/ipfs-message-port-server/src/index.js index c4820acfce..119aa05894 100644 --- a/packages/ipfs-message-port-server/src/index.js +++ b/packages/ipfs-message-port-server/src/index.js @@ -1,27 +1,20 @@ 'use strict' /* eslint-env browser */ - const { DAGService } = require('./dag') +exports.DAGService = DAGService + const { CoreService } = require('./core') -const { FilesService } = require('./files') -const { BlockService } = require('./block') +exports.CoreService = CoreService -/** - * @typedef {import('./ipfs').IPFS} IPFS - */ +const { FilesService } = require('./files') +exports.FilesService = FilesService -class IPFSService { - /** - * - * @param {IPFS} ipfs - */ - constructor (ipfs) { - this.dag = new DAGService(ipfs) - this.core = new CoreService(ipfs) - this.files = new FilesService(ipfs) - this.block = new BlockService(ipfs) - } -} +const { BlockService } = require('./block') +exports.BlockService = BlockService +const { IPFSService } = require('./service') exports.IPFSService = IPFSService + +const { Server } = require('./server') +exports.Server = Server diff --git a/packages/ipfs-message-port-server/src/service.js b/packages/ipfs-message-port-server/src/service.js new file mode 100644 index 0000000000..c4820acfce --- /dev/null +++ b/packages/ipfs-message-port-server/src/service.js @@ -0,0 +1,27 @@ +'use strict' + +/* eslint-env browser */ + +const { DAGService } = require('./dag') +const { CoreService } = require('./core') +const { FilesService } = require('./files') +const { BlockService } = require('./block') + +/** + * @typedef {import('./ipfs').IPFS} IPFS + */ + +class IPFSService { + /** + * + * @param {IPFS} ipfs + */ + constructor (ipfs) { + this.dag = new DAGService(ipfs) + this.core = new CoreService(ipfs) + this.files = new FilesService(ipfs) + this.block = new BlockService(ipfs) + } +} + +exports.IPFSService = IPFSService From 0dc83a5ebeb1c584dd95fc1866fdf795dd2daefa Mon Sep 17 00:00:00 2001 From: Irakli Gozalishvili Date: Thu, 16 Jul 2020 12:40:05 -0700 Subject: [PATCH 46/63] fix: test overcoming moxystudio/js-class-is#27 --- packages/interface-ipfs-core/src/object/put.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/interface-ipfs-core/src/object/put.js b/packages/interface-ipfs-core/src/object/put.js index 8c84afc8d4..63e210e2a3 100644 --- a/packages/interface-ipfs-core/src/object/put.js +++ b/packages/interface-ipfs-core/src/object/put.js @@ -113,7 +113,7 @@ module.exports = (common, options) => { const cid = await ipfs.object.put(node1b) const node = await ipfs.object.get(cid) expect(node1b.Data).to.deep.equal(node.Data) - expect(node1b.Links).to.deep.equal(node.Links) + expect(node1b.Links).to.containSubset(node.Links) }) }) } From 6175a3511d79bfb7061686e3533f52a3ecfcf089 Mon Sep 17 00:00:00 2001 From: Irakli Gozalishvili Date: Sat, 18 Jul 2020 00:02:37 -0700 Subject: [PATCH 47/63] chore: disable electron tests Bug in aegir ipfs/aegir#587 causes race conditions --- .../ipfs-message-port-server/package.json | 19 +++++++++++++------ 1 file changed, 13 insertions(+), 6 deletions(-) diff --git a/packages/ipfs-message-port-server/package.json b/packages/ipfs-message-port-server/package.json index bee0b0e802..9e872e8057 100644 --- a/packages/ipfs-message-port-server/package.json +++ b/packages/ipfs-message-port-server/package.json @@ -2,12 +2,19 @@ "name": "ipfs-message-port-server", "version": "0.0.1", "description": "IPFS server library for exposing IPFS node over message port", - "keywords": ["ipfs", "message-port", "worker"], + "keywords": [ + "ipfs", + "message-port", + "worker" + ], "homepage": "https://github.com/ipfs/js-ipfs/tree/master/packages/ipfs-message-port-server#readme", "bugs": "https://github.com/ipfs/js-ipfs/issues", "license": "(Apache-2.0 OR MIT)", "leadMaintainer": "Alex Potsides ", - "files": ["src", "dist"], + "files": [ + "src", + "dist" + ], "main": "src/index.js", "browser": {}, "repository": { @@ -18,8 +25,6 @@ "test": "aegir test", "test:browser": "aegir test -t browser", "test:webworker": "aegir test -t webworker", - "test:electron-main": "aegir test -t electron-main", - "test:electron-renderer": "aegir test -t electron-renderer", "test:chrome": "aegir test -t browser -t webworker -- --browsers ChromeHeadless", "test:firefox": "aegir test -t browser -t webworker -- --browsers FirefoxHeadless", "lint": "aegir lint", @@ -42,5 +47,7 @@ "node": ">=10.3.0", "npm": ">=3.0.0" }, - "contributors": ["Irakli Gozalishvili "] -} + "contributors": [ + "Irakli Gozalishvili " + ] +} \ No newline at end of file From 69c6db018c5448266acf4def0409a93e8fe01058 Mon Sep 17 00:00:00 2001 From: Irakli Gozalishvili Date: Mon, 20 Jul 2020 02:06:14 -0700 Subject: [PATCH 48/63] chore: update interface-ipfs-core to lastest --- packages/ipfs-message-port-client/package.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/ipfs-message-port-client/package.json b/packages/ipfs-message-port-client/package.json index c2540a6daf..81a8e66714 100644 --- a/packages/ipfs-message-port-client/package.json +++ b/packages/ipfs-message-port-client/package.json @@ -38,7 +38,7 @@ "it-drain": "^1.0.1", "aegir": "^22.0.0", "cross-env": "^7.0.0", - "interface-ipfs-core": "^0.136.0" + "interface-ipfs-core": "^0.137.0" }, "engines": { "node": ">=10.3.0", From 2302b2fcbac64b351d19d201259578ac008d7a39 Mon Sep 17 00:00:00 2001 From: Irakli Gozalishvili Date: Mon, 20 Jul 2020 21:16:21 -0700 Subject: [PATCH 49/63] chore: incorporate changes from ipfs@0.48 --- .../src/main.js | 10 +- packages/interface-ipfs-core/src/add.js | 19 +-- .../ipfs-message-port-client/package.json | 27 ++-- packages/ipfs-message-port-client/src/core.js | 126 +++++++++++++++--- packages/ipfs-message-port-client/src/dag.js | 82 ++++++------ .../ipfs-message-port-protocol/package.json | 6 +- .../ipfs-message-port-protocol/src/dag.js | 2 +- .../ipfs-message-port-server/package.json | 8 +- packages/ipfs-message-port-server/src/core.js | 112 +++++++++++++--- packages/ipfs-message-port-server/src/dag.js | 50 ++++++- packages/ipfs-message-port-server/src/ipfs.ts | 63 ++++----- 11 files changed, 348 insertions(+), 157 deletions(-) diff --git a/examples/browser-sharing-node-across-tabs/src/main.js b/examples/browser-sharing-node-across-tabs/src/main.js index b787ac4fb8..44d9f5ecf3 100644 --- a/examples/browser-sharing-node-across-tabs/src/main.js +++ b/examples/browser-sharing-node-across-tabs/src/main.js @@ -18,7 +18,7 @@ const main = async () => { const uploader = async (ipfs) => { document.body.outerHTML += '
Adding "hello world!" to shared IPFS node
' - const entry = await add(ipfs, new Blob(['hello world!'], { type: "text/plain" })) + const entry = await ipfs.add(ipfs, new Blob(['hello world!'], { type: "text/plain" })) const path = `/ipfs/${entry.cid}/` document.body.outerHTML += `
File was added: ${path} @@ -42,12 +42,4 @@ const viewer = async (ipfs, path) => { } } -const add = async (ipfs, blob) => { - let result = null - for await (const entry of ipfs.add(blob)) { - result = entry - } - return result -} - onload = main \ No newline at end of file diff --git a/packages/interface-ipfs-core/src/add.js b/packages/interface-ipfs-core/src/add.js index 25a5a683d9..e2fb7a12f6 100644 --- a/packages/interface-ipfs-core/src/add.js +++ b/packages/interface-ipfs-core/src/add.js @@ -5,13 +5,16 @@ const { Buffer } = require('buffer') const { fixtures } = require('./utils') const { Readable } = require('readable-stream') const { supportsFileReader } = require('ipfs-utils/src/supports') -const urlSource = require('ipfs-utils/src/files/url-source') +const urlSources = require('ipfs-utils/src/files/url-source') +const last = require('it-last') const { isNode } = require('ipfs-utils/src/env') const { getDescribe, getIt, expect } = require('./utils/mocha') const testTimeout = require('./utils/test-timeout') const echoUrl = (text) => `${process.env.ECHO_SERVER}/download?data=${encodeURIComponent(text)}` const redirectUrl = (url) => `${process.env.ECHO_SERVER}/redirect?to=${encodeURI(url)}` +const urlSource = (url) => last(urlSources(url)) + /** @typedef { import("ipfsd-ctl/src/factory") } Factory */ /** * @param {Factory} common @@ -242,7 +245,7 @@ module.exports = (common, options) => { const url = echoUrl(text) const [result, expectedResult] = await Promise.all([ - ipfs.add(urlSource(url)), + ipfs.add(await urlSource(url)), ipfs.add(Buffer.from(text)) ]) @@ -257,7 +260,7 @@ module.exports = (common, options) => { const url = echoUrl(text) const [result, expectedResult] = await Promise.all([ - ipfs.add(urlSource(redirectUrl(url))), + ipfs.add(await urlSource(redirectUrl(url))), ipfs.add(Buffer.from(text)) ]) @@ -271,7 +274,7 @@ module.exports = (common, options) => { const text = `TEST${Math.random()}` const url = echoUrl(text) - const res = await ipfs.add(urlSource(url), { onlyHash: true }) + const res = await ipfs.add(await urlSource(url), { onlyHash: true }) await expect(ipfs.object.get(res.cid, { timeout: 500 })) .to.eventually.be.rejected() @@ -284,7 +287,7 @@ module.exports = (common, options) => { const addOpts = { wrapWithDirectory: true } const [result, expectedResult] = await Promise.all([ - ipfs.add(urlSource(url), addOpts), + ipfs.add(await urlSource(url), addOpts), ipfs.add({ path: 'download', content: Buffer.from(filename) }, addOpts) ]) expect(result.err).to.not.exist() @@ -298,8 +301,8 @@ module.exports = (common, options) => { const addOpts = { wrapWithDirectory: true } const [result, expectedResult] = await Promise.all([ - ipfs.add(urlSource(url), addOpts), - ipfs.add([{ path: 'download', content: Buffer.from(filename) }], addOpts) + ipfs.add(await urlSource(url), addOpts), + ipfs.add({ path: 'download', content: Buffer.from(filename) }, addOpts) ]) expect(result.err).to.not.exist() @@ -308,7 +311,7 @@ module.exports = (common, options) => { }) it('should not add from an invalid url', () => { - return expect(ipfs.add(urlSource('123http://invalid'))).to.eventually.be.rejected() + return expect(last(ipfs.addAll(urlSources('123http://invalid')))).to.eventually.be.rejected() }) it('should respect raw leaves when file is smaller than one block and no metadata is present', async () => { diff --git a/packages/ipfs-message-port-client/package.json b/packages/ipfs-message-port-client/package.json index 81a8e66714..8c97890f8f 100644 --- a/packages/ipfs-message-port-client/package.json +++ b/packages/ipfs-message-port-client/package.json @@ -2,12 +2,19 @@ "name": "ipfs-message-port-client", "version": "0.0.1", "description": "IPFS client library for accessing IPFS node over message port", - "keywords": ["ipfs", "message-port", "worker"], + "keywords": [ + "ipfs", + "message-port", + "worker" + ], "homepage": "https://github.com/ipfs/js-ipfs/tree/master/packages/ipfs-message-port-client#readme", "bugs": "https://github.com/ipfs/js-ipfs/issues", "license": "(Apache-2.0 OR MIT)", "leadMaintainer": "Alex Potsides ", - "files": ["src", "dist"], + "files": [ + "src", + "dist" + ], "main": "src/index.js", "browser": {}, "repository": { @@ -27,22 +34,22 @@ "dep-check": "aegir dep-check" }, "dependencies": { - "cids": "^0.8.0" + "cids": "^0.8.3" }, "devDependencies": { "ipfs-message-port-protocol": "~0.0.1", "ipfs-message-port-server": "~0.0.1", "ipld-dag-pb": "^0.19.0", - "ipfs": "^0.46.0", - "it-all": "^1.0.1", - "it-drain": "^1.0.1", - "aegir": "^22.0.0", + "ipfs": "^0.48.0", + "aegir": "^23.0.0", "cross-env": "^7.0.0", - "interface-ipfs-core": "^0.137.0" + "interface-ipfs-core": "^0.138.0" }, "engines": { "node": ">=10.3.0", "npm": ">=3.0.0" }, - "contributors": ["Irakli Gozalishvili "] -} + "contributors": [ + "Irakli Gozalishvili " + ] +} \ No newline at end of file diff --git a/packages/ipfs-message-port-client/src/core.js b/packages/ipfs-message-port-client/src/core.js index aea66fbcb0..5ede2e22d1 100644 --- a/packages/ipfs-message-port-client/src/core.js +++ b/packages/ipfs-message-port-client/src/core.js @@ -19,7 +19,8 @@ const { * @typedef {import('ipfs-message-port-protocol/src/data').Time} Time * @typedef {import('ipfs-message-port-protocol/src/data').UnixFSTime} UnixFSTime * @typedef {import('ipfs-message-port-protocol/src/dag').EncodedCID} EncodedCID - * @typedef {import('ipfs-message-port-server/src/core').AddInput} EncodedAddInput + * @typedef {import('ipfs-message-port-server/src/core').SingleFileInput} EncodedAddInput + * @typedef {import('ipfs-message-port-server/src/core').MultiFileInput} EncodedAddAllInput * @typedef {import('ipfs-message-port-server/src/core').FileInput} FileInput * @typedef {import('ipfs-message-port-server/src/core').FileContent} EncodedFileContent * @@ -29,7 +30,7 @@ const { * * @typedef {ArrayBuffer|ArrayBufferView} Bytes * - * @typedef {Blob|Bytes|string|Iterable|Iterable|AsyncIterable|ReadableStream} FileContent + * @typedef {Blob|Bytes|string|Iterable|Iterable|AsyncIterable} FileContent * * @typedef {Object} FileObject * @property {string} [path] @@ -38,12 +39,9 @@ const { * @property {UnixFSTime} [mtime] * * - * @typedef {Blob|Bytes|string|FileObject|Iterable|Iterable|AsyncIterable|ReadableStream} SingleFileInput - * - * @typedef {Iterable|Iterable|Iterable|AsyncIterable|AsyncIterable|AsyncIterable} MultiFileInput - * - * @typedef {SingleFileInput | MultiFileInput} AddInput + * @typedef {Blob|Bytes|string|FileObject|Iterable|Iterable|AsyncIterable|ReadableStream} AddInput * + * @typedef {Iterable|AsyncIterable} AddAllInput */ /** @@ -71,7 +69,7 @@ class CoreClient extends Client { * `transfer: [input.buffer]` which would allow transferring it instead of * copying. * - * @param {AddInput} input + * @param {AddAllInput} input * @param {Object} [options] * @param {string} [options.chunker="size-262144"] * @param {number} [options.cidVersion=0] @@ -96,7 +94,50 @@ class CoreClient extends Client { * @property {number} size * @property {Time} mtime */ - async * add (input, options = {}) { + async * addAll (input, options = {}) { + const { timeout, signal } = options + const transfer = [...(options.transfer || [])] + const progress = options.progress + ? encodeCallback(options.progress, transfer) + : undefined + + const result = await this.remote.addAll({ + ...options, + input: encodeAddAllInput(input, transfer), + progress, + transfer, + timeout, + signal + }) + yield * decodeIterable(result.data, decodeAddedData) + } + + /** + * Add file to IPFS. + * + * If you pass binary data like `Uint8Array` it is recommended to provide + * `transfer: [input.buffer]` which would allow transferring it instead of + * copying. + * + * @param {AddInput} input + * @param {Object} [options] + * @param {string} [options.chunker="size-262144"] + * @param {number} [options.cidVersion=0] + * @param {boolean} [options.enableShardingExperiment] + * @param {string} [options.hashAlg="sha2-256"] + * @param {boolean} [options.onlyHash=false] + * @param {boolean} [options.pin=true] + * @param {function(number):void} [options.progress] + * @param {boolean} [options.rawLeaves=false] + * @param {number} [options.shardSplitThreshold=1000] + * @param {boolean} [options.trickle=false] + * @param {boolean} [options.wrapWithDirectory=false] + * @param {number} [options.timeout] + * @param {Transferable[]} [options.transfer] + * @param {AbortSignal} [options.signal] + * @returns {Promise} + */ + async add (input, options = {}) { const { timeout, signal } = options const transfer = [...(options.transfer || [])] const progress = options.progress @@ -111,7 +152,8 @@ class CoreClient extends Client { timeout, signal }) - yield * decodeIterable(result.data, decodeAddedData) + + return decodeAddedData(result.data) } /** @@ -151,7 +193,7 @@ const decodeAddedData = ({ path, cid, mode, mtime, size }) => { * @param {T} v * @returns {T} */ -const identity = v => v +const identity = (v) => v /** * Encodes input passed to the `ipfs.add` via the best possible strategy for the @@ -175,7 +217,6 @@ const encodeAddInput = (input, transfer) => { } else { // If input is (async) iterable or `ReadableStream` or "FileObject" it will // be encoded via own specific encoder. - const iterable = asIterable(input) if (iterable) { return encodeIterable(iterable, encodeIterableContent, transfer) @@ -183,7 +224,11 @@ const encodeAddInput = (input, transfer) => { const asyncIterable = asAsyncIterable(input) if (asyncIterable) { - return encodeIterable(asyncIterable, encodeAsyncIterableContent, transfer) + return encodeIterable( + asyncIterable, + encodeAsyncIterableContent, + transfer + ) } const readableStream = asReadableStream(input) @@ -204,6 +249,43 @@ const encodeAddInput = (input, transfer) => { } } +/** + * Encodes input passed to the `ipfs.add` via the best possible strategy for the + * given input. + * + * @param {AddAllInput} input + * @param {Transferable[]} transfer + * @returns {EncodedAddAllInput} + */ +const encodeAddAllInput = (input, transfer) => { + // If input is (async) iterable or `ReadableStream` or "FileObject" it will + // be encoded via own specific encoder. + const iterable = asIterable(input) + if (iterable) { + return encodeIterable(iterable, encodeIterableContent, transfer) + } + + const asyncIterable = asAsyncIterable(input) + if (asyncIterable) { + return encodeIterable( + asyncIterable, + encodeAsyncIterableContent, + transfer + ) + } + + const readableStream = asReadableStream(input) + if (readableStream) { + return encodeIterable( + iterateReadableStream(readableStream), + encodeAsyncIterableContent, + transfer + ) + } + + throw TypeError('Unexpected input: ' + typeof input) +} + /** * Function encodes individual item of some `AsyncIterable` by choosing most * effective strategy. @@ -291,7 +373,11 @@ const encodeFileContent = (content, transfer) => { const asyncIterable = asAsyncIterable(content) if (asyncIterable) { - return encodeIterable(asyncIterable, encodeAsyncIterableContent, transfer) + return encodeIterable( + asyncIterable, + encodeAsyncIterableContent, + transfer + ) } const readableStream = asReadableStream(content) @@ -331,10 +417,10 @@ const iterateReadableStream = async function * (stream) { * Pattern matches given input as `Iterable` and returns back either matched * iterable or `null`. * @template I - * @param {Iterable|AddInput} input + * @param {Iterable|AddInput|AddAllInput} input * @returns {Iterable|null} */ -const asIterable = input => { +const asIterable = (input) => { /** @type {*} */ const object = input if (object && typeof object[Symbol.iterator] === 'function') { @@ -348,10 +434,10 @@ const asIterable = input => { * Pattern matches given `input` as `AsyncIterable` and returns back either * matched `AsyncIterable` or `null`. * @template I - * @param {AsyncIterable|AddInput} input + * @param {AsyncIterable|AddInput|AddAllInput} input * @returns {AsyncIterable|null} */ -const asAsyncIterable = input => { +const asAsyncIterable = (input) => { /** @type {*} */ const object = input if (object && typeof object[Symbol.asyncIterator] === 'function') { @@ -368,7 +454,7 @@ const asAsyncIterable = input => { * @param {any} input * @returns {ReadableStream|null} */ -const asReadableStream = input => { +const asReadableStream = (input) => { if (input && typeof input.getReader === 'function') { return input } else { @@ -382,7 +468,7 @@ const asReadableStream = input => { * @param {*} input * @returns {FileObject|null} */ -const asFileObject = input => { +const asFileObject = (input) => { if (typeof input === 'object' && (input.path || input.content)) { return input } else { diff --git a/packages/ipfs-message-port-client/src/dag.js b/packages/ipfs-message-port-client/src/dag.js index 9b3af8f9ab..48a4f84a02 100644 --- a/packages/ipfs-message-port-client/src/dag.js +++ b/packages/ipfs-message-port-client/src/dag.js @@ -6,6 +6,7 @@ const { encodeNode, decodeNode } = require('ipfs-message-port-protocol/src/dag') /** * @typedef {import('cids')} CID + * @typedef {import('ipfs-message-port-server/src/dag').EncodedCID} EncodedCID * @typedef {import('ipfs-message-port-server/src/dag').DAGNode} DAGNode * @typedef {import('ipfs-message-port-server/src/dag').EncodedDAGNode} EncodedDAGNode * @typedef {import('ipfs-message-port-server/src/dag').DAGEntry} DAGEntry @@ -22,7 +23,7 @@ class DAGClient extends Client { * @param {Transport} transport */ constructor (transport) { - super('dag', ['put', 'get', 'tree'], transport) + super('dag', ['put', 'get', 'resolve', 'tree'], transport) } /** @@ -33,6 +34,7 @@ class DAGClient extends Client { * @param {CID} [options.cid] * @param {boolean} [options.pin=false] - Pin this node when adding to the blockstore * @param {boolean} [options.preload=true] + * @param {Transferable[]} [options.transfer] - References to transfer to the * @param {number} [options.timeout] - A timeout in ms * @param {AbortSignal} [options.signal] - Can be used to cancel any long running requests started as a result of this call. * @returns {Promise} @@ -42,7 +44,7 @@ class DAGClient extends Client { const encodedCID = await this.remote.put({ ...options, - dagNode: encodeNode(dagNode), + dagNode: encodeNode(dagNode, options.transfer), cid: cid != null ? encodeCID(cid) : undefined }) @@ -51,46 +53,60 @@ class DAGClient extends Client { /** * @param {CID} cid - * @param {string} [path] * @param {Object} [options] + * @param {string} [options.path] * @param {boolean} [options.localResolve] * @param {number} [options.timeout] + * @param {Transferable[]} [options.transfer] - References to transfer to the * @param {AbortSignal} [options.signal] * @returns {Promise} */ - async get (cid, path, options = {}) { - const [nodePath, { localResolve, timeout, signal }] = read(path, options, '/') - + async get (cid, options = {}) { const { value, remainderPath } = await this.remote.get({ - cid: encodeCID(cid), - path: nodePath, - localResolve, - timeout, - signal + ...options, + cid: encodeCID(cid, options.transfer) }) return { value: decodeNode(value), remainderPath } } + /** + * @typedef {Object} ResolveResult + * @property {CID} cid + * @property {string|void} remainderPath + * + * @param {CID} cid + * @param {Object} [options] + * @param {string} [options.path] + * @param {number} [options.timeout] + * @param {Transferable[]} [options.transfer] - References to transfer to the + * @param {AbortSignal} [options.signal] + * @returns {Promise} + */ + async resolve (cid, options = {}) { + const { cid: encodedCID, remainderPath } = await this.remote.resolve({ + ...options, + cid: encodeCIDOrPath(cid, options.transfer) + }) + + return { cid: decodeCID(encodedCID), remainderPath } + } + /** * Enumerate all the entries in a graph * @param {CID} cid - CID of the DAG node to enumerate - * @param {string} [path] * @param {Object} [options] + * @param {string} [options.path] * @param {boolean} [options.recursive] + * @param {Transferable[]} [options.transfer] - References to transfer to the * @param {number} [options.timeout] * @param {AbortSignal} [options.signal] * @returns {AsyncIterable} */ - async * tree (cid, path, options = {}) { - const [nodePath, { recursive, timeout, signal }] = read(path, options, '') - + async * tree (cid, options = {}) { const paths = await this.remote.tree({ - cid: encodeCID(cid), - path: nodePath, - recursive, - timeout, - signal + ...options, + cid: encodeCID(cid, options.transfer) }) yield * paths @@ -98,27 +114,15 @@ class DAGClient extends Client { } /** - * @template T - * @typedef {T|void|null} Maybe - */ - -/** - * Takes logical parameters in form of [path, options] where both `path` and - * `options` may be absent and returns normilized version where both `path` - * and `options` are present. Uses `/` for `path` when missing and uses - * `defaultOptions` when `options` are missing. - * @template T - * param {[Maybe, T]|[NonNullable, T]} params - * @param {Maybe|NonNullable} path - * @param {T} options - * @param {string} defaultPath - * @returns {[string, T]} + * @param {string|CID} input + * @param {Transferable[]} [transfer] + * @returns {string|EncodedCID} */ -const read = (path, options, defaultPath) => { - if (typeof path === 'string') { - return [path, options] +const encodeCIDOrPath = (input, transfer) => { + if (typeof input === 'string') { + return input } else { - return [defaultPath, path == null ? options : path] + return encodeCID(input, transfer) } } diff --git a/packages/ipfs-message-port-protocol/package.json b/packages/ipfs-message-port-protocol/package.json index 599db67585..f986102dee 100644 --- a/packages/ipfs-message-port-protocol/package.json +++ b/packages/ipfs-message-port-protocol/package.json @@ -33,12 +33,12 @@ }, "dependencies": { "buffer": "^5.6.0", - "cids": "^0.8.0", + "cids": "^0.8.3", "ipld-block": "^0.9.2" }, "devDependencies": { - "aegir": "^22.0.0", - "interface-ipfs-core": "^0.136.0" + "aegir": "^23.0.0", + "interface-ipfs-core": "^0.138.0" }, "engines": { "node": ">=10.3.0", diff --git a/packages/ipfs-message-port-protocol/src/dag.js b/packages/ipfs-message-port-protocol/src/dag.js index cb3e921998..f45fdd70d7 100644 --- a/packages/ipfs-message-port-protocol/src/dag.js +++ b/packages/ipfs-message-port-protocol/src/dag.js @@ -71,7 +71,7 @@ exports.encodeNode = encodeNode */ const collectNode = (value, cids, transfer) => { if (value != null && typeof value === 'object') { - if (value instanceof CID) { + if (CID.isCID(value)) { cids.push(value) encodeCID(value, transfer) } else if (value instanceof ArrayBuffer) { diff --git a/packages/ipfs-message-port-server/package.json b/packages/ipfs-message-port-server/package.json index 9e872e8057..ac16c0001d 100644 --- a/packages/ipfs-message-port-server/package.json +++ b/packages/ipfs-message-port-server/package.json @@ -34,14 +34,14 @@ "dep-check": "aegir dep-check" }, "dependencies": { - "cids": "^0.8.0" + "cids": "^0.8.3" }, "devDependencies": { "ipfs-message-port-protocol": "~0.0.1", - "ipfs": "^0.46.0", - "aegir": "^22.0.0", + "ipfs": "^0.48.0", + "aegir": "^23.0.0", "cross-env": "^7.0.0", - "interface-ipfs-core": "^0.136.0" + "interface-ipfs-core": "^0.138.0" }, "engines": { "node": ">=10.3.0", diff --git a/packages/ipfs-message-port-server/src/core.js b/packages/ipfs-message-port-server/src/core.js index c3fd949677..284f591154 100644 --- a/packages/ipfs-message-port-server/src/core.js +++ b/packages/ipfs-message-port-server/src/core.js @@ -36,8 +36,7 @@ const { decodeCID, encodeCID } = require('ipfs-message-port-protocol/src/cid') */ /** - * @typedef {Object} AddQuery - * @property {AddInput} input + * @typedef {Object} AddOptions * @property {string} [chunker] * @property {number} [cidVersion] * @property {boolean} [enableShardingExperiment] @@ -52,9 +51,17 @@ const { decodeCID, encodeCID } = require('ipfs-message-port-protocol/src/cid') * @property {number} [timeout] * @property {AbortSignal} [signal] * - * @typedef {SingleFileInput | MultiFileInput} AddInput - * @typedef {ArrayBuffer|ArrayBufferView|Blob|string|FileInput|RemoteIterable|RemoteIterable} SingleFileInput - * @typedef {RemoteIterable|RemoteIterable|RemoteIterable} MultiFileInput + * @typedef {Object} AddAllInput + * @property {MultiFileInput} input + * + * @typedef {Object} AddInput + * @property {SingleFileInput} input + * + * @typedef {AddInput & AddOptions} AddQuery + * @typedef {AddAllInput & AddOptions} AddAllQuery + * + * @typedef {ArrayBuffer|ArrayBufferView|Blob|string|FileInput|RemoteIterable} SingleFileInput + * @typedef {RemoteIterable} MultiFileInput * * @typedef {Object} FileInput * @property {string} [path] @@ -116,14 +123,60 @@ class CoreService { } /** - * @typedef {Object} AddResult + * @typedef {Object} AddAllResult * @property {RemoteIterable} data * @property {Transferable[]} transfer + * @param {AddAllQuery} query + * @returns {AddAllResult} + */ + addAll (query) { + const { input } = query + const { + chunker, + cidVersion, + enableShardingExperiment, + hashAlg, + onlyHash, + pin, + progress, + rawLeaves, + shardSplitThreshold, + trickle, + wrapWithDirectory, + timeout, + signal + } = query + + const options = { + chunker, + cidVersion, + enableShardingExperiment, + hashAlg, + onlyHash, + pin, + rawLeaves, + shardSplitThreshold, + trickle, + wrapWithDirectory, + timeout, + progress: progress != null ? decodeCallback(progress) : undefined, + signal + } + + const content = decodeAddAllInput(input) + return encodeAddAllResult(this.ipfs.addAll(content, options)) + } + + /** + * @typedef {Object} AddResult + * @property {AddedEntry} data + * @property {Transferable[]} transfer + * @param {AddQuery} query - * @returns {AddResult} + * @returns {Promise} */ - add (query) { + async add (query) { const { input } = query const { chunker, @@ -158,7 +211,7 @@ class CoreService { } const content = decodeAddInput(input) - return encodeAddResult(this.ipfs.add(content, options)) + return encodeAddResult(await this.ipfs.add(content, options)) } /** @@ -181,21 +234,29 @@ class CoreService { return encodeCatResult(content) } } +// @returns {string|ArrayBufferView|ArrayBuffer|Blob|AsyncIterable|AsyncIterable|AsyncIterable|AsyncIterable|AsyncIterable} + +/** + * @param {MultiFileInput} input + * @returns {AsyncIterable} + */ +const decodeAddAllInput = input => + decodeIterable(input, decodeFileInput) /** - * @param {AddInput} input - * @returns {string|ArrayBufferView|ArrayBuffer|Blob|AsyncIterable|AsyncIterable|AsyncIterable|AsyncIterable|AsyncIterable} + * @param {SingleFileInput} input + * @returns {string|ArrayBufferView|ArrayBuffer|Blob|FileObject} */ const decodeAddInput = input => matchInput( input, /** - * @param {*} data - * @returns {*} - */ + * @param {*} data + * @returns {*} + */ data => { if (data.type === 'RemoteIterable') { - return decodeIterable(data, decodeFileInput) + return { content: decodeIterable(data, decodeFileInput) } } else { return decodeFileInput(data) } @@ -203,11 +264,6 @@ const decodeAddInput = input => ) /** - * @property {string|void} [path] - * @property {DecodedFileContent} content - * @property {Mode|void} [mode] - * @property {Time|void} [mtime] - * @param {ArrayBufferView|ArrayBuffer|string|Blob|FileInput} input * @returns {string|ArrayBuffer|ArrayBufferView|Blob|FileObject} */ @@ -244,15 +300,27 @@ const matchInput = (input, decode) => { } /** - * * @param {AsyncIterable} out + * @returns {AddAllResult} + */ +const encodeAddAllResult = out => { + /** @type {Transferable[]} */ + const transfer = [] + return { + data: encodeIterable(out, encodeFileOutput, transfer), + transfer + } +} + +/** + * @param {FileOutput} out * @returns {AddResult} */ const encodeAddResult = out => { /** @type {Transferable[]} */ const transfer = [] return { - data: encodeIterable(out, encodeFileOutput, transfer), + data: encodeFileOutput(out, transfer), transfer } } diff --git a/packages/ipfs-message-port-server/src/dag.js b/packages/ipfs-message-port-server/src/dag.js index 59b54a7fb4..a4666855d6 100644 --- a/packages/ipfs-message-port-server/src/dag.js +++ b/packages/ipfs-message-port-server/src/dag.js @@ -6,6 +6,7 @@ const { decodeNode, encodeNode } = require('ipfs-message-port-protocol/src/dag') /** * @typedef {import('./ipfs').IPFS} IPFS + * @typedef {import('ipfs-message-port-protocol/src/cid').CID} CID * @typedef {import('ipfs-message-port-protocol/src/cid').EncodedCID} EncodedCID * @typedef {import('ipfs-message-port-protocol/src/dag').DAGNode} DAGNode * @typedef {import('ipfs-message-port-protocol/src/dag').EncodedDAGNode} EncodedDAGNode @@ -57,8 +58,8 @@ class DAGService { * * @typedef {Object} GetDAG * @property {EncodedCID} cid - * @property {string} path - * @property {boolean} localResolve + * @property {string} [path] + * @property {boolean} [localResolve] * @property {number} [timeout] * @property {AbortSignal} [signal] * @@ -69,8 +70,8 @@ class DAGService { const { cid, path, localResolve, timeout, signal } = query const { value, remainderPath } = await this.ipfs.dag.get( decodeCID(cid), - path, { + path, localResolve, timeout, signal @@ -82,11 +83,35 @@ class DAGService { return { remainderPath, value: encodeNode(value, transfer), transfer } } + /** + * @typedef {Object} ResolveQuery + * @property {EncodedCID|string} cid + * @property {string} [path] + * @property {number} [timeout] + * @property {AbortSignal} [signal] + * + * @typedef {Object} ResolveResult + * @property {EncodedCID} cid + * @property {string|void} remainderPath + * + * @param {ResolveQuery} query + * @returns {Promise} + */ + async resolve (query) { + const { cid, remainderPath } = + await this.ipfs.dag.resolve(decodePathOrCID(query.cid), query) + + return { + cid: encodeCID(cid), + remainderPath + } + } + /** * @typedef {Object} EnumerateDAG * @property {EncodedCID} cid - * @property {string} path - * @property {boolean} recursive + * @property {string} [path] + * @property {boolean} [recursive] * @property {number} [timeout] * @property {AbortSignal} [signal] * @@ -95,7 +120,8 @@ class DAGService { */ async tree (query) { const { cid, path, recursive, timeout, signal } = query - const result = await this.ipfs.dag.tree(decodeCID(cid), path, { + const result = await this.ipfs.dag.tree(decodeCID(cid), { + path, recursive, timeout, signal @@ -106,6 +132,18 @@ class DAGService { } } +/** + * @param {EncodedCID|string} input + * @returns {CID|string} + */ +const decodePathOrCID = (input) => { + if (typeof input === 'string') { + return input + } else { + return decodeCID(input) + } +} + /** * @param {EncodedDAGNode} value * @returns {DAGNode} diff --git a/packages/ipfs-message-port-server/src/ipfs.ts b/packages/ipfs-message-port-server/src/ipfs.ts index 13524b81fb..1963b17bcb 100644 --- a/packages/ipfs-message-port-server/src/ipfs.ts +++ b/packages/ipfs-message-port-server/src/ipfs.ts @@ -8,6 +8,7 @@ import { CIDVersion } from 'ipfs-message-port-protocol/src/data' import { EncodedCID } from './block' +import { ReadStream } from 'fs' type Mode = string | number export interface IPFS extends Core { @@ -34,25 +35,29 @@ interface PutOptions extends AbortOptions { } interface GetOptions extends AbortOptions { + path?: string, localResolve?: boolean } +interface ResolveOptions extends AbortOptions { + path?: string +} + interface TreeOptions extends AbortOptions { + path?: string, recursive?: boolean } export interface DAG { put(dagNode: DAGNode, options: PutOptions): Promise - get( - cid: CID, - path: string, - options: GetOptions - ): Promise<{ value: DAGNode; remainderPath: string }> - tree(cid: CID, path: string, options: TreeOptions): AsyncIterable + get(cid: CID, options: GetOptions): Promise<{ value: DAGNode; remainderPath: string }> + resolve(pathOrCID: string | CID, options: ResolveOptions): Promise<{ cid: CID, remainderPath: string }> + tree(cid: CID, options: TreeOptions): AsyncIterable } export interface Core { - add(inputs: AddInput, options: AddOptions): AsyncIterable + addAll(inputs: AddAllInput, options: AddOptions): AsyncIterable + add(input: AddInput, options: AddOptions): Promise cat(ipfsPath: CID | string, options: CatOptions): AsyncIterable } @@ -71,10 +76,10 @@ interface AddOptions extends AbortOptions { } export type FileInput = { - path: string - content: string | AsyncIterable - mode: string | number | void - mtime: { secs: number; nsecs?: number } | void + path?: string + content?: FileContent + mode?: string | number | void + mtime?: Time } export type FileOutput = { @@ -148,27 +153,18 @@ type WriteContent = | Blob | AsyncIterable -type AddInput = SingleFileInput | MultiFileInput - -type SingleFileInput = +type AddInput = + | Blob | string | ArrayBufferView | ArrayBuffer - | Blob - | FileObject - | Iterable - | Iterable - | Iterable - | AsyncIterable - | AsyncIterable + | FileInput + | ReadStream + -type MultiFileInput = - | Iterable - | Iterable - | Iterable - | AsyncIterable - | AsyncIterable - | AsyncIterable +type AddAllInput = + | Iterable + | AsyncIterable export type FileObject = { path?: string @@ -182,11 +178,8 @@ export type FileContent = | ArrayBufferView | ArrayBuffer | Blob - | Iterable - | Iterable - | Iterable - | AsyncIterable - | AsyncIterable + | Iterable + | AsyncIterable interface WriteOptions extends AbortOptions { offset?: number @@ -226,7 +219,7 @@ interface BlockService { ): Promise<{ cid: CID; size: number }> } -interface GetBlockOptions extends AbortOptions {} +interface GetBlockOptions extends AbortOptions { } interface PutBlockOptions extends AbortOptions { format?: string mhtype?: string @@ -243,4 +236,4 @@ interface RmBlockOptions extends AbortOptions { quiet?: boolean } -interface StatBlockOptions extends AbortOptions {} +interface StatBlockOptions extends AbortOptions { } From 84264a4c8fe72f40c8e5290c3545c352468706e0 Mon Sep 17 00:00:00 2001 From: Irakli Gozalishvili Date: Fri, 24 Jul 2020 12:31:04 -0700 Subject: [PATCH 50/63] chore: remove lerna.json from example --- examples/browser-sharing-node-across-tabs/lerna.json | 8 -------- 1 file changed, 8 deletions(-) delete mode 100644 examples/browser-sharing-node-across-tabs/lerna.json diff --git a/examples/browser-sharing-node-across-tabs/lerna.json b/examples/browser-sharing-node-across-tabs/lerna.json deleted file mode 100644 index 12ef44e049..0000000000 --- a/examples/browser-sharing-node-across-tabs/lerna.json +++ /dev/null @@ -1,8 +0,0 @@ -{ - "packages": [ - "../test-ipfs-example", - "../../packages/*", - "." - ], - "version": "independent" -} \ No newline at end of file From d1d37ae856d37d1677c6eb01056e4d6a41f7f6af Mon Sep 17 00:00:00 2001 From: Irakli Gozalishvili Date: Fri, 24 Jul 2020 12:42:50 -0700 Subject: [PATCH 51/63] chore: rever & disbale test for multifile ipfs.add --- packages/interface-ipfs-core/src/add.js | 19 +++++++-------- .../test/interface.spec.js | 24 +++++++++++++++++++ 2 files changed, 32 insertions(+), 11 deletions(-) diff --git a/packages/interface-ipfs-core/src/add.js b/packages/interface-ipfs-core/src/add.js index e2fb7a12f6..25a5a683d9 100644 --- a/packages/interface-ipfs-core/src/add.js +++ b/packages/interface-ipfs-core/src/add.js @@ -5,16 +5,13 @@ const { Buffer } = require('buffer') const { fixtures } = require('./utils') const { Readable } = require('readable-stream') const { supportsFileReader } = require('ipfs-utils/src/supports') -const urlSources = require('ipfs-utils/src/files/url-source') -const last = require('it-last') +const urlSource = require('ipfs-utils/src/files/url-source') const { isNode } = require('ipfs-utils/src/env') const { getDescribe, getIt, expect } = require('./utils/mocha') const testTimeout = require('./utils/test-timeout') const echoUrl = (text) => `${process.env.ECHO_SERVER}/download?data=${encodeURIComponent(text)}` const redirectUrl = (url) => `${process.env.ECHO_SERVER}/redirect?to=${encodeURI(url)}` -const urlSource = (url) => last(urlSources(url)) - /** @typedef { import("ipfsd-ctl/src/factory") } Factory */ /** * @param {Factory} common @@ -245,7 +242,7 @@ module.exports = (common, options) => { const url = echoUrl(text) const [result, expectedResult] = await Promise.all([ - ipfs.add(await urlSource(url)), + ipfs.add(urlSource(url)), ipfs.add(Buffer.from(text)) ]) @@ -260,7 +257,7 @@ module.exports = (common, options) => { const url = echoUrl(text) const [result, expectedResult] = await Promise.all([ - ipfs.add(await urlSource(redirectUrl(url))), + ipfs.add(urlSource(redirectUrl(url))), ipfs.add(Buffer.from(text)) ]) @@ -274,7 +271,7 @@ module.exports = (common, options) => { const text = `TEST${Math.random()}` const url = echoUrl(text) - const res = await ipfs.add(await urlSource(url), { onlyHash: true }) + const res = await ipfs.add(urlSource(url), { onlyHash: true }) await expect(ipfs.object.get(res.cid, { timeout: 500 })) .to.eventually.be.rejected() @@ -287,7 +284,7 @@ module.exports = (common, options) => { const addOpts = { wrapWithDirectory: true } const [result, expectedResult] = await Promise.all([ - ipfs.add(await urlSource(url), addOpts), + ipfs.add(urlSource(url), addOpts), ipfs.add({ path: 'download', content: Buffer.from(filename) }, addOpts) ]) expect(result.err).to.not.exist() @@ -301,8 +298,8 @@ module.exports = (common, options) => { const addOpts = { wrapWithDirectory: true } const [result, expectedResult] = await Promise.all([ - ipfs.add(await urlSource(url), addOpts), - ipfs.add({ path: 'download', content: Buffer.from(filename) }, addOpts) + ipfs.add(urlSource(url), addOpts), + ipfs.add([{ path: 'download', content: Buffer.from(filename) }], addOpts) ]) expect(result.err).to.not.exist() @@ -311,7 +308,7 @@ module.exports = (common, options) => { }) it('should not add from an invalid url', () => { - return expect(last(ipfs.addAll(urlSources('123http://invalid')))).to.eventually.be.rejected() + return expect(ipfs.add(urlSource('123http://invalid'))).to.eventually.be.rejected() }) it('should respect raw leaves when file is smaller than one block and no metadata is present', async () => { diff --git a/packages/ipfs-message-port-client/test/interface.spec.js b/packages/ipfs-message-port-client/test/interface.spec.js index e01cd40828..4d104983cd 100644 --- a/packages/ipfs-message-port-client/test/interface.spec.js +++ b/packages/ipfs-message-port-client/test/interface.spec.js @@ -67,6 +67,30 @@ describe('interface-ipfs-core tests', () => { { name: 'should cat with a Buffer multihash', reason: 'Passing CID as Buffer is not supported' + }, + { + name: 'should add from a HTTP URL', + reason: 'https://github.com/ipfs/js-ipfs/issues/3195' + }, + { + name: 'should add from a HTTP URL with redirection', + reason: 'https://github.com/ipfs/js-ipfs/issues/3195' + }, + { + name: 'should add from a URL with only-hash=true', + reason: 'https://github.com/ipfs/js-ipfs/issues/3195' + }, + { + name: 'should add from a URL with wrap-with-directory=true', + reason: 'https://github.com/ipfs/js-ipfs/issues/3195' + }, + { + name: 'should add from a URL with wrap-with-directory=true and URL-escaped file name', + reason: 'https://github.com/ipfs/js-ipfs/issues/3195' + }, + { + name: 'should not add from an invalid url', + reason: 'https://github.com/ipfs/js-ipfs/issues/3195' } ] }) From 7d3e35c138f32f87501214d898700052583dfd5c Mon Sep 17 00:00:00 2001 From: Irakli Gozalishvili Date: Fri, 24 Jul 2020 13:33:47 -0700 Subject: [PATCH 52/63] chore: revert changes to object.put tests --- packages/interface-ipfs-core/src/object/put.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/interface-ipfs-core/src/object/put.js b/packages/interface-ipfs-core/src/object/put.js index 63e210e2a3..8c84afc8d4 100644 --- a/packages/interface-ipfs-core/src/object/put.js +++ b/packages/interface-ipfs-core/src/object/put.js @@ -113,7 +113,7 @@ module.exports = (common, options) => { const cid = await ipfs.object.put(node1b) const node = await ipfs.object.get(cid) expect(node1b.Data).to.deep.equal(node.Data) - expect(node1b.Links).to.containSubset(node.Links) + expect(node1b.Links).to.deep.equal(node.Links) }) }) } From 6a8e65fc5e0245493f3682a281ae8aa104e0c5bf Mon Sep 17 00:00:00 2001 From: Irakli Gozalishvili Date: Fri, 24 Jul 2020 13:44:23 -0700 Subject: [PATCH 53/63] chore: consolidate imports --- packages/ipfs-message-port-client/src/core.js | 3 +-- packages/ipfs-message-port-client/src/files.js | 4 +--- packages/ipfs-message-port-protocol/src/dag.js | 3 +-- 3 files changed, 3 insertions(+), 7 deletions(-) diff --git a/packages/ipfs-message-port-client/src/core.js b/packages/ipfs-message-port-client/src/core.js index 5ede2e22d1..f01177441d 100644 --- a/packages/ipfs-message-port-client/src/core.js +++ b/packages/ipfs-message-port-client/src/core.js @@ -2,9 +2,8 @@ /* eslint-env browser */ -const CID = require('cids') const { Client } = require('./client') -const { encodeCID, decodeCID } = require('ipfs-message-port-protocol/src/cid') +const { encodeCID, decodeCID, CID } = require('ipfs-message-port-protocol/src/cid') const { decodeIterable, encodeIterable, diff --git a/packages/ipfs-message-port-client/src/files.js b/packages/ipfs-message-port-client/src/files.js index 9053ff322d..d274996849 100644 --- a/packages/ipfs-message-port-client/src/files.js +++ b/packages/ipfs-message-port-client/src/files.js @@ -1,10 +1,8 @@ 'use strict' /* eslint-env browser */ - -const CID = require('cids') const { Client } = require('./client') -const { decodeCID } = require('ipfs-message-port-protocol/src/cid') +const { decodeCID, CID } = require('ipfs-message-port-protocol/src/cid') /** * @typedef {import('ipfs-message-port-server/src/files').FilesService} FilesService diff --git a/packages/ipfs-message-port-protocol/src/dag.js b/packages/ipfs-message-port-protocol/src/dag.js index f45fdd70d7..467b68ce77 100644 --- a/packages/ipfs-message-port-protocol/src/dag.js +++ b/packages/ipfs-message-port-protocol/src/dag.js @@ -1,7 +1,6 @@ 'use strict' -const CID = require('cids') -const { encodeCID, decodeCID } = require('./cid') +const { encodeCID, decodeCID, CID } = require('./cid') /** * @typedef {import('./data').JSONValue} JSONValue From 5d8689ec441af23f432e47fe6ac7e7078613a1e5 Mon Sep 17 00:00:00 2001 From: Irakli Gozalishvili Date: Fri, 24 Jul 2020 13:52:27 -0700 Subject: [PATCH 54/63] chore: reduce bundle size --- packages/ipfs-message-port-client/.aegir.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/ipfs-message-port-client/.aegir.js b/packages/ipfs-message-port-client/.aegir.js index f3a31bb607..b24f1478c8 100644 --- a/packages/ipfs-message-port-client/.aegir.js +++ b/packages/ipfs-message-port-client/.aegir.js @@ -4,7 +4,7 @@ const EchoServer = require('aegir/utils/echo-server') const echoServer = new EchoServer() module.exports = { - bundlesize: { maxSize: '89kB' }, + bundlesize: { maxSize: '80kB' }, karma: { files: [ { From f0dd7582e6ccfd28227828ba8f5109b37a793e5b Mon Sep 17 00:00:00 2001 From: Irakli Gozalishvili Date: Fri, 24 Jul 2020 14:54:19 -0700 Subject: [PATCH 55/63] chore: remove redundant tests --- .../ipfs-message-port-client/test/dag.spec.js | 87 ------------------- 1 file changed, 87 deletions(-) delete mode 100644 packages/ipfs-message-port-client/test/dag.spec.js diff --git a/packages/ipfs-message-port-client/test/dag.spec.js b/packages/ipfs-message-port-client/test/dag.spec.js deleted file mode 100644 index aa2a612283..0000000000 --- a/packages/ipfs-message-port-client/test/dag.spec.js +++ /dev/null @@ -1,87 +0,0 @@ -/* eslint-env mocha */ -/* eslint max-nested-callbacks: ["error", 8] */ - -'use strict' - -const { Buffer } = require('buffer') -const { expect } = require('interface-ipfs-core/src/utils/mocha') -const { DAGNode } = require('ipld-dag-pb') -const { activate } = require('./util/client') - -describe('dag', function () { - this.timeout(10 * 1000) - let ipfs = null - before(() => { - ipfs = activate() - }) - - after(() => { - ipfs = null - }) - - // describe('get', () => { - // it('should throw error for invalid string CID input', () => { - // return expect(ipfs.dag.get('INVALID CID')) - // .to.eventually.be.rejected() - // .and.to.have.property('code') - // .that.equals('ERR_INVALID_CID') - // }) - - // // it('should throw error for invalid buffer CID input', () => { - // // return expect(ipfs.dag.get(Buffer.from('INVALID CID'))) - // // .to.eventually.be.rejected() - // // .and.to.have.property('code') - // // .that.equals('ERR_INVALID_CID') - // // }) - // }) - - // describe('tree', () => { - // it('should throw error for invalid CID input', () => { - // return expect(all(ipfs.dag.tree('INVALID CID'))) - // .to.eventually.be.rejected() - // .and.to.have.property('code') - // .that.equals('ERR_INVALID_CID') - // }) - // }) - - describe('ipfs.dag', () => { - it('should be able to put and get a DAG node with format dag-pb', async () => { - const data = Buffer.from('some data') - const { Data, Links } = new DAGNode(data) - const node = { Data, Links } - - let cid = await ipfs.dag.put(node, { - format: 'dag-pb', - hashAlg: 'sha2-256' - }) - cid = cid.toV0() - expect(cid.codec).to.equal('dag-pb') - // cid = cid.toBaseEncodedString('base58btc') - // expect(cid).to.equal('bafybeig3t3eugdchignsgkou3ly2mmy4ic4gtfor7inftnqn3yq4ws3a5u') - // expect(cid).to.equal('Qmd7xRhW5f29QuBFtqu3oSD27iVy35NRB91XFjmKFhtgMr') - - const result = await ipfs.dag.get(cid) - - expect(result.value.Data).to.deep.equal(data) - }) - - it('should be able to put and get a DAG node with format dag-cbor', async () => { - const cbor = { foo: 'dag-cbor-bar' } - let cid = await ipfs.dag.put(cbor, { - format: 'dag-cbor', - hashAlg: 'sha2-256' - }) - - expect(cid.codec).to.equal('dag-cbor') - // cid = cid.toBaseEncodedString('base32') - // expect(cid).to.equal( - // 'bafyreic6f672hnponukaacmk2mmt7vs324zkagvu4hcww6yba6kby25zce' - // ) - cid = cid.toV1() - - const result = await ipfs.dag.get(cid) - - expect(result.value).to.deep.equal(cbor) - }) - }) -}) From 115cc95c1de9f2ed0be3e157d9cc7167f4e639d5 Mon Sep 17 00:00:00 2001 From: Irakli Gozalishvili Date: Fri, 24 Jul 2020 16:22:34 -0700 Subject: [PATCH 56/63] chore: use browser-readablestream-to-it --- .../ipfs-message-port-client/package.json | 3 ++- packages/ipfs-message-port-client/src/core.js | 23 +++---------------- 2 files changed, 5 insertions(+), 21 deletions(-) diff --git a/packages/ipfs-message-port-client/package.json b/packages/ipfs-message-port-client/package.json index 8c97890f8f..0c9d877120 100644 --- a/packages/ipfs-message-port-client/package.json +++ b/packages/ipfs-message-port-client/package.json @@ -34,7 +34,8 @@ "dep-check": "aegir dep-check" }, "dependencies": { - "cids": "^0.8.3" + "cids": "^0.8.3", + "browser-readablestream-to-it": "~0.0.1" }, "devDependencies": { "ipfs-message-port-protocol": "~0.0.1", diff --git a/packages/ipfs-message-port-client/src/core.js b/packages/ipfs-message-port-client/src/core.js index f01177441d..603a63f168 100644 --- a/packages/ipfs-message-port-client/src/core.js +++ b/packages/ipfs-message-port-client/src/core.js @@ -9,6 +9,9 @@ const { encodeIterable, encodeCallback } = require('ipfs-message-port-protocol/src/core') +/** @type { (stream:ReadableStream) => AsyncIterable} */ +// @ts-ignore - browser-stream-to-it has not types +const iterateReadableStream = require('browser-readablestream-to-it') /** * @template T @@ -392,26 +395,6 @@ const encodeFileContent = (content, transfer) => { } } -/** - * @template T - * @param {ReadableStream} stream - * @returns {AsyncIterable} - */ - -const iterateReadableStream = async function * (stream) { - const reader = stream.getReader() - - while (true) { - const result = await reader.read() - - if (result.done) { - return - } - - yield result.value - } -} - /** * Pattern matches given input as `Iterable` and returns back either matched * iterable or `null`. From 906fafbe385e445c3e323cb37df1c2c4aca3b983 Mon Sep 17 00:00:00 2001 From: Irakli Gozalishvili Date: Fri, 24 Jul 2020 16:42:43 -0700 Subject: [PATCH 57/63] chore: adopt it-all instead of custom function --- packages/ipfs-message-port-server/package.json | 4 +++- packages/ipfs-message-port-server/src/dag.js | 2 +- packages/ipfs-message-port-server/src/util.js | 16 ---------------- 3 files changed, 4 insertions(+), 18 deletions(-) delete mode 100644 packages/ipfs-message-port-server/src/util.js diff --git a/packages/ipfs-message-port-server/package.json b/packages/ipfs-message-port-server/package.json index ac16c0001d..1d8d7277a2 100644 --- a/packages/ipfs-message-port-server/package.json +++ b/packages/ipfs-message-port-server/package.json @@ -34,10 +34,12 @@ "dep-check": "aegir dep-check" }, "dependencies": { - "cids": "^0.8.3" + "cids": "^0.8.3", + "it-all": "^1.0.2" }, "devDependencies": { "ipfs-message-port-protocol": "~0.0.1", + "@types/it-all": "^1.0.0", "ipfs": "^0.48.0", "aegir": "^23.0.0", "cross-env": "^7.0.0", diff --git a/packages/ipfs-message-port-server/src/dag.js b/packages/ipfs-message-port-server/src/dag.js index a4666855d6..68900f8a0a 100644 --- a/packages/ipfs-message-port-server/src/dag.js +++ b/packages/ipfs-message-port-server/src/dag.js @@ -1,8 +1,8 @@ 'use strict' -const { collect } = require('./util') const { encodeCID, decodeCID } = require('ipfs-message-port-protocol/src/cid') const { decodeNode, encodeNode } = require('ipfs-message-port-protocol/src/dag') +const collect = require('it-all') /** * @typedef {import('./ipfs').IPFS} IPFS diff --git a/packages/ipfs-message-port-server/src/util.js b/packages/ipfs-message-port-server/src/util.js deleted file mode 100644 index 9bdcf86052..0000000000 --- a/packages/ipfs-message-port-server/src/util.js +++ /dev/null @@ -1,16 +0,0 @@ -'use strict' - -/** - * @template T - * @param {AsyncIterable} input - * @returns {Promise} - */ -const collect = async input => { - const values = [] - for await (const value of input) { - values.push(value) - } - return values -} - -exports.collect = collect From f42cf5a1cb67c7750ece3380b077abc814275a4a Mon Sep 17 00:00:00 2001 From: Irakli Gozalishvili Date: Fri, 24 Jul 2020 17:02:11 -0700 Subject: [PATCH 58/63] chore: remove redundunt tests --- packages/ipfs-message-port-server/test/basic.spec.js | 2 -- 1 file changed, 2 deletions(-) diff --git a/packages/ipfs-message-port-server/test/basic.spec.js b/packages/ipfs-message-port-server/test/basic.spec.js index 424e4c90e5..fc90b4899d 100644 --- a/packages/ipfs-message-port-server/test/basic.spec.js +++ b/packages/ipfs-message-port-server/test/basic.spec.js @@ -12,7 +12,6 @@ describe('dag', function () { it('IPFSService', () => { expect(IPFSService).to.be.a('function') const service = new IPFSService() - expect(service).to.be.an.instanceOf(IPFSService) expect(service).to.have.property('dag') expect(service) .to.have.nested.property('dag.put') @@ -29,7 +28,6 @@ describe('dag', function () { const service = new IPFSService() const server = new Server(service) - expect(server).to.be.an.instanceOf(Server) expect(server) .to.have.property('connect') .be.a('function') From 678a061c8f5b02b02ae1e1b28549b15f5cfe11b3 Mon Sep 17 00:00:00 2001 From: Irakli Gozalishvili Date: Fri, 24 Jul 2020 17:03:24 -0700 Subject: [PATCH 59/63] chore: incorporate review edits --- packages/ipfs-message-port-client/README.md | 17 ++++++++-------- .../ipfs-message-port-client/src/client.js | 10 +++++----- packages/ipfs-message-port-protocol/README.md | 19 +++++++++++------- packages/ipfs-message-port-server/README.md | 20 +++++++++---------- 4 files changed, 36 insertions(+), 30 deletions(-) diff --git a/packages/ipfs-message-port-client/README.md b/packages/ipfs-message-port-client/README.md index 136bd3e8a0..f8e15ec7fb 100644 --- a/packages/ipfs-message-port-client/README.md +++ b/packages/ipfs-message-port-client/README.md @@ -38,13 +38,14 @@ It provides following API subset: - [`ipfs.dag`](https://github.com/ipfs/js-ipfs/blob/master/docs/core-api/DAG.md) - [`ipfs.block`](https://github.com/ipfs/js-ipfs/blob/master/docs/core-api/BLOCK.md) - [`ipfs.add`](https://github.com/ipfs/js-ipfs/blob/master/docs/core-api/FILES.md#ipfsadddata-options) +- [`ipfs.addAll`](https://github.com/ipfs/js-ipfs/blob/master/docs/core-api/FILES.md#ipfsaddallsource-options) - [`ipfs.cat`](https://github.com/ipfs/js-ipfs/blob/master/docs/core-api/FILES.md#ipfscatipfspath-options) - [`ipfs.files.stat`](https://github.com/ipfs/js-ipfs/blob/master/docs/core-api/FILES.md#ipfsfilesstatpath-options) -Client can be instantiated from the [`MessagePort`][] instance. Primary goal of -this library is to allow sharing a node across browsing contexts (tabs, iframes) -and therefore most likely `ipfs-message-port-server` will be in the separate JS -bundle and loaded in the [SharedWorker][]. +A client can be instantiated from the [`MessagePort`][] instance. The primary +goal of this library is to allow sharing a node across browsing contexts (tabs, +iframes) and therefore most likely `ipfs-message-port-server` will be in a +separate JS bundle and loaded in the [SharedWorker][]. ```js @@ -63,12 +64,12 @@ const main = async () => { } ``` -It is also possible to instantiate detached client, which can be attach it to -the server later on. This is useful when server port is received via message -from other JS context (e.g. iframe) +It is also possible to instantiate a detached client, which can be attached to +the server later on. This is useful when a server port is received via a message +from another JS context (e.g. iframe) > Note: Client will queue all API calls and only execute them once it is -> attached (unless they timeout or are aborted in the meantime). +> attached (unless they time out or are aborted in the meantime). ```js const IPFSClient = require('ipfs-message-port-client') diff --git a/packages/ipfs-message-port-client/src/client.js b/packages/ipfs-message-port-client/src/client.js index 70b46ddb50..2c39975009 100644 --- a/packages/ipfs-message-port-client/src/client.js +++ b/packages/ipfs-message-port-client/src/client.js @@ -74,7 +74,7 @@ class Query { * RPC Transport over `MessagePort` that can execute queries. It takes care of * executing queries by issuing a message with unique ID and fullfilling a * query when corresponding response message is received. It also makes sure - * that aborted / timed out queries are calcelled out as needed. + * that aborted / timed out queries are cancelled as needed. * * It is expected that there will be at most one transport for a message port * instance. @@ -120,7 +120,7 @@ class Transport { const id = `${this.id}@${this.nextID++}` this.queries[id] = query - // If query has a timeout is a timer. + // If query has a timeout set a timer. if (query.timeout > 0 && query.timeout < Infinity) { setTimeout(Transport.timeout, query.timeout, this, id) } @@ -141,7 +141,7 @@ class Transport { } /** - * Connects this transport to the given message port. Throws `RangeError` if + * Connects this transport to the given message port. Throws `Error` if * transport is already connected. All the pending queries will be executed * as connection occurs. * @@ -149,7 +149,7 @@ class Transport { */ connect (port) { if (this.port) { - throw new RangeError('Transport is already open') + throw new Error('Transport is already open') } else { this.port = port this.port.addEventListener('message', this) @@ -206,7 +206,7 @@ class Transport { /** * Aborts this query by failing with `AbortError` and sending an abort message - * to the server. If query is no longen pending this has no effect. + * to the server. If query is no longer pending this has no effect. * @param {string} id */ abort (id) { diff --git a/packages/ipfs-message-port-protocol/README.md b/packages/ipfs-message-port-protocol/README.md index f136be378c..d4d32fe9be 100644 --- a/packages/ipfs-message-port-protocol/README.md +++ b/packages/ipfs-message-port-protocol/README.md @@ -36,9 +36,9 @@ $ npm install --save ipfs-message-port-protocol ## Wire protocol codecs -Library provides encode / decode functions for types that are not supported by [structured cloning algorithm][] and therefore need to be encoded before posted over [message channel][] and decoded on the other end. +This module provides encode / decode functions for types that are not supported by [structured cloning algorithm][] and therefore need to be encoded before being posted over the [message channel][] and decoded on the other end. -All encoders take optional `transfer` array. If provided, encoder will add all `Transferable` fields of the given value so the they could be moved across threads without copying. +All encoders take an optional `transfer` array. If provided, the encoder will add all `Transferable` fields of the given value so they can be moved across threads without copying. ### `CID` @@ -51,7 +51,7 @@ const cid = new CID('bafybeig6xv5nwphfmvcnektpnojts33jqcuam7bmye2pb54adnrtccjlsu const { port1, port2 } = new MessageChannel() -// Will copy underyling memory +// Will copy underlying memory port1.postMessage(encodeCID(cid)) // Will transfer underlying memory (cid is corrupt on this thread) @@ -78,7 +78,7 @@ const block = new Block(data, cid) const { port1, port2 } = new MessageChannel() -// Will copy underyling memory +// Will copy underlying memory port1.postMessage(encodeBlock(block)) // Will transfer underlying memory (block & cid will be corrupt on this thread) @@ -106,7 +106,7 @@ const dagNode = { hi: 'hello', link: cid } const { port1, port2 } = new MessageChannel() -// Will copy underyling memory +// Will copy underlying memory port1.postMessage(encodeNode(dagNode)) // Will transfer underlying memory (`dagNode.link` will be corrupt on this thread) @@ -123,7 +123,12 @@ port2.onmessage = ({data}) => { ### AsyncIterable -Encoder allows producer to encode [async iterables][] such that it can be transferred across threads and decoded by a consumer on the other end and take care of all the IO coordination between two. Unlike other encoders `transfer` argument is mandatory (because value is encoded to a [MessagePort][] that can only be transferred). Additionally encoder / decoder take item encoder / decoder functions to encode each item of the async iterable. +This encoder encodes [async iterables][] such that they can be transferred +across threads and decoded by a consumer on the other end while taking care of +all the IO coordination between two. It needs to be provided `encoder` / +`decoder` function to encode / decode each yielded item of the async iterable. +Unlike other encoders the `transfer` argument is mandatory (because async +iterable is encoded to a [MessagePort][] that can only be transferred). ```js @@ -143,7 +148,7 @@ const { port1, port2 } = new MessageChannel() } -// Will transfer each chunk to the reciever thread (corrupting it on this thread) +// Will transfer each chunk to the receiver thread (corrupting it on this thread) { const transfer = [] port1.postMessage( diff --git a/packages/ipfs-message-port-server/README.md b/packages/ipfs-message-port-server/README.md index 0189c02a00..63f9365c66 100644 --- a/packages/ipfs-message-port-server/README.md +++ b/packages/ipfs-message-port-server/README.md @@ -32,9 +32,9 @@ $ npm install --save ipfs-message-port-server ## Usage -This library can wrap JS IPFS node and expose it over the [message channel][]. +This library can wrap a JS IPFS node and expose it over the [message channel][]. It assumes `ipfs-message-port-client` on the other end, however it is not -strictly necessary anything compling with wire protocol will do. +strictly necessary anything complying with the wire protocol will do. It provides following API subset: @@ -44,9 +44,9 @@ It provides following API subset: - [`ipfs.cat`](https://github.com/ipfs/js-ipfs/blob/master/docs/core-api/FILES.md#ipfscatipfspath-options) - [`ipfs.files.stat`](https://github.com/ipfs/js-ipfs/blob/master/docs/core-api/FILES.md#ipfsfilesstatpath-options) -Server is designed to run in the [SharedWorker][] (although it is possible to -run it in the other JS contexts). Example below illustrates running js-ipfs -node in [SharedWorker][] and exposing it to all connected ports +The server is designed to run in a [SharedWorker][] (although it is possible to +run it in the other JS contexts). The example below illustrates running a js-ipfs +node in a [SharedWorker][] and exposing it to all connected ports ```js const IPFS = require('ipfs') @@ -74,13 +74,13 @@ main() ### Notes on Performance -Since the data over [message channel][] is copied via -[structured cloning algorithm][] it may lead to suboptimal -results (espacially with large binary data). In order to avoid unecessary -copying server will transfer all the [Transferable][] which will be emptied +Since the data sent over the [message channel][] is copied via +the [structured cloning algorithm][] it may lead to suboptimal +results (especially with large binary data). In order to avoid unnecessary +copying the server will transfer all passed [Transferable][]s which will be emptied on the server side. This should not be a problem in general as IPFS node itself does not retain references to returned values, but is something to keep in mind -when doig something custom. +when doing something custom. [message channel]:https://developer.mozilla.org/en-US/docs/Web/API/MessageChannel From 77ef623e3860dde1bbf08754e9f09958fbb58eef Mon Sep 17 00:00:00 2001 From: Irakli Gozalishvili Date: Fri, 24 Jul 2020 17:08:06 -0700 Subject: [PATCH 60/63] chore: update my email address --- packages/ipfs-message-port-protocol/package.json | 2 +- packages/ipfs-message-port-server/package.json | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/packages/ipfs-message-port-protocol/package.json b/packages/ipfs-message-port-protocol/package.json index f986102dee..68520d9ff7 100644 --- a/packages/ipfs-message-port-protocol/package.json +++ b/packages/ipfs-message-port-protocol/package.json @@ -45,6 +45,6 @@ "npm": ">=3.0.0" }, "contributors": [ - "Irakli Gozalishvili " + "Irakli Gozalishvili " ] } \ No newline at end of file diff --git a/packages/ipfs-message-port-server/package.json b/packages/ipfs-message-port-server/package.json index 1d8d7277a2..84b98c15bf 100644 --- a/packages/ipfs-message-port-server/package.json +++ b/packages/ipfs-message-port-server/package.json @@ -50,6 +50,6 @@ "npm": ">=3.0.0" }, "contributors": [ - "Irakli Gozalishvili " + "Irakli Gozalishvili " ] } \ No newline at end of file From 3ed0764e29e2c0206ef31dc6c5a59911559c4383 Mon Sep 17 00:00:00 2001 From: Irakli Gozalishvili Date: Fri, 24 Jul 2020 17:09:11 -0700 Subject: [PATCH 61/63] fix: cancel timers on request success/failure --- packages/ipfs-message-port-client/src/client.js | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-) diff --git a/packages/ipfs-message-port-client/src/client.js b/packages/ipfs-message-port-client/src/client.js index 2c39975009..a15ae0241c 100644 --- a/packages/ipfs-message-port-client/src/client.js +++ b/packages/ipfs-message-port-client/src/client.js @@ -48,6 +48,8 @@ class Query { this.namespace = namespace this.method = method this.timeout = input.timeout == null ? Infinity : input.timeout + /** @type {number|null} */ + this.timerID = null }) } @@ -122,7 +124,7 @@ class Transport { // If query has a timeout set a timer. if (query.timeout > 0 && query.timeout < Infinity) { - setTimeout(Transport.timeout, query.timeout, this, id) + query.timerID = setTimeout(Transport.timeout, query.timeout, this, id) } if (query.signal) { @@ -214,10 +216,15 @@ class Transport { const query = queries[id] if (query) { delete queries[id] + query.fail(new AbortError()) if (this.port) { this.port.postMessage({ type: 'abort', id }) } + + if (query.timerID != null) { + clearTimeout(query.timerID) + } } } @@ -258,6 +265,10 @@ class Transport { } else { query.fail(decodeError(result.error)) } + + if (query.timerID != null) { + clearTimeout(query.timerID) + } } } } From cb011b56c1dc61fd14d2eaf16c90926cb98c6921 Mon Sep 17 00:00:00 2001 From: Irakli Gozalishvili Date: Fri, 24 Jul 2020 17:31:26 -0700 Subject: [PATCH 62/63] chore: align dependency versions --- examples/browser-sharing-node-across-tabs/package.json | 4 ++-- examples/traverse-ipld-graphs/package.json | 4 ++-- packages/ipfs-http-client/package.json | 2 +- packages/ipfs-message-port-client/package.json | 2 +- packages/ipfs-message-port-server/package.json | 2 +- 5 files changed, 7 insertions(+), 7 deletions(-) diff --git a/examples/browser-sharing-node-across-tabs/package.json b/examples/browser-sharing-node-across-tabs/package.json index 17f7fe65df..36d4b7c6c3 100644 --- a/examples/browser-sharing-node-across-tabs/package.json +++ b/examples/browser-sharing-node-across-tabs/package.json @@ -17,9 +17,9 @@ "babel-loader": "^8.0.5", "copy-webpack-plugin": "^5.0.4", "test-ipfs-example": "^2.0.3", - "webpack": "^4.28.4", + "webpack": "^4.43.0", "webpack-cli": "^3.3.11", - "webpack-dev-server": "^3.1.14", + "webpack-dev-server": "^3.11.0", "worker-plugin": "4.0.3" }, "dependencies": { diff --git a/examples/traverse-ipld-graphs/package.json b/examples/traverse-ipld-graphs/package.json index 38aa703f5b..a8d8aeb85f 100644 --- a/examples/traverse-ipld-graphs/package.json +++ b/examples/traverse-ipld-graphs/package.json @@ -15,8 +15,8 @@ "dependencies": { "cids": "^0.8.3", "ipfs": "^0.48.0", - "ipld-block": "^0.9.1", - "ipld-dag-pb": "^0.18.5", + "ipld-block": "^0.9.2", + "ipld-dag-pb": "^0.19.0", "multihashing-async": "^1.0.0" } } diff --git a/packages/ipfs-http-client/package.json b/packages/ipfs-http-client/package.json index 9696897fba..866c14c333 100644 --- a/packages/ipfs-http-client/package.json +++ b/packages/ipfs-http-client/package.json @@ -67,7 +67,7 @@ "nanoid": "^3.0.2", "node-fetch": "^2.6.0", "parse-duration": "^0.4.4", - "stream-to-it": "^0.2.0" + "stream-to-it": "^0.2.1" }, "devDependencies": { "aegir": "^23.0.0", diff --git a/packages/ipfs-message-port-client/package.json b/packages/ipfs-message-port-client/package.json index 0c9d877120..350a97ffec 100644 --- a/packages/ipfs-message-port-client/package.json +++ b/packages/ipfs-message-port-client/package.json @@ -35,7 +35,7 @@ }, "dependencies": { "cids": "^0.8.3", - "browser-readablestream-to-it": "~0.0.1" + "browser-readablestream-to-it": "0.0.1" }, "devDependencies": { "ipfs-message-port-protocol": "~0.0.1", diff --git a/packages/ipfs-message-port-server/package.json b/packages/ipfs-message-port-server/package.json index 84b98c15bf..7ffe733aa9 100644 --- a/packages/ipfs-message-port-server/package.json +++ b/packages/ipfs-message-port-server/package.json @@ -35,7 +35,7 @@ }, "dependencies": { "cids": "^0.8.3", - "it-all": "^1.0.2" + "it-all": "^1.0.1" }, "devDependencies": { "ipfs-message-port-protocol": "~0.0.1", From 55acadf9e84bd5b22fac5c604e34dfe327005b19 Mon Sep 17 00:00:00 2001 From: Irakli Gozalishvili Date: Fri, 24 Jul 2020 18:03:09 -0700 Subject: [PATCH 63/63] fix: use it-all instead of removed util --- packages/ipfs-message-port-server/src/block.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/ipfs-message-port-server/src/block.js b/packages/ipfs-message-port-server/src/block.js index f669a10bae..5078ad5a61 100644 --- a/packages/ipfs-message-port-server/src/block.js +++ b/packages/ipfs-message-port-server/src/block.js @@ -1,7 +1,7 @@ 'use strict' const { Buffer } = require('buffer') -const { collect } = require('./util') +const collect = require('it-all') const { encodeError } = require('ipfs-message-port-protocol/src/error') const { decodeCID, encodeCID } = require('ipfs-message-port-protocol/src/cid') const {