@salesforce/lds-worker-api 1.371.0 → 1.372.1

package/dist/standalone/es/lds-worker-api.js

@@ -4274,7 +4274,7 @@ function withDefaultLuvio(callback) {
     }
     callbacks.push(callback);
 }
-// version: 1.371.0-e11a80989c
+// version: 1.372.1-5ff6849fe2
 
 // TODO [TD-0081508]: once that TD is fulfilled we can probably change this file
 function instrumentAdapter$1(createFunction, _metadata) {
@@ -5118,6 +5118,24 @@ function snapshotToTuple(snapshot) {
     }
     return payload;
 }
+/**
+ * The graphql batch snapshot should be treated the same as a regular imperative adapter snapshot.
+ * @param snapshot - The snapshot to convert to a tuple
+ * @returns The tuple representation of the snapshot
+ */
+function batchSnapshotToTuple(snapshot) {
+    if (isErrorSnapshot$2(snapshot)) {
+        return {
+            data: undefined,
+            error: snapshot.error,
+        };
+    }
+    // We might still get pending snapshot here from invoke calls here
+    return {
+        data: snapshot.data,
+        error: undefined,
+    };
+}
 function createInvalidConfigError() {
     return {
         data: undefined,
@@ -5145,7 +5163,9 @@ function createGraphQLImperativeAdapter(luvio, adapter, metadata, astResolver) {
     const { name } = metadata;
     const imperativeAdapterInvoke = (config, requestContext, callback) => {
         let coercedConfig = null;
+        let isBatch = false;
         if ('batchQuery' in config) {
+            isBatch = true;
             coercedConfig = {
                 batchQuery: config.batchQuery.map((individualConfig) => ({
                     ...individualConfig,
@@ -5175,7 +5195,9 @@ function createGraphQLImperativeAdapter(luvio, adapter, metadata, astResolver) {
             return;
         }
         if (!isPromise$3(snapshotOrPromise)) {
-            callback(snapshotToTuple(snapshotOrPromise));
+            callback(isBatch
+                ? batchSnapshotToTuple(snapshotOrPromise)
+                : snapshotToTuple(snapshotOrPromise));
             return;
         }
         snapshotOrPromise
@@ -5184,7 +5206,7 @@ function createGraphQLImperativeAdapter(luvio, adapter, metadata, astResolver) {
                 callback(createInvalidConfigError());
                 return;
             }
-            callback(snapshotToTuple(snapshot));
+            callback(isBatch ? batchSnapshotToTuple(snapshot) : snapshotToTuple(snapshot));
         })
             .finally(() => {
             luvio.storeCleanup();
@@ -5199,7 +5221,9 @@ function createGraphQLImperativeAdapter(luvio, adapter, metadata, astResolver) {
         let subscriberCallback = callback;
         let unsub;
         let coercedConfig = null;
+        let isBatch = false;
         if ('batchQuery' in config) {
+            isBatch = true;
             coercedConfig = {
                 batchQuery: config.batchQuery.map((individualConfig) => ({
                     ...individualConfig,
@@ -5232,7 +5256,9 @@ function createGraphQLImperativeAdapter(luvio, adapter, metadata, astResolver) {
         const luvioStoreSubscribe = (snapshot) => {
             unsub = luvio.storeSubscribe(snapshot, (snapshotFromRebuild) => {
                 if (subscriberCallback !== null && !isPendingSnapshot(snapshotFromRebuild)) {
-                    subscriberCallback(snapshotToTuple(snapshotFromRebuild));
+                    subscriberCallback(isBatch
+                        ? batchSnapshotToTuple(snapshotFromRebuild)
+                        : snapshotToTuple(snapshotFromRebuild));
                 }
             });
         };
@@ -5240,7 +5266,9 @@ function createGraphQLImperativeAdapter(luvio, adapter, metadata, astResolver) {
             // We don't want to return pending snapshots to user-land
             // Instead we just subscribe to it
             if (!isPendingSnapshot(snapshotOrPromise)) {
-                subscriberCallback(snapshotToTuple(snapshotOrPromise));
+                subscriberCallback(isBatch
+                    ? batchSnapshotToTuple(snapshotOrPromise)
+                    : snapshotToTuple(snapshotOrPromise));
             }
             luvioStoreSubscribe(snapshotOrPromise);
         }
@@ -5255,7 +5283,7 @@ function createGraphQLImperativeAdapter(luvio, adapter, metadata, astResolver) {
                     // We don't want to return pending snapshots to user-land
                     // Instead we just subscribe to it
                     if (!isPendingSnapshot(snapshot)) {
-                        subscriberCallback(snapshotToTuple(snapshot));
+                        subscriberCallback(isBatch ? batchSnapshotToTuple(snapshot) : snapshotToTuple(snapshot));
                     }
                     luvioStoreSubscribe(snapshot);
                 }
@@ -5290,7 +5318,7 @@ function createGraphQLWireAdapterConstructor(luvio, adapter, metadata, astResolv
     const { apiFamily, name } = metadata;
     return createGraphQLWireAdapterConstructor$1(adapter, `${apiFamily}.${name}`, luvio, astResolver);
 }
-// version: 1.371.0-e11a80989c
+// version: 1.372.1-5ff6849fe2
 
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -34166,7 +34194,7 @@ withDefaultLuvio((luvio) => {
     throttle(60, 60000, setupNotifyAllListRecordUpdateAvailable(luvio));
     throttle(60, 60000, setupNotifyAllListInfoSummaryUpdateAvailable(luvio));
 });
-// version: 1.371.0-1f3d834ba4
+// version: 1.372.1-8824ae9dd4
 
 function requestIdleDetectedCallback(_callback) { }
 function declareNotifierTaskSingle(_name) {
@@ -94197,14 +94225,20 @@ let AuraCacheControlCommand$1 = class AuraCacheControlCommand extends CacheContr
   async coerceFetchError(errorResponse) {
     return toError(errorResponse.statusText);
   }
+  processAuraReturnValue(auraReturnValue) {
+    return ok$1(auraReturnValue);
+  }
+  processFetchReturnValue(json) {
+    return ok$1(json);
+  }
   convertAuraResponseToData(responsePromise, coerceError) {
     return responsePromise.then((response) => {
-      const auraReturnValue = response.getReturnValue();
+      return this.processAuraReturnValue(response.getReturnValue());
+    }).finally(() => {
       try {
         this.afterRequestHooks({ statusCode: 200 });
       } catch (e) {
       }
-      return ok$1(auraReturnValue);
     }).catch((error) => {
       if (!error || !error.getError) {
         return err$1(toError("Failed to get error from response"));
@@ -94223,7 +94257,9 @@ let AuraCacheControlCommand$1 = class AuraCacheControlCommand extends CacheContr
       (response2) => {
         if (response2.ok) {
           return response2.json().then(
-            (json) => ok$1(json),
+            (json) => {
+              return this.processFetchReturnValue(json);
+            },
             (reason) => err$1(toError(reason))
           ).finally(() => {
             try {
@@ -94328,14 +94364,20 @@ class AuraCacheControlCommand extends CacheControlCommand {
   async coerceFetchError(errorResponse) {
     return toError(errorResponse.statusText);
   }
+  processAuraReturnValue(auraReturnValue) {
+    return ok$1(auraReturnValue);
+  }
+  processFetchReturnValue(json) {
+    return ok$1(json);
+  }
   convertAuraResponseToData(responsePromise, coerceError) {
     return responsePromise.then((response) => {
-      const auraReturnValue = response.getReturnValue();
+      return this.processAuraReturnValue(response.getReturnValue());
+    }).finally(() => {
       try {
         this.afterRequestHooks({ statusCode: 200 });
       } catch (e) {
       }
-      return ok$1(auraReturnValue);
     }).catch((error) => {
       if (!error || !error.getError) {
         return err$1(toError("Failed to get error from response"));
@@ -94354,7 +94396,9 @@ class AuraCacheControlCommand extends CacheControlCommand {
       (response2) => {
         if (response2.ok) {
           return response2.json().then(
-            (json) => ok$1(json),
+            (json) => {
+              return this.processFetchReturnValue(json);
+            },
             (reason) => err$1(toError(reason))
           ).finally(() => {
             try {
@@ -94547,12 +94591,17 @@ class HttpCacheControlCommand extends CacheControlCommand {
   async coerceError(errorResponse) {
     return toError(errorResponse.statusText);
   }
+  processFetchReturnValue(json) {
+    return ok$1(json);
+  }
   convertFetchResponseToData(response) {
     return response.then(
       (response2) => {
         if (response2.ok) {
           return response2.json().then(
-            (json) => ok$1(json),
+            (json) => {
+              return this.processFetchReturnValue(json);
+            },
             (reason) => err$1(toError(reason))
           ).finally(() => {
             try {
@@ -95484,12 +95533,31 @@ function buildNimbusFetchServiceDescriptor() {
     const service = (...args) => {
         const resourceRequest = convertFetchParamsToResourceRequest(args);
         const context = {};
-        return NimbusNetworkAdapter(resourceRequest, context).then((response) => {
-            return new Response(response.body, {
+        return NimbusNetworkAdapter(resourceRequest, context)
+            .then((response) => {
+            // This is a hack to make the response compatible with the Response interface
+            const r = {
+                body: response.body,
                 headers: response.headers,
                 status: response.status,
                 statusText: response.statusText,
-            });
+                json: () => {
+                    return Promise.resolve(response.body);
+                },
+                ok: response.status >= 200 && response.status < 300,
+            };
+            return r;
+        })
+            .catch((error) => {
+            // Create a Response-like error object
+            return {
+                body: null,
+                headers: {},
+                status: 500,
+                statusText: error.message || 'Internal Server Error',
+                json: () => Promise.resolve(null),
+                ok: false,
+            };
         });
     };
     return {
@@ -95508,38 +95576,113 @@ function buildNimbusFetchServiceDescriptor() {
  * @returns A ResourceRequest object compatible with NimbusNetworkAdapter
  */
 function convertFetchParamsToResourceRequest([input, init]) {
-    const url = typeof input === 'string'
-        ? new URL(input)
-        : input instanceof URL
-            ? input
-            : new URL(input.url);
+    const urlString = typeof input === 'string' ? input : input.href || input.url || input;
+    const { baseUri, basePath, queryParams } = parseUrlParts(urlString);
     const headers = {};
     if (init?.headers) {
-        if (init.headers instanceof Headers) {
+        if (typeof Headers !== 'undefined' && init?.headers instanceof Headers) {
             init.headers.forEach((value, key) => {
                 headers[key] = value;
             });
         }
-        else if (Array.isArray(init.headers)) {
+        else if (Array.isArray(init?.headers)) {
             init.headers.forEach(([key, value]) => {
                 headers[key] = value;
             });
         }
         else {
-            Object.entries(init.headers).forEach(([key, value]) => {
+            Object.entries(init?.headers || {}).forEach(([key, value]) => {
                 headers[key] = value;
             });
         }
     }
-    return {
-        baseUri: url.origin,
-        basePath: url.pathname,
+    const resourceRequest = {
+        baseUri,
+        basePath,
         method: (init?.method || 'GET').toLowerCase(),
-        body: init?.body || null,
         headers,
-        queryParams: Object.fromEntries(url.searchParams),
+        body: (() => {
+            if (!init?.body) {
+                return null;
+            }
+            try {
+                return typeof init.body === 'string' ? JSON.parse(init.body) : init.body;
+            }
+            catch {
+                return init.body;
+            }
+        })(),
+        queryParams,
         urlParams: {},
     };
+    return resourceRequest;
+}
+function parseUrlParts(urlString) {
+    // Split by protocol first
+    const [protocol, rest] = urlString.split('://');
+    // If no protocol, treat whole string as path
+    if (!rest) {
+        return {
+            baseUri: '',
+            basePath: urlString.startsWith('/')
+                ? urlString.split('?')[0]
+                : `/${urlString.split('?')[0]}`,
+            queryParams: extractQueryParams(urlString),
+        };
+    }
+    // Split remaining parts
+    const parts = rest.split('/');
+    let hostPart = parts[0] || '';
+    const pathParts = parts.slice(1);
+    // Handle query string in host part (e.g., "example.com?key=value")
+    let hostQueryString = '';
+    if (hostPart.includes('?')) {
+        const [host, query] = hostPart.split('?');
+        hostPart = host;
+        hostQueryString = query;
+    }
+    // Handle query string in path parts
+    const lastPart = pathParts[pathParts.length - 1] || '';
+    const [pathEnd, pathQueryString] = lastPart.split('?');
+    // Combine query strings (host takes precedence if both exist)
+    const queryString = hostQueryString || pathQueryString;
+    // Reconstruct
+    const baseUri = hostPart ? `${protocol}://${hostPart}` : urlString;
+    const basePath = pathParts.length > 0 ? `/${pathParts.slice(0, -1).concat(pathEnd).join('/')}` : '/';
+    const queryParams = {};
+    if (queryString) {
+        queryString.split('&').forEach((param) => {
+            const [key, value = ''] = param.split('=');
+            if (key) {
+                try {
+                    queryParams[decodeURIComponent(key)] = decodeURIComponent(value);
+                }
+                catch {
+                    queryParams[key] = value;
+                }
+            }
+        });
+    }
+    return { baseUri, basePath, queryParams };
+}
+function extractQueryParams(urlString) {
+    const queryParams = {};
+    const queryStart = urlString.indexOf('?');
+    if (queryStart > -1) {
+        const queryString = urlString.substring(queryStart + 1);
+        queryString.split('&').forEach((param) => {
+            const [key, value = ''] = param.split('=');
+            if (key) {
+                try {
+                    queryParams[decodeURIComponent(key)] = decodeURIComponent(value);
+                }
+                catch {
+                    queryParams[key] = value;
+                }
+            }
+        });
+    }
+    return queryParams;
 }
 
 /*!
@@ -96069,6 +96212,10 @@ function initializeOneStore(sqliteStore) {
     if (!useOneStore.isOpen({ fallback: true })) {
         return;
     }
+    // Initialize performance.now() fallback if not available
+    if (typeof globalThis.performance === 'undefined') {
+        globalThis.performance = { now: () => Date.now() };
+    }
     const loggerService = new ConsoleLogger('ERROR');
     const cacheServiceDescriptor = buildServiceDescriptor$6();
     const instrumentationServiceDescriptor = buildServiceDescriptor$3(loggerService);
@@ -96296,7 +96443,7 @@ register$1({
     id: '@salesforce/lds-network-adapter',
     instrument: instrument$2,
 });
-// version: 1.371.0-e11a80989c
+// version: 1.372.1-5ff6849fe2
 
 const { create: create$2, keys: keys$2 } = Object;
 const { stringify, parse } = JSON;
@@ -122787,7 +122934,7 @@ function refreshGraphQL(data) {
     }
     return refresh$3(data, 'refreshUiApi');
 }
-// version: 1.371.0-1f3d834ba4
+// version: 1.372.1-8824ae9dd4
 
 // On core the unstable adapters are re-exported with different names,
 // we want to match them here.
@@ -122939,7 +123086,7 @@ withDefaultLuvio((luvio) => {
     unstable_graphQL_imperative = createImperativeAdapter(luvio, createInstrumentedAdapter(ldsAdapter, adapterMetadata), adapterMetadata);
     graphQLImperative = ldsAdapter;
 });
-// version: 1.371.0-1f3d834ba4
+// version: 1.372.1-8824ae9dd4
 
 var gqlApi = /*#__PURE__*/Object.freeze({
     __proto__: null,
@@ -123738,7 +123885,7 @@ const callbacks$1 = [];
 function register(r) {
     callbacks$1.forEach((callback) => callback(r));
 }
-// version: 1.371.0-e11a80989c
+// version: 1.372.1-5ff6849fe2
 
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -124918,11 +125065,160 @@ class LuvioAdapterModule {
     }
 }
 
+const ONESTORE_ADAPTER_FAMILY = /^force\/ldsAdapters/;
+function buildOneStoreError(error) {
+    let errorMessage;
+    if (typeof error === 'string') {
+        errorMessage = error;
+    }
+    else if (error && error.message) {
+        errorMessage = error.message;
+    }
+    else if (error !== null && error !== undefined) {
+        errorMessage = error.toString();
+    }
+    else {
+        errorMessage = error;
+    }
+    return {
+        data: undefined,
+        error: errorMessage,
+    };
+}
+function buildInvalidAdapterError(adapterOrCommandName) {
+    return {
+        data: undefined,
+        error: `Invalid adapter or command: ${adapterOrCommandName}`,
+    };
+}
+function buildNativeResponse(response) {
+    if (response && response.error) {
+        return buildOneStoreError(response.error);
+    }
+    return response;
+}
+async function importOneStoreAdapterModule(specifier) {
+    if (!ONESTORE_ADAPTER_FAMILY.test(specifier)) {
+        throw `${specifier} is not an allowed onestore adapter module`;
+    }
+    let module;
+    try {
+        module = await import(specifier);
+    }
+    catch {
+        throw `module not found for specifier ${specifier}`;
+    }
+    return new OneStoreAdapterModule(module);
+}
+class OneStoreAdapterModule {
+    constructor(module) {
+        this.module = module;
+    }
+    async invoke(adapterOrCommandName, config) {
+        const adapterOrCommand = this.module[adapterOrCommandName];
+        if (adapterOrCommand === undefined) {
+            return buildInvalidAdapterError(`Command ${adapterOrCommandName} not recognized`);
+        }
+        return new Promise((resolve) => {
+            try {
+                if (this.isCommandWireAdapter(adapterOrCommand)) {
+                    // WIRE COMMAND
+                    const adapter = new adapterOrCommand((result) => {
+                        resolve(buildNativeResponse(result));
+                        adapter.disconnect();
+                    }, undefined, { skipEmptyEmit: true });
+                    adapter.connect();
+                    adapter.update(config);
+                }
+                else if (this.hasInvoke(adapterOrCommand)) {
+                    // IMPERATIVE LEGACY INVOKER
+                    adapterOrCommand.invoke(config, null, (result) => {
+                        resolve(buildNativeResponse(result));
+                    });
+                }
+                else {
+                    // IMPERATIVE INVOKER
+                    adapterOrCommand(config)
+                        .then((response) => {
+                        resolve(buildNativeResponse(response));
+                    })
+                        .catch((error) => {
+                        resolve(buildOneStoreError(error));
+                    });
+                }
+            }
+            catch (error) {
+                resolve(buildInvalidAdapterError(adapterOrCommandName));
+            }
+        });
+    }
+    subscribe(adapterOrCommandName, config, callback) {
+        const adapterOrCommand = this.module[adapterOrCommandName];
+        if (adapterOrCommand === undefined) {
+            callback(buildInvalidAdapterError(adapterOrCommandName));
+            return Promise.resolve(undefined);
+        }
+        return new Promise((resolve) => {
+            try {
+                if (this.isCommandWireAdapter(adapterOrCommand)) {
+                    // WIRE COMMAND
+                    const adapter = new adapterOrCommand((result) => {
+                        callback(buildNativeResponse(result));
+                    }, undefined, { skipEmptyEmit: true });
+                    adapter.connect();
+                    adapter.update(config);
+                    resolve(() => adapter.disconnect());
+                }
+                else if (this.hasSubscribe(adapterOrCommand)) {
+                    // IMPERATIVE LEGACY INVOKER
+                    const unsubscribe = adapterOrCommand.subscribe(config, null, (result) => {
+                        callback(buildNativeResponse(result));
+                    });
+                    resolve(unsubscribe);
+                }
+                else {
+                    // IMPERATIVE INVOKER
+                    adapterOrCommand(config)
+                        .then((response) => {
+                        if (response.subscribe === undefined) {
+                            callback(buildNativeResponse(response));
+                            resolve(undefined);
+                        }
+                        else {
+                            const unsubscribe = response.subscribe((subscriptionResult) => {
+                                callback(buildNativeResponse(subscriptionResult));
+                            });
+                            resolve(unsubscribe);
+                        }
+                    })
+                        .catch((error) => {
+                        callback(buildOneStoreError(error));
+                        resolve(undefined);
+                    });
+                }
+            }
+            catch (error) {
+                callback(buildInvalidAdapterError(adapterOrCommandName));
+                resolve(undefined);
+            }
+        });
+    }
+    isCommandWireAdapter(adapterOrCommand) {
+        return Object.getPrototypeOf(adapterOrCommand).name === 'CommandWireAdapterConstructor';
+    }
+    hasInvoke(adapterOrCommand) {
+        return typeof adapterOrCommand.invoke === 'function';
+    }
+    hasSubscribe(adapterOrCommand) {
+        return typeof adapterOrCommand.subscribe === 'function';
+    }
+}
+
 // LWR has a "setupLDS" bootstrap service/loader hook, we simulate this in
 // standalone bundle by mimicking what "setupLDS" does here and then exporting
 // everything from main.ts
 const { luvio } = getRuntime();
 setDefaultLuvio({ luvio });
 
-export { createPrimingSession, draftManager, draftQueue, evictCacheRecordsByIds, evictExpiredCacheEntries, executeAdapter, executeMutatingAdapter, getImperativeAdapterNames, importLuvioAdapterModule, invokeAdapter, invokeAdapterWithDraftToMerge, invokeAdapterWithDraftToReplace, invokeAdapterWithMetadata, nimbusDraftQueue, registerReportObserver, setMetadataTTL, setUiApiRecordTTL, stopEviction, subscribeToAdapter };
-// version: 1.371.0-e11a80989c
+export { createPrimingSession, draftManager, draftQueue, evictCacheRecordsByIds, evictExpiredCacheEntries, executeAdapter, executeMutatingAdapter, getImperativeAdapterNames, importLuvioAdapterModule, importOneStoreAdapterModule, invokeAdapter, invokeAdapterWithDraftToMerge, invokeAdapterWithDraftToReplace, invokeAdapterWithMetadata, nimbusDraftQueue, registerReportObserver, setMetadataTTL, setUiApiRecordTTL, stopEviction, subscribeToAdapter };
+// version: 1.372.1-5ff6849fe2

package/dist/standalone/es/types/customOneStoreAdapter.d.ts

@@ -0,0 +1,21 @@
+import type { Unsubscribe } from '@luvio/engine';
+export type OneStoreNativeCallbackValue = OneStoreNativeCallbackData | OneStoreNativeCallbackError;
+export type OneStoreNativeCallbackData = {
+    data: any | undefined;
+    error?: undefined;
+};
+export type OneStoreNativeCallbackError = {
+    data?: undefined;
+    error: string;
+};
+export declare function importOneStoreAdapterModule(specifier: string): Promise<OneStoreAdapterModule>;
+declare class OneStoreAdapterModule {
+    module: any;
+    constructor(module: any);
+    invoke<Config>(adapterOrCommandName: string, config: Config): Promise<OneStoreNativeCallbackValue>;
+    subscribe<Config>(adapterOrCommandName: string, config: Config, callback: (value: OneStoreNativeCallbackValue) => void): Promise<Unsubscribe | undefined>;
+    private isCommandWireAdapter;
+    private hasInvoke;
+    private hasSubscribe;
+}
+export {};

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

@@ -7,4 +7,5 @@ import { registerReportObserver } from '@salesforce/lds-runtime-mobile';
 import { createPrimingSession } from './primingApi';
 import { evictCacheRecordsByIds, evictExpiredCacheEntries, stopEviction } from './cachePurging';
 import { importLuvioAdapterModule } from './customLuvioAdapter';
-export { subscribeToAdapter, invokeAdapter, invokeAdapterWithMetadata, invokeAdapterWithDraftToReplace, invokeAdapterWithDraftToMerge, executeAdapter, executeMutatingAdapter, nimbusDraftQueue, draftQueue, draftManager, setUiApiRecordTTL, setMetadataTTL, registerReportObserver, getImperativeAdapterNames, createPrimingSession, evictCacheRecordsByIds, evictExpiredCacheEntries, stopEviction, importLuvioAdapterModule, };
+import { importOneStoreAdapterModule } from './customOneStoreAdapter';
+export { subscribeToAdapter, invokeAdapter, invokeAdapterWithMetadata, invokeAdapterWithDraftToReplace, invokeAdapterWithDraftToMerge, executeAdapter, executeMutatingAdapter, nimbusDraftQueue, draftQueue, draftManager, setUiApiRecordTTL, setMetadataTTL, registerReportObserver, getImperativeAdapterNames, createPrimingSession, evictCacheRecordsByIds, evictExpiredCacheEntries, stopEviction, importLuvioAdapterModule, importOneStoreAdapterModule, };