@salesforce/nimbus-plugin-lds 1.303.0 → 1.304.0

package/dist/index.js

@@ -447,4 +447,107 @@ class MockNimbusNetworkAdapter {
     }
 }
 
-export { JsSqliteStorePlugin, JsSqliteStoreWebWorkerPlugin, MockNimbusNetworkAdapter, isUpsertOperation, sortedSchemaMigrations };
+function mockNimbusBinaryStorePlugin(plugin) {
+    var _a;
+    globalThis.__nimbus = {
+        ...(globalThis.__nimbus || {}),
+        plugins: {
+            // eslint-disable-next-line @salesforce/lds/no-optional-chaining
+            ...(((_a = globalThis.__nimbus) === null || _a === void 0 ? void 0 : _a.plugins) || {}),
+            LdsBinaryStorePlugin: plugin,
+        },
+    };
+}
+// simple in-memory BinaryStorePlugin implementation
+class MockNimbusBinaryStorePlugin {
+    constructor() {
+        this.counter = 0;
+        this.store = new Map();
+        this.streamsInProgress = new Map();
+        this.streamTypes = new Map();
+    }
+    storeBinary(data, type, size, onSuccess, _onError) {
+        const uri = this.counter.toString();
+        this.counter++;
+        this.store.set(uri, {
+            data,
+            type,
+            size,
+            canonicalUrl: null,
+            ttlSeconds: null,
+            expiration: null,
+        });
+        onSuccess(uri);
+    }
+    cacheBinary(url, ttlSeconds, onSuccess, _onError) {
+        // not gonna actually download a file in this mock impl
+        const mockData = new Uint8Array([1, 2, 3, 4, 5]);
+        const mockType = 'image/png';
+        const uri = this.counter.toString();
+        this.counter++;
+        this.store.set(uri, {
+            data: mockData,
+            type: mockType,
+            size: mockData.length,
+            canonicalUrl: url,
+            ttlSeconds,
+            expiration: Date.now() + ttlSeconds * 1000,
+        });
+        onSuccess(uri);
+    }
+    removeBinary(uri, onSuccess, _onError) {
+        onSuccess(this.store.delete(uri));
+    }
+    setCanonicalUrl(uri, canonicalUrl, ttlSeconds, onSuccess, onError) {
+        const fileInfo = this.store.get(uri);
+        // if the local file doesn't exist treat this same as calling "cacheBinary"
+        if (fileInfo === undefined) {
+            this.cacheBinary(canonicalUrl, ttlSeconds, onSuccess, onError);
+            return;
+        }
+        // else update the canonicalUrl and expiration info
+        this.store.set(uri, {
+            ...fileInfo,
+            canonicalUrl,
+            ttlSeconds,
+            // immediately expire
+            expiration: Date.now() - 1,
+        });
+        onSuccess(uri);
+    }
+    getBinary(uri) {
+        return this.store.get(uri);
+    }
+    createStream(type, onSuccess, _onError) {
+        const uri = this.counter.toString();
+        this.streamsInProgress.set(uri, new Uint8Array());
+        this.streamTypes.set(uri, type);
+        onSuccess(uri);
+    }
+    writeToStream(uri, chunk, onSuccess, _onError) {
+        const existingBytes = this.streamsInProgress.get(uri);
+        const newBytes = Buffer.from(chunk, 'base64');
+        let combinedBytes = new Uint8Array([...existingBytes, ...newBytes]);
+        this.streamsInProgress.set(uri, combinedBytes);
+        onSuccess(uri);
+    }
+    closeStream(uri, onSuccess, _onError) {
+        var _a, _b;
+        const data = (_a = this.streamsInProgress.get(uri)) !== null && _a !== void 0 ? _a : new Uint8Array();
+        const type = (_b = this.streamTypes.get(uri)) !== null && _b !== void 0 ? _b : 'undefined';
+        this.streamsInProgress.delete(uri);
+        this.streamTypes.delete(uri);
+        // also add it to the store for testing
+        this.store.set(uri, {
+            data: data,
+            type: type,
+            size: data.length,
+            canonicalUrl: null,
+            ttlSeconds: null,
+            expiration: null,
+        });
+        onSuccess(uri);
+    }
+}
+
+export { JsSqliteStorePlugin, JsSqliteStoreWebWorkerPlugin, MockNimbusBinaryStorePlugin, MockNimbusNetworkAdapter, isUpsertOperation, mockNimbusBinaryStorePlugin, sortedSchemaMigrations };

package/dist/types/BinaryStorePlugin.d.ts

@@ -79,4 +79,32 @@ export interface BinaryStorePlugin {
      * @param onError Callback to call if there was an error.
      */
     setCanonicalUrl(uri: string, canonicalUrl: string, ttlSeconds: number, onSuccess: (uri: string) => void, onError: (errorMessage: string) => void): void;
+    /**
+     * Creates a stream that can be used to write buffered chunks of base64-encoded data.
+     * This function should be used in conjunction with writeToStream() and closeStream().
+     *
+     * @param type The MIME type of the binary file. Ex: "image/png".
+     * @returns A Promise of a string representing the URI of the binary file. NOTE: the URI
+     *          to a binary file should be treated as opaque (only use it to pass into methods
+     *          on this interface).
+     */
+    createStream(type: string, onSuccess: (uri: string) => void, onError: (errorMessage: string) => void): void;
+    /**
+     * Writes a base64-encoded chunk of data to the stream identified by the stream uri provided
+     * by the call from createStream().
+     *
+     * @param uri The URI of the file.
+     * @returns A Promise of a string representing the URI of the binary file that was succesfully
+     *          written to.
+     */
+    writeToStream(uri: string, chunk: string, onSuccess: (uri: string) => void, onError: (errorMessage: string) => void): void;
+    /**
+     * Closes the stream represented by the given uri. Once a stream is closed, it cannot be
+     * written to and will cause an error to be returned.
+     *
+     * @param uri The URI of the file.
+     * @returns A Promise of a string representing the URI of the binary file that was succesfully
+     *          closed.
+     */
+    closeStream(uri: string, onSuccess: (uri: string) => void, onError: (errorMessage: string) => void): void;
 }

package/dist/types/index.d.ts

@@ -9,3 +9,4 @@ export { sortedSchemaMigrations, isUpsertOperation } from './SqliteStorePlugin';
 export { JsSqliteStorePlugin } from './JsSqliteStorePlugin/JsSqliteStorePlugin';
 export { JsSqliteStoreWebWorkerPlugin } from './JsSqliteStorePlugin/JsWorkerSqliteStorePlugin';
 export { MockNimbusNetworkAdapter } from './mocks/MockNimbusNetworkAdapter';
+export { MockNimbusBinaryStorePlugin, mockNimbusBinaryStorePlugin, } from './mocks/MockNimbusBinaryStorePlugin';

package/dist/types/mocks/MockNimbusBinaryStorePlugin.d.ts

@@ -0,0 +1,25 @@
+import type { BinaryStorePlugin } from '../BinaryStorePlugin';
+export declare function mockNimbusBinaryStorePlugin(plugin: BinaryStorePlugin): void;
+interface FileInfo {
+    data: Uint8Array;
+    type: string;
+    size: number;
+    canonicalUrl: string | null;
+    ttlSeconds: number | null;
+    expiration: number | null;
+}
+export declare class MockNimbusBinaryStorePlugin implements BinaryStorePlugin {
+    private counter;
+    private store;
+    private streamsInProgress;
+    private streamTypes;
+    storeBinary(data: Uint8Array, type: string, size: number, onSuccess: (uri: string) => void, _onError: (errorMessage: string) => void): void;
+    cacheBinary(url: string, ttlSeconds: number, onSuccess: (uri: string) => void, _onError: (errorMessage: string) => void): void;
+    removeBinary(uri: string, onSuccess: (wasFound: boolean) => void, _onError: (errorMessage: string) => void): void;
+    setCanonicalUrl(uri: string, canonicalUrl: string, ttlSeconds: number, onSuccess: (uri: string) => void, onError: (errorMessage: string) => void): void;
+    getBinary(uri: string): FileInfo | undefined;
+    createStream(type: string, onSuccess: (uri: string) => void, _onError: (errorMessage: string) => void): void;
+    writeToStream(uri: string, chunk: string, onSuccess: (uri: string) => void, _onError: (errorMessage: string) => void): void;
+    closeStream(uri: string, onSuccess: (uri: string) => void, _onError: (errorMessage: string) => void): void;
+}
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@salesforce/nimbus-plugin-lds",
-    "version": "1.303.0",
+    "version": "1.304.0",
     "license": "SEE LICENSE IN LICENSE.txt",
     "description": "Nimbus plugins for LDS on Mobile native integrations: durable store, networking, and draft queue.",
     "types": "dist/types/index.d.ts",
@@ -25,7 +25,7 @@
     },
     "devDependencies": {
         "@rollup/plugin-wasm": "^5.2.0",
-        "@salesforce/lds-store-sql": "^1.303.0",
+        "@salesforce/lds-store-sql": "^1.304.0",
         "@types/sql.js": "1.4.4",
         "nimbus-types": "^2.0.0-alpha1",
         "rollup-plugin-string": "^3.0.0",