@elysiumjs/moirai 0.0.0-stage → 0.1.0

package/dist/errors.d.ts

@@ -0,0 +1,209 @@
+import type { ProblemValidationError } from '@elysiumjs/core';
+import { ElysiumError } from '@elysiumjs/core';
+declare const IdempotencyKeyRequiredError_base: {
+    new (detail?: string, options?: import("@elysiumjs/core").DomainErrorOptions): {
+        name: string;
+        message: string;
+        stack?: string;
+        cause?: unknown;
+        value?(): import("elysia/types").MaybePromise<unknown>;
+        readonly code: "IDEMPOTENCY_KEY_REQUIRED";
+        readonly status: 400;
+        readonly detail: string | undefined;
+        readonly title: string;
+        readonly errors: readonly ProblemValidationError[] | undefined;
+        readonly retryAfterSeconds: number | undefined;
+        readonly extensions: Readonly<Record<string, unknown>>;
+        readonly headers: Record<string, string> | undefined;
+        readonly type: string;
+        extension(): Record<string, unknown>;
+    };
+    isError(error: unknown): error is Error;
+    isError(value: unknown): value is Error;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+    id<const Type extends string>(code: Type): import("elysia").TaggedHTTPError<Type>;
+    id<const Type extends string, const S_1 extends number | keyof import("elysia").StatusMap>(code: Type, status: S_1): import("elysia").TaggedHTTPError<Type, {
+        readonly status: S_1 extends keyof import("elysia").StatusMap ? import("elysia").StatusMap[S_1] : S_1;
+    }>;
+    typeBase?: string;
+    for<const C extends import("@elysiumjs/core").ProblemCode, const S extends number>(code: C, status: S): any;
+};
+/**
+ * Raised when an idempotent action is called without an idempotency key. Rendered as a 400
+ * problem.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export declare class IdempotencyKeyRequiredError extends IdempotencyKeyRequiredError_base {
+    readonly action: string;
+    constructor(action: string);
+}
+declare const IdempotencyKeyReusedError_base: {
+    new (detail?: string, options?: import("@elysiumjs/core").DomainErrorOptions): {
+        name: string;
+        message: string;
+        stack?: string;
+        cause?: unknown;
+        value?(): import("elysia/types").MaybePromise<unknown>;
+        readonly code: "IDEMPOTENCY_KEY_REUSED";
+        readonly status: 422;
+        readonly detail: string | undefined;
+        readonly title: string;
+        readonly errors: readonly ProblemValidationError[] | undefined;
+        readonly retryAfterSeconds: number | undefined;
+        readonly extensions: Readonly<Record<string, unknown>>;
+        readonly headers: Record<string, string> | undefined;
+        readonly type: string;
+        extension(): Record<string, unknown>;
+    };
+    isError(error: unknown): error is Error;
+    isError(value: unknown): value is Error;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+    id<const Type extends string>(code: Type): import("elysia").TaggedHTTPError<Type>;
+    id<const Type extends string, const S_1 extends number | keyof import("elysia").StatusMap>(code: Type, status: S_1): import("elysia").TaggedHTTPError<Type, {
+        readonly status: S_1 extends keyof import("elysia").StatusMap ? import("elysia").StatusMap[S_1] : S_1;
+    }>;
+    typeBase?: string;
+    for<const C extends import("@elysiumjs/core").ProblemCode, const S extends number>(code: C, status: S): any;
+};
+/**
+ * Raised when an idempotency key comes back with another action or another input. Rendered as a
+ * 422 problem.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export declare class IdempotencyKeyReusedError extends IdempotencyKeyReusedError_base {
+    readonly key: string;
+    constructor(key: string);
+}
+/**
+ * Raised by an {@link IdempotencyStore} when another call stored the same key first. The action
+ * retries, and replays the response of the call that won.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export declare class IdempotencyConflictError extends ElysiumError {
+    readonly key: string;
+    /** Conflicts are transient: the action retries them. */
+    readonly transient = true;
+    constructor(key: string);
+}
+declare const InvalidInputError_base: {
+    new (detail?: string, options?: import("@elysiumjs/core").DomainErrorOptions): {
+        name: string;
+        message: string;
+        stack?: string;
+        cause?: unknown;
+        value?(): import("elysia/types").MaybePromise<unknown>;
+        readonly code: "VALIDATION_FAILED";
+        readonly status: 422;
+        readonly detail: string | undefined;
+        readonly title: string;
+        readonly errors: readonly ProblemValidationError[] | undefined;
+        readonly retryAfterSeconds: number | undefined;
+        readonly extensions: Readonly<Record<string, unknown>>;
+        readonly headers: Record<string, string> | undefined;
+        readonly type: string;
+        extension(): Record<string, unknown>;
+    };
+    isError(error: unknown): error is Error;
+    isError(value: unknown): value is Error;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+    id<const Type extends string>(code: Type): import("elysia").TaggedHTTPError<Type>;
+    id<const Type extends string, const S_1 extends number | keyof import("elysia").StatusMap>(code: Type, status: S_1): import("elysia").TaggedHTTPError<Type, {
+        readonly status: S_1 extends keyof import("elysia").StatusMap ? import("elysia").StatusMap[S_1] : S_1;
+    }>;
+    typeBase?: string;
+    for<const C extends import("@elysiumjs/core").ProblemCode, const S extends number>(code: C, status: S): any;
+};
+/**
+ * Raised when the input of an action or a query does not match its schema. Rendered as a 422
+ * problem, with one entry per mistake in `errors`.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export declare class InvalidInputError extends InvalidInputError_base {
+    readonly target: string;
+    constructor(target: string, errors: readonly ProblemValidationError[]);
+}
+declare const CallForbiddenError_base: {
+    new (detail?: string, options?: import("@elysiumjs/core").DomainErrorOptions): {
+        name: string;
+        message: string;
+        stack?: string;
+        cause?: unknown;
+        value?(): import("elysia/types").MaybePromise<unknown>;
+        readonly code: "FORBIDDEN";
+        readonly status: 403;
+        readonly detail: string | undefined;
+        readonly title: string;
+        readonly errors: readonly ProblemValidationError[] | undefined;
+        readonly retryAfterSeconds: number | undefined;
+        readonly extensions: Readonly<Record<string, unknown>>;
+        readonly headers: Record<string, string> | undefined;
+        readonly type: string;
+        extension(): Record<string, unknown>;
+    };
+    isError(error: unknown): error is Error;
+    isError(value: unknown): value is Error;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+    id<const Type extends string>(code: Type): import("elysia").TaggedHTTPError<Type>;
+    id<const Type extends string, const S_1 extends number | keyof import("elysia").StatusMap>(code: Type, status: S_1): import("elysia").TaggedHTTPError<Type, {
+        readonly status: S_1 extends keyof import("elysia").StatusMap ? import("elysia").StatusMap[S_1] : S_1;
+    }>;
+    typeBase?: string;
+    for<const C extends import("@elysiumjs/core").ProblemCode, const S extends number>(code: C, status: S): any;
+};
+/**
+ * Raised when the `authorize` hook of an action refuses the call. Rendered as a 403 problem.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export declare class CallForbiddenError extends CallForbiddenError_base {
+    readonly action: string;
+    constructor(action: string);
+}
+/**
+ * Raised when moirai needs a store that neither the current module (`Moirai.stores()`) nor
+ * `MoiraiModule.with()` set.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export declare class MissingStoreError extends ElysiumError {
+    readonly store: string;
+    readonly module?: string | undefined;
+    constructor(store: string, module?: string | undefined);
+}
+/**
+ * Raised when an outbox row has a kind no `@Outbox.handle()` handles.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export declare class UnknownEffectError extends ElysiumError {
+    readonly kind: string;
+    constructor(kind: string);
+}
+/**
+ * Raised when two event handlers have the same consumer name.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export declare class DuplicateEventConsumerError extends ElysiumError {
+    readonly consumer: string;
+    constructor(consumer: string);
+}
+/**
+ * Raised when an event is delivered to a handler this process does not have. The delivery
+ * retries, so a process that imports the handler later can still handle it.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export declare class UnknownEventConsumerError extends ElysiumError {
+    readonly consumer: string;
+    readonly event: string;
+    constructor(consumer: string, event: string);
+}
+export {};

package/dist/event.d.ts

@@ -0,0 +1,97 @@
+/**
+ * The events of the application and their payloads. Extend it to type `Event.publish()` and
+ * `@Event.on()`; while it is empty, any name and payload are accepted.
+ * @author Axel Nana <axel.nana@workbud.com>
+ * @example
+ * ```ts
+ * declare module '@elysiumjs/moirai' {
+ * 	interface EventCatalogue {
+ * 		'wallet.credited': { walletId: string; amount: number };
+ * 	}
+ * }
+ * ```
+ */
+export interface EventCatalogue {
+}
+/** The name of an event: a key of {@link EventCatalogue}, or any string while it is empty. */
+export type EventName = [keyof EventCatalogue] extends [never] ? string : keyof EventCatalogue & string;
+/** The payload of an event: its type in {@link EventCatalogue}, else any. */
+export type EventPayload<E extends string> = E extends keyof EventCatalogue ? EventCatalogue[E] : any;
+/**
+ * What a handler receives besides the payload.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export type EventMeta = {
+    /** The id of the event, the same for every handler. */
+    id: string;
+    /** The name of the event. */
+    event: string;
+    /** When the event was published. */
+    publishedAt: Date;
+    /** The attempt of this handler, from 1. */
+    attempt: number;
+};
+/**
+ * Options of {@link Event.on}.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export type EventHandlerOptions = {
+    /**
+     * The name of the handler, which records the events it handled. Defaults to `Class.method`.
+     * Keep it when the method is renamed, so that the handled events are not handled again.
+     */
+    consumer?: string;
+    /**
+     * The attempts of the handler, the first included. Defaults to the `maxRelayAttempts` of the
+     * module; `false` gives one attempt. A handler that fails them all is dead (`onDead`).
+     */
+    retry?: false | {
+        attempts?: number;
+    };
+};
+/** The kind of the outbox rows that deliver an event to one handler. */
+export declare const MOIRAI_EVENT_EFFECT = "moirai.event";
+/** @internal Forgets the registered handlers, for tests. */
+export declare const clearEventHandlers: () => void;
+/**
+ * Domain events: what happened, published in the unit of work that made it happen, and handled
+ * once by each handler, after it commits. Each handler gets its own delivery through the outbox,
+ * so it retries and fails on its own, and records the events it handled in the inbox, in the
+ * unit of work of its own writes. Delivery needs the `outbox` and `inbox` stores of
+ * `MoiraiModule`.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export declare namespace Event {
+    /**
+     * Marks a method as a handler of an event. Static methods are called on the class; instance
+     * methods run on the registered service, or on a new instance with its dependencies.
+     * @author Axel Nana <axel.nana@workbud.com>
+     * @param event The name of the event.
+     * @param options The name of the handler and its attempts.
+     * @throws {DuplicateEventConsumerError} When another handler has the same `consumer`.
+     * @example
+     * ```ts
+     * class Receipts {
+     * 	@Event.on('wallet.credited', { consumer: 'billing.send-receipt', retry: { attempts: 5 } })
+     * 	public async send(payload: { walletId: string }, meta: EventMeta) {}
+     * }
+     * ```
+     */
+    const on: <const E extends EventName>(event: E, options?: EventHandlerOptions) => <T extends (payload: EventPayload<E>, meta: EventMeta) => unknown>(target: object, method: string | symbol, _descriptor: TypedPropertyDescriptor<T>) => void;
+    /**
+     * Publishes an event in the open unit of work, through the outbox of the current module: each
+     * handler of the event gets it once the unit
+     * commits, and never when it rolls back.
+     * @author Axel Nana <axel.nana@workbud.com>
+     * @param event The name of the event.
+     * @param payload The JSON-safe payload.
+     * @returns The id of the event.
+     */
+    const publish: <const E extends EventName>(event: E, payload: EventPayload<E>) => Promise<string>;
+    /**
+     * The consumers of an event.
+     * @author Axel Nana <axel.nana@workbud.com>
+     * @param event The name of the event.
+     */
+    const consumersOf: (event: string) => string[];
+}

package/dist/hash.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The fingerprint of an action input: the hex SHA-256 of its canonical JSON, so that the same input
+ * gives the same hash whatever the order of its keys.
+ * @author Axel Nana <axel.nana@workbud.com>
+ * @param input The validated input.
+ */
+export declare const requestHash: (input: unknown) => Promise<string>;

package/dist/heracles.d.ts

@@ -0,0 +1,43 @@
+import type { JobClass, JobDispatchOptions } from '@elysiumjs/heracles';
+import type { OutboxEffect } from './stores';
+import { ElysiumError } from '@elysiumjs/core';
+/** The kind of the effects that dispatch a Heracles job. */
+export declare const HERACLES_JOB_EFFECT = "heracles.job";
+/**
+ * An outbox effect that dispatches a Heracles job once the action commits, with the retries of
+ * the outbox until the job is queued.
+ * @author Axel Nana <axel.nana@workbud.com>
+ * @param jobClass The job class, registered in a module's `jobs`.
+ * @param args The arguments of the job, JSON-safe.
+ * @param options The dispatch options.
+ * @example
+ * ```ts
+ * await Outbox.enqueue(job(SendReceiptJob, [order.id]));
+ * ```
+ */
+export declare const job: <TClass extends JobClass<any>>(jobClass: TClass, args: ConstructorParameters<TClass>, options?: JobDispatchOptions) => OutboxEffect;
+/**
+ * Raised when `@Once()` goes on a class without an `execute()` method.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export declare class InvalidOnceJobError extends ElysiumError {
+    constructor(name: string);
+}
+/**
+ * Runs a Heracles job once per dispatch id: its `execute()` runs in a unit of work with an inbox
+ * record of the dispatch id, so a delivery that comes again, or a tick handled twice, does nothing.
+ * Made for the jobs of a `Scheduler`, whose dispatch id names the scheduler, the case and the
+ * tick. Without a database module, the record and the work run without a transaction.
+ * @author Axel Nana <axel.nana@workbud.com>
+ * The record goes to the inbox of the module that registers the job.
+ * @param options The inbox consumer. Defaults to the job name.
+ * @example
+ * ```ts
+ * @Job.register({ queue: 'billing' })
+ * @Once()
+ * class BillInvoice extends Job { ... }
+ * ```
+ */
+export declare const Once: (options?: {
+    consumer?: string;
+}) => (target: Function) => void;

package/dist/heracles.js

@@ -0,0 +1 @@
+import{registerEffect2,Inbox2}from"./index-2t45ppfs.js";import{DATABASE_TRANSACTION_SERVICE,ElysiumError,ModuleContext,Service}from"@elysiumjs/core";import{Heracles,JobRegistry}from"@elysiumjs/heracles";import{UnitOfWork}from"@elysiumjs/mnemosyne";var HERACLES_JOB_EFFECT="heracles.job";registerEffect2(HERACLES_JOB_EFFECT,async(payload)=>{let{job,args,options}=payload,entry=JobRegistry.get(job);if(!entry)throw Error(`No Heracles job is registered as ${job}.`);await Heracles.dispatch(entry.jobClass,args,options)});var job=(jobClass,args,options)=>{let name=JobRegistry.all().find((entry)=>entry.jobClass===jobClass)?.name;if(!name)throw Error(`${jobClass.name} is not registered in a module's jobs.`);return{kind:HERACLES_JOB_EFFECT,payload:{job:name,args,options}}};class InvalidOnceJobError extends ElysiumError{constructor(name){super(`@Once() goes on a Heracles job class with an execute() method, which ${name} has not.`)}}var Once=(options={})=>(target)=>{let proto=target.prototype,execute=proto.execute;if(typeof execute!=="function")throw new InvalidOnceJobError(target.name);proto.execute=async function(...args){let entry=JobRegistry.all().find((item)=>item.jobClass===this.constructor),consumer=options.consumer??entry?.name??target.name,work=()=>Inbox2.once({messageId:this.dispatchId,consumer},async()=>{await execute.apply(this,args)}),run=()=>Service.exists(DATABASE_TRANSACTION_SERVICE)?UnitOfWork.run(work):work();await(entry&&entry.module!==ModuleContext.current()?ModuleContext.run(entry.module,run):run())}};export{HERACLES_JOB_EFFECT,InvalidOnceJobError,Once,job};

package/dist/ids.d.ts

@@ -0,0 +1,7 @@
+/**
+ * A UUID version 7: a millisecond timestamp followed by random bits, so that ids sort by creation
+ * time.
+ * @author Axel Nana <axel.nana@workbud.com>
+ * @param now The time of the id. Defaults to now.
+ */
+export declare const uuidv7: (now?: number) => string;

package/dist/index-2t45ppfs.js

@@ -0,0 +1,2 @@
+import{ModuleContext,Service}from"@elysiumjs/core";import{DomainError,ElysiumError}from"@elysiumjs/core";class IdempotencyKeyRequiredError2 extends DomainError.for("IDEMPOTENCY_KEY_REQUIRED",400){action;constructor(action){super(`The ${action} action needs an Idempotency-Key.`,{extensions:{action}});this.action=action}}class IdempotencyKeyReusedError2 extends DomainError.for("IDEMPOTENCY_KEY_REUSED",422){key;constructor(key){super("This Idempotency-Key was already used for another request.",{extensions:{idempotencyKey:key}});this.key=key}}class IdempotencyConflictError2 extends ElysiumError{key;transient=!0;constructor(key){super(`The idempotency key ${key} was stored by another call.`);this.key=key}}class InvalidInputError2 extends DomainError.for("VALIDATION_FAILED",422){target;constructor(target,errors){super(`The input of ${target} is invalid.`,{errors});this.target=target}}class CallForbiddenError2 extends DomainError.for("FORBIDDEN",403){action;constructor(action){super(`You may not run the ${action} action.`);this.action=action}}class MissingStoreError2 extends ElysiumError{store;module;constructor(store,module){super(`Moirai has no ${store} store`+(module?` in module ${module}`:"")+`. Set one with MoiraiModule.with({ ${store}: ... }) in the application, or with Moirai.stores({ ${store}: ... }) in the services of the module.`);this.store=store;this.module=module}}class UnknownEffectError2 extends ElysiumError{kind;constructor(kind){super(`No @Outbox.handle('${kind}') handles the outbox rows of kind "${kind}". Effects register when their module is imported, so the process that relays must import it`+(kind==="heracles.job"?" (here '@elysiumjs/moirai/heracles').":"."));this.kind=kind}}class DuplicateEventConsumerError2 extends ElysiumError{consumer;constructor(consumer){super(`Two event handlers are named "${consumer}". Give one of them another consumer.`);this.consumer=consumer}}class UnknownEventConsumerError2 extends ElysiumError{consumer;event;constructor(consumer,event){super(`No @Event.on('${event}') handler is named "${consumer}" here. Handlers register when their module is imported, so the process that relays must import it.`);this.consumer=consumer;this.event=event}}var MOIRAI_IDEMPOTENCY_STORE2="moirai.idempotency",MOIRAI_OUTBOX_STORE2="moirai.outbox",MOIRAI_INBOX_STORE2="moirai.inbox",MOIRAI_ACTION_LOCK2="moirai.lock",MOIRAI_OPTIONS2="moirai.options",MOIRAI_MODULE_OPTIONS2="moirai.module-options",TRANSIENT_CODES=new Set(["40001","40P01"]),isTransientError2=(error)=>{if(typeof error!=="object"||error===null)return!1;let{transient,code,errno,cause}=error;if(transient===!0)return!0;if(typeof code==="string"&&TRANSIENT_CODES.has(code))return!0;if(typeof errno==="string"&&TRANSIENT_CODES.has(errno))return!0;return cause!==void 0&&cause!==error&&isTransientError2(cause)},DEFAULT_OPTIONS={maxAttempts:3,isTransient:isTransientError2,relayOnCommit:!0,maxRelayAttempts:8,relayBatch:50,relayLease:300},lookup=(name)=>Service.get(name),options=()=>{let base=lookup(MOIRAI_OPTIONS2)??DEFAULT_OPTIONS,own=lookup(MOIRAI_MODULE_OPTIONS2);return own?{...base,...own}:base},store=(name,kind)=>()=>{let found=lookup(name);if(!found)throw new MissingStoreError2(kind,ModuleContext.current()?.id);return found},idempotencyStore=store(MOIRAI_IDEMPOTENCY_STORE2,"idempotency"),outboxStore=store(MOIRAI_OUTBOX_STORE2,"outbox"),inboxStore=store(MOIRAI_INBOX_STORE2,"inbox"),actionLock=store(MOIRAI_ACTION_LOCK2,"lock"),inOwnerModule=(service,work)=>{let owner=Service.ownersOf(service)[0];return owner&&owner!==ModuleContext.current()?ModuleContext.run(owner,work):work()};var uuidv72=(now=Date.now())=>{let bytes=crypto.getRandomValues(new Uint8Array(16)),time=now;for(let i=5;i>=0;i--)bytes[i]=time%256,time=Math.floor(time/256);bytes[6]=bytes[6]&15|112,bytes[8]=bytes[8]&63|128;let hex=[...bytes].map((byte)=>byte.toString(16).padStart(2,"0")).join("");return`${hex.slice(0,8)}-${hex.slice(8,12)}-${hex.slice(12,16)}-${hex.slice(16,20)}-${hex.slice(20)}`};import{DATABASE_TRANSACTION_SERVICE,getLogger,ModuleContext as ModuleContext2,Service as Service2}from"@elysiumjs/core";import{UnitOfWork}from"@elysiumjs/mnemosyne";var EFFECTS=new Map,ATTEMPTS=new Map,effectHandler2=(kind)=>EFFECTS.get(kind),registerEffect2=(kind,handler,policy={})=>{if(EFFECTS.set(kind,handler),policy.attempts)ATTEMPTS.set(kind,policy.attempts);else ATTEMPTS.delete(kind)},BASE_DELAY_MS=5000,MAX_DELAY_MS=3600000,backoffMs2=(attempts)=>Math.min(BASE_DELAY_MS*2**Math.max(0,attempts-1),MAX_DELAY_MS),inModule=(node,work)=>node&&node!==ModuleContext2.current()?ModuleContext2.run(node,work):work(),outboxModule=(module)=>{if(!module)return;let node=Service2.ownersOf(MOIRAI_OUTBOX_STORE2).find((owner)=>owner.moduleClass===module);if(!node)throw new MissingStoreError2("outbox",module.name);return node},asError=(error)=>error instanceof Error?error:Error(String(error)),inUnitOfWork=(work)=>Service2.exists(DATABASE_TRANSACTION_SERVICE)?UnitOfWork.run(work):work(),Outbox2;((Outbox)=>{Outbox.handle=(kind)=>(target,method)=>{EFFECTS.set(kind,(payload,row)=>{let owner=target.constructor;return(Service2.get(owner)??Service2.make(owner))[method](payload,row)})},Outbox.enqueue=async(...effects)=>{if(effects.length===0)return[];let now=new Date,rows=effects.map((effect)=>({id:uuidv72(now.getTime()),kind:effect.kind,payload:structuredClone(effect.payload),createdAt:now,availableAt:effect.availableAt??now,attempts:0,lastError:null,dispatchedAt:null,deadAt:null}));await outboxStore().insert(rows);let config=options(),module=ModuleContext2.current();if(config.relayOnCommit){let ids=rows.filter((row)=>row.availableAt<=now).map((row)=>row.id);if(ids.length>0)await UnitOfWork.afterCommit(()=>{let work=inModule(module,()=>Outbox.relay({ids})).catch((error)=>getLogger().error("The outbox relay after a commit failed",{error}));if(config.defer)config.defer(work);else return work})}return rows.map((row)=>row.id)},Outbox.relay=(relayOptions={})=>inModule(outboxModule(relayOptions.module),()=>relayRows(relayOptions));let relayRows=async(relayOptions)=>{let config=options(),store=outboxStore(),summary={dispatched:0,retried:0,dead:0},now=new Date,rows=await inUnitOfWork(()=>store.claimDue({now,leaseUntil:new Date(now.getTime()+config.relayLease*1000),limit:relayOptions.batch??config.relayBatch,kinds:relayOptions.kinds,ids:relayOptions.ids}));for(let row of rows)try{await inUnitOfWork(async()=>{let handler=effectHandler2(row.kind);if(!handler)throw new UnknownEffectError2(row.kind);await handler(row.payload,row),await store.markDispatched(row.id,new Date)}),summary.dispatched++}catch(cause){let error=asError(cause),attempts=row.attempts+1,failedAt=new Date,maxAttempts=ATTEMPTS.get(row.kind)?.(row)??config.maxRelayAttempts;if(attempts>=maxAttempts)await inUnitOfWork(()=>store.markDead(row.id,{attempts,lastError:error.message,deadAt:failedAt})),config.onDead?.(row,error),getLogger().error("An outbox row is dead",{id:row.id,kind:row.kind,error}),summary.dead++;else{let availableAt=new Date(failedAt.getTime()+backoffMs2(attempts));await inUnitOfWork(()=>store.markFailed(row.id,{attempts,lastError:error.message,availableAt})),summary.retried++}}return summary};Outbox.sweep=async(relayOptions={})=>{let total={dispatched:0,retried:0,dead:0},drain=async()=>{for(;;){let summary=await relayRows(relayOptions);if(total.dispatched+=summary.dispatched,total.retried+=summary.retried,total.dead+=summary.dead,summary.dispatched+summary.retried+summary.dead===0)return}};if(relayOptions.module)return await inModule(outboxModule(relayOptions.module),drain),total;if(Service2.exists(MOIRAI_OUTBOX_STORE2))await ModuleContext2.outside(drain);for(let owner of Service2.ownersOf(MOIRAI_OUTBOX_STORE2))await ModuleContext2.run(owner,drain);return total}})(Outbox2||={});var Inbox2;((Inbox)=>Inbox.once=async(message,work)=>{if(!await inboxStore().record(message.messageId,message.consumer))return!1;return await work(),!0})(Inbox2||={});
+export{IdempotencyKeyRequiredError2,IdempotencyKeyReusedError2,IdempotencyConflictError2,InvalidInputError2,CallForbiddenError2,MissingStoreError2,UnknownEffectError2,DuplicateEventConsumerError2,UnknownEventConsumerError2,MOIRAI_IDEMPOTENCY_STORE2,MOIRAI_OUTBOX_STORE2,MOIRAI_INBOX_STORE2,MOIRAI_ACTION_LOCK2,MOIRAI_OPTIONS2,MOIRAI_MODULE_OPTIONS2,isTransientError2,DEFAULT_OPTIONS,options,idempotencyStore,actionLock,inOwnerModule,uuidv72,effectHandler2,registerEffect2,backoffMs2,Outbox2,Inbox2};

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export { type ActionClass, type ActionOptions, type ActionOutcome, type ActionRetry, type HandlerContext, type HandlerResult, type QueryClass, type QueryOptions, type QueryOutcome, Action, Moirai, Query } from './action';
+export { isTransientError, MOIRAI_ACTION_LOCK, MOIRAI_IDEMPOTENCY_STORE, MOIRAI_INBOX_STORE, MOIRAI_MODULE_OPTIONS, MOIRAI_OPTIONS, MOIRAI_OUTBOX_STORE, type MoiraiOptions } from './config';
+export { CallForbiddenError, DuplicateEventConsumerError, IdempotencyConflictError, IdempotencyKeyRequiredError, IdempotencyKeyReusedError, InvalidInputError, MissingStoreError, UnknownEventConsumerError, UnknownEffectError } from './errors';
+export { type EventCatalogue, type EventHandlerOptions, type EventMeta, type EventName, type EventPayload, Event, MOIRAI_EVENT_EFFECT } from './event';
+export { requestHash } from './hash';
+export { uuidv7 } from './ids';
+export { MoiraiModule, type MoiraiModuleConfig, type MoiraiStores } from './moirai.module';
+export { type RelayOptions, type RelaySummary, backoffMs, effectHandler, Inbox, Outbox, registerEffect } from './outbox';
+export { type ActionLock, type IdempotencyRecord, type IdempotencyStore, type InboxStore, MemoryActionLock, MemoryIdempotencyStore, MemoryInboxStore, MemoryOutboxStore, type OutboxClaim, type OutboxClaimFilter, type OutboxEffect, type OutboxRow, type OutboxStore } from './stores';

package/dist/index.js

@@ -0,0 +1 @@
+import{IdempotencyKeyRequiredError2,IdempotencyKeyReusedError2,IdempotencyConflictError2,InvalidInputError2,CallForbiddenError2,MissingStoreError2,UnknownEffectError2,DuplicateEventConsumerError2,UnknownEventConsumerError2,MOIRAI_IDEMPOTENCY_STORE2,MOIRAI_OUTBOX_STORE2,MOIRAI_INBOX_STORE2,MOIRAI_ACTION_LOCK2,MOIRAI_OPTIONS2,MOIRAI_MODULE_OPTIONS2,isTransientError2,DEFAULT_OPTIONS,options,idempotencyStore,actionLock,inOwnerModule,uuidv72,effectHandler2,registerEffect2,backoffMs2,Outbox2,Inbox2}from"./index-2t45ppfs.js";var __legacyDecorateClassTS=function(decorators,target,key,desc){var c=arguments.length,r=c<3?target:desc===null?desc=Object.getOwnPropertyDescriptor(target,key):desc,d;if(typeof Reflect==="object"&&typeof Reflect.decorate==="function")r=Reflect.decorate(decorators,target,key,desc);else for(var i=decorators.length-1;i>=0;i--)if(d=decorators[i])r=(c<3?d(r):c>3?d(target,key,r):d(target,key))||r;return c>3&&r&&Object.defineProperty(target,key,r),r};import{currentUserId,DATABASE_TRANSACTION_SERVICE,DomainError,Metadata,Service}from"@elysiumjs/core";import{UnitOfWork}from"@elysiumjs/mnemosyne";import Value from"typebox/value";var canonical=(value)=>{if(typeof value==="bigint")return value.toString();if(Array.isArray(value))return value.map(canonical);if(value instanceof Date)return value.toISOString();if(value!==null&&typeof value==="object")return Object.fromEntries(Object.keys(value).sort().map((key)=>[key,canonical(value[key])]));return value},requestHash=async(input)=>{let bytes=new TextEncoder().encode(JSON.stringify(canonical(input))??"null"),digest=await crypto.subtle.digest("SHA-256",bytes);return[...new Uint8Array(digest)].map((byte)=>byte.toString(16).padStart(2,"0")).join("")};import{Module}from"@elysiumjs/core";var build=(option)=>typeof option==="function"?option():option,definitions=(config,global)=>{let{idempotency,outbox,inbox,lock,...rest}=config,stores=[[MOIRAI_IDEMPOTENCY_STORE2,idempotency],[MOIRAI_OUTBOX_STORE2,outbox],[MOIRAI_INBOX_STORE2,inbox],[MOIRAI_ACTION_LOCK2,lock]];return[...global?[{name:MOIRAI_OPTIONS2,global,factory:()=>({...DEFAULT_OPTIONS,...rest})}]:Object.keys(rest).length>0?[{name:MOIRAI_MODULE_OPTIONS2,global,factory:()=>({...rest})}]:[],...stores.filter(([,option])=>option!==void 0).map(([name,option])=>({name,global,factory:()=>build(option)}))]},moduleStores=(config)=>definitions(config,!1);class MoiraiModule extends Module.configurable(){}MoiraiModule=__legacyDecorateClassTS([Module.register({services:(config)=>definitions(config,!0)})],MoiraiModule);var ACTION=Symbol.for("elysium:moirai:action"),QUERY=Symbol.for("elysium:moirai:query");class Action{static register(props){return(target)=>{Metadata.define(ACTION,{...props,name:props.name??target.name},target)}}}class Query{static register(props){return(target)=>{Metadata.define(QUERY,{...props,name:props.name??target.name},target)}}}var instanceOf=(target)=>Service.get(target)??Service.make(target),validate=(schema,raw,name)=>{let value=Value.Default(schema,structuredClone(raw)),errors=[...Value.Errors(schema,value)];if(errors.length>0)throw new InvalidInputError2(name,errors.map((error)=>({pointer:`/${error.instancePath?.replace(/^\//,"")??""}`,message:error.message})));return value},unwrap=(result)=>{if(result instanceof DomainError)throw result;return result},settle=async(call)=>{try{return await call()}catch(error){if(error instanceof DomainError)return error;throw error}},Moirai;((Moirai)=>{Moirai.execute=(action,input,call={})=>settle(()=>{let props=Metadata.get(ACTION,action);if(!props)throw TypeError(`${action.name} is not marked with @Action.register().`);return inOwnerModule(action,()=>run(action,props,input,call))}),Moirai.stores=(stores)=>moduleStores(stores);let run=async(action,props,input,call)=>{let{name,idempotent=!1,transactional=!0,retry=!0}=props,config=options(),value=validate(props.input,input,name);if(props.authorize&&!await props.authorize(value))throw new CallForbiddenError2(name);let key=call.idempotencyKey;if(idempotent&&!key)throw new IdempotencyKeyRequiredError2(name);let storedKey=idempotent?[call.scope??props.scope?.(value)??currentUserId()??"anonymous",name,key].map(encodeURIComponent).join(":"):void 0,body=async(attempt)=>{let release=props.serializeBy?await actionLock().lock(props.serializeBy(value)):void 0;try{let handler=instanceOf(action),context={name,idempotencyKey:key,attempt};if(!idempotent)return unwrap(await handler.handle(value,context));let store=idempotencyStore(),hash=await requestHash(value),seen=await store.get(storedKey);if(seen){if(seen.action===name&&seen.requestHash===hash)return seen.response;throw new IdempotencyKeyReusedError2(key)}let response=unwrap(await handler.handle(value,context));return await store.put({key:storedKey,action:name,requestHash:hash,response:response===void 0?null:JSON.parse(JSON.stringify(response)),createdAt:new Date}),response}finally{release?.()}},transaction=transactional&&Service.exists(DATABASE_TRANSACTION_SERVICE);if(transaction&&UnitOfWork.active())return body(1);for(let attempt=1;;attempt++)try{return transaction?await UnitOfWork.run(()=>body(attempt),{connection:props.connection}):await body(attempt)}catch(error){let policy=typeof retry==="object"?retry:{},attempts=retry===!1?1:policy.attempts??config.maxAttempts,transient=policy.isTransient??config.isTransient;if(!(attempt<attempts&&transient(error)))throw error}};Moirai.ask=(query,input)=>settle(async()=>{let props=Metadata.get(QUERY,query);if(!props)throw TypeError(`${query.name} is not marked with @Query.register().`);let value=validate(props.input,input,props.name);if(props.authorize&&!await props.authorize(value))throw new CallForbiddenError2(props.name);return instanceOf(query).handle(value,{name:props.name,attempt:1})})})(Moirai||={});import{Service as Service2}from"@elysiumjs/core";var MOIRAI_EVENT_EFFECT="moirai.event",CONSUMERS=new Map;registerEffect2(MOIRAI_EVENT_EFFECT,async(payload,row)=>{let delivery=payload,handler=CONSUMERS.get(delivery.consumer);if(!handler)throw new UnknownEventConsumerError2(delivery.consumer,delivery.event);await inOwnerModule(handler.owner,()=>Inbox2.once({messageId:delivery.id,consumer:delivery.consumer},async()=>{await handler.run(delivery.payload,{id:delivery.id,event:delivery.event,publishedAt:new Date(delivery.publishedAt),attempt:row.attempts+1})}))},{attempts:(row)=>CONSUMERS.get(row.payload?.consumer??"")?.attempts});var Event;((Event)=>(Event.on=(event,options={})=>(target,method,_descriptor)=>{let isStatic=typeof target==="function",owner=isStatic?target:target.constructor,consumer=options.consumer??`${owner.name}.${String(method)}`;if(CONSUMERS.has(consumer))throw new DuplicateEventConsumerError2(consumer);let{retry}=options;CONSUMERS.set(consumer,{event,owner,attempts:retry===!1?1:retry?.attempts,run:(payload,meta)=>(isStatic?owner:Service2.get(owner)??Service2.make(owner))[method](payload,meta)})},Event.publish=async(event,payload)=>{let publishedAt=new Date,id=uuidv72(publishedAt.getTime()),deliveries=[...CONSUMERS].filter(([,handler])=>handler.event===event).map(([consumer])=>({kind:MOIRAI_EVENT_EFFECT,payload:{id,event,consumer,payload,publishedAt:publishedAt.toISOString()}}));return await Outbox2.enqueue(...deliveries),id},Event.consumersOf=(event)=>[...CONSUMERS].filter(([,handler])=>handler.event===event).map(([consumer])=>consumer)))(Event||={});import{UnitOfWork as UnitOfWork2}from"@elysiumjs/mnemosyne";class MemoryIdempotencyStore{#records=new Map;async get(key){let record=this.#records.get(key);return record?structuredClone(record):void 0}async put(record){if(this.#records.has(record.key))throw new IdempotencyConflictError2(record.key);this.#records.set(record.key,structuredClone(record))}}class MemoryActionLock{#tails=new Map;async lock(key){let previous=this.#tails.get(key)??Promise.resolve(),release,current=new Promise((resolve)=>release=resolve),tail=previous.then(()=>current);return this.#tails.set(key,tail),await previous,()=>{if(release(),this.#tails.get(key)===tail)this.#tails.delete(key)}}}class MemoryOutboxStore{#rows=new Map;get rows(){return[...this.#rows.values()].map((row)=>({...row}))}async insert(rows){for(let row of rows)this.#rows.set(row.id,{...row});UnitOfWork2.afterRollback(()=>{for(let row of rows)this.#rows.delete(row.id)})}async claimDue(claim){let{now,leaseUntil,limit,kinds,ids}=claim;if(kinds?.length===0||ids?.length===0)return[];let due=[...this.#rows.values()].filter((row)=>row.dispatchedAt===null&&row.deadAt===null&&row.availableAt.getTime()<=now.getTime()&&(!kinds||kinds.includes(row.kind))&&(!ids||ids.includes(row.id))).sort((a,b)=>a.availableAt.getTime()-b.availableAt.getTime()).slice(0,limit);for(let row of due)this.#rows.set(row.id,{...row,availableAt:leaseUntil});return due.map((row)=>({...row,availableAt:leaseUntil}))}async markDispatched(id,dispatchedAt){this.#update(id,{dispatchedAt})}async markFailed(id,update){this.#update(id,update)}async markDead(id,update){this.#update(id,update)}#update(id,update){let row=this.#rows.get(id);if(row)this.#rows.set(id,{...row,...update})}}class MemoryInboxStore{#seen=new Set;async record(messageId,consumer){let key=`${consumer}\x00${messageId}`;if(this.#seen.has(key))return!1;return this.#seen.add(key),UnitOfWork2.afterRollback(()=>void this.#seen.delete(key)),!0}}export{Action,CallForbiddenError2 as CallForbiddenError,DuplicateEventConsumerError2 as DuplicateEventConsumerError,Event,IdempotencyConflictError2 as IdempotencyConflictError,IdempotencyKeyRequiredError2 as IdempotencyKeyRequiredError,IdempotencyKeyReusedError2 as IdempotencyKeyReusedError,Inbox2 as Inbox,InvalidInputError2 as InvalidInputError,MOIRAI_ACTION_LOCK2 as MOIRAI_ACTION_LOCK,MOIRAI_EVENT_EFFECT,MOIRAI_IDEMPOTENCY_STORE2 as MOIRAI_IDEMPOTENCY_STORE,MOIRAI_INBOX_STORE2 as MOIRAI_INBOX_STORE,MOIRAI_MODULE_OPTIONS2 as MOIRAI_MODULE_OPTIONS,MOIRAI_OPTIONS2 as MOIRAI_OPTIONS,MOIRAI_OUTBOX_STORE2 as MOIRAI_OUTBOX_STORE,MemoryActionLock,MemoryIdempotencyStore,MemoryInboxStore,MemoryOutboxStore,MissingStoreError2 as MissingStoreError,Moirai,MoiraiModule,Outbox2 as Outbox,Query,UnknownEffectError2 as UnknownEffectError,UnknownEventConsumerError2 as UnknownEventConsumerError,backoffMs2 as backoffMs,effectHandler2 as effectHandler,isTransientError2 as isTransientError,registerEffect2 as registerEffect,requestHash,uuidv72 as uuidv7};

package/dist/moirai.module.d.ts

@@ -0,0 +1,55 @@
+import type { ServiceDefinition } from '@elysiumjs/core';
+import type { MoiraiOptions } from './config';
+import type { ActionLock, IdempotencyStore, InboxStore, OutboxStore } from './stores';
+type StoreOption<T> = T | (() => T);
+/**
+ * Stores, each an instance or a function that builds it once, and options.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export type MoiraiStores = Partial<MoiraiOptions> & {
+    idempotency?: StoreOption<IdempotencyStore>;
+    outbox?: StoreOption<OutboxStore>;
+    inbox?: StoreOption<InboxStore>;
+    lock?: StoreOption<ActionLock>;
+};
+/**
+ * The configuration of {@link MoiraiModule}: the stores of the application and the options.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export type MoiraiModuleConfig = MoiraiStores;
+/** @internal The services of `Moirai.stores()`: private to the module that lists them. */
+export declare const moduleStores: (config: MoiraiStores) => ServiceDefinition[];
+declare const MoiraiModule_base: (abstract new () => {
+    readonly config: MoiraiStores;
+    onInit(): Promise<void> | void;
+    onDestroy(): Promise<void> | void;
+    onServe(_app: import("elysia").Elysia<any>): Promise<void> | void;
+}) & {
+    readonly config: string;
+    with(config: Partial<MoiraiStores> | (() => Partial<MoiraiStores> | Promise<Partial<MoiraiStores>>)): import("@elysiumjs/core").ConfiguredModule<MoiraiStores>;
+    resolveConfig(input?: Partial<MoiraiStores> | undefined): MoiraiStores;
+    register<TConfig_1 = any>(props?: import("@elysiumjs/core").ModuleProps<TConfig_1>): (target: import("@elysiumjs/core").ModuleClass) => void;
+    configurable<TConfig extends object>(options?: {
+        defaults?: Partial<TConfig>;
+        required?: (keyof TConfig)[];
+    }): any;
+};
+/**
+ * Provides the moirai stores and options of the application as global services. Set the stores
+ * the app uses: the memory ones (`MemoryIdempotencyStore`, ...) for tests, the Postgres ones of
+ * `@elysiumjs/moirai-drizzle` in production. A module that needs stores of its own, such as the
+ * outbox and inbox tables of a domain, lists them with `Moirai.stores()` in its services.
+ * @author Axel Nana <axel.nana@workbud.com>
+ * @example
+ * ```ts
+ * MoiraiModule.with({
+ * 	idempotency: () => new DrizzleIdempotencyStore({ table: tables.idempotencyKeys }),
+ * 	outbox: () => new DrizzleOutboxStore({ table: tables.outbox }),
+ * 	inbox: () => new DrizzleInboxStore({ table: tables.inbox }),
+ * 	lock: () => new PgAdvisoryLock()
+ * });
+ * ```
+ */
+export declare class MoiraiModule extends MoiraiModule_base {
+}
+export {};

package/dist/outbox.d.ts

@@ -0,0 +1,100 @@
+import type { OutboxEffect, OutboxRow } from './stores';
+type EffectHandler = (payload: unknown, row: OutboxRow) => unknown;
+/** The handler of a kind of effect, if any. */
+export declare const effectHandler: (kind: string) => EffectHandler | undefined;
+/**
+ * Registers the handler of a kind of effect with a function, for packages that ship effects.
+ * @author Axel Nana <axel.nana@workbud.com>
+ * @param kind The kind of effect.
+ * @param handler Gets the payload and the row; throwing retries the row later.
+ * @param policy `attempts` gives the attempts of a row, when they differ from `maxRelayAttempts`.
+ */
+export declare const registerEffect: (kind: string, handler: EffectHandler, policy?: {
+    attempts?: (row: OutboxRow) => number | undefined;
+}) => void;
+/**
+ * The delay before the next attempt of an outbox row: 5 s, 10 s, 20 s, ... up to 1 h.
+ * @author Axel Nana <axel.nana@workbud.com>
+ * @param attempts The failed attempts so far.
+ */
+export declare const backoffMs: (attempts: number) => number;
+/**
+ * What one relay did.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export type RelaySummary = {
+    dispatched: number;
+    retried: number;
+    dead: number;
+};
+/**
+ * Narrows and sizes one relay.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export type RelayOptions = {
+    /** Relay only the rows of these kinds. */
+    kinds?: readonly string[];
+    /** Relay only these rows, such as the ones an action just committed. */
+    ids?: readonly string[];
+    /** The rows claimed at once. Defaults to the `relayBatch` option. */
+    batch?: number;
+    /**
+     * The module whose outbox relays: the one it lists with `Moirai.stores()`. Defaults to the
+     * outbox of the current module, else the one of `MoiraiModule`.
+     */
+    module?: abstract new (...args: any[]) => unknown;
+};
+export declare namespace Outbox {
+    /**
+     * Marks a service method as the handler of the outbox rows of a kind. The method gets the
+     * payload and the row; throwing retries the row later.
+     * @author Axel Nana <axel.nana@workbud.com>
+     * @param kind The kind of effect.
+     */
+    const handle: (kind: string) => MethodDecorator;
+    /**
+     * Writes effects to the outbox of the current module, in the open unit of work: they happen if
+     * and only if it commits. Once it has, the effects relay (see the `relayOnCommit` option).
+     * @author Axel Nana <axel.nana@workbud.com>
+     * @param effects The effects.
+     * @returns The ids of the rows, in order.
+     */
+    const enqueue: (...effects: OutboxEffect[]) => Promise<string[]>;
+    /**
+     * Runs the due rows of an outbox through their `@Outbox.handle()` handlers, in the module of
+     * that outbox. A row that fails
+     * is retried later with an exponential backoff, and is dead after `maxRelayAttempts`. Delivery
+     * is at least once, so handlers must tolerate a repeat.
+     *
+     * The claim, each row (its handler and its mark) and each failure run in units of work of their
+     * own, so a handler whose statement fails rolls back alone and its failure is still recorded.
+     * Call it outside a unit of work.
+     * @author Axel Nana <axel.nana@workbud.com>
+     * @param relayOptions The rows to relay.
+     */
+    const relay: (relayOptions?: RelayOptions) => Promise<RelaySummary>;
+    /**
+     * Relays every due row, batch after batch, such as from a cron trigger. Stops when a batch
+     * dispatches nothing. With `module`, it relays the outbox of that module; without it, the
+     * outbox of `MoiraiModule` and the one of each module that lists its own with
+     * `Moirai.stores()`.
+     * @author Axel Nana <axel.nana@workbud.com>
+     * @param relayOptions The kinds to relay, the batch size and the module.
+     */
+    const sweep: (relayOptions?: Omit<RelayOptions, 'ids'>) => Promise<RelaySummary>;
+}
+export declare namespace Inbox {
+    /**
+     * Runs work unless this consumer already processed the message, as recorded in the inbox of the
+     * current module. Call it in the consumer's unit of work, so that a failure rolls the record back and the redelivery runs the work again.
+     * @author Axel Nana <axel.nana@workbud.com>
+     * @param message The id of the message and the name of the consumer.
+     * @param work The work.
+     * @returns Whether the work ran.
+     */
+    const once: (message: {
+        messageId: string;
+        consumer: string;
+    }, work: () => Promise<void> | void) => Promise<boolean>;
+}
+export {};