@ethersphere/bee-js 5.0.0 → 6.0.0-pre.0

package/dist/src/modules/feed.js

@@ -0,0 +1,67 @@
+import { filterHeaders, http } from "../utils/http.js";
+import { extractUploadHeaders } from "../utils/headers.js";
+import { BeeError } from "../utils/error.js";
+const feedEndpoint = 'feeds';
+/**
+ * Create an initial feed root manifest
+ *
+ * @param ky Ky instance
+ * @param owner           Owner's ethereum address in hex
+ * @param topic           Topic in hex
+ * @param postageBatchId  Postage BatchId to be used to create the Feed Manifest
+ * @param options         Additional options, like type (default: 'sequence')
+ */
+
+export async function createFeedManifest(ky, owner, topic, postageBatchId, options) {
+  const response = await http(ky, {
+    method: 'post',
+    responseType: 'json',
+    path: `${feedEndpoint}/${owner}/${topic}`,
+    searchParams: filterHeaders(options),
+    headers: extractUploadHeaders(postageBatchId)
+  });
+  return response.parsedData.reference;
+}
+
+function readFeedUpdateHeaders(headers) {
+  const feedIndex = headers.get('swarm-feed-index');
+  const feedIndexNext = headers.get('swarm-feed-index-next');
+
+  if (!feedIndex) {
+    throw new BeeError('Response did not contain expected swarm-feed-index!');
+  }
+
+  if (!feedIndexNext) {
+    throw new BeeError('Response did not contain expected swarm-feed-index-next!');
+  }
+
+  return {
+    feedIndex,
+    feedIndexNext
+  };
+}
+/**
+ * Find and retrieve feed update
+ *
+ * The feed consists of updates. This endpoint looks up an
+ * update that matches the provided parameters and returns
+ * the reference it contains along with its index and the
+ * index of the subsequent update.
+ *
+ * @param ky Ky instance
+ * @param owner       Owner's ethereum address in hex
+ * @param topic       Topic in hex
+ * @param options     Additional options, like index, at, type
+ */
+
+
+export async function fetchLatestFeedUpdate(ky, owner, topic, options) {
+  const response = await http(ky, {
+    responseType: 'json',
+    path: `${feedEndpoint}/${owner}/${topic}`,
+    searchParams: filterHeaders(options)
+  });
+  return { ...response.parsedData,
+    ...readFeedUpdateHeaders(response.headers)
+  };
+}

package/dist/src/modules/pinning.js

@@ -0,0 +1,60 @@
+import { http } from "../utils/http.js";
+const PINNING_ENDPOINT = 'pins';
+/**
+ * Pin data with given reference
+ *
+ * @param ky Ky instance for given Bee class instance
+ * @param reference Bee data reference
+ */
+
+export async function pin(ky, reference) {
+  await http(ky, {
+    method: 'post',
+    responseType: 'json',
+    path: `${PINNING_ENDPOINT}/${reference}`
+  });
+}
+/**
+ * Unpin data with given reference
+ *
+ * @param ky Ky instance for given Bee class instance
+ * @param reference Bee data reference
+ */
+
+export async function unpin(ky, reference) {
+  await http(ky, {
+    method: 'delete',
+    responseType: 'json',
+    path: `${PINNING_ENDPOINT}/${reference}`
+  });
+}
+/**
+ * Get pin status for specific address.
+ *
+ * @param ky Ky instance
+ * @param reference
+ * @throws Error if given address is not pinned
+ */
+
+export async function getPin(ky, reference) {
+  const response = await http(ky, {
+    method: 'get',
+    responseType: 'json',
+    path: `${PINNING_ENDPOINT}/${reference}`
+  });
+  return response.parsedData;
+}
+/**
+ * Get list of all pins
+ *
+ * @param ky Ky instance
+ */
+
+export async function getAllPins(ky) {
+  const response = await http(ky, {
+    method: 'get',
+    responseType: 'json',
+    path: `${PINNING_ENDPOINT}`
+  });
+  return response.parsedData.references;
+}

package/dist/src/modules/pss.js

@@ -0,0 +1,40 @@
+import WebSocket from 'isomorphic-ws';
+import { prepareData } from "../utils/data.js";
+import { http } from "../utils/http.js";
+import { extractUploadHeaders } from "../utils/headers.js";
+const endpoint = 'pss';
+/**
+ * Send to recipient or target with Postal Service for Swarm
+ *
+ * @param ky Ky instance for given Bee class instance
+ * @param topic Topic name
+ * @param target Target message address prefix
+ * @param data
+ * @param postageBatchId Postage BatchId that will be assigned to sent message
+ * @param recipient Recipient public key
+ *
+ */
+
+export async function send(ky, topic, target, data, postageBatchId, recipient) {
+  await http(ky, {
+    method: 'post',
+    path: `${endpoint}/send/${topic}/${target}`,
+    body: await prepareData(data),
+    responseType: 'json',
+    searchParams: {
+      recipient
+    },
+    headers: extractUploadHeaders(postageBatchId)
+  });
+}
+/**
+ * Subscribe for messages on the given topic
+ *
+ * @param url Bee node URL
+ * @param topic Topic name
+ */
+
+export function subscribe(url, topic) {
+  const wsUrl = url.replace(/^http/i, 'ws');
+  return new WebSocket(`${wsUrl}/${endpoint}/subscribe/${topic}`);
+}

package/dist/src/modules/soc.js

@@ -0,0 +1,31 @@
+import { extractUploadHeaders } from "../utils/headers.js";
+import { http } from "../utils/http.js";
+const socEndpoint = 'soc';
+/**
+ * Upload single owner chunk (SOC) to a Bee node
+ *
+ * @param ky Ky instance
+ * @param owner           Owner's ethereum address in hex
+ * @param identifier      Arbitrary identifier in hex
+ * @param signature       Signature in hex
+ * @param data            Content addressed chunk data to be uploaded
+ * @param postageBatchId  Postage BatchId that will be assigned to uploaded data
+ * @param options         Additional options like tag, encryption, pinning
+ */
+
+export async function upload(ky, owner, identifier, signature, data, postageBatchId, options) {
+  const response = await http(ky, {
+    method: 'post',
+    path: `${socEndpoint}/${owner}/${identifier}`,
+    body: data,
+    headers: {
+      'content-type': 'application/octet-stream',
+      ...extractUploadHeaders(postageBatchId, options)
+    },
+    responseType: 'json',
+    searchParams: {
+      sig: signature
+    }
+  });
+  return response.parsedData.reference;
+}

package/dist/src/modules/status.js

@@ -0,0 +1,12 @@
+import { http } from "../utils/http.js";
+/**
+ * Ping the base bee URL. If connection was not successful throw error
+ *
+ * @param ky Ky instance for given Bee class instance
+ */
+
+export async function checkConnection(ky) {
+  await http(ky, {
+    path: ''
+  });
+}

package/dist/src/modules/stewardship.js

@@ -0,0 +1,24 @@
+import { http } from "../utils/http.js";
+const stewardshipEndpoint = 'stewardship';
+/**
+ * Reupload locally pinned data
+ * @param ky Ky instance
+ * @param reference
+ * @param options
+ * @throws BeeResponseError if not locally pinned or invalid data
+ */
+
+export async function reupload(ky, reference) {
+  await http(ky, {
+    method: 'put',
+    path: `${stewardshipEndpoint}/${reference}`
+  });
+}
+export async function isRetrievable(ky, reference) {
+  const response = await http(ky, {
+    method: 'get',
+    responseType: 'json',
+    path: `${stewardshipEndpoint}/${reference}`
+  });
+  return response.parsedData.isRetrievable;
+}

package/dist/src/modules/tag.js

@@ -0,0 +1,77 @@
+import { http } from "../utils/http.js";
+const endpoint = 'tags';
+/**
+ * Create new tag on the Bee node
+ *
+ * @param url Bee tag URL
+ */
+
+export async function createTag(ky) {
+  const response = await http(ky, {
+    method: 'post',
+    path: endpoint,
+    responseType: 'json'
+  });
+  return response.parsedData;
+}
+/**
+ * Retrieve tag information from Bee node
+ *
+ * @param url Bee tag URL
+ * @param uid UID of tag to be retrieved
+ */
+
+export async function retrieveTag(ky, uid) {
+  const response = await http(ky, {
+    path: `${endpoint}/${uid}`,
+    responseType: 'json'
+  });
+  return response.parsedData;
+}
+/**
+ * Get limited listing of all tags.
+ *
+ * @param url
+ * @param offset
+ * @param limit
+ */
+
+export async function getAllTags(ky, offset, limit) {
+  const response = await http(ky, {
+    path: `${endpoint}`,
+    searchParams: {
+      offset,
+      limit
+    },
+    responseType: 'json'
+  });
+  return response.parsedData.tags;
+}
+/**
+ * Removes tag from the Bee node.
+ * @param url
+ * @param uid
+ */
+
+export async function deleteTag(ky, uid) {
+  await http(ky, {
+    method: 'delete',
+    path: `${endpoint}/${uid}`
+  });
+}
+/**
+ * Updates tag
+ * @param url
+ * @param uid
+ * @param reference
+ */
+
+export async function updateTag(ky, uid, reference) {
+  await http(ky, {
+    method: 'patch',
+    path: `${endpoint}/${uid}`,
+    json: {
+      reference
+    }
+  });
+}

package/dist/{mjs → src}/utils/bytes.js

@@ -108,9 +108,10 @@ export function makeBytes(length) {
   return new Uint8Array(length);
 }
 export function wrapBytesWithHelpers(data) {
-  return Object.assign(data, {
+  return {
+    bytes: () => data,
     text: () => new TextDecoder('utf-8').decode(data),
     json: () => JSON.parse(new TextDecoder('utf-8').decode(data)),
     hex: () => bytesToHex(data)
-  });
+  };
 }

package/dist/src/utils/collection-browser.js

@@ -0,0 +1,19 @@
+/**
+ * Creates array in the format of Collection with data loaded from directory on filesystem.
+ * The function loads all the data into memory!
+ *
+ * @param dir path to the directory
+ */
+export async function makeCollectionFromFS(dir) {
+  throw new Error('Creating Collection from File System is not supported in browsers!');
+}
+/**
+ * Calculate folder size recursively
+ *
+ * @param dir the path to the folder to check
+ * @returns size in bytes
+ */
+
+export async function getFolderSize(dir) {
+  throw new Error('Creating Collection from File System is not supported in browsers!');
+}

package/dist/src/utils/collection-node.js

@@ -0,0 +1,74 @@
+import fs from 'fs';
+import path from 'path';
+/**
+ * Creates array in the format of Collection with data loaded from directory on filesystem.
+ * The function loads all the data into memory!
+ *
+ * @param dir path to the directory
+ */
+
+export async function makeCollectionFromFS(dir) {
+  if (typeof dir !== 'string') {
+    throw new TypeError('dir has to be string!');
+  }
+
+  if (dir === '') {
+    throw new TypeError('dir must not be empty string!');
+  }
+
+  return buildCollectionRelative(dir, '');
+}
+
+async function buildCollectionRelative(dir, relativePath) {
+  // Handles case when the dir is not existing or it is a file ==> throws an error
+  const dirname = path.join(dir, relativePath);
+  const entries = await fs.promises.opendir(dirname);
+  let collection = [];
+
+  for await (const entry of entries) {
+    const fullPath = path.join(dir, relativePath, entry.name);
+    const entryPath = path.join(relativePath, entry.name);
+
+    if (entry.isFile()) {
+      collection.push({
+        path: entryPath,
+        data: new Uint8Array(await fs.promises.readFile(fullPath))
+      });
+    } else if (entry.isDirectory()) {
+      collection = [...(await buildCollectionRelative(dir, entryPath)), ...collection];
+    }
+  }
+
+  return collection;
+}
+/**
+ * Calculate folder size recursively
+ *
+ * @param dir the path to the folder to check
+ * @returns size in bytes
+ */
+
+
+export async function getFolderSize(dir) {
+  if (typeof dir !== 'string') {
+    throw new TypeError('dir has to be string!');
+  }
+
+  if (dir === '') {
+    throw new TypeError('dir must not be empty string!');
+  }
+
+  const entries = await fs.promises.opendir(dir);
+  let size = 0;
+
+  for await (const entry of entries) {
+    if (entry.isFile()) {
+      const stats = await fs.promises.stat(path.join(dir, entry.name));
+      size += stats.size;
+    } else if (entry.isDirectory()) {
+      size += await getFolderSize(path.join(dir, entry.name));
+    }
+  }
+
+  return size;
+}

package/dist/src/utils/collection.js

@@ -0,0 +1,64 @@
+import { BeeArgumentError } from "./error.js";
+import { fileArrayBuffer } from "./file.js";
+import { isUint8Array } from "./type.js";
+export function isCollection(data) {
+  if (!Array.isArray(data)) {
+    return false;
+  }
+
+  return data.every(entry => typeof entry === 'object' && entry.data && entry.path && isUint8Array(entry.data));
+}
+export function assertCollection(data) {
+  if (!isCollection(data)) {
+    throw new BeeArgumentError('invalid collection', data);
+  }
+}
+
+function makeFilePath(file) {
+  if (file.webkitRelativePath && file.webkitRelativePath !== '') {
+    return file.webkitRelativePath.replace(/.*?\//i, '');
+  }
+
+  if (file.name) {
+    return file.name;
+  }
+
+  throw new TypeError('file is not valid File object');
+}
+
+export async function makeCollectionFromFileList(fileList) {
+  const collection = [];
+
+  for (let i = 0; i < fileList.length; i++) {
+    const file = fileList[i];
+
+    if (file) {
+      collection.push({
+        path: makeFilePath(file),
+        data: new Uint8Array(await fileArrayBuffer(file))
+      });
+    }
+  }
+
+  return collection;
+}
+/**
+ * Calculate cumulative size of files
+ *
+ * @param fileList list of files to check
+ * @returns size in bytes
+ */
+
+export function getCollectionSize(fileList) {
+  let sum = 0;
+
+  for (let i = 0; i < fileList.length; i++) {
+    const file = fileList[i];
+
+    if (file) {
+      sum += file.size;
+    }
+  }
+
+  return sum;
+}

package/dist/src/utils/data.browser.js

@@ -0,0 +1,72 @@
+import { isNodeReadable, isReadableStream } from "./stream.js";
+/**
+ * Validates input and converts to Uint8Array
+ *
+ * @param data any string, ArrayBuffer or Uint8Array
+ */
+
+export async function prepareData(data) {
+  if (typeof data === 'string') return new Blob([data], {
+    type: 'text/plain'
+  });
+
+  if (data instanceof Uint8Array || data instanceof ArrayBuffer) {
+    return new Blob([data], {
+      type: 'application/octet-stream'
+    });
+  }
+
+  if (data instanceof Blob) {
+    return data;
+  } // Currently it is not possible to stream requests from browsers
+  // there are already first experiments on this field (Chromium)
+  // but till it is fully implemented across browsers-land we have to
+  // buffer the data before sending the requests.
+
+
+  if (isNodeReadable(data)) {
+    return new Promise(resolve => {
+      const buffers = [];
+      data.on('data', d => {
+        buffers.push(d);
+      });
+      data.on('end', () => {
+        resolve(new Blob(buffers, {
+          type: 'application/octet-stream'
+        }));
+      });
+    });
+  }
+
+  if (isReadableStream(data)) {
+    return new Promise(async resolve => {
+      const reader = data.getReader();
+      const buffers = [];
+      let done, value;
+
+      do {
+        ;
+        ({
+          done,
+          value
+        } = await reader.read());
+
+        if (!done) {
+          buffers.push(value);
+        }
+      } while (!done);
+
+      resolve(new Blob(buffers, {
+        type: 'application/octet-stream'
+      }));
+    });
+  }
+
+  throw new TypeError('unknown data type');
+}
+export async function prepareWebsocketData(data) {
+  if (typeof data === 'string') return new TextEncoder().encode(data);
+  if (data instanceof ArrayBuffer) return new Uint8Array(data);
+  if (data instanceof Blob) return new Uint8Array(await new Response(data).arrayBuffer());
+  throw new TypeError('unknown websocket data type');
+}

package/dist/src/utils/data.js

@@ -0,0 +1,42 @@
+import BlobPolyfill from 'fetch-blob';
+import { isNodeReadable, isReadableStream, readableWebToNode } from "./stream.js";
+/**
+ * Prepare data for valid input for node-fetch.
+ *
+ * node-fetch is not using WHATWG ReadableStream but NodeJS Readable so we need to convert in case of ReadableStream,
+ * but the typings are set to use ReadableStream so hence why type conversion here.
+ *
+ * @param data any string, ArrayBuffer, Uint8Array or Readable
+ */
+
+export async function prepareData(data) {
+  if (typeof data === 'string') return new BlobPolyfill([data], {
+    type: 'text/plain'
+  });
+
+  if (data instanceof Uint8Array || data instanceof ArrayBuffer) {
+    return new BlobPolyfill([data], {
+      type: 'application/octet-stream'
+    });
+  }
+
+  if (data instanceof BlobPolyfill || isNodeReadable(data)) return data;
+
+  if (isReadableStream(data)) {
+    return readableWebToNode(data);
+  }
+
+  throw new TypeError('unknown data type');
+}
+
+function isBufferArray(buffer) {
+  return Array.isArray(buffer) && buffer.length > 0 && buffer.every(data => data instanceof Buffer);
+}
+
+export async function prepareWebsocketData(data) {
+  if (typeof data === 'string') return new TextEncoder().encode(data);
+  if (data instanceof Buffer) return new Uint8Array(data);
+  if (data instanceof ArrayBuffer) return new Uint8Array(data);
+  if (isBufferArray(data)) return new Uint8Array(Buffer.concat(data));
+  throw new TypeError('unknown websocket data type');
+}