@webiny/event-handler-core 0.0.0-unstable.0d717d18dd

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Webiny
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,11 @@
+# @webiny/event-handler-core
+
+> [!NOTE]
+> This package is part of the [Webiny](https://www.webiny.com) monorepo.
+> It’s **included in every Webiny project by default** and is not meant to be used as a standalone package.
+
+📘 **Documentation:** [https://www.webiny.com/docs](https://www.webiny.com/docs)
+
+---
+
+_This README file is automatically generated during the publish process._

package/features/events/EventHandler.d.ts

@@ -0,0 +1,13 @@
+import { Abstraction } from "@webiny/di";
+import type { NextFunction } from "./types.js";
+export interface EventContext<TEvent = any> {
+    event: TEvent;
+    metadata: Record<string, any>;
+}
+export interface IEventHandler<TEvent = any, TResult = any> {
+    execute(ctx: EventContext<TEvent>, next: NextFunction): Promise<TResult>;
+}
+export declare const EventHandler: Abstraction<IEventHandler<any, any>>;
+export declare namespace EventHandler {
+    type Interface<TEvent = any, TResult = any> = IEventHandler<TEvent, TResult>;
+}

package/features/events/EventHandler.js

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

package/features/events/EventHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/events/EventHandler.js","sources":["../../../src/features/events/EventHandler.ts"],"sourcesContent":["import { Abstraction } from \"@webiny/di\";\nimport type { NextFunction } from \"./types.js\";\n\nexport interface EventContext<TEvent = any> {\n    event: TEvent;\n    metadata: Record<string, any>;\n}\n\nexport interface IEventHandler<TEvent = any, TResult = any> {\n    execute(ctx: EventContext<TEvent>, next: NextFunction): Promise<TResult>;\n}\n\nexport const EventHandler = new Abstraction<IEventHandler>(\"EventHandler\");\n\nexport namespace EventHandler {\n    export type Interface<TEvent = any, TResult = any> = IEventHandler<TEvent, TResult>;\n}\n"],"names":["EventHandler","Abstraction"],"mappings":";AAYO,MAAMA,eAAe,IAAIC,YAA2B"}

package/features/events/EventType.d.ts

@@ -0,0 +1,10 @@
+import { Abstraction } from "@webiny/di";
+import type { IEventHandler } from "./EventHandler.js";
+export interface IEventType<TEvent = any> {
+    canHandle(event: any): event is TEvent;
+    getHandlerAbstraction(): Abstraction<IEventHandler>;
+}
+export declare const EventType: Abstraction<IEventType<any>>;
+export declare namespace EventType {
+    type Interface<TEvent = any> = IEventType<TEvent>;
+}

package/features/events/EventType.js

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

package/features/events/EventType.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/events/EventType.js","sources":["../../../src/features/events/EventType.ts"],"sourcesContent":["import { Abstraction } from \"@webiny/di\";\nimport type { IEventHandler } from \"./EventHandler.js\";\n\nexport interface IEventType<TEvent = any> {\n    canHandle(event: any): event is TEvent;\n    getHandlerAbstraction(): Abstraction<IEventHandler>;\n}\n\nexport const EventType = new Abstraction<IEventType>(\"EventType\");\n\nexport namespace EventType {\n    export type Interface<TEvent = any> = IEventType<TEvent>;\n}\n"],"names":["EventType","Abstraction"],"mappings":";AAQO,MAAMA,YAAY,IAAIC,YAAwB"}

package/features/events/RequestContainer.d.ts

@@ -0,0 +1,8 @@
+import { Abstraction, Container } from "@webiny/di";
+/**
+ * Per-request abstraction holding the child DI container.
+ * Registered automatically on each request — available for injection into
+ * per-request services that need access to the request-scoped container
+ * (e.g. GraphQLEngine passing it as resolver contextValue).
+ */
+export declare const RequestContainer: Abstraction<Container>;

package/features/events/RequestContainer.js

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

package/features/events/RequestContainer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/events/RequestContainer.js","sources":["../../../src/features/events/RequestContainer.ts"],"sourcesContent":["import { Abstraction, Container } from \"@webiny/di\";\n\n/**\n * Per-request abstraction holding the child DI container.\n * Registered automatically on each request — available for injection into\n * per-request services that need access to the request-scoped container\n * (e.g. GraphQLEngine passing it as resolver contextValue).\n */\nexport const RequestContainer = new Abstraction<Container>(\"RequestContainer\");\n"],"names":["RequestContainer","Abstraction"],"mappings":";AAQO,MAAMA,mBAAmB,IAAIC,YAAuB"}

package/features/events/RequestContextInitializer.d.ts

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

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

package/features/events/RequestContextInitializer.js.map

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

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

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

package/features/events/RequestInitializer.js.map

@@ -0,0 +1 @@
+{"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/Transport.d.ts

@@ -0,0 +1,19 @@
+import type { Container } from "@webiny/di";
+/**
+ * A Transport owns the single transport-specific step of the handler loop: the "bind".
+ *
+ * Given the raw arguments the platform invoked the handler with, it binds any transport
+ * primitives into the per-request container (side-effect only) so downstream translators and
+ * handlers can resolve them. Everything else in the loop — request setup, initializers, event-type
+ * matching, dispatch — is transport-agnostic and lives in {@link createHandler}.
+ *
+ * The event to match on is always `rawArgs[0]`; a Transport never changes the match target.
+ */
+export interface Transport {
+    bind(container: Container, ...rawArgs: any[]): void | Promise<void>;
+}
+/**
+ * Default transport: binds nothing. Reproduces the plain `createHandler` behavior for callers
+ * (e.g. the Node HTTP server) that pass the event straight through with no transport primitives.
+ */
+export declare const noopTransport: Transport;

package/features/events/Transport.js

@@ -0,0 +1,6 @@
+const noopTransport = {
+    bind () {}
+};
+export { noopTransport };
+
+//# sourceMappingURL=Transport.js.map

package/features/events/Transport.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/events/Transport.js","sources":["../../../src/features/events/Transport.ts"],"sourcesContent":["import type { Container } from \"@webiny/di\";\n\n/**\n * A Transport owns the single transport-specific step of the handler loop: the \"bind\".\n *\n * Given the raw arguments the platform invoked the handler with, it binds any transport\n * primitives into the per-request container (side-effect only) so downstream translators and\n * handlers can resolve them. Everything else in the loop — request setup, initializers, event-type\n * matching, dispatch — is transport-agnostic and lives in {@link createHandler}.\n *\n * The event to match on is always `rawArgs[0]`; a Transport never changes the match target.\n */\nexport interface Transport {\n    bind(container: Container, ...rawArgs: any[]): void | Promise<void>;\n}\n\n/**\n * Default transport: binds nothing. Reproduces the plain `createHandler` behavior for callers\n * (e.g. the Node HTTP server) that pass the event straight through with no transport primitives.\n */\nexport const noopTransport: Transport = {\n    bind() {}\n};\n"],"names":["noopTransport"],"mappings":"AAoBO,MAAMA,gBAA2B;IACpC,SAAQ;AACZ"}

package/features/events/chain.d.ts

@@ -0,0 +1,2 @@
+import type { IEventHandler } from "../../features/events/EventHandler.js";
+export declare function executeChain(handlers: IEventHandler[], event: any): Promise<any>;

package/features/events/chain.js

@@ -0,0 +1,22 @@
+function executeChain(handlers, event) {
+    if (0 === handlers.length) throw new Error("No handlers registered in container");
+    const initialCtx = {
+        event,
+        metadata: {}
+    };
+    let chain = (_ctx)=>{
+        throw new Error("No registered handler claimed this event");
+    };
+    for(let i = handlers.length - 1; i >= 0; i--){
+        const handler = handlers[i];
+        const nextChain = chain;
+        chain = (ctx)=>{
+            const next = (newCtx)=>nextChain(newCtx ?? ctx);
+            return handler.execute(ctx, next);
+        };
+    }
+    return chain(initialCtx);
+}
+export { executeChain };
+
+//# sourceMappingURL=chain.js.map

package/features/events/chain.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/events/chain.js","sources":["../../../src/features/events/chain.ts"],"sourcesContent":["import type { IEventHandler, EventContext } from \"~/features/events/EventHandler.js\";\n\nexport function executeChain(handlers: IEventHandler[], event: any): Promise<any> {\n    if (handlers.length === 0) {\n        throw new Error(\"No handlers registered in container\");\n    }\n\n    const initialCtx: EventContext = { event, metadata: {} };\n\n    let chain = (_ctx: EventContext): Promise<any> => {\n        throw new Error(\"No registered handler claimed this event\");\n    };\n\n    for (let i = handlers.length - 1; i >= 0; i--) {\n        const handler = handlers[i];\n        const nextChain = chain;\n        chain = (ctx: EventContext) => {\n            const next = (newCtx?: EventContext) => nextChain(newCtx ?? ctx);\n            return handler.execute(ctx, next);\n        };\n    }\n\n    return chain(initialCtx);\n}\n"],"names":["executeChain","handlers","event","Error","initialCtx","chain","_ctx","i","handler","nextChain","ctx","next","newCtx"],"mappings":"AAEO,SAASA,aAAaC,QAAyB,EAAEC,KAAU;IAC9D,IAAID,AAAoB,MAApBA,SAAS,MAAM,EACf,MAAM,IAAIE,MAAM;IAGpB,MAAMC,aAA2B;QAAEF;QAAO,UAAU,CAAC;IAAE;IAEvD,IAAIG,QAAQ,CAACC;QACT,MAAM,IAAIH,MAAM;IACpB;IAEA,IAAK,IAAII,IAAIN,SAAS,MAAM,GAAG,GAAGM,KAAK,GAAGA,IAAK;QAC3C,MAAMC,UAAUP,QAAQ,CAACM,EAAE;QAC3B,MAAME,YAAYJ;QAClBA,QAAQ,CAACK;YACL,MAAMC,OAAO,CAACC,SAA0BH,UAAUG,UAAUF;YAC5D,OAAOF,QAAQ,OAAO,CAACE,KAAKC;QAChC;IACJ;IAEA,OAAON,MAAMD;AACjB"}

package/features/events/createHandler.d.ts

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

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

@@ -0,0 +1 @@
+{"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/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./EventHandler.js";
+export * from "./EventType.js";
+export * from "./RequestContainer.js";
+export * from "./RequestContextInitializer.js";
+export * from "./RequestInitializer.js";
+export * from "./chain.js";
+export * from "./createHandler.js";
+export * from "./Transport.js";
+export * from "./types.js";
+export * from "./runRequestContextInitializers.js";

package/features/events/index.js

@@ -0,0 +1,10 @@
+export * from "./EventHandler.js";
+export * from "./EventType.js";
+export * from "./RequestContainer.js";
+export * from "./RequestContextInitializer.js";
+export * from "./RequestInitializer.js";
+export * from "./chain.js";
+export * from "./createHandler.js";
+export * from "./Transport.js";
+export * from "./types.js";
+export * from "./runRequestContextInitializers.js";

package/features/events/runRequestContextInitializers.d.ts

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

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

@@ -0,0 +1 @@
+{"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/events/types.d.ts

@@ -0,0 +1,4 @@
+import type { Container } from "@webiny/di";
+import type { EventContext } from "./EventHandler.js";
+export type NextFunction = (ctx?: EventContext) => Promise<any>;
+export type HandlerSetup = (container: Container) => void | Promise<void>;

package/features/http/HttpRouter.d.ts

@@ -0,0 +1,12 @@
+import { HttpRouter } from "../../features/http/abstractions.js";
+import type { IHttpRoute, IHttpRequest, IHttpResponse } from "../../features/http/abstractions.js";
+declare class HttpRouterImplClass implements HttpRouter.Interface {
+    private routes;
+    constructor(routes: IHttpRoute[]);
+    route(request: IHttpRequest): Promise<IHttpResponse>;
+    private match;
+}
+export declare const HttpRouterImpl: typeof HttpRouterImplClass & {
+    __abstraction: import("@webiny/di").Abstraction<import("~/features/http/abstractions.js").IHttpRouter>;
+};
+export {};

package/features/http/HttpRouter.js

@@ -0,0 +1,51 @@
+import { HttpRoute, HttpRouter, RouteNotFoundError } from "./abstractions.js";
+function matchPath(pattern, path) {
+    if (pattern.endsWith("/*")) {
+        const prefix = pattern.slice(0, -2);
+        return path.startsWith(prefix) ? {} : null;
+    }
+    const patternParts = pattern.split("/").filter(Boolean);
+    const pathParts = path.split("/").filter(Boolean);
+    if (patternParts.length !== pathParts.length) return null;
+    const params = {};
+    for(let i = 0; i < patternParts.length; i++){
+        const pp = patternParts[i];
+        const pathPart = pathParts[i];
+        if (pp.startsWith(":")) params[pp.slice(1)] = decodeURIComponent(pathPart);
+        else if (pp !== pathPart) return null;
+    }
+    return params;
+}
+class HttpRouterImplClass {
+    constructor(routes){
+        this.routes = routes;
+    }
+    async route(request) {
+        for (const route of this.routes){
+            const params = this.match(route, request);
+            if (null !== params) return route.handle({
+                ...request,
+                pathParameters: params
+            });
+        }
+        throw new RouteNotFoundError(request.method, request.path);
+    }
+    match(route, request) {
+        if (route.method !== request.method) return null;
+        return matchPath(route.path, request.path);
+    }
+}
+const HttpRouterImpl = HttpRouter.createImplementation({
+    implementation: HttpRouterImplClass,
+    dependencies: [
+        [
+            HttpRoute,
+            {
+                multiple: true
+            }
+        ]
+    ]
+});
+export { HttpRouterImpl };
+
+//# sourceMappingURL=HttpRouter.js.map

package/features/http/HttpRouter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/http/HttpRouter.js","sources":["../../../src/features/http/HttpRouter.ts"],"sourcesContent":["import { HttpRouter, HttpRoute, RouteNotFoundError } from \"~/features/http/abstractions.js\";\nimport type { IHttpRoute, IHttpRequest, IHttpResponse } from \"~/features/http/abstractions.js\";\n\nfunction matchPath(pattern: string, path: string): Record<string, string> | null {\n    if (pattern.endsWith(\"/*\")) {\n        const prefix = pattern.slice(0, -2);\n        return path.startsWith(prefix) ? {} : null;\n    }\n\n    const patternParts = pattern.split(\"/\").filter(Boolean);\n    const pathParts = path.split(\"/\").filter(Boolean);\n\n    if (patternParts.length !== pathParts.length) {\n        return null;\n    }\n\n    const params: Record<string, string> = {};\n\n    for (let i = 0; i < patternParts.length; i++) {\n        const pp = patternParts[i];\n        const pathPart = pathParts[i];\n\n        if (pp.startsWith(\":\")) {\n            params[pp.slice(1)] = decodeURIComponent(pathPart);\n        } else if (pp !== pathPart) {\n            return null;\n        }\n    }\n\n    return params;\n}\n\nclass HttpRouterImplClass implements HttpRouter.Interface {\n    // TODO: revisit eager route construction.\n    // Injecting [HttpRoute, { multiple: true }] constructs EVERY registered route on each request\n    // just to path-match, so a route's constructor runs even when its path doesn't match. Any route\n    // whose constructor pulls a request-time-registered token (e.g. CMS use-cases needing\n    // EntryFromStorageTransform / a per-request CmsModel) then throws \"No registration found\" before\n    // any handler runs. Current routes work around this by resolving such deps lazily inside handle()\n    // (AssetDeliveryRoute, WebsiteBuilderRedirectsRoute) or by pre-registering them before routing.\n    // The systemic fix is to construct only the matched route lazily (inject route factories/thunks,\n    // or resolve HttpRoute by matched path on demand) so this workaround isn't required per route.\n    constructor(private routes: IHttpRoute[]) {}\n\n    async route(request: IHttpRequest): Promise<IHttpResponse> {\n        for (const route of this.routes) {\n            const params = this.match(route, request);\n            if (params !== null) {\n                return route.handle({ ...request, pathParameters: params });\n            }\n        }\n        throw new RouteNotFoundError(request.method, request.path);\n    }\n\n    private match(route: IHttpRoute, request: IHttpRequest): Record<string, string> | null {\n        if (route.method !== request.method) {\n            return null;\n        }\n        return matchPath(route.path, request.path);\n    }\n}\n\nexport const HttpRouterImpl = HttpRouter.createImplementation({\n    implementation: HttpRouterImplClass,\n    dependencies: [[HttpRoute, { multiple: true }]]\n});\n"],"names":["matchPath","pattern","path","prefix","patternParts","Boolean","pathParts","params","i","pp","pathPart","decodeURIComponent","HttpRouterImplClass","routes","request","route","RouteNotFoundError","HttpRouterImpl","HttpRouter","HttpRoute"],"mappings":";AAGA,SAASA,UAAUC,OAAe,EAAEC,IAAY;IAC5C,IAAID,QAAQ,QAAQ,CAAC,OAAO;QACxB,MAAME,SAASF,QAAQ,KAAK,CAAC,GAAG;QAChC,OAAOC,KAAK,UAAU,CAACC,UAAU,CAAC,IAAI;IAC1C;IAEA,MAAMC,eAAeH,QAAQ,KAAK,CAAC,KAAK,MAAM,CAACI;IAC/C,MAAMC,YAAYJ,KAAK,KAAK,CAAC,KAAK,MAAM,CAACG;IAEzC,IAAID,aAAa,MAAM,KAAKE,UAAU,MAAM,EACxC,OAAO;IAGX,MAAMC,SAAiC,CAAC;IAExC,IAAK,IAAIC,IAAI,GAAGA,IAAIJ,aAAa,MAAM,EAAEI,IAAK;QAC1C,MAAMC,KAAKL,YAAY,CAACI,EAAE;QAC1B,MAAME,WAAWJ,SAAS,CAACE,EAAE;QAE7B,IAAIC,GAAG,UAAU,CAAC,MACdF,MAAM,CAACE,GAAG,KAAK,CAAC,GAAG,GAAGE,mBAAmBD;aACtC,IAAID,OAAOC,UACd,OAAO;IAEf;IAEA,OAAOH;AACX;AAEA,MAAMK;IAUF,YAAoBC,MAAoB,CAAE;aAAtBA,MAAM,GAANA;IAAuB;IAE3C,MAAM,MAAMC,OAAqB,EAA0B;QACvD,KAAK,MAAMC,SAAS,IAAI,CAAC,MAAM,CAAE;YAC7B,MAAMR,SAAS,IAAI,CAAC,KAAK,CAACQ,OAAOD;YACjC,IAAIP,AAAW,SAAXA,QACA,OAAOQ,MAAM,MAAM,CAAC;gBAAE,GAAGD,OAAO;gBAAE,gBAAgBP;YAAO;QAEjE;QACA,MAAM,IAAIS,mBAAmBF,QAAQ,MAAM,EAAEA,QAAQ,IAAI;IAC7D;IAEQ,MAAMC,KAAiB,EAAED,OAAqB,EAAiC;QACnF,IAAIC,MAAM,MAAM,KAAKD,QAAQ,MAAM,EAC/B,OAAO;QAEX,OAAOd,UAAUe,MAAM,IAAI,EAAED,QAAQ,IAAI;IAC7C;AACJ;AAEO,MAAMG,iBAAiBC,WAAW,oBAAoB,CAAC;IAC1D,gBAAgBN;IAChB,cAAc;QAAC;YAACO;YAAW;gBAAE,UAAU;YAAK;SAAE;KAAC;AACnD"}

package/features/http/abstractions.d.ts

@@ -0,0 +1,34 @@
+import { Abstraction } from "@webiny/di";
+export interface IHttpRequest {
+    method: string;
+    path: string;
+    headers: Record<string, string>;
+    query: Record<string, string>;
+    pathParameters: Record<string, string>;
+    body: any;
+}
+export interface IHttpResponse {
+    statusCode: number;
+    headers?: Record<string, string>;
+    body?: any;
+}
+export interface IHttpRoute {
+    readonly method: string;
+    readonly path: string;
+    handle(request: IHttpRequest): Promise<IHttpResponse>;
+}
+export interface IHttpRouter {
+    route(request: IHttpRequest): Promise<IHttpResponse>;
+}
+export declare const HttpRoute: Abstraction<IHttpRoute>;
+export declare const HttpRouter: Abstraction<IHttpRouter>;
+export declare namespace HttpRoute {
+    type Interface = IHttpRoute;
+}
+export declare namespace HttpRouter {
+    type Interface = IHttpRouter;
+}
+export declare class RouteNotFoundError extends Error {
+    readonly code: "ROUTE_NOT_FOUND";
+    constructor(method: string, path: string);
+}

package/features/http/abstractions.js

@@ -0,0 +1,11 @@
+import { Abstraction } from "@webiny/di";
+const HttpRoute = new Abstraction("HttpRoute");
+const HttpRouter = new Abstraction("HttpRouter");
+class RouteNotFoundError extends Error {
+    constructor(method, path){
+        super(`Route not found: ${method} ${path}`), this.code = "ROUTE_NOT_FOUND";
+    }
+}
+export { HttpRoute, HttpRouter, RouteNotFoundError };
+
+//# sourceMappingURL=abstractions.js.map

package/features/http/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/http/abstractions.js","sources":["../../../src/features/http/abstractions.ts"],"sourcesContent":["import { Abstraction } from \"@webiny/di\";\n\nexport interface IHttpRequest {\n    method: string;\n    path: string;\n    headers: Record<string, string>;\n    query: Record<string, string>;\n    pathParameters: Record<string, string>;\n    body: any;\n}\n\nexport interface IHttpResponse {\n    statusCode: number;\n    headers?: Record<string, string>;\n    body?: any;\n}\n\nexport interface IHttpRoute {\n    readonly method: string;\n    readonly path: string;\n    handle(request: IHttpRequest): Promise<IHttpResponse>;\n}\n\nexport interface IHttpRouter {\n    route(request: IHttpRequest): Promise<IHttpResponse>;\n}\n\nexport const HttpRoute = new Abstraction<IHttpRoute>(\"HttpRoute\");\nexport const HttpRouter = new Abstraction<IHttpRouter>(\"HttpRouter\");\n\nexport namespace HttpRoute {\n    export type Interface = IHttpRoute;\n}\n\nexport namespace HttpRouter {\n    export type Interface = IHttpRouter;\n}\n\nexport class RouteNotFoundError extends Error {\n    readonly code = \"ROUTE_NOT_FOUND\" as const;\n\n    constructor(method: string, path: string) {\n        super(`Route not found: ${method} ${path}`);\n    }\n}\n"],"names":["HttpRoute","Abstraction","HttpRouter","RouteNotFoundError","Error","method","path"],"mappings":";AA2BO,MAAMA,YAAY,IAAIC,YAAwB;AAC9C,MAAMC,aAAa,IAAID,YAAyB;AAUhD,MAAME,2BAA2BC;IAGpC,YAAYC,MAAc,EAAEC,IAAY,CAAE;QACtC,KAAK,CAAC,CAAC,iBAAiB,EAAED,OAAO,CAAC,EAAEC,MAAM,QAHrC,IAAI,GAAG;IAIhB;AACJ"}

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

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

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

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

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

@@ -0,0 +1,11 @@
+import type { IHttpRouter, IHttpRequest, IHttpResponse } from "../../../features/http/abstractions.js";
+declare class SecureHeadersDecoratorImpl implements IHttpRouter {
+    private decoratee;
+    constructor(decoratee: IHttpRouter);
+    route(request: IHttpRequest): Promise<IHttpResponse>;
+    private optionsResponse;
+}
+export declare const SecureHeadersDecorator: typeof SecureHeadersDecoratorImpl & {
+    __abstraction: import("@webiny/di").Abstraction<IHttpRouter>;
+};
+export {};

package/features/http/decorators/SecureHeadersDecorator.js

@@ -0,0 +1,40 @@
+import { HttpRouter } from "../abstractions.js";
+const ALLOWED_HEADERS = "accept, authorization, cache-control, content-type, x-i18n-locale, x-tenant";
+class SecureHeadersDecoratorImpl {
+    constructor(decoratee){
+        this.decoratee = decoratee;
+    }
+    async route(request) {
+        if ("OPTIONS" === request.method) return this.optionsResponse(request);
+        const response = await this.decoratee.route(request);
+        return {
+            ...response,
+            headers: {
+                ...response.headers,
+                "access-control-allow-origin": request.headers["origin"] || "*",
+                "access-control-allow-credentials": "true",
+                vary: "origin"
+            }
+        };
+    }
+    optionsResponse(request) {
+        return {
+            statusCode: 204,
+            headers: {
+                "access-control-allow-origin": request.headers["origin"] || "*",
+                "access-control-allow-credentials": "true",
+                "access-control-allow-methods": "OPTIONS,POST,GET,DELETE,PUT,PATCH",
+                "access-control-allow-headers": ALLOWED_HEADERS,
+                "access-control-max-age": "86400",
+                "cache-control": "public, max-age=86400"
+            }
+        };
+    }
+}
+const SecureHeadersDecorator = HttpRouter.createDecorator({
+    decorator: SecureHeadersDecoratorImpl,
+    dependencies: []
+});
+export { SecureHeadersDecorator };
+
+//# sourceMappingURL=SecureHeadersDecorator.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/http/decorators/SecureHeadersDecorator.js","sources":["../../../../src/features/http/decorators/SecureHeadersDecorator.ts"],"sourcesContent":["import { HttpRouter } from \"~/features/http/abstractions.js\";\nimport type { IHttpRouter, IHttpRequest, IHttpResponse } from \"~/features/http/abstractions.js\";\n\nconst ALLOWED_HEADERS = [\n    \"accept\",\n    \"authorization\",\n    \"cache-control\",\n    \"content-type\",\n    \"x-i18n-locale\",\n    \"x-tenant\"\n].join(\", \");\n\nclass SecureHeadersDecoratorImpl implements IHttpRouter {\n    constructor(private decoratee: IHttpRouter) {}\n\n    async route(request: IHttpRequest): Promise<IHttpResponse> {\n        if (request.method === \"OPTIONS\") {\n            return this.optionsResponse(request);\n        }\n\n        const response = await this.decoratee.route(request);\n\n        return {\n            ...response,\n            headers: {\n                ...response.headers,\n                \"access-control-allow-origin\": request.headers[\"origin\"] || \"*\",\n                \"access-control-allow-credentials\": \"true\",\n                vary: \"origin\"\n            }\n        };\n    }\n\n    private optionsResponse(request: IHttpRequest): IHttpResponse {\n        return {\n            statusCode: 204,\n            headers: {\n                \"access-control-allow-origin\": request.headers[\"origin\"] || \"*\",\n                \"access-control-allow-credentials\": \"true\",\n                \"access-control-allow-methods\": \"OPTIONS,POST,GET,DELETE,PUT,PATCH\",\n                \"access-control-allow-headers\": ALLOWED_HEADERS,\n                \"access-control-max-age\": \"86400\",\n                \"cache-control\": \"public, max-age=86400\"\n            }\n        };\n    }\n}\n\nexport const SecureHeadersDecorator = HttpRouter.createDecorator({\n    decorator: SecureHeadersDecoratorImpl,\n    dependencies: []\n});\n"],"names":["ALLOWED_HEADERS","SecureHeadersDecoratorImpl","decoratee","request","response","SecureHeadersDecorator","HttpRouter"],"mappings":";AAGA,MAAMA,kBAAkB;AASxB,MAAMC;IACF,YAAoBC,SAAsB,CAAE;aAAxBA,SAAS,GAATA;IAAyB;IAE7C,MAAM,MAAMC,OAAqB,EAA0B;QACvD,IAAIA,AAAmB,cAAnBA,QAAQ,MAAM,EACd,OAAO,IAAI,CAAC,eAAe,CAACA;QAGhC,MAAMC,WAAW,MAAM,IAAI,CAAC,SAAS,CAAC,KAAK,CAACD;QAE5C,OAAO;YACH,GAAGC,QAAQ;YACX,SAAS;gBACL,GAAGA,SAAS,OAAO;gBACnB,+BAA+BD,QAAQ,OAAO,CAAC,SAAS,IAAI;gBAC5D,oCAAoC;gBACpC,MAAM;YACV;QACJ;IACJ;IAEQ,gBAAgBA,OAAqB,EAAiB;QAC1D,OAAO;YACH,YAAY;YACZ,SAAS;gBACL,+BAA+BA,QAAQ,OAAO,CAAC,SAAS,IAAI;gBAC5D,oCAAoC;gBACpC,gCAAgC;gBAChC,gCAAgCH;gBAChC,0BAA0B;gBAC1B,iBAAiB;YACrB;QACJ;IACJ;AACJ;AAEO,MAAMK,yBAAyBC,WAAW,eAAe,CAAC;IAC7D,WAAWL;IACX,cAAc,EAAE;AACpB"}

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

@@ -0,0 +1 @@
+export * from "./SecureHeadersDecorator.js";

package/features/http/decorators/index.js

@@ -0,0 +1 @@
+export * from "./SecureHeadersDecorator.js";

package/features/http/feature.d.ts

@@ -0,0 +1,4 @@
+export declare const HttpFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

package/features/http/feature.js

@@ -0,0 +1,15 @@
+import { createFeature } from "@webiny/feature/api";
+import { HttpRouterImpl } from "./HttpRouter.js";
+import { SecureHeadersDecorator } from "./decorators/SecureHeadersDecorator.js";
+import { RequestContextInitializerDecorator } from "./decorators/RequestContextInitializerDecorator.js";
+const HttpFeature = createFeature({
+    name: "Http",
+    register (container) {
+        container.register(HttpRouterImpl);
+        container.registerDecorator(RequestContextInitializerDecorator);
+        container.registerDecorator(SecureHeadersDecorator);
+    }
+});
+export { HttpFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/http/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/http/feature.js","sources":["../../../src/features/http/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { HttpRouterImpl } from \"~/features/http/HttpRouter.js\";\nimport { SecureHeadersDecorator } from \"~/features/http/decorators/SecureHeadersDecorator.js\";\nimport { RequestContextInitializerDecorator } from \"~/features/http/decorators/RequestContextInitializerDecorator.js\";\n\nexport const HttpFeature = createFeature({\n    name: \"Http\",\n    register(container) {\n        // Transient so per-request routes (e.g. GraphQLRoute) resolve from child container\n        container.register(HttpRouterImpl);\n        // Registered before SecureHeaders so SecureHeaders stays the OUTER decorator (it short-\n        // circuits OPTIONS before we do the per-request initializer work). This runs the post-auth\n        // RequestContextInitializers for every HTTP route, not just the GraphQL engine.\n        container.registerDecorator(RequestContextInitializerDecorator);\n        container.registerDecorator(SecureHeadersDecorator);\n    }\n});\n"],"names":["HttpFeature","createFeature","container","HttpRouterImpl","RequestContextInitializerDecorator","SecureHeadersDecorator"],"mappings":";;;;AAKO,MAAMA,cAAcC,cAAc;IACrC,MAAM;IACN,UAASC,SAAS;QAEdA,UAAU,QAAQ,CAACC;QAInBD,UAAU,iBAAiB,CAACE;QAC5BF,UAAU,iBAAiB,CAACG;IAChC;AACJ"}

package/features/http/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./abstractions.js";
+export * from "./HttpRouter.js";
+export * from "./decorators/index.js";
+export * from "./feature.js";

package/features/http/index.js

@@ -0,0 +1,4 @@
+export * from "./abstractions.js";
+export * from "./HttpRouter.js";
+export * from "./decorators/index.js";
+export * from "./feature.js";

package/features/testing/HttpRouterHandler.d.ts

@@ -0,0 +1,13 @@
+import { TestHttpEventHandler } from "./TestHttpEventHandler.js";
+import type { EventContext } from "../../features/events/EventHandler.js";
+import type { NextFunction } from "../../features/events/types.js";
+import type { IHttpRouter } from "../../features/http/abstractions.js";
+declare class HttpRouterHandlerImpl implements TestHttpEventHandler.Interface {
+    private router;
+    constructor(router: IHttpRouter);
+    execute(ctx: EventContext, _next: NextFunction): Promise<any>;
+}
+export declare const HttpRouterHandler: typeof HttpRouterHandlerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("~/features/events/EventHandler.js").IEventHandler<any, any>>;
+};
+export {};

package/features/testing/HttpRouterHandler.js

@@ -0,0 +1,42 @@
+import { TestHttpEventHandler } from "./TestHttpEventHandler.js";
+import { HttpRouter, RouteNotFoundError } from "../http/abstractions.js";
+class HttpRouterHandlerImpl {
+    constructor(router){
+        this.router = router;
+    }
+    async execute(ctx, _next) {
+        try {
+            return await this.router.route(ctx.event);
+        } catch (e) {
+            if (e instanceof RouteNotFoundError) return {
+                statusCode: 404,
+                body: {
+                    message: e.message
+                }
+            };
+            if (e && "object" == typeof e && e.code) return {
+                statusCode: 500,
+                body: {
+                    message: e.message,
+                    code: e.code,
+                    data: e.data ?? null
+                }
+            };
+            return {
+                statusCode: 500,
+                body: {
+                    message: "Internal server error"
+                }
+            };
+        }
+    }
+}
+const HttpRouterHandler = TestHttpEventHandler.createImplementation({
+    implementation: HttpRouterHandlerImpl,
+    dependencies: [
+        HttpRouter
+    ]
+});
+export { HttpRouterHandler };
+
+//# sourceMappingURL=HttpRouterHandler.js.map

package/features/testing/HttpRouterHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/testing/HttpRouterHandler.js","sources":["../../../src/features/testing/HttpRouterHandler.ts"],"sourcesContent":["import { TestHttpEventHandler } from \"./TestHttpEventHandler.js\";\nimport { HttpRouter, RouteNotFoundError } from \"~/features/http/abstractions.js\";\nimport type { EventContext } from \"~/features/events/EventHandler.js\";\nimport type { NextFunction } from \"~/features/events/types.js\";\nimport type { IHttpRouter } from \"~/features/http/abstractions.js\";\n\nclass HttpRouterHandlerImpl implements TestHttpEventHandler.Interface {\n    constructor(private router: IHttpRouter) {}\n\n    async execute(ctx: EventContext, _next: NextFunction): Promise<any> {\n        try {\n            return await this.router.route(ctx.event);\n        } catch (e) {\n            if (e instanceof RouteNotFoundError) {\n                return { statusCode: 404, body: { message: e.message } };\n            }\n            // Propagate structured errors (e.g. WebinyError with code/data) for test visibility\n            if (e && typeof e === \"object\" && (e as any).code) {\n                return {\n                    statusCode: 500,\n                    body: {\n                        message: (e as any).message,\n                        code: (e as any).code,\n                        data: (e as any).data ?? null\n                    }\n                };\n            }\n            return { statusCode: 500, body: { message: \"Internal server error\" } };\n        }\n    }\n}\n\nexport const HttpRouterHandler = TestHttpEventHandler.createImplementation({\n    implementation: HttpRouterHandlerImpl,\n    dependencies: [HttpRouter]\n});\n"],"names":["HttpRouterHandlerImpl","router","ctx","_next","e","RouteNotFoundError","HttpRouterHandler","TestHttpEventHandler","HttpRouter"],"mappings":";;AAMA,MAAMA;IACF,YAAoBC,MAAmB,CAAE;aAArBA,MAAM,GAANA;IAAsB;IAE1C,MAAM,QAAQC,GAAiB,EAAEC,KAAmB,EAAgB;QAChE,IAAI;YACA,OAAO,MAAM,IAAI,CAAC,MAAM,CAAC,KAAK,CAACD,IAAI,KAAK;QAC5C,EAAE,OAAOE,GAAG;YACR,IAAIA,aAAaC,oBACb,OAAO;gBAAE,YAAY;gBAAK,MAAM;oBAAE,SAASD,EAAE,OAAO;gBAAC;YAAE;YAG3D,IAAIA,KAAK,AAAa,YAAb,OAAOA,KAAmBA,EAAU,IAAI,EAC7C,OAAO;gBACH,YAAY;gBACZ,MAAM;oBACF,SAAUA,EAAU,OAAO;oBAC3B,MAAOA,EAAU,IAAI;oBACrB,MAAOA,EAAU,IAAI,IAAI;gBAC7B;YACJ;YAEJ,OAAO;gBAAE,YAAY;gBAAK,MAAM;oBAAE,SAAS;gBAAwB;YAAE;QACzE;IACJ;AACJ;AAEO,MAAME,oBAAoBC,qBAAqB,oBAAoB,CAAC;IACvE,gBAAgBP;IAChB,cAAc;QAACQ;KAAW;AAC9B"}

package/features/testing/TestHttpEventHandler.d.ts

@@ -0,0 +1,6 @@
+import { Abstraction } from "@webiny/di";
+import type { IEventHandler } from "../../features/events/EventHandler.js";
+export declare const TestHttpEventHandler: Abstraction<IEventHandler<any, any>>;
+export declare namespace TestHttpEventHandler {
+    type Interface = IEventHandler;
+}

package/features/testing/TestHttpEventHandler.js

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

package/features/testing/TestHttpEventHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/testing/TestHttpEventHandler.js","sources":["../../../src/features/testing/TestHttpEventHandler.ts"],"sourcesContent":["import { Abstraction } from \"@webiny/di\";\nimport type { IEventHandler } from \"~/features/events/EventHandler.js\";\n\nexport const TestHttpEventHandler = new Abstraction<IEventHandler>(\"TestHttpEventHandler\");\n\nexport namespace TestHttpEventHandler {\n    export type Interface = IEventHandler;\n}\n"],"names":["TestHttpEventHandler","Abstraction"],"mappings":";AAGO,MAAMA,uBAAuB,IAAIC,YAA2B"}

package/features/testing/TestHttpEventType.d.ts

@@ -0,0 +1,15 @@
+import type { IEventType } from "../../features/events/EventType.js";
+import type { IHttpRequest } from "../../features/http/index.js";
+export declare function isHttpRequest(event: any): event is IHttpRequest;
+/**
+ * EventType that recognizes IHttpRequest directly — no transport translation needed.
+ * Use in tests to feed IHttpRequest straight into the chain, bypassing AWS/Node adapters.
+ */
+declare class TestHttpEventTypeImplementation implements IEventType<IHttpRequest> {
+    canHandle(event: any): event is IHttpRequest;
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<import("../events/EventHandler.js").IEventHandler<any, any>>;
+}
+export declare const TestHttpEventType: typeof TestHttpEventTypeImplementation & {
+    __abstraction: import("@webiny/di").Abstraction<IEventType<any>>;
+};
+export {};

package/features/testing/TestHttpEventType.js

@@ -0,0 +1,20 @@
+import { EventType } from "../events/EventType.js";
+import { TestHttpEventHandler } from "./TestHttpEventHandler.js";
+function isHttpRequest(event) {
+    return "object" == typeof event && null !== event && "string" == typeof event.method && "string" == typeof event.path && "object" == typeof event.headers && "object" == typeof event.query;
+}
+class TestHttpEventTypeImplementation {
+    canHandle(event) {
+        return isHttpRequest(event);
+    }
+    getHandlerAbstraction() {
+        return TestHttpEventHandler;
+    }
+}
+const TestHttpEventType = EventType.createImplementation({
+    implementation: TestHttpEventTypeImplementation,
+    dependencies: []
+});
+export { TestHttpEventType, isHttpRequest };
+
+//# sourceMappingURL=TestHttpEventType.js.map

package/features/testing/TestHttpEventType.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/testing/TestHttpEventType.js","sources":["../../../src/features/testing/TestHttpEventType.ts"],"sourcesContent":["import { EventType } from \"~/features/events/EventType.js\";\nimport type { IEventType } from \"~/features/events/EventType.js\";\nimport { TestHttpEventHandler } from \"./TestHttpEventHandler.js\";\nimport type { IHttpRequest } from \"~/features/http/index.js\";\n\nexport function isHttpRequest(event: any): event is IHttpRequest {\n    return (\n        typeof event === \"object\" &&\n        event !== null &&\n        typeof event.method === \"string\" &&\n        typeof event.path === \"string\" &&\n        typeof event.headers === \"object\" &&\n        typeof event.query === \"object\"\n    );\n}\n\n/**\n * EventType that recognizes IHttpRequest directly — no transport translation needed.\n * Use in tests to feed IHttpRequest straight into the chain, bypassing AWS/Node adapters.\n */\nclass TestHttpEventTypeImplementation implements IEventType<IHttpRequest> {\n    canHandle(event: any): event is IHttpRequest {\n        return isHttpRequest(event);\n    }\n\n    getHandlerAbstraction() {\n        return TestHttpEventHandler;\n    }\n}\nexport const TestHttpEventType = EventType.createImplementation({\n    implementation: TestHttpEventTypeImplementation,\n    dependencies: []\n});\n"],"names":["isHttpRequest","event","TestHttpEventTypeImplementation","TestHttpEventHandler","TestHttpEventType","EventType"],"mappings":";;AAKO,SAASA,cAAcC,KAAU;IACpC,OACI,AAAiB,YAAjB,OAAOA,SACPA,AAAU,SAAVA,SACA,AAAwB,YAAxB,OAAOA,MAAM,MAAM,IACnB,AAAsB,YAAtB,OAAOA,MAAM,IAAI,IACjB,AAAyB,YAAzB,OAAOA,MAAM,OAAO,IACpB,AAAuB,YAAvB,OAAOA,MAAM,KAAK;AAE1B;AAMA,MAAMC;IACF,UAAUD,KAAU,EAAyB;QACzC,OAAOD,cAAcC;IACzB;IAEA,wBAAwB;QACpB,OAAOE;IACX;AACJ;AACO,MAAMC,oBAAoBC,UAAU,oBAAoB,CAAC;IAC5D,gBAAgBH;IAChB,cAAc,EAAE;AACpB"}

package/features/testing/createTestHttpHandler.d.ts

@@ -0,0 +1,14 @@
+import type { HandlerSetup, IHttpRequest, IHttpResponse } from "../../index.js";
+export interface createTestHttpHandlerOptions {
+    root: HandlerSetup;
+    request?: HandlerSetup;
+}
+/**
+ * Test handler that accepts IHttpRequest directly and returns IHttpResponse.
+ * Registers HttpRouterHandler as the base TestHttpEventHandler implementation.
+ * Callers layer middleware on top via container.registerDecorator() in options.root.
+ */
+export declare function createTestHttpHandler(options: createTestHttpHandlerOptions): (request: Partial<IHttpRequest> & {
+    method: string;
+    path: string;
+}) => Promise<IHttpResponse>;

package/features/testing/createTestHttpHandler.js

@@ -0,0 +1,26 @@
+import { HttpFeature } from "../http/feature.js";
+import { HttpRouterHandler } from "./HttpRouterHandler.js";
+import { createHandler } from "../events/createHandler.js";
+import { TestHttpEventType } from "./TestHttpEventType.js";
+function createTestHttpHandler(options) {
+    const invoke = createHandler({
+        root: async (container)=>{
+            container.register(TestHttpEventType);
+            container.register(HttpRouterHandler);
+            HttpFeature.register(container);
+            await options.root(container);
+        },
+        request: options.request
+    });
+    return async (request)=>invoke({
+            method: request.method,
+            path: request.path,
+            headers: request.headers ?? {},
+            query: request.query ?? {},
+            pathParameters: request.pathParameters ?? {},
+            body: request.body
+        });
+}
+export { createTestHttpHandler };
+
+//# sourceMappingURL=createTestHttpHandler.js.map

package/features/testing/createTestHttpHandler.js.map

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

package/features/testing/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./TestHttpEventHandler.js";
+export * from "./TestHttpEventType.js";
+export * from "./HttpRouterHandler.js";
+export * from "./createTestHttpHandler.js";

package/features/testing/index.js

@@ -0,0 +1,4 @@
+export * from "./TestHttpEventHandler.js";
+export * from "./TestHttpEventType.js";
+export * from "./HttpRouterHandler.js";
+export * from "./createTestHttpHandler.js";

package/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./features/events/index.js";
+export * from "./features/http/index.js";
+export { Container, Abstraction } from "@webiny/di";

package/index.js

@@ -0,0 +1,3 @@
+export * from "./features/events/index.js";
+export * from "./features/http/index.js";
+export { Abstraction, Container } from "@webiny/di";

package/package.json

@@ -0,0 +1,39 @@
+{
+	"name": "@webiny/event-handler-core",
+	"version": "0.0.0-unstable.0d717d18dd",
+	"type": "module",
+	"main": "index.js",
+	"exports": {
+		".": "./index.js",
+		"./*": "./*"
+	},
+	"types": "index.d.ts",
+	"description": "Cloud-agnostic handler chain for building cloud functions with Dependency Injection.",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/webiny/webiny-js.git"
+	},
+	"contributors": [
+		"Webiny Team"
+	],
+	"license": "MIT",
+	"dependencies": {
+		"@webiny/feature": "0.0.0-unstable.0d717d18dd"
+	},
+	"peerDependencies": {
+		"@webiny/di": "1.0.2"
+	},
+	"devDependencies": {
+		"@webiny/build-tools": "0.0.0-unstable.0d717d18dd",
+		"@webiny/di": "1.0.2",
+		"rimraf": "6.1.3",
+		"typescript": "7.0.2",
+		"vitest": "4.1.10"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"webiny": {
+		"publishFrom": "dist"
+	}
+}