@ethersphere/bee-js 3.2.0 → 3.3.2-pre.0

package/dist/mjs/utils/headers.js

@@ -0,0 +1,58 @@
+import { BeeError } from "./error.js";
+/**
+ * Read the filename from the content-disposition header
+ * See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Disposition
+ *
+ * @param header the content-disposition header value
+ *
+ * @returns the filename
+ */
+
+function readContentDispositionFilename(header) {
+  if (!header) {
+    throw new BeeError('missing content-disposition header');
+  } // Regex was found here
+  // https://stackoverflow.com/questions/23054475/javascript-regex-for-extracting-filename-from-content-disposition-header
+
+
+  const dispositionMatch = header.match(/filename\*?=['"]?(?:UTF-\d['"]*)?([^;\r\n"']*)['"]?;?/i);
+
+  if (dispositionMatch && dispositionMatch.length > 0) {
+    return dispositionMatch[1];
+  }
+
+  throw new BeeError('invalid content-disposition header');
+}
+
+function readTagUid(header) {
+  if (!header) {
+    return undefined;
+  }
+
+  return parseInt(header, 10);
+}
+
+export function readFileHeaders(headers) {
+  const name = readContentDispositionFilename(headers.get('content-disposition'));
+  const tagUid = readTagUid(headers.get('swarm-tag-uid'));
+  const contentType = headers.get('content-type') || undefined;
+  return {
+    name,
+    tagUid,
+    contentType
+  };
+}
+export function extractUploadHeaders(postageBatchId, options) {
+  if (!postageBatchId) {
+    throw new BeeError('Postage BatchID has to be specified!');
+  }
+
+  const headers = {
+    'swarm-postage-batch-id': postageBatchId
+  };
+  if (options?.pin) headers['swarm-pin'] = String(options.pin);
+  if (options?.encrypt) headers['swarm-encrypt'] = String(options.encrypt);
+  if (options?.tag) headers['swarm-tag'] = String(options.tag);
+  if (typeof options?.deferred === 'boolean') headers['swarm-deferred-upload'] = options.deferred.toString();
+  return headers;
+}

package/dist/mjs/utils/hex.js

@@ -0,0 +1,154 @@
+import { makeBytes } from "./bytes.js";
+/**
+ * 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!
+ */
+
+export 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!');
+}
+/**
+ * Converts a hex string to Uint8Array
+ *
+ * @param hex string input without 0x prefix!
+ */
+
+export function hexToBytes(hex) {
+  assertHexString(hex);
+  const bytes = 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;
+}
+/**
+ * Converts array of number or Uint8Array to HexString without prefix.
+ *
+ * @param bytes   The input array
+ * @param len     The length of the non prefixed HexString
+ */
+
+export 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;
+}
+/**
+ * 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
+ */
+
+export 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;
+}
+/**
+ * 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
+ */
+
+export function isHexString(s, len) {
+  return typeof s === 'string' && /^[0-9a-f]+$/i.test(s) && (!len || s.length === len);
+}
+/**
+ * Type guard for PrefixedHexStrings.
+ * Does enforce presence of 0x prefix!
+ *
+ * @param s string input
+ */
+
+export function isPrefixedHexString(s) {
+  return typeof s === 'string' && /^0x[0-9a-f]+$/i.test(s);
+}
+/**
+ * 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
+ */
+
+export 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}`);
+  }
+}
+/**
+ * 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
+ */
+
+export function assertPrefixedHexString(s, name = 'value') {
+  if (!isPrefixedHexString(s)) {
+    throw new TypeError(`${name} not valid prefixed hex string: ${s}`);
+  }
+}

package/dist/mjs/utils/http.js

@@ -0,0 +1,155 @@
+import { BeeError, BeeNotAJsonError, BeeRequestError, BeeResponseError } from "./error.js";
+import kyFactory from 'ky-universal';
+import { normalizeToReadableStream } from "./stream.js";
+import { deepMerge } from "./merge.js";
+import { isObject, isStrictlyObject } from "./type.js";
+const DEFAULT_KY_CONFIG = {
+  headers: {
+    accept: 'application/json, text/plain, */*',
+    'user-agent': `bee-js`
+  }
+};
+
+function isHttpError(e) {
+  return isObject(e) && typeof e.response !== 'undefined';
+}
+
+function isHttpRequestError(e) {
+  return 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)
+  };
+}
+
+export function wrapRequestClosure(cb) {
+  return async request => {
+    await cb(wrapRequest(request));
+  };
+}
+export function wrapResponseClosure(cb) {
+  return async (request, options, response) => {
+    await cb({
+      headers: headersToObject(response.headers),
+      status: response.status,
+      statusText: response.statusText,
+      request: wrapRequest(request)
+    });
+  };
+}
+/**
+ * Filters out entries that has undefined value from headers object.
+ * Modifies the original object!
+ *
+ * @param obj
+ */
+// eslint-disable-next-line @typescript-eslint/ban-types
+
+export function filterHeaders(obj) {
+  if (obj === undefined) {
+    return undefined;
+  }
+
+  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;
+}
+/**
+ * Main utility function to make HTTP requests.
+ * @param ky
+ * @param config
+ */
+
+export async function http(ky, config) {
+  try {
+    const {
+      path,
+      responseType,
+      ...kyConfig
+    } = config;
+    const response = await ky(path, { ...kyConfig,
+      searchParams: filterHeaders(kyConfig.searchParams)
+    });
+
+    switch (responseType) {
+      case 'stream':
+        if (!response.body) {
+          throw new BeeError('Response was expected to get data but did not get any!');
+        }
+
+        response.data = normalizeToReadableStream(response.body);
+        break;
+
+      case 'arraybuffer':
+        response.data = await response.arrayBuffer();
+        break;
+
+      case 'json':
+        try {
+          response.data = await response.json();
+        } catch (e) {
+          throw new BeeNotAJsonError();
+        }
+
+        break;
+
+      default:
+        break;
+      // If responseType is not set, then no data are expected
+    }
+
+    return response;
+  } catch (e) {
+    // Passthrough thrown errors
+    if (e instanceof 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 = await 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 BeeResponseError(e.response.status, e.response, body, config, `${e.response.statusText}: ${message}`);
+      } else {
+        throw new BeeResponseError(e.response.status, e.response, body, config, e.response.statusText);
+      }
+    } else if (isHttpRequestError(e)) {
+      throw new BeeRequestError(e.message, config);
+    } else {
+      throw new BeeError(e.message);
+    }
+  }
+}
+export function makeDefaultKy(kyConfig) {
+  return kyFactory.create(deepMerge(DEFAULT_KY_CONFIG, kyConfig));
+}

package/dist/mjs/utils/merge.js

@@ -0,0 +1,36 @@
+import { isObject } from "./type.js";
+/**
+ * Function that deep merges objects
+ *
+ * @copyright https://github.com/sindresorhus/ky/blob/b3c9e88fa49d50150dbb6e6b771b4af56cb40c98/source/utils/merge.ts
+ * @licence MIT
+ * @param sources
+ */
+
+export 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 (isObject(source)) {
+      // eslint-disable-next-line prefer-const
+      for (let [key, value] of Object.entries(source)) {
+        if (isObject(value) && key in returnValue) {
+          value = deepMerge(returnValue[key], value);
+        }
+
+        returnValue = { ...returnValue,
+          [key]: value
+        };
+      }
+    }
+  }
+
+  return returnValue;
+}

package/dist/mjs/utils/pss.js

@@ -0,0 +1,16 @@
+import { PSS_TARGET_HEX_LENGTH_MAX } from "../types/index.js";
+/**
+ * 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)
+ */
+
+export function makeMaxTarget(target) {
+  if (typeof target !== 'string') {
+    throw new TypeError('target has to be an string!');
+  }
+
+  return target.slice(0, PSS_TARGET_HEX_LENGTH_MAX);
+}

package/dist/mjs/utils/stamps.js

@@ -0,0 +1,17 @@
+/**
+ * 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
+ */
+export function getStampUsage({
+  utilization,
+  depth,
+  bucketDepth
+}) {
+  return utilization / Math.pow(2, depth - bucketDepth);
+}

package/dist/mjs/utils/stream.js

@@ -0,0 +1,156 @@
+import { Readable as NodeReadableNative } from 'stream';
+import { isStrictlyObject } from "./type.js";
+import { ReadableStream } from 'web-streams-polyfill';
+const NodeReadable = NodeReadableNative || class {};
+/**
+ * Validates if passed object is either browser's ReadableStream
+ * or Node's Readable.
+ *
+ * @param entry
+ */
+
+export function isReadable(entry) {
+  return isReadableStream(entry) || isNodeReadable(entry);
+}
+export function isReadableStream(entry) {
+  if (!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;
+}
+export function isNodeReadable(entry) {
+  if (!isStrictlyObject(entry)) {
+    return false;
+  }
+
+  const nodeReadable = entry;
+
+  if (typeof nodeReadable.pipe === 'function' && nodeReadable.readable && typeof nodeReadable._read === 'function') {
+    return true;
+  }
+
+  return false;
+}
+/**
+ * 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
+ */
+
+export function readableNodeToWeb(nodeStream) {
+  return new 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();
+    }
+
+  });
+}
+/**
+ * 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 NodeReadable {
+  _webStream;
+  _reader;
+  _reading;
+
+  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 is outdated.
+ *
+ * **Warning!**
+ * If you want to use this function in browser you have to polyfill `stream` package with your bundler.
+ *
+ * @author https://github.com/gwicke
+ * @licence Apache License 2.0 https://github.com/gwicke/node-web-streams/blob/master/LICENSE
+ * @param webStream
+ * @param options
+ */
+
+
+export function readableWebToNode(webStream, options) {
+  if (!NodeReadableNative) {
+    throw new Error("The Node's Readable is not available! If you are running this in browser you have to polyfill 'stream' package!");
+  }
+
+  return new NodeReadableWrapper(webStream, options);
+}
+export 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!');
+}

package/dist/mjs/utils/tar.js

@@ -0,0 +1,21 @@
+import Tar from '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]
+  };
+}
+
+export function makeTar(data) {
+  const tar = new Tar();
+
+  for (const entry of data) {
+    const path = fixUnicodePath(entry.path);
+    tar.append(path, entry.data);
+  }
+
+  return tar.out;
+}