@ethersphere/bee-js 3.2.0 → 3.3.0

package/dist/cjs/utils/hex.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertPrefixedHexString = exports.assertHexString = exports.isPrefixedHexString = exports.isHexString = exports.intToHex = exports.bytesToHex = exports.hexToBytes = exports.makeHexString = void 0;
+const bytes_1 = require("./bytes");
+/**
+ * Creates unprefixed hex string from wide range of data.
+ *
+ * TODO: Make Length mandatory: https://github.com/ethersphere/bee-js/issues/208
+ *
+ * @param input
+ * @param len of the resulting HexString WITHOUT prefix!
+ */
+function makeHexString(input, len) {
+    if (typeof input === 'number') {
+        return intToHex(input, len);
+    }
+    if (input instanceof Uint8Array) {
+        return bytesToHex(input, len);
+    }
+    if (typeof input === 'string') {
+        if (isPrefixedHexString(input)) {
+            const hex = input.slice(2);
+            if (len && hex.length !== len) {
+                throw new TypeError(`Length mismatch for valid hex string. Expecting length ${len}: ${hex}`);
+            }
+            return hex;
+        }
+        else {
+            // We use assertHexString() as there might be more reasons why a string is not valid hex string
+            // and usage of isHexString() would not give enough information to the user on what is going
+            // wrong.
+            assertHexString(input, len);
+            return input;
+        }
+    }
+    throw new TypeError('Not HexString compatible type!');
+}
+exports.makeHexString = makeHexString;
+/**
+ * Converts a hex string to Uint8Array
+ *
+ * @param hex string input without 0x prefix!
+ */
+function hexToBytes(hex) {
+    assertHexString(hex);
+    const bytes = (0, bytes_1.makeBytes)(hex.length / 2);
+    for (let i = 0; i < bytes.length; i++) {
+        const hexByte = hex.substr(i * 2, 2);
+        bytes[i] = parseInt(hexByte, 16);
+    }
+    return bytes;
+}
+exports.hexToBytes = hexToBytes;
+/**
+ * Converts array of number or Uint8Array to HexString without prefix.
+ *
+ * @param bytes   The input array
+ * @param len     The length of the non prefixed HexString
+ */
+function bytesToHex(bytes, len) {
+    const hexByte = (n) => n.toString(16).padStart(2, '0');
+    const hex = Array.from(bytes, hexByte).join('');
+    // TODO: Make Length mandatory: https://github.com/ethersphere/bee-js/issues/208
+    if (len && hex.length !== len) {
+        throw new TypeError(`Resulting HexString does not have expected length ${len}: ${hex}`);
+    }
+    return hex;
+}
+exports.bytesToHex = bytesToHex;
+/**
+ * Converts integer number to hex string.
+ *
+ * Optionally provides '0x' prefix or padding
+ *
+ * @param int         The positive integer to be converted
+ * @param len     The length of the non prefixed HexString
+ */
+function intToHex(int, len) {
+    if (!Number.isInteger(int))
+        throw new TypeError('the value provided is not integer');
+    if (int > Number.MAX_SAFE_INTEGER)
+        throw new TypeError('the value provided exceeds safe integer');
+    if (int < 0)
+        throw new TypeError('the value provided is a negative integer');
+    const hex = int.toString(16);
+    // TODO: Make Length mandatory: https://github.com/ethersphere/bee-js/issues/208
+    if (len && hex.length !== len) {
+        throw new TypeError(`Resulting HexString does not have expected length ${len}: ${hex}`);
+    }
+    return hex;
+}
+exports.intToHex = intToHex;
+/**
+ * Type guard for HexStrings.
+ * Requires no 0x prefix!
+ *
+ * TODO: Make Length mandatory: https://github.com/ethersphere/bee-js/issues/208
+ *
+ * @param s string input
+ * @param len expected length of the HexString
+ */
+function isHexString(s, len) {
+    return typeof s === 'string' && /^[0-9a-f]+$/i.test(s) && (!len || s.length === len);
+}
+exports.isHexString = isHexString;
+/**
+ * Type guard for PrefixedHexStrings.
+ * Does enforce presence of 0x prefix!
+ *
+ * @param s string input
+ */
+function isPrefixedHexString(s) {
+    return typeof s === 'string' && /^0x[0-9a-f]+$/i.test(s);
+}
+exports.isPrefixedHexString = isPrefixedHexString;
+/**
+ * Verifies if the provided input is a HexString.
+ *
+ * TODO: Make Length mandatory: https://github.com/ethersphere/bee-js/issues/208
+ *
+ * @param s string input
+ * @param len expected length of the HexString
+ * @param name optional name for the asserted value
+ * @returns HexString or throws error
+ */
+function assertHexString(s, len, name = 'value') {
+    if (!isHexString(s, len)) {
+        if (isPrefixedHexString(s)) {
+            throw new TypeError(`${name} not valid non prefixed hex string (has 0x prefix): ${s}`);
+        }
+        // Don't display length error if no length specified in order not to confuse user
+        const lengthMsg = len ? ` of length ${len}` : '';
+        throw new TypeError(`${name} not valid hex string${lengthMsg}: ${s}`);
+    }
+}
+exports.assertHexString = assertHexString;
+/**
+ * Verifies if the provided input is a PrefixedHexString.
+ *
+ * @param s string input
+ * @param len expected length of the HexString
+ * @param name optional name for the asserted value
+ * @returns HexString or throws error
+ */
+function assertPrefixedHexString(s, name = 'value') {
+    if (!isPrefixedHexString(s)) {
+        throw new TypeError(`${name} not valid prefixed hex string: ${s}`);
+    }
+}
+exports.assertPrefixedHexString = assertPrefixedHexString;

package/dist/cjs/utils/http.js

@@ -0,0 +1,166 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeDefaultKy = exports.http = exports.filterHeaders = exports.wrapResponseClosure = exports.wrapRequestClosure = void 0;
+const error_1 = require("./error");
+const ky_universal_1 = __importDefault(require("ky-universal"));
+const stream_1 = require("./stream");
+const merge_1 = require("./merge");
+const type_1 = require("./type");
+const DEFAULT_KY_CONFIG = {
+    headers: {
+        accept: 'application/json, text/plain, */*',
+        'user-agent': `bee-js`,
+    },
+};
+function isHttpError(e) {
+    return (0, type_1.isObject)(e) && typeof e.response !== 'undefined';
+}
+function isHttpRequestError(e) {
+    return (0, type_1.isObject)(e) && typeof e.request !== 'undefined';
+}
+function headersToObject(header) {
+    return [...header.entries()].reduce((obj, [key, val]) => {
+        obj[key] = val;
+        return obj;
+    }, {});
+}
+function wrapRequest(request) {
+    return {
+        url: request.url,
+        method: request.method.toUpperCase(),
+        headers: headersToObject(request.headers),
+    };
+}
+function wrapRequestClosure(cb) {
+    return (request) => __awaiter(this, void 0, void 0, function* () {
+        yield cb(wrapRequest(request));
+    });
+}
+exports.wrapRequestClosure = wrapRequestClosure;
+function wrapResponseClosure(cb) {
+    return (request, options, response) => __awaiter(this, void 0, void 0, function* () {
+        yield cb({
+            headers: headersToObject(response.headers),
+            status: response.status,
+            statusText: response.statusText,
+            request: wrapRequest(request),
+        });
+    });
+}
+exports.wrapResponseClosure = wrapResponseClosure;
+/**
+ * Filters out entries that has undefined value from headers object.
+ * Modifies the original object!
+ *
+ * @param obj
+ */
+// eslint-disable-next-line @typescript-eslint/ban-types
+function filterHeaders(obj) {
+    if (obj === undefined) {
+        return undefined;
+    }
+    (0, type_1.isStrictlyObject)(obj);
+    const typedObj = obj;
+    for (const key in typedObj) {
+        if (typedObj[key] === undefined) {
+            delete typedObj[key];
+        }
+    }
+    if (Object.keys(typedObj).length === 0) {
+        return undefined;
+    }
+    return typedObj;
+}
+exports.filterHeaders = filterHeaders;
+/**
+ * Main utility function to make HTTP requests.
+ * @param ky
+ * @param config
+ */
+function http(ky, config) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const { path, responseType } = config, kyConfig = __rest(config, ["path", "responseType"]);
+            const response = (yield ky(path, Object.assign(Object.assign({}, kyConfig), { searchParams: filterHeaders(kyConfig.searchParams) })));
+            switch (responseType) {
+                case 'stream':
+                    if (!response.body) {
+                        throw new error_1.BeeError('Response was expected to get data but did not get any!');
+                    }
+                    response.data = (0, stream_1.normalizeToReadableStream)(response.body);
+                    break;
+                case 'arraybuffer':
+                    response.data = (yield response.arrayBuffer());
+                    break;
+                case 'json':
+                    try {
+                        response.data = (yield response.json());
+                    }
+                    catch (e) {
+                        throw new error_1.BeeNotAJsonError();
+                    }
+                    break;
+                default:
+                    break; // If responseType is not set, then no data are expected
+            }
+            return response;
+        }
+        catch (e) {
+            // Passthrough thrown errors
+            if (e instanceof error_1.BeeNotAJsonError) {
+                throw e;
+            }
+            if (isHttpError(e)) {
+                let message;
+                // We store the response body here as it can be read only once in Response's lifecycle so to make it exposed
+                // to the user in the BeeResponseError, for further analysis.
+                const body = yield e.response.text();
+                try {
+                    // The response can be Bee's JSON with structure `{code, message}` lets try to parse it
+                    message = JSON.parse(body).message;
+                }
+                catch (e) { }
+                if (message) {
+                    throw new error_1.BeeResponseError(e.response.status, e.response, body, config, `${e.response.statusText}: ${message}`);
+                }
+                else {
+                    throw new error_1.BeeResponseError(e.response.status, e.response, body, config, e.response.statusText);
+                }
+            }
+            else if (isHttpRequestError(e)) {
+                throw new error_1.BeeRequestError(e.message, config);
+            }
+            else {
+                throw new error_1.BeeError(e.message);
+            }
+        }
+    });
+}
+exports.http = http;
+function makeDefaultKy(kyConfig) {
+    return ky_universal_1.default.create((0, merge_1.deepMerge)(DEFAULT_KY_CONFIG, kyConfig));
+}
+exports.makeDefaultKy = makeDefaultKy;

package/dist/cjs/utils/merge.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deepMerge = void 0;
+const type_1 = require("./type");
+/**
+ * Function that deep merges objects
+ *
+ * @copyright https://github.com/sindresorhus/ky/blob/b3c9e88fa49d50150dbb6e6b771b4af56cb40c98/source/utils/merge.ts
+ * @licence MIT
+ * @param sources
+ */
+function deepMerge(...sources) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let returnValue = {};
+    for (const source of sources) {
+        if (Array.isArray(source)) {
+            if (!Array.isArray(returnValue)) {
+                returnValue = [];
+            }
+            returnValue = [...returnValue, ...source];
+        }
+        else if ((0, type_1.isObject)(source)) {
+            // eslint-disable-next-line prefer-const
+            for (let [key, value] of Object.entries(source)) {
+                if ((0, type_1.isObject)(value) && key in returnValue) {
+                    value = deepMerge(returnValue[key], value);
+                }
+                returnValue = Object.assign(Object.assign({}, returnValue), { [key]: value });
+            }
+        }
+    }
+    return returnValue;
+}
+exports.deepMerge = deepMerge;

package/dist/cjs/utils/pss.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMaxTarget = void 0;
+const types_1 = require("../types");
+/**
+ * Utility function that for given strings/reference takes the most specific
+ * target that Bee node will except.
+ *
+ * @param target is a non-prefixed hex string Bee address
+ * @see [Bee docs - PSS](https://docs.ethswarm.org/docs/dapps-on-swarm/pss)
+ */
+function makeMaxTarget(target) {
+    if (typeof target !== 'string') {
+        throw new TypeError('target has to be an string!');
+    }
+    return target.slice(0, types_1.PSS_TARGET_HEX_LENGTH_MAX);
+}
+exports.makeMaxTarget = makeMaxTarget;

package/dist/cjs/utils/stamps.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStampUsage = void 0;
+/**
+ * Utility function that calculates usage of postage batch based on its utilization, depth and bucket depth.
+ *
+ * Be aware for small depths (17, 18) this does not provide that much information as the provided set of distinct values
+ * is small.
+ *
+ * @param utilization
+ * @param depth
+ * @param bucketDepth
+ */
+function getStampUsage({ utilization, depth, bucketDepth }) {
+    return utilization / Math.pow(2, depth - bucketDepth);
+}
+exports.getStampUsage = getStampUsage;

package/dist/cjs/utils/stream.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeToReadableStream = exports.readableWebToNode = exports.readableNodeToWeb = exports.isNodeReadable = exports.isReadableStream = exports.isReadable = void 0;
+const type_1 = require("./type");
+const ponyfill_1 = require("web-streams-polyfill/ponyfill");
+const readable_stream_1 = require("readable-stream");
+/**
+ * Validates if passed object is either browser's ReadableStream
+ * or Node's Readable.
+ *
+ * @param entry
+ */
+function isReadable(entry) {
+    return isReadableStream(entry) || isNodeReadable(entry);
+}
+exports.isReadable = isReadable;
+function isReadableStream(entry) {
+    if (!(0, type_1.isStrictlyObject)(entry)) {
+        return false;
+    }
+    const browserReadable = entry;
+    if (typeof browserReadable.getReader === 'function' &&
+        browserReadable.locked !== undefined &&
+        typeof browserReadable.cancel === 'function' &&
+        typeof browserReadable.pipeTo === 'function' &&
+        typeof browserReadable.pipeThrough === 'function') {
+        return true;
+    }
+    return false;
+}
+exports.isReadableStream = isReadableStream;
+function isNodeReadable(entry) {
+    if (!(0, type_1.isStrictlyObject)(entry)) {
+        return false;
+    }
+    const nodeReadable = entry;
+    if (typeof nodeReadable.pipe === 'function' && nodeReadable.readable && typeof nodeReadable._read === 'function') {
+        return true;
+    }
+    return false;
+}
+exports.isNodeReadable = isNodeReadable;
+/**
+ * Function that converts Node's Readable into WHATWG ReadableStream
+ *
+ * Taken over from https://github.com/gwicke/node-web-streams/blob/master/lib/conversions.js
+ * Because it uses forked web-streams-polyfill that are outdated.
+ *
+ * @author https://github.com/gwicke
+ * @licence Apache License 2.0 https://github.com/gwicke/node-web-streams/blob/master/LICENSE
+ * @param nodeStream
+ */
+function readableNodeToWeb(nodeStream) {
+    return new ponyfill_1.ReadableStream({
+        start(controller) {
+            nodeStream.pause();
+            nodeStream.on('data', chunk => {
+                if (Buffer.isBuffer(chunk)) {
+                    controller.enqueue(new Uint8Array(chunk.buffer));
+                }
+                else {
+                    controller.enqueue(chunk);
+                }
+                nodeStream.pause();
+            });
+            nodeStream.on('end', () => controller.close());
+            nodeStream.on('error', e => controller.error(e));
+        },
+        pull() {
+            nodeStream.resume();
+        },
+        cancel() {
+            nodeStream.pause();
+        },
+    });
+}
+exports.readableNodeToWeb = readableNodeToWeb;
+/**
+ * Taken over from https://github.com/gwicke/node-web-streams/blob/master/lib/conversions.js
+ * Because it uses forked web-streams-polyfill that are outdated.
+ *
+ * @author https://github.com/gwicke
+ * @licence Apache License 2.0 https://github.com/gwicke/node-web-streams/blob/master/LICENSE
+ */
+class NodeReadableWrapper extends readable_stream_1.Readable {
+    constructor(webStream, options) {
+        super(options);
+        this._webStream = webStream;
+        this._reader = webStream.getReader();
+        this._reading = false;
+    }
+    _read() {
+        if (this._reading) {
+            return;
+        }
+        this._reading = true;
+        const doRead = () => {
+            this._reader.read().then(res => {
+                if (res.done) {
+                    this.push(null);
+                    return;
+                }
+                if (this.push(res.value)) {
+                    return doRead();
+                }
+                else {
+                    this._reading = false;
+                }
+            });
+        };
+        doRead();
+    }
+}
+/**
+ * Function that converts WHATWG ReadableStream into Node's Readable
+ *
+ * Taken over from https://github.com/gwicke/node-web-streams/blob/master/lib/conversions.js
+ * Because it uses forked web-streams-polyfill that are outdated.
+ *
+ * @author https://github.com/gwicke
+ * @licence Apache License 2.0 https://github.com/gwicke/node-web-streams/blob/master/LICENSE
+ * @param webStream
+ */
+function readableWebToNode(webStream, options) {
+    return new NodeReadableWrapper(webStream, options);
+}
+exports.readableWebToNode = readableWebToNode;
+function normalizeToReadableStream(stream) {
+    if (isNodeReadable(stream)) {
+        return readableNodeToWeb(stream);
+    }
+    else if (isReadableStream(stream)) {
+        return stream;
+    }
+    throw new TypeError('Passed stream is not Node Readable nor ReadableStream!');
+}
+exports.normalizeToReadableStream = normalizeToReadableStream;

package/dist/cjs/utils/tar.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeTar = void 0;
+const tar_js_1 = __importDefault(require("tar-js"));
+// converts a string to utf8 Uint8Array and returns it as a string-like
+// object that `tar.append` accepts as path
+function fixUnicodePath(path) {
+    const codes = new TextEncoder().encode(path);
+    return {
+        length: codes.length,
+        charCodeAt: index => codes[index],
+    };
+}
+function makeTar(data) {
+    const tar = new tar_js_1.default();
+    for (const entry of data) {
+        const path = fixUnicodePath(entry.path);
+        tar.append(path, entry.data);
+    }
+    return tar.out;
+}
+exports.makeTar = makeTar;