@salesforce/lds-store-nimbus 1.233.0 → 1.235.0

package/dist/index.js

@@ -1,6 +1,6 @@
 import { DefaultDurableSegment } from '@luvio/environments';
 
-const { keys, create, assign, entries } = Object;
+const { keys, create, assign, entries, values } = Object;
 const { stringify, parse } = JSON;
 
 function selectColumnsFromTableWhereKeyIn(columnNames, table, keyColumnName, whereIn) {
@@ -34,6 +34,22 @@ class LdsDataTable {
             }, reject);
         });
     }
+    getMetadataByKeys(keys) {
+        const query = selectColumnsFromTableWhereKeyIn([COLUMN_NAME_KEY$2, COLUMN_NAME_METADATA$1], this.tableName, COLUMN_NAME_KEY$2, keys);
+        return new Promise((resolve, reject) => {
+            this.plugin.query(query, keys, (results) => {
+                resolve(results.rows.reduce((entries, row) => {
+                    const [key, stringifiedMetadata] = row;
+                    if (stringifiedMetadata !== undefined) {
+                        entries[key] = {
+                            metadata: parse(stringifiedMetadata),
+                        };
+                    }
+                    return entries;
+                }, {}));
+            }, reject);
+        });
+    }
     getAll() {
         return new Promise((resolve, reject) => {
             this.plugin.query(this.getAllQuery, [], (x) => {
@@ -60,6 +76,24 @@ class LdsDataTable {
             }, []),
         };
     }
+    metadataToUpdateOperations(entries, segment) {
+        return {
+            type: 'update',
+            table: this.tableName,
+            keyColumn: COLUMN_NAME_KEY$2,
+            context: {
+                segment,
+                type: 'setMetadata',
+            },
+            columns: [COLUMN_NAME_METADATA$1],
+            values: keys(entries).reduce((values, key) => {
+                const { metadata } = entries[key];
+                const row = [metadata ? stringify(metadata) : null];
+                values[key] = row;
+                return values;
+            }, {}),
+        };
+    }
     mapToDurableEntries(sqliteResult) {
         return sqliteResult.rows.reduce((entries, row) => {
             const [key, stringifiedData, stringifiedMetadata] = row;
@@ -106,6 +140,25 @@ class LdsInternalDataTable {
             }, reject);
         });
     }
+    getMetadataByKeys(keys, namespace) {
+        if (namespace === undefined) {
+            throw Error('LdsInternalDataTable requires namespace');
+        }
+        const query = selectColumnsFromTableWhereKeyInNamespaced([COLUMN_NAME_KEY$1, COLUMN_NAME_METADATA], this.tableName, COLUMN_NAME_KEY$1, keys, COLUMN_NAME_NAMESPACE);
+        return new Promise((resolve, reject) => {
+            this.plugin.query(query, [namespace].concat(keys), (results) => {
+                resolve(results.rows.reduce((entries, row) => {
+                    const [key, stringifiedMetadata] = row;
+                    if (stringifiedMetadata !== undefined) {
+                        entries[key] = {
+                            metadata: parse(stringifiedMetadata),
+                        };
+                    }
+                    return entries;
+                }, {}));
+            }, reject);
+        });
+    }
     getAll(namespace) {
         return new Promise((resolve, reject) => {
             this.plugin.query(this.getAllQuery, [namespace], (x) => {
@@ -139,6 +192,42 @@ class LdsInternalDataTable {
             }, []),
         };
     }
+    metadataToUpdateOperations(entries, segment) {
+        return {
+            type: 'update',
+            table: this.tableName,
+            keyColumn: COLUMN_NAME_KEY$1,
+            context: {
+                segment,
+                type: 'setMetadata',
+            },
+            columns: [COLUMN_NAME_METADATA],
+            values: keys(entries).reduce((values, key) => {
+                const { metadata } = entries[key];
+                const row = [metadata ? stringify(metadata) : null];
+                values[key] = row;
+                return values;
+            }, {}),
+        };
+    }
+    metadataToUpdateSQLQueries(entries, segment) {
+        return keys(entries).reduce((accu, key) => {
+            const { metadata } = entries[key];
+            if (metadata !== undefined) {
+                accu.push({
+                    sql: `UPDATE ${this.tableName} SET ${COLUMN_NAME_METADATA} = ? WHERE (${COLUMN_NAME_KEY$1} IS ? AND ${COLUMN_NAME_NAMESPACE} IS ?)`,
+                    params: [stringify(metadata), key, segment],
+                    change: {
+                        ids: [key],
+                        segment,
+                        type: 'setMetadata',
+                        isExternalChange: false,
+                    },
+                });
+            }
+            return accu;
+        }, []);
+    }
     mapToDurableEntries(sqliteResult) {
         return sqliteResult.rows.reduce((entries, row) => {
             const [key, stringifiedData, stringifiedMetadata] = row;
@@ -175,9 +264,16 @@ class NimbusSqliteStore {
             });
         });
     }
+    batchQuery(queries) {
+        const promises = queries.map((q) => this.query(q.sql, q.params));
+        return Promise.all(promises);
+    }
     async getEntries(entryIds, segment) {
         return this.getTable(segment).getByKeys(entryIds, segment);
     }
+    async getMetadata(entryIds, segment) {
+        return this.getTable(segment).getMetadataByKeys(entryIds, segment);
+    }
     getAllEntries(segment) {
         return this.getTable(segment).getAll(segment);
     }
@@ -186,12 +282,30 @@ class NimbusSqliteStore {
         const upsertOperation = table.entriesToUpsertOperations(entries, segment);
         return this.batchOperationAsPromise([upsertOperation]);
     }
+    setMetadata(entries, segment) {
+        const table = this.getTable(segment);
+        const operation = this.plugin.supportsBatchUpdates === undefined ||
+            this.plugin.supportsBatchUpdates() === false
+            ? table.entriesToUpsertOperations(entries, segment)
+            : table.metadataToUpdateOperations(entries, segment);
+        return this.batchOperationAsPromise([operation]);
+    }
     batchOperations(operations) {
         const sqliteOperations = operations.reduce((acc, cur) => {
             if (cur.type === 'setEntries') {
                 const table = this.getTable(cur.segment);
                 acc.push(table.entriesToUpsertOperations(cur.entries, cur.segment));
             }
+            else if (cur.type === 'setMetadata') {
+                const table = this.getTable(cur.segment);
+                if (this.plugin.supportsBatchUpdates === undefined ||
+                    this.plugin.supportsBatchUpdates() === false) {
+                    acc.push(table.entriesToUpsertOperations(cur.entries, cur.segment));
+                }
+                else {
+                    acc.push(table.metadataToUpdateOperations(cur.entries, cur.segment));
+                }
+            }
             else {
                 acc.push(this.idsToDeleteOperation(cur.ids, cur.segment));
             }
@@ -208,8 +322,15 @@ class NimbusSqliteStore {
         this.plugin
             .registerOnChangedListener(async (changes) => {
             const durableChanges = changes.map((c) => {
+                let type = c.type === 'upsert' ? 'setEntries' : 'evictEntries';
+                // if our context contains a type then set that as our main level type
+                // allows us in the future of updates to specify the segment change happening
+                // example being update call on metadata only or updating data
+                if (c.type === 'update' && c.context.type !== undefined) {
+                    type = c.context.type;
+                }
                 return {
-                    type: c.type === 'upsert' ? 'setEntries' : 'evictEntries',
+                    type,
                     ids: c.keys,
                     isExternalChange: false,
                     segment: c.context.segment,
@@ -276,6 +397,10 @@ class AbstractKeyValueDataTable {
             }, reject);
         });
     }
+    getMetadataByKeys(_keys) {
+        // eslint-disable-next-line @salesforce/lds/no-error-in-production
+        throw new Error(`There is no metadata in the ${this.tableName} table.`);
+    }
     getAll() {
         const getAllQuery = `SELECT ${this.columnNames.join(',')} FROM ${this.tableName}`;
         return new Promise((resolve, reject) => {
@@ -301,6 +426,10 @@ class AbstractKeyValueDataTable {
             }, []),
         };
     }
+    metadataToUpdateOperations(_entries, _segment) {
+        // eslint-disable-next-line @salesforce/lds/no-error-in-production
+        throw new Error(`There is no metadata in the ${this.tableName} table.`);
+    }
     mapToDurableEntries(sqliteResult) {
         return sqliteResult.rows.reduce((entries, row) => {
             const [key, stringifiedData] = row;

package/dist/types/NimbusSqliteStore.d.ts

@@ -1,7 +1,12 @@
 import type { SqliteResult, SqliteStore, SqliteType } from '@salesforce/lds-store-sql';
 import type { SqliteStorePlugin } from '@salesforce/nimbus-plugin-lds';
-import type { DurableStore, DurableStoreEntries, DurableStoreOperation, OnDurableStoreChangedListener } from '@luvio/environments';
+import type { DurableStore, DurableStoreChange, DurableStoreEntries, DurableStoreMetadataEntries, DurableStoreOperation, OnDurableStoreChangedListener } from '@luvio/environments';
 import type { LdsDataTableBase } from './tables';
+export type SQLQuery = {
+    sql: string;
+    params: SqliteType[];
+    change: DurableStoreChange;
+};
 export declare class NimbusSqliteStore implements SqliteStore, DurableStore {
     private plugin;
     private readonly dataTableMap;
@@ -9,9 +14,12 @@ export declare class NimbusSqliteStore implements SqliteStore, DurableStore {
     constructor(plugin: SqliteStorePlugin, additionalTableMap?: Record<string, LdsDataTableBase>);
     isEvalSupported(): boolean;
     query(sql: string, params: SqliteType[]): Promise<SqliteResult>;
+    batchQuery(queries: SQLQuery[]): Promise<SqliteResult[]>;
     getEntries<T>(entryIds: string[], segment: string): Promise<DurableStoreEntries<T> | undefined>;
+    getMetadata(entryIds: string[], segment: string): Promise<DurableStoreMetadataEntries | undefined>;
     getAllEntries<T>(segment: string): Promise<DurableStoreEntries<T> | undefined>;
     setEntries<T>(entries: DurableStoreEntries<T>, segment: string): Promise<void>;
+    setMetadata(entries: DurableStoreMetadataEntries, segment: string): Promise<void>;
     batchOperations<T>(operations: DurableStoreOperation<T>[]): Promise<void>;
     evictEntries(entryIds: string[], segment: string): Promise<void>;
     registerOnChangedListener(listener: OnDurableStoreChangedListener): () => Promise<void>;

package/dist/types/tables/AbstractKeyValueDataTable.d.ts

@@ -1,5 +1,5 @@
 import type { SqliteOperation, SqliteStorePlugin } from '@salesforce/nimbus-plugin-lds';
-import type { DurableStoreEntries } from '@luvio/environments';
+import type { DurableStoreEntries, DurableStoreMetadataEntries } from '@luvio/environments';
 import type { LdsDataTableBase } from '../tables/LdsDataTableBase';
 export declare abstract class AbstractKeyValueDataTable implements LdsDataTableBase {
     readonly tableName: SqliteOperation['table'];
@@ -8,7 +8,9 @@ export declare abstract class AbstractKeyValueDataTable implements LdsDataTableB
     private conflictColumnNames;
     constructor(plugin: SqliteStorePlugin, tableName: SqliteOperation['table']);
     getByKeys<T>(keys: string[]): Promise<DurableStoreEntries<T>>;
+    getMetadataByKeys(_keys: string[]): Promise<DurableStoreMetadataEntries | undefined>;
     getAll<T>(): Promise<DurableStoreEntries<T>>;
     entriesToUpsertOperations<T>(entries: DurableStoreEntries<T>, segment: string): SqliteOperation;
+    metadataToUpdateOperations(_entries: DurableStoreMetadataEntries, _segment: string): SqliteOperation;
     private mapToDurableEntries;
 }

package/dist/types/tables/LdsDataTable.d.ts

@@ -1,5 +1,5 @@
 import type { SqliteOperation, SqliteStorePlugin } from '@salesforce/nimbus-plugin-lds';
-import type { DurableStoreEntries } from '@luvio/environments';
+import type { DurableStoreEntries, DurableStoreMetadataEntries } from '@luvio/environments';
 import type { LdsDataTableBase } from '../tables/LdsDataTableBase';
 export declare class LdsDataTable implements LdsDataTableBase {
     readonly tableName = "lds_data";
@@ -9,7 +9,9 @@ export declare class LdsDataTable implements LdsDataTableBase {
     private getAllQuery;
     constructor(plugin: SqliteStorePlugin);
     getByKeys<T>(keys: string[]): Promise<DurableStoreEntries<T>>;
+    getMetadataByKeys(keys: string[]): Promise<DurableStoreMetadataEntries | undefined>;
     getAll<T>(): Promise<DurableStoreEntries<T>>;
     entriesToUpsertOperations<T>(entries: DurableStoreEntries<T>, segment: string): SqliteOperation;
+    metadataToUpdateOperations(entries: DurableStoreMetadataEntries, segment: string): SqliteOperation;
     private mapToDurableEntries;
 }

package/dist/types/tables/LdsDataTableBase.d.ts

@@ -1,8 +1,10 @@
-import type { DurableStoreEntries } from '@luvio/environments';
+import type { DurableStoreEntries, DurableStoreMetadataEntries } from '@luvio/environments';
 import type { SqliteOperation } from '@salesforce/nimbus-plugin-lds';
 export interface LdsDataTableBase {
     tableName: SqliteOperation['table'];
     getByKeys<T>(keys: string[], segment?: string): Promise<DurableStoreEntries<T>>;
+    getMetadataByKeys(keys: string[], segment?: string): Promise<DurableStoreMetadataEntries | undefined>;
     getAll<T>(segment?: string): Promise<DurableStoreEntries<T>>;
     entriesToUpsertOperations<T>(entries: DurableStoreEntries<T>, segment: string): SqliteOperation;
+    metadataToUpdateOperations(entries: DurableStoreMetadataEntries, segment: string): SqliteOperation;
 }

package/dist/types/tables/LdsInternalDataTable.d.ts

@@ -1,6 +1,7 @@
 import type { SqliteOperation, SqliteStorePlugin } from '@salesforce/nimbus-plugin-lds';
-import type { DurableStoreEntries } from '@luvio/environments';
+import type { DurableStoreEntries, DurableStoreMetadataEntries } from '@luvio/environments';
 import type { LdsDataTableBase } from '../tables';
+import type { SQLQuery } from '../NimbusSqliteStore';
 export declare class LdsInternalDataTable implements LdsDataTableBase {
     readonly tableName = "lds_internal";
     readonly plugin: SqliteStorePlugin;
@@ -9,7 +10,10 @@ export declare class LdsInternalDataTable implements LdsDataTableBase {
     private getAllQuery;
     constructor(plugin: SqliteStorePlugin);
     getByKeys<T>(keys: string[], namespace: string): Promise<DurableStoreEntries<T>>;
+    getMetadataByKeys(keys: string[], namespace: string): Promise<DurableStoreMetadataEntries | undefined>;
     getAll<T>(namespace: string): Promise<DurableStoreEntries<T>>;
     entriesToUpsertOperations<T>(entries: DurableStoreEntries<T>, segment: string): SqliteOperation;
+    metadataToUpdateOperations(entries: DurableStoreMetadataEntries, segment: string): SqliteOperation;
+    metadataToUpdateSQLQueries(entries: DurableStoreMetadataEntries, segment: string): SQLQuery[];
     private mapToDurableEntries;
 }

package/dist/types/utils/language.d.ts

@@ -14,6 +14,11 @@ declare const keys: {
         [s: string]: T;
     } | ArrayLike<T>): [string, T][];
     (o: {}): [string, any][];
+}, values: {
+    <T>(o: {
+        [s: string]: T;
+    } | ArrayLike<T>): T[];
+    (o: {}): any[];
 };
 declare const stringify: {
     (value: any, replacer?: ((this: any, key: string, value: any) => any) | undefined, space?: string | number | undefined): string;
@@ -26,4 +31,4 @@ declare const isArray: (arg: any) => arg is any[], from: {
     <T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
     <T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
 };
-export { keys as ObjectKeys, create as ObjectCreate, assign as ObjectAssign, entries as ObjectEntries, push as ArrayPrototypePush, join as ArrayPrototypeJoin, slice as ArrayPrototypeSlice, isArray as ArrayIsArray, from as ArrayFrom, stringify as JSONStringify, parse as JSONParse, };
+export { keys as ObjectKeys, create as ObjectCreate, assign as ObjectAssign, entries as ObjectEntries, values as ObjectValues, push as ArrayPrototypePush, join as ArrayPrototypeJoin, slice as ArrayPrototypeSlice, isArray as ArrayIsArray, from as ArrayFrom, stringify as JSONStringify, parse as JSONParse, };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@salesforce/lds-store-nimbus",
-    "version": "1.233.0",
+    "version": "1.235.0",
     "description": "A nimbus-plugin-based implementation of the Luvio DurableStore and SqliteStore.",
     "license": "SEE LICENSE IN LICENSE.txt",
     "types": "dist/types/index.d.ts",
@@ -26,7 +26,7 @@
     },
     "dependencies": {},
     "devDependencies": {
-        "@luvio/environments": "0.145.3",
+        "@luvio/environments": "0.147.1",
         "@salesforce/nimbus-plugin-lds": "*",
         "@salesforce/lds-store-sql": "*"
     },
@@ -34,8 +34,8 @@
         {
             "path": "./dist/index.js",
             "maxSize": {
-                "none": "12 kB",
-                "min": "7 kB",
+                "none": "17 kB",
+                "min": "8 kB",
                 "compressed": "3 kB"
             }
         }