@dynamic-labs-sdk/client 1.33.2 → 1.33.4

package/dist/services/resilientIndexedDbStore/utils/createTombstoneStore/createTombstoneStore.d.ts

@@ -0,0 +1,61 @@
+import type { Storage } from '../../../storage/storage.types';
+type CreateTombstoneStoreParams = {
+    /** Name of the IndexedDB database the tombstones belong to. */
+    dbName: string;
+    /** Persists deletions that IndexedDB has not acknowledged. */
+    storage: Storage;
+    /** Name of the object store the tombstones belong to. */
+    storeName: string;
+};
+export type TombstoneStore = {
+    /**
+     * Records that a key must be deleted from IndexedDB and resolves once the
+     * record is durable. Rejects when storage cannot hold it, since the caller's
+     * deletion would not survive a reload.
+     */
+    add: (params: {
+        key: string;
+    }) => Promise<void>;
+    /** Keys whose deletion has not been confirmed by IndexedDB yet. */
+    list: () => Promise<string[]>;
+    /** Drops the record for a key whose deletion has landed and resolves once it is removed. */
+    remove: (params: {
+        key: string;
+    }) => Promise<void>;
+    /** Resolves once queued tombstone work has settled. */
+    waitUntilIdle: () => Promise<void>;
+};
+/**
+ * Durable record of deletions that IndexedDB has not acknowledged, held in
+ * the storage service so they outlive the page.
+ *
+ * Only deletions are persisted, and only as keys. A value may hold types that
+ * cannot be serialized, so a pending write has nothing to persist and degrades
+ * to the value being absent. A pending deletion, on the other hand, must
+ * outlive the page: a value the caller was told is gone would otherwise
+ * resurface in the next instance.
+ *
+ * @example
+ * ```ts
+ * const tombstones = createTombstoneStore({
+ *   dbName: 'dynamic_keychain',
+ *   storage,
+ *   storeName: 'keys',
+ * });
+ *
+ * tombstones.add({ key: 'session' });
+ * await tombstones.list(); // ['session']
+ * tombstones.remove({ key: 'session' });
+ * ```
+ *
+ * @param params.dbName - Name of the IndexedDB database the tombstones belong to.
+ * @param params.storage - Persists deletions that IndexedDB has not acknowledged.
+ * @param params.storeName - Name of the object store the tombstones belong to.
+ * @returns A store for reading and updating pending deletions.
+ * @see createWorkQueue
+ * @see createResilientIndexedDbStore
+ * @notInstrumented
+ */
+export declare const createTombstoneStore: ({ dbName, storage, storeName, }: CreateTombstoneStoreParams) => TombstoneStore;
+export {};
+//# sourceMappingURL=createTombstoneStore.d.ts.map

package/dist/services/resilientIndexedDbStore/utils/createTombstoneStore/createTombstoneStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createTombstoneStore.d.ts","sourceRoot":"","sources":["../../../../../src/services/resilientIndexedDbStore/utils/createTombstoneStore/createTombstoneStore.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gCAAgC,CAAC;AAE9D,KAAK,0BAA0B,GAAG;IAChC,+DAA+D;IAC/D,MAAM,EAAE,MAAM,CAAC;IAEf,8DAA8D;IAC9D,OAAO,EAAE,OAAO,CAAC;IAEjB,yDAAyD;IACzD,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B;;;;OAIG;IACH,GAAG,EAAE,CAAC,MAAM,EAAE;QAAE,GAAG,EAAE,MAAM,CAAA;KAAE,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAEhD,mEAAmE;IACnE,IAAI,EAAE,MAAM,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IAE9B,4FAA4F;IAC5F,MAAM,EAAE,CAAC,MAAM,EAAE;QAAE,GAAG,EAAE,MAAM,CAAA;KAAE,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAEnD,uDAAuD;IACvD,aAAa,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CACpC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,eAAO,MAAM,oBAAoB,oCAI9B,0BAA0B,KAAG,cAsE/B,CAAC"}

package/dist/services/resilientIndexedDbStore/utils/createTombstoneStore/index.d.ts

@@ -0,0 +1,3 @@
+export { createTombstoneStore } from './createTombstoneStore';
+export type { TombstoneStore } from './createTombstoneStore';
+//# sourceMappingURL=index.d.ts.map

package/dist/services/resilientIndexedDbStore/utils/createTombstoneStore/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/services/resilientIndexedDbStore/utils/createTombstoneStore/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAC9D,YAAY,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC"}

package/dist/services/resilientIndexedDbStore/utils/createWorkQueue/createWorkQueue.d.ts

@@ -0,0 +1,60 @@
+import type { Logger } from '../../../logger';
+import type { StoreDatabaseConfig, StoreMutation } from '../../resilientIndexedDbStore.types';
+import type { TombstoneStore } from '../createTombstoneStore';
+type CreateWorkQueueParams = {
+    /** Where the store keeps its records. */
+    database: StoreDatabaseConfig;
+    /** Reports degraded storage. The queue works without it. */
+    logger?: Logger;
+    /** Durable record of deletions that IndexedDB has not acknowledged. */
+    tombstones: TombstoneStore;
+};
+export type WorkQueue<TValue> = {
+    /**
+     * Registers a mutation and wakes the worker, which writes it to IndexedDB in
+     * the background. Resolves once a deletion is durably recorded, and rejects
+     * when it cannot be, since the caller would otherwise be told of a deletion
+     * that a reload undoes.
+     */
+    enqueue: (params: {
+        mutation: StoreMutation<TValue>;
+    }) => Promise<void>;
+    /** The mutation still waiting to be written for a key, if any. */
+    getPending: (params: {
+        key: string;
+    }) => StoreMutation<TValue> | undefined;
+    /** Resolves once queued mutations and tombstones settle. */
+    waitUntilIdle: () => Promise<void>;
+};
+/**
+ * Queue of pending mutations drained by one worker, retrying on backoff until
+ * each mutation lands in IndexedDB.
+ *
+ * Callers never wait on IndexedDB: a mutation is acknowledged as soon as it is
+ * queued, which keeps an interaction alive through transient connection
+ * closures mobile WebKit performs under memory pressure. At most one mutation
+ * is pending per key, since only the final state of a key is observable.
+ *
+ * Work IndexedDB rejects on its input is given up on instead of retried, since
+ * no amount of retrying makes that input valid and the caller would otherwise
+ * wait on it forever.
+ *
+ * @example
+ * ```ts
+ * const queue = createWorkQueue<StoredKey>({ database, tombstones });
+ *
+ * queue.enqueue({ mutation: { key: 'session', type: 'set', value } });
+ * queue.getPending({ key: 'session' });
+ * ```
+ *
+ * @param params.database - Where the store keeps its records.
+ * @param params.logger - Reports degraded storage.
+ * @param params.tombstones - Durable record of unacknowledged deletions.
+ * @returns The queue used to register and inspect pending mutations.
+ * @see createTombstoneStore
+ * @see applyMutation
+ * @notInstrumented
+ */
+export declare const createWorkQueue: <TValue>({ database, logger, tombstones, }: CreateWorkQueueParams) => WorkQueue<TValue>;
+export {};
+//# sourceMappingURL=createWorkQueue.d.ts.map

package/dist/services/resilientIndexedDbStore/utils/createWorkQueue/createWorkQueue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createWorkQueue.d.ts","sourceRoot":"","sources":["../../../../../src/services/resilientIndexedDbStore/utils/createWorkQueue/createWorkQueue.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAC9C,OAAO,KAAK,EACV,mBAAmB,EACnB,aAAa,EACd,MAAM,qCAAqC,CAAC;AAG7C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAO9D,KAAK,qBAAqB,GAAG;IAC3B,yCAAyC;IACzC,QAAQ,EAAE,mBAAmB,CAAC;IAE9B,4DAA4D;IAC5D,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB,uEAAuE;IACvE,UAAU,EAAE,cAAc,CAAC;CAC5B,CAAC;AAgBF,MAAM,MAAM,SAAS,CAAC,MAAM,IAAI;IAC9B;;;;;OAKG;IACH,OAAO,EAAE,CAAC,MAAM,EAAE;QAAE,QAAQ,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;KAAE,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAExE,kEAAkE;IAClE,UAAU,EAAE,CAAC,MAAM,EAAE;QAAE,GAAG,EAAE,MAAM,CAAA;KAAE,KAAK,aAAa,CAAC,MAAM,CAAC,GAAG,SAAS,CAAC;IAE3E,4DAA4D;IAC5D,aAAa,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CACpC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,eAAe,GAAI,MAAM,qCAInC,qBAAqB,KAAG,SAAS,CAAC,MAAM,CAqJ1C,CAAC"}

package/dist/services/resilientIndexedDbStore/utils/createWorkQueue/index.d.ts

@@ -0,0 +1,3 @@
+export { createWorkQueue } from './createWorkQueue';
+export type { WorkQueue } from './createWorkQueue';
+//# sourceMappingURL=index.d.ts.map

package/dist/services/resilientIndexedDbStore/utils/createWorkQueue/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/services/resilientIndexedDbStore/utils/createWorkQueue/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,YAAY,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/services/resilientIndexedDbStore/utils/deleteRecord/deleteRecord.d.ts

@@ -0,0 +1,35 @@
+type DeleteRecordParams = {
+    /** An open connection to the store's database. */
+    db: IDBDatabase;
+    /** Key of the record to delete. */
+    key: string;
+    /** Name of the object store to delete from. */
+    storeName: string;
+};
+/**
+ * Deletes a single record from an object store, resolving once the transaction
+ * commits.
+ *
+ * A successful request only means the deletion ran inside the transaction, and
+ * a transaction can still abort after that, so the caller learns the record is
+ * gone only once IndexedDB has committed it.
+ *
+ * @example
+ * ```ts
+ * await deleteRecord({ db, key: 'session', storeName: 'keys' });
+ * ```
+ *
+ * @param params.db - An open connection to the store's database.
+ * @param params.key - Key of the record to delete.
+ * @param params.storeName - Name of the object store to delete from.
+ * @returns A promise that resolves once the deletion is committed.
+ * @throws When IndexedDB rejects the deletion or the transaction does not
+ * commit.
+ * @see getTransactionError
+ * @see withDatabase
+ * @see applyMutation
+ * @notInstrumented
+ */
+export declare const deleteRecord: ({ db, key, storeName, }: DeleteRecordParams) => Promise<void>;
+export {};
+//# sourceMappingURL=deleteRecord.d.ts.map

package/dist/services/resilientIndexedDbStore/utils/deleteRecord/deleteRecord.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deleteRecord.d.ts","sourceRoot":"","sources":["../../../../../src/services/resilientIndexedDbStore/utils/deleteRecord/deleteRecord.ts"],"names":[],"mappings":"AAEA,KAAK,kBAAkB,GAAG;IACxB,kDAAkD;IAClD,EAAE,EAAE,WAAW,CAAC;IAEhB,mCAAmC;IACnC,GAAG,EAAE,MAAM,CAAC;IAEZ,+CAA+C;IAC/C,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,YAAY,4BAItB,kBAAkB,KAAG,OAAO,CAAC,IAAI,CAShC,CAAC"}

package/dist/services/resilientIndexedDbStore/utils/deleteRecord/index.d.ts

@@ -0,0 +1,2 @@
+export { deleteRecord } from './deleteRecord';
+//# sourceMappingURL=index.d.ts.map

package/dist/services/resilientIndexedDbStore/utils/deleteRecord/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/services/resilientIndexedDbStore/utils/deleteRecord/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/services/resilientIndexedDbStore/utils/getBackoffDelay/getBackoffDelay.d.ts

@@ -0,0 +1,22 @@
+type GetBackoffDelayParams = {
+    /** How many attempts have already failed. */
+    attempt: number;
+};
+/**
+ * Exponential backoff between IndexedDB attempts, capped so a caller waiting
+ * on a read never sits through a multi-second gap.
+ *
+ * @example
+ * ```ts
+ * await waitForDelay({ delayMs: getBackoffDelay({ attempt: 3 }) });
+ * ```
+ *
+ * @param params.attempt - How many attempts have already failed.
+ * @returns The delay in milliseconds to wait before the next attempt.
+ * @see waitForDelay
+ * @see readStoredValue
+ * @notInstrumented
+ */
+export declare const getBackoffDelay: ({ attempt }: GetBackoffDelayParams) => number;
+export {};
+//# sourceMappingURL=getBackoffDelay.d.ts.map

package/dist/services/resilientIndexedDbStore/utils/getBackoffDelay/getBackoffDelay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getBackoffDelay.d.ts","sourceRoot":"","sources":["../../../../../src/services/resilientIndexedDbStore/utils/getBackoffDelay/getBackoffDelay.ts"],"names":[],"mappings":"AAEA,KAAK,qBAAqB,GAAG;IAC3B,6CAA6C;IAC7C,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,eAAe,gBAAiB,qBAAqB,KAAG,MAIpE,CAAC"}

package/dist/services/resilientIndexedDbStore/utils/getBackoffDelay/index.d.ts

@@ -0,0 +1,2 @@
+export { getBackoffDelay } from './getBackoffDelay';
+//# sourceMappingURL=index.d.ts.map

package/dist/services/resilientIndexedDbStore/utils/getBackoffDelay/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/services/resilientIndexedDbStore/utils/getBackoffDelay/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/services/resilientIndexedDbStore/utils/getRecord/getRecord.d.ts

@@ -0,0 +1,32 @@
+type GetRecordParams = {
+    /** An open connection to the store's database. */
+    db: IDBDatabase;
+    /** Key of the record to read. */
+    key: string;
+    /** Name of the object store to read from. */
+    storeName: string;
+};
+/**
+ * Reads a single record from an object store.
+ *
+ * Values come back exactly as they were written, through structured clone, so
+ * types that cannot be serialized (such as a non-extractable `CryptoKey`)
+ * survive the round trip.
+ *
+ * @example
+ * ```ts
+ * const record = await getRecord<StoredKey>({ db, key: 'session', storeName: 'keys' });
+ * ```
+ *
+ * @param params.db - An open connection to the store's database.
+ * @param params.key - Key of the record to read.
+ * @param params.storeName - Name of the object store to read from.
+ * @returns The stored value, or undefined when the key has no record.
+ * @throws When IndexedDB rejects the read.
+ * @see withDatabase
+ * @see readStoredValue
+ * @notInstrumented
+ */
+export declare const getRecord: <TValue>({ db, key, storeName, }: GetRecordParams) => Promise<TValue | undefined>;
+export {};
+//# sourceMappingURL=getRecord.d.ts.map

package/dist/services/resilientIndexedDbStore/utils/getRecord/getRecord.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getRecord.d.ts","sourceRoot":"","sources":["../../../../../src/services/resilientIndexedDbStore/utils/getRecord/getRecord.ts"],"names":[],"mappings":"AAAA,KAAK,eAAe,GAAG;IACrB,kDAAkD;IAClD,EAAE,EAAE,WAAW,CAAC;IAEhB,iCAAiC;IACjC,GAAG,EAAE,MAAM,CAAC;IAEZ,6CAA6C;IAC7C,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,SAAS,GAAI,MAAM,2BAI7B,eAAe,KAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAQ3C,CAAC"}

package/dist/services/resilientIndexedDbStore/utils/getRecord/index.d.ts

@@ -0,0 +1,2 @@
+export { getRecord } from './getRecord';
+//# sourceMappingURL=index.d.ts.map

package/dist/services/resilientIndexedDbStore/utils/getRecord/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/services/resilientIndexedDbStore/utils/getRecord/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC"}

package/dist/services/resilientIndexedDbStore/utils/getRecordKey/getRecordKey.d.ts

@@ -0,0 +1,27 @@
+type GetRecordKeyParams<TValue> = {
+    /** Property of a value that holds its key. */
+    keyPath: string;
+    /** The value to read the key from. */
+    value: TValue;
+};
+/**
+ * The key IndexedDB stores a value under, read from the value itself.
+ *
+ * A value whose key path holds no string has no key to be stored under, so the
+ * caller learns that before IndexedDB rejects the write.
+ *
+ * @example
+ * ```ts
+ * const key = getRecordKey({ keyPath: 'keyName', value: storedKey });
+ * ```
+ *
+ * @param params.keyPath - Property of a value that holds its key.
+ * @param params.value - The value to read the key from.
+ * @returns The key, or undefined when the key path holds no string.
+ * @see createResilientIndexedDbStore
+ * @see putRecord
+ * @notInstrumented
+ */
+export declare const getRecordKey: <TValue>({ keyPath, value, }: GetRecordKeyParams<TValue>) => string | undefined;
+export {};
+//# sourceMappingURL=getRecordKey.d.ts.map

package/dist/services/resilientIndexedDbStore/utils/getRecordKey/getRecordKey.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getRecordKey.d.ts","sourceRoot":"","sources":["../../../../../src/services/resilientIndexedDbStore/utils/getRecordKey/getRecordKey.ts"],"names":[],"mappings":"AAAA,KAAK,kBAAkB,CAAC,MAAM,IAAI;IAChC,8CAA8C;IAC9C,OAAO,EAAE,MAAM,CAAC;IAEhB,sCAAsC;IACtC,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,YAAY,GAAI,MAAM,uBAGhC,kBAAkB,CAAC,MAAM,CAAC,KAAG,MAAM,GAAG,SAcxC,CAAC"}

package/dist/services/resilientIndexedDbStore/utils/getRecordKey/index.d.ts

@@ -0,0 +1,2 @@
+export { getRecordKey } from './getRecordKey';
+//# sourceMappingURL=index.d.ts.map

package/dist/services/resilientIndexedDbStore/utils/getRecordKey/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/services/resilientIndexedDbStore/utils/getRecordKey/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/services/resilientIndexedDbStore/utils/getTransactionError/getTransactionError.d.ts

@@ -0,0 +1,28 @@
+type GetTransactionErrorParams = {
+    /** The request that ran inside the transaction. */
+    request: IDBRequest;
+    /** The transaction that failed or was aborted. */
+    transaction: IDBTransaction;
+};
+/**
+ * The reason a write transaction did not commit.
+ *
+ * A transaction aborted by the browser rather than by a failing request, as
+ * happens when a connection closes mid-transaction, carries no error on either
+ * object, so the caller still gets something to log and retry on.
+ *
+ * @example
+ * ```ts
+ * transaction.onabort = () => reject(getTransactionError({ request, transaction }));
+ * ```
+ *
+ * @param params.request - The request that ran inside the transaction.
+ * @param params.transaction - The transaction that failed or was aborted.
+ * @returns The error to reject the write with.
+ * @see putRecord
+ * @see deleteRecord
+ * @notInstrumented
+ */
+export declare const getTransactionError: ({ request, transaction, }: GetTransactionErrorParams) => Error;
+export {};
+//# sourceMappingURL=getTransactionError.d.ts.map

package/dist/services/resilientIndexedDbStore/utils/getTransactionError/getTransactionError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getTransactionError.d.ts","sourceRoot":"","sources":["../../../../../src/services/resilientIndexedDbStore/utils/getTransactionError/getTransactionError.ts"],"names":[],"mappings":"AAEA,KAAK,yBAAyB,GAAG;IAC/B,mDAAmD;IACnD,OAAO,EAAE,UAAU,CAAC;IAEpB,kDAAkD;IAClD,WAAW,EAAE,cAAc,CAAC;CAC7B,CAAC;AAEF;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,mBAAmB,8BAG7B,yBAAyB,KAAG,KAQ9B,CAAC"}

package/dist/services/resilientIndexedDbStore/utils/getTransactionError/index.d.ts

@@ -0,0 +1,2 @@
+export { getTransactionError } from './getTransactionError';
+//# sourceMappingURL=index.d.ts.map

package/dist/services/resilientIndexedDbStore/utils/getTransactionError/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/services/resilientIndexedDbStore/utils/getTransactionError/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/services/resilientIndexedDbStore/utils/isPermanentWriteError/index.d.ts

@@ -0,0 +1,2 @@
+export { isPermanentWriteError } from './isPermanentWriteError';
+//# sourceMappingURL=index.d.ts.map

package/dist/services/resilientIndexedDbStore/utils/isPermanentWriteError/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/services/resilientIndexedDbStore/utils/isPermanentWriteError/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC"}

package/dist/services/resilientIndexedDbStore/utils/isPermanentWriteError/isPermanentWriteError.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Whether IndexedDB rejected a write because of what it was asked to write,
+ * which tells a retrying caller to give the write up instead of repeating it
+ * for as long as the process lives.
+ *
+ * @example
+ * ```ts
+ * if (isPermanentWriteError(error)) {
+ *   logger?.debug('Dropping a mutation IndexedDB will never accept', error);
+ * }
+ * ```
+ *
+ * @param error - Whatever the write rejected with.
+ * @returns Whether repeating the write is pointless.
+ * @see createWorkQueue
+ * @see applyMutation
+ * @notInstrumented
+ */
+export declare const isPermanentWriteError: (error: unknown) => boolean;
+//# sourceMappingURL=isPermanentWriteError.d.ts.map

package/dist/services/resilientIndexedDbStore/utils/isPermanentWriteError/isPermanentWriteError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isPermanentWriteError.d.ts","sourceRoot":"","sources":["../../../../../src/services/resilientIndexedDbStore/utils/isPermanentWriteError/isPermanentWriteError.ts"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,qBAAqB,UAAW,OAAO,KAAG,OACiB,CAAC"}

package/dist/services/resilientIndexedDbStore/utils/openDatabase/index.d.ts

@@ -0,0 +1,2 @@
+export { openDatabase } from './openDatabase';
+//# sourceMappingURL=index.d.ts.map

package/dist/services/resilientIndexedDbStore/utils/openDatabase/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/services/resilientIndexedDbStore/utils/openDatabase/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/services/resilientIndexedDbStore/utils/openDatabase/openDatabase.d.ts

@@ -0,0 +1,31 @@
+import type { StoreDatabaseConfig } from '../../resilientIndexedDbStore.types';
+type OpenDatabaseParams = {
+    /** Where the store keeps its records. */
+    database: StoreDatabaseConfig;
+};
+/**
+ * Opens the store's IndexedDB connection, recovering from a corrupted schema.
+ *
+ * If the database exists but is missing the expected object store (an upgrade
+ * interrupted by a reload on iOS WebKit leaves the database committed at its
+ * version with the store creation rolled back), it reopens at the next version
+ * so `onupgradeneeded` fires and recreates only the missing store. Stored data
+ * is preserved: the database is never deleted.
+ *
+ * @example
+ * ```ts
+ * const db = await openDatabase({
+ *   database: { dbName: 'dynamic_keychain', keyPath: 'keyName', storeName: 'keys' },
+ * });
+ * ```
+ *
+ * @param params.database - Where the store keeps its records.
+ * @returns An open connection whose object store is guaranteed to exist.
+ * @throws When IndexedDB refuses to open the database.
+ * @see withDatabase
+ * @see createResilientIndexedDbStore
+ * @notInstrumented
+ */
+export declare const openDatabase: ({ database, }: OpenDatabaseParams) => Promise<IDBDatabase>;
+export {};
+//# sourceMappingURL=openDatabase.d.ts.map

package/dist/services/resilientIndexedDbStore/utils/openDatabase/openDatabase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openDatabase.d.ts","sourceRoot":"","sources":["../../../../../src/services/resilientIndexedDbStore/utils/openDatabase/openDatabase.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAC;AAE/E,KAAK,kBAAkB,GAAG;IACxB,yCAAyC;IACzC,QAAQ,EAAE,mBAAmB,CAAC;CAC/B,CAAC;AAmCF;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,YAAY,kBAEtB,kBAAkB,KAAG,OAAO,CAAC,WAAW,CAe1C,CAAC"}

package/dist/services/resilientIndexedDbStore/utils/putRecord/index.d.ts

@@ -0,0 +1,2 @@
+export { putRecord } from './putRecord';
+//# sourceMappingURL=index.d.ts.map

package/dist/services/resilientIndexedDbStore/utils/putRecord/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/services/resilientIndexedDbStore/utils/putRecord/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC"}

package/dist/services/resilientIndexedDbStore/utils/putRecord/putRecord.d.ts

@@ -0,0 +1,37 @@
+type PutRecordParams<TValue> = {
+    /** An open connection to the store's database. */
+    db: IDBDatabase;
+    /** Name of the object store to write to. */
+    storeName: string;
+    /** The value to write. It carries its own key under the store's key path. */
+    value: TValue;
+};
+/**
+ * Writes a single record to an object store, resolving once the transaction
+ * commits.
+ *
+ * A successful request only means the write ran inside the transaction, and a
+ * transaction can still abort after that, so the caller learns the value is
+ * stored only once IndexedDB has committed it.
+ *
+ * The value is written as it is, through structured clone, so types that cannot
+ * be serialized (such as a non-extractable `CryptoKey`) survive the round trip.
+ *
+ * @example
+ * ```ts
+ * await putRecord({ db, storeName: 'keys', value: storedKey });
+ * ```
+ *
+ * @param params.db - An open connection to the store's database.
+ * @param params.storeName - Name of the object store to write to.
+ * @param params.value - The value to write.
+ * @returns A promise that resolves once the write is committed.
+ * @throws When IndexedDB rejects the write or the transaction does not commit.
+ * @see getTransactionError
+ * @see withDatabase
+ * @see applyMutation
+ * @notInstrumented
+ */
+export declare const putRecord: <TValue>({ db, storeName, value, }: PutRecordParams<TValue>) => Promise<void>;
+export {};
+//# sourceMappingURL=putRecord.d.ts.map

package/dist/services/resilientIndexedDbStore/utils/putRecord/putRecord.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"putRecord.d.ts","sourceRoot":"","sources":["../../../../../src/services/resilientIndexedDbStore/utils/putRecord/putRecord.ts"],"names":[],"mappings":"AAEA,KAAK,eAAe,CAAC,MAAM,IAAI;IAC7B,kDAAkD;IAClD,EAAE,EAAE,WAAW,CAAC;IAEhB,4CAA4C;IAC5C,SAAS,EAAE,MAAM,CAAC;IAElB,6EAA6E;IAC7E,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,SAAS,GAAI,MAAM,6BAI7B,eAAe,CAAC,MAAM,CAAC,KAAG,OAAO,CAAC,IAAI,CASrC,CAAC"}

package/dist/services/resilientIndexedDbStore/utils/readStoredValue/index.d.ts

@@ -0,0 +1,2 @@
+export { readStoredValue } from './readStoredValue';
+//# sourceMappingURL=index.d.ts.map

package/dist/services/resilientIndexedDbStore/utils/readStoredValue/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/services/resilientIndexedDbStore/utils/readStoredValue/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/services/resilientIndexedDbStore/utils/readStoredValue/readStoredValue.d.ts

@@ -0,0 +1,42 @@
+import type { StoreDatabaseConfig, StoreReadResult } from '../../resilientIndexedDbStore.types';
+type ReadStoredValueParams = {
+    /** Where the store keeps its records. */
+    database: StoreDatabaseConfig;
+    /** Key of the value to read. */
+    key: string;
+    /** How long the read may keep retrying before reporting unavailability. */
+    timeoutMs: number;
+};
+/**
+ * Reads a value from IndexedDB, retrying with backoff while the database is
+ * unusable and resolving deterministically once the timeout budget is spent.
+ *
+ * Each attempt is bounded by whatever is left of the budget, so an open the
+ * browser leaves blocked and a request it never settles both end the read
+ * within the budget instead of holding it forever.
+ *
+ * The caller is usually a user waiting on an interaction, so the result is
+ * always one of found, absent, or unavailable: never a hanging promise and
+ * never a thrown IndexedDB error.
+ *
+ * @example
+ * ```ts
+ * const result = await readStoredValue<StoredKey>({
+ *   database,
+ *   key: 'session',
+ *   timeoutMs: DEFAULT_READ_TIMEOUT_MS,
+ * });
+ * ```
+ *
+ * @param params.database - Where the store keeps its records.
+ * @param params.key - Key of the value to read.
+ * @param params.timeoutMs - How long the read may keep retrying.
+ * @returns Whether the value was found, is absent, or could not be read.
+ * @see createResilientIndexedDbStore
+ * @see getBackoffDelay
+ * @see runWithTimeout
+ * @notInstrumented
+ */
+export declare const readStoredValue: <TValue>({ database, key, timeoutMs, }: ReadStoredValueParams) => Promise<StoreReadResult<TValue>>;
+export {};
+//# sourceMappingURL=readStoredValue.d.ts.map

package/dist/services/resilientIndexedDbStore/utils/readStoredValue/readStoredValue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"readStoredValue.d.ts","sourceRoot":"","sources":["../../../../../src/services/resilientIndexedDbStore/utils/readStoredValue/readStoredValue.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,mBAAmB,EACnB,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAO7C,KAAK,qBAAqB,GAAG;IAC3B,yCAAyC;IACzC,QAAQ,EAAE,mBAAmB,CAAC;IAE9B,gCAAgC;IAChC,GAAG,EAAE,MAAM,CAAC;IAEZ,2EAA2E;IAC3E,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,eAAe,GAAU,MAAM,iCAIzC,qBAAqB,KAAG,OAAO,CAAC,eAAe,CAAC,MAAM,CAAC,CA+BzD,CAAC"}

package/dist/services/resilientIndexedDbStore/utils/replayTombstones/index.d.ts

@@ -0,0 +1,2 @@
+export { replayTombstones } from './replayTombstones';
+//# sourceMappingURL=index.d.ts.map

package/dist/services/resilientIndexedDbStore/utils/replayTombstones/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/services/resilientIndexedDbStore/utils/replayTombstones/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/services/resilientIndexedDbStore/utils/replayTombstones/replayTombstones.d.ts

@@ -0,0 +1,31 @@
+import type { Logger } from '../../../logger';
+import type { TombstoneStore } from '../createTombstoneStore';
+import type { WorkQueue } from '../createWorkQueue';
+type ReplayTombstonesParams<TValue> = {
+    /** Reports degraded storage. */
+    logger?: Logger;
+    /** Queue the deletions are registered with. */
+    queue: WorkQueue<TValue>;
+    /** Durable record of deletions that IndexedDB has not acknowledged. */
+    tombstones: TombstoneStore;
+};
+/**
+ * Re-queues the deletions an earlier instance recorded but IndexedDB never
+ * acknowledged, so a value the caller was told is gone cannot come back.
+ *
+ * @example
+ * ```ts
+ * await replayTombstones({ logger, queue, tombstones });
+ * ```
+ *
+ * @param params.logger - Reports degraded storage.
+ * @param params.queue - Queue the deletions are registered with.
+ * @param params.tombstones - Durable record of unacknowledged deletions.
+ * @returns A promise that resolves once the deletions are queued.
+ * @see createResilientIndexedDbStore
+ * @see createTombstoneStore
+ * @notInstrumented
+ */
+export declare const replayTombstones: <TValue>({ logger, queue, tombstones, }: ReplayTombstonesParams<TValue>) => Promise<void>;
+export {};
+//# sourceMappingURL=replayTombstones.d.ts.map

package/dist/services/resilientIndexedDbStore/utils/replayTombstones/replayTombstones.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"replayTombstones.d.ts","sourceRoot":"","sources":["../../../../../src/services/resilientIndexedDbStore/utils/replayTombstones/replayTombstones.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAC9C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAC9D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAEpD,KAAK,sBAAsB,CAAC,MAAM,IAAI;IACpC,gCAAgC;IAChC,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB,+CAA+C;IAC/C,KAAK,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;IAEzB,uEAAuE;IACvE,UAAU,EAAE,cAAc,CAAC;CAC5B,CAAC;AAEF;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,gBAAgB,GAAU,MAAM,kCAI1C,sBAAsB,CAAC,MAAM,CAAC,KAAG,OAAO,CAAC,IAAI,CAgB/C,CAAC"}

package/dist/services/resilientIndexedDbStore/utils/runWithTimeout/index.d.ts

@@ -0,0 +1,2 @@
+export { runWithTimeout } from './runWithTimeout';
+//# sourceMappingURL=index.d.ts.map

package/dist/services/resilientIndexedDbStore/utils/runWithTimeout/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/services/resilientIndexedDbStore/utils/runWithTimeout/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/services/resilientIndexedDbStore/utils/runWithTimeout/runWithTimeout.d.ts

@@ -0,0 +1,34 @@
+type RunWithTimeoutParams<TResult> = {
+    /** Runs when the budget is spent, to release what the operation acquired. */
+    onTimeout?: () => void;
+    /** Work that may never settle. */
+    operation: Promise<TResult>;
+    /** How long the operation may take before it is given up on. */
+    timeoutMs: number;
+};
+/**
+ * Bounds work that may never settle, which an IndexedDB request can do: an
+ * open blocked by another connection emits neither success nor error, and a
+ * request on a connection the browser closed can stay pending.
+ *
+ * @example
+ * ```ts
+ * const db = await runWithTimeout({
+ *   operation: openDatabase({ database }),
+ *   timeoutMs: DATABASE_OPERATION_TIMEOUT_MS,
+ * });
+ * ```
+ *
+ * @param params.onTimeout - Runs when the budget is spent.
+ * @param params.operation - Work that may never settle.
+ * @param params.timeoutMs - How long the operation may take.
+ * @returns Whatever the operation resolves with.
+ * @throws A `TimeoutError` `DOMException` once the budget is spent, or whatever
+ * the operation rejects with.
+ * @see withDatabase
+ * @see createWorkQueue
+ * @notInstrumented
+ */
+export declare const runWithTimeout: <TResult>({ onTimeout, operation, timeoutMs, }: RunWithTimeoutParams<TResult>) => Promise<TResult>;
+export {};
+//# sourceMappingURL=runWithTimeout.d.ts.map