@webiny/api-event-handler-standalone 0.0.0-unstable.5387e5f7c8 → 0.0.0-unstable.eb81deee7e

package/bulkActions/bulkActionsServer.d.ts

@@ -1,6 +1,2 @@
 import type { Container } from "@webiny/di";
-/**
- * Empties the trash bins on a timer by dispatching an `EmptyTrashBinsEvent`. The standalone
- * counterpart of the EventBridge rule that does it on AWS.
- */
 export declare function startBulkActionsServer(rootContainer: Container): void;

package/bulkActions/bulkActionsServer.js

@@ -1,20 +1,29 @@
-import { EventDispatcher } from "@webiny/event-handler-core";
-import { EMPTY_TRASH_BINS_EVENT_IDENTIFIER } from "@webiny/api-headless-cms-bulk-actions-standalone";
+import { BulkActionsInternalToken } from "@webiny/api-headless-cms-bulk-actions-standalone";
+const BULK_ACTIONS_HEADER = "x-webiny-bulk-actions-token";
+const serverBase = ()=>`http://localhost:${process.env.PORT || "3002"}`;
 const EMPTY_TRASH_INTERVAL_MS = 21600000;
-const FIRST_RUN_DELAY_MS = 5000;
 function startBulkActionsServer(rootContainer) {
-    const dispatcher = rootContainer.resolve(EventDispatcher);
-    const event = {
-        [EMPTY_TRASH_BINS_EVENT_IDENTIFIER]: true
-    };
+    const token = rootContainer.resolve(BulkActionsInternalToken).value;
     const trigger = async ()=>{
         try {
-            await dispatcher.dispatch(event);
+            const res = await fetch(`${serverBase()}/empty-trash-bins`, {
+                method: "POST",
+                headers: {
+                    "content-type": "application/json",
+                    [BULK_ACTIONS_HEADER]: token
+                },
+                body: JSON.stringify({})
+            });
+            if (!res.ok) {
+                const body = await res.text().catch(()=>"");
+                console.error(`[bulk-actions] empty-trash-bins returned HTTP ${res.status}: ${body}`);
+            }
         } catch (err) {
-            console.error("[bulk-actions] failed to start emptying the trash bins:", err);
+            const message = err instanceof Error ? err.message : String(err);
+            console.error(`[bulk-actions] failed to reach empty-trash-bins route: ${message}`);
         }
     };
-    setTimeout(trigger, FIRST_RUN_DELAY_MS);
+    setTimeout(trigger, 5000);
     setInterval(trigger, EMPTY_TRASH_INTERVAL_MS);
 }
 export { startBulkActionsServer };

package/bulkActions/bulkActionsServer.js.map

@@ -1 +1 @@
-{"version":3,"file":"bulkActions/bulkActionsServer.js","sources":["../../src/bulkActions/bulkActionsServer.ts"],"sourcesContent":["import type { Container } from \"@webiny/di\";\nimport { EventDispatcher } from \"@webiny/event-handler-core\";\nimport { EMPTY_TRASH_BINS_EVENT_IDENTIFIER } from \"@webiny/api-headless-cms-bulk-actions-standalone\";\nimport type { IEmptyTrashBinsEvent } from \"@webiny/api-headless-cms-bulk-actions-standalone\";\n\n// Every 6 hours.\nconst EMPTY_TRASH_INTERVAL_MS = 6 * 60 * 60 * 1000;\n\n// Shortly after boot, so the first run doesn't compete with startup.\nconst FIRST_RUN_DELAY_MS = 5000;\n\n/**\n * Empties the trash bins on a timer by dispatching an `EmptyTrashBinsEvent`. The standalone\n * counterpart of the EventBridge rule that does it on AWS.\n */\nexport function startBulkActionsServer(rootContainer: Container): void {\n    const dispatcher = rootContainer.resolve(EventDispatcher);\n    const event: IEmptyTrashBinsEvent = { [EMPTY_TRASH_BINS_EVENT_IDENTIFIER]: true };\n\n    const trigger = async () => {\n        try {\n            await dispatcher.dispatch(event);\n        } catch (err) {\n            console.error(\"[bulk-actions] failed to start emptying the trash bins:\", err);\n        }\n    };\n\n    setTimeout(trigger, FIRST_RUN_DELAY_MS);\n    setInterval(trigger, EMPTY_TRASH_INTERVAL_MS);\n}\n"],"names":["EMPTY_TRASH_INTERVAL_MS","FIRST_RUN_DELAY_MS","startBulkActionsServer","rootContainer","dispatcher","EventDispatcher","event","EMPTY_TRASH_BINS_EVENT_IDENTIFIER","trigger","err","console","setTimeout","setInterval"],"mappings":";;AAMA,MAAMA,0BAA0B;AAGhC,MAAMC,qBAAqB;AAMpB,SAASC,uBAAuBC,aAAwB;IAC3D,MAAMC,aAAaD,cAAc,OAAO,CAACE;IACzC,MAAMC,QAA8B;QAAE,CAACC,kCAAkC,EAAE;IAAK;IAEhF,MAAMC,UAAU;QACZ,IAAI;YACA,MAAMJ,WAAW,QAAQ,CAACE;QAC9B,EAAE,OAAOG,KAAK;YACVC,QAAQ,KAAK,CAAC,2DAA2DD;QAC7E;IACJ;IAEAE,WAAWH,SAASP;IACpBW,YAAYJ,SAASR;AACzB"}
+{"version":3,"file":"bulkActions/bulkActionsServer.js","sources":["../../src/bulkActions/bulkActionsServer.ts"],"sourcesContent":["import type { Container } from \"@webiny/di\";\nimport { BulkActionsInternalToken } from \"@webiny/api-headless-cms-bulk-actions-standalone\";\n\nconst BULK_ACTIONS_HEADER = \"x-webiny-bulk-actions-token\";\nconst serverBase = () => `http://localhost:${process.env.PORT || \"3002\"}`;\n\n// Default: trigger every 6 hours (in milliseconds).\nconst EMPTY_TRASH_INTERVAL_MS = 6 * 60 * 60 * 1000;\n\nexport function startBulkActionsServer(rootContainer: Container): void {\n    const token = rootContainer.resolve(BulkActionsInternalToken).value;\n\n    const trigger = async () => {\n        try {\n            const res = await fetch(`${serverBase()}/empty-trash-bins`, {\n                method: \"POST\",\n                headers: { \"content-type\": \"application/json\", [BULK_ACTIONS_HEADER]: token },\n                body: JSON.stringify({})\n            });\n            if (!res.ok) {\n                const body = await res.text().catch(() => \"\");\n                console.error(\n                    `[bulk-actions] empty-trash-bins returned HTTP ${res.status}: ${body}`\n                );\n            }\n        } catch (err) {\n            const message = err instanceof Error ? err.message : String(err);\n            console.error(`[bulk-actions] failed to reach empty-trash-bins route: ${message}`);\n        }\n    };\n\n    // Deferred initial trigger + periodic interval.\n    setTimeout(trigger, 5000);\n    setInterval(trigger, EMPTY_TRASH_INTERVAL_MS);\n}\n"],"names":["BULK_ACTIONS_HEADER","serverBase","process","EMPTY_TRASH_INTERVAL_MS","startBulkActionsServer","rootContainer","token","BulkActionsInternalToken","trigger","res","fetch","JSON","body","console","err","message","Error","String","setTimeout","setInterval"],"mappings":";AAGA,MAAMA,sBAAsB;AAC5B,MAAMC,aAAa,IAAM,CAAC,iBAAiB,EAAEC,QAAQ,GAAG,CAAC,IAAI,IAAI,QAAQ;AAGzE,MAAMC,0BAA0B;AAEzB,SAASC,uBAAuBC,aAAwB;IAC3D,MAAMC,QAAQD,cAAc,OAAO,CAACE,0BAA0B,KAAK;IAEnE,MAAMC,UAAU;QACZ,IAAI;YACA,MAAMC,MAAM,MAAMC,MAAM,GAAGT,aAAa,iBAAiB,CAAC,EAAE;gBACxD,QAAQ;gBACR,SAAS;oBAAE,gBAAgB;oBAAoB,CAACD,oBAAoB,EAAEM;gBAAM;gBAC5E,MAAMK,KAAK,SAAS,CAAC,CAAC;YAC1B;YACA,IAAI,CAACF,IAAI,EAAE,EAAE;gBACT,MAAMG,OAAO,MAAMH,IAAI,IAAI,GAAG,KAAK,CAAC,IAAM;gBAC1CI,QAAQ,KAAK,CACT,CAAC,8CAA8C,EAAEJ,IAAI,MAAM,CAAC,EAAE,EAAEG,MAAM;YAE9E;QACJ,EAAE,OAAOE,KAAK;YACV,MAAMC,UAAUD,eAAeE,QAAQF,IAAI,OAAO,GAAGG,OAAOH;YAC5DD,QAAQ,KAAK,CAAC,CAAC,uDAAuD,EAAEE,SAAS;QACrF;IACJ;IAGAG,WAAWV,SAAS;IACpBW,YAAYX,SAASL;AACzB"}

package/createWebinyApiHandler.d.ts

@@ -11,5 +11,10 @@ export interface CreateWebinyApiHandlerConfig {
      * IdP assumption — the variant supplies the complete storage + auth wiring.
      */
     registerRootStorage: (container: Container) => void | Promise<void>;
+    /**
+     * Register the per-request storage features (e.g. the CMS storage operations) in the request
+     * container, before `HeadlessCmsFeature` builds its storage. Optional.
+     */
+    registerRequestStorage?: (container: Container) => void | Promise<void>;
 }
 export declare function createWebinyApiHandler(config: CreateWebinyApiHandlerConfig): Promise<import("http").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse>>;

package/createWebinyApiHandler.js

@@ -12,7 +12,7 @@ import { NodeHttpIdentityLoaderDecorator } from "./handlers/NodeHttpIdentityLoad
 import { NodeHttpTenantLoaderDecorator } from "./handlers/NodeHttpTenantLoaderDecorator.js";
 import { NodeHttpAssumePermissionsDecorator } from "./handlers/NodeHttpAssumePermissionsDecorator.js";
 import { createWebsocketsAuthenticator } from "./websockets/createWebsocketsAuthenticator.js";
-import { EmptyTrashBinsFeature } from "@webiny/api-headless-cms-bulk-actions-standalone";
+import { EmptyTrashBinRouteFeature } from "@webiny/api-headless-cms-bulk-actions-standalone";
 function createWebinyApiHandler(config) {
     return createServerHandler({
         root: async (rootContainer)=>{
@@ -28,11 +28,12 @@ function createWebinyApiHandler(config) {
             JwksStoreFeature.register(rootContainer);
             BackgroundTasksStandaloneFeature.register(rootContainer);
             registerSchedulerServer(rootContainer);
-            EmptyTrashBinsFeature.register(rootContainer);
+            EmptyTrashBinRouteFeature.register(rootContainer);
         },
         child: async (container)=>{
             await registerApiRequestStack(container, {
                 extensions: config.extensions,
+                registerRequestStorage: config.registerRequestStorage,
                 transports: {
                     realtime: (requestContainer)=>{
                         WebsocketsStandaloneFeature.register(requestContainer);

package/createWebinyApiHandler.js.map

@@ -1 +1 @@
-{"version":3,"file":"createWebinyApiHandler.js","sources":["../src/createWebinyApiHandler.ts"],"sourcesContent":["/**\n * Webiny API handler for the standalone Node HTTP server transport — storage-agnostic BASE.\n *\n * The ROOT container wires the Node HTTP transport (NodeHttpFeature = event type + router + HttpFeature)\n * plus the auth/tenant loader decorators (extract token / x-tenant from the IncomingMessage → shared\n * RequestIdentityLoader / RequestTenantLoader). The per-request feature stack is the transport-agnostic\n * `registerApiRequestStack` from `@webiny/api-event-handler-core` — the SAME stack the AWS handler uses.\n * The realtime transport hook installs the server WebSockets transport (vs AWS's API Gateway Management\n * API) with a SINGLE-PROCESS, in-process implementation. Background tasks and the Bree scheduler are\n * ROOT-container singletons (below) — mirroring how the AWS handler registers background tasks at root,\n * and the WebSockets connection manager — rather than per-request transports; the scheduler fires timers\n * in-process (vs AWS's EventBridge). The storage variant (and identity provider) is injected via\n * `registerRootStorage`.\n *\n * The identity provider (e.g. `@webiny/self-hosted-auth`'s JWT IdP) must be registered by the variant\n * in `registerRootStorage`, so the RequestIdentityLoader driven by the identity decorator can resolve it.\n */\nimport { GraphQLSchemaCacheFeature } from \"@webiny/api-graphql\";\nimport { EncryptionKeyCacheFeature } from \"@webiny/api-core/features/encryption/index.js\";\nimport { JwksStoreFeature } from \"@webiny/api-core/idp/index.js\";\nimport type { Container } from \"@webiny/di\";\nimport { createServerHandler, NodeHttpFeature } from \"@webiny/event-handler-standalone\";\nimport { registerExtensions } from \"@webiny/handler\";\nimport { registerApiRequestStack } from \"@webiny/api-event-handler-core\";\nimport {\n    ServerConnectionManager,\n    NodeWsAdapter,\n    WebsocketsStandaloneFeature,\n    WebsocketsConnectionManager,\n    attachWebsocketsServer\n} from \"@webiny/api-websockets-standalone\";\nimport { BackgroundTasksStandaloneFeature } from \"@webiny/background-tasks-standalone\";\nimport { FileManagerStandaloneFeature } from \"@webiny/api-file-manager-standalone\";\nimport { registerSchedulerServer, startSchedulerServer } from \"~/scheduler/schedulerServer.js\";\nimport { startBulkActionsServer } from \"~/bulkActions/bulkActionsServer.js\";\nimport { NodeHttpIdentityLoaderDecorator } from \"~/handlers/NodeHttpIdentityLoaderDecorator.js\";\nimport { NodeHttpTenantLoaderDecorator } from \"~/handlers/NodeHttpTenantLoaderDecorator.js\";\nimport { NodeHttpAssumePermissionsDecorator } from \"~/handlers/NodeHttpAssumePermissionsDecorator.js\";\nimport { createWebsocketsAuthenticator } from \"~/websockets/createWebsocketsAuthenticator.js\";\nimport { EmptyTrashBinsFeature } from \"@webiny/api-headless-cms-bulk-actions-standalone\";\n\nexport interface CreateWebinyApiHandlerConfig {\n    /**\n     * Project-defined extensions, applied at register() time.\n     */\n    extensions: () => Parameters<typeof registerExtensions>[1];\n    /**\n     * Register ALL root-container storage for this deployment (the DB feature + CMS storage ops +\n     * registries) AND the identity provider. Unlike the AWS base, the server base bakes in no DB or\n     * IdP assumption — the variant supplies the complete storage + auth wiring.\n     */\n    registerRootStorage: (container: Container) => void | Promise<void>;\n}\n\nexport function createWebinyApiHandler(config: CreateWebinyApiHandlerConfig) {\n    return createServerHandler({\n        root: async rootContainer => {\n            // ── Transport (Node HTTP) ──────────────────────────────────\n            // NodeHttpFeature registers the event type + HttpFeature (router) + the routing terminal.\n            NodeHttpFeature.register(rootContainer);\n\n            // ── Tenant + auth (extract → shared load) ──────────────────\n            // registerDecorator applies LATER registrations as the OUTER wrapper (whose execute()\n            // runs first). TENANT must be established before IDENTITY: API-key authentication resolves\n            // the key by tenant partition (ApiKeysRepository reads TenantContext.getTenant()), so\n            // identity depends on the tenant; the reverse is not true (RequestTenantLoader has no\n            // identity dependency). Register identity first (inner) and tenant last (outer) → tenant\n            // runs, then identity, then the router.\n            rootContainer.registerDecorator(NodeHttpIdentityLoaderDecorator);\n            rootContainer.registerDecorator(NodeHttpTenantLoaderDecorator);\n\n            // Preview-as. Mirrors the AWS handler.\n            rootContainer.registerDecorator(NodeHttpAssumePermissionsDecorator);\n\n            // ── Storage + identity provider (variant-supplied) ─────────\n            await config.registerRootStorage(rootContainer);\n\n            // ── WebSockets transport (root) ────────────────────────────\n            // Live-socket registry + adapter live in the root as singletons: the connection manager\n            // is shared between the upgrade acceptor (attachWebsocketsServer, below) and the\n            // per-request ServerWebsocketsTransport that sends to those live sockets. The persistent\n            // connection registry (ConnectionRegistry) is the storage variant's job (e.g. sql).\n            rootContainer.register(ServerConnectionManager).inSingletonScope();\n            rootContainer.register(NodeWsAdapter).inSingletonScope();\n\n            // ── GraphQL schema cache (root) ────────────────────────────\n            // Root, so a built schema outlives the request that built it.\n            GraphQLSchemaCacheFeature.register(rootContainer);\n\n            // ── Encryption key cache (root) ────────────────────────────\n            // Root, so the scrypt-derived key is computed once per process instead of per request.\n            EncryptionKeyCacheFeature.register(rootContainer);\n            // Root, so identity providers' signing keys are fetched once per process, not per request.\n            JwksStoreFeature.register(rootContainer);\n\n            // ── Background tasks (root) ────────────────────────────────\n            // Mirrors the AWS handler registering its background-task transport at root. Where AWS\n            // has Step Functions invoke the Lambda once per iteration, a root task loop dispatches a\n            // BackgroundTaskEvent per iteration through the EventDispatcher (registered by\n            // createServerHandler), and each one runs in a fresh request container.\n            BackgroundTasksStandaloneFeature.register(rootContainer);\n\n            // ── Scheduler (root) ───────────────────────────────────────\n            // The Bree scheduler is a single long-lived instance for ALL tenants, started once at boot\n            // (onServer, below) — the counterpart of the WebSockets connection manager, NOT a per-request\n            // transport. Registered here as SchedulerService (per-request create/update/delete during\n            // mutations manipulate this one live timer set) plus the run/recover event handlers. When a\n            // timer fires (outside any request) it dispatches a ScheduledActionEvent, handled in a fresh\n            // request container by the same handler AWS uses.\n            registerSchedulerServer(rootContainer);\n\n            // ── Bulk actions (root) ───────────────────────────────────\n            // Registers the EmptyTrashBinsEvent handler that the periodic trigger\n            // (startBulkActionsServer, onServer below) dispatches.\n            EmptyTrashBinsFeature.register(rootContainer);\n        },\n\n        child: async container => {\n            // The transport-agnostic per-request stack. The realtime hook installs the server\n            // WebSockets transport (overriding the domain's NullWebsocketsTransport); it resolves the\n            // shared connection manager + adapter from the root. Scheduler is NOT a per-request\n            // transport here — it's a root singleton wired in `root` + `onServer` (see above).\n            await registerApiRequestStack(container, {\n                extensions: config.extensions,\n                // Why hooks (and not just registering the transports ourselves): `.register()` calls\n                // are otherwise order-independent — you can register Features in any order, because\n                // they only REGISTER, they don't RESOLVE during registration (resolution happens\n                // later, in Initializers / SchemaFactories). The one thing that makes order matter is\n                // a DEFAULT registration: e.g. `WebsocketsFeature` registers `NullWebsocketsTransport`\n                // so the abstraction is always resolvable. Overriding it (last-registration-wins) means\n                // our transport MUST be registered AFTER that Feature. These hooks are the seams\n                // `registerApiRequestStack` provides for exactly that — each runs right after its Null\n                // default, so the override is guaranteed without the caller knowing the internal order.\n                transports: {\n                    // Server WebSockets transport; resolves the shared connection manager + adapter\n                    // from the root (registered as singletons above).\n                    realtime: requestContainer => {\n                        WebsocketsStandaloneFeature.register(requestContainer);\n                    },\n                    // File-manager storage transport: local disk. Where AWS uses S3 (+ a separate asset-\n                    // delivery Lambda), the single-process server stores files on disk and serves them\n                    // in-process — FileManagerStandaloneFeature registers local asset delivery (overriding\n                    // the domain's null impls), the upload/multipart HTTP routes, and disk file ops.\n                    fileManager: requestContainer => {\n                        FileManagerStandaloneFeature.register(requestContainer);\n                    }\n                }\n            });\n        },\n\n        onServer: async (server, rootContainer) => {\n            // Attach the WebSockets upgrade handler to the running HTTP server, backed by the shared\n            // (root) connection manager so request-time sends reach the live sockets.\n            //\n            // Authenticate each WebSocket connection from its `?token` JWT so it's registered under\n            // the real identity (targeted server→client sends match by identity id). It's a callback\n            // the handler supplies rather than something the WS server resolves itself — see\n            // createWebsocketsAuthenticator for why (AuthenticationContext is per-request, unreachable\n            // from the root container the WS server is attached to).\n            const websockets = attachWebsocketsServer({\n                server,\n                connectionManager: rootContainer.resolve(WebsocketsConnectionManager),\n                authenticate: createWebsocketsAuthenticator(rootContainer, config.extensions)\n            });\n            await websockets.start();\n\n            // Start the in-process scheduler timers, then re-arm persisted schedules in the\n            // background (see startSchedulerServer).\n            await startSchedulerServer(rootContainer);\n\n            // Start the periodic empty-trash-bin trigger.\n            startBulkActionsServer(rootContainer);\n        }\n    });\n}\n"],"names":["createWebinyApiHandler","config","createServerHandler","rootContainer","NodeHttpFeature","NodeHttpIdentityLoaderDecorator","NodeHttpTenantLoaderDecorator","NodeHttpAssumePermissionsDecorator","ServerConnectionManager","NodeWsAdapter","GraphQLSchemaCacheFeature","EncryptionKeyCacheFeature","JwksStoreFeature","BackgroundTasksStandaloneFeature","registerSchedulerServer","EmptyTrashBinsFeature","container","registerApiRequestStack","requestContainer","WebsocketsStandaloneFeature","FileManagerStandaloneFeature","server","websockets","attachWebsocketsServer","WebsocketsConnectionManager","createWebsocketsAuthenticator","startSchedulerServer","startBulkActionsServer"],"mappings":";;;;;;;;;;;;;;;AAsDO,SAASA,uBAAuBC,MAAoC;IACvE,OAAOC,oBAAoB;QACvB,MAAM,OAAMC;YAGRC,gBAAgB,QAAQ,CAACD;YASzBA,cAAc,iBAAiB,CAACE;YAChCF,cAAc,iBAAiB,CAACG;YAGhCH,cAAc,iBAAiB,CAACI;YAGhC,MAAMN,OAAO,mBAAmB,CAACE;YAOjCA,cAAc,QAAQ,CAACK,yBAAyB,gBAAgB;YAChEL,cAAc,QAAQ,CAACM,eAAe,gBAAgB;YAItDC,0BAA0B,QAAQ,CAACP;YAInCQ,0BAA0B,QAAQ,CAACR;YAEnCS,iBAAiB,QAAQ,CAACT;YAO1BU,iCAAiC,QAAQ,CAACV;YAS1CW,wBAAwBX;YAKxBY,sBAAsB,QAAQ,CAACZ;QACnC;QAEA,OAAO,OAAMa;YAKT,MAAMC,wBAAwBD,WAAW;gBACrC,YAAYf,OAAO,UAAU;gBAU7B,YAAY;oBAGR,UAAUiB,CAAAA;wBACNC,4BAA4B,QAAQ,CAACD;oBACzC;oBAKA,aAAaA,CAAAA;wBACTE,6BAA6B,QAAQ,CAACF;oBAC1C;gBACJ;YACJ;QACJ;QAEA,UAAU,OAAOG,QAAQlB;YASrB,MAAMmB,aAAaC,uBAAuB;gBACtCF;gBACA,mBAAmBlB,cAAc,OAAO,CAACqB;gBACzC,cAAcC,8BAA8BtB,eAAeF,OAAO,UAAU;YAChF;YACA,MAAMqB,WAAW,KAAK;YAItB,MAAMI,qBAAqBvB;YAG3BwB,uBAAuBxB;QAC3B;IACJ;AACJ"}
+{"version":3,"file":"createWebinyApiHandler.js","sources":["../src/createWebinyApiHandler.ts"],"sourcesContent":["/**\n * Webiny API handler for the standalone Node HTTP server transport — storage-agnostic BASE.\n *\n * The ROOT container wires the Node HTTP transport (NodeHttpFeature = event type + router + HttpFeature)\n * plus the auth/tenant loader decorators (extract token / x-tenant from the IncomingMessage → shared\n * RequestIdentityLoader / RequestTenantLoader). The per-request feature stack is the transport-agnostic\n * `registerApiRequestStack` from `@webiny/api-event-handler-core` — the SAME stack the AWS handler uses.\n * The realtime transport hook installs the server WebSockets transport (vs AWS's API Gateway Management\n * API) with a SINGLE-PROCESS, in-process implementation. Background tasks and the Bree scheduler are\n * ROOT-container singletons (below) — mirroring how the AWS handler registers background tasks at root,\n * and the WebSockets connection manager — rather than per-request transports; the scheduler fires timers\n * in-process (vs AWS's EventBridge). The storage variant (and identity provider) is injected via\n * `registerRootStorage`.\n *\n * The identity provider (e.g. `@webiny/self-hosted-auth`'s JWT IdP) must be registered by the variant\n * in `registerRootStorage`, so the RequestIdentityLoader driven by the identity decorator can resolve it.\n */\nimport { GraphQLSchemaCacheFeature } from \"@webiny/api-graphql\";\nimport { EncryptionKeyCacheFeature } from \"@webiny/api-core/features/encryption/index.js\";\nimport { JwksStoreFeature } from \"@webiny/api-core/idp/index.js\";\nimport type { Container } from \"@webiny/di\";\nimport { createServerHandler, NodeHttpFeature } from \"@webiny/event-handler-standalone\";\nimport { registerExtensions } from \"@webiny/handler\";\nimport { registerApiRequestStack } from \"@webiny/api-event-handler-core\";\nimport {\n    ServerConnectionManager,\n    NodeWsAdapter,\n    WebsocketsStandaloneFeature,\n    WebsocketsConnectionManager,\n    attachWebsocketsServer\n} from \"@webiny/api-websockets-standalone\";\nimport { BackgroundTasksStandaloneFeature } from \"@webiny/background-tasks-standalone\";\nimport { FileManagerStandaloneFeature } from \"@webiny/api-file-manager-standalone\";\nimport { registerSchedulerServer, startSchedulerServer } from \"~/scheduler/schedulerServer.js\";\nimport { startBulkActionsServer } from \"~/bulkActions/bulkActionsServer.js\";\nimport { NodeHttpIdentityLoaderDecorator } from \"~/handlers/NodeHttpIdentityLoaderDecorator.js\";\nimport { NodeHttpTenantLoaderDecorator } from \"~/handlers/NodeHttpTenantLoaderDecorator.js\";\nimport { NodeHttpAssumePermissionsDecorator } from \"~/handlers/NodeHttpAssumePermissionsDecorator.js\";\nimport { createWebsocketsAuthenticator } from \"~/websockets/createWebsocketsAuthenticator.js\";\nimport { EmptyTrashBinRouteFeature } from \"@webiny/api-headless-cms-bulk-actions-standalone\";\n\nexport interface CreateWebinyApiHandlerConfig {\n    /**\n     * Project-defined extensions, applied at register() time.\n     */\n    extensions: () => Parameters<typeof registerExtensions>[1];\n    /**\n     * Register ALL root-container storage for this deployment (the DB feature + CMS storage ops +\n     * registries) AND the identity provider. Unlike the AWS base, the server base bakes in no DB or\n     * IdP assumption — the variant supplies the complete storage + auth wiring.\n     */\n    registerRootStorage: (container: Container) => void | Promise<void>;\n    /**\n     * Register the per-request storage features (e.g. the CMS storage operations) in the request\n     * container, before `HeadlessCmsFeature` builds its storage. Optional.\n     */\n    registerRequestStorage?: (container: Container) => void | Promise<void>;\n}\n\nexport function createWebinyApiHandler(config: CreateWebinyApiHandlerConfig) {\n    return createServerHandler({\n        root: async rootContainer => {\n            // ── Transport (Node HTTP) ──────────────────────────────────\n            // NodeHttpFeature registers the event type + HttpFeature (router) + the routing terminal.\n            NodeHttpFeature.register(rootContainer);\n\n            // ── Tenant + auth (extract → shared load) ──────────────────\n            // registerDecorator applies LATER registrations as the OUTER wrapper (whose execute()\n            // runs first). TENANT must be established before IDENTITY: API-key authentication resolves\n            // the key by tenant partition (ApiKeysRepository reads TenantContext.getTenant()), so\n            // identity depends on the tenant; the reverse is not true (RequestTenantLoader has no\n            // identity dependency). Register identity first (inner) and tenant last (outer) → tenant\n            // runs, then identity, then the router.\n            rootContainer.registerDecorator(NodeHttpIdentityLoaderDecorator);\n            rootContainer.registerDecorator(NodeHttpTenantLoaderDecorator);\n\n            // Preview-as. Mirrors the AWS handler.\n            rootContainer.registerDecorator(NodeHttpAssumePermissionsDecorator);\n\n            // ── Storage + identity provider (variant-supplied) ─────────\n            await config.registerRootStorage(rootContainer);\n\n            // ── WebSockets transport (root) ────────────────────────────\n            // Live-socket registry + adapter live in the root as singletons: the connection manager\n            // is shared between the upgrade acceptor (attachWebsocketsServer, below) and the\n            // per-request ServerWebsocketsTransport that sends to those live sockets. The persistent\n            // connection registry (ConnectionRegistry) is the storage variant's job (e.g. sql).\n            rootContainer.register(ServerConnectionManager).inSingletonScope();\n            rootContainer.register(NodeWsAdapter).inSingletonScope();\n\n            // ── GraphQL schema cache (root) ────────────────────────────\n            // Root, so a built schema outlives the request that built it.\n            GraphQLSchemaCacheFeature.register(rootContainer);\n\n            // ── Encryption key cache (root) ────────────────────────────\n            // Root, so the scrypt-derived key is computed once per process instead of per request.\n            EncryptionKeyCacheFeature.register(rootContainer);\n            // Root, so identity providers' signing keys are fetched once per process, not per request.\n            JwksStoreFeature.register(rootContainer);\n\n            // ── Background tasks (root) ────────────────────────────────\n            // Mirrors the AWS handler registering its background-task transport at root. There is no\n            // Step Functions / Lambda re-invocation in a single process, so the transport is in-process:\n            // WorkerService (the BackgroundTasks/TaskService dispatch abstraction) runs each triggered\n            // task in a Node worker_thread that POSTs back to this server's `/background-task` HTTP route\n            // (BackgroundTaskRoute), which runs the task loop (continue/timeout/abort) in-process. Root,\n            // not per-request, is load-bearing: the shared InternalToken (registered here as a singleton)\n            // gates the route against the worker's callback, so dispatcher and route MUST see the SAME\n            // token — a per-request registration would mint a fresh token per request and always 403.\n            // The route is an HttpRoute; the per-request HttpRouter collects it via the parent chain.\n            BackgroundTasksStandaloneFeature.register(rootContainer);\n\n            // ── Scheduler (root) ───────────────────────────────────────\n            // The Bree scheduler is a single long-lived instance for ALL tenants, started once at boot\n            // (onServer, below) — the counterpart of the WebSockets connection manager, NOT a per-request\n            // transport. Registered here as SchedulerService (per-request create/update/delete during\n            // mutations manipulate this one live timer set) plus the run/recover HTTP routes + internal\n            // token. When a timer fires (outside any request) it POSTs `/scheduled-action-run`, which\n            // rebuilds the tenant's request context and executes the action.\n            registerSchedulerServer(rootContainer);\n\n            // ── Bulk actions (root) ───────────────────────────────────\n            // Registers the `/empty-trash-bins` HTTP route + internal token so the periodic trigger\n            // (startBulkActionsServer, onServer below) can POST to it after the server is listening.\n            EmptyTrashBinRouteFeature.register(rootContainer);\n        },\n\n        child: async container => {\n            // The transport-agnostic per-request stack. The realtime hook installs the server\n            // WebSockets transport (overriding the domain's NullWebsocketsTransport); it resolves the\n            // shared connection manager + adapter from the root. Scheduler is NOT a per-request\n            // transport here — it's a root singleton wired in `root` + `onServer` (see above).\n            await registerApiRequestStack(container, {\n                extensions: config.extensions,\n                registerRequestStorage: config.registerRequestStorage,\n                // Why hooks (and not just registering the transports ourselves): `.register()` calls\n                // are otherwise order-independent — you can register Features in any order, because\n                // they only REGISTER, they don't RESOLVE during registration (resolution happens\n                // later, in Initializers / SchemaFactories). The one thing that makes order matter is\n                // a DEFAULT registration: e.g. `WebsocketsFeature` registers `NullWebsocketsTransport`\n                // so the abstraction is always resolvable. Overriding it (last-registration-wins) means\n                // our transport MUST be registered AFTER that Feature. These hooks are the seams\n                // `registerApiRequestStack` provides for exactly that — each runs right after its Null\n                // default, so the override is guaranteed without the caller knowing the internal order.\n                transports: {\n                    // Server WebSockets transport; resolves the shared connection manager + adapter\n                    // from the root (registered as singletons above).\n                    realtime: requestContainer => {\n                        WebsocketsStandaloneFeature.register(requestContainer);\n                    },\n                    // File-manager storage transport: local disk. Where AWS uses S3 (+ a separate asset-\n                    // delivery Lambda), the single-process server stores files on disk and serves them\n                    // in-process — FileManagerStandaloneFeature registers local asset delivery (overriding\n                    // the domain's null impls), the upload/multipart HTTP routes, and disk file ops.\n                    fileManager: requestContainer => {\n                        FileManagerStandaloneFeature.register(requestContainer);\n                    }\n                }\n            });\n        },\n\n        onServer: async (server, rootContainer) => {\n            // Attach the WebSockets upgrade handler to the running HTTP server, backed by the shared\n            // (root) connection manager so request-time sends reach the live sockets.\n            //\n            // Authenticate each WebSocket connection from its `?token` JWT so it's registered under\n            // the real identity (targeted server→client sends match by identity id). It's a callback\n            // the handler supplies rather than something the WS server resolves itself — see\n            // createWebsocketsAuthenticator for why (AuthenticationContext is per-request, unreachable\n            // from the root container the WS server is attached to).\n            const websockets = attachWebsocketsServer({\n                server,\n                connectionManager: rootContainer.resolve(WebsocketsConnectionManager),\n                authenticate: createWebsocketsAuthenticator(rootContainer, config.extensions)\n            });\n            await websockets.start();\n\n            // Start the in-process scheduler timers, then re-arm persisted schedules (deferred until\n            // the server is listening — see startSchedulerServer).\n            await startSchedulerServer(rootContainer);\n\n            // Start the periodic empty-trash-bin trigger (deferred until the server is listening).\n            startBulkActionsServer(rootContainer);\n        }\n    });\n}\n"],"names":["createWebinyApiHandler","config","createServerHandler","rootContainer","NodeHttpFeature","NodeHttpIdentityLoaderDecorator","NodeHttpTenantLoaderDecorator","NodeHttpAssumePermissionsDecorator","ServerConnectionManager","NodeWsAdapter","GraphQLSchemaCacheFeature","EncryptionKeyCacheFeature","JwksStoreFeature","BackgroundTasksStandaloneFeature","registerSchedulerServer","EmptyTrashBinRouteFeature","container","registerApiRequestStack","requestContainer","WebsocketsStandaloneFeature","FileManagerStandaloneFeature","server","websockets","attachWebsocketsServer","WebsocketsConnectionManager","createWebsocketsAuthenticator","startSchedulerServer","startBulkActionsServer"],"mappings":";;;;;;;;;;;;;;;AA2DO,SAASA,uBAAuBC,MAAoC;IACvE,OAAOC,oBAAoB;QACvB,MAAM,OAAMC;YAGRC,gBAAgB,QAAQ,CAACD;YASzBA,cAAc,iBAAiB,CAACE;YAChCF,cAAc,iBAAiB,CAACG;YAGhCH,cAAc,iBAAiB,CAACI;YAGhC,MAAMN,OAAO,mBAAmB,CAACE;YAOjCA,cAAc,QAAQ,CAACK,yBAAyB,gBAAgB;YAChEL,cAAc,QAAQ,CAACM,eAAe,gBAAgB;YAItDC,0BAA0B,QAAQ,CAACP;YAInCQ,0BAA0B,QAAQ,CAACR;YAEnCS,iBAAiB,QAAQ,CAACT;YAY1BU,iCAAiC,QAAQ,CAACV;YAS1CW,wBAAwBX;YAKxBY,0BAA0B,QAAQ,CAACZ;QACvC;QAEA,OAAO,OAAMa;YAKT,MAAMC,wBAAwBD,WAAW;gBACrC,YAAYf,OAAO,UAAU;gBAC7B,wBAAwBA,OAAO,sBAAsB;gBAUrD,YAAY;oBAGR,UAAUiB,CAAAA;wBACNC,4BAA4B,QAAQ,CAACD;oBACzC;oBAKA,aAAaA,CAAAA;wBACTE,6BAA6B,QAAQ,CAACF;oBAC1C;gBACJ;YACJ;QACJ;QAEA,UAAU,OAAOG,QAAQlB;YASrB,MAAMmB,aAAaC,uBAAuB;gBACtCF;gBACA,mBAAmBlB,cAAc,OAAO,CAACqB;gBACzC,cAAcC,8BAA8BtB,eAAeF,OAAO,UAAU;YAChF;YACA,MAAMqB,WAAW,KAAK;YAItB,MAAMI,qBAAqBvB;YAG3BwB,uBAAuBxB;QAC3B;IACJ;AACJ"}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@webiny/api-event-handler-standalone",
-	"version": "0.0.0-unstable.5387e5f7c8",
+	"version": "0.0.0-unstable.eb81deee7e",
 	"type": "module",
 	"main": "index.js",
 	"exports": {
@@ -18,26 +18,27 @@
 	],
 	"license": "MIT",
 	"dependencies": {
-		"@webiny/api-core": "0.0.0-unstable.5387e5f7c8",
-		"@webiny/api-event-handler-core": "0.0.0-unstable.5387e5f7c8",
-		"@webiny/api-file-manager-standalone": "0.0.0-unstable.5387e5f7c8",
-		"@webiny/api-graphql": "0.0.0-unstable.5387e5f7c8",
-		"@webiny/api-headless-cms-bulk-actions-standalone": "0.0.0-unstable.5387e5f7c8",
-		"@webiny/api-scheduler": "0.0.0-unstable.5387e5f7c8",
-		"@webiny/api-scheduler-standalone": "0.0.0-unstable.5387e5f7c8",
-		"@webiny/api-websockets-standalone": "0.0.0-unstable.5387e5f7c8",
-		"@webiny/background-tasks-standalone": "0.0.0-unstable.5387e5f7c8",
-		"@webiny/event-handler-core": "0.0.0-unstable.5387e5f7c8",
-		"@webiny/event-handler-standalone": "0.0.0-unstable.5387e5f7c8",
-		"@webiny/feature": "0.0.0-unstable.5387e5f7c8",
-		"@webiny/handler": "0.0.0-unstable.5387e5f7c8"
+		"@webiny/api-core": "0.0.0-unstable.eb81deee7e",
+		"@webiny/api-event-handler-core": "0.0.0-unstable.eb81deee7e",
+		"@webiny/api-file-manager-standalone": "0.0.0-unstable.eb81deee7e",
+		"@webiny/api-graphql": "0.0.0-unstable.eb81deee7e",
+		"@webiny/api-headless-cms-bulk-actions-standalone": "0.0.0-unstable.eb81deee7e",
+		"@webiny/api-scheduler": "0.0.0-unstable.eb81deee7e",
+		"@webiny/api-scheduler-standalone": "0.0.0-unstable.eb81deee7e",
+		"@webiny/api-websockets-standalone": "0.0.0-unstable.eb81deee7e",
+		"@webiny/background-tasks-standalone": "0.0.0-unstable.eb81deee7e",
+		"@webiny/event-handler-core": "0.0.0-unstable.eb81deee7e",
+		"@webiny/event-handler-standalone": "0.0.0-unstable.eb81deee7e",
+		"@webiny/feature": "0.0.0-unstable.eb81deee7e",
+		"@webiny/handler": "0.0.0-unstable.eb81deee7e",
+		"@webiny/stdlib": "0.0.17"
 	},
 	"peerDependencies": {
-		"@webiny/di": "^2.0.0"
+		"@webiny/di": "^1.1.0"
 	},
 	"devDependencies": {
-		"@webiny/build-tools": "0.0.0-unstable.5387e5f7c8",
-		"@webiny/di": "2.0.0",
+		"@webiny/build-tools": "0.0.0-unstable.eb81deee7e",
+		"@webiny/di": "1.1.0",
 		"rimraf": "6.1.3",
 		"typescript": "7.0.2",
 		"vitest": "4.1.11"

package/scheduler/ScheduledActionRecoverRoute.d.ts

@@ -0,0 +1,34 @@
+import { HttpRouteDefinition, HttpRouteHandler } from "@webiny/event-handler-core";
+import type { Container } from "@webiny/feature/api";
+import { SchedulerInternalToken } from "./abstractions/InternalToken.js";
+/**
+ * Re-arms the persisted (pending) scheduled actions for a tenant into the root Bree singleton — used
+ * at boot to restore schedules after a restart. Runs the full request-context bootstrap (like the run
+ * route) so ListScheduledActionsUseCase has its CMS model, then hands the results to the singleton's
+ * `recover()`. Defaults to the root tenant when no tenant is given.
+ *
+ * NOTE: recovers ONE tenant per call. Boot recovery for additional (non-root) tenants would enumerate
+ * tenants and call this per tenant — left as a follow-up; single/root-tenant deployments are covered.
+ */
+declare class ScheduledActionRecoverRouteImpl implements HttpRouteHandler.Interface {
+    private readonly container;
+    private readonly internalToken;
+    constructor(container: Container, internalToken: SchedulerInternalToken.Interface);
+    handle(request: HttpRouteHandler.Request, response: HttpRouteHandler.Response): Promise<import("@webiny/event-handler-core").IHttpResponseBuilder>;
+}
+export declare const ScheduledActionRecoverRoute: typeof ScheduledActionRecoverRouteImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/event-handler-core").IHttpRoute>;
+};
+declare class ScheduledActionRecoverRouteDefinitionImpl implements HttpRouteDefinition.Interface {
+    readonly name = "scheduled-action-recover";
+    readonly method = "POST";
+    readonly path = "/scheduled-action-recover";
+    readonly handler: typeof ScheduledActionRecoverRouteImpl & {
+        __abstraction: import("@webiny/di").Abstraction<import("@webiny/event-handler-core").IHttpRoute>;
+    };
+}
+/** What the router matches on. Zero dependencies, so building it costs nothing. */
+export declare const ScheduledActionRecoverRouteDefinition: typeof ScheduledActionRecoverRouteDefinitionImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/event-handler-core").IHttpRouteDefinition>;
+};
+export {};

package/scheduler/ScheduledActionRecoverRoute.js

@@ -0,0 +1,84 @@
+import { HttpRouteDefinition, HttpRouteHandler, RequestContainer } from "@webiny/event-handler-core";
+import { RawTenantId, RequestTenantLoader } from "@webiny/api-core/features/requestContext/index.js";
+import { GetRootTenantUseCase } from "@webiny/api-core/features/tenancy/GetRootTenant/index.js";
+import { IdentityContext } from "@webiny/api-core/exports/api/security.js";
+import { ListScheduledActionsUseCase } from "@webiny/api-scheduler/features/ListScheduledActions/index.js";
+import { SchedulerInternalToken } from "./abstractions/InternalToken.js";
+import { SchedulerSingleton } from "./abstractions/SchedulerSingleton.js";
+const INTERNAL_HEADER = "x-webiny-scheduler-token";
+class ScheduledActionRecoverRouteImpl {
+    constructor(container, internalToken){
+        this.container = container;
+        this.internalToken = internalToken;
+    }
+    async handle(request, response) {
+        if (request.headers[INTERNAL_HEADER] !== this.internalToken.value) return response.status(403).json({
+            error: "Forbidden."
+        });
+        try {
+            let tenant = request.body?.tenant;
+            if (!tenant) {
+                const rootResult = await this.container.resolve(GetRootTenantUseCase).execute();
+                if (rootResult.isFail()) return response.json({
+                    status: "ok",
+                    recovered: 0
+                });
+                tenant = rootResult.value.id;
+            }
+            this.container.resolve(RawTenantId).set(tenant);
+            await this.container.resolve(RequestTenantLoader).establish();
+            const listResult = await this.container.resolve(IdentityContext).withoutAuthorization(()=>this.container.resolve(ListScheduledActionsUseCase).execute({
+                    where: {},
+                    limit: 1000
+                }));
+            if (listResult.isFail()) return response.status(500).json({
+                status: "error",
+                error: {
+                    message: listResult.error.message
+                }
+            });
+            const pending = listResult.value.items.map((action)=>({
+                    id: action.id,
+                    namespace: action.namespace,
+                    tenant: tenant,
+                    scheduledFor: action.scheduledFor
+                }));
+            await this.container.resolve(SchedulerSingleton).recover(pending);
+            return response.json({
+                status: "ok",
+                recovered: pending.length
+            });
+        } catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            console.error(`Scheduled action recover route error: ${message}`);
+            return response.status(500).json({
+                status: "error",
+                error: {
+                    message
+                }
+            });
+        }
+    }
+}
+const ScheduledActionRecoverRoute = HttpRouteHandler.createImplementation({
+    implementation: ScheduledActionRecoverRouteImpl,
+    dependencies: [
+        RequestContainer,
+        SchedulerInternalToken
+    ]
+});
+class ScheduledActionRecoverRouteDefinitionImpl {
+    constructor(){
+        this.name = "scheduled-action-recover";
+        this.method = "POST";
+        this.path = "/scheduled-action-recover";
+        this.handler = ScheduledActionRecoverRoute;
+    }
+}
+const ScheduledActionRecoverRouteDefinition = HttpRouteDefinition.createImplementation({
+    implementation: ScheduledActionRecoverRouteDefinitionImpl,
+    dependencies: []
+});
+export { ScheduledActionRecoverRoute, ScheduledActionRecoverRouteDefinition };
+
+//# sourceMappingURL=ScheduledActionRecoverRoute.js.map

package/scheduler/ScheduledActionRecoverRoute.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheduler/ScheduledActionRecoverRoute.js","sources":["../../src/scheduler/ScheduledActionRecoverRoute.ts"],"sourcesContent":["import {\n    HttpRouteDefinition,\n    HttpRouteHandler,\n    RequestContainer\n} from \"@webiny/event-handler-core\";\nimport {\n    RawTenantId,\n    RequestTenantLoader\n} from \"@webiny/api-core/features/requestContext/index.js\";\nimport { GetRootTenantUseCase } from \"@webiny/api-core/features/tenancy/GetRootTenant/index.js\";\nimport { IdentityContext } from \"@webiny/api-core/exports/api/security.js\";\nimport { ListScheduledActionsUseCase } from \"@webiny/api-scheduler/features/ListScheduledActions/index.js\";\nimport type { Container } from \"@webiny/feature/api\";\nimport { SchedulerInternalToken } from \"./abstractions/InternalToken.js\";\nimport { SchedulerSingleton } from \"./abstractions/SchedulerSingleton.js\";\n\nconst INTERNAL_HEADER = \"x-webiny-scheduler-token\";\n\n/**\n * Re-arms the persisted (pending) scheduled actions for a tenant into the root Bree singleton — used\n * at boot to restore schedules after a restart. Runs the full request-context bootstrap (like the run\n * route) so ListScheduledActionsUseCase has its CMS model, then hands the results to the singleton's\n * `recover()`. Defaults to the root tenant when no tenant is given.\n *\n * NOTE: recovers ONE tenant per call. Boot recovery for additional (non-root) tenants would enumerate\n * tenants and call this per tenant — left as a follow-up; single/root-tenant deployments are covered.\n */\nclass ScheduledActionRecoverRouteImpl implements HttpRouteHandler.Interface {\n    public constructor(\n        private readonly container: Container,\n        private readonly internalToken: SchedulerInternalToken.Interface\n    ) {}\n\n    public async handle(request: HttpRouteHandler.Request, response: HttpRouteHandler.Response) {\n        if (request.headers[INTERNAL_HEADER] !== this.internalToken.value) {\n            return response.status(403).json({ error: \"Forbidden.\" });\n        }\n\n        try {\n            let tenant: string | undefined = request.body?.tenant;\n            if (!tenant) {\n                const rootResult = await this.container.resolve(GetRootTenantUseCase).execute();\n                if (rootResult.isFail()) {\n                    return response.json({ status: \"ok\", recovered: 0 });\n                }\n                tenant = rootResult.value.id;\n            }\n\n            this.container.resolve(RawTenantId).set(tenant);\n            await this.container.resolve(RequestTenantLoader).establish();\n\n            // At boot there's no request and no identity, so we skip authorization for the list — the\n            // same thing ExecuteScheduledActionUseCase does on the run route. Without it, the\n            // permission check in ListScheduledActions sees the anonymous identity and fails with\n            // \"Not authorized!\".\n            const listResult = await this.container\n                .resolve(IdentityContext)\n                .withoutAuthorization(() =>\n                    this.container\n                        .resolve(ListScheduledActionsUseCase)\n                        .execute({ where: {}, limit: 1000 })\n                );\n\n            if (listResult.isFail()) {\n                return response\n                    .status(500)\n                    .json({ status: \"error\", error: { message: listResult.error.message } });\n            }\n\n            const pending = listResult.value.items.map(action => ({\n                id: action.id,\n                namespace: action.namespace,\n                tenant: tenant as string,\n                scheduledFor: action.scheduledFor\n            }));\n\n            await this.container.resolve(SchedulerSingleton).recover(pending);\n\n            return response.json({ status: \"ok\", recovered: pending.length });\n        } catch (err) {\n            const message = err instanceof Error ? err.message : String(err);\n            console.error(`Scheduled action recover route error: ${message}`);\n            return response.status(500).json({ status: \"error\", error: { message } });\n        }\n    }\n}\n\nexport const ScheduledActionRecoverRoute = HttpRouteHandler.createImplementation({\n    implementation: ScheduledActionRecoverRouteImpl,\n    dependencies: [RequestContainer, SchedulerInternalToken]\n});\n\nclass ScheduledActionRecoverRouteDefinitionImpl implements HttpRouteDefinition.Interface {\n    readonly name = \"scheduled-action-recover\";\n    readonly method = \"POST\";\n    readonly path = \"/scheduled-action-recover\";\n    readonly handler = ScheduledActionRecoverRoute;\n}\n\n/** What the router matches on. Zero dependencies, so building it costs nothing. */\nexport const ScheduledActionRecoverRouteDefinition = HttpRouteDefinition.createImplementation({\n    implementation: ScheduledActionRecoverRouteDefinitionImpl,\n    dependencies: []\n});\n"],"names":["INTERNAL_HEADER","ScheduledActionRecoverRouteImpl","container","internalToken","request","response","tenant","rootResult","GetRootTenantUseCase","RawTenantId","RequestTenantLoader","listResult","IdentityContext","ListScheduledActionsUseCase","pending","action","SchedulerSingleton","err","message","Error","String","console","ScheduledActionRecoverRoute","HttpRouteHandler","RequestContainer","SchedulerInternalToken","ScheduledActionRecoverRouteDefinitionImpl","ScheduledActionRecoverRouteDefinition","HttpRouteDefinition"],"mappings":";;;;;;;AAgBA,MAAMA,kBAAkB;AAWxB,MAAMC;IACF,YACqBC,SAAoB,EACpBC,aAA+C,CAClE;aAFmBD,SAAS,GAATA;aACAC,aAAa,GAAbA;IAClB;IAEH,MAAa,OAAOC,OAAiC,EAAEC,QAAmC,EAAE;QACxF,IAAID,QAAQ,OAAO,CAACJ,gBAAgB,KAAK,IAAI,CAAC,aAAa,CAAC,KAAK,EAC7D,OAAOK,SAAS,MAAM,CAAC,KAAK,IAAI,CAAC;YAAE,OAAO;QAAa;QAG3D,IAAI;YACA,IAAIC,SAA6BF,QAAQ,IAAI,EAAE;YAC/C,IAAI,CAACE,QAAQ;gBACT,MAAMC,aAAa,MAAM,IAAI,CAAC,SAAS,CAAC,OAAO,CAACC,sBAAsB,OAAO;gBAC7E,IAAID,WAAW,MAAM,IACjB,OAAOF,SAAS,IAAI,CAAC;oBAAE,QAAQ;oBAAM,WAAW;gBAAE;gBAEtDC,SAASC,WAAW,KAAK,CAAC,EAAE;YAChC;YAEA,IAAI,CAAC,SAAS,CAAC,OAAO,CAACE,aAAa,GAAG,CAACH;YACxC,MAAM,IAAI,CAAC,SAAS,CAAC,OAAO,CAACI,qBAAqB,SAAS;YAM3D,MAAMC,aAAa,MAAM,IAAI,CAAC,SAAS,CAClC,OAAO,CAACC,iBACR,oBAAoB,CAAC,IAClB,IAAI,CAAC,SAAS,CACT,OAAO,CAACC,6BACR,OAAO,CAAC;oBAAE,OAAO,CAAC;oBAAG,OAAO;gBAAK;YAG9C,IAAIF,WAAW,MAAM,IACjB,OAAON,SACF,MAAM,CAAC,KACP,IAAI,CAAC;gBAAE,QAAQ;gBAAS,OAAO;oBAAE,SAASM,WAAW,KAAK,CAAC,OAAO;gBAAC;YAAE;YAG9E,MAAMG,UAAUH,WAAW,KAAK,CAAC,KAAK,CAAC,GAAG,CAACI,CAAAA,SAAW;oBAClD,IAAIA,OAAO,EAAE;oBACb,WAAWA,OAAO,SAAS;oBAC3B,QAAQT;oBACR,cAAcS,OAAO,YAAY;gBACrC;YAEA,MAAM,IAAI,CAAC,SAAS,CAAC,OAAO,CAACC,oBAAoB,OAAO,CAACF;YAEzD,OAAOT,SAAS,IAAI,CAAC;gBAAE,QAAQ;gBAAM,WAAWS,QAAQ,MAAM;YAAC;QACnE,EAAE,OAAOG,KAAK;YACV,MAAMC,UAAUD,eAAeE,QAAQF,IAAI,OAAO,GAAGG,OAAOH;YAC5DI,QAAQ,KAAK,CAAC,CAAC,sCAAsC,EAAEH,SAAS;YAChE,OAAOb,SAAS,MAAM,CAAC,KAAK,IAAI,CAAC;gBAAE,QAAQ;gBAAS,OAAO;oBAAEa;gBAAQ;YAAE;QAC3E;IACJ;AACJ;AAEO,MAAMI,8BAA8BC,iBAAiB,oBAAoB,CAAC;IAC7E,gBAAgBtB;IAChB,cAAc;QAACuB;QAAkBC;KAAuB;AAC5D;AAEA,MAAMC;;aACO,IAAI,GAAG;aACP,MAAM,GAAG;aACT,IAAI,GAAG;aACP,OAAO,GAAGJ;;AACvB;AAGO,MAAMK,wCAAwCC,oBAAoB,oBAAoB,CAAC;IAC1F,gBAAgBF;IAChB,cAAc,EAAE;AACpB"}

package/scheduler/ScheduledActionRunRoute.d.ts

@@ -0,0 +1,31 @@
+import { HttpRouteDefinition, HttpRouteHandler } from "@webiny/event-handler-core";
+import type { Container } from "@webiny/feature/api";
+import { SchedulerInternalToken } from "./abstractions/InternalToken.js";
+/**
+ * Runs a single scheduled action. The in-process Bree singleton (root) POSTs here when a timer fires —
+ * the timer fires OUTSIDE any HTTP request, so this route rebuilds the full request context (tenant +
+ * CMS models via the request-context initializers + contextual schemas) for the action's tenant, then
+ * runs ExecuteScheduledActionUseCase. Mirrors the background-task run route.
+ */
+declare class ScheduledActionRunRouteImpl implements HttpRouteHandler.Interface {
+    private readonly container;
+    private readonly internalToken;
+    constructor(container: Container, internalToken: SchedulerInternalToken.Interface);
+    handle(request: HttpRouteHandler.Request, response: HttpRouteHandler.Response): Promise<import("@webiny/event-handler-core").IHttpResponseBuilder>;
+}
+export declare const ScheduledActionRunRoute: typeof ScheduledActionRunRouteImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/event-handler-core").IHttpRoute>;
+};
+declare class ScheduledActionRunRouteDefinitionImpl implements HttpRouteDefinition.Interface {
+    readonly name = "scheduled-action-run";
+    readonly method = "POST";
+    readonly path = "/scheduled-action-run";
+    readonly handler: typeof ScheduledActionRunRouteImpl & {
+        __abstraction: import("@webiny/di").Abstraction<import("@webiny/event-handler-core").IHttpRoute>;
+    };
+}
+/** What the router matches on. Zero dependencies, so building it costs nothing. */
+export declare const ScheduledActionRunRouteDefinition: typeof ScheduledActionRunRouteDefinitionImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/event-handler-core").IHttpRouteDefinition>;
+};
+export {};

package/scheduler/ScheduledActionRunRoute.js

@@ -0,0 +1,69 @@
+import { HttpRouteDefinition, HttpRouteHandler, RequestContainer } from "@webiny/event-handler-core";
+import { RawTenantId, RequestTenantLoader } from "@webiny/api-core/features/requestContext/index.js";
+import { ExecuteScheduledActionUseCase } from "@webiny/api-scheduler/features/ExecuteScheduledAction/index.js";
+import { SchedulerInternalToken } from "./abstractions/InternalToken.js";
+const INTERNAL_HEADER = "x-webiny-scheduler-token";
+class ScheduledActionRunRouteImpl {
+    constructor(container, internalToken){
+        this.container = container;
+        this.internalToken = internalToken;
+    }
+    async handle(request, response) {
+        if (request.headers[INTERNAL_HEADER] !== this.internalToken.value) return response.status(403).json({
+            error: "Forbidden."
+        });
+        const { id, namespace, tenant } = request.body ?? {};
+        if (!id || !namespace || !tenant) return response.status(400).json({
+            error: "Missing id, namespace or tenant."
+        });
+        try {
+            this.container.resolve(RawTenantId).set(tenant);
+            await this.container.resolve(RequestTenantLoader).establish();
+            const result = await this.container.resolve(ExecuteScheduledActionUseCase).execute({
+                id,
+                namespace,
+                tenant
+            });
+            if (result.isFail()) return response.status(500).json({
+                status: "error",
+                error: {
+                    message: result.error.message
+                }
+            });
+            return response.json({
+                status: "ok"
+            });
+        } catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            console.error(`Scheduled action run route error: ${message}`);
+            return response.status(500).json({
+                status: "error",
+                error: {
+                    message
+                }
+            });
+        }
+    }
+}
+const ScheduledActionRunRoute = HttpRouteHandler.createImplementation({
+    implementation: ScheduledActionRunRouteImpl,
+    dependencies: [
+        RequestContainer,
+        SchedulerInternalToken
+    ]
+});
+class ScheduledActionRunRouteDefinitionImpl {
+    constructor(){
+        this.name = "scheduled-action-run";
+        this.method = "POST";
+        this.path = "/scheduled-action-run";
+        this.handler = ScheduledActionRunRoute;
+    }
+}
+const ScheduledActionRunRouteDefinition = HttpRouteDefinition.createImplementation({
+    implementation: ScheduledActionRunRouteDefinitionImpl,
+    dependencies: []
+});
+export { ScheduledActionRunRoute, ScheduledActionRunRouteDefinition };
+
+//# sourceMappingURL=ScheduledActionRunRoute.js.map

package/scheduler/ScheduledActionRunRoute.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheduler/ScheduledActionRunRoute.js","sources":["../../src/scheduler/ScheduledActionRunRoute.ts"],"sourcesContent":["import {\n    HttpRouteDefinition,\n    HttpRouteHandler,\n    RequestContainer\n} from \"@webiny/event-handler-core\";\nimport {\n    RawTenantId,\n    RequestTenantLoader\n} from \"@webiny/api-core/features/requestContext/index.js\";\nimport { ExecuteScheduledActionUseCase } from \"@webiny/api-scheduler/features/ExecuteScheduledAction/index.js\";\nimport type { Container } from \"@webiny/feature/api\";\nimport { SchedulerInternalToken } from \"./abstractions/InternalToken.js\";\n\n/* Shared between the Bree singleton and this route to gate access. */\nconst INTERNAL_HEADER = \"x-webiny-scheduler-token\";\n\n/**\n * Runs a single scheduled action. The in-process Bree singleton (root) POSTs here when a timer fires —\n * the timer fires OUTSIDE any HTTP request, so this route rebuilds the full request context (tenant +\n * CMS models via the request-context initializers + contextual schemas) for the action's tenant, then\n * runs ExecuteScheduledActionUseCase. Mirrors the background-task run route.\n */\nclass ScheduledActionRunRouteImpl implements HttpRouteHandler.Interface {\n    public constructor(\n        private readonly container: Container,\n        private readonly internalToken: SchedulerInternalToken.Interface\n    ) {}\n\n    public async handle(request: HttpRouteHandler.Request, response: HttpRouteHandler.Response) {\n        if (request.headers[INTERNAL_HEADER] !== this.internalToken.value) {\n            return response.status(403).json({ error: \"Forbidden.\" });\n        }\n\n        const { id, namespace, tenant } = request.body ?? {};\n        if (!id || !namespace || !tenant) {\n            return response.status(400).json({ error: \"Missing id, namespace or tenant.\" });\n        }\n\n        try {\n            this.container.resolve(RawTenantId).set(tenant);\n            await this.container.resolve(RequestTenantLoader).establish();\n\n            const result = await this.container\n                .resolve(ExecuteScheduledActionUseCase)\n                .execute({ id, namespace, tenant });\n\n            if (result.isFail()) {\n                return response\n                    .status(500)\n                    .json({ status: \"error\", error: { message: result.error.message } });\n            }\n\n            return response.json({ status: \"ok\" });\n        } catch (err) {\n            const message = err instanceof Error ? err.message : String(err);\n            console.error(`Scheduled action run route error: ${message}`);\n            return response.status(500).json({ status: \"error\", error: { message } });\n        }\n    }\n}\n\nexport const ScheduledActionRunRoute = HttpRouteHandler.createImplementation({\n    implementation: ScheduledActionRunRouteImpl,\n    dependencies: [RequestContainer, SchedulerInternalToken]\n});\n\nclass ScheduledActionRunRouteDefinitionImpl implements HttpRouteDefinition.Interface {\n    readonly name = \"scheduled-action-run\";\n    readonly method = \"POST\";\n    readonly path = \"/scheduled-action-run\";\n    readonly handler = ScheduledActionRunRoute;\n}\n\n/** What the router matches on. Zero dependencies, so building it costs nothing. */\nexport const ScheduledActionRunRouteDefinition = HttpRouteDefinition.createImplementation({\n    implementation: ScheduledActionRunRouteDefinitionImpl,\n    dependencies: []\n});\n"],"names":["INTERNAL_HEADER","ScheduledActionRunRouteImpl","container","internalToken","request","response","id","namespace","tenant","RawTenantId","RequestTenantLoader","result","ExecuteScheduledActionUseCase","err","message","Error","String","console","ScheduledActionRunRoute","HttpRouteHandler","RequestContainer","SchedulerInternalToken","ScheduledActionRunRouteDefinitionImpl","ScheduledActionRunRouteDefinition","HttpRouteDefinition"],"mappings":";;;;AAcA,MAAMA,kBAAkB;AAQxB,MAAMC;IACF,YACqBC,SAAoB,EACpBC,aAA+C,CAClE;aAFmBD,SAAS,GAATA;aACAC,aAAa,GAAbA;IAClB;IAEH,MAAa,OAAOC,OAAiC,EAAEC,QAAmC,EAAE;QACxF,IAAID,QAAQ,OAAO,CAACJ,gBAAgB,KAAK,IAAI,CAAC,aAAa,CAAC,KAAK,EAC7D,OAAOK,SAAS,MAAM,CAAC,KAAK,IAAI,CAAC;YAAE,OAAO;QAAa;QAG3D,MAAM,EAAEC,EAAE,EAAEC,SAAS,EAAEC,MAAM,EAAE,GAAGJ,QAAQ,IAAI,IAAI,CAAC;QACnD,IAAI,CAACE,MAAM,CAACC,aAAa,CAACC,QACtB,OAAOH,SAAS,MAAM,CAAC,KAAK,IAAI,CAAC;YAAE,OAAO;QAAmC;QAGjF,IAAI;YACA,IAAI,CAAC,SAAS,CAAC,OAAO,CAACI,aAAa,GAAG,CAACD;YACxC,MAAM,IAAI,CAAC,SAAS,CAAC,OAAO,CAACE,qBAAqB,SAAS;YAE3D,MAAMC,SAAS,MAAM,IAAI,CAAC,SAAS,CAC9B,OAAO,CAACC,+BACR,OAAO,CAAC;gBAAEN;gBAAIC;gBAAWC;YAAO;YAErC,IAAIG,OAAO,MAAM,IACb,OAAON,SACF,MAAM,CAAC,KACP,IAAI,CAAC;gBAAE,QAAQ;gBAAS,OAAO;oBAAE,SAASM,OAAO,KAAK,CAAC,OAAO;gBAAC;YAAE;YAG1E,OAAON,SAAS,IAAI,CAAC;gBAAE,QAAQ;YAAK;QACxC,EAAE,OAAOQ,KAAK;YACV,MAAMC,UAAUD,eAAeE,QAAQF,IAAI,OAAO,GAAGG,OAAOH;YAC5DI,QAAQ,KAAK,CAAC,CAAC,kCAAkC,EAAEH,SAAS;YAC5D,OAAOT,SAAS,MAAM,CAAC,KAAK,IAAI,CAAC;gBAAE,QAAQ;gBAAS,OAAO;oBAAES;gBAAQ;YAAE;QAC3E;IACJ;AACJ;AAEO,MAAMI,0BAA0BC,iBAAiB,oBAAoB,CAAC;IACzE,gBAAgBlB;IAChB,cAAc;QAACmB;QAAkBC;KAAuB;AAC5D;AAEA,MAAMC;;aACO,IAAI,GAAG;aACP,MAAM,GAAG;aACT,IAAI,GAAG;aACP,OAAO,GAAGJ;;AACvB;AAGO,MAAMK,oCAAoCC,oBAAoB,oBAAoB,CAAC;IACtF,gBAAgBF;IAChB,cAAc,EAAE;AACpB"}

package/scheduler/abstractions/InternalToken.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Per-process token generated at startup, shared between the in-process Bree scheduler singleton and
+ * the scheduler routes via DI. The singleton sends it as a header when a timer fires; the routes
+ * reject requests without a matching value. Single-process only — for multi-server, replace with a
+ * shared secret. Mirrors the background-tasks InternalToken.
+ */
+interface IInternalToken {
+    readonly value: string;
+}
+export declare const SchedulerInternalToken: import("@webiny/di").Abstraction<IInternalToken>;
+export declare namespace SchedulerInternalToken {
+    type Interface = IInternalToken;
+}
+export {};

package/scheduler/abstractions/InternalToken.js

@@ -0,0 +1,5 @@
+import { createAbstraction } from "@webiny/feature/api";
+const SchedulerInternalToken = createAbstraction("SchedulerServer/InternalToken");
+export { SchedulerInternalToken };
+
+//# sourceMappingURL=InternalToken.js.map

package/scheduler/abstractions/InternalToken.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheduler/abstractions/InternalToken.js","sources":["../../../src/scheduler/abstractions/InternalToken.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\n\n/**\n * Per-process token generated at startup, shared between the in-process Bree scheduler singleton and\n * the scheduler routes via DI. The singleton sends it as a header when a timer fires; the routes\n * reject requests without a matching value. Single-process only — for multi-server, replace with a\n * shared secret. Mirrors the background-tasks InternalToken.\n */\ninterface IInternalToken {\n    readonly value: string;\n}\n\nexport const SchedulerInternalToken = createAbstraction<IInternalToken>(\n    \"SchedulerServer/InternalToken\"\n);\n\nexport namespace SchedulerInternalToken {\n    export type Interface = IInternalToken;\n}\n"],"names":["SchedulerInternalToken","createAbstraction"],"mappings":";AAYO,MAAMA,yBAAyBC,kBAClC"}

package/scheduler/schedulerServer.d.ts

@@ -1,17 +1,20 @@
 import type { Container } from "@webiny/di";
 /**
  * ROOT wiring for the standalone (Bree, in-process) scheduler. Unlike AWS (per-request EventBridge
- * binding), the server holds ONE long-lived Bree instance for all tenants, started once at boot —
- * the counterpart of the WebSockets connection manager. Registered as `SchedulerService` so
- * per-request create/update/delete (during GraphQL mutations) manipulate that single live timer set.
+ * binding), the server holds ONE long-lived Bree instance for all tenants, started once at boot — the
+ * counterpart of the WebSockets connection manager. Registered as `SchedulerService` so per-request
+ * create/update/delete (during GraphQL mutations) manipulate that single live timer set.
  *
- * When a timer fires (outside any request), the singleton dispatches a `ScheduledActionEvent`. The
- * handler is the one AWS runs for an EventBridge Scheduler invocation, in a fresh request container.
+ * When a timer fires (outside any request), the singleton POSTs to `/scheduled-action-run`, which
+ * rebuilds the request context for the action's tenant and executes it (see the route).
  */
 export declare function registerSchedulerServer(rootContainer: Container): void;
 /**
- * Boot step (onServer): start the timers, then re-arm the persisted schedules. Recovery runs in the
- * background: it executes overdue actions one by one, and the server should not wait for that
- * before it starts listening. A failure is logged and never crashes startup.
+ * Boot step (onServer): start the timers, then re-arm persisted schedules by POSTing the recover route
+ * (root tenant).
+ *
+ * `onServer` runs BEFORE the HTTP server starts listening, so the recover POST (which hits this same
+ * server) is DEFERRED to the next tick — by then `createServerHandler` has returned and the runner has
+ * called `.listen()`. Fire-and-forget: a recovery failure must never block or crash startup.
  */
 export declare function startSchedulerServer(rootContainer: Container): Promise<void>;

package/scheduler/schedulerServer.js

@@ -1,10 +1,11 @@
-import { EventDispatcher, SCHEDULED_ACTION_EVENT_IDENTIFIER, ScheduledActionEventType } from "@webiny/event-handler-core";
+import { uuid } from "@webiny/stdlib";
 import { SchedulerService } from "@webiny/api-scheduler/shared/abstractions.js";
-import { ScheduledActionLambdaHandler } from "@webiny/api-scheduler";
 import { BreeSchedulerService } from "@webiny/api-scheduler-standalone";
+import { SchedulerInternalToken } from "./abstractions/InternalToken.js";
 import { SchedulerSingleton } from "./abstractions/SchedulerSingleton.js";
-import { SCHEDULED_ACTION_RECOVER_EVENT_IDENTIFIER, ScheduledActionRecoverEventType } from "./ScheduledActionRecoverEventType.js";
-import { RecoverScheduledActionsHandler } from "./RecoverScheduledActionsHandler.js";
+import { ScheduledActionRunRouteDefinition } from "./ScheduledActionRunRoute.js";
+import { ScheduledActionRecoverRouteDefinition } from "./ScheduledActionRecoverRoute.js";
+const SCHEDULER_HEADER = "x-webiny-scheduler-token";
 const consoleLogger = {
     trace: (...args)=>console.trace(...args),
     debug: (...args)=>console.debug(...args),
@@ -14,48 +15,66 @@ const consoleLogger = {
     fatal: (...args)=>console.error(...args),
     log: (...args)=>console.log(...args)
 };
+const serverBase = ()=>`http://localhost:${process.env.PORT || "3002"}`;
 function registerSchedulerServer(rootContainer) {
-    const dispatcher = rootContainer.resolve(EventDispatcher);
+    const token = uuid();
+    rootContainer.registerInstance(SchedulerInternalToken, {
+        value: token
+    });
     const service = new BreeSchedulerService({
         logger: consoleLogger,
         onTrigger: async (id, namespace, tenant)=>{
-            const event = {
-                [SCHEDULED_ACTION_EVENT_IDENTIFIER]: {
-                    id,
-                    namespace,
-                    tenant,
-                    scheduleFor: new Date().toISOString()
-                }
-            };
+            console.log(`[scheduler] timer fired for "${id}" (namespace=${namespace}, tenant=${tenant}); calling run route`);
             try {
-                await dispatcher.dispatch(event);
+                const res = await fetch(`${serverBase()}/scheduled-action-run`, {
+                    method: "POST",
+                    headers: {
+                        "content-type": "application/json",
+                        [SCHEDULER_HEADER]: token
+                    },
+                    body: JSON.stringify({
+                        id,
+                        namespace,
+                        tenant
+                    })
+                });
+                if (!res.ok) {
+                    const body = await res.text().catch(()=>"");
+                    console.error(`[scheduler] run route returned HTTP ${res.status} for "${id}": ${body}`);
+                }
             } catch (err) {
-                console.error(`[scheduler] scheduled action "${id}" failed:`, err);
+                const message = err instanceof Error ? err.message : String(err);
+                console.error(`Scheduler trigger for "${id}" failed to reach the run route: ${message}`);
             }
         }
     });
     rootContainer.registerInstance(SchedulerSingleton, service);
     rootContainer.registerInstance(SchedulerService, service);
-    rootContainer.register(ScheduledActionEventType);
-    rootContainer.register(ScheduledActionLambdaHandler);
-    rootContainer.register(ScheduledActionRecoverEventType);
-    rootContainer.register(RecoverScheduledActionsHandler);
-}
-async function recoverPendingSchedules(dispatcher) {
-    const event = {
-        [SCHEDULED_ACTION_RECOVER_EVENT_IDENTIFIER]: true
-    };
-    try {
-        const result = await dispatcher.dispatch(event);
-        console.log(`[scheduler] boot recovery: re-armed ${result.recovered} pending action(s)`);
-    } catch (err) {
-        console.error("[scheduler] boot recovery failed:", err);
-    }
+    rootContainer.register(ScheduledActionRunRouteDefinition);
+    rootContainer.register(ScheduledActionRecoverRouteDefinition);
 }
 async function startSchedulerServer(rootContainer) {
     await rootContainer.resolve(SchedulerSingleton).start();
-    const dispatcher = rootContainer.resolve(EventDispatcher);
-    recoverPendingSchedules(dispatcher);
+    const token = rootContainer.resolve(SchedulerInternalToken).value;
+    console.log(`[scheduler] boot: re-arming persisted schedules via ${serverBase()} ...`);
+    setTimeout(async ()=>{
+        try {
+            const res = await fetch(`${serverBase()}/scheduled-action-recover`, {
+                method: "POST",
+                headers: {
+                    "content-type": "application/json",
+                    [SCHEDULER_HEADER]: token
+                },
+                body: JSON.stringify({})
+            });
+            const body = await res.json().catch(()=>({}));
+            if (!res.ok) return void console.error(`[scheduler] boot recovery failed: HTTP ${res.status}`, body);
+            console.log(`[scheduler] boot recovery: re-armed ${body.recovered ?? "?"} pending action(s)`);
+        } catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            console.error(`[scheduler] boot recovery failed to reach the recover route: ${message}`);
+        }
+    }, 1000);
 }
 export { registerSchedulerServer, startSchedulerServer };
 

package/scheduler/schedulerServer.js.map

@@ -1 +1 @@
-{"version":3,"file":"scheduler/schedulerServer.js","sources":["../../src/scheduler/schedulerServer.ts"],"sourcesContent":["import type { Container } from \"@webiny/di\";\nimport { EventDispatcher } from \"@webiny/event-handler-core\";\nimport { ScheduledActionEventType } from \"@webiny/event-handler-core\";\nimport { SCHEDULED_ACTION_EVENT_IDENTIFIER } from \"@webiny/event-handler-core\";\nimport type { IScheduledActionEvent } from \"@webiny/event-handler-core\";\nimport { SchedulerService } from \"@webiny/api-scheduler/shared/abstractions.js\";\nimport { ScheduledActionLambdaHandler } from \"@webiny/api-scheduler\";\nimport { BreeSchedulerService } from \"@webiny/api-scheduler-standalone\";\nimport type { Logger } from \"@webiny/api-core/features/logger/abstractions.js\";\nimport { SchedulerSingleton } from \"./abstractions/SchedulerSingleton.js\";\nimport { ScheduledActionRecoverEventType } from \"./ScheduledActionRecoverEventType.js\";\nimport { SCHEDULED_ACTION_RECOVER_EVENT_IDENTIFIER } from \"./ScheduledActionRecoverEventType.js\";\nimport type { IScheduledActionRecoverEvent } from \"./ScheduledActionRecoverEventType.js\";\nimport { RecoverScheduledActionsHandler } from \"./RecoverScheduledActionsHandler.js\";\nimport { ScheduledActionRecoverEventHandler } from \"./ScheduledActionRecoverEventHandler.js\";\n\n/**\n * Minimal console-backed logger for the root scheduler singleton. The real DI Logger is registered\n * per-request (via ApiCoreFeature/LoggerFeature), so it isn't resolvable here at the root where the\n * singleton is built. And even if we bridged to it, timers fire outside any request — there's no\n * request context for a context-aware logger to enrich — so console is functionally equivalent, not\n * a downgrade. Revisit (a shared boot-time logger for all root singletons) tracked in\n * https://github.com/webiny/webiny-js/issues/5446.\n */\nconst consoleLogger: Logger.Interface = {\n    trace: (...args: any[]) => console.trace(...args),\n    debug: (...args: any[]) => console.debug(...args),\n    info: (...args: any[]) => console.info(...args),\n    warn: (...args: any[]) => console.warn(...args),\n    error: (...args: any[]) => console.error(...args),\n    fatal: (...args: any[]) => console.error(...args),\n    log: (...args: any[]) => console.log(...args)\n};\n\n/**\n * ROOT wiring for the standalone (Bree, in-process) scheduler. Unlike AWS (per-request EventBridge\n * binding), the server holds ONE long-lived Bree instance for all tenants, started once at boot —\n * the counterpart of the WebSockets connection manager. Registered as `SchedulerService` so\n * per-request create/update/delete (during GraphQL mutations) manipulate that single live timer set.\n *\n * When a timer fires (outside any request), the singleton dispatches a `ScheduledActionEvent`. The\n * handler is the one AWS runs for an EventBridge Scheduler invocation, in a fresh request container.\n */\nexport function registerSchedulerServer(rootContainer: Container): void {\n    const dispatcher = rootContainer.resolve(EventDispatcher);\n\n    const service = new BreeSchedulerService({\n        logger: consoleLogger,\n        onTrigger: async (id, namespace, tenant) => {\n            /*\n             * `scheduleFor` is the time it fired. The event type needs one to recognise the event,\n             * and nothing downstream reads it.\n             */\n            const event: IScheduledActionEvent = {\n                [SCHEDULED_ACTION_EVENT_IDENTIFIER]: {\n                    id,\n                    namespace,\n                    tenant,\n                    scheduleFor: new Date().toISOString()\n                }\n            };\n            try {\n                await dispatcher.dispatch(event);\n            } catch (err) {\n                console.error(`[scheduler] scheduled action \"${id}\" failed:`, err);\n            }\n        }\n    });\n\n    // Register the ONE Bree instance under TWO tokens — two views of the same object:\n    //\n    //   - SchedulerService: the hosting-agnostic contract (create/update/delete/exists) that AWS\n    //     implements too. This is what per-request GraphQL mutations resolve to schedule/reschedule.\n    //   - SchedulerSingleton: typed as the CONCRETE BreeSchedulerService, so it also exposes the\n    //     methods that aren't on that contract — start() and recover(). Those are Bree-only: AWS's\n    //     EventBridge is managed infra (nothing to start) and persists its own schedules (nothing to\n    //     recover), so they don't belong on the shared interface. The boot step + recover handler\n    //     resolve this token precisely because they need start()/recover().\n    //\n    // registerInstance (not register) because it's a single live object holding all tenants' timers —\n    // every caller must get the SAME instance, not a per-scope construction. Registered at root, so\n    // per-request child containers inherit it via the parent chain; nothing registers a per-request\n    // SchedulerService default that would shadow it (unlike e.g. the WS transport's Null default).\n    rootContainer.registerInstance(SchedulerSingleton, service);\n    rootContainer.registerInstance(SchedulerService, service);\n\n    rootContainer.register(ScheduledActionEventType);\n    rootContainer.register(ScheduledActionLambdaHandler);\n\n    rootContainer.register(ScheduledActionRecoverEventType);\n    rootContainer.register(RecoverScheduledActionsHandler);\n}\n\nasync function recoverPendingSchedules(dispatcher: EventDispatcher.Interface): Promise<void> {\n    const event: IScheduledActionRecoverEvent = {\n        [SCHEDULED_ACTION_RECOVER_EVENT_IDENTIFIER]: true\n    };\n\n    try {\n        const result = await dispatcher.dispatch<ScheduledActionRecoverEventHandler.Result>(event);\n        console.log(`[scheduler] boot recovery: re-armed ${result.recovered} pending action(s)`);\n    } catch (err) {\n        console.error(\"[scheduler] boot recovery failed:\", err);\n    }\n}\n\n/**\n * Boot step (onServer): start the timers, then re-arm the persisted schedules. Recovery runs in the\n * background: it executes overdue actions one by one, and the server should not wait for that\n * before it starts listening. A failure is logged and never crashes startup.\n */\nexport async function startSchedulerServer(rootContainer: Container): Promise<void> {\n    await rootContainer.resolve(SchedulerSingleton).start();\n\n    const dispatcher = rootContainer.resolve(EventDispatcher);\n    void recoverPendingSchedules(dispatcher);\n}\n"],"names":["consoleLogger","args","console","registerSchedulerServer","rootContainer","dispatcher","EventDispatcher","service","BreeSchedulerService","id","namespace","tenant","event","SCHEDULED_ACTION_EVENT_IDENTIFIER","Date","err","SchedulerSingleton","SchedulerService","ScheduledActionEventType","ScheduledActionLambdaHandler","ScheduledActionRecoverEventType","RecoverScheduledActionsHandler","recoverPendingSchedules","SCHEDULED_ACTION_RECOVER_EVENT_IDENTIFIER","result","startSchedulerServer"],"mappings":";;;;;;;AAwBA,MAAMA,gBAAkC;IACpC,OAAO,CAAC,GAAGC,OAAgBC,QAAQ,KAAK,IAAID;IAC5C,OAAO,CAAC,GAAGA,OAAgBC,QAAQ,KAAK,IAAID;IAC5C,MAAM,CAAC,GAAGA,OAAgBC,QAAQ,IAAI,IAAID;IAC1C,MAAM,CAAC,GAAGA,OAAgBC,QAAQ,IAAI,IAAID;IAC1C,OAAO,CAAC,GAAGA,OAAgBC,QAAQ,KAAK,IAAID;IAC5C,OAAO,CAAC,GAAGA,OAAgBC,QAAQ,KAAK,IAAID;IAC5C,KAAK,CAAC,GAAGA,OAAgBC,QAAQ,GAAG,IAAID;AAC5C;AAWO,SAASE,wBAAwBC,aAAwB;IAC5D,MAAMC,aAAaD,cAAc,OAAO,CAACE;IAEzC,MAAMC,UAAU,IAAIC,qBAAqB;QACrC,QAAQR;QACR,WAAW,OAAOS,IAAIC,WAAWC;YAK7B,MAAMC,QAA+B;gBACjC,CAACC,kCAAkC,EAAE;oBACjCJ;oBACAC;oBACAC;oBACA,aAAa,IAAIG,OAAO,WAAW;gBACvC;YACJ;YACA,IAAI;gBACA,MAAMT,WAAW,QAAQ,CAACO;YAC9B,EAAE,OAAOG,KAAK;gBACVb,QAAQ,KAAK,CAAC,CAAC,8BAA8B,EAAEO,GAAG,SAAS,CAAC,EAAEM;YAClE;QACJ;IACJ;IAgBAX,cAAc,gBAAgB,CAACY,oBAAoBT;IACnDH,cAAc,gBAAgB,CAACa,kBAAkBV;IAEjDH,cAAc,QAAQ,CAACc;IACvBd,cAAc,QAAQ,CAACe;IAEvBf,cAAc,QAAQ,CAACgB;IACvBhB,cAAc,QAAQ,CAACiB;AAC3B;AAEA,eAAeC,wBAAwBjB,UAAqC;IACxE,MAAMO,QAAsC;QACxC,CAACW,0CAA0C,EAAE;IACjD;IAEA,IAAI;QACA,MAAMC,SAAS,MAAMnB,WAAW,QAAQ,CAA4CO;QACpFV,QAAQ,GAAG,CAAC,CAAC,oCAAoC,EAAEsB,OAAO,SAAS,CAAC,kBAAkB,CAAC;IAC3F,EAAE,OAAOT,KAAK;QACVb,QAAQ,KAAK,CAAC,qCAAqCa;IACvD;AACJ;AAOO,eAAeU,qBAAqBrB,aAAwB;IAC/D,MAAMA,cAAc,OAAO,CAACY,oBAAoB,KAAK;IAErD,MAAMX,aAAaD,cAAc,OAAO,CAACE;IACpCgB,wBAAwBjB;AACjC"}
+{"version":3,"file":"scheduler/schedulerServer.js","sources":["../../src/scheduler/schedulerServer.ts"],"sourcesContent":["import type { Container } from \"@webiny/di\";\nimport { uuid } from \"@webiny/stdlib\";\nimport { SchedulerService } from \"@webiny/api-scheduler/shared/abstractions.js\";\nimport { BreeSchedulerService } from \"@webiny/api-scheduler-standalone\";\nimport type { Logger } from \"@webiny/api-core/features/logger/abstractions.js\";\nimport { SchedulerInternalToken } from \"./abstractions/InternalToken.js\";\nimport { SchedulerSingleton } from \"./abstractions/SchedulerSingleton.js\";\nimport { ScheduledActionRunRouteDefinition } from \"./ScheduledActionRunRoute.js\";\nimport { ScheduledActionRecoverRouteDefinition } from \"./ScheduledActionRecoverRoute.js\";\n\nconst SCHEDULER_HEADER = \"x-webiny-scheduler-token\";\n\n/**\n * Minimal console-backed logger for the root scheduler singleton. The real DI Logger is registered\n * per-request (via ApiCoreFeature/LoggerFeature), so it isn't resolvable here at the root where the\n * singleton is built. And even if we bridged to it, timers fire outside any request — there's no\n * request context for a context-aware logger to enrich — so console is functionally equivalent, not\n * a downgrade. Revisit (a shared boot-time logger for all root singletons) tracked in\n * https://github.com/webiny/webiny-js/issues/5446.\n */\nconst consoleLogger: Logger.Interface = {\n    trace: (...args: any[]) => console.trace(...args),\n    debug: (...args: any[]) => console.debug(...args),\n    info: (...args: any[]) => console.info(...args),\n    warn: (...args: any[]) => console.warn(...args),\n    error: (...args: any[]) => console.error(...args),\n    fatal: (...args: any[]) => console.error(...args),\n    log: (...args: any[]) => console.log(...args)\n};\n\n// Self-callback base. process.env.PORT is the resolved listening port injected by spawnApiServer;\n// the 3002 fallback matches findFreePort's search base (and the background-tasks default) so every\n// self-callback agrees, though in practice PORT is always set. A shared helper + fail-loud handling\n// is tracked in https://github.com/webiny/webiny-js/issues/5448.\nconst serverBase = () => `http://localhost:${process.env.PORT || \"3002\"}`;\n\n/**\n * ROOT wiring for the standalone (Bree, in-process) scheduler. Unlike AWS (per-request EventBridge\n * binding), the server holds ONE long-lived Bree instance for all tenants, started once at boot — the\n * counterpart of the WebSockets connection manager. Registered as `SchedulerService` so per-request\n * create/update/delete (during GraphQL mutations) manipulate that single live timer set.\n *\n * When a timer fires (outside any request), the singleton POSTs to `/scheduled-action-run`, which\n * rebuilds the request context for the action's tenant and executes it (see the route).\n */\nexport function registerSchedulerServer(rootContainer: Container): void {\n    const token = uuid();\n    rootContainer.registerInstance(SchedulerInternalToken, { value: token });\n\n    const service = new BreeSchedulerService({\n        logger: consoleLogger,\n        onTrigger: async (id, namespace, tenant) => {\n            console.log(\n                `[scheduler] timer fired for \"${id}\" (namespace=${namespace}, tenant=${tenant}); calling run route`\n            );\n            try {\n                const res = await fetch(`${serverBase()}/scheduled-action-run`, {\n                    method: \"POST\",\n                    headers: { \"content-type\": \"application/json\", [SCHEDULER_HEADER]: token },\n                    body: JSON.stringify({ id, namespace, tenant })\n                });\n                // fetch only throws on network errors; a 403 or 500 comes back as a normal non-ok\n                // response, so we check for that explicitly — otherwise a failed run would be silent.\n                if (!res.ok) {\n                    const body = await res.text().catch(() => \"\");\n                    console.error(\n                        `[scheduler] run route returned HTTP ${res.status} for \"${id}\": ${body}`\n                    );\n                }\n            } catch (err) {\n                const message = err instanceof Error ? err.message : String(err);\n                console.error(\n                    `Scheduler trigger for \"${id}\" failed to reach the run route: ${message}`\n                );\n            }\n        }\n    });\n\n    // Register the ONE Bree instance under TWO tokens — two views of the same object:\n    //\n    //   - SchedulerService: the hosting-agnostic contract (create/update/delete/exists) that AWS\n    //     implements too. This is what per-request GraphQL mutations resolve to schedule/reschedule.\n    //   - SchedulerSingleton: typed as the CONCRETE BreeSchedulerService, so it also exposes the\n    //     methods that aren't on that contract — start() and recover(). Those are Bree-only: AWS's\n    //     EventBridge is managed infra (nothing to start) and persists its own schedules (nothing to\n    //     recover), so they don't belong on the shared interface. The boot step + recover route resolve\n    //     this token precisely because they need start()/recover().\n    //\n    // registerInstance (not register) because it's a single live object holding all tenants' timers —\n    // every caller must get the SAME instance, not a per-scope construction. Registered at root, so\n    // per-request child containers inherit it via the parent chain; nothing registers a per-request\n    // SchedulerService default that would shadow it (unlike e.g. the WS transport's Null default).\n    rootContainer.registerInstance(SchedulerSingleton, service);\n    rootContainer.registerInstance(SchedulerService, service);\n\n    rootContainer.register(ScheduledActionRunRouteDefinition);\n    rootContainer.register(ScheduledActionRecoverRouteDefinition);\n}\n\n/**\n * Boot step (onServer): start the timers, then re-arm persisted schedules by POSTing the recover route\n * (root tenant).\n *\n * `onServer` runs BEFORE the HTTP server starts listening, so the recover POST (which hits this same\n * server) is DEFERRED to the next tick — by then `createServerHandler` has returned and the runner has\n * called `.listen()`. Fire-and-forget: a recovery failure must never block or crash startup.\n */\nexport async function startSchedulerServer(rootContainer: Container): Promise<void> {\n    await rootContainer.resolve(SchedulerSingleton).start();\n\n    const token = rootContainer.resolve(SchedulerInternalToken).value;\n\n    // Deferred: give the runner a moment to bind the listener before we call back into it.\n    console.log(`[scheduler] boot: re-arming persisted schedules via ${serverBase()} ...`);\n    setTimeout(async () => {\n        try {\n            const res = await fetch(`${serverBase()}/scheduled-action-recover`, {\n                method: \"POST\",\n                headers: { \"content-type\": \"application/json\", [SCHEDULER_HEADER]: token },\n                body: JSON.stringify({})\n            });\n            const body = await res.json().catch(() => ({}) as Record<string, unknown>);\n            // fetch only throws on network errors; a 403 or 500 comes back as a normal non-ok\n            // response, so we check for it here (a token-mismatch 403 used to fail silently).\n            if (!res.ok) {\n                console.error(`[scheduler] boot recovery failed: HTTP ${res.status}`, body);\n                return;\n            }\n            console.log(\n                `[scheduler] boot recovery: re-armed ${body.recovered ?? \"?\"} pending action(s)`\n            );\n        } catch (err) {\n            const message = err instanceof Error ? err.message : String(err);\n            console.error(\n                `[scheduler] boot recovery failed to reach the recover route: ${message}`\n            );\n        }\n    }, 1000);\n}\n"],"names":["SCHEDULER_HEADER","consoleLogger","args","console","serverBase","process","registerSchedulerServer","rootContainer","token","uuid","SchedulerInternalToken","service","BreeSchedulerService","id","namespace","tenant","res","fetch","JSON","body","err","message","Error","String","SchedulerSingleton","SchedulerService","ScheduledActionRunRouteDefinition","ScheduledActionRecoverRouteDefinition","startSchedulerServer","setTimeout"],"mappings":";;;;;;;AAUA,MAAMA,mBAAmB;AAUzB,MAAMC,gBAAkC;IACpC,OAAO,CAAC,GAAGC,OAAgBC,QAAQ,KAAK,IAAID;IAC5C,OAAO,CAAC,GAAGA,OAAgBC,QAAQ,KAAK,IAAID;IAC5C,MAAM,CAAC,GAAGA,OAAgBC,QAAQ,IAAI,IAAID;IAC1C,MAAM,CAAC,GAAGA,OAAgBC,QAAQ,IAAI,IAAID;IAC1C,OAAO,CAAC,GAAGA,OAAgBC,QAAQ,KAAK,IAAID;IAC5C,OAAO,CAAC,GAAGA,OAAgBC,QAAQ,KAAK,IAAID;IAC5C,KAAK,CAAC,GAAGA,OAAgBC,QAAQ,GAAG,IAAID;AAC5C;AAMA,MAAME,aAAa,IAAM,CAAC,iBAAiB,EAAEC,QAAQ,GAAG,CAAC,IAAI,IAAI,QAAQ;AAWlE,SAASC,wBAAwBC,aAAwB;IAC5D,MAAMC,QAAQC;IACdF,cAAc,gBAAgB,CAACG,wBAAwB;QAAE,OAAOF;IAAM;IAEtE,MAAMG,UAAU,IAAIC,qBAAqB;QACrC,QAAQX;QACR,WAAW,OAAOY,IAAIC,WAAWC;YAC7BZ,QAAQ,GAAG,CACP,CAAC,6BAA6B,EAAEU,GAAG,aAAa,EAAEC,UAAU,SAAS,EAAEC,OAAO,oBAAoB,CAAC;YAEvG,IAAI;gBACA,MAAMC,MAAM,MAAMC,MAAM,GAAGb,aAAa,qBAAqB,CAAC,EAAE;oBAC5D,QAAQ;oBACR,SAAS;wBAAE,gBAAgB;wBAAoB,CAACJ,iBAAiB,EAAEQ;oBAAM;oBACzE,MAAMU,KAAK,SAAS,CAAC;wBAAEL;wBAAIC;wBAAWC;oBAAO;gBACjD;gBAGA,IAAI,CAACC,IAAI,EAAE,EAAE;oBACT,MAAMG,OAAO,MAAMH,IAAI,IAAI,GAAG,KAAK,CAAC,IAAM;oBAC1Cb,QAAQ,KAAK,CACT,CAAC,oCAAoC,EAAEa,IAAI,MAAM,CAAC,MAAM,EAAEH,GAAG,GAAG,EAAEM,MAAM;gBAEhF;YACJ,EAAE,OAAOC,KAAK;gBACV,MAAMC,UAAUD,eAAeE,QAAQF,IAAI,OAAO,GAAGG,OAAOH;gBAC5DjB,QAAQ,KAAK,CACT,CAAC,uBAAuB,EAAEU,GAAG,iCAAiC,EAAEQ,SAAS;YAEjF;QACJ;IACJ;IAgBAd,cAAc,gBAAgB,CAACiB,oBAAoBb;IACnDJ,cAAc,gBAAgB,CAACkB,kBAAkBd;IAEjDJ,cAAc,QAAQ,CAACmB;IACvBnB,cAAc,QAAQ,CAACoB;AAC3B;AAUO,eAAeC,qBAAqBrB,aAAwB;IAC/D,MAAMA,cAAc,OAAO,CAACiB,oBAAoB,KAAK;IAErD,MAAMhB,QAAQD,cAAc,OAAO,CAACG,wBAAwB,KAAK;IAGjEP,QAAQ,GAAG,CAAC,CAAC,oDAAoD,EAAEC,aAAa,IAAI,CAAC;IACrFyB,WAAW;QACP,IAAI;YACA,MAAMb,MAAM,MAAMC,MAAM,GAAGb,aAAa,yBAAyB,CAAC,EAAE;gBAChE,QAAQ;gBACR,SAAS;oBAAE,gBAAgB;oBAAoB,CAACJ,iBAAiB,EAAEQ;gBAAM;gBACzE,MAAMU,KAAK,SAAS,CAAC,CAAC;YAC1B;YACA,MAAMC,OAAO,MAAMH,IAAI,IAAI,GAAG,KAAK,CAAC,IAAO,EAAC;YAG5C,IAAI,CAACA,IAAI,EAAE,EAAE,YACTb,QAAQ,KAAK,CAAC,CAAC,uCAAuC,EAAEa,IAAI,MAAM,EAAE,EAAEG;YAG1EhB,QAAQ,GAAG,CACP,CAAC,oCAAoC,EAAEgB,KAAK,SAAS,IAAI,IAAI,kBAAkB,CAAC;QAExF,EAAE,OAAOC,KAAK;YACV,MAAMC,UAAUD,eAAeE,QAAQF,IAAI,OAAO,GAAGG,OAAOH;YAC5DjB,QAAQ,KAAK,CACT,CAAC,6DAA6D,EAAEkB,SAAS;QAEjF;IACJ,GAAG;AACP"}

package/scheduler/RecoverScheduledActionsHandler.d.ts

@@ -1,29 +0,0 @@
-import { RawTenantId } from "@webiny/api-core/features/requestContext/index.js";
-import { RequestTenantLoader } from "@webiny/api-core/features/requestContext/index.js";
-import { GetRootTenantUseCase } from "@webiny/api-core/features/tenancy/GetRootTenant/index.js";
-import { IdentityContext } from "@webiny/api-core/exports/api/security.js";
-import { ListScheduledActionsUseCase } from "@webiny/api-scheduler/features/ListScheduledActions/index.js";
-import { ScheduledActionRecoverEventHandler } from "./ScheduledActionRecoverEventHandler.js";
-import { SchedulerSingleton } from "./abstractions/SchedulerSingleton.js";
-/**
- * Re-arms the root tenant's pending scheduled actions in the Bree singleton. Overdue ones run at
- * once (see `BreeSchedulerService.recover`).
- *
- * Root tenant only. Recovering other tenants means enumerating them and recovering each; until
- * then a restart drops their pending schedules.
- */
-declare class RecoverScheduledActionsHandlerImpl implements ScheduledActionRecoverEventHandler.Interface {
-    private readonly getRootTenant;
-    private readonly rawTenantId;
-    private readonly tenantLoader;
-    private readonly identityContext;
-    private readonly listScheduledActions;
-    private readonly scheduler;
-    constructor(getRootTenant: GetRootTenantUseCase.Interface, rawTenantId: RawTenantId.Interface, tenantLoader: RequestTenantLoader.Interface, identityContext: IdentityContext.Interface, listScheduledActions: ListScheduledActionsUseCase.Interface, scheduler: SchedulerSingleton.Interface);
-    execute(): Promise<ScheduledActionRecoverEventHandler.Result>;
-    private recoverAllPending;
-}
-export declare const RecoverScheduledActionsHandler: typeof RecoverScheduledActionsHandlerImpl & {
-    __abstraction: import("@webiny/di").Abstraction<import("./ScheduledActionRecoverEventHandler.js").IScheduledActionRecoverEventHandler>;
-};
-export {};

package/scheduler/RecoverScheduledActionsHandler.js

@@ -1,68 +0,0 @@
-import { RawTenantId, RequestTenantLoader } from "@webiny/api-core/features/requestContext/index.js";
-import { GetRootTenantUseCase } from "@webiny/api-core/features/tenancy/GetRootTenant/index.js";
-import { IdentityContext } from "@webiny/api-core/exports/api/security.js";
-import { ListScheduledActionsUseCase } from "@webiny/api-scheduler/features/ListScheduledActions/index.js";
-import { ScheduledActionRecoverEventHandler } from "./ScheduledActionRecoverEventHandler.js";
-import { SchedulerSingleton } from "./abstractions/SchedulerSingleton.js";
-const PAGE_SIZE = 1000;
-class RecoverScheduledActionsHandlerImpl {
-    constructor(getRootTenant, rawTenantId, tenantLoader, identityContext, listScheduledActions, scheduler){
-        this.getRootTenant = getRootTenant;
-        this.rawTenantId = rawTenantId;
-        this.tenantLoader = tenantLoader;
-        this.identityContext = identityContext;
-        this.listScheduledActions = listScheduledActions;
-        this.scheduler = scheduler;
-    }
-    async execute() {
-        const rootResult = await this.getRootTenant.execute();
-        if (rootResult.isFail()) return {
-            recovered: 0
-        };
-        const tenant = rootResult.value.id;
-        this.rawTenantId.set(tenant);
-        await this.tenantLoader.establish();
-        const recovered = await this.identityContext.withoutAuthorization(()=>this.recoverAllPending(tenant));
-        return {
-            recovered
-        };
-    }
-    async recoverAllPending(tenant) {
-        let recovered = 0;
-        let after;
-        do {
-            const listResult = await this.listScheduledActions.execute({
-                where: {},
-                limit: PAGE_SIZE,
-                after
-            });
-            if (listResult.isFail()) throw listResult.error;
-            const page = [];
-            for (const action of listResult.value.items)page.push({
-                id: action.id,
-                namespace: action.namespace,
-                tenant,
-                scheduledFor: action.scheduledFor
-            });
-            await this.scheduler.recover(page);
-            recovered += page.length;
-            const { meta } = listResult.value;
-            after = meta.hasMoreItems && meta.cursor ? meta.cursor : void 0;
-        }while (after)
-        return recovered;
-    }
-}
-const RecoverScheduledActionsHandler = ScheduledActionRecoverEventHandler.createImplementation({
-    implementation: RecoverScheduledActionsHandlerImpl,
-    dependencies: [
-        GetRootTenantUseCase,
-        RawTenantId,
-        RequestTenantLoader,
-        IdentityContext,
-        ListScheduledActionsUseCase,
-        SchedulerSingleton
-    ]
-});
-export { RecoverScheduledActionsHandler };
-
-//# sourceMappingURL=RecoverScheduledActionsHandler.js.map

package/scheduler/RecoverScheduledActionsHandler.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"scheduler/RecoverScheduledActionsHandler.js","sources":["../../src/scheduler/RecoverScheduledActionsHandler.ts"],"sourcesContent":["import { RawTenantId } from \"@webiny/api-core/features/requestContext/index.js\";\nimport { RequestTenantLoader } from \"@webiny/api-core/features/requestContext/index.js\";\nimport { GetRootTenantUseCase } from \"@webiny/api-core/features/tenancy/GetRootTenant/index.js\";\nimport { IdentityContext } from \"@webiny/api-core/exports/api/security.js\";\nimport { ListScheduledActionsUseCase } from \"@webiny/api-scheduler/features/ListScheduledActions/index.js\";\nimport { ScheduledActionRecoverEventHandler } from \"./ScheduledActionRecoverEventHandler.js\";\nimport type { IPendingAction } from \"@webiny/api-scheduler-standalone\";\nimport { SchedulerSingleton } from \"./abstractions/SchedulerSingleton.js\";\n\n// Pending actions read per page.\nconst PAGE_SIZE = 1000;\n\n/**\n * Re-arms the root tenant's pending scheduled actions in the Bree singleton. Overdue ones run at\n * once (see `BreeSchedulerService.recover`).\n *\n * Root tenant only. Recovering other tenants means enumerating them and recovering each; until\n * then a restart drops their pending schedules.\n */\nclass RecoverScheduledActionsHandlerImpl implements ScheduledActionRecoverEventHandler.Interface {\n    public constructor(\n        private readonly getRootTenant: GetRootTenantUseCase.Interface,\n        private readonly rawTenantId: RawTenantId.Interface,\n        private readonly tenantLoader: RequestTenantLoader.Interface,\n        private readonly identityContext: IdentityContext.Interface,\n        private readonly listScheduledActions: ListScheduledActionsUseCase.Interface,\n        private readonly scheduler: SchedulerSingleton.Interface\n    ) {}\n\n    public async execute(): Promise<ScheduledActionRecoverEventHandler.Result> {\n        const rootResult = await this.getRootTenant.execute();\n        if (rootResult.isFail()) {\n            // No root tenant yet: a fresh install has nothing to recover.\n            return { recovered: 0 };\n        }\n        const tenant = rootResult.value.id;\n\n        this.rawTenantId.set(tenant);\n        await this.tenantLoader.establish();\n\n        /*\n         * Nobody is signed in at boot. Listing without authorization is what the run side does too\n         * (ExecuteScheduledActionUseCase); otherwise the anonymous identity fails the permission check.\n         */\n        const recovered = await this.identityContext.withoutAuthorization(() => {\n            return this.recoverAllPending(tenant);\n        });\n\n        return { recovered };\n    }\n\n    /*\n     * Re-arms page by page, so a lookup that fails on a later page still leaves the earlier pages\n     * armed. The failure is rethrown and logged by the boot step.\n     */\n    private async recoverAllPending(tenant: string): Promise<number> {\n        let recovered = 0;\n        let after: string | undefined;\n\n        do {\n            const listResult = await this.listScheduledActions.execute({\n                where: {},\n                limit: PAGE_SIZE,\n                after\n            });\n            if (listResult.isFail()) {\n                throw listResult.error;\n            }\n\n            const page: IPendingAction[] = [];\n            for (const action of listResult.value.items) {\n                page.push({\n                    id: action.id,\n                    namespace: action.namespace,\n                    tenant,\n                    scheduledFor: action.scheduledFor\n                });\n            }\n\n            await this.scheduler.recover(page);\n            recovered += page.length;\n\n            const { meta } = listResult.value;\n            after = meta.hasMoreItems && meta.cursor ? meta.cursor : undefined;\n        } while (after);\n\n        return recovered;\n    }\n}\n\nexport const RecoverScheduledActionsHandler =\n    ScheduledActionRecoverEventHandler.createImplementation({\n        implementation: RecoverScheduledActionsHandlerImpl,\n        dependencies: [\n            GetRootTenantUseCase,\n            RawTenantId,\n            RequestTenantLoader,\n            IdentityContext,\n            ListScheduledActionsUseCase,\n            SchedulerSingleton\n        ]\n    });\n"],"names":["PAGE_SIZE","RecoverScheduledActionsHandlerImpl","getRootTenant","rawTenantId","tenantLoader","identityContext","listScheduledActions","scheduler","rootResult","tenant","recovered","after","listResult","page","action","meta","undefined","RecoverScheduledActionsHandler","ScheduledActionRecoverEventHandler","GetRootTenantUseCase","RawTenantId","RequestTenantLoader","IdentityContext","ListScheduledActionsUseCase","SchedulerSingleton"],"mappings":";;;;;;AAUA,MAAMA,YAAY;AASlB,MAAMC;IACF,YACqBC,aAA6C,EAC7CC,WAAkC,EAClCC,YAA2C,EAC3CC,eAA0C,EAC1CC,oBAA2D,EAC3DC,SAAuC,CAC1D;aANmBL,aAAa,GAAbA;aACAC,WAAW,GAAXA;aACAC,YAAY,GAAZA;aACAC,eAAe,GAAfA;aACAC,oBAAoB,GAApBA;aACAC,SAAS,GAATA;IAClB;IAEH,MAAa,UAA8D;QACvE,MAAMC,aAAa,MAAM,IAAI,CAAC,aAAa,CAAC,OAAO;QACnD,IAAIA,WAAW,MAAM,IAEjB,OAAO;YAAE,WAAW;QAAE;QAE1B,MAAMC,SAASD,WAAW,KAAK,CAAC,EAAE;QAElC,IAAI,CAAC,WAAW,CAAC,GAAG,CAACC;QACrB,MAAM,IAAI,CAAC,YAAY,CAAC,SAAS;QAMjC,MAAMC,YAAY,MAAM,IAAI,CAAC,eAAe,CAAC,oBAAoB,CAAC,IACvD,IAAI,CAAC,iBAAiB,CAACD;QAGlC,OAAO;YAAEC;QAAU;IACvB;IAMA,MAAc,kBAAkBD,MAAc,EAAmB;QAC7D,IAAIC,YAAY;QAChB,IAAIC;QAEJ,GAAG;YACC,MAAMC,aAAa,MAAM,IAAI,CAAC,oBAAoB,CAAC,OAAO,CAAC;gBACvD,OAAO,CAAC;gBACR,OAAOZ;gBACPW;YACJ;YACA,IAAIC,WAAW,MAAM,IACjB,MAAMA,WAAW,KAAK;YAG1B,MAAMC,OAAyB,EAAE;YACjC,KAAK,MAAMC,UAAUF,WAAW,KAAK,CAAC,KAAK,CACvCC,KAAK,IAAI,CAAC;gBACN,IAAIC,OAAO,EAAE;gBACb,WAAWA,OAAO,SAAS;gBAC3BL;gBACA,cAAcK,OAAO,YAAY;YACrC;YAGJ,MAAM,IAAI,CAAC,SAAS,CAAC,OAAO,CAACD;YAC7BH,aAAaG,KAAK,MAAM;YAExB,MAAM,EAAEE,IAAI,EAAE,GAAGH,WAAW,KAAK;YACjCD,QAAQI,KAAK,YAAY,IAAIA,KAAK,MAAM,GAAGA,KAAK,MAAM,GAAGC;QAC7D,QAASL,MAAO;QAEhB,OAAOD;IACX;AACJ;AAEO,MAAMO,iCACTC,mCAAmC,oBAAoB,CAAC;IACpD,gBAAgBjB;IAChB,cAAc;QACVkB;QACAC;QACAC;QACAC;QACAC;QACAC;KACH;AACL"}

package/scheduler/ScheduledActionRecoverEventHandler.d.ts

@@ -1,13 +0,0 @@
-import { Abstraction } from "@webiny/di";
-import type { IEventHandler } from "@webiny/event-handler-core";
-import type { IScheduledActionRecoverEvent } from "./ScheduledActionRecoverEventType.js";
-export interface IScheduledActionRecoverResult {
-    recovered: number;
-}
-export interface IScheduledActionRecoverEventHandler extends IEventHandler<IScheduledActionRecoverEvent, IScheduledActionRecoverResult> {
-}
-export declare const ScheduledActionRecoverEventHandler: Abstraction<IScheduledActionRecoverEventHandler>;
-export declare namespace ScheduledActionRecoverEventHandler {
-    type Interface = IScheduledActionRecoverEventHandler;
-    type Result = IScheduledActionRecoverResult;
-}

package/scheduler/ScheduledActionRecoverEventHandler.js

@@ -1,5 +0,0 @@
-import { Abstraction } from "@webiny/di";
-const ScheduledActionRecoverEventHandler = new Abstraction("ScheduledActionRecoverEventHandler");
-export { ScheduledActionRecoverEventHandler };
-
-//# sourceMappingURL=ScheduledActionRecoverEventHandler.js.map

package/scheduler/ScheduledActionRecoverEventHandler.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"scheduler/ScheduledActionRecoverEventHandler.js","sources":["../../src/scheduler/ScheduledActionRecoverEventHandler.ts"],"sourcesContent":["import { Abstraction } from \"@webiny/di\";\nimport type { IEventHandler } from \"@webiny/event-handler-core\";\nimport type { IScheduledActionRecoverEvent } from \"./ScheduledActionRecoverEventType.js\";\n\nexport interface IScheduledActionRecoverResult {\n    recovered: number;\n}\n\nexport interface IScheduledActionRecoverEventHandler extends IEventHandler<\n    IScheduledActionRecoverEvent,\n    IScheduledActionRecoverResult\n> {}\n\nexport const ScheduledActionRecoverEventHandler =\n    new Abstraction<IScheduledActionRecoverEventHandler>(\"ScheduledActionRecoverEventHandler\");\n\nexport namespace ScheduledActionRecoverEventHandler {\n    export type Interface = IScheduledActionRecoverEventHandler;\n    export type Result = IScheduledActionRecoverResult;\n}\n"],"names":["ScheduledActionRecoverEventHandler","Abstraction"],"mappings":";AAaO,MAAMA,qCACT,IAAIC,YAAiD"}

package/scheduler/ScheduledActionRecoverEventType.d.ts

@@ -1,17 +0,0 @@
-import type { IEventType } from "@webiny/event-handler-core";
-export declare const SCHEDULED_ACTION_RECOVER_EVENT_IDENTIFIER = "WebinyScheduledActionRecover";
-/**
- * Asks the scheduler to re-arm the root tenant's pending scheduled actions. Dispatched once at
- * boot: Bree keeps its timers in memory, so a restart loses every schedule that has not fired yet.
- */
-export interface IScheduledActionRecoverEvent {
-    [SCHEDULED_ACTION_RECOVER_EVENT_IDENTIFIER]: true;
-}
-declare class ScheduledActionRecoverEventTypeImpl implements IEventType<IScheduledActionRecoverEvent> {
-    canHandle(event: any): event is IScheduledActionRecoverEvent;
-    getHandlerAbstraction(): import("@webiny/di").Abstraction<import("./ScheduledActionRecoverEventHandler.js").IScheduledActionRecoverEventHandler>;
-}
-export declare const ScheduledActionRecoverEventType: typeof ScheduledActionRecoverEventTypeImpl & {
-    __abstraction: import("@webiny/di").Abstraction<IEventType<any>>;
-};
-export {};

package/scheduler/ScheduledActionRecoverEventType.js

@@ -1,18 +0,0 @@
-import { EventType } from "@webiny/event-handler-core";
-import { ScheduledActionRecoverEventHandler } from "./ScheduledActionRecoverEventHandler.js";
-const SCHEDULED_ACTION_RECOVER_EVENT_IDENTIFIER = "WebinyScheduledActionRecover";
-class ScheduledActionRecoverEventTypeImpl {
-    canHandle(event) {
-        return event?.[SCHEDULED_ACTION_RECOVER_EVENT_IDENTIFIER] === true;
-    }
-    getHandlerAbstraction() {
-        return ScheduledActionRecoverEventHandler;
-    }
-}
-const ScheduledActionRecoverEventType = EventType.createImplementation({
-    implementation: ScheduledActionRecoverEventTypeImpl,
-    dependencies: []
-});
-export { SCHEDULED_ACTION_RECOVER_EVENT_IDENTIFIER, ScheduledActionRecoverEventType };
-
-//# sourceMappingURL=ScheduledActionRecoverEventType.js.map

package/scheduler/ScheduledActionRecoverEventType.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"scheduler/ScheduledActionRecoverEventType.js","sources":["../../src/scheduler/ScheduledActionRecoverEventType.ts"],"sourcesContent":["import { EventType } from \"@webiny/event-handler-core\";\nimport type { IEventType } from \"@webiny/event-handler-core\";\nimport { ScheduledActionRecoverEventHandler } from \"./ScheduledActionRecoverEventHandler.js\";\n\nexport const SCHEDULED_ACTION_RECOVER_EVENT_IDENTIFIER = \"WebinyScheduledActionRecover\";\n\n/**\n * Asks the scheduler to re-arm the root tenant's pending scheduled actions. Dispatched once at\n * boot: Bree keeps its timers in memory, so a restart loses every schedule that has not fired yet.\n */\nexport interface IScheduledActionRecoverEvent {\n    [SCHEDULED_ACTION_RECOVER_EVENT_IDENTIFIER]: true;\n}\n\nclass ScheduledActionRecoverEventTypeImpl implements IEventType<IScheduledActionRecoverEvent> {\n    canHandle(event: any): event is IScheduledActionRecoverEvent {\n        return event?.[SCHEDULED_ACTION_RECOVER_EVENT_IDENTIFIER] === true;\n    }\n\n    getHandlerAbstraction() {\n        return ScheduledActionRecoverEventHandler;\n    }\n}\n\nexport const ScheduledActionRecoverEventType = EventType.createImplementation({\n    implementation: ScheduledActionRecoverEventTypeImpl,\n    dependencies: []\n});\n"],"names":["SCHEDULED_ACTION_RECOVER_EVENT_IDENTIFIER","ScheduledActionRecoverEventTypeImpl","event","ScheduledActionRecoverEventHandler","ScheduledActionRecoverEventType","EventType"],"mappings":";;AAIO,MAAMA,4CAA4C;AAUzD,MAAMC;IACF,UAAUC,KAAU,EAAyC;QACzD,OAAOA,OAAO,CAACF,0CAA0C,KAAK;IAClE;IAEA,wBAAwB;QACpB,OAAOG;IACX;AACJ;AAEO,MAAMC,kCAAkCC,UAAU,oBAAoB,CAAC;IAC1E,gBAAgBJ;IAChB,cAAc,EAAE;AACpB"}