@salesforce/lds-worker-api 1.244.0 → 1.245.0

package/dist/sfdc/es/ldsWorkerApi.js

@@ -36,7 +36,7 @@ import * as gqlApi from 'force/ldsAdaptersGraphql';
 import { getRuntime, reportGraphqlQueryParseError } from 'native/ldsRuntimeMobile';
 export { registerReportObserver } from 'native/ldsRuntimeMobile';
 import { HttpStatusCode } from 'force/luvioEngine';
-import { API_NAMESPACE, RECORD_REPRESENTATION_NAME } from 'force/ldsAdaptersUiapi';
+import { API_NAMESPACE, RECORD_REPRESENTATION_NAME, keyBuilderRecord } from 'force/ldsAdaptersUiapi';
 import { withDefaultLuvio } from 'native/ldsEngineMobile';
 
 const { create, keys } = Object;
@@ -778,6 +778,245 @@ function removeEventHandler(session, handler) {
     }
 }
 
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+
+var DraftActionStatus;
+(function (DraftActionStatus) {
+    DraftActionStatus["Pending"] = "pending";
+    DraftActionStatus["Uploading"] = "uploading";
+    DraftActionStatus["Error"] = "error";
+    DraftActionStatus["Completed"] = "completed";
+})(DraftActionStatus || (DraftActionStatus = {}));
+var ProcessActionResult;
+(function (ProcessActionResult) {
+    // non-2xx network error, requires user intervention
+    ProcessActionResult["ACTION_ERRORED"] = "ERROR";
+    // upload succeeded
+    ProcessActionResult["ACTION_SUCCEEDED"] = "SUCCESS";
+    // queue is empty
+    ProcessActionResult["NO_ACTION_TO_PROCESS"] = "NO_ACTION_TO_PROCESS";
+    // network request is in flight
+    ProcessActionResult["ACTION_ALREADY_PROCESSING"] = "ACTION_ALREADY_PROCESSING";
+    // network call failed (offline)
+    ProcessActionResult["NETWORK_ERROR"] = "NETWORK_ERROR";
+    // queue is blocked on an error that requires user intervention
+    ProcessActionResult["BLOCKED_ON_ERROR"] = "BLOCKED_ON_ERROR";
+    //waiting for user to execute custom action
+    ProcessActionResult["CUSTOM_ACTION_WAITING"] = "CUSTOM_ACTION_WAITING";
+})(ProcessActionResult || (ProcessActionResult = {}));
+var DraftQueueState;
+(function (DraftQueueState) {
+    /** Currently processing an item in the queue or queue is empty and waiting to process the next item. */
+    DraftQueueState["Started"] = "started";
+    /**
+     * The queue is stopped and will not attempt to upload any drafts until startDraftQueue() is called.
+     * This is the initial state when the DraftQueue gets instantiated.
+     */
+    DraftQueueState["Stopped"] = "stopped";
+    /**
+     * The queue is stopped due to a blocking error from the last upload attempt.
+     * The queue will not run again until startDraftQueue() is called.
+     */
+    DraftQueueState["Error"] = "error";
+    /**
+     * There was a network error and the queue will attempt to upload again shortly.
+     * To attempt to force an upload now call startDraftQueue().
+     */
+    DraftQueueState["Waiting"] = "waiting";
+})(DraftQueueState || (DraftQueueState = {}));
+var DraftQueueEventType;
+(function (DraftQueueEventType) {
+    /**
+     * Triggered after an action had been added to the queue
+     */
+    DraftQueueEventType["ActionAdded"] = "added";
+    /**
+     * Triggered when starting to upload and process an action
+     */
+    DraftQueueEventType["ActionUploading"] = "uploading";
+    /**
+     * Triggered once an action failed
+     */
+    DraftQueueEventType["ActionFailed"] = "failed";
+    /**
+     * Triggered after an action has been deleted from the queue
+     */
+    DraftQueueEventType["ActionDeleted"] = "deleted";
+    /**
+     * Triggered after an action has been completed and after it has been removed from the queue
+     */
+    DraftQueueEventType["ActionCompleted"] = "completed";
+    /**
+     * Triggered after an action has been updated by the updateAction API
+     */
+    DraftQueueEventType["ActionUpdated"] = "updated";
+    /**
+     * Triggered after the Draft Queue state changes
+     */
+    DraftQueueEventType["QueueStateChanged"] = "state";
+})(DraftQueueEventType || (DraftQueueEventType = {}));
+var QueueOperationType;
+(function (QueueOperationType) {
+    QueueOperationType["Add"] = "add";
+    QueueOperationType["Delete"] = "delete";
+    QueueOperationType["Update"] = "update";
+})(QueueOperationType || (QueueOperationType = {}));
+/**
+Use Math.random to generate v4 RFC4122 compliant uuid
+ */
+function uuidv4() {
+    const uuid = [];
+    for (let i = 0; i < 32; i++) {
+        const random = (Math.random() * 16) | 0;
+        if (i === 8 || i === 12 || i === 16 || i === 20) {
+            uuid.push('-');
+        }
+        uuid.push((i === 12 ? 4 : i === 16 ? (random & 3) | 8 : random).toString(16));
+    }
+    return uuid.join('');
+}
+
+var CustomActionResultType;
+(function (CustomActionResultType) {
+    CustomActionResultType["SUCCESS"] = "SUCCESS";
+    CustomActionResultType["FAILURE"] = "FAILURE";
+})(CustomActionResultType || (CustomActionResultType = {}));
+var CustomActionErrorType;
+(function (CustomActionErrorType) {
+    CustomActionErrorType["NETWORK_ERROR"] = "NETWORK_ERROR";
+    CustomActionErrorType["CLIENT_ERROR"] = "CLIENT_ERROR";
+})(CustomActionErrorType || (CustomActionErrorType = {}));
+
+/**
+ * Denotes what kind of operation a DraftQueueItem represents.
+ */
+var DraftActionOperationType;
+(function (DraftActionOperationType) {
+    DraftActionOperationType["Create"] = "create";
+    DraftActionOperationType["Update"] = "update";
+    DraftActionOperationType["Delete"] = "delete";
+    DraftActionOperationType["Custom"] = "custom";
+})(DraftActionOperationType || (DraftActionOperationType = {}));
+var DraftQueueOperationType;
+(function (DraftQueueOperationType) {
+    DraftQueueOperationType["ItemAdded"] = "added";
+    DraftQueueOperationType["ItemUploading"] = "uploading";
+    DraftQueueOperationType["ItemDeleted"] = "deleted";
+    DraftQueueOperationType["ItemCompleted"] = "completed";
+    DraftQueueOperationType["ItemFailed"] = "failed";
+    DraftQueueOperationType["ItemUpdated"] = "updated";
+    DraftQueueOperationType["QueueStarted"] = "started";
+    DraftQueueOperationType["QueueStopped"] = "stopped";
+})(DraftQueueOperationType || (DraftQueueOperationType = {}));
+
+var EvictStatus;
+(function (EvictStatus) {
+    EvictStatus["InProgress"] = "InProgress";
+    EvictStatus["Succeeded"] = "Succeeded";
+    EvictStatus["Error"] = "Error";
+    EvictStatus["Cancelled"] = "Cancelled";
+})(EvictStatus || (EvictStatus = {}));
+const MessagingDurableSegmentName = 'MESSAGING';
+const DEFAULT_MAX_ENTRIES_PER_OPERATION = 500;
+/**
+ * Keep tracking of ongoing eviction id to a flag to trigger eviction cancellation.
+ * false in the begining, set to false when cancelEviction is called.
+ */
+const inProgressEvictions = new Map();
+/**
+ * Purging records specified by an array of record id from durable store
+ * @param recordIds record id array
+ * @onProgressUpdate call back to report evict progress
+ *
+ * @returns a function to cancel the eviction
+ *
+ * The record will not be purged if the record has draft.
+ */
+function evictCacheRecordsByIds(recordIds, onProgressUpdate) {
+    const evictionId = uuidv4();
+    inProgressEvictions.set(evictionId, false);
+    const onEvicted = (progress) => {
+        onProgressUpdate(progress);
+        const { status } = progress;
+        if (status === EvictStatus.Succeeded || status === EvictStatus.Error) {
+            inProgressEvictions.delete(evictionId);
+        }
+        if (status === EvictStatus.InProgress) {
+            if (inProgressEvictions.get(evictionId)) {
+                inProgressEvictions.delete(evictionId);
+                onProgressUpdate({ status: EvictStatus.Cancelled });
+            }
+            else {
+                evictAChunk();
+            }
+        }
+    };
+    const evictAChunk = () => {
+        evictChunksOfRecord(recordIds).then(onEvicted);
+    };
+    evictAChunk();
+    return evictionId;
+}
+/**
+ * Cancel the eviction by specified id.
+ * @param evictionId
+ */
+function cancelEviction(evictionId) {
+    inProgressEvictions.set(evictionId, true);
+}
+/**
+ * pull a chunk of record id, evict status back in a promise.
+ * @param ids the list of record ids.
+ * @returns
+ */
+function evictChunksOfRecord(ids) {
+    const chunk = ids.splice(0, DEFAULT_MAX_ENTRIES_PER_OPERATION);
+    if (chunk.length === 0) {
+        return Promise.resolve({ status: EvictStatus.Succeeded });
+    }
+    return new Promise((resolve) => {
+        // evict the chunk
+        const { luvio, nimbusSqliteStore } = getRuntime();
+        const paramTemplate = chunk.map((_) => '?').join(',');
+        const params = chunk.map((recordId) => keyBuilderRecord(luvio, { recordId }));
+        try {
+            nimbusSqliteStore
+                .query(`DELETE FROM lds_data  
+                    WHERE key IN (${paramTemplate}) AND JSON_EXTRACT(data,'$.drafts') IS NULL
+                    RETURNING key
+                `, params)
+                .then((result) => {
+                const evictedEntries = result.rows.map((row) => row[0]);
+                const skippedEntries = params.filter((entryKey) => evictedEntries.indexOf(entryKey) === -1);
+                // broadcast entries evicted
+                nimbusSqliteStore.setEntries({ notifyStoreUpdateAvailable: { data: evictedEntries } }, MessagingDurableSegmentName);
+                resolve({
+                    status: EvictStatus.InProgress,
+                    evictedEntries,
+                    skippedEntries,
+                });
+            })
+                .catch((reason) => {
+                resolve({
+                    status: EvictStatus.Error,
+                    message: JSON.stringify(reason),
+                });
+            });
+        }
+        catch (reason) {
+            resolve({
+                status: EvictStatus.Error,
+                message: JSON.stringify(reason),
+            });
+        }
+    });
+}
+
 if (process.env.NODE_ENV !== 'production') {
     // eslint-disable-next-line no-undef
     withDefaultLuvio((luvio) => {
@@ -787,5 +1026,5 @@ if (process.env.NODE_ENV !== 'production') {
     });
 }
 
-export { createPrimingSession, draftManager, draftQueue, executeAdapter, executeMutatingAdapter, getImperativeAdapterNames, invokeAdapter, invokeAdapterWithDraftToReplace, invokeAdapterWithMetadata, nimbusDraftQueue, setMetadataTTL, setUiApiRecordTTL, subscribeToAdapter };
-// version: 1.244.0-72e322fff
+export { cancelEviction, createPrimingSession, draftManager, draftQueue, evictCacheRecordsByIds, executeAdapter, executeMutatingAdapter, getImperativeAdapterNames, invokeAdapter, invokeAdapterWithDraftToReplace, invokeAdapterWithMetadata, nimbusDraftQueue, setMetadataTTL, setUiApiRecordTTL, subscribeToAdapter };
+// version: 1.245.0-0ea124370

package/dist/sfdc/es/types/cachePurging.d.ts

@@ -0,0 +1,39 @@
+declare enum EvictStatus {
+    InProgress = "InProgress",
+    Succeeded = "Succeeded",
+    Error = "Error",
+    Cancelled = "Cancelled"
+}
+interface EvictInProgress {
+    status: EvictStatus.InProgress;
+    skippedEntries?: string[];
+    evictedEntries?: string[];
+}
+interface EvictSucceeded {
+    status: EvictStatus.Succeeded;
+}
+interface EvictError {
+    status: EvictStatus.Error;
+    message: string;
+}
+interface EvictCancelled {
+    status: EvictStatus.Cancelled;
+}
+export type EvictProgress = EvictInProgress | EvictSucceeded | EvictError | EvictCancelled;
+export type ProgressUpdateCallback = (progess: EvictProgress) => void;
+/**
+ * Purging records specified by an array of record id from durable store
+ * @param recordIds record id array
+ * @onProgressUpdate call back to report evict progress
+ *
+ * @returns a function to cancel the eviction
+ *
+ * The record will not be purged if the record has draft.
+ */
+export declare function evictCacheRecordsByIds(recordIds: string[], onProgressUpdate: ProgressUpdateCallback): string;
+/**
+ * Cancel the eviction by specified id.
+ * @param evictionId
+ */
+export declare function cancelEviction(evictionId: string): void;
+export {};

package/dist/sfdc/es/types/main.d.ts

@@ -5,4 +5,5 @@ import { draftQueue, draftManager } from './draftQueueImplementation';
 import { setUiApiRecordTTL, setMetadataTTL } from './ttl';
 import { registerReportObserver } from '@salesforce/lds-runtime-mobile';
 import { createPrimingSession } from './primingApi';
-export { subscribeToAdapter, invokeAdapter, invokeAdapterWithMetadata, invokeAdapterWithDraftToReplace, executeAdapter, executeMutatingAdapter, nimbusDraftQueue, draftQueue, draftManager, setUiApiRecordTTL, setMetadataTTL, registerReportObserver, getImperativeAdapterNames, createPrimingSession, };
+import { evictCacheRecordsByIds, cancelEviction } from './cachePurging';
+export { subscribeToAdapter, invokeAdapter, invokeAdapterWithMetadata, invokeAdapterWithDraftToReplace, executeAdapter, executeMutatingAdapter, nimbusDraftQueue, draftQueue, draftManager, setUiApiRecordTTL, setMetadataTTL, registerReportObserver, getImperativeAdapterNames, createPrimingSession, evictCacheRecordsByIds, cancelEviction, };