@ethersphere/bee-js 2.0.0 → 3.1.0

package/test/unit/utils/type.spec.ts

@@ -1,32 +0,0 @@
-/* eslint @typescript-eslint/no-empty-function: 0 */
-import { NumberString } from '../../../src/types'
-import { isInteger } from '../../../src/utils/type'
-
-describe('type', () => {
-  describe('isInteger', () => {
-    const wrongValues = [
-      () => {},
-      Number.MAX_SAFE_INTEGER + 1,
-      Number.MIN_SAFE_INTEGER - 1,
-      5.000000000000001,
-      false,
-      true,
-      Infinity,
-      NaN,
-      [1],
-    ]
-    const correctValues = [5, 0, '10', 5.0000000000000001, '-1']
-
-    wrongValues.forEach((v: unknown | NumberString) =>
-      test(`should return false for value  ${v}`, () => {
-        expect(isInteger(v)).toEqual(false)
-      }),
-    )
-
-    correctValues.forEach((v: unknown | NumberString) =>
-      test(`should return true for value  ${v}`, () => {
-        expect(isInteger(v)).toEqual(true)
-      }),
-    )
-  })
-})

package/test/unit/utils/uint64.spec.ts

@@ -1,102 +0,0 @@
-import { Bytes, makeBytes } from '../../../src/utils/bytes'
-import { HexString, hexToBytes } from '../../../src/utils/hex'
-import { readUint64BigEndian, writeUint64BigEndian, writeUint64LittleEndian } from '../../../src/utils/uint64'
-
-describe('uint64', () => {
-  describe('little endian', () => {
-    test('zero', () => {
-      const uint64 = writeUint64LittleEndian(0)
-      const zero = makeBytes(8)
-
-      expect(uint64).toEqual(zero)
-    })
-
-    test('one', () => {
-      const uint64 = writeUint64LittleEndian(1)
-      const one = hexToBytes('0100000000000000' as HexString)
-
-      expect(uint64).toEqual(one)
-    })
-
-    test('deadbeef', () => {
-      const uint64 = writeUint64LittleEndian(0xdeadbeef)
-      const deadbeef = hexToBytes('efbeadde00000000' as HexString)
-
-      expect(uint64).toEqual(deadbeef)
-    })
-  })
-
-  describe('big endian', () => {
-    describe('write', () => {
-      test('zero', () => {
-        const uint64 = writeUint64BigEndian(0)
-        const zero = makeBytes(8)
-
-        expect(uint64).toEqual(zero)
-      })
-
-      test('one', () => {
-        const uint64 = writeUint64BigEndian(1)
-        const one = hexToBytes('0000000000000001' as HexString)
-
-        expect(uint64).toEqual(one)
-      })
-
-      test('deadbeef', () => {
-        const uint64 = writeUint64BigEndian(0xdeadbeef)
-        const deadbeef = hexToBytes('00000000deadbeef' as HexString)
-
-        expect(uint64).toEqual(deadbeef)
-      })
-    })
-
-    describe('read', () => {
-      test('zero', () => {
-        const zero = makeBytes(8)
-        const value = readUint64BigEndian(zero)
-
-        expect(value).toEqual(0)
-      })
-
-      test('one', () => {
-        const one = hexToBytes('0000000000000001' as HexString) as Bytes<8>
-        const value = readUint64BigEndian(one)
-
-        expect(value).toEqual(1)
-      })
-
-      test('deadbeef', () => {
-        const deadbeef = hexToBytes('00000000deadbeef' as HexString) as Bytes<8>
-        const value = readUint64BigEndian(deadbeef)
-
-        expect(value).toEqual(0xdeadbeef)
-      })
-    })
-
-    describe('read and write', () => {
-      test('zero', () => {
-        const zero = makeBytes(8)
-        const num = readUint64BigEndian(zero)
-        const value = writeUint64BigEndian(num)
-
-        expect(value).toEqual(zero)
-      })
-
-      test('one', () => {
-        const one = hexToBytes('0000000000000001' as HexString) as Bytes<8>
-        const num = readUint64BigEndian(one)
-        const value = writeUint64BigEndian(num)
-
-        expect(value).toEqual(one)
-      })
-
-      test('deadbeef', () => {
-        const deadbeef = hexToBytes('00000000deadbeef' as HexString) as Bytes<8>
-        const num = readUint64BigEndian(deadbeef)
-        const value = writeUint64BigEndian(num)
-
-        expect(value).toEqual(deadbeef)
-      })
-    })
-  })
-})

package/test/utils.ts

@@ -1,328 +0,0 @@
-import { Readable } from 'stream'
-import type { Ky, BeeGenericResponse, Reference, Address, BatchId } from '../src/types'
-import { bytesToHex, HexString } from '../src/utils/hex'
-import { deleteChunkFromLocalStorage } from '../src/modules/debug/chunk'
-import { BeeResponseError } from '../src'
-import { ChunkAddress } from '../src/chunk/cac'
-import { assertBytes } from '../src/utils/bytes'
-import ky from 'ky-universal'
-import { ReadableStream } from 'web-streams-polyfill/ponyfill'
-
-declare global {
-  // eslint-disable-next-line @typescript-eslint/no-namespace
-  namespace jest {
-    interface Matchers<R> {
-      toBeHashReference(): R
-      toBeBeeResponse(expectedStatusCode: number): R
-      toBeOneOf(el: unknown[]): R
-      toBeType(type: string): R
-      toBeNumberString(): R
-    }
-  }
-}
-
-/**
- * Load common own Jest Matchers which can be used to check particular return values.
- */
-export function commonMatchers(): void {
-  expect.extend({
-    toBeHashReference(received: string) {
-      const result = {
-        pass: false,
-        message: () => 'Given input is not a Swarm hash reference',
-      }
-
-      if (typeof received === 'string' && /^[0-9a-fA-F]{64}$/.test(received)) {
-        result.pass = true
-        result.message = () => 'Given string is semantically valid Swarm hash reference'
-      }
-
-      return result
-    },
-    toBeBeeResponse(received: BeeGenericResponse, expectedStatusCode: number) {
-      const result = {
-        pass: false,
-        message: () =>
-          `Bee response does not have status code ${expectedStatusCode}. Got: ${received.code}\nResponse message: ${received.message}`,
-      }
-
-      if (received.code === expectedStatusCode) {
-        result.pass = true
-        result.message = () => 'Bee response meets with its requirements'
-      }
-
-      return result
-    },
-    toBeOneOf(received, argument) {
-      const validValues = Array.isArray(argument) ? argument : [argument]
-      let containsValidValue = false
-
-      for (const validValue of validValues) {
-        try {
-          expect(received).toEqual(validValue)
-          containsValidValue = true
-          // eslint-disable-next-line no-empty
-        } catch (e) {}
-      }
-
-      if (containsValidValue) {
-        return {
-          message: () => `expected ${JSON.stringify(received)} not to be one of [${validValues.join(', ')}]`,
-          pass: true,
-        }
-      }
-
-      return {
-        message: () => `expected ${JSON.stringify(received)} to be one of [${validValues.join(', ')}]`,
-        pass: false,
-      }
-    },
-    toBeType(received, argument) {
-      const initialType = typeof received
-      const isArray = Array.isArray(received) ? 'array' : initialType
-      const type = initialType === 'object' ? isArray : initialType
-
-      return type === argument
-        ? {
-            message: () => `expected ${received} to be type ${argument}`,
-            pass: true,
-          }
-        : {
-            message: () => `expected ${received} to be type ${argument}`,
-            pass: false,
-          }
-    },
-    toBeNumberString(received) {
-      const message = () => `expected ${received} to be a number in a string type`
-
-      return /^-?(0|[1-9][0-9]*)$/g.test(received)
-        ? {
-            message,
-            pass: true,
-          }
-        : {
-            message,
-            pass: false,
-          }
-    },
-  })
-}
-
-/**
- * Sleep for N miliseconds
- *
- * @param ms Number of miliseconds to sleep
- */
-export async function sleep(ms: number): Promise<void> {
-  return new Promise<void>(resolve => setTimeout(() => resolve(), ms))
-}
-
-export function createRandomNodeReadable(totalSize: number, chunkSize = 1000): Readable {
-  if (totalSize % chunkSize !== 0) {
-    throw new Error(`totalSize ${totalSize} is not dividable without remainder by chunkSize ${chunkSize}`)
-  }
-
-  const stream = new Readable()
-  // eslint-disable-next-line @typescript-eslint/no-empty-function
-  stream._read = (): void => {}
-
-  for (let i = 0; i < totalSize / chunkSize; i++) {
-    stream.push(randomByteArray(chunkSize))
-  }
-
-  stream.push(null)
-
-  return stream
-}
-
-export function createReadableStream(iterable: Iterable<Uint8Array>): ReadableStream {
-  const iter = iterable[Symbol.iterator]()
-
-  return new ReadableStream({
-    async pull(controller) {
-      const result = iter.next()
-
-      if (result.done) {
-        controller.close()
-
-        return
-      }
-
-      controller.enqueue(result.value)
-    },
-  })
-}
-
-/**
- * Lehmer random number generator with seed (minstd_rand in C++11)
- * !!! Very fast but not well distributed pseudo-random function !!!
- *
- * @param seed Seed for the pseudo-random generator
- */
-function lrng(seed: number): () => number {
-  return (): number => ((2 ** 31 - 1) & (seed = Math.imul(48271, seed))) / 2 ** 31
-}
-
-/**
- * Utility function for generating random Buffer
- * !!! IT IS NOT CRYPTO SAFE !!!
- * For that use `crypto.randomBytes()`
- *
- * @param length Number of bytes to generate
- * @param seed Seed for the pseudo-random generator
- */
-export function randomByteArray(length: number, seed = 500): Uint8Array {
-  const rand = lrng(seed)
-  const buf = new Uint8Array(length)
-
-  for (let i = 0; i < length; ++i) {
-    buf[i] = (rand() * 0xff) << 0
-  }
-
-  return buf
-}
-
-/**
- * Returns a url for testing the Bee public API
- */
-export function beeUrl(): string {
-  return process.env.BEE_API_URL || 'http://localhost:1633'
-}
-
-export function beeKy(): Ky {
-  return ky.create({ prefixUrl: beeUrl(), timeout: false })
-}
-
-/**
- * Returns a url of another peer for testing the Bee public API
- */
-export function beePeerUrl(): string {
-  return process.env.BEE_PEER_API_URL || 'http://localhost:11633'
-}
-
-export function beePeerKy(): Ky {
-  return ky.create({ prefixUrl: beePeerUrl(), timeout: false })
-}
-
-/**
- * Helper function that create monster batch for all the tests.
- * There is semaphore mechanism that allows only creation of one batch across all the
- * parallel running tests that have to wait until it is created.
- */
-export function getPostageBatch(url = beeDebugUrl()): BatchId {
-  let stamp: BatchId
-
-  switch (url) {
-    case beeDebugUrl():
-      stamp = process.env.BEE_POSTAGE as BatchId
-      break
-    case beePeerDebugUrl():
-      stamp = process.env.BEE_PEER_POSTAGE as BatchId
-      break
-    default:
-      throw new Error('Unknown URL ' + url)
-  }
-
-  if (!stamp) {
-    throw new Error('There is no postage stamp configured for URL ' + url)
-  }
-
-  return stamp
-}
-
-/**
- * Returns a url for testing the Bee Debug API
- */
-export function beeDebugUrl(): string {
-  return process.env.BEE_DEBUG_API_URL || 'http://localhost:1635'
-}
-
-export function beeDebugKy(): Ky {
-  return ky.create({ prefixUrl: beeDebugUrl() })
-}
-
-/**
- * Returns a url for testing the Bee Debug API
- */
-export function beePeerDebugUrl(): string {
-  return process.env.BEE_PEER_DEBUG_API_URL || 'http://localhost:11635'
-}
-
-export function beePeerDebugKy(): Ky {
-  return ky.create({ prefixUrl: beePeerDebugUrl() })
-}
-
-/**
- * Try to delete a chunk from local storage, ignoring all errors
- *
- * @param address  Swarm address of chunk
- */
-export async function tryDeleteChunkFromLocalStorage(address: string | ChunkAddress): Promise<void> {
-  if (typeof address !== 'string') {
-    assertBytes(address, 32)
-    address = bytesToHex(address)
-  }
-
-  try {
-    await deleteChunkFromLocalStorage(beeDebugKy(), address)
-  } catch (e) {
-    // ignore not found errors
-    if (e instanceof BeeResponseError && e.status === 404) {
-      return
-    }
-    throw e
-  }
-}
-
-/**
- * Formatting utility for displaying long strings like hexstrings.
- *
- * @param inputStr
- * @param len
- */
-export function shorten(inputStr: unknown, len = 17): string {
-  const str = typeof inputStr === 'string' ? inputStr : (inputStr as string).toString()
-
-  if (str.length <= len) {
-    return str
-  }
-
-  return `${str.slice(0, 6)}...${str.slice(-6)} (length: ${str.length})`
-}
-
-export const invalidReference = '0000000000000000000000000000000000000000000000000000000000000000' as Reference
-
-export const okResponse: BeeGenericResponse = {
-  code: 200,
-  message: 'OK',
-}
-
-export const createdResponse: BeeGenericResponse = {
-  code: 201,
-  message: 'Created',
-}
-
-export const ERR_TIMEOUT = 40000
-export const BIG_FILE_TIMEOUT = 100000
-export const PSS_TIMEOUT = 120000
-export const FEED_TIMEOUT = 120000
-export const POSTAGE_BATCH_TIMEOUT = 40000
-
-export const testChunkPayload = new Uint8Array([1, 2, 3])
-// span is the payload length encoded as uint64 little endian
-export const testChunkSpan = new Uint8Array([testChunkPayload.length, 0, 0, 0, 0, 0, 0, 0])
-export const testChunkData = new Uint8Array([...testChunkSpan, ...testChunkPayload])
-// the hash is hardcoded because we would need the bmt hasher otherwise
-export const testChunkHash = 'ca6357a08e317d15ec560fef34e4c45f8f19f01c372aa70f1da72bfa7f1a4338' as Reference
-export const testAddress = 'ca6357a08e317d15ec560fef34e4c45f8f19f01c372aa70f1da72bfa7f1a4338' as Address
-export const testBatchId = 'ca6357a08e317d15ec560fef34e4c45f8f19f01c372aa70f1da72bfa7f1a4338' as BatchId
-
-export const testJsonPayload = [{ some: 'object' }]
-export const testJsonStringPayload = JSON.stringify(testJsonPayload)
-export const testJsonHash = '872a858115b8bee4408b1427b49e472883fdc2512d5a8f2d428b97ecc8f7ccfa'
-
-export const testIdentity = {
-  privateKey: '634fb5a872396d9693e5c9f9d7233cfa93f395c093371017ff44aa9ae6564cdd' as HexString,
-  publicKey: '03c32bb011339667a487b6c1c35061f15f7edc36aa9a0f8648aba07a4b8bd741b4' as HexString,
-  address: '8d3766440f0d7b949a5e32995d09619a7f86e632' as HexString,
-}

package/tsconfig.json

@@ -1,18 +0,0 @@
-{
-  "include": ["src"],
-  "compilerOptions": {
-    "alwaysStrict": true,
-    "target": "ES6",
-    "esModuleInterop": true,
-    "allowSyntheticDefaultImports": true,
-    "moduleResolution": "node",
-    "module": "commonjs",
-    "strict": true,
-    "resolveJsonModule": true,
-    "experimentalDecorators": true,
-    "emitDecoratorMetadata": true,
-    "typeRoots": ["./src/types", "node_modules/@types"],
-    "rootDirs": ["src"],
-    "outDir": "dist"
-  },
-}

package/tsconfig.test.json

@@ -1,11 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "include": [
-    "src",
-    "test",
-    "jest.config.ts"
-  ],
-  "compilerOptions": {
-    "noEmit": true
-  }
-}

package/typedoc.json

@@ -1,7 +0,0 @@
-{
-  "entryPoints": ["./src/index.ts"],
-  "readme": "none",
-  "logLevel": "Verbose",
-  "excludePrivate": true,
-  "out": "docs"
-}

package/webpack.config.ts

@@ -1,141 +0,0 @@
-/* eslint-disable no-console */
-import Path from 'path'
-import { DefinePlugin, Configuration, WebpackPluginInstance, NormalModuleReplacementPlugin } from 'webpack'
-import { BundleAnalyzerPlugin } from 'webpack-bundle-analyzer'
-import TerserPlugin from 'terser-webpack-plugin'
-import PackageJson from './package.json'
-import { getBrowserPathMapping } from './jest.config'
-
-interface WebpackEnvParams {
-  target: 'web' | 'node'
-  debug: boolean
-  mode: 'production' | 'development'
-  fileName: string
-}
-
-const base = async (env?: Partial<WebpackEnvParams>): Promise<Configuration> => {
-  const isProduction = env?.mode === 'production'
-  const isBrowser = env?.target === 'web'
-  const filename =
-    env?.fileName ||
-    ['index', isBrowser ? '.browser' : null, isProduction ? '.min' : null, '.js'].filter(Boolean).join('')
-  const entry = Path.resolve(__dirname, 'src')
-  const path = Path.resolve(__dirname, 'dist')
-  const target = env?.target || 'web' // 'node' or 'web'
-  const plugins: WebpackPluginInstance[] = [
-    new DefinePlugin({
-      'process.env.ENV': env?.mode || 'development',
-      'process.env.IS_WEBPACK_BUILD': 'true',
-    }),
-  ]
-
-  if (target === 'web') {
-    const browserPathMapping = await getBrowserPathMapping()
-    // eslint-disable-next-line guard-for-in
-    for (const nodeReference in browserPathMapping) {
-      plugins.push(
-        new NormalModuleReplacementPlugin(new RegExp(`\\${nodeReference}`), browserPathMapping[nodeReference]),
-      )
-    }
-    // change node modules to browser modules according to packageJson.browser mapping
-    // eslint-disable-next-line guard-for-in
-    const browserModuleMapping = PackageJson.browser as { [key: string]: string }
-    // eslint-disable-next-line guard-for-in
-    for (const nodeReference in browserModuleMapping) {
-      const browserReference: string = browserModuleMapping[nodeReference]
-      plugins.push(new NormalModuleReplacementPlugin(new RegExp(`^${nodeReference}$`), browserReference))
-    }
-  }
-
-  return {
-    bail: Boolean(isProduction),
-    mode: env?.mode || 'development',
-    devtool: isProduction ? 'source-map' : 'cheap-module-source-map',
-    entry,
-    output: {
-      path,
-      filename,
-      sourceMapFilename: filename + '.map',
-      library: 'BeeJs',
-      libraryTarget: 'umd',
-      globalObject: 'this',
-    },
-    module: {
-      rules: [
-        {
-          test: /\.(ts|js)$/,
-          // include: entry,
-          use: {
-            loader: 'babel-loader',
-          },
-        },
-      ],
-    },
-    resolve: {
-      extensions: ['.ts', '.js'],
-      fallback: {
-        path: false,
-        fs: false,
-        stream: false,
-      },
-    },
-    optimization: {
-      minimize: isProduction,
-      minimizer: [
-        // This is only used in production mode
-        new TerserPlugin({
-          terserOptions: {
-            parse: {
-              // we want terser to parse ecma 8 code. However, we don't want it
-              // to apply any minfication steps that turns valid ecma 5 code
-              // into invalid ecma 5 code. This is why the 'compress' and 'output'
-              // sections only apply transformations that are ecma 5 safe
-              // https://github.com/facebook/create-react-app/pull/4234
-              ecma: 2018,
-            },
-            compress: {
-              ecma: 5,
-            },
-            mangle: {
-              safari10: true,
-            },
-            output: {
-              ecma: 5,
-              comments: false,
-            },
-          },
-          // Use multi-process parallel running to improve the build speed
-          // Default number of concurrent runs: os.cpus().length - 1
-          parallel: true,
-        }),
-      ],
-    },
-    plugins,
-    target,
-    node: {
-      global: true,
-      __filename: 'mock',
-      __dirname: 'mock',
-    },
-    performance: {
-      hints: false,
-    },
-  }
-}
-
-export default async (env?: Partial<WebpackEnvParams>): Promise<Configuration> => {
-  // eslint-disable-next-line no-console
-  console.log('env', env)
-
-  if (env?.debug) {
-    const config = {
-      ...(await base(env)),
-      plugins: [new BundleAnalyzerPlugin()],
-      profile: true,
-    }
-
-    return config
-  }
-
-  return base(env)
-}