@ethersphere/bee-js 2.1.0 → 3.2.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/http.ts

@@ -1,141 +0,0 @@
-import { BeeError, BeeRequestError, BeeResponseError } from './error'
-import type { BeeRequest, BeeResponse, HookCallback, HttpMethod, Ky } from '../types'
-import kyFactory, { Options as KyOptions } from 'ky-universal'
-import { normalizeToReadableStream } from './stream'
-import { deepMerge } from './merge'
-import { version as beeJsVersion } from '../../package.json'
-import { isStrictlyObject } from './type'
-
-const DEFAULT_KY_CONFIG: KyOptions = {
-  headers: {
-    accept: 'application/json, text/plain, */*',
-    'user-agent': `bee-js/${beeJsVersion}`,
-  },
-}
-
-interface HttpOptions extends Omit<KyOptions, 'searchParams'> {
-  path: string
-  responseType?: 'json' | 'arraybuffer' | 'stream'
-
-  /**
-   * Overridden parameter that allows undefined as a value.
-   */
-  searchParams?: Record<string, string | number | boolean | undefined>
-}
-
-interface KyResponse<T> extends Response {
-  data: T
-}
-
-function headersToObject(header: Headers) {
-  return [...header.entries()].reduce<Record<string, string>>((obj, [key, val]) => {
-    obj[key] = val
-
-    return obj
-  }, {})
-}
-
-function wrapRequest(request: Request): BeeRequest {
-  return {
-    url: request.url,
-    method: request.method.toUpperCase() as HttpMethod,
-    headers: headersToObject(request.headers),
-  }
-}
-
-export function wrapRequestClosure(cb: HookCallback<BeeRequest>): (request: Request) => Promise<void> {
-  return async (request: Request) => {
-    await cb(wrapRequest(request))
-  }
-}
-
-export function wrapResponseClosure(
-  cb: HookCallback<BeeResponse>,
-): (request: Request, options: unknown, response: Response) => Promise<void> {
-  return async (request: Request, options: unknown, response: 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?: object): Record<string, string> | undefined {
-  if (obj === undefined) {
-    return undefined
-  }
-
-  isStrictlyObject(obj)
-
-  const typedObj = obj as Record<string, string>
-
-  for (const key in typedObj) {
-    if (typedObj[key] === undefined) {
-      delete typedObj[key]
-    }
-  }
-
-  if (Object.keys(typedObj).length === 0) {
-    return undefined
-  }
-
-  return typedObj
-}
-
-export async function http<T>(ky: Ky, config: HttpOptions): Promise<KyResponse<T>> {
-  try {
-    const { path, responseType, ...kyConfig } = config
-
-    const response = (await ky(path, {
-      ...kyConfig,
-      searchParams: filterHeaders(kyConfig.searchParams),
-    })) as KyResponse<T>
-
-    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) as unknown as T
-        break
-      case 'arraybuffer':
-        response.data = (await response.arrayBuffer()) as unknown as T
-        break
-      case 'json':
-        response.data = (await response.json()) as unknown as T
-        break
-      default:
-        break // If responseType is not set, then no data are expected
-    }
-
-    return response
-  } catch (e) {
-    if (e.response) {
-      const message = (await e.response.json()).message
-
-      if (message) {
-        throw new BeeResponseError(e.response.status, `${e.response.statusText}: ${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)
-    }
-  }
-}
-
-export function makeDefaultKy(kyConfig: KyOptions): Ky {
-  return kyFactory.create(deepMerge(DEFAULT_KY_CONFIG, kyConfig))
-}

package/src/utils/merge.ts

@@ -1,34 +0,0 @@
-import { isObject } from './type'
-
-/**
- * Function that deep merges objects
- *
- * @copyright https://github.com/sindresorhus/ky/blob/b3c9e88fa49d50150dbb6e6b771b4af56cb40c98/source/utils/merge.ts
- * @licence MIT
- * @param sources
- */
-export function deepMerge<T>(...sources: Array<Partial<T> | undefined>): T {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  let returnValue: any = {}
-
-  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/src/utils/pss.ts

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

package/src/utils/stream.ts

@@ -1,146 +0,0 @@
-import type { Readable as NodeReadableType } from 'stream'
-import { isStrictlyObject } from './type'
-import { ReadableStream } from 'web-streams-polyfill/ponyfill'
-import { Readable as NodeReadable, ReadableOptions as NodeReadableOptions } from 'readable-stream'
-
-import { Readable } from '../types'
-
-/**
- * Validates if passed object is either browser's ReadableStream
- * or Node's Readable.
- *
- * @param entry
- */
-export function isReadable(entry: unknown): entry is NodeReadableType {
-  return isReadableStream(entry) || isNodeReadable(entry)
-}
-
-export function isReadableStream(entry: unknown): entry is ReadableStream {
-  if (!isStrictlyObject(entry)) {
-    return false
-  }
-
-  const browserReadable = entry as ReadableStream
-
-  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: unknown): entry is NodeReadableType {
-  if (!isStrictlyObject(entry)) {
-    return false
-  }
-
-  const nodeReadable = entry as NodeReadableType
-
-  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: NodeReadableType): ReadableStream<Uint8Array> {
-  return new ReadableStream({
-    start(controller) {
-      nodeStream.pause()
-      nodeStream.on('data', chunk => {
-        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 {
-  private _webStream: ReadableStream
-  private _reader: ReadableStreamDefaultReader<any>
-  private _reading: boolean
-  constructor(webStream: ReadableStream, options?: NodeReadableOptions) {
-    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
- */
-export function readableWebToNode(webStream: ReadableStream, options?: NodeReadableOptions): NodeReadableType {
-  return new NodeReadableWrapper(webStream, options) as unknown as NodeReadableType
-}
-
-export function normalizeToReadableStream(stream: Readable): ReadableStream {
-  if (isNodeReadable(stream)) {
-    return readableNodeToWeb(stream)
-  } else if (isReadableStream(stream)) {
-    return stream
-  }
-
-  throw new TypeError('Passed stream is not Node Readable nor ReadableStream!')
-}

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
-}