@ethersphere/bee-js 1.2.1 → 3.0.0

package/src/utils/hex.ts

@@ -1,186 +0,0 @@
-import { Bytes, makeBytes } from './bytes'
-import { BrandedType, FlavoredType } from '../types'
-
-/**
- * Nominal type to represent hex strings WITHOUT '0x' prefix.
- * For example for 32 bytes hex representation you have to use 64 length.
- * TODO: Make Length mandatory: https://github.com/ethersphere/bee-js/issues/208
- */
-export type HexString<Length extends number = number> = FlavoredType<
-  string & {
-    readonly length: Length
-  },
-  'HexString'
->
-
-/**
- * Type for HexString with prefix.
- * The main hex type used internally should be non-prefixed HexString
- * and therefore this type should be used as least as possible.
- * Because of that it does not contain the Length property as the variables
- * should be validated and converted to HexString ASAP.
- */
-export type PrefixedHexString = BrandedType<string, 'PrefixedHexString'>
-
-/**
- * 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<L extends number>(input: string | number | Uint8Array | unknown, len?: L): HexString<L> {
-  if (typeof input === 'number') {
-    return intToHex<L>(input, len)
-  }
-
-  if (input instanceof Uint8Array) {
-    return bytesToHex<L>(input, len)
-  }
-
-  if (typeof input === 'string') {
-    if (isPrefixedHexString(input)) {
-      const hex = input.slice(2) as HexString<L>
-
-      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<L>(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<Length extends number, LengthHex extends number = number>(
-  hex: HexString<LengthHex>,
-): Bytes<Length> {
-  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 as Bytes<Length>
-}
-
-/**
- * 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<Length extends number = number>(bytes: Uint8Array, len?: Length): HexString<Length> {
-  const hexByte = (n: number) => n.toString(16).padStart(2, '0')
-  const hex = Array.from(bytes, hexByte).join('') as HexString<Length>
-
-  // 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<Length extends number = number>(int: number, len?: Length): HexString<Length> {
-  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) as HexString<Length>
-
-  // 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<Length extends number = number>(s: unknown, len?: number): s is HexString<Length> {
-  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: unknown): s is PrefixedHexString {
-  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<Length extends number = number>(
-  s: unknown,
-  len?: number,
-  name = 'value',
-): asserts s is HexString<Length> {
-  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: string, name = 'value'): asserts s is PrefixedHexString {
-  if (!isPrefixedHexString(s)) {
-    throw new TypeError(`${name} not valid prefixed hex string: ${s}`)
-  }
-}

package/src/utils/hooks.ts

@@ -1,89 +0,0 @@
-import axios, { AxiosRequestConfig, AxiosResponse } from 'axios'
-import { BeeRequest, BeeResponse, HttpMethod } from '../types'
-
-type HookCallback<V> = (value: V) => V | Promise<V>
-
-function wrapRequest(request: AxiosRequestConfig): BeeRequest {
-  let headers = request.headers
-
-  // For request interceptor, axios returns also default headers in the object that needs to be joined based on HTTP method
-  // and the default headers removed
-  if (headers.common && headers.get && headers.delete && headers.post && headers.patch) {
-    // Filters out the default headers properties
-    const { common: _1, get: _2, delete: _3, post: _4, patch: _5, head: _6, put: _7, ...rest } = headers
-
-    headers = Object.assign({}, request.headers.common ?? {}, request.headers[request.method as HttpMethod] ?? {}, rest)
-  }
-
-  return {
-    url: `${request.url}`,
-    method: request.method as HttpMethod,
-    params: request.params,
-    headers,
-    data: request.data,
-  }
-}
-
-function wrapRequestClosure(
-  cb: HookCallback<BeeRequest>,
-): (request: AxiosRequestConfig) => Promise<AxiosRequestConfig> {
-  return async (request: AxiosRequestConfig) => {
-    await cb(wrapRequest(request))
-
-    return request
-  }
-}
-
-function wrapResponseClosure(cb: HookCallback<BeeResponse>): (response: AxiosResponse) => Promise<AxiosResponse> {
-  return async (response: AxiosResponse) => {
-    await cb({
-      headers: response.headers,
-      data: response.data,
-      status: response.status,
-      statusText: response.statusText,
-      request: wrapRequest(response.config),
-    })
-
-    return response
-  }
-}
-
-/**
- * Function that registers listener callback for all outgoing HTTP requests that bee-js makes.
- *
- * **Be Aware! This listener listens to all Bee/BeeDebug class instances without differentiation!**
- *
- * @param cb
- * @returns ID of the listener that can be used to stop the callback to receive new requests
- */
-export function onRequest(cb: HookCallback<BeeRequest>): number {
-  return axios.interceptors.request.use(wrapRequestClosure(cb))
-}
-
-/**
- * Function that stops forwarding new requests to associated listener callback
- * @param id ID that onRequest returned
- */
-export function clearOnRequest(id: number): void {
-  axios.interceptors.request.eject(id)
-}
-
-/**
- * Function that registers listener callback for all incoming HTTP responses that bee-js made.
- *
- * **Be Aware! This listener listens to all Bee/BeeDebug class instances without differentiation!**
- *
- * @param cb
- * @returns ID of the listener that can be used to stop the callback to receive new responses
- */
-export function onResponse(cb: HookCallback<BeeResponse>): number {
-  return axios.interceptors.response.use(wrapResponseClosure(cb))
-}
-
-/**
- * Function that stops forwarding new responses to associated listener callback
- * @param id ID that onResponse returned
- */
-export function clearOnResponse(id: number): void {
-  axios.interceptors.response.eject(id)
-}

package/src/utils/safe-axios.ts

@@ -1,98 +0,0 @@
-import axios, { AxiosRequestConfig, AxiosResponse } from 'axios'
-import { BeeError, BeeRequestError, BeeResponseError } from './error'
-
-import utils from 'axios/lib/utils'
-import normalizeHeaderName from 'axios/lib/helpers/normalizeHeaderName'
-axios.defaults.adapter = require('axios/lib/adapters/http') // https://stackoverflow.com/a/57320262
-
-/**
- * Utility function that sets passed headers to ALL axios calls without distinction of Bee URLs.
- *
- * @param headers
- */
-export function setDefaultHeaders(headers: Record<string, string>): void {
-  axios.defaults.headers.common = headers
-}
-
-/**
- * Utility function from axios's implementation
- * https://github.com/axios/axios/blob/d99d5faac29899eba68ce671e6b3cbc9832e9ad8/lib/defaults.js
- *
- * @param headers
- * @param value
- */
-function setContentTypeIfUnset(headers: Record<string, unknown>, value: string) {
-  if (!utils.isUndefined(headers) && utils.isUndefined(headers['Content-Type'])) {
-    headers['Content-Type'] = value
-  }
-}
-
-/**
- * Taken over from axios's implementation
- * https://github.com/axios/axios/blob/d99d5faac29899eba68ce671e6b3cbc9832e9ad8/lib/defaults.js
- *
- * Unfortunately we can't use the default implementation as fallback one and override only the JSON serialization as the JSON.stringify
- * is a last thing to do as all the previous cases (buffer, file etc.) are objects as well
- * so they have to be ruled out first before trying JSON.stringify.
- *
- * @param data
- * @param headers
- */
-function transformRequest(data: unknown, headers: Record<string, unknown>): string | unknown {
-  normalizeHeaderName(headers, 'Accept')
-  normalizeHeaderName(headers, 'Content-Type')
-
-  if (
-    utils.isFormData(data) ||
-    utils.isArrayBuffer(data) ||
-    utils.isBuffer(data) ||
-    utils.isStream(data) ||
-    utils.isFile(data) ||
-    utils.isBlob(data)
-  ) {
-    return data
-  }
-
-  if (utils.isArrayBufferView(data)) {
-    return data.buffer
-  }
-
-  if (utils.isURLSearchParams(data)) {
-    setContentTypeIfUnset(headers, 'application/x-www-form-urlencoded;charset=utf-8')
-
-    return data.toString()
-  }
-
-  if (utils.isObject(data) || (headers && headers['Content-Type'] === 'application/json')) {
-    setContentTypeIfUnset(headers, 'application/json')
-
-    return JSON.stringify(data)
-  }
-
-  return data
-}
-
-export async function safeAxios<T>(config: AxiosRequestConfig): Promise<AxiosResponse<T>> {
-  try {
-    const response = await axios({
-      maxContentLength: Infinity,
-      maxBodyLength: Infinity,
-      transformRequest,
-      ...config,
-    })
-
-    return response
-  } catch (e) {
-    if (e.response) {
-      if (e.response.data?.message) {
-        throw new BeeResponseError(e.response.status, `${e.response.statusText}: ${e.response.data.message}`)
-      } else {
-        throw new BeeResponseError(e.response.status, e.response.statusText)
-      }
-    } else if (e.request) {
-      throw new BeeRequestError(e.message)
-    } else {
-      throw new BeeError(e.message)
-    }
-  }
-}

package/src/utils/tar.ts

@@ -1,30 +0,0 @@
-import { Collection } from '../types'
-import Tar from 'tar-js'
-
-// this is a workaround type so that we are able to pass in Uint8Arrays
-// as string to `tar.append`
-interface StringLike {
-  readonly length: number
-  charCodeAt: (index: number) => number
-}
-
-// converts a string to utf8 Uint8Array and returns it as a string-like
-// object that `tar.append` accepts as path
-function fixUnicodePath(path: string): StringLike {
-  const codes = new TextEncoder().encode(path)
-
-  return {
-    length: codes.length,
-    charCodeAt: index => codes[index],
-  }
-}
-
-export function makeTar(data: Collection<Uint8Array>): Uint8Array {
-  const tar = new Tar()
-  for (const entry of data) {
-    const path = fixUnicodePath(entry.path)
-    tar.append(path, entry.data)
-  }
-
-  return tar.out
-}

package/src/utils/type.ts

@@ -1,302 +0,0 @@
-import { Readable } from 'stream'
-import {
-  Address,
-  AddressPrefix,
-  ADDRESS_HEX_LENGTH,
-  BatchId,
-  BATCH_ID_HEX_LENGTH,
-  CollectionUploadOptions,
-  ENCRYPTED_REFERENCE_HEX_LENGTH,
-  FileUploadOptions,
-  NumberString,
-  PssMessageHandler,
-  PUBKEY_HEX_LENGTH,
-  PublicKey,
-  Reference,
-  REFERENCE_HEX_LENGTH,
-  Tag,
-  UploadOptions,
-  AllTagsOptions,
-  TAGS_LIMIT_MIN,
-  TAGS_LIMIT_MAX,
-  TransactionHash,
-} from '../types'
-import { BeeArgumentError } from './error'
-import { isFile } from './file'
-import { assertHexString, assertPrefixedHexString } from './hex'
-
-export function isReadable(entry: unknown): entry is Readable {
-  return (
-    typeof entry === 'object' &&
-    entry !== null &&
-    typeof (entry as Readable).pipe === 'function' &&
-    (entry as Readable).readable &&
-    typeof (entry as Readable)._read === 'function'
-  )
-}
-
-export function isUint8Array(obj: unknown): obj is Uint8Array {
-  return obj instanceof Uint8Array
-}
-
-export function isInteger(value: unknown): value is number | NumberString {
-  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: unknown): value is Record<string, unknown> {
-  return value !== null && typeof value === 'object'
-}
-
-export function isStrictlyObject(value: unknown): value is Record<string, unknown> {
-  return isObject(value) && !Array.isArray(value)
-}
-
-export function assertBoolean(value: unknown): asserts value is boolean {
-  if (value !== true && value !== false) throw new TypeError('value is not boolean')
-}
-
-export function assertInteger(value: unknown): asserts value is number | NumberString {
-  if (!isInteger(value)) throw new TypeError('value is not integer')
-}
-
-export function assertNonNegativeInteger(value: unknown, name = 'Value'): asserts value is number | NumberString {
-  assertInteger(value)
-
-  if (Number(value) < 0) throw new BeeArgumentError(`${name} has to be bigger or equal to zero`, value)
-}
-
-export function assertReference(value: unknown): asserts value is Reference {
-  try {
-    assertHexString(value, REFERENCE_HEX_LENGTH)
-  } catch (e) {
-    assertHexString(value, ENCRYPTED_REFERENCE_HEX_LENGTH)
-  }
-}
-
-export function assertAddress(value: unknown): asserts value is Address {
-  assertHexString(value, ADDRESS_HEX_LENGTH, 'Address')
-}
-
-export function assertBatchId(value: unknown): asserts value is BatchId {
-  assertHexString(value, BATCH_ID_HEX_LENGTH, 'BatchId')
-}
-
-export function assertUploadOptions(value: unknown, name = 'UploadOptions'): asserts value is UploadOptions {
-  if (!isStrictlyObject(value)) {
-    throw new TypeError(`${name} has to be an object!`)
-  }
-
-  const options = value as UploadOptions
-
-  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')
-  }
-
-  if (options.axiosOptions && !isStrictlyObject(options.axiosOptions)) {
-    throw new TypeError(`options.axiosOptions property in ${name} has to be object or undefined!`)
-  }
-}
-
-export function assertFileUploadOptions(value: unknown): asserts value is FileUploadOptions {
-  assertUploadOptions(value, 'FileUploadOptions')
-
-  const options = value as FileUploadOptions
-
-  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 assertCollectionUploadOptions(value: unknown): asserts value is CollectionUploadOptions {
-  assertUploadOptions(value, 'CollectionUploadOptions')
-
-  const options = value as CollectionUploadOptions
-
-  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 isTag(value: unknown): value is Tag {
-  if (!isStrictlyObject(value)) {
-    return false
-  }
-
-  const tag = value as Record<string, unknown>
-
-  const numberProperties = ['total', 'processed', 'synced', 'uid']
-  const correctNumberProperties = numberProperties.every(numberProperty => typeof tag[numberProperty] === 'number')
-
-  if (!correctNumberProperties || !tag.startedAt || typeof tag.startedAt !== 'string') {
-    return false
-  }
-
-  return true
-}
-
-export function assertTag(value: unknown): asserts value is Tag {
-  if (!isStrictlyObject(value)) {
-    throw new TypeError('Tag is not an object!')
-  }
-
-  const tag = value as Record<string, unknown>
-
-  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: unknown): asserts value is AddressPrefix {
-  assertHexString(value, undefined, 'AddressPrefix')
-
-  if (value.length > ADDRESS_HEX_LENGTH) {
-    throw new BeeArgumentError(
-      `AddressPrefix must have length of ${ADDRESS_HEX_LENGTH} at most! Got string with ${value.length}`,
-      value,
-    )
-  }
-}
-
-export function assertPssMessageHandler(value: unknown): asserts value is PssMessageHandler {
-  if (!isStrictlyObject(value)) {
-    throw new TypeError('PssMessageHandler has to be object!')
-  }
-
-  const handler = value as unknown as PssMessageHandler
-
-  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: unknown): asserts value is PublicKey {
-  assertHexString(value, PUBKEY_HEX_LENGTH, 'PublicKey')
-}
-
-/**
- * Check whether the given parameter is valid data to upload
- * @param value
- * @throws TypeError if not valid
- */
-export function assertData(value: unknown): asserts value is string | Uint8Array {
-  if (typeof value !== 'string' && !(value instanceof Uint8Array)) {
-    throw new TypeError('Data must be either string or Uint8Array!')
-  }
-}
-
-/**
- * Check whether the given parameter is a correct file representation to file upload.
- * @param value
- * @throws TypeError if not valid
- */
-export function assertFileData(value: unknown): asserts value is string | Uint8Array | Readable | File {
-  if (typeof value !== 'string' && !(value instanceof Uint8Array) && !isFile(value) && !isReadable(value)) {
-    throw new TypeError('Data must be either string, Readable, Uint8Array or File!')
-  }
-}
-
-/**
- * Checks whether optional options for AllTags query are valid
- * @param options
- */
-export function assertAllTagsOptions(options: unknown): asserts options is AllTagsOptions {
-  if (options !== undefined && !isStrictlyObject(options)) {
-    throw new TypeError('options has to be an object or undefined!')
-  }
-
-  if (options?.limit !== undefined) {
-    if (typeof options.limit !== 'number') {
-      throw new TypeError('options.limit has to be a number or undefined!')
-    }
-
-    if (options.limit < TAGS_LIMIT_MIN) {
-      throw new BeeArgumentError(`options.limit has to be at least ${TAGS_LIMIT_MIN}`, options.limit)
-    }
-
-    if (options.limit > TAGS_LIMIT_MAX) {
-      throw new BeeArgumentError(`options.limit has to be at most ${TAGS_LIMIT_MAX}`, options.limit)
-    }
-  }
-
-  if (options?.offset !== undefined) {
-    assertNonNegativeInteger(options.offset, 'options.offset')
-  }
-}
-
-/**
- * Utility functions that return Tag UID
- * @param tagUid
- */
-export function makeTagUid(tagUid: number | Tag): number {
-  if (isTag(tagUid)) {
-    return tagUid.uid
-  } else if (typeof tagUid === 'number') {
-    assertNonNegativeInteger(tagUid, 'UID')
-
-    return tagUid
-  }
-
-  throw new TypeError('tagUid has to be either Tag or a number (UID)!')
-}
-
-export function assertTransactionHash(transactionHash: unknown): asserts transactionHash is 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)')
-  }
-}