applesauce-actions 0.0.0-next-20251209200210 → 0.0.0-next-20251231055351

package/README.md

@@ -18,12 +18,12 @@ Actions are common pre-built async operations that apps can perform. They use:
 - `EventFactory` to build and sign new nostr events
 - A `publish` method to publish or save the resulting events
 
-The package provides an `ActionHub` class that combines these components into a single manager for easier action execution.
+The package provides an `ActionRunner` class that combines these components into a single manager for easier action execution.
 
 ## Basic Usage
 
 ```typescript
-import { ActionHub } from "applesauce-actions";
+import { ActionRunner } from "applesauce-actions";
 import { FollowUser } from "applesauce-actions/actions";
 
 async function publishEvent(event: NostrEvent) {
@@ -31,7 +31,7 @@ async function publishEvent(event: NostrEvent) {
 }
 
 // Create an action hub with your event store, factory and publish method
-const hub = new ActionHub(eventStore, eventFactory, publishEvent);
+const hub = new ActionRunner(eventStore, eventFactory, publishEvent);
 
 // Example: Follow a user
 await hub

package/dist/action-runner.d.ts

@@ -0,0 +1,53 @@
+import { User } from "applesauce-common/casts/user";
+import { EventFactory, EventSigner } from "applesauce-core/event-factory";
+import { EventModels, IEventStoreActions, IEventStoreRead, IEventStoreStreams, IEventSubscriptions } from "applesauce-core/event-store";
+import { EventTemplate, NostrEvent, UnsignedEvent } from "applesauce-core/helpers/event";
+import { Observable } from "rxjs";
+/** A callback used to tell the upstream app to publish an event */
+export type PublishMethod = (event: NostrEvent, relays?: string[]) => void | Promise<any> | Observable<any>;
+type UpstreamPool = PublishMethod | {
+    publish: PublishMethod;
+};
+/** The context that is passed to actions for them to use to preform actions */
+export type ActionContext = {
+    /** The event store to load events from */
+    events: IEventStoreRead & IEventStoreStreams & IEventSubscriptions & EventModels;
+    /** The pubkey of the signer in the event factory */
+    self: string;
+    /** The {@link User} cast that is signing the events */
+    user: User;
+    /** The event signer used to sign events */
+    signer?: EventSigner;
+    /** The event factory used to build and modify events */
+    factory: EventFactory;
+    /** Sign an event using the event factory */
+    sign: (draft: EventTemplate | UnsignedEvent) => Promise<NostrEvent>;
+    /** The method to publish events to an optional list of relays */
+    publish: (event: NostrEvent | NostrEvent[], relays?: string[]) => Promise<void>;
+    /** Run a sub-action within the current action context and return the events */
+    run: <Args extends Array<any>>(builder: ActionBuilder<Args>, ...args: Args) => Promise<void>;
+};
+/** An action that can be run in a context to preform an action */
+export type Action = (context: ActionContext) => Promise<void>;
+/** A function that takes arguments and returns an action */
+export type ActionBuilder<Args extends Array<any>> = (...args: Args) => Action;
+/** The main class that runs actions */
+export declare class ActionRunner {
+    events: IEventStoreRead & IEventStoreStreams & IEventSubscriptions & IEventStoreActions & EventModels;
+    factory: EventFactory;
+    private publishMethod?;
+    /** Whether to save all events created by actions to the event store */
+    saveToStore: boolean;
+    constructor(events: IEventStoreRead & IEventStoreStreams & IEventSubscriptions & IEventStoreActions & EventModels, factory: EventFactory, publishMethod?: UpstreamPool | undefined);
+    protected context: ActionContext | undefined;
+    protected getContext(): Promise<ActionContext>;
+    /** Internal method for publishing events to relays */
+    publish(event: NostrEvent | NostrEvent[], relays?: string[]): Promise<void>;
+    /** Run an action and publish events using the publish method */
+    run<Args extends Array<any>>(builder: ActionBuilder<Args>, ...args: Args): Promise<void>;
+    /** Run an action without publishing the events */
+    exec<Args extends Array<any>>(builder: ActionBuilder<Args>, ...args: Args): Observable<NostrEvent>;
+}
+/** @deprecated Use ActionRunner instead */
+export declare const ActionHub: typeof ActionRunner;
+export {};

package/dist/action-runner.js

@@ -0,0 +1,91 @@
+import { castUser } from "applesauce-common/casts/user";
+import { from, identity, isObservable, lastValueFrom, Observable, switchMap, tap } from "rxjs";
+/** The main class that runs actions */
+export class ActionRunner {
+    events;
+    factory;
+    publishMethod;
+    /** Whether to save all events created by actions to the event store */
+    saveToStore = true;
+    constructor(events, factory, publishMethod) {
+        this.events = events;
+        this.factory = factory;
+        this.publishMethod = publishMethod;
+    }
+    context = undefined;
+    async getContext() {
+        if (this.context)
+            return this.context;
+        else {
+            if (!this.factory.context.signer)
+                throw new Error("Missing signer");
+            const self = await this.factory.context.signer.getPublicKey();
+            const user = castUser(self, this.events);
+            this.context = {
+                self,
+                user,
+                events: this.events,
+                signer: this.factory.context.signer,
+                factory: this.factory,
+                publish: this.publish.bind(this),
+                run: this.run.bind(this),
+                sign: this.factory.sign.bind(this.factory),
+            };
+            return this.context;
+        }
+    }
+    /** Internal method for publishing events to relays */
+    async publish(event, relays) {
+        if (!this.publishMethod)
+            throw new Error("Missing publish method, use ActionRunner.exec");
+        // Unwrap array of events to publish
+        if (Array.isArray(event)) {
+            await Promise.all(event.map((e) => this.publish(e, relays)));
+            return;
+        }
+        if (this.publishMethod) {
+            let result;
+            if ("publish" in this.publishMethod)
+                result = this.publishMethod.publish(event, relays);
+            else if (typeof this.publishMethod === "function")
+                result = this.publishMethod(event, relays);
+            else
+                throw new Error("Invalid publish method");
+            if (isObservable(result)) {
+                await lastValueFrom(result);
+            }
+            else if (result instanceof Promise) {
+                await result;
+            }
+            // Optionally save the event to the store
+            if (this.saveToStore)
+                this.events.add(event);
+        }
+    }
+    /** Run an action and publish events using the publish method */
+    async run(builder, ...args) {
+        // wait for action to complete and group events
+        const context = await this.getContext();
+        await builder(...args)(context);
+    }
+    /** Run an action without publishing the events */
+    exec(builder, ...args) {
+        return from(this.getContext()).pipe(
+        // Run the action
+        switchMap((ctx) => {
+            return new Observable((subscriber) => {
+                const context = {
+                    ...ctx,
+                    publish: async (event) => Array.isArray(event) ? event.forEach((e) => subscriber.next(e)) : subscriber.next(event),
+                    run: (builder, ...args) => builder(...args)(context),
+                };
+                builder(...args)(context).then(() => subscriber.complete(), (err) => subscriber.error(err));
+            });
+        }), 
+        // NOTE: its necessary to add a tap() here because we are overwriting the publish method above
+        // Optionally save all events to the store
+        this.saveToStore ? tap((event) => this.events.add(event)) : identity);
+    }
+}
+/** @deprecated Use ActionRunner instead */
+export const ActionHub = ActionRunner;

package/dist/actions/app-data.d.ts

@@ -1,2 +1,2 @@
-import { Action } from "../action-hub.js";
+import { Action } from "../action-runner.js";
 export declare function UpdateAppData<T>(identifier: string, data: T): Action;

package/dist/actions/app-data.js

@@ -2,12 +2,12 @@ import { AppDataBlueprint } from "applesauce-common/blueprints/app-data";
 import { APP_DATA_KIND, getAppDataEncryption } from "applesauce-common/helpers/app-data";
 import * as AppData from "applesauce-common/operations/app-data";
 export function UpdateAppData(identifier, data) {
-    return async function* ({ self, factory, events }) {
+    return async ({ self, factory, events, user, publish, sign }) => {
         const event = events.getReplaceable(APP_DATA_KIND, self, identifier);
         const encryption = !!event && getAppDataEncryption(event);
-        const draft = event
-            ? await factory.modify(event, AppData.setContent(data, encryption))
-            : await factory.create(AppDataBlueprint, identifier, data, encryption);
-        yield await factory.sign(draft);
+        const signed = event
+            ? await factory.modify(event, AppData.setContent(data, encryption)).then(sign)
+            : await factory.create(AppDataBlueprint, identifier, data, encryption).then(sign);
+        await publish(signed, await user.outboxes$.$first(1000, undefined));
     };
 }

package/dist/actions/blocked-relays.d.ts

@@ -1,10 +1,5 @@
-import { Action } from "../action-hub.js";
+import { Action } from "../action-runner.js";
 /** An action that adds a relay to the 10006 blocked relays event */
 export declare function AddBlockedRelay(relay: string | string[], hidden?: boolean): Action;
 /** An action that removes a relay from the 10006 blocked relays event */
 export declare function RemoveBlockedRelay(relay: string | string[], hidden?: boolean): Action;
-/** Creates a new blocked relays event */
-export declare function NewBlockedRelays(relays?: string[] | {
-    public?: string[];
-    hidden?: string[];
-}): Action;

package/dist/actions/blocked-relays.js

@@ -1,48 +1,42 @@
+import { firstValueFrom } from "applesauce-core";
 import { kinds } from "applesauce-core/helpers/event";
 import { modifyHiddenTags, modifyPublicTags } from "applesauce-core/operations";
 import { addRelayTag, removeRelayTag } from "applesauce-core/operations/tag/relay";
-function getBlockedRelaysEvent(events, self) {
-    const event = events.getReplaceable(kinds.BlockedRelaysList, self);
-    if (!event)
-        throw new Error("Can't find blocked relays event");
-    return event;
+import { of, timeout } from "rxjs";
+// Action to generally modify the blocked relays event
+function ModifyBlockedRelaysEvent(operations) {
+    return async ({ events, factory, user, publish, sign }) => {
+        const [event, outboxes] = await Promise.all([
+            firstValueFrom(events
+                .replaceable(kinds.BlockedRelaysList, user.pubkey)
+                .pipe(timeout({ first: 1000, with: () => of(undefined) }))),
+            user.outboxes$.$first(1000, undefined),
+        ]);
+        // Modify or build new event
+        const signed = event
+            ? await factory.modify(event, ...operations).then(sign)
+            : await factory.build({ kind: kinds.BlockedRelaysList }, ...operations).then(sign);
+        // Publish the event to the user's outboxes
+        await publish(signed, outboxes);
+    };
 }
 /** An action that adds a relay to the 10006 blocked relays event */
 export function AddBlockedRelay(relay, hidden = false) {
-    return async function* ({ events, factory, self }) {
-        const blocked = getBlockedRelaysEvent(events, self);
-        const operation = Array.isArray(relay) ? relay.map((r) => addRelayTag(r)) : addRelayTag(relay);
-        const draft = await factory.modifyTags(blocked, hidden ? { hidden: operation } : operation);
-        yield await factory.sign(draft);
+    return async ({ run }) => {
+        const tagOperations = Array.isArray(relay)
+            ? relay.map((r) => addRelayTag(r))
+            : [addRelayTag(relay)];
+        const operation = hidden ? modifyHiddenTags(...tagOperations) : modifyPublicTags(...tagOperations);
+        await run(ModifyBlockedRelaysEvent, [operation]);
     };
 }
 /** An action that removes a relay from the 10006 blocked relays event */
 export function RemoveBlockedRelay(relay, hidden = false) {
-    return async function* ({ events, factory, self }) {
-        const blocked = getBlockedRelaysEvent(events, self);
-        const operation = Array.isArray(relay) ? relay.map((r) => removeRelayTag(r)) : removeRelayTag(relay);
-        const draft = await factory.modifyTags(blocked, hidden ? { hidden: operation } : operation);
-        yield await factory.sign(draft);
-    };
-}
-/** Creates a new blocked relays event */
-export function NewBlockedRelays(relays) {
-    return async function* ({ events, factory, self }) {
-        const blocked = events.getReplaceable(kinds.BlockedRelaysList, self);
-        if (blocked)
-            throw new Error("Blocked relays event already exists");
-        let publicOperations = [];
-        let hiddenOperations = [];
-        if (Array.isArray(relays)) {
-            publicOperations.push(...relays.map((r) => addRelayTag(r)));
-        }
-        else {
-            if (relays?.public)
-                publicOperations.push(...(relays?.public ?? []).map((r) => addRelayTag(r)));
-            if (relays?.hidden)
-                hiddenOperations.push(...(relays?.hidden ?? []).map((r) => addRelayTag(r)));
-        }
-        const draft = await factory.build({ kind: kinds.BlockedRelaysList }, publicOperations.length ? modifyPublicTags(...publicOperations) : undefined, hiddenOperations.length ? modifyHiddenTags(...hiddenOperations) : undefined);
-        yield await factory.sign(draft);
+    return async ({ run }) => {
+        const tagOperations = Array.isArray(relay)
+            ? relay.map((r) => removeRelayTag(r))
+            : [removeRelayTag(relay)];
+        const operation = hidden ? modifyHiddenTags(...tagOperations) : modifyPublicTags(...tagOperations);
+        await run(ModifyBlockedRelaysEvent, [operation]);
     };
 }

package/dist/actions/blossom.d.ts

@@ -1,4 +1,4 @@
-import { Action } from "../action-hub.js";
+import { Action } from "../action-runner.js";
 /** An action that adds a server to the Blossom servers event */
 export declare function AddBlossomServer(server: string | URL | (string | URL)[]): Action;
 /** An action that removes a server from the Blossom servers event */

package/dist/actions/blossom.js

@@ -1,51 +1,44 @@
 import { BLOSSOM_SERVER_LIST_KIND } from "applesauce-common/helpers/blossom";
 import { addBlossomServer, removeBlossomServer } from "applesauce-common/operations/blossom";
-/** An action that adds a server to the Blossom servers event */
-export function AddBlossomServer(server) {
-    return async function* ({ events, factory, self }) {
-        const servers = events.getReplaceable(BLOSSOM_SERVER_LIST_KIND, self);
-        const operations = Array.isArray(server) ? server.map((s) => addBlossomServer(s)) : [addBlossomServer(server)];
+// Action to modify or create a new Blossom servers event
+function ModifyBlossomServersEvent(operations) {
+    return async ({ factory, user, publish, sign }) => {
+        const [event, outboxes] = await Promise.all([
+            user.replaceable(BLOSSOM_SERVER_LIST_KIND).$first(1000, undefined),
+            user.outboxes$.$first(1000, undefined),
+        ]);
         // Modify or build new event
-        const draft = servers
-            ? await factory.modify(servers, ...operations)
-            : await factory.build({ kind: BLOSSOM_SERVER_LIST_KIND }, ...operations);
-        yield await factory.sign(draft);
+        const signed = event
+            ? await factory.modify(event, ...operations).then(sign)
+            : await factory.build({ kind: BLOSSOM_SERVER_LIST_KIND }, ...operations).then(sign);
+        // Publish the event to the user's outboxes
+        await publish(signed, outboxes);
     };
 }
+/** An action that adds a server to the Blossom servers event */
+export function AddBlossomServer(server) {
+    return ModifyBlossomServersEvent(Array.isArray(server) ? server.map((s) => addBlossomServer(s)) : [addBlossomServer(server)]);
+}
 /** An action that removes a server from the Blossom servers event */
 export function RemoveBlossomServer(server) {
-    return async function* ({ events, factory, self }) {
-        const servers = events.getReplaceable(BLOSSOM_SERVER_LIST_KIND, self);
-        const operations = Array.isArray(server)
-            ? server.map((s) => removeBlossomServer(s))
-            : [removeBlossomServer(server)];
-        // Modify or build new event
-        const draft = servers
-            ? await factory.modify(servers, ...operations)
-            : await factory.build({ kind: BLOSSOM_SERVER_LIST_KIND }, ...operations);
-        yield await factory.sign(draft);
-    };
+    return ModifyBlossomServersEvent(Array.isArray(server) ? server.map((s) => removeBlossomServer(s)) : [removeBlossomServer(server)]);
+}
+// Small event operation to prepend a tag to the events tags
+function prependTag(tag) {
+    return (draft) => ({ ...draft, tags: [tag, ...draft.tags] });
 }
 /** Makes a specific Blossom server the default server (move it to the top of the list) */
 export function SetDefaultBlossomServer(server) {
-    return async function* ({ events, factory, self }) {
-        const servers = events.getReplaceable(BLOSSOM_SERVER_LIST_KIND, self);
-        const prependTag = (tag) => (draft) => ({ ...draft, tags: [tag, ...draft.tags] });
-        const operations = [removeBlossomServer(server), prependTag(["server", String(server)])];
-        const draft = servers
-            ? await factory.modify(servers, ...operations)
-            : await factory.build({ kind: BLOSSOM_SERVER_LIST_KIND }, ...operations);
-        yield await factory.sign(draft);
-    };
+    return ModifyBlossomServersEvent([removeBlossomServer(server), prependTag(["server", String(server)])]);
 }
 /** Creates a new Blossom servers event */
 export function NewBlossomServers(servers) {
-    return async function* ({ events, factory, self }) {
+    return async ({ events, factory, self, user, publish, sign }) => {
         const existing = events.getReplaceable(BLOSSOM_SERVER_LIST_KIND, self);
         if (existing)
             throw new Error("Blossom servers event already exists");
         const operations = servers ? servers.map((s) => addBlossomServer(s)) : [];
-        const draft = await factory.build({ kind: BLOSSOM_SERVER_LIST_KIND }, ...operations);
-        yield await factory.sign(draft);
+        const signed = await factory.build({ kind: BLOSSOM_SERVER_LIST_KIND }, ...operations).then(sign);
+        await publish(signed, await user.outboxes$.$first(1000, undefined));
     };
 }

package/dist/actions/bookmarks.d.ts

@@ -1,19 +1,20 @@
+import { AddressPointer, EventPointer } from "applesauce-core/helpers";
 import { NostrEvent } from "applesauce-core/helpers/event";
-import { Action } from "../action-hub.js";
+import { Action } from "../action-runner.js";
 /**
  * An action that adds a note or article to the bookmark list or a bookmark set
  * @param event the event to bookmark
  * @param identifier the "d" tag of the bookmark set or `undefined` for the default bookmark list
  * @param hidden set to true to add to hidden bookmarks
  */
-export declare function BookmarkEvent(event: NostrEvent, identifier?: string | NostrEvent, hidden?: boolean): Action;
+export declare function BookmarkEvent(event: NostrEvent | EventPointer | AddressPointer, identifier?: string | NostrEvent, hidden?: boolean): Action;
 /**
  * An action that removes a note or article from the bookmark list or bookmark set
  * @param event the event to remove from bookmarks
  * @param identifier the "d" tag of the bookmark set or `undefined` for the default bookmark list
  * @param hidden set to true to remove from hidden bookmarks
  */
-export declare function UnbookmarkEvent(event: NostrEvent, identifier?: string | NostrEvent, hidden?: boolean): Action;
+export declare function UnbookmarkEvent(event: NostrEvent | EventPointer | AddressPointer, identifier?: string | NostrEvent, hidden?: boolean): Action;
 /** An action that creates a new bookmark list for a user */
 export declare function CreateBookmarkList(bookmarks?: NostrEvent[]): Action;
 /** An action that creates a new bookmark set for a user */

package/dist/actions/bookmarks.js

@@ -1,40 +1,55 @@
 import * as List from "applesauce-common/operations/list";
 import { addEventBookmarkTag, removeEventBookmarkTag } from "applesauce-common/operations/tag/bookmarks";
-import { kinds } from "applesauce-core/helpers/event";
+import { getReplaceableIdentifier, kinds } from "applesauce-core/helpers/event";
 import { modifyHiddenTags, modifyPublicTags } from "applesauce-core/operations";
+function ModifyBookmarkSetEvent(operations, set, hidden = false) {
+    const identifier = typeof set === "string" ? set : getReplaceableIdentifier(set);
+    return async ({ factory, user, publish, sign }) => {
+        const [event, outboxes] = await Promise.all([
+            user.replaceable(kinds.Bookmarksets, identifier).$first(1000, undefined),
+            user.outboxes$.$first(1000, undefined),
+        ]);
+        const operation = hidden ? modifyHiddenTags(...operations) : modifyPublicTags(...operations);
+        // Modify or build new event
+        const signed = event
+            ? await factory.modify(event, operation).then(sign)
+            : await factory.build({ kind: kinds.Bookmarksets }, operation).then(sign);
+        // Publish the event to the user's outboxes
+        await publish(signed, outboxes);
+    };
+}
+function ModifyBookmarkListEvent(operations, hidden = false) {
+    return async ({ factory, user, publish, sign }) => {
+        const [event, outboxes] = await Promise.all([
+            user.replaceable(kinds.BookmarkList).$first(1000, undefined),
+            user.outboxes$.$first(1000, undefined),
+        ]);
+        const operation = hidden ? modifyHiddenTags(...operations) : modifyPublicTags(...operations);
+        // Modify or build new event
+        const signed = event
+            ? await factory.modify(event, operation).then(sign)
+            : await factory.build({ kind: kinds.BookmarkList }, operation).then(sign);
+        // Publish the event to the user's outboxes
+        await publish(signed, outboxes);
+    };
+}
 /**
  * An action that adds a note or article to the bookmark list or a bookmark set
  * @param event the event to bookmark
  * @param identifier the "d" tag of the bookmark set or `undefined` for the default bookmark list
  * @param hidden set to true to add to hidden bookmarks
  */
-export function BookmarkEvent(event, identifier, hidden = false) {
-    return async function* ({ events, factory, self }) {
-        let draft;
-        const operation = addEventBookmarkTag(event);
-        if (typeof identifier === "string" || identifier?.kind === kinds.Bookmarksets) {
-            const list = typeof identifier === "string" ? events.getReplaceable(kinds.Bookmarksets, self, identifier) : identifier;
-            if (list && list.kind !== kinds.Bookmarksets)
-                throw new Error("Event is not a bookmark set");
-            // Modify or build new event bookmark set
-            draft = list
-                ? await factory.modifyTags(list, hidden ? { hidden: operation } : operation)
-                : await factory.build({ kind: kinds.Bookmarksets }, hidden ? modifyHiddenTags(operation) : modifyPublicTags(operation));
-        }
-        else if (identifier === undefined || identifier?.kind === kinds.BookmarkList) {
-            const list = identifier ? identifier : events.getReplaceable(kinds.BookmarkList, self);
-            if (list && list.kind !== kinds.BookmarkList)
-                throw new Error("Event is not a bookmark list");
-            // Modify or build new event bookmark list
-            draft = list
-                ? await factory.modifyTags(list, hidden ? { hidden: operation } : operation)
-                : await factory.build({ kind: kinds.BookmarkList }, hidden ? modifyHiddenTags(operation) : modifyPublicTags(operation));
-        }
-        else {
-            throw new Error(`Event kind ${identifier.kind} is not a bookmark list or bookmark set`);
-        }
-        yield await factory.sign(draft);
-    };
+export function BookmarkEvent(event, identifier, hidden) {
+    const operation = addEventBookmarkTag(event);
+    if (typeof identifier === "string" || identifier?.kind === kinds.Bookmarksets) {
+        return ModifyBookmarkSetEvent([operation], identifier, hidden);
+    }
+    else if (identifier === undefined || identifier?.kind === kinds.BookmarkList) {
+        return ModifyBookmarkListEvent([operation], hidden);
+    }
+    else {
+        throw new Error(`Event kind ${identifier.kind} is not a bookmark list or bookmark set`);
+    }
 }
 /**
  * An action that removes a note or article from the bookmark list or bookmark set
@@ -42,42 +57,36 @@ export function BookmarkEvent(event, identifier, hidden = false) {
  * @param identifier the "d" tag of the bookmark set or `undefined` for the default bookmark list
  * @param hidden set to true to remove from hidden bookmarks
  */
-export function UnbookmarkEvent(event, identifier, hidden = false) {
-    return async function* ({ events, factory, self }) {
-        let list;
-        const operation = removeEventBookmarkTag(event);
-        if (typeof identifier === "string" || identifier?.kind === kinds.Bookmarksets) {
-            list = typeof identifier === "string" ? events.getReplaceable(kinds.Bookmarksets, self, identifier) : identifier;
-        }
-        else if (identifier === undefined || identifier?.kind === kinds.BookmarkList) {
-            list = identifier ? identifier : events.getReplaceable(kinds.BookmarkList, self);
-            if (!list)
-                return;
-        }
-        else {
-            throw new Error(`Event kind ${identifier.kind} is not a bookmark list or bookmark set`);
-        }
-        // If no list is found, return
-        if (!list)
-            return;
-        const draft = await factory.modifyTags(list, hidden ? { hidden: operation } : operation);
-        yield await factory.sign(draft);
-    };
+export function UnbookmarkEvent(event, identifier, hidden) {
+    const operation = removeEventBookmarkTag(event);
+    if (typeof identifier === "string" || identifier?.kind === kinds.Bookmarksets) {
+        return ModifyBookmarkSetEvent([operation], identifier, hidden);
+    }
+    else if (identifier === undefined || identifier?.kind === kinds.BookmarkList) {
+        return ModifyBookmarkListEvent([operation], hidden);
+    }
+    else {
+        throw new Error(`Event kind ${identifier.kind} is not a bookmark list or bookmark set`);
+    }
 }
 /** An action that creates a new bookmark list for a user */
 export function CreateBookmarkList(bookmarks) {
-    return async function* ({ events, factory, self }) {
+    return async ({ events, factory, self, user, publish, sign }) => {
         const existing = events.getReplaceable(kinds.BookmarkList, self);
         if (existing)
             throw new Error("Bookmark list already exists");
-        const draft = await factory.build({ kind: kinds.BookmarkList }, bookmarks ? modifyPublicTags(...bookmarks.map(addEventBookmarkTag)) : undefined);
-        yield await factory.sign(draft);
+        const signed = await factory
+            .build({ kind: kinds.BookmarkList }, bookmarks ? modifyPublicTags(...bookmarks.map(addEventBookmarkTag)) : undefined)
+            .then(sign);
+        await publish(signed, await user.outboxes$.$first(1000, undefined));
     };
 }
 /** An action that creates a new bookmark set for a user */
 export function CreateBookmarkSet(title, description, additional) {
-    return async function* ({ factory }) {
-        const draft = await factory.build({ kind: kinds.BookmarkList }, List.setTitle(title), List.setDescription(description), additional.image ? List.setImage(additional.image) : undefined, additional.public ? modifyPublicTags(...additional.public.map(addEventBookmarkTag)) : undefined, additional.hidden ? modifyHiddenTags(...additional.hidden.map(addEventBookmarkTag)) : undefined);
-        yield await factory.sign(draft);
+    return async ({ factory, user, publish, sign }) => {
+        const signed = await factory
+            .build({ kind: kinds.BookmarkList }, List.setTitle(title), List.setDescription(description), additional.image ? List.setImage(additional.image) : undefined, additional.public ? modifyPublicTags(...additional.public.map(addEventBookmarkTag)) : undefined, additional.hidden ? modifyHiddenTags(...additional.hidden.map(addEventBookmarkTag)) : undefined)
+            .then(sign);
+        await publish(signed, await user.outboxes$.$first(1000, undefined));
     };
 }

package/dist/actions/calendar.d.ts

@@ -1,6 +1,9 @@
+import { AddressPointer } from "applesauce-core/helpers";
 import { NostrEvent } from "applesauce-core/helpers/event";
-import { Action } from "../action-hub.js";
+import { Action } from "../action-runner.js";
 /** Adds a calendar event to a calendar */
-export declare function AddEventToCalendar(calendar: NostrEvent, event: NostrEvent): Action;
+export declare function AddEventToCalendar(calendar: NostrEvent | AddressPointer, event: NostrEvent | AddressPointer): Action;
 /** Removes a calendar event from a calendar */
-export declare function RemoveEventFromCalendar(calendar: NostrEvent, event: NostrEvent): Action;
+export declare function RemoveEventFromCalendar(calendar: NostrEvent | AddressPointer, event: NostrEvent | AddressPointer): Action;
+/** Creates a new calendar event with title and events */
+export declare function CreateCalendar(title: string, events?: (NostrEvent | AddressPointer)[]): Action;

package/dist/actions/calendar.js

@@ -1,25 +1,39 @@
 import { DATE_BASED_CALENDAR_EVENT_KIND, TIME_BASED_CALENDAR_EVENT_KIND, } from "applesauce-common/helpers/calendar-event";
-import { kinds } from "applesauce-core/helpers/event";
 import * as Calendar from "applesauce-common/operations/calendar";
+import { isEvent, kinds } from "applesauce-core/helpers/event";
+import { firstValueFrom, of, timeout } from "rxjs";
+function ModifyCalendarEvent(calendar, operations) {
+    return async ({ factory, user, publish, events, sign }) => {
+        const [event, outboxes] = await Promise.all([
+            isEvent(calendar)
+                ? Promise.resolve(calendar)
+                : firstValueFrom(events.replaceable(kinds.Calendar, user.pubkey).pipe(timeout({ first: 1000, with: () => of(undefined) }))),
+            user.outboxes$.$first(1000, undefined),
+        ]);
+        if (!event)
+            throw new Error("Calendar event not found");
+        const signed = await factory.modify(event, ...operations).then(sign);
+        await publish(signed, outboxes);
+    };
+}
 /** Adds a calendar event to a calendar */
 export function AddEventToCalendar(calendar, event) {
-    if (calendar.kind !== kinds.Calendar)
-        throw new Error("Calendar is not a calendar event");
     if (event.kind !== DATE_BASED_CALENDAR_EVENT_KIND && event.kind !== TIME_BASED_CALENDAR_EVENT_KIND)
         throw new Error("Event is not a calendar event");
-    return async function* ({ factory }) {
-        const draft = await factory.modify(calendar, Calendar.addEvent(event));
-        return await factory.sign(draft);
-    };
+    return ModifyCalendarEvent(calendar, [Calendar.addEvent(event)]);
 }
 /** Removes a calendar event from a calendar */
 export function RemoveEventFromCalendar(calendar, event) {
-    if (calendar.kind !== kinds.Calendar)
-        throw new Error("Calendar is not a calendar event");
     if (event.kind !== DATE_BASED_CALENDAR_EVENT_KIND && event.kind !== TIME_BASED_CALENDAR_EVENT_KIND)
         throw new Error("Event is not a calendar event");
-    return async function* ({ factory }) {
-        const draft = await factory.modify(calendar, Calendar.removeEvent(event));
-        return await factory.sign(draft);
+    return ModifyCalendarEvent(calendar, [Calendar.removeEvent(event)]);
+}
+/** Creates a new calendar event with title and events */
+export function CreateCalendar(title, events) {
+    return async ({ factory, sign, publish, user }) => {
+        const event = await factory
+            .build({ kind: kinds.Calendar }, Calendar.setTitle(title), ...(events?.map((event) => Calendar.addEvent(event)) ?? []))
+            .then(sign);
+        await publish(event, await user.outboxes$.$first(1000, undefined));
     };
 }

package/dist/actions/comment.d.ts

@@ -0,0 +1,10 @@
+import { CommentBlueprintOptions } from "applesauce-common/blueprints";
+import { CommentPointer } from "applesauce-common/helpers/comment";
+import { NostrEvent } from "applesauce-core/helpers/event";
+import { Action } from "../action-runner.js";
+/**
+ * Creates a comment on an event or CommentPointer and publishes it to:
+ * - The parent event's author's inboxes (if the author exists and pubkey is available)
+ * - The current user's outboxes
+ */
+export declare function CreateComment(parent: NostrEvent | CommentPointer, content: string, options?: CommentBlueprintOptions): Action;