@warlock.js/core 4.0.174 → 4.1.3

package/esm/use-cases/types.d.mts

@@ -0,0 +1,306 @@
+import { BenchmarkOptions } from "../benchmark/types.mjs";
+import { Infer, ObjectValidator } from "@warlock.js/seal";
+import { RetryOptions } from "@mongez/reinforcements";
+
+//#region ../../@warlock.js/core/src/use-cases/types.d.ts
+/**
+ * Shared context object passed through the entire use case pipeline.
+ * Contains the optional schema and can be enriched by guards/middleware
+ * with arbitrary data (e.g., currentUser, permissions, request metadata).
+ */
+type UseCaseContext = {
+  schema?: ObjectValidator;
+} & Record<string, any>;
+/**
+ * Guard function that runs **before** schema validation.
+ *
+ * Guards are authorization/precondition checks. They receive a read-only
+ * view of the input data and can enrich the context, but **must not** mutate
+ * the input. Throw an error to abort the entire pipeline.
+ *
+ * @example
+ * ```ts
+ * const authGuard: UseCaseGuard<LoginInput> = async (data, ctx) => {
+ *   const user = await getSession(ctx.token);
+ *   if (!user) throw new UnauthorizedError();
+ *   ctx.currentUser = user;
+ * };
+ * ```
+ *
+ * @template Input - The shape of the use case input data
+ * @template Ctx - The shape of the shared context
+ */
+type UseCaseGuard<Input, Ctx extends UseCaseContext = UseCaseContext> = (data: Readonly<Input>, ctx: Ctx) => void | Promise<void>;
+/**
+ * Before middleware that runs **after** schema validation.
+ *
+ * Receives validated data and must return the (optionally transformed) data.
+ * Multiple before middlewares form a chain: output of one becomes input of next.
+ *
+ * @example
+ * ```ts
+ * const normalizeEmail: UseCaseBeforeMiddleware<SignupInput> = async (data) => {
+ *   return { ...data, email: data.email.toLowerCase().trim() };
+ * };
+ * ```
+ *
+ * @template Input - The shape of the use case input data
+ * @template Ctx - The shape of the shared context
+ */
+type UseCaseBeforeMiddleware<Input, Ctx extends UseCaseContext = UseCaseContext> = (data: Input, ctx: Ctx) => Input | Promise<Input>;
+/**
+ * After middleware that runs **after** the handler succeeds.
+ *
+ * Fire-and-forget side effects: errors are caught and logged, never thrown.
+ * Does **not** affect the returned output. Use for analytics, notifications,
+ * cache invalidation, webhooks, etc.
+ *
+ * @example
+ * ```ts
+ * const notifySlack: UseCaseAfterMiddleware<OrderOutput> = async (output) => {
+ *   await slack.send(`New order #${output.orderId} placed`);
+ * };
+ * ```
+ *
+ * @template Output - The shape of the use case output data
+ * @template Ctx - The shape of the shared context
+ */
+type UseCaseAfterMiddleware<Output, Ctx extends UseCaseContext = UseCaseContext> = (output: Output, ctx: Ctx) => void | Promise<void>;
+/**
+ * Context passed to `onExecuting` lifecycle event callbacks.
+ * Fired at the start of each use case execution, before guards run.
+ */
+type UseCaseOnExecutingContext = {
+  /** The shared pipeline context */ctx: UseCaseContext; /** Unique execution ID */
+  id: string; /** Use case name */
+  name: string; /** Raw input data */
+  data: any; /** Schema validator (if defined) */
+  schema?: ObjectValidator; /** Timestamp when execution started */
+  startedAt: Date;
+};
+/**
+ * A broadcastable event emitted on successful completion.
+ *
+ * An envelope (not the bare payload) so consumers get a correlation `id` for
+ * tracing/idempotency under at-least-once delivery.
+ */
+type UseCaseBroadcastEvent = {
+  /** Use case name */useCase: string; /** Channel/event name — defaults to the use case name */
+  event: string; /** Execution id (correlation / idempotency) */
+  id: string; /** Emission timestamp */
+  at: Date; /** The output as-is, or the projected shape from `broadcast.output` */
+  payload: unknown;
+};
+/**
+ * Transport-neutral broadcast sink. Implemented by adapters (e.g. `heraldBroadcast`
+ * from `@warlock.js/herald`) and registered globally via use-cases config.
+ *
+ * The use case only declares **what** to broadcast; the registered channels decide
+ * **how** (which broker, transport, etc.).
+ *
+ * @example
+ * ```ts
+ * // src/config/use-cases.ts
+ * broadcast: { enabled: true, channels: [heraldBroadcast({ broker: "default" })] }
+ * ```
+ */
+interface UseCaseBroadcastChannel {
+  broadcast(event: UseCaseBroadcastEvent): void | Promise<void>;
+}
+/**
+ * Per-use-case broadcast declaration — **what** to broadcast, no transport knobs.
+ * `true` broadcasts the output as-is on the channel named after the use case.
+ *
+ * @template Output - The shape of the handler's return value
+ */
+type UseCaseBroadcastOption<Output> = boolean | {
+  /** Channel/event name; defaults to the use case name */event?: string; /** Project the payload before broadcasting (e.g. strip sensitive fields) */
+  output?: (output: Output, result: UseCaseResult<Output>) => unknown;
+};
+/**
+ * Use case definition.
+ *
+ * Defines the full execution pipeline: guards → validation → before → handler → after.
+ * All fields except `name` and `handler` are optional.
+ *
+ * @example
+ * ```ts
+ * const createOrder = useCase<OrderOutput, OrderInput>({
+ *   name: "create_order",
+ *   description: "Create a new order",
+ *   guards: [authGuard],
+ *   schema: createOrderSchema,
+ *   before: [enrichWithPricing],
+ *   handler: async (data, ctx) => orderService.create(data, ctx.currentUser),
+ *   after: [sendConfirmationEmail],
+ *   retry: { attempts: 3, delay: 500, backoff: "exponential" },
+ *   benchmark: true,
+ *   broadcast: true,
+ * });
+ * ```
+ *
+ * @template Output - The shape of the handler's return value
+ * @template Input - The shape of the input data (before transformation)
+ * @template Ctx - The shape of the shared context
+ */
+type UseCase<Output = any, Input = any, Ctx extends UseCaseContext = UseCaseContext> = {
+  /** Unique use case identifier, used for registration, logging, and cache keys */name: string; /** Human-readable description, surfaced in the registry and observability */
+  description?: string; /** Core business logic handler. Receives validated + transformed data and context */
+  handler: (data: Input, ctx: Ctx) => Promise<Output>; /** Optional schema validator (from @warlock.js/seal). Runs after guards */
+  schema?: ObjectValidator; /** Guards to run before validation. Sequential, can enrich ctx, cannot mutate data */
+  guards?: UseCaseGuard<Input, Ctx>[]; /** Before middleware to run after validation. Sequential, can transform data */
+  before?: UseCaseBeforeMiddleware<Input, Ctx>[]; /** After middleware to run on success. Fire-and-forget, errors are logged not thrown */
+  after?: UseCaseAfterMiddleware<Output, Ctx>[]; /** Lifecycle callback: fires when execution starts (before guards) */
+  onExecuting?: (ctx: UseCaseOnExecutingContext) => void; /** Lifecycle callback: fires on successful completion with full result snapshot */
+  onCompleted?: (result: UseCaseResult<Output>) => void; /** Lifecycle callback: fires on error with error details and execution context */
+  onError?: (ctx: UseCaseErrorResult) => void;
+  /**
+   * Retry configuration (from `@mongez/reinforcements`). When set, the **handler**
+   * is retried on failure. Opt-in — omitted means the handler runs exactly once.
+   */
+  retry?: RetryOptions;
+  /**
+   * Benchmark the handler. `true` uses global config defaults, an object customizes
+   * thresholds/hooks, `false` disables. Measures the handler only — not the prelude.
+   */
+  benchmark?: boolean | BenchmarkOptions;
+  /**
+   * Broadcast the result on success through the globally-configured channels.
+   * `true` sends the output as-is; an object can rename the event and project the payload.
+   */
+  broadcast?: UseCaseBroadcastOption<Output>;
+};
+/**
+ * Use case definition whose `Input` is inferred from a **required** schema.
+ * Backs the inference overload of `useCase()` so callers skip the manual generic.
+ *
+ * @template Output - The shape of the handler's return value
+ * @template Schema - The schema validator the input is inferred from
+ * @template Ctx - The shape of the shared context
+ */
+type UseCaseWithSchema<Output, Schema extends ObjectValidator, Ctx extends UseCaseContext = UseCaseContext> = Omit<UseCase<Output, Infer<Schema>, Ctx>, "schema"> & {
+  schema: Schema;
+};
+/**
+ * The executable returned by `useCase()`. Call it with the input data and optional
+ * runtime options; `$cleanup` unregisters the use case and drops its history.
+ *
+ * @template Output - The shape of the handler's return value
+ * @template Input - The shape of the input data
+ */
+type UseCaseHandler<Output, Input> = ((data: Input, options?: UseCaseRuntimeOptions<Output>) => Promise<Output>) & {
+  $cleanup: () => void;
+};
+/**
+ * A registered use case with call tracking metadata.
+ * Created internally when a use case is registered via `useCase()`.
+ */
+type RegisteredUseCase<Output = any, Input = any> = UseCase<Output, Input> & {
+  /** Execution call counters */calls: {
+    /** Number of successful executions */success: number; /** Number of failed executions */
+    failed: number; /** Total executions (success + failed) */
+    total: number;
+  };
+};
+/**
+ * Runtime options passed at invocation time (second argument to the executor).
+ * These override or supplement the use case definition for a single execution.
+ *
+ * @example
+ * ```ts
+ * await createOrder(orderData, {
+ *   id: "order-123",
+ *   ctx: { currentUser },
+ *   onCompleted: (result) => console.log("Order created:", result.output),
+ * });
+ * ```
+ *
+ * @template Output - The shape of the use case output data
+ */
+type UseCaseRuntimeOptions<Output = any> = {
+  /** Override the auto-generated execution ID */id?: string; /** Provide a pre-populated context object */
+  ctx?: UseCaseContext; /** Invocation-level lifecycle callback: fires first, before use case and global */
+  onExecuting?: (ctx: UseCaseOnExecutingContext) => void; /** Invocation-level lifecycle callback: fires first on success */
+  onCompleted?: (result: UseCaseResult<Output>) => void; /** Invocation-level lifecycle callback: fires first on error */
+  onError?: (ctx: UseCaseErrorResult) => void;
+};
+/**
+ * Error result snapshot, emitted via `onError` lifecycle callbacks.
+ * Contains all fields from `UseCaseResult` except `output`, plus the thrown error.
+ */
+type UseCaseErrorResult = Omit<UseCaseResult, "output"> & {
+  /** The error that caused the failure */error: Error;
+};
+/**
+ * Success result snapshot, emitted via `onCompleted` lifecycle callbacks
+ * and stored in execution history cache.
+ *
+ * @template Output - The shape of the handler's return value
+ */
+type UseCaseResult<Output = any> = {
+  /** Handler return value (undefined if execution failed) */output?: Output; /** The pipeline context at time of completion */
+  ctx: UseCaseContext; /** Timestamp when execution started */
+  startedAt: Date; /** Timestamp when execution ended */
+  endedAt: Date; /** Unique execution ID */
+  id: string; /** Use case name */
+  name: string; /** Success or failed call count at time of completion (matches the outcome) */
+  calls: number; /** Retry state (present only if retry was configured) */
+  retries?: {
+    /** Total allowed attempts (initial try + retries) */attempts: number; /** Delay between attempts in ms */
+    delay?: number; /** Actual retry attempts performed (0 = succeeded on first try) */
+    currentRetry: number;
+  }; /** Benchmark result (present only if benchmark was enabled) */
+  benchmarkResult?: {
+    /** Execution time in milliseconds */latency: number; /** Performance classification */
+    state: "poor" | "good" | "excellent";
+  };
+};
+/**
+ * Internal registry of global lifecycle event callback arrays.
+ * Used by `globalUseCasesEvents` to manage subscriptions.
+ */
+type UseCaseEventsCallbacksMap = {
+  onExecuting: ((ctx: UseCaseOnExecutingContext) => void)[];
+  onCompleted: ((result: UseCaseResult<any>) => void)[];
+  onError: ((ctx: UseCaseErrorResult) => void)[];
+};
+/**
+ * App-level configuration for use cases, resolved via `config.get("use-cases")`.
+ * Provides default values that can be overridden per use case.
+ *
+ * @example
+ * ```ts
+ * // src/config/use-cases.ts
+ * export default {
+ *   benchmark: true,
+ *   log: false,
+ *   history: { enabled: true, ttl: 3600, maxEntries: 100 },
+ *   broadcast: { enabled: true, channels: [heraldBroadcast()] },
+ * } satisfies UseCaseConfigurations;
+ * ```
+ */
+type UseCaseConfigurations = {
+  /**
+   * Default retry for all use cases (from `@mongez/reinforcements`).
+   * When set, every use case retries its handler unless it overrides `retry`.
+   */
+  retry?: RetryOptions;
+  /**
+   * Default benchmark setting for all use cases.
+   * For standalone benchmark usage, use `config.get("benchmark")` instead.
+   */
+  benchmark?: boolean | BenchmarkOptions; /** Broadcast transport — registered channels plus a global kill-switch */
+  broadcast?: {
+    /** Global on/off — `false` disables broadcasting for every use case */enabled?: boolean; /** Channels every broadcast fans out to */
+    channels?: UseCaseBroadcastChannel[];
+  }; /** Per-step debug logging through `@warlock.js/logger` (default: false) */
+  log?: boolean; /** Execution history cache settings */
+  history?: {
+    /** Enable/disable history storage (default: true) */enabled?: boolean; /** Cache TTL in seconds (default: 3600). `false` uses the cache driver default */
+    ttl?: number | false; /** Max history entries kept per use case before oldest are evicted (default: 100) */
+    maxEntries?: number;
+  };
+};
+//#endregion
+export { RegisteredUseCase, UseCase, UseCaseAfterMiddleware, UseCaseBeforeMiddleware, UseCaseBroadcastChannel, UseCaseBroadcastEvent, UseCaseBroadcastOption, UseCaseConfigurations, UseCaseContext, UseCaseErrorResult, UseCaseEventsCallbacksMap, UseCaseGuard, UseCaseHandler, UseCaseOnExecutingContext, UseCaseResult, UseCaseRuntimeOptions, UseCaseWithSchema };
+//# sourceMappingURL=types.d.mts.map

package/esm/use-cases/types.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.mts","names":[],"sources":["../../../../../../@warlock.js/core/src/use-cases/types.ts"],"mappings":"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"}

package/esm/use-cases/use-case-broadcast.d.mts

@@ -0,0 +1,24 @@
+import { UseCaseBroadcastOption, UseCaseConfigurations, UseCaseResult } from "./types.mjs";
+
+//#region ../../@warlock.js/core/src/use-cases/use-case-broadcast.d.ts
+/**
+ * Broadcast a successful use-case result through the globally-configured channels.
+ *
+ * Fires only when the use case opted in (`broadcast`) and the global transport is
+ * enabled with at least one channel. Fan-out is isolated via `Promise.allSettled` —
+ * a failing channel is logged and never affects the use case or sibling channels.
+ *
+ * @example
+ * await broadcastUseCaseResult({ name, id, output, result, broadcast, config });
+ */
+declare function broadcastUseCaseResult<Output>(params: {
+  name: string;
+  id: string;
+  output: Output;
+  result: UseCaseResult<Output>;
+  broadcast?: UseCaseBroadcastOption<Output>;
+  config?: UseCaseConfigurations["broadcast"];
+}): Promise<void>;
+//#endregion
+export { broadcastUseCaseResult };
+//# sourceMappingURL=use-case-broadcast.d.mts.map

package/esm/use-cases/use-case-broadcast.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-case-broadcast.d.mts","names":[],"sources":["../../../../../../@warlock.js/core/src/use-cases/use-case-broadcast.ts"],"mappings":";;;;;AAkBA;;;;;;;;iBAAsB,sBAAA,QAAA,CAA+B,MAAA;EACnD,IAAA;EACA,EAAA;EACA,MAAA,EAAQ,MAAA;EACR,MAAA,EAAQ,aAAA,CAAc,MAAA;EACtB,SAAA,GAAY,sBAAA,CAAuB,MAAA;EACnC,MAAA,GAAS,qBAAA;AAAA,IACP,OAAA"}

package/esm/use-cases/use-case-broadcast.mjs

@@ -0,0 +1,36 @@
+import { log } from "@warlock.js/logger";
+
+//#region ../../@warlock.js/core/src/use-cases/use-case-broadcast.ts
+/**
+* Broadcast a successful use-case result through the globally-configured channels.
+*
+* Fires only when the use case opted in (`broadcast`) and the global transport is
+* enabled with at least one channel. Fan-out is isolated via `Promise.allSettled` —
+* a failing channel is logged and never affects the use case or sibling channels.
+*
+* @example
+* await broadcastUseCaseResult({ name, id, output, result, broadcast, config });
+*/
+async function broadcastUseCaseResult(params) {
+	const { name, id, output, result, broadcast, config } = params;
+	if (!broadcast) return;
+	if (config?.enabled === false) return;
+	const channels = config?.channels;
+	if (!channels || channels.length === 0) return;
+	const projector = typeof broadcast === "object" ? broadcast.output : void 0;
+	const event = typeof broadcast === "object" && broadcast.event ? broadcast.event : name;
+	const payload = projector ? projector(output, result) : output;
+	const broadcastEvent = {
+		useCase: name,
+		event,
+		id,
+		at: /* @__PURE__ */ new Date(),
+		payload
+	};
+	const outcomes = await Promise.allSettled(channels.map((channel) => channel.broadcast(broadcastEvent)));
+	for (const outcome of outcomes) if (outcome.status === "rejected") log.error("use-cases", name, "broadcast channel failed", { error: outcome.reason });
+}
+
+//#endregion
+export { broadcastUseCaseResult };
+//# sourceMappingURL=use-case-broadcast.mjs.map

package/esm/use-cases/use-case-broadcast.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-case-broadcast.mjs","names":[],"sources":["../../../../../../@warlock.js/core/src/use-cases/use-case-broadcast.ts"],"sourcesContent":["import { log } from \"@warlock.js/logger\";\nimport type {\n  UseCaseBroadcastEvent,\n  UseCaseBroadcastOption,\n  UseCaseConfigurations,\n  UseCaseResult,\n} from \"./types\";\n\n/**\n * Broadcast a successful use-case result through the globally-configured channels.\n *\n * Fires only when the use case opted in (`broadcast`) and the global transport is\n * enabled with at least one channel. Fan-out is isolated via `Promise.allSettled` —\n * a failing channel is logged and never affects the use case or sibling channels.\n *\n * @example\n * await broadcastUseCaseResult({ name, id, output, result, broadcast, config });\n */\nexport async function broadcastUseCaseResult<Output>(params: {\n  name: string;\n  id: string;\n  output: Output;\n  result: UseCaseResult<Output>;\n  broadcast?: UseCaseBroadcastOption<Output>;\n  config?: UseCaseConfigurations[\"broadcast\"];\n}): Promise<void> {\n  const { name, id, output, result, broadcast, config } = params;\n\n  if (!broadcast) {\n    return;\n  }\n\n  if (config?.enabled === false) {\n    return;\n  }\n\n  const channels = config?.channels;\n\n  if (!channels || channels.length === 0) {\n    return;\n  }\n\n  const projector = typeof broadcast === \"object\" ? broadcast.output : undefined;\n  const event = typeof broadcast === \"object\" && broadcast.event ? broadcast.event : name;\n  const payload = projector ? projector(output, result) : output;\n\n  const broadcastEvent: UseCaseBroadcastEvent = {\n    useCase: name,\n    event,\n    id,\n    at: new Date(),\n    payload,\n  };\n\n  const outcomes = await Promise.allSettled(\n    channels.map((channel) => channel.broadcast(broadcastEvent)),\n  );\n\n  for (const outcome of outcomes) {\n    if (outcome.status === \"rejected\") {\n      log.error(\"use-cases\", name, \"broadcast channel failed\", { error: outcome.reason });\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;AAkBA,eAAsB,uBAA+B,QAOnC;CAChB,MAAM,EAAE,MAAM,IAAI,QAAQ,QAAQ,WAAW,WAAW;CAExD,IAAI,CAAC,WACH;CAGF,IAAI,QAAQ,YAAY,OACtB;CAGF,MAAM,WAAW,QAAQ;CAEzB,IAAI,CAAC,YAAY,SAAS,WAAW,GACnC;CAGF,MAAM,YAAY,OAAO,cAAc,WAAW,UAAU,SAAS;CACrE,MAAM,QAAQ,OAAO,cAAc,YAAY,UAAU,QAAQ,UAAU,QAAQ;CACnF,MAAM,UAAU,YAAY,UAAU,QAAQ,MAAM,IAAI;CAExD,MAAM,iBAAwC;EAC5C,SAAS;EACT;EACA;EACA,oBAAI,IAAI,KAAK;EACb;CACF;CAEA,MAAM,WAAW,MAAM,QAAQ,WAC7B,SAAS,KAAK,YAAY,QAAQ,UAAU,cAAc,CAAC,CAC7D;CAEA,KAAK,MAAM,WAAW,UACpB,IAAI,QAAQ,WAAW,YACrB,IAAI,MAAM,aAAa,MAAM,4BAA4B,EAAE,OAAO,QAAQ,OAAO,CAAC;AAGxF"}

package/esm/use-cases/use-case-events.d.mts

@@ -0,0 +1,40 @@
+import { UseCaseErrorResult, UseCaseEventsCallbacksMap, UseCaseOnExecutingContext, UseCaseResult } from "./types.mjs";
+
+//#region ../../@warlock.js/core/src/use-cases/use-case-events.d.ts
+/**
+ * Global event callbacks — shared across all use case instances.
+ */
+declare const globalEventsCallbacksMap: UseCaseEventsCallbacksMap;
+/**
+ * Subscribe to lifecycle events fired by any use case.
+ *
+ * @example
+ * globalUseCasesEvents.onCompleted((result) => metrics.track(result.name, result.benchmarkResult));
+ * globalUseCasesEvents.onError((ctx) => logger.error(ctx.name, ctx.error));
+ */
+declare const globalUseCasesEvents: {
+  onExecuting(callback: (ctx: UseCaseOnExecutingContext) => void): {
+    unsubscribe: () => void;
+  };
+  onCompleted<Output>(callback: (result: UseCaseResult<Output>) => void): {
+    unsubscribe: () => void;
+  };
+  onError(callback: (ctx: UseCaseErrorResult) => void): {
+    unsubscribe: () => void;
+  };
+};
+/**
+ * Dispatches a lifecycle event to invocation → use-case → global observers, in that order.
+ *
+ * Each observer is awaited sequentially and isolated in its own try/catch — a slow
+ * observer can't stall the others, and a throwing one can't break the pipeline (e.g.
+ * a successful use case must not fail because a metrics/broadcast observer threw).
+ */
+declare function fireLifecycleEvent<EventCtx>(ctx: EventCtx, observers: {
+  invocation?: ((ctx: EventCtx) => void | Promise<void>)[];
+  useCase?: ((ctx: EventCtx) => void | Promise<void>)[];
+  global?: ((ctx: EventCtx) => void | Promise<void>)[];
+}): Promise<void>;
+//#endregion
+export { fireLifecycleEvent, globalEventsCallbacksMap, globalUseCasesEvents };
+//# sourceMappingURL=use-case-events.d.mts.map

package/esm/use-cases/use-case-events.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-case-events.d.mts","names":[],"sources":["../../../../../../@warlock.js/core/src/use-cases/use-case-events.ts"],"mappings":";;;;;AAWA;cAAa,wBAAA,EAA0B,yBAItC;;;AAAA;AASD;;;;cAAa,oBAAA;yBACY,GAAA,EAAK,yBAAA;;;sBASV,QAAA,GAAa,MAAA,EAAQ,aAAA,CAAc,MAAA;;;qBASlC,GAAA,EAAK,kBAAA;;;;;;;;;;;iBAkBJ,kBAAA,UAAA,CACpB,GAAA,EAAK,QAAA,EACL,SAAA;EACE,UAAA,KAAe,GAAA,EAAK,QAAA,YAAoB,OAAA;EACxC,OAAA,KAAY,GAAA,EAAK,QAAA,YAAoB,OAAA;EACrC,MAAA,KAAW,GAAA,EAAK,QAAA,YAAoB,OAAA;AAAA,IACrC,OAAA"}

package/esm/use-cases/use-case-events.mjs

@@ -0,0 +1,67 @@
+import { log } from "@warlock.js/logger";
+
+//#region ../../@warlock.js/core/src/use-cases/use-case-events.ts
+/**
+* Global event callbacks — shared across all use case instances.
+*/
+const globalEventsCallbacksMap = {
+	onExecuting: [],
+	onCompleted: [],
+	onError: []
+};
+/**
+* Subscribe to lifecycle events fired by any use case.
+*
+* @example
+* globalUseCasesEvents.onCompleted((result) => metrics.track(result.name, result.benchmarkResult));
+* globalUseCasesEvents.onError((ctx) => logger.error(ctx.name, ctx.error));
+*/
+const globalUseCasesEvents = {
+	onExecuting(callback) {
+		globalEventsCallbacksMap.onExecuting.push(callback);
+		return { unsubscribe: () => {
+			const idx = globalEventsCallbacksMap.onExecuting.indexOf(callback);
+			if (idx !== -1) globalEventsCallbacksMap.onExecuting.splice(idx, 1);
+		} };
+	},
+	onCompleted(callback) {
+		globalEventsCallbacksMap.onCompleted.push(callback);
+		return { unsubscribe: () => {
+			const idx = globalEventsCallbacksMap.onCompleted.indexOf(callback);
+			if (idx !== -1) globalEventsCallbacksMap.onCompleted.splice(idx, 1);
+		} };
+	},
+	onError(callback) {
+		globalEventsCallbacksMap.onError.push(callback);
+		return { unsubscribe: () => {
+			const idx = globalEventsCallbacksMap.onError.indexOf(callback);
+			if (idx !== -1) globalEventsCallbacksMap.onError.splice(idx, 1);
+		} };
+	}
+};
+/**
+* Dispatches a lifecycle event to invocation → use-case → global observers, in that order.
+*
+* Each observer is awaited sequentially and isolated in its own try/catch — a slow
+* observer can't stall the others, and a throwing one can't break the pipeline (e.g.
+* a successful use case must not fail because a metrics/broadcast observer threw).
+*/
+async function fireLifecycleEvent(ctx, observers) {
+	const tiers = [
+		observers.invocation,
+		observers.useCase,
+		observers.global
+	];
+	for (const tier of tiers) {
+		if (!tier) continue;
+		for (const observer of tier) try {
+			await observer(ctx);
+		} catch (observerError) {
+			log.error("use-cases", "lifecycle", "observer failed", { error: observerError });
+		}
+	}
+}
+
+//#endregion
+export { fireLifecycleEvent, globalEventsCallbacksMap, globalUseCasesEvents };
+//# sourceMappingURL=use-case-events.mjs.map

package/esm/use-cases/use-case-events.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-case-events.mjs","names":[],"sources":["../../../../../../@warlock.js/core/src/use-cases/use-case-events.ts"],"sourcesContent":["import { log } from \"@warlock.js/logger\";\r\nimport type {\r\n  UseCaseErrorResult,\r\n  UseCaseEventsCallbacksMap,\r\n  UseCaseOnExecutingContext,\r\n  UseCaseResult,\r\n} from \"./types\";\r\n\r\n/**\r\n * Global event callbacks — shared across all use case instances.\r\n */\r\nexport const globalEventsCallbacksMap: UseCaseEventsCallbacksMap = {\r\n  onExecuting: [],\r\n  onCompleted: [],\r\n  onError: [],\r\n};\r\n\r\n/**\r\n * Subscribe to lifecycle events fired by any use case.\r\n *\r\n * @example\r\n * globalUseCasesEvents.onCompleted((result) => metrics.track(result.name, result.benchmarkResult));\r\n * globalUseCasesEvents.onError((ctx) => logger.error(ctx.name, ctx.error));\r\n */\r\nexport const globalUseCasesEvents = {\r\n  onExecuting(callback: (ctx: UseCaseOnExecutingContext) => void) {\r\n    globalEventsCallbacksMap.onExecuting.push(callback);\r\n    return {\r\n      unsubscribe: () => {\r\n        const idx = globalEventsCallbacksMap.onExecuting.indexOf(callback);\r\n        if (idx !== -1) globalEventsCallbacksMap.onExecuting.splice(idx, 1);\r\n      },\r\n    };\r\n  },\r\n  onCompleted<Output>(callback: (result: UseCaseResult<Output>) => void) {\r\n    globalEventsCallbacksMap.onCompleted.push(callback);\r\n    return {\r\n      unsubscribe: () => {\r\n        const idx = globalEventsCallbacksMap.onCompleted.indexOf(callback);\r\n        if (idx !== -1) globalEventsCallbacksMap.onCompleted.splice(idx, 1);\r\n      },\r\n    };\r\n  },\r\n  onError(callback: (ctx: UseCaseErrorResult) => void) {\r\n    globalEventsCallbacksMap.onError.push(callback);\r\n    return {\r\n      unsubscribe: () => {\r\n        const idx = globalEventsCallbacksMap.onError.indexOf(callback);\r\n        if (idx !== -1) globalEventsCallbacksMap.onError.splice(idx, 1);\r\n      },\r\n    };\r\n  },\r\n};\r\n\r\n/**\r\n * Dispatches a lifecycle event to invocation → use-case → global observers, in that order.\r\n *\r\n * Each observer is awaited sequentially and isolated in its own try/catch — a slow\r\n * observer can't stall the others, and a throwing one can't break the pipeline (e.g.\r\n * a successful use case must not fail because a metrics/broadcast observer threw).\r\n */\r\nexport async function fireLifecycleEvent<EventCtx>(\r\n  ctx: EventCtx,\r\n  observers: {\r\n    invocation?: ((ctx: EventCtx) => void | Promise<void>)[];\r\n    useCase?: ((ctx: EventCtx) => void | Promise<void>)[];\r\n    global?: ((ctx: EventCtx) => void | Promise<void>)[];\r\n  },\r\n) {\r\n  const tiers = [observers.invocation, observers.useCase, observers.global];\r\n\r\n  for (const tier of tiers) {\r\n    if (!tier) {\r\n      continue;\r\n    }\r\n\r\n    for (const observer of tier) {\r\n      try {\r\n        await observer(ctx);\r\n      } catch (observerError) {\r\n        log.error(\"use-cases\", \"lifecycle\", \"observer failed\", { error: observerError });\r\n      }\r\n    }\r\n  }\r\n}\r\n"],"mappings":";;;;;;AAWA,MAAa,2BAAsD;CACjE,aAAa,CAAC;CACd,aAAa,CAAC;CACd,SAAS,CAAC;AACZ;;;;;;;;AASA,MAAa,uBAAuB;CAClC,YAAY,UAAoD;EAC9D,yBAAyB,YAAY,KAAK,QAAQ;EAClD,OAAO,EACL,mBAAmB;GACjB,MAAM,MAAM,yBAAyB,YAAY,QAAQ,QAAQ;GACjE,IAAI,QAAQ,IAAI,yBAAyB,YAAY,OAAO,KAAK,CAAC;EACpE,EACF;CACF;CACA,YAAoB,UAAmD;EACrE,yBAAyB,YAAY,KAAK,QAAQ;EAClD,OAAO,EACL,mBAAmB;GACjB,MAAM,MAAM,yBAAyB,YAAY,QAAQ,QAAQ;GACjE,IAAI,QAAQ,IAAI,yBAAyB,YAAY,OAAO,KAAK,CAAC;EACpE,EACF;CACF;CACA,QAAQ,UAA6C;EACnD,yBAAyB,QAAQ,KAAK,QAAQ;EAC9C,OAAO,EACL,mBAAmB;GACjB,MAAM,MAAM,yBAAyB,QAAQ,QAAQ,QAAQ;GAC7D,IAAI,QAAQ,IAAI,yBAAyB,QAAQ,OAAO,KAAK,CAAC;EAChE,EACF;CACF;AACF;;;;;;;;AASA,eAAsB,mBACpB,KACA,WAKA;CACA,MAAM,QAAQ;EAAC,UAAU;EAAY,UAAU;EAAS,UAAU;CAAM;CAExE,KAAK,MAAM,QAAQ,OAAO;EACxB,IAAI,CAAC,MACH;EAGF,KAAK,MAAM,YAAY,MACrB,IAAI;GACF,MAAM,SAAS,GAAG;EACpB,SAAS,eAAe;GACtB,IAAI,MAAM,aAAa,aAAa,mBAAmB,EAAE,OAAO,cAAc,CAAC;EACjF;CAEJ;AACF"}

package/esm/use-cases/use-case-pipeline.d.mts

@@ -0,0 +1,33 @@
+import { UseCaseBeforeMiddleware, UseCaseContext, UseCaseGuard, UseCaseOnExecutingContext } from "./types.mjs";
+import { ObjectValidator } from "@warlock.js/seal";
+
+//#region ../../@warlock.js/core/src/use-cases/use-case-pipeline.d.ts
+type PipelineOptions<Input> = {
+  name: string;
+  id: string;
+  data: Input;
+  ctx: UseCaseContext;
+  startedAt: Date;
+  schema?: ObjectValidator;
+  guards?: UseCaseGuard<Input>[];
+  before?: UseCaseBeforeMiddleware<Input>[]; /** Invocation-level onExecuting override */
+  onExecuting?: (ctx: UseCaseOnExecutingContext) => void; /** Use-case-level onExecuting */
+  ucOnExecuting?: (ctx: UseCaseOnExecutingContext) => void;
+};
+/**
+ * Runs the pre-handler pipeline in order:
+ * onExecuting event → guards → validation → before middleware.
+ *
+ * Returns the validated, transformed data ready for the handler. The handler is
+ * invoked by the caller so retry/benchmark can wrap it in isolation — keeping
+ * guards, validation, and onExecuting from re-running on each retry attempt.
+ *
+ * Throws on guard failure or validation failure.
+ *
+ * @example
+ * const data = await runPipeline({ name, id, data, ctx, startedAt, schema, guards, before });
+ */
+declare function runPipeline<Input>(opts: PipelineOptions<Input>): Promise<Input>;
+//#endregion
+export { PipelineOptions, runPipeline };
+//# sourceMappingURL=use-case-pipeline.d.mts.map

package/esm/use-cases/use-case-pipeline.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-case-pipeline.d.mts","names":[],"sources":["../../../../../../@warlock.js/core/src/use-cases/use-case-pipeline.ts"],"mappings":";;;;KAWY,eAAA;EACV,IAAA;EACA,EAAA;EACA,IAAA,EAAM,KAAA;EACN,GAAA,EAAK,cAAA;EACL,SAAA,EAAW,IAAA;EACX,MAAA,GAAS,eAAA;EACT,MAAA,GAAS,YAAA,CAAa,KAAA;EACtB,MAAA,GAAS,uBAAA,CAAwB,KAAA,KADX;EAGtB,WAAA,IAAe,GAAA,EAAK,yBAAA,WAFa;EAIjC,aAAA,IAAiB,GAAA,EAAK,yBAAA;AAAA;;;;;;;;;;;;;;iBAgBF,WAAA,OAAA,CAAmB,IAAA,EAAM,eAAA,CAAgB,KAAA,IAAS,OAAA,CAAQ,KAAA"}

package/esm/use-cases/use-case-pipeline.mjs

@@ -0,0 +1,47 @@
+import { fireLifecycleEvent, globalEventsCallbacksMap } from "./use-case-events.mjs";
+import { BadSchemaUseCaseError } from "./use-case.errors.mjs";
+import { v } from "@warlock.js/seal";
+
+//#region ../../@warlock.js/core/src/use-cases/use-case-pipeline.ts
+/**
+* Runs the pre-handler pipeline in order:
+* onExecuting event → guards → validation → before middleware.
+*
+* Returns the validated, transformed data ready for the handler. The handler is
+* invoked by the caller so retry/benchmark can wrap it in isolation — keeping
+* guards, validation, and onExecuting from re-running on each retry attempt.
+*
+* Throws on guard failure or validation failure.
+*
+* @example
+* const data = await runPipeline({ name, id, data, ctx, startedAt, schema, guards, before });
+*/
+async function runPipeline(opts) {
+	const { name, id, ctx, startedAt, schema, guards, before, onExecuting, ucOnExecuting } = opts;
+	let data = opts.data;
+	await fireLifecycleEvent({
+		name,
+		id,
+		data,
+		schema,
+		ctx,
+		startedAt
+	}, {
+		invocation: onExecuting ? [onExecuting] : void 0,
+		useCase: ucOnExecuting ? [ucOnExecuting] : void 0,
+		global: globalEventsCallbacksMap.onExecuting.length ? globalEventsCallbacksMap.onExecuting : void 0
+	});
+	if (guards) for (const guard of guards) await guard(Object.freeze(data), ctx);
+	if (schema) {
+		const result = await v.validate(schema, data);
+		if (!result.isValid) throw new BadSchemaUseCaseError(result);
+		data = result.data;
+	}
+	let transformed = data;
+	if (before) for (const middleware of before) transformed = await middleware(transformed, ctx);
+	return transformed;
+}
+
+//#endregion
+export { runPipeline };
+//# sourceMappingURL=use-case-pipeline.mjs.map

package/esm/use-cases/use-case-pipeline.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-case-pipeline.mjs","names":[],"sources":["../../../../../../@warlock.js/core/src/use-cases/use-case-pipeline.ts"],"sourcesContent":["import type { ObjectValidator } from \"@warlock.js/seal\";\r\nimport { v } from \"@warlock.js/seal\";\r\nimport type {\r\n  UseCaseBeforeMiddleware,\r\n  UseCaseContext,\r\n  UseCaseGuard,\r\n  UseCaseOnExecutingContext,\r\n} from \"./types\";\r\nimport { fireLifecycleEvent, globalEventsCallbacksMap } from \"./use-case-events\";\r\nimport { BadSchemaUseCaseError } from \"./use-case.errors\";\r\n\r\nexport type PipelineOptions<Input> = {\r\n  name: string;\r\n  id: string;\r\n  data: Input;\r\n  ctx: UseCaseContext;\r\n  startedAt: Date;\r\n  schema?: ObjectValidator;\r\n  guards?: UseCaseGuard<Input>[];\r\n  before?: UseCaseBeforeMiddleware<Input>[];\r\n  /** Invocation-level onExecuting override */\r\n  onExecuting?: (ctx: UseCaseOnExecutingContext) => void;\r\n  /** Use-case-level onExecuting */\r\n  ucOnExecuting?: (ctx: UseCaseOnExecutingContext) => void;\r\n};\r\n\r\n/**\r\n * Runs the pre-handler pipeline in order:\r\n * onExecuting event → guards → validation → before middleware.\r\n *\r\n * Returns the validated, transformed data ready for the handler. The handler is\r\n * invoked by the caller so retry/benchmark can wrap it in isolation — keeping\r\n * guards, validation, and onExecuting from re-running on each retry attempt.\r\n *\r\n * Throws on guard failure or validation failure.\r\n *\r\n * @example\r\n * const data = await runPipeline({ name, id, data, ctx, startedAt, schema, guards, before });\r\n */\r\nexport async function runPipeline<Input>(opts: PipelineOptions<Input>): Promise<Input> {\r\n  const { name, id, ctx, startedAt, schema, guards, before, onExecuting, ucOnExecuting } = opts;\r\n  let data = opts.data;\r\n\r\n  await fireLifecycleEvent<UseCaseOnExecutingContext>(\r\n    { name, id, data, schema, ctx, startedAt },\r\n    {\r\n      invocation: onExecuting ? [onExecuting] : undefined,\r\n      useCase: ucOnExecuting ? [ucOnExecuting] : undefined,\r\n      global: globalEventsCallbacksMap.onExecuting.length\r\n        ? globalEventsCallbacksMap.onExecuting\r\n        : undefined,\r\n    },\r\n  );\r\n\r\n  if (guards) {\r\n    for (const guard of guards) {\r\n      await guard(Object.freeze(data) as Readonly<Input>, ctx);\r\n    }\r\n  }\r\n\r\n  if (schema) {\r\n    const result = await v.validate(schema, data);\r\n\r\n    if (!result.isValid) {\r\n      throw new BadSchemaUseCaseError(result);\r\n    }\r\n\r\n    data = result.data;\r\n  }\r\n\r\n  let transformed = data;\r\n\r\n  if (before) {\r\n    for (const middleware of before) {\r\n      transformed = await middleware(transformed, ctx);\r\n    }\r\n  }\r\n\r\n  return transformed;\r\n}\r\n"],"mappings":";;;;;;;;;;;;;;;;;;AAuCA,eAAsB,YAAmB,MAA8C;CACrF,MAAM,EAAE,MAAM,IAAI,KAAK,WAAW,QAAQ,QAAQ,QAAQ,aAAa,kBAAkB;CACzF,IAAI,OAAO,KAAK;CAEhB,MAAM,mBACJ;EAAE;EAAM;EAAI;EAAM;EAAQ;EAAK;CAAU,GACzC;EACE,YAAY,cAAc,CAAC,WAAW,IAAI;EAC1C,SAAS,gBAAgB,CAAC,aAAa,IAAI;EAC3C,QAAQ,yBAAyB,YAAY,SACzC,yBAAyB,cACzB;CACN,CACF;CAEA,IAAI,QACF,KAAK,MAAM,SAAS,QAClB,MAAM,MAAM,OAAO,OAAO,IAAI,GAAsB,GAAG;CAI3D,IAAI,QAAQ;EACV,MAAM,SAAS,MAAM,EAAE,SAAS,QAAQ,IAAI;EAE5C,IAAI,CAAC,OAAO,SACV,MAAM,IAAI,sBAAsB,MAAM;EAGxC,OAAO,OAAO;CAChB;CAEA,IAAI,cAAc;CAElB,IAAI,QACF,KAAK,MAAM,cAAc,QACvB,cAAc,MAAM,WAAW,aAAa,GAAG;CAInD,OAAO;AACT"}

package/esm/use-cases/use-case.d.mts

@@ -0,0 +1,35 @@
+import { UseCase, UseCaseContext, UseCaseHandler, UseCaseWithSchema } from "./types.mjs";
+import { Infer, ObjectValidator } from "@warlock.js/seal";
+
+//#region ../../@warlock.js/core/src/use-cases/use-case.d.ts
+/**
+ * Defines and registers a use case.
+ *
+ * A use case is a named, observable, optionally benchmarked unit of business logic.
+ * The returned handler is a typed async function you call with the input data.
+ *
+ * Execution order: onExecuting → guards → validation → before → handler → after →
+ * onCompleted → broadcast. Retry and benchmark wrap the **handler** only.
+ *
+ * When a `schema` is provided, the handler's input is inferred from it — no manual
+ * `Input` generic needed.
+ *
+ * @example
+ * export const createOrderUseCase = useCase({
+ *   name: "create_order",
+ *   schema: createOrderSchema,           // handler `data` is inferred from this
+ *   guards: [authGuard],
+ *   handler: async (data, ctx) => orderService.create(data),
+ *   after: [sendConfirmationEmail],
+ *   retry: { attempts: 3, delay: 500, backoff: "exponential" },
+ *   broadcast: true,
+ * });
+ *
+ * // In a controller:
+ * const output = await createOrderUseCase({ ...validated, user_id: req.user.id });
+ */
+declare function useCase<Output, Schema extends ObjectValidator, Ctx extends UseCaseContext = UseCaseContext>(options: UseCaseWithSchema<Output, Schema, Ctx>): UseCaseHandler<Output, Infer<Schema>>;
+declare function useCase<Output = any, Input = any, Ctx extends UseCaseContext = UseCaseContext>(options: UseCase<Output, Input, Ctx>): UseCaseHandler<Output, Input>;
+//#endregion
+export { useCase };
+//# sourceMappingURL=use-case.d.mts.map

package/esm/use-cases/use-case.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-case.d.mts","names":[],"sources":["../../../../../../@warlock.js/core/src/use-cases/use-case.ts"],"mappings":";;;;;;AAwDA;;;;;;;;;;;;;;;;;;;;;;;;iBAAgB,OAAA,wBAEC,eAAA,cACH,cAAA,GAAiB,cAAA,CAAA,CAC7B,OAAA,EAAS,iBAAA,CAAkB,MAAA,EAAQ,MAAA,EAAQ,GAAA,IAAO,cAAA,CAAe,MAAA,EAAQ,KAAA,CAAM,MAAA;AAAA,iBACjE,OAAA,wCAA+C,cAAA,GAAiB,cAAA,CAAA,CAC9E,OAAA,EAAS,OAAA,CAAQ,MAAA,EAAQ,KAAA,EAAO,GAAA,IAC/B,cAAA,CAAe,MAAA,EAAQ,KAAA"}

package/esm/use-cases/use-case.errors.d.mts

@@ -0,0 +1,10 @@
+import { HttpError } from "../http/errors/errors.mjs";
+import { ValidationResult } from "@warlock.js/seal";
+
+//#region ../../@warlock.js/core/src/use-cases/use-case.errors.d.ts
+declare class BadSchemaUseCaseError extends HttpError {
+  constructor(result: ValidationResult);
+}
+//#endregion
+export { BadSchemaUseCaseError };
+//# sourceMappingURL=use-case.errors.d.mts.map