@ethersphere/bee-js 12.2.1 → 12.3.0

package/dist/mjs/utils/bytes.js

@@ -1,5 +1,7 @@
-import { Binary, Objects, Types } from 'cafe-utility';
+import { Binary, Objects } from 'cafe-utility';
 import _debug from 'debug';
+import { z } from 'zod';
+import { HexStringSchema } from "./hex-schema.js";
 const debug = _debug('bee-js:bytes');
 const DECODER = new TextDecoder();
 const ENCODER = new TextEncoder();
@@ -11,9 +13,7 @@ export class Bytes {
     if (bytes instanceof Bytes) {
       this.bytes = bytes.bytes;
     } else if (typeof bytes === 'string') {
-      this.bytes = Binary.hexToUint8Array(Types.asHexString(bytes, {
-        name: 'Bytes#constructor(bytes)'
-      }));
+      this.bytes = Binary.hexToUint8Array(HexStringSchema.parse(bytes));
     } else if (bytes instanceof ArrayBuffer) {
       this.bytes = new Uint8Array(bytes);
     } else if (bytes instanceof Uint8Array) {
@@ -21,11 +21,9 @@ export class Bytes {
     } else {
       const unknownInput = bytes;
       const toHex = Objects.getDeep(unknownInput, 'toHex');
-      if (Types.isFunction(toHex)) {
+      if (z.function().safeParse(toHex).success) {
         const hex = toHex.call(unknownInput);
-        this.bytes = Binary.hexToUint8Array(Types.asHexString(hex, {
-          name: 'Bytes#constructor(bytes)'
-        }));
+        this.bytes = Binary.hexToUint8Array(HexStringSchema.parse(hex));
       } else {
         debug('bytes', bytes);
         throw new Error(`Bytes#constructor: unsupported type: ${typeof bytes}`);

package/dist/mjs/utils/error.js

@@ -17,5 +17,10 @@ export class BeeResponseError extends BeeError {
     this.responseBody = responseBody;
     this.status = status;
     this.statusText = statusText;
+    this.response = {
+      status,
+      data: responseBody,
+      statusText
+    };
   }
 }

package/dist/mjs/utils/headers.js

@@ -1,4 +1,4 @@
-import { Types } from 'cafe-utility';
+import { z } from 'zod';
 import { BeeError } from "./error.js";
 import { convertEnvelopeToMarshaledStamp } from "./stamps.js";
 import { BatchId, PublicKey, Reference } from "./typed-bytes.js";
@@ -41,7 +41,7 @@ export function prepareRequestHeaders(stamp, nullableOptions) {
   if (!nullableOptions) {
     return headers;
   }
-  const options = Types.asObject(nullableOptions);
+  const options = nullableOptions;
   if (options.size) {
     headers['content-length'] = String(options.size);
   }
@@ -51,26 +51,31 @@ export function prepareRequestHeaders(stamp, nullableOptions) {
   if (options.redundancyLevel) {
     headers['swarm-redundancy-level'] = String(options.redundancyLevel);
   }
-  if (Types.isBoolean(options.act)) {
-    headers['swarm-act'] = String(options.act);
+  const act = z.boolean().safeParse(options.act);
+  if (act.success) {
+    headers['swarm-act'] = String(act.data);
   }
-  if (Types.isBoolean(options.pin)) {
-    headers['swarm-pin'] = String(options.pin);
+  const pin = z.boolean().safeParse(options.pin);
+  if (pin.success) {
+    headers['swarm-pin'] = String(pin.data);
   }
-  if (Types.isBoolean(options.encrypt)) {
-    headers['swarm-encrypt'] = options.encrypt.toString();
+  const encrypt = z.boolean().safeParse(options.encrypt);
+  if (encrypt.success) {
+    headers['swarm-encrypt'] = String(encrypt.data);
   }
   if (options.tag) {
     headers['swarm-tag'] = String(options.tag);
   }
-  if (Types.isBoolean(options.deferred)) {
-    headers['swarm-deferred-upload'] = options.deferred.toString();
+  const deferred = z.boolean().safeParse(options.deferred);
+  if (deferred.success) {
+    headers['swarm-deferred-upload'] = String(deferred.data);
   }
   if (options.redundancyStrategy) {
     headers['swarm-redundancy-strategy'] = String(options.redundancyStrategy);
   }
-  if (Types.isBoolean(options.fallback)) {
-    headers['swarm-redundancy-fallback-mode'] = options.fallback.toString();
+  const fallback = z.boolean().safeParse(options.fallback);
+  if (fallback.success) {
+    headers['swarm-redundancy-fallback-mode'] = String(fallback.data);
   }
   if (options.timeoutMs) {
     headers['swarm-chunk-retrieval-timeout'] = String(options.timeoutMs);
@@ -102,7 +107,8 @@ export function prepareRequestHeaders(stamp, nullableOptions) {
   return headers;
 }
 function isEnvelopeWithBatchId(value) {
-  if (!Types.isObject(value)) {
+  const result = z.object({}).safeParse(value);
+  if (!result.success) {
     return false;
   }
   const envelope = value;

package/dist/mjs/utils/hex-schema.js

@@ -0,0 +1,2 @@
+import { z } from 'zod';
+export const HexStringSchema = z.string().regex(/^(?:0x)?[0-9a-fA-F]*$/i, 'expected hex string').refine(s => s.replace(/^0x/i, '').length % 2 === 0, 'expected even-length hex string');

package/dist/mjs/utils/http.js

@@ -1,28 +1,16 @@
-import axios from 'axios';
-import { Dates, Objects, Strings, System } from 'cafe-utility';
+import { Objects, Strings, System } from 'cafe-utility';
 import _debug from 'debug';
 import { BeeResponseError } from "../index.js";
 const debug = _debug('bee-js:http');
-const {
-  AxiosError
-} = axios;
 const MAX_FAILED_ATTEMPTS = 100000;
 const DELAY_FAST = 200;
 const DELAY_SLOW = 1000;
-const DELAY_THRESHOLD = Dates.minutes(1) / DELAY_FAST;
-const ABORT_ERROR_MESSAGE = 'Request aborted';
+const FAST_RETRY_COUNT = 300;
 export const DEFAULT_HTTP_CONFIG = {
   headers: {
     accept: 'application/json, text/plain, */*'
-  },
-  maxBodyLength: Infinity,
-  maxContentLength: Infinity
-};
-function throwIfAborted(signal, config, responseData, responseStatus) {
-  if (signal?.aborted) {
-    throw new BeeResponseError(config.method || 'get', config.url || '<unknown>', ABORT_ERROR_MESSAGE, responseData, responseStatus, 'ERR_CANCELED');
   }
-}
+};
 /**
  * Main function to make HTTP requests.
  * @param options User defined settings
@@ -32,68 +20,118 @@ export async function http(options, config) {
   const requestConfig = Objects.deepMerge3(DEFAULT_HTTP_CONFIG, config, options);
   if (options.signal) {
     requestConfig.signal = options.signal;
-    throwIfAborted(options.signal, config);
   }
-  maybeReplaceBodyBuffers(requestConfig);
+  attachBody(requestConfig);
   if (requestConfig.params) {
-    const keys = Object.keys(requestConfig.params);
-    for (const key of keys) {
-      const value = requestConfig.params[key];
-      if (value === undefined) {
-        delete requestConfig.params[key];
-      }
+    for (const k of Object.keys(requestConfig.params)) {
+      if (requestConfig.params[k] === undefined) delete requestConfig.params[k];
     }
   }
+  const url = buildUrl(requestConfig);
+  const method = (requestConfig.method || 'GET').toUpperCase();
+  requestConfig.method = method;
+  options.onRequest?.({
+    method,
+    url: Strings.joinUrl([requestConfig.baseURL ?? '', requestConfig.url ?? '']),
+    headers: {
+      ...requestConfig.headers
+    },
+    params: requestConfig.params
+  });
   let failedAttempts = 0;
   while (failedAttempts < MAX_FAILED_ATTEMPTS) {
-    throwIfAborted(options.signal, config);
     try {
-      debug(`${requestConfig.method || 'get'} ${Strings.joinUrl([requestConfig.baseURL, requestConfig.url])}`, {
-        headers: {
-          ...requestConfig.headers
-        },
+      debug(`${method} ${url}`, {
+        headers: requestConfig.headers,
         params: requestConfig.params
       });
-      maybeRunOnRequestHook(options, requestConfig);
-      const response = await axios(requestConfig);
-      return response;
+      const res = await fetch(url, requestConfig);
+      if (!res.ok) await throwHttpError(method, url, res, requestConfig.responseType);
+      return toBeeResponse(res, requestConfig.responseType);
     } catch (e) {
-      if (e instanceof AxiosError) {
-        if (e.code === 'ERR_CANCELED') {
-          throwIfAborted({
-            aborted: true
-          }, config, e.response?.data, e.response?.status);
-        }
-        if (e.code === 'ECONNABORTED' && options.endlesslyRetry) {
-          failedAttempts++;
-          await System.sleepMillis(failedAttempts < DELAY_THRESHOLD ? DELAY_FAST : DELAY_SLOW);
-        } else {
-          throw new BeeResponseError(config.method || 'get', config.url || '<unknown>', e.message, e.response?.data, e.response?.status, e.response?.statusText);
-        }
+      if (e instanceof BeeResponseError) throw e;
+      const err = e;
+      if (err.name === 'TimeoutError' && options.endlesslyRetry) {
+        failedAttempts++;
+        await System.sleepMillis(failedAttempts < FAST_RETRY_COUNT ? DELAY_FAST : DELAY_SLOW);
       } else {
-        throw e;
+        throw toBeeError(err, method, url);
       }
     }
   }
   throw Error('Max number of failed attempts reached');
 }
-function maybeRunOnRequestHook(options, requestConfig) {
-  if (options.onRequest) {
-    options.onRequest({
-      method: requestConfig.method || 'GET',
-      url: Strings.joinUrl([requestConfig.baseURL, requestConfig.url]),
-      headers: {
-        ...requestConfig.headers
-      },
-      params: requestConfig.params
-    });
+function attachBody(config) {
+  if (config.data === undefined) return;
+  const data = config.data;
+  const isJsonShape = data !== null && typeof data === 'object' && data.constructor === Object || Array.isArray(data);
+  if (isJsonShape) {
+    config.body = JSON.stringify(data);
+    config.headers = {
+      'content-type': 'application/json',
+      ...config.headers
+    };
+  } else {
+    config.body = data;
+    config.duplex = 'half';
+    const ct = data instanceof Blob && data.type ? data.type : 'application/octet-stream';
+    config.headers = {
+      'content-type': ct,
+      ...config.headers
+    };
   }
 }
-function maybeReplaceBodyBuffers(config) {
-  if (config.data && config.data instanceof Uint8Array) {
-    config.data = config.data.buffer.slice(config.data.byteOffset, config.data.byteOffset + config.data.byteLength);
+async function throwHttpError(method, url, res, responseType) {
+  const errBody = await toBeeResponse(res, responseType).catch(() => ({
+    data: undefined
+  }));
+  const bodyMsg = typeof errBody.data === 'string' ? errBody.data : JSON.stringify(errBody.data);
+  const message = bodyMsg && bodyMsg !== 'undefined' ? `${res.statusText}: ${bodyMsg}` : res.statusText;
+  throw new BeeResponseError(method, url, message, errBody.data, res.status, res.statusText);
+}
+function toBeeError(err, method, url) {
+  if (err.name === 'AbortError') {
+    return new BeeResponseError(method, url, 'Request aborted', undefined, undefined, 'ERR_CANCELED');
   }
-  if (config.data && typeof Buffer !== 'undefined' && Buffer.isBuffer(config.data)) {
-    config.data = config.data.buffer.slice(config.data.byteOffset, config.data.byteOffset + config.data.byteLength);
+  const cause = err.cause;
+  const message = cause?.message ? `${err.message}: ${cause.message}` : err.message;
+  return new BeeResponseError(method, url, message);
+}
+export async function toBeeResponse(res, responseType = 'json') {
+  let data;
+  switch (responseType) {
+    case 'arraybuffer':
+      data = await res.arrayBuffer();
+      break;
+    case 'text':
+      data = await res.text();
+      break;
+    case 'blob':
+      data = await res.blob();
+      break;
+    case 'stream':
+      data = res.body;
+      break;
+    case 'json':
+    default:
+      {
+        const text = await res.text();
+        data = text ? JSON.parse(text) : null;
+      }
+  }
+  return {
+    data: data,
+    status: res.status,
+    statusText: res.statusText,
+    headers: Object.fromEntries(res.headers.entries()),
+    raw: res
+  };
+}
+function buildUrl(config) {
+  let url = Strings.joinUrl([config.baseURL ?? '', config.url ?? '']);
+  if (config.params) {
+    const qs = new URLSearchParams(Object.entries(config.params).filter(([, v]) => v !== undefined).map(([k, v]) => [k, String(v)])).toString();
+    if (qs) url += `?${qs}`;
   }
+  return url;
 }

package/dist/mjs/utils/resource-locator.js

@@ -1,12 +1,13 @@
-import { Types } from 'cafe-utility';
+import { z } from 'zod';
 import { Reference } from "./typed-bytes.js";
 export class ResourceLocator {
   constructor(raw) {
     this.raw = raw;
   }
   toString() {
-    if (Types.isString(this.raw) && this.raw.includes('.eth')) {
-      return this.raw;
+    const asString = z.string().safeParse(this.raw);
+    if (asString.success && asString.data.includes('.eth')) {
+      return asString.data;
     }
     return new Reference(this.raw).toHex();
   }

package/dist/mjs/utils/schema.js

@@ -0,0 +1,81 @@
+import { z } from 'zod';
+import { TAGS_LIMIT_MAX, TAGS_LIMIT_MIN } from "../types/index.js";
+import { PublicKey, Reference } from "./typed-bytes.js";
+export { HexStringSchema } from "./hex-schema.js";
+const fnField = z.any().refine(v => z.function().safeParse(v).success, 'expected a function');
+const integerStringField = z.any().transform(v => {
+  if (z.bigint().safeParse(v).success) v = String(v);
+  return z.string().regex(/^-?\d+$/, 'expected integer string').parse(v);
+});
+const nonNegativeIntegerStringField = z.any().transform(v => {
+  if (z.bigint().safeParse(v).success) v = String(v);
+  return z.string().regex(/^\d+$/, 'expected non-negative integer string').parse(v);
+});
+export const BeeRequestOptionsSchema = z.object({
+  baseURL: z.string().optional(),
+  timeout: z.number().int().min(0).optional(),
+  headers: z.record(z.string(), z.string()).optional(),
+  onRequest: fnField.optional(),
+  httpAgent: z.unknown().optional(),
+  httpsAgent: z.unknown().optional(),
+  endlesslyRetry: z.boolean().optional(),
+  signal: z.any().optional()
+});
+export const DownloadOptionsSchema = z.object({
+  redundancyStrategy: z.number().int().optional(),
+  fallback: z.boolean().optional(),
+  timeoutMs: z.number().int().min(0).optional(),
+  actPublisher: z.optional(z.any().transform(v => new PublicKey(v))),
+  actHistoryAddress: z.optional(z.any().transform(v => new Reference(v))),
+  actTimestamp: z.coerce.number().optional()
+});
+export const UploadOptionsSchema = z.object({
+  act: z.boolean().optional(),
+  actHistoryAddress: z.optional(z.any().transform(v => new Reference(v))),
+  deferred: z.boolean().optional(),
+  encrypt: z.boolean().optional(),
+  pin: z.boolean().optional(),
+  tag: z.number().int().min(0).optional()
+});
+export const RedundantUploadOptionsSchema = UploadOptionsSchema.extend({
+  redundancyLevel: z.number().int().min(0).optional()
+});
+export const FileUploadOptionsSchema = UploadOptionsSchema.extend({
+  size: z.number().int().min(0).optional(),
+  contentType: z.string().optional(),
+  redundancyLevel: z.number().int().min(0).optional()
+});
+export const CollectionUploadOptionsSchema = UploadOptionsSchema.extend({
+  errorDocument: z.string().optional(),
+  indexDocument: z.string().optional(),
+  redundancyLevel: z.number().int().min(0).optional()
+});
+export const TagInputSchema = z.object({
+  uid: z.number().int()
+});
+export const TagUidSchema = z.coerce.number().min(0);
+export const PssMessageHandlerSchema = z.object({
+  onMessage: fnField,
+  onError: fnField,
+  onClose: fnField
+});
+export const GsocMessageHandlerSchema = z.object({
+  onMessage: fnField,
+  onError: fnField,
+  onClose: fnField
+});
+export const PostageBatchOptionsSchema = z.object({
+  gasPrice: integerStringField.optional(),
+  immutableFlag: z.boolean().optional(),
+  label: z.string().optional(),
+  waitForUsable: z.boolean().optional(),
+  waitForUsableTimeout: z.number().int().min(0).optional()
+});
+export const TransactionOptionsSchema = z.object({
+  gasLimit: nonNegativeIntegerStringField.optional(),
+  gasPrice: nonNegativeIntegerStringField.optional()
+});
+export const AllTagsOptionsSchema = z.object({
+  limit: z.number().int().min(TAGS_LIMIT_MIN).max(TAGS_LIMIT_MAX).optional(),
+  offset: z.number().int().min(0).optional()
+});

package/dist/mjs/utils/stamps.js

@@ -142,10 +142,10 @@ export function marshalStamp(signature, batchId, timestamp, index) {
   return new Bytes(Binary.concatBytes(batchId, index, timestamp, signature));
 }
 export function mapPostageBatch(raw, encryption, erasureCodeLevel) {
-  const usage = getStampUsage(raw.utilization, raw.depth, raw.bucketDepth);
   const batchTTL = normalizeBatchTTL(raw.batchTTL);
   const duration = Duration.fromSeconds(batchTTL);
   const effectiveBytes = getStampEffectiveBytes(raw.depth, encryption, erasureCodeLevel);
+  const usage = raw.utilizationRatio ?? getStampUsage(raw.utilization, raw.depth, raw.bucketDepth);
   return {
     batchID: new BatchId(raw.batchID),
     utilization: raw.utilization,
@@ -176,6 +176,7 @@ export function unmapPostageBatch(batch) {
   return {
     batchID: batch.batchID.toHex(),
     utilization: batch.utilization,
+    utilizationRatio: batch.usage,
     usable: batch.usable,
     label: batch.label,
     depth: batch.depth,