@webiny/api-event-handler-standalone 0.0.0-unstable.0156a4c312

package/scheduler/ScheduledActionRecoverEventHandler.d.ts

@@ -0,0 +1,14 @@
+import { Abstraction } from "@webiny/di";
+import type { IEventHandler } from "@webiny/event-handler-core";
+import type { IScheduledActionRecoverEvent } from "./ScheduledActionRecoverEventType.js";
+export interface IScheduledActionRecoverResult {
+    recovered: number;
+    failedTenants: string[];
+}
+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

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

package/scheduler/ScheduledActionRecoverEventHandler.js.map

@@ -0,0 +1 @@
+{"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    // Tenants whose schedules could not be read or re-armed; the others were still recovered.\n    failedTenants: string[];\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":";AAeO,MAAMA,qCACT,IAAIC,YAAiD"}

package/scheduler/ScheduledActionRecoverEventType.d.ts

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1 @@
+{"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"}

package/scheduler/abstractions/SchedulerSingleton.d.ts

@@ -0,0 +1,10 @@
+import type { BreeSchedulerService } from "@webiny/api-scheduler-standalone";
+/**
+ * DI token for the single root Bree scheduler instance. Distinct from the `SchedulerService`
+ * abstraction (create/update/delete/exists): this exposes the concrete service so the recover route +
+ * boot step can call `recover()`, which isn't part of the SchedulerService contract.
+ */
+export declare const SchedulerSingleton: import("@webiny/di").Abstraction<BreeSchedulerService>;
+export declare namespace SchedulerSingleton {
+    type Interface = BreeSchedulerService;
+}

package/scheduler/abstractions/SchedulerSingleton.js

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

package/scheduler/abstractions/SchedulerSingleton.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheduler/abstractions/SchedulerSingleton.js","sources":["../../../src/scheduler/abstractions/SchedulerSingleton.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { BreeSchedulerService } from \"@webiny/api-scheduler-standalone\";\n\n/**\n * DI token for the single root Bree scheduler instance. Distinct from the `SchedulerService`\n * abstraction (create/update/delete/exists): this exposes the concrete service so the recover route +\n * boot step can call `recover()`, which isn't part of the SchedulerService contract.\n */\nexport const SchedulerSingleton = createAbstraction<BreeSchedulerService>(\n    \"SchedulerServer/Singleton\"\n);\n\nexport namespace SchedulerSingleton {\n    export type Interface = BreeSchedulerService;\n}\n"],"names":["SchedulerSingleton","createAbstraction"],"mappings":";AAQO,MAAMA,qBAAqBC,kBAC9B"}

package/scheduler/schedulerServer.d.ts

@@ -0,0 +1,25 @@
+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.
+ *
+ * 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.
+ */
+export declare function registerSchedulerServer(rootContainer: Container): void;
+/**
+ * Boot step (onServer): start the timers, then re-arm the persisted schedules, at boot and then every
+ * minute. 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.
+ *
+ * Running it every minute is what makes several processes work. Each holds its own timers, so an
+ * action scheduled or moved through one process reaches the others' timers within a minute, and an
+ * action whose process died is still fired, as an overdue one. `RunScheduledActionOnceDecorator`
+ * keeps the processes from all running it. Runs never overlap.
+ *
+ * Returns a function for the shutdown: it stops the timers and recovery, then waits up to
+ * `timeoutMs` for actions already running.
+ */
+export declare function startSchedulerServer(rootContainer: Container): Promise<(timeoutMs: number) => Promise<void>>;

package/scheduler/schedulerServer.js

@@ -0,0 +1,89 @@
+import { EventDispatcher, SCHEDULED_ACTION_EVENT_IDENTIFIER, ScheduledActionEventType } from "@webiny/event-handler-core";
+import { SchedulerService } from "@webiny/api-scheduler/shared/abstractions.js";
+import { ScheduledActionLambdaHandler } from "@webiny/api-scheduler";
+import { BreeSchedulerService } from "@webiny/api-scheduler-standalone";
+import { SchedulerSingleton } from "./abstractions/SchedulerSingleton.js";
+import { SCHEDULED_ACTION_RECOVER_EVENT_IDENTIFIER, ScheduledActionRecoverEventType } from "./ScheduledActionRecoverEventType.js";
+import { RecoverScheduledActionsHandler } from "./RecoverScheduledActionsHandler.js";
+import { RunScheduledActionOnceDecorator } from "./RunScheduledActionOnceDecorator.js";
+import { Logger } from "@webiny/api-core/features/logger/index.js";
+function registerSchedulerServer(rootContainer) {
+    const dispatcher = rootContainer.resolve(EventDispatcher);
+    const logger = rootContainer.resolve(Logger);
+    const service = new BreeSchedulerService({
+        logger,
+        runAction: async (id, namespace, tenant)=>{
+            const event = {
+                [SCHEDULED_ACTION_EVENT_IDENTIFIER]: {
+                    id,
+                    namespace,
+                    tenant,
+                    scheduleFor: new Date().toISOString()
+                }
+            };
+            try {
+                await dispatcher.dispatch(event);
+            } catch (err) {
+                logger.error({
+                    error: err,
+                    id,
+                    tenant
+                }, "[scheduler] scheduled action failed");
+            }
+        }
+    });
+    rootContainer.registerInstance(SchedulerSingleton, service);
+    rootContainer.registerInstance(SchedulerService, service);
+    rootContainer.register(ScheduledActionEventType);
+    rootContainer.register(ScheduledActionLambdaHandler);
+    rootContainer.registerDecorator(RunScheduledActionOnceDecorator);
+    rootContainer.register(ScheduledActionRecoverEventType);
+    rootContainer.register(RecoverScheduledActionsHandler);
+}
+const RECOVER_EVERY_MS = 60000;
+async function recoverPendingSchedules(dispatcher, logger, atBoot) {
+    const event = {
+        [SCHEDULED_ACTION_RECOVER_EVENT_IDENTIFIER]: true
+    };
+    try {
+        const result = await dispatcher.dispatch(event);
+        if (atBoot) logger.info({
+            recovered: result.recovered
+        }, "[scheduler] boot recovery re-armed pending actions");
+        if (result.failedTenants.length > 0) logger.error({
+            tenants: result.failedTenants
+        }, "[scheduler] recovery failed for some tenants");
+    } catch (err) {
+        logger.error({
+            error: err
+        }, "[scheduler] recovery failed");
+    }
+}
+async function startSchedulerServer(rootContainer) {
+    const scheduler = rootContainer.resolve(SchedulerSingleton);
+    await scheduler.start();
+    const dispatcher = rootContainer.resolve(EventDispatcher);
+    const logger = rootContainer.resolve(Logger);
+    let recovering = false;
+    const recover = async (atBoot)=>{
+        if (recovering) return;
+        recovering = true;
+        try {
+            await recoverPendingSchedules(dispatcher, logger, atBoot);
+        } finally{
+            recovering = false;
+        }
+    };
+    recover(true);
+    const everyMinute = setInterval(()=>{
+        recover(false);
+    }, RECOVER_EVERY_MS);
+    return async (timeoutMs)=>{
+        clearInterval(everyMinute);
+        await scheduler.stop();
+        await scheduler.waitForRunning(timeoutMs);
+    };
+}
+export { registerSchedulerServer, startSchedulerServer };
+
+//# sourceMappingURL=schedulerServer.js.map

package/scheduler/schedulerServer.js.map

@@ -0,0 +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 { 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\";\nimport { RunScheduledActionOnceDecorator } from \"./RunScheduledActionOnceDecorator.js\";\nimport { Logger } from \"@webiny/api-core/features/logger/index.js\";\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    const logger = rootContainer.resolve(Logger);\n\n    const service = new BreeSchedulerService({\n        logger,\n        runAction: 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                logger.error({ error: err, id, tenant }, \"[scheduler] scheduled action failed\");\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    // Every process holds timers for the same actions; this lets only one of them run each action.\n    rootContainer.registerDecorator(RunScheduledActionOnceDecorator);\n\n    rootContainer.register(ScheduledActionRecoverEventType);\n    rootContainer.register(RecoverScheduledActionsHandler);\n}\n\n// How often each process re-arms pending actions and fires overdue ones.\nconst RECOVER_EVERY_MS = 60_000;\n\nasync function recoverPendingSchedules(\n    dispatcher: EventDispatcher.Interface,\n    logger: Logger.Interface,\n    atBoot: boolean\n): 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        if (atBoot) {\n            logger.info(\n                { recovered: result.recovered },\n                \"[scheduler] boot recovery re-armed pending actions\"\n            );\n        }\n        if (result.failedTenants.length > 0) {\n            logger.error(\n                { tenants: result.failedTenants },\n                \"[scheduler] recovery failed for some tenants\"\n            );\n        }\n    } catch (err) {\n        logger.error({ error: err }, \"[scheduler] recovery failed\");\n    }\n}\n\n/**\n * Boot step (onServer): start the timers, then re-arm the persisted schedules, at boot and then every\n * minute. Recovery runs in the background: it executes overdue actions one by one, and the server\n * should not wait for that before it starts listening. A failure is logged and never crashes startup.\n *\n * Running it every minute is what makes several processes work. Each holds its own timers, so an\n * action scheduled or moved through one process reaches the others' timers within a minute, and an\n * action whose process died is still fired, as an overdue one. `RunScheduledActionOnceDecorator`\n * keeps the processes from all running it. Runs never overlap.\n *\n * Returns a function for the shutdown: it stops the timers and recovery, then waits up to\n * `timeoutMs` for actions already running.\n */\nexport async function startSchedulerServer(\n    rootContainer: Container\n): Promise<(timeoutMs: number) => Promise<void>> {\n    const scheduler = rootContainer.resolve(SchedulerSingleton);\n    await scheduler.start();\n\n    const dispatcher = rootContainer.resolve(EventDispatcher);\n    const logger = rootContainer.resolve(Logger);\n    let recovering = false;\n    const recover = async (atBoot: boolean) => {\n        if (recovering) {\n            return;\n        }\n        recovering = true;\n        try {\n            await recoverPendingSchedules(dispatcher, logger, atBoot);\n        } finally {\n            recovering = false;\n        }\n    };\n\n    void recover(true);\n    const everyMinute = setInterval(() => {\n        void recover(false);\n    }, RECOVER_EVERY_MS);\n\n    return async (timeoutMs: number) => {\n        clearInterval(everyMinute);\n        await scheduler.stop();\n        await scheduler.waitForRunning(timeoutMs);\n    };\n}\n"],"names":["registerSchedulerServer","rootContainer","dispatcher","EventDispatcher","logger","Logger","service","BreeSchedulerService","id","namespace","tenant","event","SCHEDULED_ACTION_EVENT_IDENTIFIER","Date","err","SchedulerSingleton","SchedulerService","ScheduledActionEventType","ScheduledActionLambdaHandler","RunScheduledActionOnceDecorator","ScheduledActionRecoverEventType","RecoverScheduledActionsHandler","RECOVER_EVERY_MS","recoverPendingSchedules","atBoot","SCHEDULED_ACTION_RECOVER_EVENT_IDENTIFIER","result","startSchedulerServer","scheduler","recovering","recover","everyMinute","setInterval","timeoutMs","clearInterval"],"mappings":";;;;;;;;;AA0BO,SAASA,wBAAwBC,aAAwB;IAC5D,MAAMC,aAAaD,cAAc,OAAO,CAACE;IACzC,MAAMC,SAASH,cAAc,OAAO,CAACI;IAErC,MAAMC,UAAU,IAAIC,qBAAqB;QACrCH;QACA,WAAW,OAAOI,IAAIC,WAAWC;YAK7B,MAAMC,QAA+B;gBACjC,CAACC,kCAAkC,EAAE;oBACjCJ;oBACAC;oBACAC;oBACA,aAAa,IAAIG,OAAO,WAAW;gBACvC;YACJ;YACA,IAAI;gBACA,MAAMX,WAAW,QAAQ,CAACS;YAC9B,EAAE,OAAOG,KAAK;gBACVV,OAAO,KAAK,CAAC;oBAAE,OAAOU;oBAAKN;oBAAIE;gBAAO,GAAG;YAC7C;QACJ;IACJ;IAgBAT,cAAc,gBAAgB,CAACc,oBAAoBT;IACnDL,cAAc,gBAAgB,CAACe,kBAAkBV;IAEjDL,cAAc,QAAQ,CAACgB;IACvBhB,cAAc,QAAQ,CAACiB;IAEvBjB,cAAc,iBAAiB,CAACkB;IAEhClB,cAAc,QAAQ,CAACmB;IACvBnB,cAAc,QAAQ,CAACoB;AAC3B;AAGA,MAAMC,mBAAmB;AAEzB,eAAeC,wBACXrB,UAAqC,EACrCE,MAAwB,EACxBoB,MAAe;IAEf,MAAMb,QAAsC;QACxC,CAACc,0CAA0C,EAAE;IACjD;IAEA,IAAI;QACA,MAAMC,SAAS,MAAMxB,WAAW,QAAQ,CAA4CS;QACpF,IAAIa,QACApB,OAAO,IAAI,CACP;YAAE,WAAWsB,OAAO,SAAS;QAAC,GAC9B;QAGR,IAAIA,OAAO,aAAa,CAAC,MAAM,GAAG,GAC9BtB,OAAO,KAAK,CACR;YAAE,SAASsB,OAAO,aAAa;QAAC,GAChC;IAGZ,EAAE,OAAOZ,KAAK;QACVV,OAAO,KAAK,CAAC;YAAE,OAAOU;QAAI,GAAG;IACjC;AACJ;AAeO,eAAea,qBAClB1B,aAAwB;IAExB,MAAM2B,YAAY3B,cAAc,OAAO,CAACc;IACxC,MAAMa,UAAU,KAAK;IAErB,MAAM1B,aAAaD,cAAc,OAAO,CAACE;IACzC,MAAMC,SAASH,cAAc,OAAO,CAACI;IACrC,IAAIwB,aAAa;IACjB,MAAMC,UAAU,OAAON;QACnB,IAAIK,YACA;QAEJA,aAAa;QACb,IAAI;YACA,MAAMN,wBAAwBrB,YAAYE,QAAQoB;QACtD,SAAU;YACNK,aAAa;QACjB;IACJ;IAEKC,QAAQ;IACb,MAAMC,cAAcC,YAAY;QACvBF,QAAQ;IACjB,GAAGR;IAEH,OAAO,OAAOW;QACVC,cAAcH;QACd,MAAMH,UAAU,IAAI;QACpB,MAAMA,UAAU,cAAc,CAACK;IACnC;AACJ"}

package/websockets/createWebsocketsAuthenticator.d.ts

@@ -0,0 +1,24 @@
+import type { Container } from "@webiny/di";
+import { type RegisterApiRequestStackConfig } from "@webiny/api-event-handler-core";
+import type { WebsocketsConnectionAuthenticator } from "@webiny/api-websockets-standalone";
+/**
+ * Builds the `authenticate` callback the server WebSocket upgrade acceptor uses to turn a
+ * connection's `?token` JWT into an identity.
+ *
+ * Each new WebSocket connection (the HTTP upgrade handshake) is authenticated from its `?token` JWT
+ * so the connection is registered under the real identity — targeted server→client sends need this,
+ * since SendToIdentity matches connections by identity id. The catch is that AuthenticationContext
+ * lives in the per-request stack (registered by ApiCoreFeature, not registerRootStorage), so we can't
+ * resolve it from the root container. Instead we spin up a short-lived request-scoped child container,
+ * the same way createHandler does for each HTTP request, and resolve it there. We only need the core
+ * stack, not the transports, because this is just the token→identity step the HTTP stack already runs
+ * via RequestIdentityLoader — and that step doesn't depend on the tenant (the HTTP stack resolves
+ * identity before tenant), so there's no request or tenant state to set up. Connections are rare (one
+ * per admin session), so a fresh child per connection is cheap enough.
+ *
+ * This is also why the WebSocket server takes `authenticate` as a plain callback instead of resolving
+ * auth itself: AuthenticationContext isn't reachable from the root container (it's per-request), so
+ * only the handler — which can build a request-scoped child — can supply it. So authenticate has to be
+ * a callback the handler builds, regardless of DI.
+ */
+export declare function createWebsocketsAuthenticator(rootContainer: Container, extensions: RegisterApiRequestStackConfig["extensions"]): WebsocketsConnectionAuthenticator;

package/websockets/createWebsocketsAuthenticator.js

@@ -0,0 +1,22 @@
+import { RequestContainer } from "@webiny/event-handler-core";
+import { registerApiRequestStack } from "@webiny/api-event-handler-core";
+import { AuthenticationContext } from "@webiny/api-core/features/security/authentication/AuthenticationContext/index.js";
+function createWebsocketsAuthenticator(rootContainer, extensions) {
+    return async (token)=>{
+        const child = rootContainer.createChildContainer();
+        child.registerInstance(RequestContainer, child);
+        await registerApiRequestStack(child, {
+            extensions
+        });
+        const identity = await child.resolve(AuthenticationContext).authenticate(token);
+        if (!identity?.id) return null;
+        return {
+            id: identity.id,
+            displayName: identity.displayName,
+            type: identity.type
+        };
+    };
+}
+export { createWebsocketsAuthenticator };
+
+//# sourceMappingURL=createWebsocketsAuthenticator.js.map

package/websockets/createWebsocketsAuthenticator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"websockets/createWebsocketsAuthenticator.js","sources":["../../src/websockets/createWebsocketsAuthenticator.ts"],"sourcesContent":["import type { Container } from \"@webiny/di\";\nimport { RequestContainer } from \"@webiny/event-handler-core\";\nimport {\n    registerApiRequestStack,\n    type RegisterApiRequestStackConfig\n} from \"@webiny/api-event-handler-core\";\nimport { AuthenticationContext } from \"@webiny/api-core/features/security/authentication/AuthenticationContext/index.js\";\nimport type { WebsocketsConnectionAuthenticator } from \"@webiny/api-websockets-standalone\";\n\n/**\n * Builds the `authenticate` callback the server WebSocket upgrade acceptor uses to turn a\n * connection's `?token` JWT into an identity.\n *\n * Each new WebSocket connection (the HTTP upgrade handshake) is authenticated from its `?token` JWT\n * so the connection is registered under the real identity — targeted server→client sends need this,\n * since SendToIdentity matches connections by identity id. The catch is that AuthenticationContext\n * lives in the per-request stack (registered by ApiCoreFeature, not registerRootStorage), so we can't\n * resolve it from the root container. Instead we spin up a short-lived request-scoped child container,\n * the same way createHandler does for each HTTP request, and resolve it there. We only need the core\n * stack, not the transports, because this is just the token→identity step the HTTP stack already runs\n * via RequestIdentityLoader — and that step doesn't depend on the tenant (the HTTP stack resolves\n * identity before tenant), so there's no request or tenant state to set up. Connections are rare (one\n * per admin session), so a fresh child per connection is cheap enough.\n *\n * This is also why the WebSocket server takes `authenticate` as a plain callback instead of resolving\n * auth itself: AuthenticationContext isn't reachable from the root container (it's per-request), so\n * only the handler — which can build a request-scoped child — can supply it. So authenticate has to be\n * a callback the handler builds, regardless of DI.\n */\nexport function createWebsocketsAuthenticator(\n    rootContainer: Container,\n    extensions: RegisterApiRequestStackConfig[\"extensions\"]\n): WebsocketsConnectionAuthenticator {\n    return async token => {\n        const child = rootContainer.createChildContainer();\n        child.registerInstance(RequestContainer, child);\n        await registerApiRequestStack(child, { extensions });\n        const identity = await child.resolve(AuthenticationContext).authenticate(token);\n        if (!identity?.id) {\n            return null;\n        }\n        return {\n            id: identity.id,\n            displayName: identity.displayName,\n            type: identity.type\n        };\n    };\n}\n"],"names":["createWebsocketsAuthenticator","rootContainer","extensions","token","child","RequestContainer","registerApiRequestStack","identity","AuthenticationContext"],"mappings":";;;AA6BO,SAASA,8BACZC,aAAwB,EACxBC,UAAuD;IAEvD,OAAO,OAAMC;QACT,MAAMC,QAAQH,cAAc,oBAAoB;QAChDG,MAAM,gBAAgB,CAACC,kBAAkBD;QACzC,MAAME,wBAAwBF,OAAO;YAAEF;QAAW;QAClD,MAAMK,WAAW,MAAMH,MAAM,OAAO,CAACI,uBAAuB,YAAY,CAACL;QACzE,IAAI,CAACI,UAAU,IACX,OAAO;QAEX,OAAO;YACH,IAAIA,SAAS,EAAE;YACf,aAAaA,SAAS,WAAW;YACjC,MAAMA,SAAS,IAAI;QACvB;IACJ;AACJ"}