@salesforce/lds-durable-records 1.299.0 → 1.300.0

package/dist/ldsDurableRecords.js

@@ -36,7 +36,7 @@ function isEntryDurableRecordRepresentation(entry, key) {
 function normalizeRecordFields(key, entry) {
     const { data: record } = entry;
     const { fields, links } = record;
-    const missingFieldLinks = keys(links);
+    const missingFieldLinks = links === undefined ? [] : keys(links);
     const fieldNames = keys(fields);
     const normalizedFields = {};
     const returnEntries = {};
@@ -44,6 +44,10 @@ function normalizeRecordFields(key, entry) {
     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);
@@ -75,7 +79,6 @@ function normalizeRecordFields(key, entry) {
 function buildDurableRecordRepresentation(normalizedRecord, records, pendingEntries, store) {
     const fields = normalizedRecord.fields;
     const filteredFields = {};
-    const links = {};
     const fieldNames = keys(fields);
     for (let i = 0, len = fieldNames.length; i < len; i++) {
         const fieldName = fieldNames[i];
@@ -117,13 +120,16 @@ function buildDurableRecordRepresentation(normalizedRecord, records, pendingEntr
         }
         // we want to preserve fields that are missing nodes
         if (field.isMissing === true) {
-            links[fieldName] = field;
+            filteredFields[fieldName] = {
+                value: undefined,
+                displayValue: undefined,
+                __state: { isMissing: true },
+            };
         }
     }
     return {
         ...normalizedRecord,
         fields: filteredFields,
-        links,
     };
 }
 function getDenormalizedKey(originalKey, recordId, luvio) {
@@ -351,36 +357,66 @@ function makeRecordDenormalizingDurableStore(luvio, durableStore, getStoreRecord
         }
         return durableStore.batchOperations(operationsWithDenormedRecords);
     };
-    /**
-     * Retrieves a denormalized record from the store
-     * NOTE: do no use this if you don't know what you're doing, this can still contain normalized record references
-     * @param recordKey record key
-     * @param durableStore the durable store
-     * @returns a DraftRecordRepresentation containing the requested fields
-     */
-    const getDenormalizedRecord = function (recordKey) {
-        return durableStore.getEntries([recordKey], DefaultDurableSegment).then((entries) => {
-            if (entries === undefined) {
-                return undefined;
-            }
-            const denormalizedEntry = entries[recordKey];
-            if (denormalizedEntry === undefined) {
+    return create(durableStore, {
+        getEntries: { value: getEntries, writable: true },
+        setEntries: { value: setEntries, writable: true },
+        batchOperations: { value: batchOperations, writable: true },
+    });
+}
+
+// TODO [W-15983267]: this is here for backwards compatibility from <252 and can be removed in 256
+// This HOF ensures that missing links that are stored in the "links" property in the durable store get restored to the "fields" property.
+// this code is necessary for backwards compatibility with records that were stored in the durable store before the "links" property was removed.
+function makeDurableStoreBackwardsCompatible(durableStore) {
+    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({});
+        }
+        // call base getEntries
+        return durableStore.getEntries(entries, segment).then((durableEntries) => {
+            if (durableEntries === undefined) {
                 return undefined;
             }
-            // don't include link information
-            const denormalizedRecord = denormalizedEntry.data;
-            if (isStoreRecordError(denormalizedRecord)) {
-                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)) {
+                    const record = value.data;
+                    const { links } = record;
+                    if (links !== undefined) {
+                        const missingLinks = keys(links);
+                        for (let j = 0, len = missingLinks.length; j < len; j++) {
+                            const fieldName = missingLinks[j];
+                            const link = links[fieldName];
+                            if (link !== undefined && link.isMissing === true) {
+                                record.fields[fieldName] = {
+                                    __state: { isMissing: true },
+                                    value: undefined,
+                                    displayValue: undefined,
+                                };
+                            }
+                        }
+                        delete record.links;
+                    }
+                }
+                returnEntries[key] = value;
             }
-            return denormalizedRecord;
+            return returnEntries;
         });
     };
     return create(durableStore, {
         getEntries: { value: getEntries, writable: true },
-        setEntries: { value: setEntries, writable: true },
-        batchOperations: { value: batchOperations, writable: true },
-        getDenormalizedRecord: { value: getDenormalizedRecord, writable: true },
     });
 }
 
-export { makeRecordDenormalizingDurableStore };
+export { makeDurableStoreBackwardsCompatible, makeRecordDenormalizingDurableStore };

package/dist/types/main.d.ts

@@ -1,4 +1,5 @@
-export { makeRecordDenormalizingDurableStore, type RecordDenormalizingDurableStore, } from './makeRecordDenormalizingDurableStore';
+export { makeRecordDenormalizingDurableStore } from './makeRecordDenormalizingDurableStore';
+export { makeDurableStoreBackwardsCompatible } from './makeDurableStoreBackwardsCompatible';
 export interface DurableRecordRepresentation {
     drafts?: {
         created: boolean;
@@ -11,13 +12,17 @@ export interface DurableRecordRepresentation {
         draftActionIds: string[];
         latestDraftActionId: string;
     };
-    links: Record<string, DurableStoreLink>;
+    links?: Record<string, DurableStoreLink>;
     apiName: string;
     childRelationships: Record<string, DurableStoreLink>;
     eTag: string;
     fields: Record<string, {
-        value: ScalarFieldType | DurableStoreLink;
-        displayValue: string | null;
+        value: ScalarFieldType | DurableStoreLink | undefined;
+        displayValue: string | null | undefined;
+        __state?: {
+            isMissing?: true;
+            pending?: true;
+        };
     }>;
     id: string;
     lastModifiedById: string | null;

package/dist/types/makeDurableStoreBackwardsCompatible.d.ts

@@ -0,0 +1,2 @@
+import { type DurableStore } from '@luvio/environments';
+export declare function makeDurableStoreBackwardsCompatible(durableStore: DurableStore): any;

package/dist/types/makeRecordDenormalizingDurableStore.d.ts

@@ -4,11 +4,4 @@ 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 interface RecordDenormalizingDurableStore extends DurableStore {
-    /**
-     * Gets a record with denormalized scalar fields from the durable store (references are still normalized)
-     * @param key Record key
-     */
-    getDenormalizedRecord(key: string): Promise<DurableRecordRepresentation | undefined>;
-}
-export declare function makeRecordDenormalizingDurableStore(luvio: Luvio, durableStore: DurableStore, getStoreRecords: () => RecordSource, getStoreMetadata: () => InMemoryStore['fallbackStringKeyInMemoryStore']['metadata'], getStore: () => InMemoryStore['fallbackStringKeyInMemoryStore'] | undefined, sqlStore?: NimbusSqliteStore): RecordDenormalizingDurableStore;
+export declare function makeRecordDenormalizingDurableStore(luvio: Luvio, durableStore: DurableStore, getStoreRecords: () => RecordSource, getStoreMetadata: () => InMemoryStore['fallbackStringKeyInMemoryStore']['metadata'], getStore: () => InMemoryStore['fallbackStringKeyInMemoryStore'] | undefined, sqlStore?: NimbusSqliteStore): DurableStore;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@salesforce/lds-durable-records",
-    "version": "1.299.0",
+    "version": "1.300.0",
     "license": "SEE LICENSE IN LICENSE.txt",
     "description": "LDS Record Utilities",
     "main": "dist/ldsDurableRecords.js",
@@ -23,11 +23,11 @@
         "test:unit": "jest"
     },
     "dependencies": {
-        "@luvio/engine": "0.154.20",
-        "@luvio/environments": "0.154.20",
-        "@salesforce/lds-adapters-uiapi": "^1.299.0"
+        "@luvio/engine": "0.155.1",
+        "@luvio/environments": "0.155.1",
+        "@salesforce/lds-adapters-uiapi": "^1.300.0"
     },
     "devDependencies": {
-        "@salesforce/lds-store-nimbus": "^1.299.0"
+        "@salesforce/lds-store-nimbus": "^1.300.0"
     }
 }