@salesforce/lds-utils-adapters 1.124.1 → 1.124.3

package/dist/ldsAdapterUtils.js

@@ -8,387 +8,387 @@ import { isDurableEnvironmentEvent } from '@luvio/environments';
 
 const { stringify } = JSON;
 
-function isPromise(value) {
-    // check for Thenable due to test frameworks using custom Promise impls
-    return value !== null && value !== undefined && typeof value.then === 'function';
-}
-function isErrorSnapshot(snapshot) {
-    return snapshot.state === 'Error';
+function isPromise(value) {
+    // check for Thenable due to test frameworks using custom Promise impls
+    return value !== null && value !== undefined && typeof value.then === 'function';
+}
+function isErrorSnapshot(snapshot) {
+    return snapshot.state === 'Error';
 }
 
-function runAdapterWithReport(adapterName, adapter, adapterConfig, requestContext, onAdapterComplete) {
-    let adapterStart;
-    let adapterEnd;
-    let lookupStart;
-    let lookupEnd;
-    let cacheStart;
-    let cacheEnd;
-    let networkStart;
-    let networkEnd;
-    let staleLookup = false;
-    let result;
-    let snapshotState = '';
-    let error;
-    let exceptionMessage;
-    let completedNetworkRequests = [];
-    let collectedNetworkStartEvents = {};
-    let reviveStats = [];
-    let rawEvents = [];
-    const markEnd = (adapterEndedCallback) => {
-        if (adapterStart === undefined) {
-            throw Error('adapter has not been started yet');
-        }
-        if (adapterEnd) {
-            throw Error('adapter has already ended');
-        }
-        if (result === undefined) {
-            throw Error('no result type set');
-        }
-        adapterEnd = Date.now();
-        const executionTime = adapterEnd - adapterStart;
-        const cacheLookupTime = cacheEnd - cacheStart;
-        const lookupTime = lookupEnd - lookupStart;
-        const networkLookupTime = networkEnd - networkStart;
-        const config = stringify(adapterConfig);
-        switch (result) {
-            case 'l1-hit':
-                if (staleLookup === true) {
-                    adapterEndedCallback({
-                        result: 'l1-hit',
-                        adapterName,
-                        rawEvents,
-                        config,
-                        stale: true,
-                        executionTime,
-                        cacheLookupTime,
-                        lookupTime,
-                        snapshotState,
-                    });
-                }
-                else {
-                    adapterEndedCallback({
-                        result: 'l1-hit',
-                        adapterName,
-                        rawEvents,
-                        config,
-                        stale: false,
-                        executionTime,
-                        cacheLookupTime,
-                        lookupTime,
-                        snapshotState,
-                    });
-                }
-                break;
-            case 'l2-hit':
-                if (staleLookup === true) {
-                    adapterEndedCallback({
-                        result: 'l2-hit',
-                        adapterName,
-                        rawEvents,
-                        config,
-                        stale: true,
-                        executionTime,
-                        cacheLookupTime,
-                        lookupTime,
-                        snapshotState,
-                        revives: reviveStats,
-                    });
-                }
-                else {
-                    adapterEndedCallback({
-                        result: 'l2-hit',
-                        adapterName,
-                        rawEvents,
-                        config,
-                        stale: false,
-                        executionTime,
-                        cacheLookupTime,
-                        lookupTime,
-                        snapshotState,
-                        revives: reviveStats,
-                    });
-                }
-                break;
-            case 'cache-miss':
-                adapterEndedCallback({
-                    result: 'cache-miss',
-                    adapterName,
-                    rawEvents,
-                    config,
-                    executionTime,
-                    cacheLookupTime,
-                    lookupTime,
-                    networkLookupTime,
-                    completedNetworkRequests,
-                    snapshotState,
-                    revives: reviveStats,
-                });
-                break;
-            case 'invalid-config':
-                adapterEndedCallback({
-                    result: 'invalid-config',
-                    rawEvents,
-                    config,
-                    adapterName,
-                    executionTime,
-                });
-                break;
-            case 'error':
-                adapterEndedCallback({
-                    result: 'error',
-                    rawEvents,
-                    config,
-                    error,
-                    adapterName,
-                    executionTime,
-                    cacheLookupTime,
-                    lookupTime,
-                    networkLookupTime,
-                    snapshotState,
-                });
-                break;
-            case 'exception':
-                adapterEndedCallback({
-                    result: 'exception',
-                    rawEvents,
-                    config,
-                    exceptionMessage,
-                    adapterName,
-                    executionTime,
-                });
-                break;
-        }
-    };
-    const markException = (error) => {
-        let message = 'Unknown Error';
-        if (error instanceof Error)
-            message = error.message;
-        exceptionMessage = message;
-        result = 'exception';
-    };
-    const metricsEventObserver = {
-        onAdapterEvent: (ev) => {
-            rawEvents.push(ev);
-            switch (ev.type) {
-                case 'adapter-lookup-start':
-                    lookupStart = Date.now();
-                    break;
-                case 'adapter-lookup-end':
-                    lookupEnd = Date.now();
-                    break;
-                case 'cache-lookup-start':
-                    cacheStart = Date.now();
-                    break;
-                case 'cache-lookup-end':
-                    cacheEnd = Date.now();
-                    if (ev.wasResultAsync === false) {
-                        // L1 cache hit
-                        result = 'l1-hit';
-                    }
-                    else {
-                        // L2 cache hit
-                        result = 'l2-hit';
-                    }
-                    if (ev.snapshotState === 'Stale') {
-                        staleLookup = true;
-                    }
-                    break;
-                case 'network-lookup-start':
-                    // if the lookup is stale, the network lookup is
-                    // caused by an async refresh
-                    if (staleLookup === false) {
-                        result = 'cache-miss';
-                        networkStart = Date.now();
-                    }
-                    break;
-                case 'network-lookup-end':
-                    if (staleLookup === false) {
-                        networkEnd = Date.now();
-                    }
-                    break;
-                case 'network-request-start':
-                    collectedNetworkStartEvents[ev.uuid] = ev;
-                    break;
-                case 'network-request-end': {
-                    const startEvent = collectedNetworkStartEvents[ev.uuid];
-                    if (startEvent === undefined || startEvent.type !== 'network-request-start') {
-                        if (process.env.NODE_ENV !== 'production') {
-                            throw Error('no matching network start event emmited');
-                        }
-                        return;
-                    }
-                    completedNetworkRequests.push({
-                        request: startEvent.request,
-                        response: ev.response,
-                        duration: ev.timestamp - startEvent.timestamp,
-                    });
-                    break;
-                }
-            }
-        },
-        onEnvironmentEvent: (ev) => {
-            rawEvents.push(ev);
-            if (isDurableEnvironmentEvent(ev)) {
-                if (ev.data.type === 'l2-revive-end') {
-                    let missingKeys;
-                    const snapshot = ev.data.snapshot;
-                    if (snapshot.state === 'Unfulfilled') {
-                        missingKeys = snapshot.missingLinks.keysAsArray();
-                        if (snapshot.missingLinks.size() === 0) {
-                            missingKeys.push(snapshot.recordId);
-                        }
-                    }
-                    reviveStats.push({
-                        resultState: ev.data.snapshot.state,
-                        missingKeys,
-                        l2Trips: ev.data.l2Trips,
-                        duration: ev.data.duration,
-                    });
-                }
-            }
-        },
-        onCustomAdapterEvent: (ev) => {
-            rawEvents.push(ev);
-        },
-    };
-    const bindObserverToAdapterRequestContext = (requestContext) => {
-        let requestContextWithInstrumentationObserver = requestContext;
-        if (requestContextWithInstrumentationObserver === undefined) {
-            requestContextWithInstrumentationObserver = { eventObservers: [] };
-        }
-        if (requestContextWithInstrumentationObserver.eventObservers === undefined) {
-            requestContextWithInstrumentationObserver.eventObservers = [];
-        }
-        requestContextWithInstrumentationObserver.eventObservers.push(metricsEventObserver);
-    };
-    adapterStart = Date.now();
-    try {
-        bindObserverToAdapterRequestContext(requestContext);
-        const adapterResult = adapter(adapterConfig, requestContext);
-        if (isPromise(adapterResult)) {
-            adapterResult
-                .then((snapshot) => {
-                snapshotState = snapshot.state;
-                if (isErrorSnapshot(snapshot)) {
-                    result = 'error';
-                    error = stringify(snapshot.error);
-                }
-                markEnd(onAdapterComplete);
-            })
-                .catch((e) => {
-                // async error
-                markException(e);
-                markEnd(onAdapterComplete);
-            });
-        }
-        else {
-            if (adapterResult === null) {
-                // invalid config
-                result = 'invalid-config';
-            }
-            else if (isErrorSnapshot(adapterResult)) {
-                snapshotState = 'Error';
-                result = 'error';
-                error = stringify(adapterResult.error);
-            }
-            markEnd(onAdapterComplete);
-        }
-        return adapterResult;
-    }
-    catch (error) {
-        // synchronous error (lookup exception)
-        markException(error);
-        markEnd(onAdapterComplete);
-        throw error;
-    }
+function runAdapterWithReport(adapterName, adapter, adapterConfig, requestContext, onAdapterComplete) {
+    let adapterStart;
+    let adapterEnd;
+    let lookupStart;
+    let lookupEnd;
+    let cacheStart;
+    let cacheEnd;
+    let networkStart;
+    let networkEnd;
+    let staleLookup = false;
+    let result;
+    let snapshotState = '';
+    let error;
+    let exceptionMessage;
+    let completedNetworkRequests = [];
+    let collectedNetworkStartEvents = {};
+    let reviveStats = [];
+    let rawEvents = [];
+    const markEnd = (adapterEndedCallback) => {
+        if (adapterStart === undefined) {
+            throw Error('adapter has not been started yet');
+        }
+        if (adapterEnd) {
+            throw Error('adapter has already ended');
+        }
+        if (result === undefined) {
+            throw Error('no result type set');
+        }
+        adapterEnd = Date.now();
+        const executionTime = adapterEnd - adapterStart;
+        const cacheLookupTime = cacheEnd - cacheStart;
+        const lookupTime = lookupEnd - lookupStart;
+        const networkLookupTime = networkEnd - networkStart;
+        const config = stringify(adapterConfig);
+        switch (result) {
+            case 'l1-hit':
+                if (staleLookup === true) {
+                    adapterEndedCallback({
+                        result: 'l1-hit',
+                        adapterName,
+                        rawEvents,
+                        config,
+                        stale: true,
+                        executionTime,
+                        cacheLookupTime,
+                        lookupTime,
+                        snapshotState,
+                    });
+                }
+                else {
+                    adapterEndedCallback({
+                        result: 'l1-hit',
+                        adapterName,
+                        rawEvents,
+                        config,
+                        stale: false,
+                        executionTime,
+                        cacheLookupTime,
+                        lookupTime,
+                        snapshotState,
+                    });
+                }
+                break;
+            case 'l2-hit':
+                if (staleLookup === true) {
+                    adapterEndedCallback({
+                        result: 'l2-hit',
+                        adapterName,
+                        rawEvents,
+                        config,
+                        stale: true,
+                        executionTime,
+                        cacheLookupTime,
+                        lookupTime,
+                        snapshotState,
+                        revives: reviveStats,
+                    });
+                }
+                else {
+                    adapterEndedCallback({
+                        result: 'l2-hit',
+                        adapterName,
+                        rawEvents,
+                        config,
+                        stale: false,
+                        executionTime,
+                        cacheLookupTime,
+                        lookupTime,
+                        snapshotState,
+                        revives: reviveStats,
+                    });
+                }
+                break;
+            case 'cache-miss':
+                adapterEndedCallback({
+                    result: 'cache-miss',
+                    adapterName,
+                    rawEvents,
+                    config,
+                    executionTime,
+                    cacheLookupTime,
+                    lookupTime,
+                    networkLookupTime,
+                    completedNetworkRequests,
+                    snapshotState,
+                    revives: reviveStats,
+                });
+                break;
+            case 'invalid-config':
+                adapterEndedCallback({
+                    result: 'invalid-config',
+                    rawEvents,
+                    config,
+                    adapterName,
+                    executionTime,
+                });
+                break;
+            case 'error':
+                adapterEndedCallback({
+                    result: 'error',
+                    rawEvents,
+                    config,
+                    error,
+                    adapterName,
+                    executionTime,
+                    cacheLookupTime,
+                    lookupTime,
+                    networkLookupTime,
+                    snapshotState,
+                });
+                break;
+            case 'exception':
+                adapterEndedCallback({
+                    result: 'exception',
+                    rawEvents,
+                    config,
+                    exceptionMessage,
+                    adapterName,
+                    executionTime,
+                });
+                break;
+        }
+    };
+    const markException = (error) => {
+        let message = 'Unknown Error';
+        if (error instanceof Error)
+            message = error.message;
+        exceptionMessage = message;
+        result = 'exception';
+    };
+    const metricsEventObserver = {
+        onAdapterEvent: (ev) => {
+            rawEvents.push(ev);
+            switch (ev.type) {
+                case 'adapter-lookup-start':
+                    lookupStart = Date.now();
+                    break;
+                case 'adapter-lookup-end':
+                    lookupEnd = Date.now();
+                    break;
+                case 'cache-lookup-start':
+                    cacheStart = Date.now();
+                    break;
+                case 'cache-lookup-end':
+                    cacheEnd = Date.now();
+                    if (ev.wasResultAsync === false) {
+                        // L1 cache hit
+                        result = 'l1-hit';
+                    }
+                    else {
+                        // L2 cache hit
+                        result = 'l2-hit';
+                    }
+                    if (ev.snapshotState === 'Stale') {
+                        staleLookup = true;
+                    }
+                    break;
+                case 'network-lookup-start':
+                    // if the lookup is stale, the network lookup is
+                    // caused by an async refresh
+                    if (staleLookup === false) {
+                        result = 'cache-miss';
+                        networkStart = Date.now();
+                    }
+                    break;
+                case 'network-lookup-end':
+                    if (staleLookup === false) {
+                        networkEnd = Date.now();
+                    }
+                    break;
+                case 'network-request-start':
+                    collectedNetworkStartEvents[ev.uuid] = ev;
+                    break;
+                case 'network-request-end': {
+                    const startEvent = collectedNetworkStartEvents[ev.uuid];
+                    if (startEvent === undefined || startEvent.type !== 'network-request-start') {
+                        if (process.env.NODE_ENV !== 'production') {
+                            throw Error('no matching network start event emmited');
+                        }
+                        return;
+                    }
+                    completedNetworkRequests.push({
+                        request: startEvent.request,
+                        response: ev.response,
+                        duration: ev.timestamp - startEvent.timestamp,
+                    });
+                    break;
+                }
+            }
+        },
+        onEnvironmentEvent: (ev) => {
+            rawEvents.push(ev);
+            if (isDurableEnvironmentEvent(ev)) {
+                if (ev.data.type === 'l2-revive-end') {
+                    let missingKeys;
+                    const snapshot = ev.data.snapshot;
+                    if (snapshot.state === 'Unfulfilled') {
+                        missingKeys = snapshot.missingLinks.keysAsArray();
+                        if (snapshot.missingLinks.size() === 0) {
+                            missingKeys.push(snapshot.recordId);
+                        }
+                    }
+                    reviveStats.push({
+                        resultState: ev.data.snapshot.state,
+                        missingKeys,
+                        l2Trips: ev.data.l2Trips,
+                        duration: ev.data.duration,
+                    });
+                }
+            }
+        },
+        onCustomAdapterEvent: (ev) => {
+            rawEvents.push(ev);
+        },
+    };
+    const bindObserverToAdapterRequestContext = (requestContext) => {
+        let requestContextWithInstrumentationObserver = requestContext;
+        if (requestContextWithInstrumentationObserver === undefined) {
+            requestContextWithInstrumentationObserver = { eventObservers: [] };
+        }
+        if (requestContextWithInstrumentationObserver.eventObservers === undefined) {
+            requestContextWithInstrumentationObserver.eventObservers = [];
+        }
+        requestContextWithInstrumentationObserver.eventObservers.push(metricsEventObserver);
+    };
+    adapterStart = Date.now();
+    try {
+        bindObserverToAdapterRequestContext(requestContext);
+        const adapterResult = adapter(adapterConfig, requestContext);
+        if (isPromise(adapterResult)) {
+            adapterResult
+                .then((snapshot) => {
+                snapshotState = snapshot.state;
+                if (isErrorSnapshot(snapshot)) {
+                    result = 'error';
+                    error = stringify(snapshot.error);
+                }
+                markEnd(onAdapterComplete);
+            })
+                .catch((e) => {
+                // async error
+                markException(e);
+                markEnd(onAdapterComplete);
+            });
+        }
+        else {
+            if (adapterResult === null) {
+                // invalid config
+                result = 'invalid-config';
+            }
+            else if (isErrorSnapshot(adapterResult)) {
+                snapshotState = 'Error';
+                result = 'error';
+                error = stringify(adapterResult.error);
+            }
+            markEnd(onAdapterComplete);
+        }
+        return adapterResult;
+    }
+    catch (error) {
+        // synchronous error (lookup exception)
+        markException(error);
+        markEnd(onAdapterComplete);
+        throw error;
+    }
 }
 
-/* Ideally we would use AbortController but it does not exist in V8, this is a simplified version */
-class LdsAbortController {
-    constructor() {
-        this._aborted = false;
-        this.listeners = new Set();
-    }
-    get aborted() {
-        return this._aborted;
-    }
-    addEventListener(listener) {
-        this.listeners.add(listener);
-    }
-    removeEventListener(listener) {
-        this.listeners.delete(listener);
-    }
-    abort() {
-        if (!this.aborted) {
-            this._aborted = true;
-            for (const listener of this.listeners) {
-                listener();
-            }
-        }
-    }
+/* Ideally we would use AbortController but it does not exist in V8, this is a simplified version */
+class LdsAbortController {
+    constructor() {
+        this._aborted = false;
+        this.listeners = new Set();
+    }
+    get aborted() {
+        return this._aborted;
+    }
+    addEventListener(listener) {
+        this.listeners.add(listener);
+    }
+    removeEventListener(listener) {
+        this.listeners.delete(listener);
+    }
+    abort() {
+        if (!this.aborted) {
+            this._aborted = true;
+            for (const listener of this.listeners) {
+                listener();
+            }
+        }
+    }
 }
 
-class AsyncWorkerPool {
-    constructor(concurrency) {
-        this.queue = [];
-        this.activeWork = [];
-        this.concurrency = concurrency;
-    }
-    push(work) {
-        return new Promise((resolve, reject) => {
-            this.queue.push({
-                ...work,
-                workFn: (abortController) => work.workFn(abortController).then(resolve).catch(reject),
-            });
-            this.doWork();
-        });
-    }
-    /**
-     * cancel all work in the queue and active work
-     * @returns true if all work was cancelled, false if any work could not be cancelled
-     */
-    cancel() {
-        let success = true;
-        for (const { cancelFn } of this.queue) {
-            if (cancelFn) {
-                try {
-                    cancelFn();
-                }
-                catch (_a) {
-                    success = false;
-                }
-            }
-        }
-        this.queue = [];
-        for (const { abortController, cancelFn } of this.activeWork) {
-            abortController.abort();
-            if (cancelFn) {
-                try {
-                    cancelFn();
-                }
-                catch (_b) {
-                    success = false;
-                }
-            }
-        }
-        this.activeWork = [];
-        return success;
-    }
-    doWork() {
-        while (this.queue.length > 0 && this.activeWork.length < this.concurrency) {
-            const work = this.queue.shift();
-            if (work) {
-                const abortController = new LdsAbortController();
-                const newWork = { ...work, abortController };
-                this.activeWork.push(newWork);
-                const { workFn } = work;
-                workFn(abortController).finally(() => {
-                    this.activeWork = this.activeWork.filter((w) => w !== newWork);
-                    this.doWork();
-                });
-            }
-        }
-    }
+class AsyncWorkerPool {
+    constructor(concurrency) {
+        this.queue = [];
+        this.activeWork = [];
+        this.concurrency = concurrency;
+    }
+    push(work) {
+        return new Promise((resolve, reject) => {
+            this.queue.push({
+                ...work,
+                workFn: (abortController) => work.workFn(abortController).then(resolve).catch(reject),
+            });
+            this.doWork();
+        });
+    }
+    /**
+     * cancel all work in the queue and active work
+     * @returns true if all work was cancelled, false if any work could not be cancelled
+     */
+    cancel() {
+        let success = true;
+        for (const { cancelFn } of this.queue) {
+            if (cancelFn) {
+                try {
+                    cancelFn();
+                }
+                catch (_a) {
+                    success = false;
+                }
+            }
+        }
+        this.queue = [];
+        for (const { abortController, cancelFn } of this.activeWork) {
+            abortController.abort();
+            if (cancelFn) {
+                try {
+                    cancelFn();
+                }
+                catch (_b) {
+                    success = false;
+                }
+            }
+        }
+        this.activeWork = [];
+        return success;
+    }
+    doWork() {
+        while (this.queue.length > 0 && this.activeWork.length < this.concurrency) {
+            const work = this.queue.shift();
+            if (work) {
+                const abortController = new LdsAbortController();
+                const newWork = { ...work, abortController };
+                this.activeWork.push(newWork);
+                const { workFn } = work;
+                workFn(abortController).finally(() => {
+                    this.activeWork = this.activeWork.filter((w) => w !== newWork);
+                    this.doWork();
+                });
+            }
+        }
+    }
 }
 
 export { AsyncWorkerPool, LdsAbortController, runAdapterWithReport };

package/dist/{AdapterReport.d.ts → types/AdapterReport.d.ts}

@@ -1,71 +1,71 @@
-import type { LuvioAdapterEvent, NormalizedKeyMetadata, ResourceRequest } from '@luvio/engine';
-export type AdapterResultType = 'invalid-config' | 'l1-hit' | 'l2-hit' | 'cache-miss' | 'error' | 'exception';
-export type AdapterReport = L1CacheHitFresh | L1CacheHitStale | L2CacheHitFresh | L2CacheHitStale | CacheMiss | InvalidConfig | Error | Exception;
-interface ReportBase {
-    adapterName: string;
-    config: string;
-    executionTime: number;
-    snapshotState: string;
-    rawEvents: LuvioAdapterEvent[];
-}
-export interface CompletedNetworkRequest {
-    request: ResourceRequest;
-    response: unknown;
-    duration: number;
-}
-interface SuccessBase extends ReportBase {
-    lookupTime: number;
-    cacheLookupTime: number;
-}
-interface StaleBase {
-    stale: true;
-}
-export interface ReviveStats {
-    duration: number;
-    l2Trips: {
-        duration: number;
-        keysRequestedCount: number;
-    }[];
-    missingKeys: (string | NormalizedKeyMetadata)[] | undefined;
-    resultState: string;
-}
-interface L1CacheHitFresh extends SuccessBase {
-    result: 'l1-hit';
-    stale: false;
-}
-interface L1CacheHitStale extends SuccessBase, StaleBase {
-    result: 'l1-hit';
-}
-interface L2CacheHit extends SuccessBase {
-    result: 'l2-hit';
-    lookupTime: number;
-    revives: ReviveStats[];
-}
-interface L2CacheHitFresh extends L2CacheHit {
-    stale: false;
-    revives: ReviveStats[];
-}
-interface L2CacheHitStale extends L2CacheHit, StaleBase {
-}
-interface CacheMiss extends SuccessBase {
-    result: 'cache-miss';
-    lookupTime: number;
-    networkLookupTime: number;
-    completedNetworkRequests: CompletedNetworkRequest[];
-    revives: ReviveStats[];
-}
-interface Error extends ReportBase {
-    result: 'error';
-    error: unknown;
-    lookupTime: number;
-    cacheLookupTime?: number;
-    networkLookupTime?: number;
-}
-interface Exception extends Omit<ReportBase, 'snapshotState'> {
-    result: 'exception';
-    exceptionMessage: string;
-}
-interface InvalidConfig extends Omit<ReportBase, 'snapshotState'> {
-    result: 'invalid-config';
-}
-export {};
+import type { LuvioAdapterEvent, NormalizedKeyMetadata, ResourceRequest } from '@luvio/engine';
+export type AdapterResultType = 'invalid-config' | 'l1-hit' | 'l2-hit' | 'cache-miss' | 'error' | 'exception';
+export type AdapterReport = L1CacheHitFresh | L1CacheHitStale | L2CacheHitFresh | L2CacheHitStale | CacheMiss | InvalidConfig | Error | Exception;
+interface ReportBase {
+    adapterName: string;
+    config: string;
+    executionTime: number;
+    snapshotState: string;
+    rawEvents: LuvioAdapterEvent[];
+}
+export interface CompletedNetworkRequest {
+    request: ResourceRequest;
+    response: unknown;
+    duration: number;
+}
+interface SuccessBase extends ReportBase {
+    lookupTime: number;
+    cacheLookupTime: number;
+}
+interface StaleBase {
+    stale: true;
+}
+export interface ReviveStats {
+    duration: number;
+    l2Trips: {
+        duration: number;
+        keysRequestedCount: number;
+    }[];
+    missingKeys: (string | NormalizedKeyMetadata)[] | undefined;
+    resultState: string;
+}
+interface L1CacheHitFresh extends SuccessBase {
+    result: 'l1-hit';
+    stale: false;
+}
+interface L1CacheHitStale extends SuccessBase, StaleBase {
+    result: 'l1-hit';
+}
+interface L2CacheHit extends SuccessBase {
+    result: 'l2-hit';
+    lookupTime: number;
+    revives: ReviveStats[];
+}
+interface L2CacheHitFresh extends L2CacheHit {
+    stale: false;
+    revives: ReviveStats[];
+}
+interface L2CacheHitStale extends L2CacheHit, StaleBase {
+}
+interface CacheMiss extends SuccessBase {
+    result: 'cache-miss';
+    lookupTime: number;
+    networkLookupTime: number;
+    completedNetworkRequests: CompletedNetworkRequest[];
+    revives: ReviveStats[];
+}
+interface Error extends ReportBase {
+    result: 'error';
+    error: unknown;
+    lookupTime: number;
+    cacheLookupTime?: number;
+    networkLookupTime?: number;
+}
+interface Exception extends Omit<ReportBase, 'snapshotState'> {
+    result: 'exception';
+    exceptionMessage: string;
+}
+interface InvalidConfig extends Omit<ReportBase, 'snapshotState'> {
+    result: 'invalid-config';
+}
+export {};

package/dist/{AsyncWorkerPool.d.ts → types/AsyncWorkerPool.d.ts}

@@ -1,18 +1,18 @@
-import { LdsAbortController } from './LdsAbortController';
-export interface Work<T> {
-    workFn: (abortController: LdsAbortController) => Promise<T>;
-    cancelFn?: () => void;
-}
-export declare class AsyncWorkerPool {
-    private concurrency;
-    private queue;
-    private activeWork;
-    constructor(concurrency: number);
-    push<T>(work: Work<T>): Promise<T>;
-    /**
-     * cancel all work in the queue and active work
-     * @returns true if all work was cancelled, false if any work could not be cancelled
-     */
-    cancel(): boolean;
-    private doWork;
-}
+import { LdsAbortController } from './LdsAbortController';
+export interface Work<T> {
+    workFn: (abortController: LdsAbortController) => Promise<T>;
+    cancelFn?: () => void;
+}
+export declare class AsyncWorkerPool {
+    private concurrency;
+    private queue;
+    private activeWork;
+    constructor(concurrency: number);
+    push<T>(work: Work<T>): Promise<T>;
+    /**
+     * cancel all work in the queue and active work
+     * @returns true if all work was cancelled, false if any work could not be cancelled
+     */
+    cancel(): boolean;
+    private doWork;
+}

package/dist/{LdsAbortController.d.ts → types/LdsAbortController.d.ts}

@@ -1,10 +1,10 @@
-type EventListener = () => void;
-export declare class LdsAbortController {
-    private _aborted;
-    get aborted(): boolean;
-    private listeners;
-    addEventListener(listener: EventListener): void;
-    removeEventListener(listener: EventListener): void;
-    abort(): void;
-}
-export {};
+type EventListener = () => void;
+export declare class LdsAbortController {
+    private _aborted;
+    get aborted(): boolean;
+    private listeners;
+    addEventListener(listener: EventListener): void;
+    removeEventListener(listener: EventListener): void;
+    abort(): void;
+}
+export {};

package/dist/{language.d.ts → types/language.d.ts}

@@ -1,5 +1,5 @@
-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;
-};
-export { stringify as JSONStringify, };
+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;
+};
+export { stringify as JSONStringify, };

package/dist/{main.d.ts → types/main.d.ts}

@@ -1,4 +1,4 @@
-export { runAdapterWithReport } from './runAdapterWithReport';
-export { AdapterReport } from './AdapterReport';
-export { AsyncWorkerPool } from './AsyncWorkerPool';
-export { LdsAbortController } from './LdsAbortController';
+export { runAdapterWithReport } from './runAdapterWithReport';
+export { AdapterReport } from './AdapterReport';
+export { AsyncWorkerPool } from './AsyncWorkerPool';
+export { LdsAbortController } from './LdsAbortController';

package/dist/{runAdapterWithReport.d.ts → types/runAdapterWithReport.d.ts}

@@ -1,3 +1,3 @@
-import type { Adapter, AdapterRequestContext } from '@luvio/engine';
-import type { AdapterReport } from './AdapterReport';
-export declare function runAdapterWithReport<C, D>(adapterName: string, adapter: Adapter<C, D>, adapterConfig: C, requestContext: AdapterRequestContext, onAdapterComplete: (report: AdapterReport) => void): import("@luvio/engine").ErrorSnapshot | import("@luvio/engine").DataSnapshot<D, unknown> | Promise<import("@luvio/engine").ErrorSnapshot | import("@luvio/engine").FulfilledSnapshot<D, unknown> | import("@luvio/engine").UnfulfilledSnapshot<D, unknown> | import("@luvio/engine").StaleSnapshot<D, unknown> | import("@luvio/engine").PendingSnapshot<D, unknown>> | null;
+import type { Adapter, AdapterRequestContext } from '@luvio/engine';
+import type { AdapterReport } from './AdapterReport';
+export declare function runAdapterWithReport<C, D>(adapterName: string, adapter: Adapter<C, D>, adapterConfig: C, requestContext: AdapterRequestContext, onAdapterComplete: (report: AdapterReport) => void): import("@luvio/engine").ErrorSnapshot | import("@luvio/engine").DataSnapshot<D, unknown> | Promise<import("@luvio/engine").ErrorSnapshot | import("@luvio/engine").FulfilledSnapshot<D, unknown> | import("@luvio/engine").UnfulfilledSnapshot<D, unknown> | import("@luvio/engine").StaleSnapshot<D, unknown> | import("@luvio/engine").PendingSnapshot<D, unknown>> | null;

package/dist/{utils.d.ts → types/utils.d.ts}

@@ -1,3 +1,3 @@
-import type { Snapshot, ErrorSnapshot } from '@luvio/engine';
-export declare function isPromise<D>(value: D | Promise<D> | null): value is Promise<D>;
-export declare function isErrorSnapshot(snapshot: Snapshot<any>): snapshot is ErrorSnapshot;
+import type { Snapshot, ErrorSnapshot } from '@luvio/engine';
+export declare function isPromise<D>(value: D | Promise<D> | null): value is Promise<D>;
+export declare function isErrorSnapshot(snapshot: Snapshot<any>): snapshot is ErrorSnapshot;

package/package.json

@@ -1,18 +1,18 @@
 {
     "name": "@salesforce/lds-utils-adapters",
-    "version": "1.124.1",
+    "version": "1.124.3",
     "license": "SEE LICENSE IN LICENSE.txt",
     "description": "LDS Adapter Utilities",
     "main": "dist/ldsAdapterUtils.js",
     "module": "dist/ldsAdapterUtils.js",
-    "types": "dist/main.d.ts",
+    "types": "dist/types/main.d.ts",
     "files": [
         "dist"
     ],
     "exports": {
         ".": {
             "import": "./dist/ldsAdapterUtils.js",
-            "types": "./dist/main.d.ts",
+            "types": "./dist/types/main.d.ts",
             "default": "./dist/ldsAdapterUtils.js"
         }
     },