applesauce-accounts 0.0.0-next-20250125174815 → 0.0.0-next-20250125183855

package/dist/account.d.ts

@@ -1,15 +1,15 @@
 import { Nip07Interface } from "applesauce-signer";
-import { EventTemplate, IAccount, SerializedAccount } from "./types.js";
 import { BehaviorSubject } from "rxjs";
 import { NostrEvent } from "nostr-tools";
+import { EventTemplate, IAccount, SerializedAccount } from "./types.js";
 export declare class SignerMismatchError extends Error {
 }
 export declare class BaseAccount<Signer extends Nip07Interface, SignerData, Metadata extends unknown> implements IAccount<Signer, SignerData, Metadata> {
     pubkey: string;
     signer: Signer;
     id: string;
-    /** Use a queue for sign and encryption/decryption requests so that there is only one request at a time */
-    queueRequests: boolean;
+    /** Disable request queueing */
+    disableQueue?: boolean;
     metadata$: BehaviorSubject<Metadata | undefined>;
     get metadata(): Metadata | undefined;
     set metadata(metadata: Metadata);
@@ -27,10 +27,12 @@ export declare class BaseAccount<Signer extends Nip07Interface, SignerData, Meta
     getPublicKey(): string | Promise<string>;
     /** sign the event and make sure its signed with the correct pubkey */
     signEvent(template: EventTemplate): Promise<NostrEvent> | NostrEvent;
-    /** Resets the request queue */
-    resetQueue(): void;
+    /** Aborts all pending requests in the queue */
+    abortQueue(reason: Error): void;
     /** internal queue */
     protected queueLength: number;
     protected lock: Promise<any> | null;
+    protected abort: AbortController | null;
+    protected reduceQueue(): void;
     protected waitForLock<T>(fn: () => Promise<T> | T): Promise<T> | T;
 }

package/dist/account.js

@@ -1,13 +1,34 @@
 import { nanoid } from "nanoid";
 import { BehaviorSubject } from "rxjs";
+function wrapInSignal(promise, signal) {
+    return new Promise((res, rej) => {
+        signal.throwIfAborted();
+        let done = false;
+        // reject promise if abort signal is triggered
+        signal.addEventListener("abort", () => {
+            if (!done)
+                rej(signal.reason || undefined);
+            done = true;
+        });
+        return promise.then((v) => {
+            if (!done)
+                res(v);
+            done = true;
+        }, (err) => {
+            if (!done)
+                rej(err);
+            done = true;
+        });
+    });
+}
 export class SignerMismatchError extends Error {
 }
 export class BaseAccount {
     pubkey;
     signer;
     id = nanoid(8);
-    /** Use a queue for sign and encryption/decryption requests so that there is only one request at a time */
-    queueRequests = true;
+    /** Disable request queueing */
+    disableQueue;
     metadata$ = new BehaviorSubject(undefined);
     get metadata() {
         return this.metadata$.value;
@@ -81,31 +102,37 @@ export class BaseAccount {
             }
         });
     }
-    /** Resets the request queue */
-    resetQueue() {
-        this.lock = null;
-        this.queueLength = 0;
+    /** Aborts all pending requests in the queue */
+    abortQueue(reason) {
+        if (this.abort)
+            this.abort.abort(reason);
     }
     /** internal queue */
     queueLength = 0;
     lock = null;
+    abort = null;
+    reduceQueue() {
+        // shorten the queue
+        this.queueLength--;
+        // if this was the last request, remove the lock
+        if (this.queueLength === 0) {
+            this.lock = null;
+            this.abort = null;
+        }
+    }
     waitForLock(fn) {
-        if (!this.queueRequests)
+        if (this.disableQueue)
             return fn();
         // if there is already a pending request, wait for it
-        if (this.lock) {
+        if (this.lock && this.abort) {
             // create a new promise that runs after the lock
-            const p = this.lock
-                .then(() => fn())
-                .finally(() => {
-                // shorten the queue
-                this.queueLength--;
-                // if this was the last request, remove the lock
-                if (this.queueLength === 0)
-                    this.lock = null;
-            });
-            // set the lock the new promise
-            this.lock = p;
+            const p = wrapInSignal(this.lock.then(() => {
+                // if the abort signal is triggered, don't call the signer
+                this.abort?.signal.throwIfAborted();
+                return fn();
+            }), this.abort.signal);
+            // set the lock the new promise that ignores errors
+            this.lock = p.catch(() => { }).finally(this.reduceQueue.bind(this));
             this.queueLength++;
             return p;
         }
@@ -113,7 +140,10 @@ export class BaseAccount {
             const result = fn();
             // if the result is async, set the new lock
             if (result instanceof Promise) {
-                this.lock = result;
+                this.abort = new AbortController();
+                const p = wrapInSignal(result, this.abort.signal);
+                // set the lock the new promise that ignores errors
+                this.lock = p.catch(() => { }).finally(this.reduceQueue.bind(this));
                 this.queueLength = 1;
             }
             return result;

package/dist/account.test.js

@@ -17,8 +17,8 @@ describe("BaseAccount", () => {
                 });
             });
             // make two signing requests
-            account.signEvent({ kind: 1, content: "first", created_at: 0, tags: [] });
-            account.signEvent({ kind: 1, content: "second", created_at: 0, tags: [] });
+            expect(account.signEvent({ kind: 1, content: "first", created_at: 0, tags: [] })).toEqual(expect.any(Promise));
+            expect(account.signEvent({ kind: 1, content: "second", created_at: 0, tags: [] })).toEqual(expect.any(Promise));
             expect(signer.signEvent).toHaveBeenCalledOnce();
             expect(signer.signEvent).toHaveBeenCalledWith(expect.objectContaining({ content: "first" }));
             // resolve first
@@ -29,10 +29,15 @@ describe("BaseAccount", () => {
             expect(signer.signEvent).toHaveBeenCalledWith(expect.objectContaining({ content: "second" }));
             // resolve second
             resolve.shift()?.();
+            // wait next tick
+            await new Promise((res) => setTimeout(res, 0));
+            expect(Reflect.get(account, "queueLength")).toBe(0);
+            expect(Reflect.get(account, "lock")).toBeNull();
         });
+        it("should cancel queue if request throws", () => { });
         it("should not use queueing if its disabled", async () => {
             const account = new BaseAccount(await signer.getPublicKey(), signer);
-            account.queueRequests = false;
+            account.disableQueue = false;
             let resolve = [];
             vi.spyOn(signer, "signEvent").mockImplementation(() => {
                 return new Promise((res) => {
@@ -42,14 +47,12 @@ describe("BaseAccount", () => {
             // make two signing requests
             account.signEvent({ kind: 1, content: "first", created_at: 0, tags: [] });
             account.signEvent({ kind: 1, content: "second", created_at: 0, tags: [] });
+            expect(Reflect.get(account, "lock")).toBeNull();
             expect(signer.signEvent).toHaveBeenCalledTimes(2);
             expect(signer.signEvent).toHaveBeenCalledWith(expect.objectContaining({ content: "first" }));
             expect(signer.signEvent).toHaveBeenCalledWith(expect.objectContaining({ content: "second" }));
-            // resolve first
+            // resolve both
             resolve.shift()?.();
-            // wait next tick
-            await new Promise((res) => setTimeout(res, 0));
-            // resolve second
             resolve.shift()?.();
         });
     });

package/dist/manager.d.ts

@@ -7,6 +7,8 @@ export declare class AccountManager<Metadata extends unknown = any> {
     get active(): IAccount<any, any, Metadata> | null;
     accounts$: BehaviorSubject<IAccount<any, any, Metadata>[]>;
     get accounts(): IAccount<any, any, Metadata>[];
+    /** Disable request queueing for any accounts added to this manager */
+    disableQueue?: boolean;
     /** Add account type class */
     registerType<S extends Nip07Interface>(accountType: IAccountConstructor<S, any, Metadata>): void;
     /** Remove account type */

package/dist/manager.js

@@ -9,6 +9,8 @@ export class AccountManager {
     get accounts() {
         return this.accounts$.value;
     }
+    /** Disable request queueing for any accounts added to this manager */
+    disableQueue;
     // Account type CRUD
     /** Add account type class */
     registerType(accountType) {
@@ -44,6 +46,10 @@ export class AccountManager {
     addAccount(account) {
         if (this.getAccount(account.id))
             return;
+        // copy the disableQueue flag only if its set
+        if (this.disableQueue !== undefined && account.disableQueue !== undefined) {
+            account.disableQueue = this.disableQueue;
+        }
         this.accounts$.next({
             ...this.accounts$.value,
             [account.id]: account,

package/dist/types.d.ts

@@ -25,6 +25,7 @@ export interface IAccount<Signer extends Nip07Interface, SignerData, Metadata ex
     pubkey: string;
     metadata?: Metadata;
     signer: Signer;
+    disableQueue?: boolean;
     toJSON(): SerializedAccount<SignerData, Metadata>;
 }
 export interface IAccountConstructor<Signer extends Nip07Interface, SignerData, Metadata extends unknown> {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applesauce-accounts",
-  "version": "0.0.0-next-20250125174815",
+  "version": "0.0.0-next-20250125183855",
   "description": "A simple nostr account management system",
   "type": "module",
   "main": "dist/index.js",
@@ -32,7 +32,7 @@
   },
   "dependencies": {
     "@noble/hashes": "^1.5.0",
-    "applesauce-signer": "0.0.0-next-20250125174815",
+    "applesauce-signer": "0.0.0-next-20250125183855",
     "nanoid": "^5.0.9",
     "nostr-tools": "^2.10.3",
     "rxjs": "^7.8.1"