@dynamic-labs-sdk/client 1.30.2 → 1.31.0

package/dist/utils/createSequenceQueue/createSequenceQueue.d.ts

@@ -0,0 +1,52 @@
+import type { DynamicClient } from '../../client/types';
+/** The queue function `createSequenceQueue` returns. */
+export type SequenceQueue = <T>(callback: () => Promise<T>, client: DynamicClient) => Promise<T>;
+/**
+ * Creates a queue function that runs every callback passed to it **one at a
+ * time, in FIFO order**, relative to every other call made through that same
+ * queue function for the same client:
+ *
+ * - Every queued call runs — this is NOT last-wins/coalescing (see
+ *   `debouncedMutex` for that behavior instead).
+ * - A callback that rejects does not stall the queue: the next queued
+ *   callback still runs.
+ * - Each caller receives its own callback's resolution or rejection,
+ *   independent of other callers' outcomes.
+ * - Different clients never block each other, even through the same queue
+ *   function.
+ *
+ * Useful for serializing read-modify-write cycles against a single piece of
+ * storage/state so concurrent callers can't race and silently lose an update.
+ *
+ * @example
+ * Without a queue, two concurrent callers incrementing a
+ * persisted counter can both read `0`, both write `1`, and lose an update:
+ * ```ts
+ * const incrementStoredCount = async (client: DynamicClient) => {
+ *   const current = await storage.get('count'); // both callers read 0
+ *   await storage.set('count', current + 1); // both callers write 1
+ * };
+ *
+ * await Promise.all([incrementStoredCount(client), incrementStoredCount(client)]);
+ * // storage.get('count') === 1, but two increments were requested
+ * ```
+ *
+ * Wrapping the same read-modify-write cycle in a queue forces the second
+ * call to wait for the first to finish, so it reads the value the first call
+ * just wrote:
+ * ```ts
+ * const queueCountWrite = createSequenceQueue();
+ *
+ * const incrementStoredCount = (client: DynamicClient) =>
+ *   queueCountWrite(async () => {
+ *     const current = await storage.get('count');
+ *     await storage.set('count', current + 1);
+ *   }, client);
+ *
+ * await Promise.all([incrementStoredCount(client), incrementStoredCount(client)]);
+ * // storage.get('count') === 2 — both increments are applied
+ * ```
+ * @notInstrumented
+ */
+export declare const createSequenceQueue: () => SequenceQueue;
+//# sourceMappingURL=createSequenceQueue.d.ts.map

package/dist/utils/createSequenceQueue/createSequenceQueue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createSequenceQueue.d.ts","sourceRoot":"","sources":["../../../src/utils/createSequenceQueue/createSequenceQueue.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAExD,wDAAwD;AACxD,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,EAC5B,QAAQ,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EAC1B,MAAM,EAAE,aAAa,KAClB,OAAO,CAAC,CAAC,CAAC,CAAC;AAEhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,eAAO,MAAM,mBAAmB,QAAO,aAkBtC,CAAC"}

package/dist/utils/createSequenceQueue/index.d.ts

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

package/dist/utils/createSequenceQueue/index.d.ts.map

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