@ethersphere/bee-js 8.3.0 → 9.0.1

package/dist/mjs/utils/type.js

@@ -1,288 +1,215 @@
-import { Readable } from 'stream';
-import { ADDRESS_HEX_LENGTH, BATCH_ID_HEX_LENGTH, ENCRYPTED_REFERENCE_HEX_LENGTH, PSS_TARGET_HEX_LENGTH_MAX, PUBKEY_HEX_LENGTH, REFERENCE_HEX_LENGTH, TAGS_LIMIT_MAX, TAGS_LIMIT_MIN } from "../types/index.js";
-import { convertCidToReference, convertReferenceToCid } from "./cid.js";
-import { BeeArgumentError, BeeError } from "./error.js";
+import { Types } from 'cafe-utility';
+import * as stream from 'stream';
+import { TAGS_LIMIT_MAX, TAGS_LIMIT_MIN } from "../types/index.js";
 import { isFile } from "./file.js";
-import { assertHexString, assertPrefixedHexString, isHexString } from "./hex.js";
-export function isReadable(obj) {
-  return typeof Readable !== 'undefined' && obj instanceof Readable;
+import { PublicKey, Reference } from "./typed-bytes.js";
+export function isReadable(value) {
+  return typeof stream.Readable !== 'undefined' && value instanceof stream.Readable;
 }
-export function isInteger(value) {
-  return typeof value === 'string' && /^-?(0|[1-9][0-9]*)$/g.test(value) || typeof value === 'number' && value > Number.MIN_SAFE_INTEGER && value < Number.MAX_SAFE_INTEGER && Number.isInteger(value);
-}
-export function isObject(value) {
-  return value !== null && typeof value === 'object';
-}
-export function isStrictlyObject(value) {
-  return isObject(value) && !Array.isArray(value);
-}
-/**
- * Asserts if object is Error
- *
- * @param e
- */
-export function isError(e) {
-  return e instanceof Error;
-}
-// eslint-disable-next-line @typescript-eslint/ban-types
-export function assertStrictlyObject(value, name = 'value') {
-  if (!isStrictlyObject(value)) {
-    throw new TypeError(`${name} has to be an object that is not null nor array!`);
-  }
-}
-export function assertBoolean(value, name = 'value') {
-  if (value !== true && value !== false) throw new TypeError(`${name} is not boolean`);
-}
-export function assertInteger(value, name = 'value') {
-  if (!isInteger(value)) throw new TypeError(`${name} is not integer`);
-}
-export function assertNonNegativeInteger(value, name = 'Value') {
-  assertInteger(value, name);
-  if (Number(value) < 0) throw new BeeArgumentError(`${name} has to be bigger or equal to zero`, value);
-}
-export function assertPositiveInteger(value, name = 'Value') {
-  assertInteger(value, name);
-  if (Number(value) <= 0) throw new BeeArgumentError(`${name} has to be bigger then zero`, value);
-}
-export function assertReference(value) {
-  try {
-    assertHexString(value, REFERENCE_HEX_LENGTH);
-  } catch (e) {
-    assertHexString(value, ENCRYPTED_REFERENCE_HEX_LENGTH);
-  }
-}
-export function assertReferenceOrEns(value) {
-  if (typeof value !== 'string') {
-    throw new TypeError('ReferenceOrEns has to be a string!');
-  }
-  if (isHexString(value)) {
-    assertReference(value);
-    return;
-  }
-  /**
-   * a.asdf - VALID
-   * test.eth - VALID
-   * ADAM.ETH - VALID
-   * ADAM UHLIR.ETH - INVALID
-   * test.whatever.eth - VALID
-   * -adg.ets - INVALID
-   * adg-.ets - INVALID
-   * as-a.com - VALID
-   * ethswarm.org - VALID
-   * http://asdf.asf - INVALID
-   * řš+ýí.šě+ř.čě - VALID
-   * tsg.asg?asg - INVALID
-   * tsg.asg:1599 - INVALID
-   * ethswarm.something- - INVALID
-   * ethswarm.-something - INVALID
-   * ethswarm.some-thing - VALID
-   *
-   * The idea of this regex is to match strings that are 1 to 63 characters long and do not start or end with dash character
-   *
-   * This part matches 2-63 character string that does not start or end with -
-   * [^-.\/?:\s][^.\/?:\s]{0,61}[^-.\/?:\s]   <regexp1>
-   *
-   * For 1 character long string we use the part after |
-   * [^-.\/?:\s]   <regexp2>
-   *
-   * This is terminated in a group with . character an repeated at least once
-   * (<regexp1>|<regexp2>\.)+
-   *
-   * This covers everything but top level domain which is 2 to 63 characters long so we can just use the <regexp2> again
-   * ^(<regexp1>|<regexp2>\.)+<regexp1>$
-   */
-  const DOMAIN_REGEX = /^(?:(?:[^-.\/?:\s][^.\/?:\s]{0,61}[^-.\/?:\s]|[^-.\/?:\s]{1,2})\.)+[^-.\/?:\s][^.\/?:\s]{0,61}[^-.\/?:\s]$/;
-  // We are doing best-effort validation of domain here. The proper way would be to do validation using IDNA UTS64 standard
-  // but that would give us high penalty to our dependencies as the library (idna-uts46-hx) that does this validation and translation
-  // adds 160kB minified size which is significant. We expects that full validation will be done on Bee side.
-  if (!DOMAIN_REGEX.test(value)) {
-    throw new TypeError('ReferenceOrEns is not valid Reference, but also not valid ENS domain.');
+export function asNumberString(value, options) {
+  if (typeof value === 'bigint') {
+    value = value.toString();
   }
+  return Types.asIntegerString(value, options);
 }
-/**
- * Function that mainly converts Swarm CID into hex encoded Swarm Reference
- *
- * @param value
- * @param expectedCidType
- */
-export function makeReferenceOrEns(value, expectedCidType) {
-  if (typeof value !== 'string') {
-    throw new TypeError('ReferenceCidOrEns has to be a string!');
-  }
-  try {
-    const result = convertCidToReference(value);
-    if (result.type !== expectedCidType) {
-      throw new BeeError(`CID was expected to be of type ${expectedCidType}, but got instead ${result.type ?? 'non-Swarm CID'}`);
-    }
-    return result.reference;
-  } catch (e) {
-    if (e instanceof BeeError) throw e;
-  }
-  assertReferenceOrEns(value);
-  return value;
-}
-/**
- * Function that adds getter which converts the reference into CID base32 encoded string.
- * @param result
- * @param cidType feed or manifest
- */
-export function addCidConversionFunction(result, cidType) {
+export function prepareBeeRequestOptions(value) {
+  const object = Types.asObject(value, {
+    name: 'BeeRequestOptions'
+  });
   return {
-    ...result,
-    cid() {
-      return convertReferenceToCid(result.reference, cidType);
-    }
+    baseURL: Types.asOptional(x => Types.asString(x, {
+      name: 'baseURL'
+    }), object.baseURL),
+    timeout: Types.asOptional(x => Types.asInteger(x, {
+      name: 'timeout',
+      min: 0
+    }), object.timeout),
+    headers: Types.asOptional(x => Types.asStringMap(x, {
+      name: 'headers'
+    }), object.headers),
+    onRequest: Types.asOptional(x => Types.asFunction(x, {
+      name: 'onRequest'
+    }), object.onRequest),
+    httpAgent: object.httpAgent,
+    httpsAgent: object.httpsAgent,
+    endlesslyRetry: Types.asOptional(x => Types.asBoolean(x, {
+      name: 'endlesslyRetry'
+    }), object.endlesslyRetry)
   };
 }
-export function assertAddress(value) {
-  assertHexString(value, ADDRESS_HEX_LENGTH, 'Address');
-}
-export function assertBatchId(value) {
-  assertHexString(value, BATCH_ID_HEX_LENGTH, 'BatchId');
+export function prepareDownloadOptions(value) {
+  const object = Types.asObject(value, {
+    name: 'DownloadOptions'
+  });
+  return {
+    redundancyStrategy: Types.asOptional(x => Types.asInteger(x, {
+      name: 'redundancyStrategy'
+    }), object.redundancyStrategy),
+    fallback: Types.asOptional(x => Types.asBoolean(x, {
+      name: 'fallback'
+    }), object.fallback),
+    timeoutMs: Types.asOptional(x => Types.asInteger(x, {
+      name: 'timeoutMs',
+      min: 0
+    }), object.timeoutMs),
+    actPublisher: Types.asOptional(x => new PublicKey(x), object.actPublisher),
+    actHistoryAddress: Types.asOptional(x => new Reference(x), object.actHistoryAddress),
+    actTimestamp: Types.asOptional(x => Types.asNumber(x, {
+      name: 'actTimestamp'
+    }), object.actTimestamp)
+  };
 }
-export function assertRequestOptions(value, name = 'RequestOptions') {
-  if (value === undefined) {
-    return;
-  }
-  if (!isStrictlyObject(value)) {
-    throw new TypeError(`${name} has to be an object!`);
-  }
-  const options = value;
-  if (options.timeout) {
-    assertNonNegativeInteger(options.timeout, `${name}.timeout`);
-  }
+export function prepareUploadOptions(value, name = 'UploadOptions') {
+  const object = Types.asObject(value, {
+    name
+  });
+  return {
+    act: Types.asOptional(x => Types.asBoolean(x, {
+      name: 'act'
+    }), object.act),
+    deferred: Types.asOptional(x => Types.asBoolean(x, {
+      name: 'deferred'
+    }), object.deferred),
+    encrypt: Types.asOptional(x => Types.asBoolean(x, {
+      name: 'encrypt'
+    }), object.encrypt),
+    pin: Types.asOptional(x => Types.asBoolean(x, {
+      name: 'pin'
+    }), object.pin),
+    tag: Types.asOptional(x => Types.asInteger(x, {
+      name: 'tag',
+      min: 0
+    }), object.tag)
+  };
 }
-export function assertUploadOptions(value, name = 'UploadOptions') {
-  if (!isStrictlyObject(value)) {
-    throw new TypeError(`${name} has to be an object!`);
-  }
-  assertRequestOptions(value, name);
-  const options = value;
-  if (options.pin && typeof options.pin !== 'boolean') {
-    throw new TypeError(`options.pin property in ${name} has to be boolean or undefined!`);
-  }
-  if (options.encrypt && typeof options.encrypt !== 'boolean') {
-    throw new TypeError(`options.encrypt property in ${name} has to be boolean or undefined!`);
-  }
-  if (options.tag) {
-    if (typeof options.tag !== 'number') {
-      throw new TypeError(`options.tag property in ${name} has to be number or undefined!`);
-    }
-    assertNonNegativeInteger(options.tag, 'options.tag');
-  }
+export function prepareRedundantUploadOptions(value, name = 'UploadOptions') {
+  const uploadOptions = prepareUploadOptions(value, name);
+  const object = Types.asObject(value, {
+    name
+  });
+  return {
+    ...uploadOptions,
+    redundancyLevel: Types.asOptional(x => Types.asInteger(x, {
+      name: 'redundancyLevel',
+      min: 0
+    }), object.redundancyLevel)
+  };
 }
-export function assertFileUploadOptions(value) {
-  assertUploadOptions(value, 'FileUploadOptions');
-  const options = value;
-  if (options.size) {
-    if (typeof options.size !== 'number') {
-      throw new TypeError('tag property in FileUploadOptions has to be number or undefined!');
-    }
-    assertNonNegativeInteger(options.size, 'options.size');
-  }
-  if (options.contentType && typeof options.contentType !== 'string') {
-    throw new TypeError('contentType property in FileUploadOptions has to be string or undefined!');
-  }
+export function prepareFileUploadOptions(value) {
+  const uploadOptions = prepareUploadOptions(value, 'FileUploadOptions');
+  const object = Types.asObject(value, {
+    name: 'FileUploadOptions'
+  });
+  return {
+    ...uploadOptions,
+    size: Types.asOptional(x => Types.asInteger(x, {
+      name: 'size',
+      min: 0
+    }), object.size),
+    contentType: Types.asOptional(x => Types.asString(x, {
+      name: 'contentType'
+    }), object.contentType),
+    redundancyLevel: Types.asOptional(x => Types.asInteger(x, {
+      name: 'redundancyLevel',
+      min: 0
+    }), object.redundancyLevel)
+  };
 }
-export function assertCollectionUploadOptions(value) {
-  assertUploadOptions(value, 'CollectionUploadOptions');
-  const options = value;
-  if (options.indexDocument && typeof options.indexDocument !== 'string') {
-    throw new TypeError('indexDocument property in CollectionUploadOptions has to be string or undefined!');
-  }
-  if (options.errorDocument && typeof options.errorDocument !== 'string') {
-    throw new TypeError('errorDocument property in CollectionUploadOptions has to be string or undefined!');
-  }
+export function prepareCollectionUploadOptions(value) {
+  const uploadOptions = prepareUploadOptions(value, 'CollectionUploadOptions');
+  const object = Types.asObject(value, {
+    name: 'CollectionUploadOptions'
+  });
+  return {
+    ...uploadOptions,
+    errorDocument: Types.asOptional(x => Types.asString(x, {
+      name: 'errorDocument'
+    }), object.errorDocument),
+    indexDocument: Types.asOptional(x => Types.asString(x, {
+      name: 'indexDocument'
+    }), object.indexDocument),
+    redundancyLevel: Types.asOptional(x => Types.asInteger(x, {
+      name: 'redundancyLevel',
+      min: 0
+    }), object.redundancyLevel)
+  };
 }
 export function isTag(value) {
-  if (!isStrictlyObject(value)) {
+  try {
+    const object = Types.asObject(value, {
+      name: 'Tag'
+    });
+    Types.asInteger(object.uid, {
+      name: 'Tag.uid'
+    });
+    return true;
+  } catch {
     return false;
   }
-  return Boolean(value.uid);
-}
-export function assertTag(value) {
-  if (!isStrictlyObject(value)) {
-    throw new TypeError('Tag is not an object!');
-  }
-  const tag = value;
-  const numberProperties = ['total', 'processed', 'synced', 'uid'];
-  for (const numberProperty of numberProperties) {
-    if (!tag[numberProperty]) {
-      throw new TypeError(`Tag's property '${numberProperty}' has to be specified!`);
-    }
-    if (typeof tag[numberProperty] !== 'number') {
-      throw new TypeError(`Tag's property '${numberProperty}' has to be number!`);
-    }
-  }
-  if (!tag.startedAt) {
-    throw new TypeError("Tag's property 'startedAt' has to be specified!");
-  }
-  if (typeof tag.startedAt !== 'string') {
-    throw new TypeError("Tag's property 'startedAt' has to be string!");
-  }
 }
-export function assertAddressPrefix(value) {
-  assertHexString(value, undefined, 'AddressPrefix');
-  if (value.length > PSS_TARGET_HEX_LENGTH_MAX) {
-    throw new BeeArgumentError(`AddressPrefix must have length of ${PSS_TARGET_HEX_LENGTH_MAX} at most! Got string with ${value.length}`, value);
-  }
-}
-export function assertPssMessageHandler(value) {
-  if (!isStrictlyObject(value)) {
-    throw new TypeError('PssMessageHandler has to be object!');
-  }
-  const handler = value;
-  if (typeof handler.onMessage !== 'function') {
-    throw new TypeError('onMessage property of PssMessageHandler has to be function!');
-  }
-  if (typeof handler.onError !== 'function') {
-    throw new TypeError('onError property of PssMessageHandler has to be function!');
-  }
-}
-export function assertPublicKey(value) {
-  assertHexString(value, PUBKEY_HEX_LENGTH, 'PublicKey');
+export function preparePssMessageHandler(value) {
+  const object = Types.asObject(value, {
+    name: 'PssMessageHandler'
+  });
+  return {
+    onMessage: Types.asFunction(object.onMessage, {
+      name: 'onMessage'
+    }),
+    onError: Types.asFunction(object.onError, {
+      name: 'onError'
+    })
+  };
 }
-export function assertPostageBatchOptions(value) {
-  if (value === undefined) {
-    return;
-  }
-  assertStrictlyObject(value);
-  const options = value;
-  assertRequestOptions(options, 'PostageBatchOptions');
-  if (options?.gasPrice) {
-    assertNonNegativeInteger(options.gasPrice);
-  }
-  if (options?.immutableFlag !== undefined) {
-    assertBoolean(options.immutableFlag);
-  }
-  if (options?.waitForUsable !== undefined) {
-    assertBoolean(options.waitForUsable);
-  }
-  if (options?.waitForUsableTimeout !== undefined) {
-    assertNonNegativeInteger(options.waitForUsableTimeout, 'options.waitForUsableTimeout');
-  }
+export function prepareGsocMessageHandler(value) {
+  const object = Types.asObject(value, {
+    name: 'GsocMessageHandler'
+  });
+  return {
+    onMessage: Types.asFunction(object.onMessage, {
+      name: 'onMessage'
+    }),
+    onError: Types.asFunction(object.onError, {
+      name: 'onError'
+    })
+  };
 }
-export function assertTransactionOptions(value, name = 'TransactionOptions') {
-  if (value === undefined) {
-    return;
-  }
-  assertStrictlyObject(value, name);
-  const options = value;
-  if (options?.gasLimit) {
-    assertNonNegativeInteger(options.gasLimit, name);
-  }
-  if (options?.gasPrice) {
-    assertNonNegativeInteger(options.gasPrice, name);
-  }
+export function preparePostageBatchOptions(value) {
+  const object = Types.asObject(value, {
+    name: 'PostageBatchOptions'
+  });
+  return {
+    gasPrice: Types.asOptional(x => asNumberString(x, {
+      name: 'gasPrice'
+    }), object.gasPrice),
+    immutableFlag: Types.asOptional(x => Types.asBoolean(x, {
+      name: 'immutableFlag'
+    }), object.immutableFlag),
+    label: Types.asOptional(x => Types.asString(x, {
+      name: 'label'
+    }), object.label),
+    waitForUsable: Types.asOptional(x => Types.asBoolean(x, {
+      name: 'waitForUsable'
+    }), object.waitForUsable),
+    waitForUsableTimeout: Types.asOptional(x => Types.asInteger(x, {
+      name: 'waitForUsableTimeout',
+      min: 0
+    }), object.waitForUsableTimeout)
+  };
 }
-export function assertCashoutOptions(value) {
-  if (value === undefined) {
-    return;
-  }
-  assertStrictlyObject(value);
-  const options = value;
-  assertRequestOptions(options, 'CashoutOptions');
-  assertTransactionOptions(options, 'CashoutOptions');
+export function prepareTransactionOptions(value, name = 'TransactionOptions') {
+  const object = Types.asObject(value, {
+    name
+  });
+  return {
+    gasLimit: Types.asOptional(x => asNumberString(x, {
+      name: 'gasLimit',
+      min: 0n
+    }), object.gasLimit),
+    gasPrice: Types.asOptional(x => asNumberString(x, {
+      name: 'gasPrice',
+      min: 0n
+    }), object.gasPrice)
+  };
 }
 /**
  * Check whether the given parameter is valid data to upload
@@ -308,26 +235,21 @@ export function assertFileData(value) {
  * Checks whether optional options for AllTags query are valid
  * @param options
  */
-export function assertAllTagsOptions(entry) {
-  if (entry !== undefined && !isStrictlyObject(entry)) {
-    throw new TypeError('options has to be an object or undefined!');
-  }
-  assertRequestOptions(entry, 'AllTagsOptions');
-  const options = entry;
-  if (options?.limit !== undefined) {
-    if (typeof options.limit !== 'number') {
-      throw new TypeError('AllTagsOptions.limit has to be a number or undefined!');
-    }
-    if (options.limit < TAGS_LIMIT_MIN) {
-      throw new BeeArgumentError(`AllTagsOptions.limit has to be at least ${TAGS_LIMIT_MIN}`, options.limit);
-    }
-    if (options.limit > TAGS_LIMIT_MAX) {
-      throw new BeeArgumentError(`AllTagsOptions.limit has to be at most ${TAGS_LIMIT_MAX}`, options.limit);
-    }
-  }
-  if (options?.offset !== undefined) {
-    assertNonNegativeInteger(options.offset, 'AllTagsOptions.offset');
-  }
+export function prepareAllTagsOptions(value) {
+  const object = Types.asObject(value, {
+    name: 'AllTagsOptions'
+  });
+  return {
+    limit: Types.asOptional(x => Types.asInteger(x, {
+      name: 'limit',
+      min: TAGS_LIMIT_MIN,
+      max: TAGS_LIMIT_MAX
+    }), object.limit),
+    offset: Types.asOptional(x => Types.asInteger(x, {
+      name: 'offset',
+      min: 0
+    }), object.offset)
+  };
 }
 /**
  * Utility functions that return Tag UID
@@ -335,32 +257,15 @@ export function assertAllTagsOptions(entry) {
  */
 export function makeTagUid(tagUid) {
   if (tagUid === undefined || tagUid === null) {
-    throw new TypeError('TagUid was expected but got undefined or null instead!');
+    throw new TypeError(`Expected number | Tag | string from tagUid, got: ${tagUid}`);
   }
   if (isTag(tagUid)) {
     return tagUid.uid;
-  } else if (typeof tagUid === 'number') {
-    assertNonNegativeInteger(tagUid, 'UID');
-    return tagUid;
-  } else if (typeof tagUid === 'string') {
-    const int = parseInt(tagUid);
-    if (isNaN(int)) {
-      throw new TypeError('Passed tagUid string is not valid integer!');
-    }
-    if (int < 0) {
-      throw new TypeError(`TagUid was expected to be positive non-negative integer! Got ${int}`);
-    }
-    return int;
-  }
-  throw new TypeError('tagUid has to be either Tag or a number (UID)!');
-}
-export function assertTransactionHash(transactionHash) {
-  if (typeof transactionHash !== 'string') {
-    throw new TypeError('TransactionHash has to be a string!');
-  }
-  assertPrefixedHexString(transactionHash, 'TransactionHash');
-  // Hash is 64 long + '0x' prefix = 66
-  if (transactionHash.length !== 66) {
-    throw new TypeError('TransactionHash has to be prefixed hex string with total length 66 (prefix including)');
+  } else if (typeof tagUid === 'number' || typeof tagUid === 'string') {
+    return Types.asNumber(tagUid, {
+      name: 'tagUid',
+      min: 0
+    });
   }
+  throw new TypeError(`Expected number | Tag | string from tagUid, got: ${tagUid}`);
 }