@simplito/privmx-webendpoint 2.1.1 → 2.2.0

package/extra/files.js

@@ -0,0 +1,216 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.downloadFile = exports.FileUploader = exports.StreamReader = exports.FILE_DEFAULT_CHUNK_SIZE = void 0;
+exports.FILE_DEFAULT_CHUNK_SIZE = 1_048_576;
+class StreamReader {
+    _handle;
+    _offset;
+    _api;
+    chunkSize;
+    hasDataToRead = true;
+    /**
+     * Creates an instance of StreamReader.
+     *
+     * @param {number} handle - The file handle.
+     * @param {StoreApi} api {@link StoreApi `StoreApi`} instance
+     */
+    constructor(handle, api, chunkSize) {
+        this._handle = handle;
+        this._offset = 0;
+        this._api = api;
+        this.chunkSize = chunkSize ?? exports.FILE_DEFAULT_CHUNK_SIZE;
+    }
+    static async readFile(api, fileID, chunkSize) {
+        const fileHandle = await api.openFile(fileID);
+        const reader = new StreamReader(fileHandle, api, chunkSize);
+        return reader;
+    }
+    /**
+     * Reads the next chunk of the file.
+     *
+     * @returns {Promise<boolean>} A promise that resolves to true if there are more chunks to read, or false if the end of the file is reached.
+     */
+    async *[Symbol.asyncIterator]() {
+        while (this.hasDataToRead) {
+            const chunk = await this.readNextChunk();
+            yield [chunk, this._offset];
+        }
+    }
+    async readNextChunk() {
+        const chunkSizeToRead = this.chunkSize ?? exports.FILE_DEFAULT_CHUNK_SIZE;
+        const chunk = await this._api.readFromFile(this._handle, chunkSizeToRead);
+        //if chunk length is lesser than requested, the end of the file is reached
+        this.hasDataToRead = chunk.length === chunkSizeToRead;
+        return chunk;
+    }
+    async getFileContent() {
+        const chunks = [];
+        while (this.hasDataToRead) {
+            chunks.push(await this.readNextChunk());
+        }
+        await this.close();
+        const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+        const fileBuffer = new Uint8Array(totalLength);
+        let offset = 0;
+        for (const chunk of chunks) {
+            fileBuffer.set(chunk, offset);
+            offset += chunk.length;
+        }
+        return fileBuffer;
+    }
+    /**
+     * Aborts the reading process and closes the file handle.
+     *
+     * @returns {Promise<string>} A promise that resolves when the file handle is closed.
+     */
+    async abort() {
+        return this._api.closeFile(this._handle);
+    }
+    /**
+     * Closes the file handle.
+     *
+     * @returns {Promise<string>} A promise that resolves when the file handle is closed and returns file ID.
+     */
+    async close() {
+        return this._api.closeFile(this._handle);
+    }
+}
+exports.StreamReader = StreamReader;
+class FileUploader {
+    _size;
+    offset = 0;
+    _api;
+    _reader;
+    /**
+     * Creates an instance of FileUploader.
+     *
+     * @param {number} handle - The file handle.
+     * @param {File} file - The data (file content) to upload.
+     * @param {StoreApi} api {@link StoreApi `StoreApi`} instance
+     */
+    constructor(file, api) {
+        this._size = file.size;
+        this._api = api;
+        this._reader = file.stream().getReader();
+    }
+    static async uploadStoreFile({ storeApi, storeId, file, privateMeta, publicMeta }) {
+        const meta = {
+            publicMeta: publicMeta || new Uint8Array(),
+            privateMeta: privateMeta || new Uint8Array()
+        };
+        const handle = await storeApi.createFile(storeId, meta.publicMeta, meta.privateMeta, file.size);
+        const streamer = new FileUploader(file, {
+            closeFile() {
+                return storeApi.closeFile(handle);
+            },
+            writeToFile(chunk) {
+                return storeApi.writeToFile(handle, chunk);
+            }
+        });
+        return streamer;
+    }
+    static async uploadInboxFile({ inboxApi, inboxHandle, preparedFileUpload }) {
+        const streamer = new FileUploader(preparedFileUpload.file, {
+            closeFile() {
+                return inboxApi.closeFile(preparedFileUpload.handle);
+            },
+            writeToFile(chunk) {
+                return inboxApi.writeToFile(inboxHandle, preparedFileUpload.handle, chunk);
+            }
+        });
+        return streamer;
+    }
+    static async prepareInboxUpload({ inboxApi, file, privateMeta, publicMeta }) {
+        const meta = {
+            publicMeta: publicMeta || new Uint8Array(),
+            privateMeta: privateMeta || new Uint8Array()
+        };
+        const handle = await inboxApi.createFileHandle(meta.publicMeta, meta.privateMeta, file.size);
+        return { file: file, handle };
+    }
+    /**
+     * Gets the progress of uploading the file as a percentage.
+     *
+     * @returns {number} The progress percentage.
+     */
+    get progress() {
+        if (this._size === 0)
+            return 100;
+        return (this.offset / this._size) * 100;
+    }
+    /**
+     * Sends the next chunk of the file data to the server.
+     *
+     * @returns {Promise<boolean>} A promise that resolves to true if there are more chunks to send, or false if all data has been sent.
+     */
+    async sendNextChunk() {
+        const { done, value } = await this._reader.read();
+        if (done) {
+            return false;
+        }
+        await this._api.writeToFile(value);
+        this.offset += value?.length;
+        return true;
+    }
+    async uploadFileContent() {
+        while (await this.sendNextChunk()) { }
+        return this.close();
+    }
+    /**
+     * Aborts the uploading process, closes the file handle, and deletes the uploaded part of the file.
+     *
+     * @returns {Promise<void>} A promise that resolves when the file handle is closed and the uploaded part is deleted.
+     */
+    async abort() {
+        await this._api.closeFile();
+    }
+    /**
+     * Closes the file handle.
+     *
+     * @returns {Promise<string>} A promise that resolves when the file handle is closed and returns file ID.
+     */
+    async close() {
+        this._reader.releaseLock();
+        return this._api.closeFile();
+    }
+}
+exports.FileUploader = FileUploader;
+/**
+ * Downloads a file from the server.
+ *
+ * @param {StoreApi|InboxApi} api - The API instance used for file operations.
+ * @param {string} fileId - The ID of the file to download.
+ * @param {string} [targetFileName] - The target file name for saving the downloaded file.
+ * @returns {Promise<void>} A promise that resolves when the download is complete.
+ */
+async function downloadFile(api, fileId, targetFileName) {
+    const filename = targetFileName || fileId;
+    const apiReader = await StreamReader.readFile(api, fileId);
+    if ('showSaveFilePicker' in window && window.isSecureContext) {
+        //@ts-ignore
+        const systemHandle = (await window.showSaveFilePicker({
+            id: 0,
+            suggestedName: filename,
+            startIn: 'downloads'
+        }));
+        const accessHandle = await systemHandle.createWritable();
+        for await (const [file] of apiReader) {
+            await accessHandle.write(file);
+        }
+        await accessHandle.close();
+    }
+    else {
+        const fileBuffer = await apiReader.getFileContent();
+        const anchor = document.createElement('a');
+        const reader = new FileReader();
+        reader.onload = (e) => {
+            if (!e.target)
+                return;
+            anchor.href = e.target.result;
+            anchor.download = filename;
+            anchor.click();
+        };
+        reader.readAsDataURL(new Blob([fileBuffer]));
+    }
+}
+exports.downloadFile = downloadFile;

package/extra/generics.d.ts

@@ -0,0 +1,19 @@
+import { Types } from '..';
+export interface CreateContainerPayload {
+    contextId: string;
+    users: Types.UserWithPubKey[];
+    managers: Types.UserWithPubKey[];
+    publicMeta?: Uint8Array;
+    privateMeta?: Uint8Array;
+}
+export interface UpdateContainerPayload {
+    users: Types.UserWithPubKey[];
+    managers: Types.UserWithPubKey[];
+    publicMeta?: Uint8Array;
+    privateMeta?: Uint8Array;
+    version: number;
+    options?: {
+        force?: boolean;
+        forceGenerateNewKey?: boolean;
+    };
+}

package/extra/generics.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/extra/inbox.d.ts

@@ -0,0 +1,38 @@
+import { Endpoint } from '..';
+/**
+ * Represents payload that is sent to an Inbox.
+ */
+export interface InboxEntryPayload {
+    /**
+     * Content of the entry.
+     */
+    data: Uint8Array;
+    /**
+     * Optional files associated with the entry.
+     */
+    files?: Array<{
+        /**
+         *Optional, contains confidential data that will be encrypted before being sent to server.
+         */
+        privateMeta?: Uint8Array;
+        /**
+         *Optional, contains data that can be accessed by everyone and is not encrypted.
+         */
+        publicMeta?: Uint8Array;
+        /**
+         * Content of the file.
+         */
+        content: File;
+    }>;
+}
+/**
+ * Sends an entry to the specified inbox.
+ *
+ * @param {Awaited<ReturnType<typeof Endpoint.createInboxApi>>} inboxApi - The API instance used to interact with the inbox.
+ * @param {string} inboxId - The ID of the target inbox where the entry will be sent.
+ * @param {InboxEntryPayload} payload - The data payload for the inbox entry, including files, metadata, and other information.
+ *
+ * @returns {Promise<void>} A promise that resolves when the entry has been successfully sent.
+ *
+ */
+export declare function sendEntry(inboxApi: Awaited<ReturnType<typeof Endpoint.createInboxApi>>, inboxId: string, payload: InboxEntryPayload): Promise<void>;

package/extra/inbox.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendEntry = void 0;
+const files_1 = require("./files");
+/**
+ * Sends an entry to the specified inbox.
+ *
+ * @param {Awaited<ReturnType<typeof Endpoint.createInboxApi>>} inboxApi - The API instance used to interact with the inbox.
+ * @param {string} inboxId - The ID of the target inbox where the entry will be sent.
+ * @param {InboxEntryPayload} payload - The data payload for the inbox entry, including files, metadata, and other information.
+ *
+ * @returns {Promise<void>} A promise that resolves when the entry has been successfully sent.
+ *
+ */
+async function sendEntry(inboxApi, inboxId, payload) {
+    const preparedFiles = payload.files
+        ? await Promise.all(payload.files.map((file) => {
+            return files_1.FileUploader.prepareInboxUpload({
+                inboxApi,
+                file: file.content,
+                privateMeta: file.privateMeta,
+                publicMeta: file.publicMeta
+            });
+        }))
+        : [];
+    const inboxEntryHandle = await inboxApi.prepareEntry(inboxId, payload.data, preparedFiles.map((file) => file.handle));
+    const uploaders = await Promise.all(preparedFiles.map((file) => files_1.FileUploader.uploadInboxFile({
+        inboxApi,
+        inboxHandle: inboxEntryHandle,
+        preparedFileUpload: file
+    })));
+    await Promise.all(uploaders.map((uploader) => uploader.uploadFileContent()));
+    await inboxApi.sendEntry(inboxEntryHandle);
+}
+exports.sendEntry = sendEntry;

package/extra/index.d.ts

@@ -0,0 +1,8 @@
+import * as Files from "./files";
+import * as Events from "./events";
+import { EventManager, ThreadEventsManager, StoreEventsManager, InboxEventsManager, BaseEventManager } from "./events";
+import * as Utils from "./utils";
+import * as Generics from "./generics";
+import * as Inboxes from "./inbox";
+import { FileUploader, StreamReader, downloadFile } from "./files";
+export { Files, Inboxes, Events, Utils, Generics, FileUploader, downloadFile, EventManager, ThreadEventsManager, StoreEventsManager, InboxEventsManager, BaseEventManager, StreamReader };

package/extra/index.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamReader = exports.BaseEventManager = exports.InboxEventsManager = exports.StoreEventsManager = exports.ThreadEventsManager = exports.EventManager = exports.downloadFile = exports.FileUploader = exports.Generics = exports.Utils = exports.Events = exports.Inboxes = exports.Files = void 0;
+const Files = require("./files");
+exports.Files = Files;
+const Events = require("./events");
+exports.Events = Events;
+const events_1 = require("./events");
+Object.defineProperty(exports, "EventManager", { enumerable: true, get: function () { return events_1.EventManager; } });
+Object.defineProperty(exports, "ThreadEventsManager", { enumerable: true, get: function () { return events_1.ThreadEventsManager; } });
+Object.defineProperty(exports, "StoreEventsManager", { enumerable: true, get: function () { return events_1.StoreEventsManager; } });
+Object.defineProperty(exports, "InboxEventsManager", { enumerable: true, get: function () { return events_1.InboxEventsManager; } });
+Object.defineProperty(exports, "BaseEventManager", { enumerable: true, get: function () { return events_1.BaseEventManager; } });
+const Utils = require("./utils");
+exports.Utils = Utils;
+const Generics = require("./generics");
+exports.Generics = Generics;
+const Inboxes = require("./inbox");
+exports.Inboxes = Inboxes;
+const files_1 = require("./files");
+Object.defineProperty(exports, "FileUploader", { enumerable: true, get: function () { return files_1.FileUploader; } });
+Object.defineProperty(exports, "StreamReader", { enumerable: true, get: function () { return files_1.StreamReader; } });
+Object.defineProperty(exports, "downloadFile", { enumerable: true, get: function () { return files_1.downloadFile; } });

package/extra/utils.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Helper function to convert objects to Uint8Array
+ * @param {Record<string, any>} object - The object to serialize
+ * @returns {Uint8Array} object serialized to `Uint8Array`
+ */
+export declare function serializeObject(object: Record<string, any>): Uint8Array;
+/**
+ * Helper function to convert Uint8Array to objects
+ * @param {Uint8Array} data - The data to deserialize
+ * @returns {Record<string, any>} parsed JSON object
+ */
+export declare function deserializeObject(data: Uint8Array): Record<string, any>;
+/**
+ * Convert Uint8Array to a string
+ * @param {Uint8Array} arr - The array to convert
+ * @returns {string} The resulting string
+ */
+export declare function uint8ToStr(arr: Uint8Array): string;
+/**
+ * Convert a string to Uint8Array
+ * @param {string} text - The text to convert
+ * @returns {Uint8Array} The resulting Uint8Array
+ */
+export declare function strToUint8(text: string): Uint8Array;

package/extra/utils.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.strToUint8 = exports.uint8ToStr = exports.deserializeObject = exports.serializeObject = void 0;
+/**
+ * Helper function to convert objects to Uint8Array
+ * @param {Record<string, any>} object - The object to serialize
+ * @returns {Uint8Array} object serialized to `Uint8Array`
+ */
+function serializeObject(object) {
+    if (object === null || typeof object !== 'object') {
+        throw new TypeError('Input must be a non-null object.');
+    }
+    const encoder = new TextEncoder();
+    const parsed = JSON.stringify(object);
+    return encoder.encode(parsed);
+}
+exports.serializeObject = serializeObject;
+/**
+ * Helper function to convert Uint8Array to objects
+ * @param {Uint8Array} data - The data to deserialize
+ * @returns {Record<string, any>} parsed JSON object
+ */
+function deserializeObject(data) {
+    if (!(data instanceof Uint8Array)) {
+        throw new TypeError('Input must be a Uint8Array.');
+    }
+    const decoder = new TextDecoder();
+    const decodedData = decoder.decode(data);
+    if (decodedData.trim() === '') {
+        return {};
+    }
+    try {
+        return JSON.parse(decodedData);
+    }
+    catch (error) {
+        if (error instanceof SyntaxError) {
+            throw new SyntaxError('Failed to parse JSON: ' + error.message);
+        }
+        else {
+            throw new Error('An unexpected error occurred: ' + String(error));
+        }
+    }
+}
+exports.deserializeObject = deserializeObject;
+/**
+ * Convert Uint8Array to a string
+ * @param {Uint8Array} arr - The array to convert
+ * @returns {string} The resulting string
+ */
+function uint8ToStr(arr) {
+    if (!(arr instanceof Uint8Array)) {
+        throw new TypeError('Input must be a Uint8Array.');
+    }
+    return new TextDecoder().decode(arr);
+}
+exports.uint8ToStr = uint8ToStr;
+/**
+ * Convert a string to Uint8Array
+ * @param {string} text - The text to convert
+ * @returns {Uint8Array} The resulting Uint8Array
+ */
+function strToUint8(text) {
+    if (typeof text !== 'string') {
+        throw new TypeError('Input must be a string.');
+    }
+    return new TextEncoder().encode(text);
+}
+exports.strToUint8 = strToUint8;

package/index.d.ts

@@ -0,0 +1,14 @@
+/*!
+PrivMX Web Endpoint.
+Copyright © 2024 Simplito sp. z o.o.
+
+This file is part of the PrivMX Platform (https://privmx.dev).
+This software is Licensed under the PrivMX Free License.
+
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+import { EndpointFactory } from "./service/EndpointFactory";
+import { EventQueue, StoreApi, ThreadApi, InboxApi, Connection, CryptoApi, BaseApi } from "./service";
+import * as Types from "./Types";
+export { EndpointFactory as Endpoint, Types, EventQueue, StoreApi, ThreadApi, InboxApi, CryptoApi, Connection, BaseApi, };

package/index.js

@@ -0,0 +1,25 @@
+"use strict";
+/*!
+PrivMX Web Endpoint.
+Copyright © 2024 Simplito sp. z o.o.
+
+This file is part of the PrivMX Platform (https://privmx.dev).
+This software is Licensed under the PrivMX Free License.
+
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseApi = exports.Connection = exports.CryptoApi = exports.InboxApi = exports.ThreadApi = exports.StoreApi = exports.EventQueue = exports.Types = exports.Endpoint = void 0;
+const EndpointFactory_1 = require("./service/EndpointFactory");
+Object.defineProperty(exports, "Endpoint", { enumerable: true, get: function () { return EndpointFactory_1.EndpointFactory; } });
+const service_1 = require("./service");
+Object.defineProperty(exports, "EventQueue", { enumerable: true, get: function () { return service_1.EventQueue; } });
+Object.defineProperty(exports, "StoreApi", { enumerable: true, get: function () { return service_1.StoreApi; } });
+Object.defineProperty(exports, "ThreadApi", { enumerable: true, get: function () { return service_1.ThreadApi; } });
+Object.defineProperty(exports, "InboxApi", { enumerable: true, get: function () { return service_1.InboxApi; } });
+Object.defineProperty(exports, "Connection", { enumerable: true, get: function () { return service_1.Connection; } });
+Object.defineProperty(exports, "CryptoApi", { enumerable: true, get: function () { return service_1.CryptoApi; } });
+Object.defineProperty(exports, "BaseApi", { enumerable: true, get: function () { return service_1.BaseApi; } });
+const Types = require("./Types");
+exports.Types = Types;

package/package.json

@@ -1,9 +1,8 @@
 {
   "name": "@simplito/privmx-webendpoint",
-  "version": "2.1.1",
+  "version": "2.2.0",
   "description": "PrivMX Web Endpoint library",
   "author": "Simplito",
-  "homepage": "https://privmx.dev",
   "license": "PrivMX Free License",
   "keywords": [
     "privmx",
@@ -29,5 +28,48 @@
     "privacy",
     "privacy-protection",
     "security"
-  ]
+  ],
+  "type": "commonjs",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "compile": "tsc",
+    "build": "npm run clean && npm run build:bundle && npm run build:mjs && npm run build:fixup",
+    "clean": "rm -rf ./dist",
+    "build:bundle": "webpack",
+    "build:mjs": "tsc -p tsconfig.mjs.json",
+    "build:fixup": "node fixup-package-json.js",
+    "watch": "tsc -w"
+  },
+  "engines": {
+    "node": ">=4"
+  },
+  "devDependencies": {
+    "@types/node": "^20.9.0",
+    "@types/webpack": "^5.28.5",
+    "assert": "^2.1.0",
+    "buffer": "^6.0.3",
+    "crypto-browserify": "^3.12.0",
+    "process": "^0.11.10",
+    "stream-browserify": "^3.0.0",
+    "ts-loader": "^9.5.1",
+    "ts-node": "^10.9.1",
+    "tslib": "^2.6.2",
+    "typescript": "^5.2.2",
+    "vm-browserify": "^1.1.2",
+    "webpack": "^5.89.0",
+    "webpack-cli": "^5.1.4",
+    "webpack-dev-server": "^4.15.1",
+    "@babel/core": "^7.26.0",
+    "@babel/preset-env": "^7.26.0",
+    "@types/jest": "^29.5.14",
+    "babel-jest": "^29.7.0",
+    "jest": "^29.7.0",
+    "prettier": "^3.4.2",
+    "ts-jest": "^29.2.5"
+  },
+  "dependencies": {
+  }
 }
+

package/service/BaseApi.d.ts

@@ -0,0 +1,16 @@
+/*!
+PrivMX Web Endpoint.
+Copyright © 2024 Simplito sp. z o.o.
+
+This file is part of the PrivMX Platform (https://privmx.dev).
+This software is Licensed under the PrivMX Free License.
+
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+export declare class BaseApi {
+    private _servicePtr;
+    constructor(ptr: number);
+    get servicePtr(): number;
+    destroyRefs(): void;
+}

package/service/BaseApi.js

@@ -0,0 +1,29 @@
+"use strict";
+/*!
+PrivMX Web Endpoint.
+Copyright © 2024 Simplito sp. z o.o.
+
+This file is part of the PrivMX Platform (https://privmx.dev).
+This software is Licensed under the PrivMX Free License.
+
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseApi = void 0;
+class BaseApi {
+    _servicePtr;
+    constructor(ptr) {
+        this._servicePtr = ptr;
+    }
+    get servicePtr() {
+        if (this._servicePtr < 0) {
+            throw new Error("This API instance is no longer valid because the connection associated with it has been closed.");
+        }
+        return this._servicePtr;
+    }
+    destroyRefs() {
+        this._servicePtr = -1;
+    }
+}
+exports.BaseApi = BaseApi;

package/service/Connection.d.ts

@@ -0,0 +1,45 @@
+/*!
+PrivMX Web Endpoint.
+Copyright © 2024 Simplito sp. z o.o.
+
+This file is part of the PrivMX Platform (https://privmx.dev).
+This software is Licensed under the PrivMX Free License.
+
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+import { BaseApi } from "./BaseApi";
+import { ConnectionNative } from "../api/ConnectionNative";
+import { PagingQuery, PagingList, Context } from "../Types";
+import { BaseNative } from "../api/BaseNative";
+export declare class Connection extends BaseApi {
+    private native;
+    apisRefs: {
+        [apiId: string]: {
+            _apiServicePtr: number;
+        };
+    };
+    nativeApisDeps: {
+        [apiId: string]: BaseNative;
+    };
+    constructor(native: ConnectionNative, ptr: number);
+    /**
+     * Gets the ID of the current connection.
+     *
+     * @returns {number} ID of the connection
+     */
+    getConnectionId(): Promise<number>;
+    /**
+     * Gets a list of Contexts available for the user.
+     *
+     * @param pagingQuery struct with list query parameters
+     * @returns {PagingList<Context>} struct containing a list of Contexts
+     */
+    listContexts(pagingQuery: PagingQuery): Promise<PagingList<Context>>;
+    /**
+     * Disconnects from the Platform backend.
+     *
+     */
+    disconnect(): Promise<void>;
+    private freeApis;
+}