@salesforce/lds-store-nimbus 0.1.0-dev1

package/LICENSE.txt

@@ -0,0 +1,82 @@
+Terms of Use
+
+Copyright 2022 Salesforce, Inc. All rights reserved.
+
+These Terms of Use govern the download, installation, and/or use of this
+software provided by Salesforce, Inc. ("Salesforce") (the "Software"), were
+last updated on April 15, 2022, and constitute a legally binding
+agreement between you and Salesforce. If you do not agree to these Terms of
+Use, do not install or use the Software.
+
+Salesforce grants you a worldwide, non-exclusive, no-charge, royalty-free
+copyright license to reproduce, prepare derivative works of, publicly
+display, publicly perform, sublicense, and distribute the Software and
+derivative works subject to these Terms. These Terms shall be included in
+all copies or substantial portions of the Software.
+
+Subject to the limited rights expressly granted hereunder, Salesforce
+reserves all rights, title, and interest in and to all intellectual
+property subsisting in the Software. No rights are granted to you hereunder
+other than as expressly set forth herein. Users residing in countries on
+the United States Office of Foreign Assets Control sanction list, or which
+are otherwise subject to a US export embargo, may not use the Software.
+
+Implementation of the Software may require development work, for which you
+are responsible. The Software may contain bugs, errors and
+incompatibilities and is made available on an AS IS basis without support,
+updates, or service level commitments.
+
+Salesforce reserves the right at any time to modify, suspend, or
+discontinue, the Software (or any part thereof) with or without notice. You
+agree that Salesforce shall not be liable to you or to any third party for
+any modification, suspension, or discontinuance.
+
+You agree to defend Salesforce against any claim, demand, suit or
+proceeding made or brought against Salesforce by a third party arising out
+of or accruing from (a) your use of the Software, and (b) any application
+you develop with the Software that infringes any copyright, trademark,
+trade secret, trade dress, patent, or other intellectual property right of
+any person or defames any person or violates their rights of publicity or
+privacy (each a "Claim Against Salesforce"), and will indemnify Salesforce
+from any damages, attorney fees, and costs finally awarded against
+Salesforce as a result of, or for any amounts paid by Salesforce under a
+settlement approved by you in writing of, a Claim Against Salesforce,
+provided Salesforce (x) promptly gives you written notice of the Claim
+Against Salesforce, (y) gives you sole control of the defense and
+settlement of the Claim Against Salesforce (except that you may not settle
+any Claim Against Salesforce unless it unconditionally releases Salesforce
+of all liability), and (z) gives you all reasonable assistance, at your
+expense.
+
+WITHOUT LIMITING THE GENERALITY OF THE FOREGOING, THE SOFTWARE IS NOT
+SUPPORTED AND IS PROVIDED "AS IS," WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED. IN NO EVENT SHALL SALESFORCE HAVE ANY LIABILITY FOR ANY DAMAGES,
+INCLUDING, BUT NOT LIMITED TO, DIRECT, INDIRECT, SPECIAL, INCIDENTAL,
+PUNITIVE, OR CONSEQUENTIAL DAMAGES, OR DAMAGES BASED ON LOST PROFITS, DATA,
+OR USE, IN CONNECTION WITH THE SOFTWARE, HOWEVER CAUSED AND WHETHER IN
+CONTRACT, TORT, OR UNDER ANY OTHER THEORY OF LIABILITY, WHETHER OR NOT YOU
+HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+
+These Terms of Use shall be governed exclusively by the internal laws of
+the State of California, without regard to its conflicts of laws
+rules. Each party hereby consents to the exclusive jurisdiction of the
+state and federal courts located in San Francisco County, California to
+adjudicate any dispute arising out of or relating to these Terms of Use and
+the download, installation, and/or use of the Software. Except as expressly
+stated herein, these Terms of Use constitute the entire agreement between
+the parties, and supersede all prior and contemporaneous agreements,
+proposals, or representations, written or oral, concerning their subject
+matter. No modification, amendment, or waiver of any provision of these
+Terms of Use shall be effective unless it is by an update to these Terms of
+Use that Salesforce makes available, or is in writing and signed by the
+party against whom the modification, amendment, or waiver is to be
+asserted.
+
+Data Privacy: Salesforce may collect, process, and store device,
+system, and other information related to your use of the Software. This
+information includes, but is not limited to, IP address, user metrics, and
+other data ("Usage Data"). Salesforce may use Usage Data for analytics,
+product development, and marketing purposes. You acknowledge that files
+generated in conjunction with the Software may contain sensitive or
+confidential data, and you are solely responsible for anonymizing and
+protecting such data.

package/dist/index.js

@@ -0,0 +1,488 @@
+import { DefaultDurableSegment } from '@luvio/environments';
+import { idleDetector, getInstrumentation } from 'o11y/client';
+
+const { keys, create, assign, entries, values } = Object;
+const { stringify, parse } = JSON;
+
+function selectColumnsFromTableWhereKeyIn(columnNames, table, keyColumnName, whereIn) {
+    const paramList = whereIn.map(() => '?').join(',');
+    return `SELECT ${columnNames.join(',')} FROM ${table} WHERE ${keyColumnName} IN (${paramList})`;
+}
+function selectColumnsFromTableWhereKeyInNamespaced(columnNames, table, keyColumnName, whereIn, namespaceColumnName) {
+    const paramList = whereIn.map(() => '?').join(',');
+    return `SELECT ${columnNames.join(',')} FROM ${table} WHERE ${namespaceColumnName} = ? AND ${keyColumnName} IN (${paramList})`;
+}
+
+// These const values must be in sync with the latest
+// @salesforce/nimbus-plugin-lds/sql schema file
+const TABLE_NAME$1 = 'lds_data';
+const COLUMN_NAME_KEY$2 = 'key';
+const COLUMN_NAME_DATA$2 = 'data';
+const COLUMN_NAME_METADATA$1 = 'metadata';
+class LdsDataTable {
+    constructor(plugin) {
+        this.tableName = TABLE_NAME$1;
+        this.columnNames = [COLUMN_NAME_KEY$2, COLUMN_NAME_DATA$2, COLUMN_NAME_METADATA$1];
+        this.conflictColumnNames = [COLUMN_NAME_KEY$2];
+        this.getAllQuery = `SELECT ${this.columnNames.join(',')} FROM ${this.tableName}`;
+        this.plugin = plugin;
+    }
+    getByKeys(keys) {
+        const getQuery = selectColumnsFromTableWhereKeyIn(this.columnNames, this.tableName, COLUMN_NAME_KEY$2, keys);
+        return new Promise((resolve, reject) => {
+            this.plugin.query(getQuery, keys, (x) => {
+                resolve(this.mapToDurableEntries(x));
+            }, 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) => {
+                resolve(this.mapToDurableEntries(x));
+            }, reject);
+        });
+    }
+    entriesToUpsertOperations(entries, segment) {
+        return {
+            type: 'upsert',
+            table: this.tableName,
+            keyColumn: COLUMN_NAME_KEY$2,
+            context: {
+                segment,
+            },
+            conflictColumns: this.conflictColumnNames,
+            columns: this.columnNames,
+            rows: keys(entries).reduce((rows, key) => {
+                const entry = entries[key];
+                const { data, metadata } = entry;
+                const row = [key, stringify(data), metadata ? stringify(metadata) : null];
+                rows.push(row);
+                return rows;
+            }, []),
+        };
+    }
+    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;
+            const durableStoreEntry = {
+                data: parse(stringifiedData),
+            };
+            if (stringifiedMetadata !== null) {
+                durableStoreEntry.metadata = parse(stringifiedMetadata);
+            }
+            entries[key] = durableStoreEntry;
+            return entries;
+        }, {});
+    }
+}
+
+// These const values must be in sync with the latest
+// @salesforce/nimbus-plugin-lds/sql schema file
+const TABLE_NAME = 'lds_internal';
+const COLUMN_NAME_KEY$1 = 'key';
+const COLUMN_NAME_DATA$1 = 'data';
+const COLUMN_NAME_METADATA = 'metadata';
+const COLUMN_NAME_NAMESPACE = 'namespace';
+class LdsInternalDataTable {
+    constructor(plugin) {
+        this.tableName = TABLE_NAME;
+        this.columnNames = [
+            COLUMN_NAME_KEY$1,
+            COLUMN_NAME_DATA$1,
+            COLUMN_NAME_METADATA,
+            COLUMN_NAME_NAMESPACE,
+        ];
+        this.conflictColumnNames = [COLUMN_NAME_KEY$1, COLUMN_NAME_NAMESPACE];
+        this.getAllQuery = `SELECT ${this.columnNames.join(',')} FROM ${this.tableName} WHERE ${COLUMN_NAME_NAMESPACE} = ?`;
+        this.plugin = plugin;
+    }
+    getByKeys(keys, namespace) {
+        if (namespace === undefined) {
+            throw Error('LdsInternalDataTable requires namespace');
+        }
+        const getQuery = selectColumnsFromTableWhereKeyInNamespaced(this.columnNames, this.tableName, COLUMN_NAME_KEY$1, keys, COLUMN_NAME_NAMESPACE);
+        return new Promise((resolve, reject) => {
+            this.plugin.query(getQuery, [namespace].concat(keys), (x) => {
+                resolve(this.mapToDurableEntries(x));
+            }, 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) => {
+                resolve(this.mapToDurableEntries(x));
+            }, reject);
+        });
+    }
+    entriesToUpsertOperations(entries, segment) {
+        return {
+            type: 'upsert',
+            table: this.tableName,
+            keyColumn: COLUMN_NAME_KEY$1,
+            context: {
+                segment,
+            },
+            conflictColumns: this.conflictColumnNames,
+            columns: this.columnNames,
+            rows: keys(entries).reduce((rows, key) => {
+                const entry = entries[key];
+                const { data, metadata } = entry;
+                const row = [key, stringify(data)];
+                if (metadata) {
+                    row.push(stringify(metadata));
+                }
+                else {
+                    row.push(null);
+                }
+                row.push(segment);
+                rows.push(row);
+                return rows;
+            }, []),
+        };
+    }
+    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;
+            const durableStoreEntry = {
+                data: parse(stringifiedData),
+            };
+            if (stringifiedMetadata !== null) {
+                durableStoreEntry.metadata = parse(stringifiedMetadata);
+            }
+            entries[key] = durableStoreEntry;
+            return entries;
+        }, {});
+    }
+}
+
+const tasker = idleDetector.declareNotifierTaskMulti('NimbusSqliteStore');
+const instrumentation = getInstrumentation('lds-mobile');
+const GRAPHQL_QUERY_ROOT_KEY = 'UiApi::uiapi::Query[uiapi]__uiapi__query';
+const GRAPHQL_QUERY_ROOT_METRIC_NAME = 'gql-query-root-object-size';
+class NimbusSqliteStore {
+    constructor(plugin, additionalTableMap = {}) {
+        this.plugin = plugin;
+        this.internalDataTable = new LdsInternalDataTable(plugin);
+        this.dataTableMap = {
+            ...additionalTableMap,
+            [DefaultDurableSegment]: new LdsDataTable(plugin),
+        };
+    }
+    isEvalSupported() {
+        return true;
+    }
+    query(sql, params) {
+        tasker.add();
+        return new Promise((resolve, reject) => {
+            this.plugin.query(sql, params, (result) => {
+                resolve(result);
+            }, (error) => {
+                reject(error);
+            });
+        }).finally(() => tasker.done());
+    }
+    batchQuery(queries) {
+        const promises = queries.map((q) => this.query(q.sql, q.params));
+        tasker.add();
+        return Promise.all(promises).finally(() => tasker.done());
+    }
+    async getEntries(entryIds, segment) {
+        tasker.add();
+        return this.getTable(segment)
+            .getByKeys(entryIds, segment)
+            .finally(() => tasker.done());
+    }
+    async getMetadata(entryIds, segment) {
+        tasker.add();
+        return this.getTable(segment)
+            .getMetadataByKeys(entryIds, segment)
+            .finally(() => tasker.done());
+    }
+    getAllEntries(segment) {
+        tasker.add();
+        return this.getTable(segment)
+            .getAll(segment)
+            .finally(() => tasker.done());
+    }
+    setEntries(entries, segment) {
+        if (keys(entries).length === 0) {
+            return Promise.resolve();
+        }
+        const table = this.getTable(segment);
+        const upsertOperation = table.entriesToUpsertOperations(entries, segment);
+        if (entries[GRAPHQL_QUERY_ROOT_KEY]) {
+            this.trackGraphQLQueryRootSize(upsertOperation);
+        }
+        return this.batchOperationAsPromise([upsertOperation]);
+    }
+    setMetadata(entries, segment) {
+        if (keys(entries).length === 0) {
+            return Promise.resolve();
+        }
+        const table = this.getTable(segment);
+        let operation = table.metadataToUpdateOperations(entries, segment);
+        return this.batchOperationAsPromise([operation]);
+    }
+    batchOperations(operations) {
+        const sqliteOperations = operations.reduce((acc, cur) => {
+            if (cur.type === 'setEntries') {
+                if (keys(cur.entries).length > 0) {
+                    const table = this.getTable(cur.segment);
+                    const upsertOperation = table.entriesToUpsertOperations(cur.entries, cur.segment);
+                    if (cur.entries[GRAPHQL_QUERY_ROOT_KEY]) {
+                        this.trackGraphQLQueryRootSize(upsertOperation);
+                    }
+                    acc.push(upsertOperation);
+                }
+            }
+            else if (cur.type === 'setMetadata') {
+                if (keys(cur.entries).length > 0) {
+                    const table = this.getTable(cur.segment);
+                    acc.push(table.metadataToUpdateOperations(cur.entries, cur.segment));
+                }
+            }
+            else {
+                if (cur.ids.length > 0) {
+                    acc.push(this.idsToDeleteOperation(cur.ids, cur.segment));
+                }
+            }
+            return acc;
+        }, []);
+        return sqliteOperations.length === 0
+            ? Promise.resolve()
+            : this.batchOperationAsPromise(sqliteOperations);
+    }
+    evictEntries(entryIds, segment) {
+        return entryIds.length === 0
+            ? Promise.resolve()
+            : this.batchOperationAsPromise([this.idsToDeleteOperation(entryIds, segment)]);
+    }
+    registerOnChangedListener(listener) {
+        let unsubscribeId = undefined;
+        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.type === 'upsert') &&
+                    c.context.type !== undefined) {
+                    type = c.context.type;
+                }
+                return {
+                    type,
+                    ids: c.keys,
+                    isExternalChange: false,
+                    segment: c.context.segment,
+                };
+            });
+            await listener(durableChanges);
+        })
+            .then((unsub) => {
+            unsubscribeId = unsub;
+        });
+        return () => {
+            if (unsubscribeId) {
+                return this.plugin.unsubscribeOnChangedListener(unsubscribeId);
+            }
+            return Promise.resolve();
+        };
+    }
+    getTable(segment) {
+        return this.dataTableMap[segment] ?? this.internalDataTable;
+    }
+    idsToDeleteOperation(entryIds, segment) {
+        const table = this.getTable(segment);
+        return {
+            type: 'delete',
+            table: table.tableName,
+            keyColumn: 'key',
+            context: {
+                segment,
+            },
+            ids: entryIds,
+        };
+    }
+    batchOperationAsPromise(sqliteOperations) {
+        tasker.add();
+        return new Promise((resolve, reject) => {
+            this.plugin.batchOperations(sqliteOperations, (error) => {
+                if (error && error !== null) {
+                    reject(error);
+                }
+                else {
+                    resolve();
+                }
+            });
+        }).finally(() => tasker.done());
+    }
+    trackGraphQLQueryRootSize(upsertOperation) {
+        try {
+            if (upsertOperation.type !== 'upsert') {
+                return;
+            }
+            const row = upsertOperation.rows.find((r) => r[0] === GRAPHQL_QUERY_ROOT_KEY);
+            if (!(row && row[1] && typeof row[1] === 'string')) {
+                return;
+            }
+            instrumentation.trackValue(GRAPHQL_QUERY_ROOT_METRIC_NAME, row[1].length);
+        }
+        catch { }
+    }
+}
+
+// These const values must be in sync with the latest
+// @salesforce/nimbus-plugin-lds/sql schema file
+const COLUMN_NAME_KEY = 'key';
+const COLUMN_NAME_DATA = 'data';
+class AbstractKeyValueDataTable {
+    constructor(plugin, tableName) {
+        this.columnNames = [COLUMN_NAME_KEY, COLUMN_NAME_DATA];
+        this.conflictColumnNames = [COLUMN_NAME_KEY];
+        this.plugin = plugin;
+        this.tableName = tableName;
+    }
+    getByKeys(keys) {
+        return new Promise((resolve, reject) => {
+            const getQuery = selectColumnsFromTableWhereKeyIn(this.columnNames, this.tableName, COLUMN_NAME_KEY, keys);
+            this.plugin.query(getQuery, keys, (x) => {
+                resolve(this.mapToDurableEntries(x));
+            }, 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) => {
+            this.plugin.query(getAllQuery, [], (x) => {
+                resolve(this.mapToDurableEntries(x));
+            }, reject);
+        });
+    }
+    entriesToUpsertOperations(entries, segment) {
+        return {
+            type: 'upsert',
+            table: this.tableName,
+            keyColumn: COLUMN_NAME_KEY,
+            context: {
+                segment,
+            },
+            conflictColumns: this.conflictColumnNames,
+            columns: this.columnNames,
+            rows: keys(entries).reduce((rows, key) => {
+                const entry = entries[key];
+                rows.push([key, stringify(entry.data)]);
+                return rows;
+            }, []),
+        };
+    }
+    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;
+            const durableStoreEntry = {
+                data: parse(stringifiedData),
+            };
+            entries[key] = durableStoreEntry;
+            return entries;
+        }, {});
+    }
+}
+
+export { AbstractKeyValueDataTable, NimbusSqliteStore };

package/dist/types/NimbusSqliteStore.d.ts

@@ -0,0 +1,30 @@
+import type { SqliteResult, SqliteStore, SqliteType } from '@salesforce/lds-store-sql';
+import { type SqliteStorePlugin } from '@salesforce/nimbus-plugin-lds';
+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;
+    private readonly internalDataTable;
+    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>;
+    private getTable;
+    private idsToDeleteOperation;
+    private batchOperationAsPromise;
+    private trackGraphQLQueryRootSize;
+}

package/dist/types/__mocks__/o11y/activity.d.ts

@@ -0,0 +1,11 @@
+declare function stop(_userSchemaOrText?: any | string, _userData?: any): void;
+declare function error(_error: Error, _userSchemaOrText?: any | string, _userData?: any): void;
+declare function discard(): void;
+declare function terminate(): void;
+export declare const activity: {
+    stop: typeof stop;
+    error: typeof error;
+    discard: typeof discard;
+    terminate: typeof terminate;
+};
+export {};

package/dist/types/__mocks__/o11y/client.d.ts

@@ -0,0 +1,5 @@
+import { instrumentation } from './instrumentation';
+export { activity } from './activity';
+export { instrumentation } from './instrumentation';
+export { idleDetector } from './idleDetector';
+export declare function getInstrumentation(_name: string): typeof instrumentation;

package/dist/types/__mocks__/o11y/idleDetector.d.ts

@@ -0,0 +1,18 @@
+declare function requestIdleDetectedCallback(_callback: any): void;
+declare function declareNotifierTaskSingle(_name: string): {
+    isBusy: boolean;
+    done: () => void;
+};
+declare function declareNotifierTaskMulti(_name: string, _existingBusyCount?: number): {
+    isBusy: boolean;
+    add: () => void;
+    done: () => void;
+};
+declare function declarePollableTaskMulti(_name: string, _isBusyChecker: any): void;
+export declare const idleDetector: {
+    requestIdleDetectedCallback: typeof requestIdleDetectedCallback;
+    declareNotifierTaskSingle: typeof declareNotifierTaskSingle;
+    declareNotifierTaskMulti: typeof declareNotifierTaskMulti;
+    declarePollableTaskMulti: typeof declarePollableTaskMulti;
+};
+export {};

package/dist/types/__mocks__/o11y/instrumentation.d.ts

@@ -0,0 +1,16 @@
+declare function log(_schema: any, _data?: any): void;
+declare function error(_err: Error, _userSchemaOrText?: string, _data?: any): void;
+declare function startActivity(_name: string): any;
+declare function incrementCounter(_operation: string, _increment?: number, _hasError?: boolean, _tags?: any): void;
+declare function trackValue(_operation: string, _value: number, _hasError?: boolean, _tags?: any): void;
+declare function bucketValue(_operation: string, _value: number, _buckets: number[]): void;
+export declare const instrumentation: {
+    log: typeof log;
+    error: typeof error;
+    startActivity: typeof startActivity;
+    incrementCounter: typeof incrementCounter;
+    trackValue: typeof trackValue;
+    bucketValue: typeof bucketValue;
+};
+export declare const METRIC_KEYS: {};
+export {};

package/dist/types/index.d.ts

@@ -0,0 +1,2 @@
+export { NimbusSqliteStore } from './NimbusSqliteStore';
+export { AbstractKeyValueDataTable } from './tables/AbstractKeyValueDataTable';

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

@@ -0,0 +1,16 @@
+import type { SqliteOperation, SqliteStorePlugin } from '@salesforce/nimbus-plugin-lds';
+import type { DurableStoreEntries, DurableStoreMetadataEntries } from '@luvio/environments';
+import type { LdsDataTableBase } from '../tables/LdsDataTableBase';
+export declare abstract class AbstractKeyValueDataTable implements LdsDataTableBase {
+    readonly tableName: SqliteOperation['table'];
+    readonly plugin: SqliteStorePlugin;
+    private columnNames;
+    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

@@ -0,0 +1,17 @@
+import type { SqliteOperation, SqliteStorePlugin } from '@salesforce/nimbus-plugin-lds';
+import type { DurableStoreEntries, DurableStoreMetadataEntries } from '@luvio/environments';
+import type { LdsDataTableBase } from '../tables/LdsDataTableBase';
+export declare class LdsDataTable implements LdsDataTableBase {
+    readonly tableName = "lds_data";
+    readonly plugin: SqliteStorePlugin;
+    private columnNames;
+    private conflictColumnNames;
+    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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,19 @@
+import type { SqliteOperation, SqliteStorePlugin } from '@salesforce/nimbus-plugin-lds';
+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;
+    private columnNames;
+    private conflictColumnNames;
+    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/tables/index.d.ts

@@ -0,0 +1,3 @@
+export { LdsDataTable } from './LdsDataTable';
+export { LdsInternalDataTable } from './LdsInternalDataTable';
+export { LdsDataTableBase } from './LdsDataTableBase';

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

@@ -0,0 +1,2 @@
+export declare function selectColumnsFromTableWhereKeyIn(columnNames: string[], table: string, keyColumnName: string, whereIn: string[]): string;
+export declare function selectColumnsFromTableWhereKeyInNamespaced(columnNames: string[], table: string, keyColumnName: string, whereIn: string[], namespaceColumnName: string): string;

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

@@ -0,0 +1,34 @@
+declare const keys: {
+    (o: object): string[];
+    (o: {}): string[];
+}, create: {
+    (o: object | null): any;
+    (o: object | null, properties: PropertyDescriptorMap & ThisType<any>): any;
+}, assign: {
+    <T extends {}, U>(target: T, source: U): T & U;
+    <T_1 extends {}, U_1, V>(target: T_1, source1: U_1, source2: V): T_1 & U_1 & V;
+    <T_2 extends {}, U_2, V_1, W>(target: T_2, source1: U_2, source2: V_1, source3: W): T_2 & U_2 & V_1 & W;
+    (target: object, ...sources: any[]): any;
+}, entries: {
+    <T>(o: {
+        [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;
+    (value: any, replacer?: (string | number)[] | null | undefined, space?: string | number | undefined): string;
+}, parse: (text: string, reviver?: ((this: any, key: string, value: any) => any) | undefined) => any;
+declare const push: (...items: any[]) => number, join: (separator?: string | undefined) => string, slice: (start?: number | undefined, end?: number | undefined) => any[];
+declare const isArray: (arg: any) => arg is any[], from: {
+    <T>(arrayLike: ArrayLike<T>): T[];
+    <T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+    <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, 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

@@ -0,0 +1,45 @@
+{
+    "name": "@salesforce/lds-store-nimbus",
+    "version": "0.1.0-dev1",
+    "description": "A nimbus-plugin-based implementation of the Luvio DurableStore and SqliteStore.",
+    "license": "SEE LICENSE IN LICENSE.txt",
+    "types": "dist/types/index.d.ts",
+    "main": "dist/index.js",
+    "module": "dist/index.js",
+    "files": [
+        "dist"
+    ],
+    "exports": {
+        ".": {
+            "types": "./dist/types/index.d.ts",
+            "import": "./dist/index.js",
+            "default": "./dist/index.js"
+        }
+    },
+    "scripts": {
+        "prepare": "yarn build",
+        "clean": "rm -rf dist",
+        "build": "rollup --bundleConfigAsCjs --config rollup.config.js",
+        "test:debug": "node --inspect-brk ../../node_modules/.bin/jest --runInBand",
+        "test:unit": "NODE_ENV=production jest",
+        "test:size": "luvioBundlesize"
+    },
+    "dependencies": {
+        "o11y": "250.7.0"
+    },
+    "devDependencies": {
+        "@luvio/environments": "0.158.7",
+        "@salesforce/lds-store-sql": "^0.1.0-dev1",
+        "@salesforce/nimbus-plugin-lds": "^0.1.0-dev1"
+    },
+    "luvioBundlesize": [
+        {
+            "path": "./dist/index.js",
+            "maxSize": {
+                "none": "19 kB",
+                "min": "9 kB",
+                "compressed": "3 kB"
+            }
+        }
+    ]
+}