@moostjs/event-wf 0.6.53 → 0.7.1

package/dist/index.cjs

@@ -102,6 +102,45 @@ function getWfMate() {
 	}
 };
 
+//#endregion
+//#region packages/event-wf/src/run-scope.ts
+/** Marks a `WooksWf` whose runs release their moost DI scope (see {@link releaseRunScopes}). */ const RUN_SCOPES_RELEASED = Symbol.for("moost-wf.run-scopes-released");
+/** Marks the cleanup that releases a run's scope, so a resumed run does not wrap it twice. */ const RUN_SCOPE_CLEANUP = Symbol.for("moost-wf.run-scope-cleanup");
+/** Run options whose `cleanup` also releases the run's moost DI scope (when the run ends). */ function withRunScopeCleanup(opts) {
+	const own = opts?.cleanup;
+	if (own?.[RUN_SCOPE_CLEANUP]) return opts;
+	const cleanup = () => {
+		try {
+			own?.();
+		} finally {
+			(0, moost.getMoostInfact)().unregisterScope((0, moost.useScopeId)());
+		}
+	};
+	cleanup[RUN_SCOPE_CLEANUP] = true;
+	return {
+		...opts,
+		cleanup
+	};
+}
+/**
+* Makes every run of `wfApp` release its moost DI scope when it ends — whoever starts it:
+* `MoostWf.start()`, `getWfApp().start()`, an outlet trigger or `mintWfToken()`. Step handlers
+* keep the run's scope (`FOR_EVENT` instances) alive across steps, so the run end releases it.
+* Replaces the instance's `start`/`resume`: anything that captured them before (e.g. a
+* `createOutletHandler(wooksWf)` made before `new MoostWf(wooksWf)`) bypasses the release.
+*/ function releaseRunScopes(wfApp) {
+	const app = wfApp;
+	if (app[RUN_SCOPES_RELEASED]) return;
+	app[RUN_SCOPES_RELEASED] = true;
+	const { start, resume } = app;
+	app.start = function(schemaId, context, opts) {
+		return start.call(this, schemaId, context, withRunScopeCleanup(opts));
+	};
+	app.resume = function(state, opts) {
+		return resume.call(this, state, withRunScopeCleanup(opts));
+	};
+}
+
 //#endregion
 //#region packages/event-wf/src/event-wf.ts
 function _define_property(obj, key, value) {
@@ -160,17 +199,47 @@ const LOGGER_TITLE = "moost-wf";
 	*
 	* Reads `wfid` (workflow ID) and `wfs` (state token) from the HTTP request,
 	* starts or resumes the workflow, and dispatches pauses to registered outlets.
+	* `allow`/`block` are judged on the registered flow id the request resolves to
+	* (see {@link MoostWf.resolveSchemaId}).
 	*
 	* Must be called from within an HTTP event context (e.g. a `@Post` handler)
 	* so that wooks HTTP composables are available.
 	*
 	* @param config - Outlet trigger configuration (allowed workflows, state strategy, outlets, etc.)
-	* @returns The outlet result (form payload + token), finished response, or error.
+	* @returns The outlet result (form payload + token) or the finished response. Refusals
+	*   (missing/invalid/expired token, forbidden or unknown flow) are thrown as `HttpError`s
+	*   with a `code` (`WF_MISSING`, `WF_INVALID_TOKEN`, `WF_EXPIRED`, `WF_FORBIDDEN`, …).
 	*/ handleOutlet(config) {
-		return (0, _wooksjs_event_wf.handleWfOutletRequest)(config, {
-			start: (schemaId, context, opts) => this.start(schemaId, context, opts),
-			resume: (state, opts) => this.resume(state, opts)
-		});
+		return (0, _wooksjs_event_wf.handleWfOutletRequest)(config, this);
+	}
+	/**
+	* Resolves a workflow id, spelled as a caller would pass it to `start()` (`'auth/login'`,
+	* `'/auth/login'`, `'user/42'`), to the id of the registered flow `start()` would run
+	* (`'/auth/login'`, `'/user/:id'`) — also what a paused run stores as `state.schemaId`.
+	* Returns `undefined` when no flow matches.
+	*
+	* @param id - Workflow id as a caller spells it.
+	* @param opts - `eventContext`: the parent event `start()` would get (e.g. the HTTP request).
+	*/ resolveSchemaId(id, opts) {
+		return this.wfApp.resolveSchemaId(id, opts);
+	}
+	/**
+	* Starts a workflow without a request and persists its first pause the way the outlet
+	* trigger does, returning a token the trigger resumes (`<strategy>.<handle>`) — for
+	* server-initiated flows: invites, approval links, scheduled reminders. No outlet is called:
+	* deliver the token yourself. `allow`/`block` are not checked here; they apply on resume.
+	* The run's DI scope is released when it pauses or ends.
+	*
+	* @param options - `wfid`, `context`, `input`, the trigger's `state` config, `ttl` (ms),
+	*   `meta`, and an optional parent `eventContext`.
+	*
+	* @example
+	* ```ts
+	* const { token } = await wf.mint({ wfid: 'invite', context: { email }, state, ttl: 7 * 86_400_000 })
+	* if (token) await sendInvite(email, `https://app.example/invite?wfs=${token}`)
+	* ```
+	*/ mint(options) {
+		return (0, _wooksjs_event_wf.mintWfToken)(this, options);
 	}
 	/**
 	* Starts a new workflow execution.
@@ -183,12 +252,7 @@ const LOGGER_TITLE = "moost-wf";
 	*   `input` value (legacy positional form) is no longer supported — wrap it
 	*   in `{ input }`.
 	*/ start(schemaId, initialContext, opts) {
-		return this.wfApp.start(schemaId, initialContext, {
-			...opts,
-			cleanup: () => {
-				(0, moost.getMoostInfact)().unregisterScope((0, moost.useScopeId)());
-			}
-		});
+		return this.wfApp.start(schemaId, initialContext, opts);
 	}
 	/**
 	* Resumes a previously paused workflow from a saved state.
@@ -198,12 +262,7 @@ const LOGGER_TITLE = "moost-wf";
 	*   for parent-chain composable access, and `strategy.name` for the strategy
 	*   that loaded this state. Legacy positional `input` is no longer supported.
 	*/ resume(state, opts) {
-		return this.wfApp.resume(state, {
-			...opts,
-			cleanup: () => {
-				(0, moost.getMoostInfact)().unregisterScope((0, moost.useScopeId)());
-			}
-		});
+		return this.wfApp.resume(state, opts);
 	}
 	bindHandler(opts) {
 		let fn;
@@ -274,6 +333,7 @@ const LOGGER_TITLE = "moost-wf";
 		if (opts && opts instanceof _wooksjs_event_wf.WooksWf) this.wfApp = opts;
 		else if (opts) this.wfApp = (0, _wooksjs_event_wf.createWfApp)(opts);
 		else this.wfApp = (0, _wooksjs_event_wf.createWfApp)();
+		releaseRunScopes(this.wfApp);
 	}
 };
 /** Names this adapter for DI independently of class identity (see `MOOST_ADAPTER_BRAND`). */ _define_property(MoostWf, moost.MOOST_ADAPTER_BRAND, "@moostjs/event-wf/MoostWf");
@@ -300,6 +360,12 @@ Object.defineProperty(exports, 'StepRetriableError', {
   }
 });
 exports.StepTTL = StepTTL;
+Object.defineProperty(exports, 'WF_TRIGGER_ERRORS', {
+  enumerable: true,
+  get: function () {
+    return _wooksjs_event_wf.WF_TRIGGER_ERRORS;
+  }
+});
 Object.defineProperty(exports, 'WfStateStoreMemory', {
   enumerable: true,
   get: function () {
@@ -333,6 +399,18 @@ Object.defineProperty(exports, 'handleWfOutletRequest', {
     return _wooksjs_event_wf.handleWfOutletRequest;
   }
 });
+Object.defineProperty(exports, 'mintWfToken', {
+  enumerable: true,
+  get: function () {
+    return _wooksjs_event_wf.mintWfToken;
+  }
+});
+Object.defineProperty(exports, 'normalizeWfId', {
+  enumerable: true,
+  get: function () {
+    return _wooksjs_event_wf.normalizeWfId;
+  }
+});
 Object.defineProperty(exports, 'outlet', {
   enumerable: true,
   get: function () {

package/dist/index.d.ts

@@ -1,8 +1,8 @@
 import { TWorkflowSchema, TWorkflowSpy, TFlowOutput } from '@prostojs/wf';
 export { StepRetriableError, TFlowOutput, TWorkflowSchema } from '@prostojs/wf';
-import { WooksWf, TWooksWfOptions, WfOutletTriggerConfig, TWfRunOptions } from '@wooksjs/event-wf';
-export { WfFinishedResponse, WfOutletTokenConfig, WfOutletTriggerConfig, WfOutletTriggerDeps, WfPauseRequest, createEmailOutlet, createHttpOutlet, createOutletHandler, handleWfOutletRequest, swapStrategy, useWfFinished, useWfOutlet, useWfState, useWfStrategy, wfKind } from '@wooksjs/event-wf';
-import { TMoostAdapter, MOOST_ADAPTER_BRAND, Moost, TMoostAdapterOptions } from 'moost';
+import { WooksWf, TWooksWfOptions, WfOutletTriggerConfig, WfMintTokenOptions, WfMintTokenResult, TWfRunOptions } from '@wooksjs/event-wf';
+export { WF_TRIGGER_ERRORS, WfFinishedResponse, WfMintTokenOptions, WfMintTokenResult, WfOutletTokenConfig, WfOutletTriggerConfig, WfOutletTriggerDeps, WfPauseRequest, WfStartRunner, WfTriggerErrorBody, WfTriggerErrorCode, createEmailOutlet, createHttpOutlet, createOutletHandler, handleWfOutletRequest, mintWfToken, normalizeWfId, swapStrategy, useWfFinished, useWfOutlet, useWfState, useWfStrategy, wfKind } from '@wooksjs/event-wf';
+import { TMoostAdapter, MOOST_ADAPTER_BRAND, Moost, EventContext, TMoostAdapterOptions } from 'moost';
 export { EncapsulatedStateStrategy, HandleStateStrategy, WfOutlet, WfOutletRequest, WfOutletResult, WfState, WfStateStore, WfStateStoreMemory, WfStateStrategy, outlet, outletEmail, outletHttp } from '@prostojs/wf/outlets';
 
 /**
@@ -117,14 +117,47 @@ declare class MoostWf<T = any, IR = any> implements TMoostAdapter<TWfHandlerMeta
      *
      * Reads `wfid` (workflow ID) and `wfs` (state token) from the HTTP request,
      * starts or resumes the workflow, and dispatches pauses to registered outlets.
+     * `allow`/`block` are judged on the registered flow id the request resolves to
+     * (see {@link MoostWf.resolveSchemaId}).
      *
      * Must be called from within an HTTP event context (e.g. a `@Post` handler)
      * so that wooks HTTP composables are available.
      *
      * @param config - Outlet trigger configuration (allowed workflows, state strategy, outlets, etc.)
-     * @returns The outlet result (form payload + token), finished response, or error.
+     * @returns The outlet result (form payload + token) or the finished response. Refusals
+     *   (missing/invalid/expired token, forbidden or unknown flow) are thrown as `HttpError`s
+     *   with a `code` (`WF_MISSING`, `WF_INVALID_TOKEN`, `WF_EXPIRED`, `WF_FORBIDDEN`, …).
      */
     handleOutlet(config: WfOutletTriggerConfig): Promise<unknown>;
+    /**
+     * Resolves a workflow id, spelled as a caller would pass it to `start()` (`'auth/login'`,
+     * `'/auth/login'`, `'user/42'`), to the id of the registered flow `start()` would run
+     * (`'/auth/login'`, `'/user/:id'`) — also what a paused run stores as `state.schemaId`.
+     * Returns `undefined` when no flow matches.
+     *
+     * @param id - Workflow id as a caller spells it.
+     * @param opts - `eventContext`: the parent event `start()` would get (e.g. the HTTP request).
+     */
+    resolveSchemaId(id: string, opts?: {
+        eventContext?: EventContext;
+    }): Promise<string | undefined>;
+    /**
+     * Starts a workflow without a request and persists its first pause the way the outlet
+     * trigger does, returning a token the trigger resumes (`<strategy>.<handle>`) — for
+     * server-initiated flows: invites, approval links, scheduled reminders. No outlet is called:
+     * deliver the token yourself. `allow`/`block` are not checked here; they apply on resume.
+     * The run's DI scope is released when it pauses or ends.
+     *
+     * @param options - `wfid`, `context`, `input`, the trigger's `state` config, `ttl` (ms),
+     *   `meta`, and an optional parent `eventContext`.
+     *
+     * @example
+     * ```ts
+     * const { token } = await wf.mint({ wfid: 'invite', context: { email }, state, ttl: 7 * 86_400_000 })
+     * if (token) await sendInvite(email, `https://app.example/invite?wfs=${token}`)
+     * ```
+     */
+    mint(options: WfMintTokenOptions): Promise<WfMintTokenResult>;
     /**
      * Starts a new workflow execution.
      *

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { WooksWf, createEmailOutlet, createHttpOutlet, createOutletHandler, createWfApp, handleWfOutletRequest, handleWfOutletRequest as handleWfOutletRequest$1, swapStrategy, useWfFinished, useWfOutlet, useWfState, useWfState as useWfState$1, useWfStrategy, wfKind } from "@wooksjs/event-wf";
+import { WF_TRIGGER_ERRORS, WooksWf, createEmailOutlet, createHttpOutlet, createOutletHandler, createWfApp, handleWfOutletRequest, handleWfOutletRequest as handleWfOutletRequest$1, mintWfToken, mintWfToken as mintWfToken$1, normalizeWfId, swapStrategy, useWfFinished, useWfOutlet, useWfState, useWfState as useWfState$1, useWfStrategy, wfKind } from "@wooksjs/event-wf";
 import { MOOST_ADAPTER_BRAND, Resolve, defineMoostEventHandler, getMoostInfact, getMoostMate, setControllerContext, useScopeId } from "moost";
 import { StepRetriableError } from "@prostojs/wf";
 import { EncapsulatedStateStrategy, HandleStateStrategy, WfStateStoreMemory, outlet, outletEmail, outletHttp } from "@prostojs/wf/outlets";
@@ -101,6 +101,45 @@ function getWfMate() {
 	}
 };
 
+//#endregion
+//#region packages/event-wf/src/run-scope.ts
+/** Marks a `WooksWf` whose runs release their moost DI scope (see {@link releaseRunScopes}). */ const RUN_SCOPES_RELEASED = Symbol.for("moost-wf.run-scopes-released");
+/** Marks the cleanup that releases a run's scope, so a resumed run does not wrap it twice. */ const RUN_SCOPE_CLEANUP = Symbol.for("moost-wf.run-scope-cleanup");
+/** Run options whose `cleanup` also releases the run's moost DI scope (when the run ends). */ function withRunScopeCleanup(opts) {
+	const own = opts?.cleanup;
+	if (own?.[RUN_SCOPE_CLEANUP]) return opts;
+	const cleanup = () => {
+		try {
+			own?.();
+		} finally {
+			getMoostInfact().unregisterScope(useScopeId());
+		}
+	};
+	cleanup[RUN_SCOPE_CLEANUP] = true;
+	return {
+		...opts,
+		cleanup
+	};
+}
+/**
+* Makes every run of `wfApp` release its moost DI scope when it ends — whoever starts it:
+* `MoostWf.start()`, `getWfApp().start()`, an outlet trigger or `mintWfToken()`. Step handlers
+* keep the run's scope (`FOR_EVENT` instances) alive across steps, so the run end releases it.
+* Replaces the instance's `start`/`resume`: anything that captured them before (e.g. a
+* `createOutletHandler(wooksWf)` made before `new MoostWf(wooksWf)`) bypasses the release.
+*/ function releaseRunScopes(wfApp) {
+	const app = wfApp;
+	if (app[RUN_SCOPES_RELEASED]) return;
+	app[RUN_SCOPES_RELEASED] = true;
+	const { start, resume } = app;
+	app.start = function(schemaId, context, opts) {
+		return start.call(this, schemaId, context, withRunScopeCleanup(opts));
+	};
+	app.resume = function(state, opts) {
+		return resume.call(this, state, withRunScopeCleanup(opts));
+	};
+}
+
 //#endregion
 //#region packages/event-wf/src/event-wf.ts
 function _define_property(obj, key, value) {
@@ -159,17 +198,47 @@ const LOGGER_TITLE = "moost-wf";
 	*
 	* Reads `wfid` (workflow ID) and `wfs` (state token) from the HTTP request,
 	* starts or resumes the workflow, and dispatches pauses to registered outlets.
+	* `allow`/`block` are judged on the registered flow id the request resolves to
+	* (see {@link MoostWf.resolveSchemaId}).
 	*
 	* Must be called from within an HTTP event context (e.g. a `@Post` handler)
 	* so that wooks HTTP composables are available.
 	*
 	* @param config - Outlet trigger configuration (allowed workflows, state strategy, outlets, etc.)
-	* @returns The outlet result (form payload + token), finished response, or error.
+	* @returns The outlet result (form payload + token) or the finished response. Refusals
+	*   (missing/invalid/expired token, forbidden or unknown flow) are thrown as `HttpError`s
+	*   with a `code` (`WF_MISSING`, `WF_INVALID_TOKEN`, `WF_EXPIRED`, `WF_FORBIDDEN`, …).
 	*/ handleOutlet(config) {
-		return handleWfOutletRequest$1(config, {
-			start: (schemaId, context, opts) => this.start(schemaId, context, opts),
-			resume: (state, opts) => this.resume(state, opts)
-		});
+		return handleWfOutletRequest$1(config, this);
+	}
+	/**
+	* Resolves a workflow id, spelled as a caller would pass it to `start()` (`'auth/login'`,
+	* `'/auth/login'`, `'user/42'`), to the id of the registered flow `start()` would run
+	* (`'/auth/login'`, `'/user/:id'`) — also what a paused run stores as `state.schemaId`.
+	* Returns `undefined` when no flow matches.
+	*
+	* @param id - Workflow id as a caller spells it.
+	* @param opts - `eventContext`: the parent event `start()` would get (e.g. the HTTP request).
+	*/ resolveSchemaId(id, opts) {
+		return this.wfApp.resolveSchemaId(id, opts);
+	}
+	/**
+	* Starts a workflow without a request and persists its first pause the way the outlet
+	* trigger does, returning a token the trigger resumes (`<strategy>.<handle>`) — for
+	* server-initiated flows: invites, approval links, scheduled reminders. No outlet is called:
+	* deliver the token yourself. `allow`/`block` are not checked here; they apply on resume.
+	* The run's DI scope is released when it pauses or ends.
+	*
+	* @param options - `wfid`, `context`, `input`, the trigger's `state` config, `ttl` (ms),
+	*   `meta`, and an optional parent `eventContext`.
+	*
+	* @example
+	* ```ts
+	* const { token } = await wf.mint({ wfid: 'invite', context: { email }, state, ttl: 7 * 86_400_000 })
+	* if (token) await sendInvite(email, `https://app.example/invite?wfs=${token}`)
+	* ```
+	*/ mint(options) {
+		return mintWfToken$1(this, options);
 	}
 	/**
 	* Starts a new workflow execution.
@@ -182,12 +251,7 @@ const LOGGER_TITLE = "moost-wf";
 	*   `input` value (legacy positional form) is no longer supported — wrap it
 	*   in `{ input }`.
 	*/ start(schemaId, initialContext, opts) {
-		return this.wfApp.start(schemaId, initialContext, {
-			...opts,
-			cleanup: () => {
-				getMoostInfact().unregisterScope(useScopeId());
-			}
-		});
+		return this.wfApp.start(schemaId, initialContext, opts);
 	}
 	/**
 	* Resumes a previously paused workflow from a saved state.
@@ -197,12 +261,7 @@ const LOGGER_TITLE = "moost-wf";
 	*   for parent-chain composable access, and `strategy.name` for the strategy
 	*   that loaded this state. Legacy positional `input` is no longer supported.
 	*/ resume(state, opts) {
-		return this.wfApp.resume(state, {
-			...opts,
-			cleanup: () => {
-				getMoostInfact().unregisterScope(useScopeId());
-			}
-		});
+		return this.wfApp.resume(state, opts);
 	}
 	bindHandler(opts) {
 		let fn;
@@ -273,9 +332,10 @@ const LOGGER_TITLE = "moost-wf";
 		if (opts && opts instanceof WooksWf) this.wfApp = opts;
 		else if (opts) this.wfApp = createWfApp(opts);
 		else this.wfApp = createWfApp();
+		releaseRunScopes(this.wfApp);
 	}
 };
 /** Names this adapter for DI independently of class identity (see `MOOST_ADAPTER_BRAND`). */ _define_property(MoostWf, MOOST_ADAPTER_BRAND, "@moostjs/event-wf/MoostWf");
 
 //#endregion
-export { EncapsulatedStateStrategy, HandleStateStrategy, MoostWf, Step, StepRetriableError, StepTTL, WfStateStoreMemory, Workflow, WorkflowParam, WorkflowSchema, createEmailOutlet, createHttpOutlet, createOutletHandler, handleWfOutletRequest, outlet, outletEmail, outletHttp, swapStrategy, useWfFinished, useWfOutlet, useWfState, useWfStrategy, wfKind };
+export { EncapsulatedStateStrategy, HandleStateStrategy, MoostWf, Step, StepRetriableError, StepTTL, WF_TRIGGER_ERRORS, WfStateStoreMemory, Workflow, WorkflowParam, WorkflowSchema, createEmailOutlet, createHttpOutlet, createOutletHandler, handleWfOutletRequest, mintWfToken, normalizeWfId, outlet, outletEmail, outletHttp, swapStrategy, useWfFinished, useWfOutlet, useWfState, useWfStrategy, wfKind };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moostjs/event-wf",
-  "version": "0.6.53",
+  "version": "0.7.1",
   "description": "@moostjs/event-wf",
   "keywords": [
     "composables",
@@ -38,18 +38,18 @@
     }
   },
   "dependencies": {
-    "@prostojs/wf": "^0.2.1",
-    "@wooksjs/event-wf": "^0.7.31"
+    "@prostojs/wf": "^0.3.0",
+    "@wooksjs/event-wf": "^0.8.0"
   },
   "devDependencies": {
-    "vitest": "3.2.7"
+    "vitest": "4.1.12"
   },
   "peerDependencies": {
     "@prostojs/infact": "^0.6.1",
     "@prostojs/mate": "^0.5.1",
-    "@wooksjs/event-core": "^0.7.31",
-    "wooks": "^0.7.31",
-    "moost": "^0.6.53"
+    "@wooksjs/event-core": "^0.8.0",
+    "wooks": "^0.8.0",
+    "moost": "^0.7.1"
   },
   "scripts": {
     "pub": "pnpm publish --access public",