@salesforce/lds-durable-records 1.332.0-dev2 → 1.332.0-dev21

package/dist/ldsDurableRecords.js

@@ -5,13 +5,19 @@
  */
 
 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';
+import { RECORD_VIEW_ENTITY_ID_PREFIX, API_NAMESPACE, isStoreKeyRecordViewEntity, extractRecordIdFromStoreKey, keyBuilderRecord, RECORD_FIELDS_KEY_JUNCTION, RECORD_ID_PREFIX } from '@salesforce/lds-adapters-uiapi';
 
 const { keys, values, create, assign, freeze, entries } = Object;
 
+const RECORD_TEMPLATE_CREATE_REPRESENTATION_NAME = 'RecordTemplateCreateRepresentation';
+const RECORD_TEMPLATE_CREATE_REPRESENTATION_PREFIX = `${API_NAMESPACE}::${RECORD_TEMPLATE_CREATE_REPRESENTATION_NAME}:`;
 function buildRecordFieldStoreKey(recordKey, fieldName) {
     return `${recordKey}${RECORD_FIELDS_KEY_JUNCTION}${fieldName}`;
 }
+function isStoreKeyRecordTemplateId(key) {
+    return (key.indexOf(RECORD_TEMPLATE_CREATE_REPRESENTATION_PREFIX) > -1 &&
+        key.indexOf(RECORD_FIELDS_KEY_JUNCTION) === -1);
+}
 function isStoreKeyRecordId(key) {
     return key.indexOf(RECORD_ID_PREFIX) > -1 && key.indexOf(RECORD_FIELDS_KEY_JUNCTION) === -1;
 }
@@ -23,7 +29,9 @@ function isStoreRecordError(storeRecord) {
 }
 function isEntryDurableRecordRepresentation(entry, key) {
     // Either a DurableRecordRepresentation or StoreRecordError can live at a record key
-    return ((isStoreKeyRecordId(key) || isStoreKeyRecordViewEntity(key)) &&
+    return ((isStoreKeyRecordId(key) ||
+        isStoreKeyRecordViewEntity(key) ||
+        isStoreKeyRecordTemplateId(key)) &&
         entry.data.__type === undefined);
 }
 /**
@@ -132,6 +140,29 @@ function buildDurableRecordRepresentation(normalizedRecord, records, pendingEntr
         fields: filteredFields,
     };
 }
+// We have a local version of this that calls the imported version because
+// we need to check for a prefix that is defined in this file
+function extractRecordIdFromStoreKeyWithRecordTemplate(key) {
+    const superResult = extractRecordIdFromStoreKey(key);
+    if (superResult) {
+        return superResult;
+    }
+    if (key === undefined || key.indexOf(RECORD_TEMPLATE_CREATE_REPRESENTATION_PREFIX) === -1) {
+        return undefined;
+    }
+    const parts = key.split(':');
+    return parts[parts.length - 1].split('_')[0];
+}
+function buildRecordTemplateCreateKeyFromId(recordId, apiName) {
+    return `${RECORD_TEMPLATE_CREATE_REPRESENTATION_PREFIX}${apiName}:${recordId}`;
+}
+function extractAPINameFromRecordTemplateKey(originalKey) {
+    if (originalKey.indexOf(RECORD_TEMPLATE_CREATE_REPRESENTATION_PREFIX) !== -1) {
+        const trimmed = originalKey.substring(RECORD_TEMPLATE_CREATE_REPRESENTATION_PREFIX.length);
+        return trimmed.split(':')[0];
+    }
+    return undefined;
+}
 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
@@ -139,6 +170,11 @@ function getDenormalizedKey(originalKey, recordId, luvio) {
     if (originalKey.startsWith(RECORD_VIEW_ENTITY_ID_PREFIX)) {
         return RECORD_VIEW_ENTITY_ID_PREFIX + recordId;
     }
+    // if key starts with record template, return that plus record id and api name
+    const apiName = extractAPINameFromRecordTemplateKey(originalKey);
+    if (originalKey.startsWith(RECORD_TEMPLATE_CREATE_REPRESENTATION_PREFIX) && apiName) {
+        return buildRecordTemplateCreateKeyFromId(recordId, apiName);
+    }
     return keyBuilderRecord(luvio, { recordId });
 }
 function makeRecordDenormalizingDurableStore(luvio, durableStore, getStoreRecords, getStoreMetadata, getStore, sqlStore) {
@@ -156,9 +192,10 @@ function makeRecordDenormalizingDurableStore(luvio, durableStore, getStoreRecord
         // map of records to avoid requesting duplicate record keys when requesting both records and fields
         const recordEntries = {};
         const recordViewEntries = {};
+        const recordTemplateEntries = {};
         for (let i = 0, len = entriesLength; i < len; i++) {
             const id = entries[i];
-            const recordId = extractRecordIdFromStoreKey(id);
+            const recordId = extractRecordIdFromStoreKeyWithRecordTemplate(id);
             if (recordId !== undefined) {
                 if (id.startsWith(RECORD_VIEW_ENTITY_ID_PREFIX)) {
                     if (recordViewEntries[recordId] === undefined) {
@@ -167,6 +204,13 @@ function makeRecordDenormalizingDurableStore(luvio, durableStore, getStoreRecord
                         filteredEntryIds.push(key);
                     }
                 }
+                else if (id.startsWith(RECORD_TEMPLATE_CREATE_REPRESENTATION_PREFIX)) {
+                    if (recordTemplateEntries[recordId] === undefined) {
+                        const key = getDenormalizedKey(id, recordId, luvio);
+                        recordTemplateEntries[recordId] = true;
+                        filteredEntryIds.push(key);
+                    }
+                }
                 else {
                     if (recordEntries[recordId] === undefined) {
                         const key = getDenormalizedKey(id, recordId, luvio);
@@ -210,21 +254,29 @@ function makeRecordDenormalizingDurableStore(luvio, durableStore, getStoreRecord
         const keys$1 = keys(entries);
         const putRecords = {};
         const putRecordViews = {};
+        const putRecordTemplateViews = {};
         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);
+            const recordId = extractRecordIdFromStoreKeyWithRecordTemplate(key);
             // do not put normalized field values
             if (recordId !== undefined) {
                 const isRecordView = key.startsWith(RECORD_VIEW_ENTITY_ID_PREFIX);
+                const isRecordTemplateView = key.startsWith(RECORD_TEMPLATE_CREATE_REPRESENTATION_PREFIX);
+                // put a record view in there for record templates
                 if (isRecordView) {
                     if (putRecordViews[recordId] === true) {
                         continue;
                     }
                 }
+                else if (isRecordTemplateView) {
+                    if (putRecordTemplateViews[recordId] === true) {
+                        continue;
+                    }
+                }
                 else {
                     if (putRecords[recordId] === true) {
                         continue;
@@ -245,6 +297,9 @@ function makeRecordDenormalizingDurableStore(luvio, durableStore, getStoreRecord
                 if (isRecordView) {
                     putRecordViews[recordId] = true;
                 }
+                else if (isRecordTemplateView) {
+                    putRecordTemplateViews[recordId] = true;
+                }
                 else {
                     putRecords[recordId] = true;
                 }

package/dist/types/makeRecordDenormalizingDurableStore.d.ts

@@ -2,6 +2,10 @@ import type { RecordSource, InMemoryStore, Luvio, StoreRecordError } from '@luvi
 import type { DurableStore, DurableStoreEntry } from '@luvio/environments';
 import type { NimbusSqliteStore } from '@salesforce/lds-store-nimbus';
 import type { DurableRecordRepresentation } from './main';
+export declare const RECORD_TEMPLATE_CREATE_REPRESENTATION_NAME = "RecordTemplateCreateRepresentation";
+export declare const RECORD_TEMPLATE_CREATE_REPRESENTATION_PREFIX: string;
+export declare function isStoreKeyRecordTemplateId(key: string): boolean;
 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 extractAPINameFromRecordTemplateKey(originalKey: string): string | undefined;
 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.332.0-dev2",
+    "version": "1.332.0-dev21",
     "license": "SEE LICENSE IN LICENSE.txt",
     "description": "LDS Record Utilities",
     "main": "dist/ldsDurableRecords.js",
@@ -25,9 +25,9 @@
     "dependencies": {
         "@luvio/engine": "0.156.5",
         "@luvio/environments": "0.156.5",
-        "@salesforce/lds-adapters-uiapi": "^1.332.0-dev2"
+        "@salesforce/lds-adapters-uiapi": "^1.332.0-dev21"
     },
     "devDependencies": {
-        "@salesforce/lds-store-nimbus": "^1.332.0-dev2"
+        "@salesforce/lds-store-nimbus": "^1.332.0-dev21"
     }
 }