@salesforce/lds-durable-records 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/ldsDurableRecords.js

@@ -0,0 +1,363 @@
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+import { DefaultDurableSegment, DURABLE_METADATA_VERSION } from '@luvio/environments';
+import { extractRecordIdFromStoreKey, RECORD_VIEW_ENTITY_ID_PREFIX, isStoreKeyRecordViewEntity, keyBuilderRecord, RECORD_ID_PREFIX, RECORD_FIELDS_KEY_JUNCTION } from '@salesforce/lds-adapters-uiapi';
+
+const { keys, values, create, assign, freeze, entries } = Object;
+
+function buildRecordFieldStoreKey(recordKey, fieldName) {
+    return `${recordKey}${RECORD_FIELDS_KEY_JUNCTION}${fieldName}`;
+}
+function isStoreKeyRecordId(key) {
+    return key.indexOf(RECORD_ID_PREFIX) > -1 && key.indexOf(RECORD_FIELDS_KEY_JUNCTION) === -1;
+}
+function createLink(key) {
+    return { __ref: key };
+}
+function isStoreRecordError(storeRecord) {
+    return storeRecord.__type === 'error';
+}
+function isEntryDurableRecordRepresentation(entry, key) {
+    // Either a DurableRecordRepresentation or StoreRecordError can live at a record key
+    return ((isStoreKeyRecordId(key) || isStoreKeyRecordViewEntity(key)) &&
+        entry.data.__type === undefined);
+}
+/**
+ * Records are stored in the durable store with scalar fields denormalized. This function takes that denoramlized
+ * durable store record representation and normalizes it back out into the format the the luvio store expects it
+ * @param key Record store key
+ * @param entry Durable entry containing a denormalized record representation
+ * @returns a set of entries containing the normalized record and its normalized fields
+ */
+function normalizeRecordFields(key, entry) {
+    const { data: record } = entry;
+    const { fields, links } = record;
+    const missingFieldLinks = links === undefined ? [] : keys(links);
+    const fieldNames = keys(fields);
+    const normalizedFields = {};
+    const returnEntries = {};
+    // restore fields
+    for (let i = 0, len = fieldNames.length; i < len; i++) {
+        const fieldName = fieldNames[i];
+        const field = fields[fieldName];
+        if (field.__state !== undefined && field.__state.isMissing === true) {
+            normalizedFields[fieldName] = { isMissing: true, __ref: undefined };
+            continue;
+        }
+        const fieldKey = buildRecordFieldStoreKey(key, fieldName);
+        returnEntries[fieldKey] = { data: field };
+        normalizedFields[fieldName] = createLink(fieldKey);
+    }
+    // restore missing fields
+    for (let i = 0, len = missingFieldLinks.length; i < len; i++) {
+        const fieldName = missingFieldLinks[i];
+        const link = links[fieldName];
+        if (link.isMissing === true) {
+            normalizedFields[fieldName] = { ...link, __ref: undefined };
+        }
+    }
+    returnEntries[key] = {
+        data: assign(record, { fields: normalizedFields }),
+        metadata: entry.metadata,
+    };
+    return returnEntries;
+}
+/**
+ * Transforms a record for storage in the durable store. The transformation involves denormalizing
+ * scalar fields and persisting link metadata to transform back into a normalized representation
+ *
+ * If the record contains pending fields this will return undefined as pending records do not get persisted
+ * to the durable store. There should be a refresh operation outbound that will bring in the updated record.
+ *
+ * @param normalizedRecord Record containing normalized field links
+ * @param recordStore a store containing referenced record fields
+ */
+function buildDurableRecordRepresentation(normalizedRecord, records, pendingEntries, store) {
+    const fields = normalizedRecord.fields;
+    const filteredFields = {};
+    const fieldNames = keys(fields);
+    for (let i = 0, len = fieldNames.length; i < len; i++) {
+        const fieldName = fieldNames[i];
+        const field = fields[fieldName];
+        // pending fields get filtered out of the durable store
+        const { pending } = field;
+        if (pending === true) {
+            // do not write records with pending fields to the durable store
+            // there should be a refresh operation outbound that will bring in the updated record
+            return undefined;
+        }
+        const { __ref } = field;
+        if (__ref !== undefined) {
+            let ref = records[__ref];
+            if (pendingEntries !== undefined) {
+                // If the ref was part of the pending write that takes precedence
+                const pendingEntry = pendingEntries[__ref];
+                if (pendingEntry !== undefined) {
+                    ref = pendingEntry.data;
+                }
+            }
+            // if field reference exists then add it to our filteredFields
+            if (ref !== undefined) {
+                filteredFields[fieldName] = ref;
+            }
+            else {
+                // if we have a store to read, try to find the field there too
+                // The durable ingest staging store may pass through to L1, and
+                // not all fields are necessarily published every time, so it is
+                // important to check L1 and not just the fields being published,
+                // otherwise we risk truncating the fields on the record.
+                if (store) {
+                    ref = store.readEntry(__ref);
+                    if (ref !== undefined) {
+                        filteredFields[fieldName] = ref;
+                    }
+                }
+            }
+        }
+        // we want to preserve fields that are missing nodes
+        if (field.isMissing === true) {
+            filteredFields[fieldName] = {
+                value: undefined,
+                displayValue: undefined,
+                __state: { isMissing: true },
+            };
+        }
+    }
+    return {
+        ...normalizedRecord,
+        fields: filteredFields,
+    };
+}
+function getDenormalizedKey(originalKey, recordId, luvio) {
+    // this will likely need to be handled when moving to structured keys
+    // note record view entities dont have an associated keybuilder. They get ingested as records to a different key format
+    // see the override for how they are handled packages/lds-adapters-uiapi/src/raml-artifacts/types/RecordRepresentation/keyBuilderFromType.ts
+    if (originalKey.startsWith(RECORD_VIEW_ENTITY_ID_PREFIX)) {
+        return RECORD_VIEW_ENTITY_ID_PREFIX + recordId;
+    }
+    return keyBuilderRecord(luvio, { recordId });
+}
+function makeRecordDenormalizingDurableStore(luvio, durableStore, getStoreRecords, getStoreMetadata, getStore, sqlStore) {
+    const getEntries = function (entries, segment) {
+        // this HOF only inspects records in the default segment
+        if (segment !== DefaultDurableSegment) {
+            return durableStore.getEntries(entries, segment);
+        }
+        const { length: entriesLength } = entries;
+        if (entriesLength === 0) {
+            return Promise.resolve({});
+        }
+        // filter out record field keys
+        const filteredEntryIds = [];
+        // map of records to avoid requesting duplicate record keys when requesting both records and fields
+        const recordEntries = {};
+        const recordViewEntries = {};
+        for (let i = 0, len = entriesLength; i < len; i++) {
+            const id = entries[i];
+            const recordId = extractRecordIdFromStoreKey(id);
+            if (recordId !== undefined) {
+                if (id.startsWith(RECORD_VIEW_ENTITY_ID_PREFIX)) {
+                    if (recordViewEntries[recordId] === undefined) {
+                        const key = getDenormalizedKey(id, recordId, luvio);
+                        recordViewEntries[recordId] = true;
+                        filteredEntryIds.push(key);
+                    }
+                }
+                else {
+                    if (recordEntries[recordId] === undefined) {
+                        const key = getDenormalizedKey(id, recordId, luvio);
+                        recordEntries[recordId] = true;
+                        filteredEntryIds.push(key);
+                    }
+                }
+            }
+            else {
+                filteredEntryIds.push(id);
+            }
+        }
+        // call base getEntries
+        return durableStore.getEntries(filteredEntryIds, segment).then((durableEntries) => {
+            if (durableEntries === undefined) {
+                return undefined;
+            }
+            const returnEntries = create(null);
+            const keys$1 = keys(durableEntries);
+            for (let i = 0, len = keys$1.length; i < len; i++) {
+                const key = keys$1[i];
+                const value = durableEntries[key];
+                if (value === undefined) {
+                    continue;
+                }
+                if (isEntryDurableRecordRepresentation(value, key)) {
+                    assign(returnEntries, normalizeRecordFields(key, value));
+                }
+                else {
+                    returnEntries[key] = value;
+                }
+            }
+            return returnEntries;
+        });
+    };
+    const denormalizeEntries = function (entries) {
+        let hasEntries = false;
+        let hasMetadata = false;
+        const putEntries = create(null);
+        const putMetadata = create(null);
+        const keys$1 = keys(entries);
+        const putRecords = {};
+        const putRecordViews = {};
+        const storeRecords = getStoreRecords !== undefined ? getStoreRecords() : {};
+        const storeMetadata = getStoreMetadata !== undefined ? getStoreMetadata() : {};
+        const store = getStore();
+        for (let i = 0, len = keys$1.length; i < len; i++) {
+            const key = keys$1[i];
+            let value = entries[key];
+            const recordId = extractRecordIdFromStoreKey(key);
+            // do not put normalized field values
+            if (recordId !== undefined) {
+                const isRecordView = key.startsWith(RECORD_VIEW_ENTITY_ID_PREFIX);
+                if (isRecordView) {
+                    if (putRecordViews[recordId] === true) {
+                        continue;
+                    }
+                }
+                else {
+                    if (putRecords[recordId] === true) {
+                        continue;
+                    }
+                }
+                const recordKey = getDenormalizedKey(key, recordId, luvio);
+                const recordEntries = entries;
+                const entry = recordEntries[recordKey];
+                let record = entry && entry.data;
+                if (record === undefined) {
+                    record = storeRecords[recordKey];
+                    if (record === undefined) {
+                        // fields are being published without a record for them existing,
+                        // fields cannot exist standalone in the durable store
+                        continue;
+                    }
+                }
+                if (isRecordView) {
+                    putRecordViews[recordId] = true;
+                }
+                else {
+                    putRecords[recordId] = true;
+                }
+                if (isStoreRecordError(record)) {
+                    hasEntries = true;
+                    putEntries[recordKey] = value;
+                    continue;
+                }
+                let metadata = entry && entry.metadata;
+                if (metadata === undefined) {
+                    metadata = {
+                        ...storeMetadata[recordKey],
+                        metadataVersion: DURABLE_METADATA_VERSION,
+                    };
+                }
+                const denormalizedRecord = buildDurableRecordRepresentation(record, storeRecords, recordEntries, store);
+                if (denormalizedRecord !== undefined) {
+                    hasEntries = true;
+                    putEntries[recordKey] = {
+                        data: denormalizedRecord,
+                        metadata,
+                    };
+                    // if undefined then it is pending
+                    // we should still update metadata on pending records
+                }
+                else {
+                    hasMetadata = true;
+                    metadata.expirationTimestamp = metadata.ingestionTimestamp;
+                    putMetadata[recordKey] = {
+                        metadata,
+                    };
+                }
+            }
+            else {
+                hasEntries = true;
+                putEntries[key] = value;
+            }
+        }
+        return { putEntries, putMetadata, hasEntries, hasMetadata };
+    };
+    const setEntries = function (entries, segment) {
+        if (segment !== DefaultDurableSegment) {
+            return durableStore.setEntries(entries, segment);
+        }
+        const { putEntries, putMetadata, hasEntries, hasMetadata } = denormalizeEntries(entries);
+        const promises = [
+            hasEntries ? durableStore.setEntries(putEntries, segment) : undefined,
+        ];
+        if (sqlStore !== undefined) {
+            promises.push(hasMetadata && sqlStore !== undefined
+                ? durableStore.setMetadata(putMetadata, segment)
+                : undefined);
+        }
+        return Promise.all(promises).then(() => { });
+    };
+    const batchOperations = function (operations) {
+        const operationsWithDenormedRecords = [];
+        for (let i = 0, len = operations.length; i < len; i++) {
+            const operation = operations[i];
+            if (operation.type === 'setMetadata') {
+                // if setMetadata also contains entry data then it needs to be denormalized.
+                const keys$1 = keys(operation.entries);
+                if (keys$1.length > 0) {
+                    const firstKey = keys$1[0];
+                    // casted to any to check if data exists
+                    const firstEntry = operation.entries[firstKey];
+                    // it is not possible for setMetadata to contain entries with both data and no data in the same operation.
+                    // this is determined by the plugin supporting update batch calls before it gets to this HOF.
+                    // so we only need to check one entry to confirm this for performance
+                    if (firstEntry.data !== undefined) {
+                        const { putEntries, putMetadata, hasMetadata } = denormalizeEntries(operation.entries);
+                        operationsWithDenormedRecords.push({
+                            ...operation,
+                            entries: putEntries,
+                        });
+                        if (hasMetadata && sqlStore !== undefined) {
+                            operationsWithDenormedRecords.push({
+                                ...operation,
+                                entries: putMetadata,
+                                type: 'setMetadata',
+                            });
+                        }
+                    }
+                    else {
+                        operationsWithDenormedRecords.push(operation);
+                    }
+                }
+                continue;
+            }
+            if (operation.segment !== DefaultDurableSegment || operation.type === 'evictEntries') {
+                operationsWithDenormedRecords.push(operation);
+                continue;
+            }
+            const { putEntries, putMetadata, hasMetadata } = denormalizeEntries(operation.entries);
+            operationsWithDenormedRecords.push({
+                ...operation,
+                entries: putEntries,
+            });
+            if (hasMetadata && sqlStore !== undefined) {
+                operationsWithDenormedRecords.push({
+                    ...operation,
+                    entries: putMetadata,
+                    type: 'setMetadata',
+                });
+            }
+        }
+        return durableStore.batchOperations(operationsWithDenormedRecords);
+    };
+    return create(durableStore, {
+        getEntries: { value: getEntries, writable: true },
+        setEntries: { value: setEntries, writable: true },
+        batchOperations: { value: batchOperations, writable: true },
+    });
+}
+
+export { makeRecordDenormalizingDurableStore };

package/dist/types/main.d.ts

@@ -0,0 +1,62 @@
+export { makeRecordDenormalizingDurableStore } from './makeRecordDenormalizingDurableStore';
+export type DurableRecordRepresentationFieldState = {
+    isMissing?: true;
+    pending?: true;
+};
+export type DurableRecordRepresentationField = {
+    value: ScalarFieldType | DurableStoreLink | undefined;
+    displayValue: string | null | undefined;
+    __state?: DurableRecordRepresentationFieldState;
+};
+export type DurableRecordRepresentationFields = Record<string, DurableRecordRepresentationField>;
+type ServerValueFieldType = {
+    displayValue: string | null;
+    value: ScalarFieldType;
+} | null;
+export interface DurableRecordRepresentation {
+    drafts?: {
+        created: boolean;
+        edited: boolean;
+        deleted: boolean;
+        serverValues: Record<string, ServerValueFieldType>;
+        serverRootValues: {
+            recordTypeId: string | null;
+            recordTypeInfo: {
+                available: boolean;
+                defaultRecordTypeMapping: boolean;
+                master: boolean;
+                name: string;
+                recordTypeId: string;
+            } | null;
+            lastModifiedById: string | null;
+            lastModifiedDate: string | null;
+            systemModstamp: string | null;
+        } | undefined;
+        draftActionIds: string[];
+        latestDraftActionId: string;
+    };
+    links?: Record<string, DurableStoreLink>;
+    apiName: string;
+    childRelationships: Record<string, DurableStoreLink>;
+    eTag: string;
+    fields: DurableRecordRepresentationFields;
+    id: string;
+    lastModifiedById: string | null;
+    lastModifiedDate: string | null;
+    recordTypeId: string | null;
+    recordTypeInfo: {
+        available: boolean;
+        defaultRecordTypeMapping: boolean;
+        master: boolean;
+        name: string;
+        recordTypeId: string;
+    } | null;
+    systemModstamp: string | null;
+    weakEtag: number;
+}
+export type ScalarFieldType = boolean | number | string | null;
+type DurableStoreLink = {
+    __ref?: string;
+    pending?: true;
+    isMissing?: true;
+};

package/dist/types/makeRecordDenormalizingDurableStore.d.ts

@@ -0,0 +1,7 @@
+import type { RecordSource, InMemoryStore, Luvio, StoreRecordError } from '@luvio/engine';
+import type { DurableStore, DurableStoreEntry } from '@luvio/environments';
+import type { NimbusSqliteStore } from '@salesforce/lds-store-nimbus';
+import type { DurableRecordRepresentation } from './main';
+export declare function isStoreRecordError(storeRecord: object): storeRecord is StoreRecordError;
+export declare function isEntryDurableRecordRepresentation(entry: DurableStoreEntry<any>, key: string): entry is DurableStoreEntry<DurableRecordRepresentation>;
+export declare function makeRecordDenormalizingDurableStore(luvio: Luvio, durableStore: DurableStore, getStoreRecords: () => RecordSource, getStoreMetadata: () => InMemoryStore['fallbackStringKeyInMemoryStore']['metadata'], getStore: () => InMemoryStore['fallbackStringKeyInMemoryStore'] | undefined, sqlStore?: NimbusSqliteStore): DurableStore;

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

@@ -0,0 +1,40 @@
+declare const keys: {
+    (o: object): string[];
+    (o: {}): string[];
+}, values: {
+    <T>(o: {
+        [s: string]: T;
+    } | ArrayLike<T>): T[];
+    (o: {}): any[];
+}, 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;
+}, freeze: {
+    <T extends Function>(f: T): T;
+    <T_1 extends {
+        [idx: string]: object | U | null | undefined;
+    }, U extends string | number | bigint | boolean | symbol>(o: T_1): Readonly<T_1>;
+    <T_2>(o: T_2): Readonly<T_2>;
+}, entries: {
+    <T>(o: {
+        [s: string]: T;
+    } | ArrayLike<T>): [string, T][];
+    (o: {}): [string, 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 shift: () => 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, values as ObjectValues, create as ObjectCreate, assign as ObjectAssign, freeze as ObjectFreeze, entries as ObjectEntries, stringify as JSONStringify, parse as JSONParse, shift as ArrayPrototypeShift, isArray as ArrayIsArray, from as ArrayFrom, };

package/package.json

@@ -0,0 +1,33 @@
+{
+    "name": "@salesforce/lds-durable-records",
+    "version": "0.1.0-dev1",
+    "license": "SEE LICENSE IN LICENSE.txt",
+    "description": "LDS Record Utilities",
+    "main": "dist/ldsDurableRecords.js",
+    "module": "dist/ldsDurableRecords.js",
+    "types": "dist/types/main.d.ts",
+    "files": [
+        "dist"
+    ],
+    "exports": {
+        ".": {
+            "types": "./dist/types/main.d.ts",
+            "import": "./dist/ldsDurableRecords.js",
+            "default": "./dist/ldsDurableRecords.js"
+        }
+    },
+    "scripts": {
+        "prepare": "yarn build",
+        "build": "rollup --bundleConfigAsCjs --config rollup.config.js",
+        "clean": "rm -rf dist",
+        "test:unit": "jest"
+    },
+    "dependencies": {
+        "@luvio/engine": "0.158.7",
+        "@luvio/environments": "0.158.7",
+        "@salesforce/lds-adapters-uiapi": "^0.1.0-dev1"
+    },
+    "devDependencies": {
+        "@salesforce/lds-store-nimbus": "^0.1.0-dev1"
+    }
+}