@webiny/event-handler-core 6.6.0-alpha.0 → 6.6.0-alpha.2

package/features/http/toSseFrame.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Frame one value as a server-sent-events `data:` record.
+ *
+ * The SSE wire format, not any one feature's protocol: a record is `data: <payload>` followed by the
+ * blank line that terminates it. What goes IN the payload — the event names and their fields — is per
+ * feature and belongs with that feature.
+ *
+ * Counterpart to `readServerSentEvents` in `@webiny/app`, which parses these on the client.
+ */
+export declare function toSseFrame(data: unknown): string;

package/features/http/toSseFrame.js

@@ -0,0 +1,6 @@
+function toSseFrame(data) {
+    return `data: ${JSON.stringify(data)}\n\n`;
+}
+export { toSseFrame };
+
+//# sourceMappingURL=toSseFrame.js.map

package/features/http/toSseFrame.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/http/toSseFrame.js","sources":["../../../src/features/http/toSseFrame.ts"],"sourcesContent":["/**\n * Frame one value as a server-sent-events `data:` record.\n *\n * The SSE wire format, not any one feature's protocol: a record is `data: <payload>` followed by the\n * blank line that terminates it. What goes IN the payload — the event names and their fields — is per\n * feature and belongs with that feature.\n *\n * Counterpart to `readServerSentEvents` in `@webiny/app`, which parses these on the client.\n */\nexport function toSseFrame(data: unknown): string {\n    return `data: ${JSON.stringify(data)}\\n\\n`;\n}\n"],"names":["toSseFrame","data","JSON"],"mappings":"AASO,SAASA,WAAWC,IAAa;IACpC,OAAO,CAAC,MAAM,EAAEC,KAAK,SAAS,CAACD,MAAM,IAAI,CAAC;AAC9C"}

package/features/testing/createTestHttpHandler.d.ts

@@ -1,7 +1,7 @@
 import type { HandlerSetup, IHttpRequest, IHttpResponse } from "../../index.js";
 export interface createTestHttpHandlerOptions {
     root: HandlerSetup;
-    request?: HandlerSetup;
+    child?: HandlerSetup;
 }
 /**
  * Test handler that accepts IHttpRequest directly and returns IHttpResponse.

package/features/testing/createTestHttpHandler.js

@@ -1,18 +1,18 @@
 import { HttpFeature } from "../http/feature.js";
 import { HttpRouterHandler } from "./HttpRouterHandler.js";
-import { createHandler } from "../events/createHandler.js";
+import { HandlerApp } from "../events/HandlerApp.js";
 import { TestHttpEventType } from "./TestHttpEventType.js";
 function createTestHttpHandler(options) {
-    const invoke = createHandler({
+    const app = HandlerApp.init({
         root: async (container)=>{
             container.register(TestHttpEventType);
             container.register(HttpRouterHandler);
             HttpFeature.register(container);
             await options.root(container);
         },
-        request: options.request
+        child: options.child
     });
-    return async (request)=>invoke({
+    return async (request)=>app.handle({
             method: request.method,
             path: request.path,
             headers: request.headers ?? {},

package/features/testing/createTestHttpHandler.js.map

@@ -1 +1 @@
-{"version":3,"file":"features/testing/createTestHttpHandler.js","sources":["../../../src/features/testing/createTestHttpHandler.ts"],"sourcesContent":["import { HttpFeature } from \"~/features/http/feature.js\";\nimport { HttpRouterHandler } from \"./HttpRouterHandler.js\";\nimport { createHandler } from \"~/features/events/createHandler.js\";\nimport { TestHttpEventType } from \"./TestHttpEventType.js\";\nimport type { HandlerSetup, IHttpRequest, IHttpResponse } from \"~/index.js\";\n\nexport interface createTestHttpHandlerOptions {\n    root: HandlerSetup;\n    request?: HandlerSetup;\n}\n\n/**\n * Test handler that accepts IHttpRequest directly and returns IHttpResponse.\n * Registers HttpRouterHandler as the base TestHttpEventHandler implementation.\n * Callers layer middleware on top via container.registerDecorator() in options.root.\n */\nexport function createTestHttpHandler(options: createTestHttpHandlerOptions) {\n    const invoke = createHandler({\n        root: async container => {\n            container.register(TestHttpEventType);\n            container.register(HttpRouterHandler);\n            HttpFeature.register(container);\n            await options.root(container);\n        },\n        request: options.request\n    });\n\n    return async (\n        request: Partial<IHttpRequest> & { method: string; path: string }\n    ): Promise<IHttpResponse> => {\n        return invoke({\n            method: request.method,\n            path: request.path,\n            headers: request.headers ?? {},\n            query: request.query ?? {},\n            pathParameters: request.pathParameters ?? {},\n            body: request.body\n        });\n    };\n}\n"],"names":["createTestHttpHandler","options","invoke","createHandler","container","TestHttpEventType","HttpRouterHandler","HttpFeature","request"],"mappings":";;;;AAgBO,SAASA,sBAAsBC,OAAqC;IACvE,MAAMC,SAASC,cAAc;QACzB,MAAM,OAAMC;YACRA,UAAU,QAAQ,CAACC;YACnBD,UAAU,QAAQ,CAACE;YACnBC,YAAY,QAAQ,CAACH;YACrB,MAAMH,QAAQ,IAAI,CAACG;QACvB;QACA,SAASH,QAAQ,OAAO;IAC5B;IAEA,OAAO,OACHO,UAEON,OAAO;YACV,QAAQM,QAAQ,MAAM;YACtB,MAAMA,QAAQ,IAAI;YAClB,SAASA,QAAQ,OAAO,IAAI,CAAC;YAC7B,OAAOA,QAAQ,KAAK,IAAI,CAAC;YACzB,gBAAgBA,QAAQ,cAAc,IAAI,CAAC;YAC3C,MAAMA,QAAQ,IAAI;QACtB;AAER"}
+{"version":3,"file":"features/testing/createTestHttpHandler.js","sources":["../../../src/features/testing/createTestHttpHandler.ts"],"sourcesContent":["import { HttpFeature } from \"~/features/http/feature.js\";\nimport { HttpRouterHandler } from \"./HttpRouterHandler.js\";\nimport { HandlerApp } from \"~/features/events/HandlerApp.js\";\nimport { TestHttpEventType } from \"./TestHttpEventType.js\";\nimport type { HandlerSetup, IHttpRequest, IHttpResponse } from \"~/index.js\";\n\nexport interface createTestHttpHandlerOptions {\n    root: HandlerSetup;\n    child?: HandlerSetup;\n}\n\n/**\n * Test handler that accepts IHttpRequest directly and returns IHttpResponse.\n * Registers HttpRouterHandler as the base TestHttpEventHandler implementation.\n * Callers layer middleware on top via container.registerDecorator() in options.root.\n */\nexport function createTestHttpHandler(options: createTestHttpHandlerOptions) {\n    const app = HandlerApp.init({\n        root: async container => {\n            container.register(TestHttpEventType);\n            container.register(HttpRouterHandler);\n            HttpFeature.register(container);\n            await options.root(container);\n        },\n        child: options.child\n    });\n\n    return async (\n        request: Partial<IHttpRequest> & { method: string; path: string }\n    ): Promise<IHttpResponse> => {\n        return app.handle({\n            method: request.method,\n            path: request.path,\n            headers: request.headers ?? {},\n            query: request.query ?? {},\n            pathParameters: request.pathParameters ?? {},\n            body: request.body\n        });\n    };\n}\n"],"names":["createTestHttpHandler","options","app","HandlerApp","container","TestHttpEventType","HttpRouterHandler","HttpFeature","request"],"mappings":";;;;AAgBO,SAASA,sBAAsBC,OAAqC;IACvE,MAAMC,MAAMC,WAAW,IAAI,CAAC;QACxB,MAAM,OAAMC;YACRA,UAAU,QAAQ,CAACC;YACnBD,UAAU,QAAQ,CAACE;YACnBC,YAAY,QAAQ,CAACH;YACrB,MAAMH,QAAQ,IAAI,CAACG;QACvB;QACA,OAAOH,QAAQ,KAAK;IACxB;IAEA,OAAO,OACHO,UAEON,IAAI,MAAM,CAAC;YACd,QAAQM,QAAQ,MAAM;YACtB,MAAMA,QAAQ,IAAI;YAClB,SAASA,QAAQ,OAAO,IAAI,CAAC;YAC7B,OAAOA,QAAQ,KAAK,IAAI,CAAC;YACzB,gBAAgBA,QAAQ,cAAc,IAAI,CAAC;YAC3C,MAAMA,QAAQ,IAAI;QACtB;AAER"}

package/features/testing/index.d.ts

@@ -2,3 +2,4 @@ export * from "./TestHttpEventHandler.js";
 export * from "./TestHttpEventType.js";
 export * from "./HttpRouterHandler.js";
 export * from "./createTestHttpHandler.js";
+export * from "./registerHttpRouteInstance.js";

package/features/testing/index.js

@@ -2,3 +2,4 @@ export * from "./TestHttpEventHandler.js";
 export * from "./TestHttpEventType.js";
 export * from "./HttpRouterHandler.js";
 export * from "./createTestHttpHandler.js";
+export * from "./registerHttpRouteInstance.js";

package/features/testing/registerHttpRouteInstance.d.ts

@@ -0,0 +1,16 @@
+import type { Container } from "@webiny/di";
+import type { IHttpRoute } from "../../features/http/abstractions.js";
+export interface IRegisterHttpRouteInstanceParams {
+    readonly name?: string;
+    readonly method: string;
+    readonly path: string;
+    readonly route: IHttpRoute;
+}
+/**
+ * Registers a definition pointing at an ALREADY-BUILT route object.
+ *
+ * For tests that hand-roll a route as a literal. The router builds routes from a class, so the
+ * literal is wrapped in a zero-dependency one that delegates to it. Production code declares its
+ * class with `HttpRouteHandler.createImplementation` and points the definition straight at it.
+ */
+export declare function registerHttpRouteInstance(container: Container, params: IRegisterHttpRouteInstanceParams): void;

package/features/testing/registerHttpRouteInstance.js

@@ -0,0 +1,27 @@
+import { HttpRouteDefinition, HttpRouteHandler } from "../http/abstractions.js";
+function registerHttpRouteInstance(container, params) {
+    class DelegatingRoute {
+        handle(request, response) {
+            return Promise.resolve(params.route.handle(request, response));
+        }
+    }
+    const handler = HttpRouteHandler.createImplementation({
+        implementation: DelegatingRoute,
+        dependencies: []
+    });
+    class DelegatingRouteDefinition {
+        constructor(){
+            this.name = params.name ?? `test:${params.method}${params.path}`;
+            this.method = params.method;
+            this.path = params.path;
+            this.handler = handler;
+        }
+    }
+    container.register(HttpRouteDefinition.createImplementation({
+        implementation: DelegatingRouteDefinition,
+        dependencies: []
+    }));
+}
+export { registerHttpRouteInstance };
+
+//# sourceMappingURL=registerHttpRouteInstance.js.map

package/features/testing/registerHttpRouteInstance.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/testing/registerHttpRouteInstance.js","sources":["../../../src/features/testing/registerHttpRouteInstance.ts"],"sourcesContent":["import type { Container } from \"@webiny/di\";\nimport { HttpRouteDefinition, HttpRouteHandler } from \"~/features/http/abstractions.js\";\nimport type {\n    IHttpRequest,\n    IHttpResponse,\n    IHttpResponseBuilder\n} from \"~/features/http/abstractions.js\";\nimport type { IHttpRoute } from \"~/features/http/abstractions.js\";\n\nexport interface IRegisterHttpRouteInstanceParams {\n    readonly name?: string;\n    readonly method: string;\n    readonly path: string;\n    readonly route: IHttpRoute;\n}\n\n/**\n * Registers a definition pointing at an ALREADY-BUILT route object.\n *\n * For tests that hand-roll a route as a literal. The router builds routes from a class, so the\n * literal is wrapped in a zero-dependency one that delegates to it. Production code declares its\n * class with `HttpRouteHandler.createImplementation` and points the definition straight at it.\n */\nexport function registerHttpRouteInstance(\n    container: Container,\n    params: IRegisterHttpRouteInstanceParams\n): void {\n    class DelegatingRoute implements HttpRouteHandler.Interface {\n        handle(\n            request: IHttpRequest,\n            response: IHttpResponseBuilder\n        ): Promise<IHttpResponse | IHttpResponseBuilder | void> {\n            return Promise.resolve(params.route.handle(request, response));\n        }\n    }\n\n    const handler = HttpRouteHandler.createImplementation({\n        implementation: DelegatingRoute,\n        dependencies: []\n    });\n\n    class DelegatingRouteDefinition implements HttpRouteDefinition.Interface {\n        readonly name = params.name ?? `test:${params.method}${params.path}`;\n        readonly method = params.method;\n        readonly path = params.path;\n        readonly handler = handler;\n    }\n\n    container.register(\n        HttpRouteDefinition.createImplementation({\n            implementation: DelegatingRouteDefinition,\n            dependencies: []\n        })\n    );\n}\n"],"names":["registerHttpRouteInstance","container","params","DelegatingRoute","request","response","Promise","handler","HttpRouteHandler","DelegatingRouteDefinition","HttpRouteDefinition"],"mappings":";AAuBO,SAASA,0BACZC,SAAoB,EACpBC,MAAwC;IAExC,MAAMC;QACF,OACIC,OAAqB,EACrBC,QAA8B,EACsB;YACpD,OAAOC,QAAQ,OAAO,CAACJ,OAAO,KAAK,CAAC,MAAM,CAACE,SAASC;QACxD;IACJ;IAEA,MAAME,UAAUC,iBAAiB,oBAAoB,CAAC;QAClD,gBAAgBL;QAChB,cAAc,EAAE;IACpB;IAEA,MAAMM;;iBACO,IAAI,GAAGP,OAAO,IAAI,IAAI,CAAC,KAAK,EAAEA,OAAO,MAAM,GAAGA,OAAO,IAAI,EAAE;iBAC3D,MAAM,GAAGA,OAAO,MAAM;iBACtB,IAAI,GAAGA,OAAO,IAAI;iBAClB,OAAO,GAAGK;;IACvB;IAEAN,UAAU,QAAQ,CACdS,oBAAoB,oBAAoB,CAAC;QACrC,gBAAgBD;QAChB,cAAc,EAAE;IACpB;AAER"}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@webiny/event-handler-core",
-	"version": "6.6.0-alpha.0",
+	"version": "6.6.0-alpha.2",
 	"type": "module",
 	"main": "index.js",
 	"exports": {
@@ -18,17 +18,17 @@
 	],
 	"license": "MIT",
 	"dependencies": {
-		"@webiny/feature": "6.6.0-alpha.0"
+		"@webiny/feature": "6.6.0-alpha.2"
 	},
 	"peerDependencies": {
-		"@webiny/di": "1.0.2"
+		"@webiny/di": "1.1.0"
 	},
 	"devDependencies": {
-		"@webiny/build-tools": "6.6.0-alpha.0",
-		"@webiny/di": "1.0.2",
+		"@webiny/build-tools": "6.6.0-alpha.2",
+		"@webiny/di": "1.1.0",
 		"rimraf": "6.1.3",
 		"typescript": "7.0.2",
-		"vitest": "4.1.10"
+		"vitest": "4.1.11"
 	},
 	"publishConfig": {
 		"access": "public"

package/features/events/RequestContextInitializer.d.ts

@@ -1,26 +0,0 @@
-import { Abstraction } from "@webiny/di";
-/**
- * Per-request, POST-auth initialization hook. Runs after the request's tenant/identity have been
- * established (in the route, before the schema is built and before resolvers), so unlike
- * {@link RequestInitializer} (which runs pre-auth) it can do tenant/identity-dependent setup.
- *
- * Use it for per-request work that must happen before resolvers and that genuinely can't be a lazy
- * DI factory — e.g. resolving a per-tenant content model (async), registering decorators that must
- * precede the resolvers they wrap, or building a dynamic, model-derived GraphQL schema.
- *
- * - For pre-auth, tenant-agnostic per-request setup, use {@link RequestInitializer}.
- * - For tenant/identity-dependent capabilities that can be built on demand, prefer a lazy DI factory.
- *
- * It contributes no schema content; its only product is the side effect of init(ctx). Multiple
- * initializers may be registered; they run in registration order.
- *
- * NOTE: despite living in event-handler-core, the current runners are the GraphQL routes
- * (GraphQLEngine + the CMS route). Making it run for non-GraphQL transports is a separate step.
- */
-export interface IRequestContextInitializer {
-    init(ctx: Record<string, any>): void | Promise<void>;
-}
-export declare const RequestContextInitializer: Abstraction<IRequestContextInitializer>;
-export declare namespace RequestContextInitializer {
-    type Interface = IRequestContextInitializer;
-}

package/features/events/RequestContextInitializer.js

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

package/features/events/RequestContextInitializer.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"features/events/RequestContextInitializer.js","sources":["../../../src/features/events/RequestContextInitializer.ts"],"sourcesContent":["import { Abstraction } from \"@webiny/di\";\n\n/**\n * Per-request, POST-auth initialization hook. Runs after the request's tenant/identity have been\n * established (in the route, before the schema is built and before resolvers), so unlike\n * {@link RequestInitializer} (which runs pre-auth) it can do tenant/identity-dependent setup.\n *\n * Use it for per-request work that must happen before resolvers and that genuinely can't be a lazy\n * DI factory — e.g. resolving a per-tenant content model (async), registering decorators that must\n * precede the resolvers they wrap, or building a dynamic, model-derived GraphQL schema.\n *\n * - For pre-auth, tenant-agnostic per-request setup, use {@link RequestInitializer}.\n * - For tenant/identity-dependent capabilities that can be built on demand, prefer a lazy DI factory.\n *\n * It contributes no schema content; its only product is the side effect of init(ctx). Multiple\n * initializers may be registered; they run in registration order.\n *\n * NOTE: despite living in event-handler-core, the current runners are the GraphQL routes\n * (GraphQLEngine + the CMS route). Making it run for non-GraphQL transports is a separate step.\n */\nexport interface IRequestContextInitializer {\n    init(ctx: Record<string, any>): void | Promise<void>;\n}\n\nexport const RequestContextInitializer = new Abstraction<IRequestContextInitializer>(\n    \"RequestContextInitializer\"\n);\n\nexport namespace RequestContextInitializer {\n    export type Interface = IRequestContextInitializer;\n}\n"],"names":["RequestContextInitializer","Abstraction"],"mappings":";AAwBO,MAAMA,4BAA4B,IAAIC,YACzC"}

package/features/events/RequestInitializer.d.ts

@@ -1,22 +0,0 @@
-import { Abstraction } from "@webiny/di";
-/**
- * Per-request async initialization hook. Runs once per request, after the request container is set
- * up (options.request) and BEFORE the event is dispatched to its handler chain — i.e. before
- * auth/tenant are established.
- *
- * Use it for async, tenant-agnostic, per-request setup that must be ready before synchronous
- * consumers run, and that can change between requests (e.g. loading the WCP project license).
- *
- * - For tenant/identity-dependent state, use a lazy DI factory instead (resolved during request
- *   handling, after auth has run).
- * - For build-once async setup (a process-lifetime singleton), use a RootInitializer.
- *
- * Multiple initializers may be registered; they run in registration order.
- */
-export interface IRequestInitializer {
-    init(): void | Promise<void>;
-}
-export declare const RequestInitializer: Abstraction<IRequestInitializer>;
-export declare namespace RequestInitializer {
-    type Interface = IRequestInitializer;
-}

package/features/events/RequestInitializer.js

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

package/features/events/RequestInitializer.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"features/events/RequestInitializer.js","sources":["../../../src/features/events/RequestInitializer.ts"],"sourcesContent":["import { Abstraction } from \"@webiny/di\";\n\n/**\n * Per-request async initialization hook. Runs once per request, after the request container is set\n * up (options.request) and BEFORE the event is dispatched to its handler chain — i.e. before\n * auth/tenant are established.\n *\n * Use it for async, tenant-agnostic, per-request setup that must be ready before synchronous\n * consumers run, and that can change between requests (e.g. loading the WCP project license).\n *\n * - For tenant/identity-dependent state, use a lazy DI factory instead (resolved during request\n *   handling, after auth has run).\n * - For build-once async setup (a process-lifetime singleton), use a RootInitializer.\n *\n * Multiple initializers may be registered; they run in registration order.\n */\nexport interface IRequestInitializer {\n    init(): void | Promise<void>;\n}\n\nexport const RequestInitializer = new Abstraction<IRequestInitializer>(\"RequestInitializer\");\n\nexport namespace RequestInitializer {\n    export type Interface = IRequestInitializer;\n}\n"],"names":["RequestInitializer","Abstraction"],"mappings":";AAoBO,MAAMA,qBAAqB,IAAIC,YAAiC"}

package/features/events/createHandler.d.ts

@@ -1,20 +0,0 @@
-import { Container } from "@webiny/di";
-import type { Transport } from "../../features/events/Transport.js";
-import type { HandlerSetup } from "../../features/events/types.js";
-export interface CreateHandlerOptions {
-    root: HandlerSetup;
-    request?: HandlerSetup;
-    /**
-     * Transport-specific extract step: binds the raw platform arguments (e.g. the AWS Lambda
-     * event + context) into the per-request container. Defaults to a no-op, which leaves the
-     * event to pass straight through — the plain server/HTTP behavior.
-     */
-    transport?: Transport;
-    /**
-     * A pre-built, already root-initialized container. When provided, `root` is NOT called again —
-     * used by transports that must build the root eagerly at startup (e.g. the Node server, which
-     * needs the root container ready to attach a WebSockets upgrade handler before the first request).
-     */
-    rootContainer?: Container;
-}
-export declare function createHandler(options: CreateHandlerOptions): (...rawArgs: any[]) => Promise<any>;

package/features/events/createHandler.js

@@ -1,41 +0,0 @@
-import { Container } from "@webiny/di";
-import { EventType } from "./EventType.js";
-import { RequestContainer } from "./RequestContainer.js";
-import { RequestInitializer } from "./RequestInitializer.js";
-import { executeChain } from "./chain.js";
-import { noopTransport } from "./Transport.js";
-function createHandler(options) {
-    let rootContainer = options.rootContainer ?? null;
-    const transport = options.transport ?? noopTransport;
-    return async (...rawArgs)=>{
-        if (!rootContainer) {
-            rootContainer = new Container();
-            await options.root(rootContainer);
-        }
-        const child = rootContainer.createChildContainer();
-        child.registerInstance(RequestContainer, child);
-        await transport.bind(child, ...rawArgs);
-        if (options.request) await options.request(child);
-        for (const initializer of child.resolveAll(RequestInitializer))await initializer.init();
-        const event = rawArgs[0];
-        const eventTypes = child.resolveAll(EventType);
-        const matched = eventTypes.find((et)=>et.canHandle(event));
-        if (!matched) {
-            const shape = event && "object" == typeof event ? {
-                keys: Object.keys(event),
-                source: event.source,
-                detailType: event["detail-type"]
-            } : {
-                type: typeof event
-            };
-            const registered = eventTypes.map((et)=>et?.constructor?.name);
-            throw new Error(`No event type matched the incoming event. Event shape: ${JSON.stringify(shape)}; registered event types: ${JSON.stringify(registered)}`);
-        }
-        const abstraction = matched.getHandlerAbstraction();
-        const handlers = child.resolveAll(abstraction);
-        return executeChain(handlers, event);
-    };
-}
-export { createHandler };
-
-//# sourceMappingURL=createHandler.js.map

package/features/events/createHandler.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"features/events/createHandler.js","sources":["../../../src/features/events/createHandler.ts"],"sourcesContent":["import { Container } from \"@webiny/di\";\nimport { EventType } from \"~/features/events/EventType.js\";\nimport { RequestContainer } from \"~/features/events/RequestContainer.js\";\nimport { RequestInitializer } from \"~/features/events/RequestInitializer.js\";\nimport { executeChain } from \"~/features/events/chain.js\";\nimport { noopTransport } from \"~/features/events/Transport.js\";\nimport type { Transport } from \"~/features/events/Transport.js\";\nimport type { HandlerSetup } from \"~/features/events/types.js\";\n\nexport interface CreateHandlerOptions {\n    root: HandlerSetup;\n    request?: HandlerSetup;\n    /**\n     * Transport-specific extract step: binds the raw platform arguments (e.g. the AWS Lambda\n     * event + context) into the per-request container. Defaults to a no-op, which leaves the\n     * event to pass straight through — the plain server/HTTP behavior.\n     */\n    transport?: Transport;\n    /**\n     * A pre-built, already root-initialized container. When provided, `root` is NOT called again —\n     * used by transports that must build the root eagerly at startup (e.g. the Node server, which\n     * needs the root container ready to attach a WebSockets upgrade handler before the first request).\n     */\n    rootContainer?: Container;\n}\n\nexport function createHandler(options: CreateHandlerOptions) {\n    let rootContainer: Container | null = options.rootContainer ?? null;\n    const transport = options.transport ?? noopTransport;\n\n    return async (...rawArgs: any[]): Promise<any> => {\n        if (!rootContainer) {\n            rootContainer = new Container();\n            await options.root(rootContainer);\n        }\n\n        const child = rootContainer.createChildContainer();\n        child.registerInstance(RequestContainer, child);\n\n        // Transport-specific bind: register the raw platform arguments into the request container\n        // before request setup runs. The default transport binds nothing.\n        await transport.bind(child, ...rawArgs);\n\n        if (options.request) {\n            await options.request(child);\n        }\n\n        // Per-request async initialization (tenant-agnostic), before the event is dispatched and\n        // before auth/tenant are established. For tenant-dependent setup use lazy DI factories.\n        for (const initializer of child.resolveAll(RequestInitializer)) {\n            await initializer.init();\n        }\n\n        // The event to match on is always the first raw argument (transports never change this).\n        const event = rawArgs[0];\n        const eventTypes = child.resolveAll(EventType);\n        const matched = eventTypes.find(et => et.canHandle(event));\n\n        if (!matched) {\n            // Include a non-sensitive shape summary so this is debuggable: which event types were\n            // registered vs. what the event actually looks like (keys + EventBridge discriminators).\n            const shape =\n                event && typeof event === \"object\"\n                    ? {\n                          keys: Object.keys(event),\n                          source: (event as any).source,\n                          detailType: (event as any)[\"detail-type\"]\n                      }\n                    : { type: typeof event };\n            const registered = eventTypes.map(et => (et as any)?.constructor?.name);\n            throw new Error(\n                `No event type matched the incoming event. Event shape: ${JSON.stringify(\n                    shape\n                )}; registered event types: ${JSON.stringify(registered)}`\n            );\n        }\n\n        const abstraction = matched.getHandlerAbstraction();\n        const handlers = child.resolveAll(abstraction);\n\n        return executeChain(handlers, event);\n    };\n}\n"],"names":["createHandler","options","rootContainer","transport","noopTransport","rawArgs","Container","child","RequestContainer","initializer","RequestInitializer","event","eventTypes","EventType","matched","et","shape","Object","registered","Error","JSON","abstraction","handlers","executeChain"],"mappings":";;;;;;AA0BO,SAASA,cAAcC,OAA6B;IACvD,IAAIC,gBAAkCD,QAAQ,aAAa,IAAI;IAC/D,MAAME,YAAYF,QAAQ,SAAS,IAAIG;IAEvC,OAAO,OAAO,GAAGC;QACb,IAAI,CAACH,eAAe;YAChBA,gBAAgB,IAAII;YACpB,MAAML,QAAQ,IAAI,CAACC;QACvB;QAEA,MAAMK,QAAQL,cAAc,oBAAoB;QAChDK,MAAM,gBAAgB,CAACC,kBAAkBD;QAIzC,MAAMJ,UAAU,IAAI,CAACI,UAAUF;QAE/B,IAAIJ,QAAQ,OAAO,EACf,MAAMA,QAAQ,OAAO,CAACM;QAK1B,KAAK,MAAME,eAAeF,MAAM,UAAU,CAACG,oBACvC,MAAMD,YAAY,IAAI;QAI1B,MAAME,QAAQN,OAAO,CAAC,EAAE;QACxB,MAAMO,aAAaL,MAAM,UAAU,CAACM;QACpC,MAAMC,UAAUF,WAAW,IAAI,CAACG,CAAAA,KAAMA,GAAG,SAAS,CAACJ;QAEnD,IAAI,CAACG,SAAS;YAGV,MAAME,QACFL,SAAS,AAAiB,YAAjB,OAAOA,QACV;gBACI,MAAMM,OAAO,IAAI,CAACN;gBAClB,QAASA,MAAc,MAAM;gBAC7B,YAAaA,KAAa,CAAC,cAAc;YAC7C,IACA;gBAAE,MAAM,OAAOA;YAAM;YAC/B,MAAMO,aAAaN,WAAW,GAAG,CAACG,CAAAA,KAAOA,IAAY,aAAa;YAClE,MAAM,IAAII,MACN,CAAC,uDAAuD,EAAEC,KAAK,SAAS,CACpEJ,OACF,0BAA0B,EAAEI,KAAK,SAAS,CAACF,aAAa;QAElE;QAEA,MAAMG,cAAcP,QAAQ,qBAAqB;QACjD,MAAMQ,WAAWf,MAAM,UAAU,CAACc;QAElC,OAAOE,aAAaD,UAAUX;IAClC;AACJ"}

package/features/events/runRequestContextInitializers.d.ts

@@ -1,20 +0,0 @@
-import type { Container } from "@webiny/di";
-export interface RunRequestContextInitializersOptions {
-    /**
-     * When true, a failing initializer is logged and skipped instead of aborting the whole run.
-     * Use for event categories (e.g. background tasks) that register the full HTTP initializer set
-     * but don't need every one — a side-effect initializer that doesn't apply shouldn't fail the task.
-     * HTTP keeps the default (fail-fast) so a broken critical initializer surfaces.
-     */
-    continueOnError?: boolean;
-}
-/**
- * Runs all registered {@link RequestContextInitializer}s (post-auth per-request setup) against the
- * given container. Call this once per request, AFTER the request's identity/tenant have been
- * established, and BEFORE dispatching to the handler that needs them.
- *
- * Context establishment differs per event category (HTTP establishers, a background task's payload,
- * etc.), but the initializer run itself is identical — so each category invokes this at its own
- * "context established" point (the HTTP layer for all HTTP routes; the bg-task handler for tasks).
- */
-export declare const runRequestContextInitializers: (container: Container, options?: RunRequestContextInitializersOptions) => Promise<void>;

package/features/events/runRequestContextInitializers.js

@@ -1,16 +0,0 @@
-import { RequestContextInitializer } from "./RequestContextInitializer.js";
-const runRequestContextInitializers = async (container, options = {})=>{
-    const ctx = {
-        container
-    };
-    for (const initializer of container.resolveAll(RequestContextInitializer))try {
-        await initializer.init(ctx);
-    } catch (err) {
-        if (!options.continueOnError) throw err;
-        const name = initializer?.constructor?.name ?? "RequestContextInitializer";
-        console.error(`[runRequestContextInitializers] "${name}" failed (continuing):`, err);
-    }
-};
-export { runRequestContextInitializers };
-
-//# sourceMappingURL=runRequestContextInitializers.js.map

package/features/events/runRequestContextInitializers.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"features/events/runRequestContextInitializers.js","sources":["../../../src/features/events/runRequestContextInitializers.ts"],"sourcesContent":["import type { Container } from \"@webiny/di\";\nimport { RequestContextInitializer } from \"./RequestContextInitializer.js\";\n\nexport interface RunRequestContextInitializersOptions {\n    /**\n     * When true, a failing initializer is logged and skipped instead of aborting the whole run.\n     * Use for event categories (e.g. background tasks) that register the full HTTP initializer set\n     * but don't need every one — a side-effect initializer that doesn't apply shouldn't fail the task.\n     * HTTP keeps the default (fail-fast) so a broken critical initializer surfaces.\n     */\n    continueOnError?: boolean;\n}\n\n/**\n * Runs all registered {@link RequestContextInitializer}s (post-auth per-request setup) against the\n * given container. Call this once per request, AFTER the request's identity/tenant have been\n * established, and BEFORE dispatching to the handler that needs them.\n *\n * Context establishment differs per event category (HTTP establishers, a background task's payload,\n * etc.), but the initializer run itself is identical — so each category invokes this at its own\n * \"context established\" point (the HTTP layer for all HTTP routes; the bg-task handler for tasks).\n */\nexport const runRequestContextInitializers = async (\n    container: Container,\n    options: RunRequestContextInitializersOptions = {}\n): Promise<void> => {\n    const ctx: Record<string, any> = { container };\n    for (const initializer of container.resolveAll(RequestContextInitializer)) {\n        try {\n            await initializer.init(ctx);\n        } catch (err) {\n            if (!options.continueOnError) {\n                throw err;\n            }\n            const name = (initializer as any)?.constructor?.name ?? \"RequestContextInitializer\";\n            console.error(`[runRequestContextInitializers] \"${name}\" failed (continuing):`, err);\n        }\n    }\n};\n"],"names":["runRequestContextInitializers","container","options","ctx","initializer","RequestContextInitializer","err","name","console"],"mappings":";AAsBO,MAAMA,gCAAgC,OACzCC,WACAC,UAAgD,CAAC,CAAC;IAElD,MAAMC,MAA2B;QAAEF;IAAU;IAC7C,KAAK,MAAMG,eAAeH,UAAU,UAAU,CAACI,2BAC3C,IAAI;QACA,MAAMD,YAAY,IAAI,CAACD;IAC3B,EAAE,OAAOG,KAAK;QACV,IAAI,CAACJ,QAAQ,eAAe,EACxB,MAAMI;QAEV,MAAMC,OAAQH,aAAqB,aAAa,QAAQ;QACxDI,QAAQ,KAAK,CAAC,CAAC,iCAAiC,EAAED,KAAK,sBAAsB,CAAC,EAAED;IACpF;AAER"}

package/features/http/decorators/RequestContextInitializerDecorator.d.ts

@@ -1,20 +0,0 @@
-import type { Container } from "@webiny/di";
-import type { IHttpRouter, IHttpRequest, IHttpResponse } from "../../../features/http/abstractions.js";
-/**
- * Runs the post-auth {@link RequestContextInitializer}s once per request, for EVERY HTTP route
- * (graphql, cms, /files/* asset delivery, ...) — not just the GraphQL engine. It's transport-
- * agnostic: it lives in event-handler-core and depends only on DI abstractions. The transport's
- * auth decorators (e.g. ApiGatewayIdentityLoaderDecorator / ApiGatewayTenantLoaderDecorator)
- * establish identity/tenant BEFORE control reaches HttpRouter, so by the time this runs, the request
- * context is established.
- */
-declare class RequestContextInitializerDecoratorImpl implements IHttpRouter {
-    private container;
-    private decoratee;
-    constructor(container: Container, decoratee: IHttpRouter);
-    route(request: IHttpRequest): Promise<IHttpResponse>;
-}
-export declare const RequestContextInitializerDecorator: typeof RequestContextInitializerDecoratorImpl & {
-    __abstraction: import("@webiny/di").Abstraction<IHttpRouter>;
-};
-export {};

package/features/http/decorators/RequestContextInitializerDecorator.js

@@ -1,22 +0,0 @@
-import { HttpRouter } from "../abstractions.js";
-import { RequestContainer } from "../../events/RequestContainer.js";
-import { runRequestContextInitializers } from "../../events/runRequestContextInitializers.js";
-class RequestContextInitializerDecoratorImpl {
-    constructor(container, decoratee){
-        this.container = container;
-        this.decoratee = decoratee;
-    }
-    async route(request) {
-        await runRequestContextInitializers(this.container);
-        return this.decoratee.route(request);
-    }
-}
-const RequestContextInitializerDecorator = HttpRouter.createDecorator({
-    decorator: RequestContextInitializerDecoratorImpl,
-    dependencies: [
-        RequestContainer
-    ]
-});
-export { RequestContextInitializerDecorator };
-
-//# sourceMappingURL=RequestContextInitializerDecorator.js.map

package/features/http/decorators/RequestContextInitializerDecorator.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"features/http/decorators/RequestContextInitializerDecorator.js","sources":["../../../../src/features/http/decorators/RequestContextInitializerDecorator.ts"],"sourcesContent":["import type { Container } from \"@webiny/di\";\nimport { HttpRouter } from \"~/features/http/abstractions.js\";\nimport type { IHttpRouter, IHttpRequest, IHttpResponse } from \"~/features/http/abstractions.js\";\nimport { RequestContainer } from \"~/features/events/RequestContainer.js\";\nimport { runRequestContextInitializers } from \"~/features/events/runRequestContextInitializers.js\";\n\n/**\n * Runs the post-auth {@link RequestContextInitializer}s once per request, for EVERY HTTP route\n * (graphql, cms, /files/* asset delivery, ...) — not just the GraphQL engine. It's transport-\n * agnostic: it lives in event-handler-core and depends only on DI abstractions. The transport's\n * auth decorators (e.g. ApiGatewayIdentityLoaderDecorator / ApiGatewayTenantLoaderDecorator)\n * establish identity/tenant BEFORE control reaches HttpRouter, so by the time this runs, the request\n * context is established.\n */\nclass RequestContextInitializerDecoratorImpl implements IHttpRouter {\n    constructor(\n        private container: Container,\n        private decoratee: IHttpRouter\n    ) {}\n\n    async route(request: IHttpRequest): Promise<IHttpResponse> {\n        await runRequestContextInitializers(this.container);\n        return this.decoratee.route(request);\n    }\n}\n\nexport const RequestContextInitializerDecorator = HttpRouter.createDecorator({\n    decorator: RequestContextInitializerDecoratorImpl,\n    dependencies: [RequestContainer]\n});\n"],"names":["RequestContextInitializerDecoratorImpl","container","decoratee","request","runRequestContextInitializers","RequestContextInitializerDecorator","HttpRouter","RequestContainer"],"mappings":";;;AAcA,MAAMA;IACF,YACYC,SAAoB,EACpBC,SAAsB,CAChC;aAFUD,SAAS,GAATA;aACAC,SAAS,GAATA;IACT;IAEH,MAAM,MAAMC,OAAqB,EAA0B;QACvD,MAAMC,8BAA8B,IAAI,CAAC,SAAS;QAClD,OAAO,IAAI,CAAC,SAAS,CAAC,KAAK,CAACD;IAChC;AACJ;AAEO,MAAME,qCAAqCC,WAAW,eAAe,CAAC;IACzE,WAAWN;IACX,cAAc;QAACO;KAAiB;AACpC"}