@webiny/event-handler-core 0.0.0-unstable.0d717d18dd → 6.6.0-alpha.1

package/exports/api.d.ts

@@ -0,0 +1,2 @@
+export { HttpRouteDefinition, HttpRouteHandler } from "../features/http/abstractions.js";
+export type { IHttpRequest, IHttpResponse, IHttpResponseBuilder, IMatchedRouteDefinition } from "../features/http/abstractions.js";

package/exports/api.js

@@ -0,0 +1 @@
+export { HttpRouteDefinition, HttpRouteHandler } from "../features/http/abstractions.js";

package/features/events/ChildContainerFactory.d.ts

@@ -0,0 +1,11 @@
+import { Container } from "@webiny/di";
+import { ChildContainerFactory, HandlerConfig } from "./abstractions.js";
+declare class ChildContainerFactoryImpl implements ChildContainerFactory.Interface {
+    private config;
+    constructor(config: HandlerConfig.Interface);
+    create(root: Container, rawArgs: any[]): Promise<Container>;
+}
+export declare const DefaultChildContainerFactory: typeof ChildContainerFactoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IChildContainerFactory>;
+};
+export {};

package/features/events/ChildContainerFactory.js

@@ -0,0 +1,25 @@
+import { ChildContainerFactory, HandlerConfig } from "./abstractions.js";
+import { RequestContainer } from "./RequestContainer.js";
+import { noopTransport } from "./Transport.js";
+class ChildContainerFactoryImpl {
+    constructor(config){
+        this.config = config;
+    }
+    async create(root, rawArgs) {
+        const child = root.createChildContainer();
+        child.registerInstance(RequestContainer, child);
+        const transport = this.config.transport ?? noopTransport;
+        await transport.bind(child, ...rawArgs);
+        if (this.config.child) await this.config.child(child);
+        return child;
+    }
+}
+const DefaultChildContainerFactory = ChildContainerFactory.createImplementation({
+    implementation: ChildContainerFactoryImpl,
+    dependencies: [
+        HandlerConfig
+    ]
+});
+export { DefaultChildContainerFactory };
+
+//# sourceMappingURL=ChildContainerFactory.js.map

package/features/events/ChildContainerFactory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/events/ChildContainerFactory.js","sources":["../../../src/features/events/ChildContainerFactory.ts"],"sourcesContent":["import { Container } from \"@webiny/di\";\nimport { ChildContainerFactory, HandlerConfig } from \"./abstractions.js\";\nimport { RequestContainer } from \"./RequestContainer.js\";\nimport { noopTransport } from \"./Transport.js\";\n\nclass ChildContainerFactoryImpl implements ChildContainerFactory.Interface {\n    constructor(private config: HandlerConfig.Interface) {}\n\n    async create(root: Container, rawArgs: any[]): Promise<Container> {\n        const child = root.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        const transport = this.config.transport ?? noopTransport;\n        await transport.bind(child, ...rawArgs);\n\n        if (this.config.child) {\n            await this.config.child(child);\n        }\n\n        return child;\n    }\n}\n\nexport const DefaultChildContainerFactory = ChildContainerFactory.createImplementation({\n    implementation: ChildContainerFactoryImpl,\n    dependencies: [HandlerConfig]\n});\n"],"names":["ChildContainerFactoryImpl","config","root","rawArgs","child","RequestContainer","transport","noopTransport","DefaultChildContainerFactory","ChildContainerFactory","HandlerConfig"],"mappings":";;;AAKA,MAAMA;IACF,YAAoBC,MAA+B,CAAE;aAAjCA,MAAM,GAANA;IAAkC;IAEtD,MAAM,OAAOC,IAAe,EAAEC,OAAc,EAAsB;QAC9D,MAAMC,QAAQF,KAAK,oBAAoB;QACvCE,MAAM,gBAAgB,CAACC,kBAAkBD;QAIzC,MAAME,YAAY,IAAI,CAAC,MAAM,CAAC,SAAS,IAAIC;QAC3C,MAAMD,UAAU,IAAI,CAACF,UAAUD;QAE/B,IAAI,IAAI,CAAC,MAAM,CAAC,KAAK,EACjB,MAAM,IAAI,CAAC,MAAM,CAAC,KAAK,CAACC;QAG5B,OAAOA;IACX;AACJ;AAEO,MAAMI,+BAA+BC,sBAAsB,oBAAoB,CAAC;IACnF,gBAAgBT;IAChB,cAAc;QAACU;KAAc;AACjC"}

package/features/events/HandlerApp.d.ts

@@ -0,0 +1,27 @@
+import { Container } from "@webiny/di";
+import { HandlerConfig } from "./abstractions.js";
+/**
+ * The DI-native handler app. `HandlerApp.init(config)` builds a small "app container" (distinct
+ * from the per-process root container and the per-request child container it goes on to create),
+ * wires the default lifecycle abstractions, and returns an app whose `handle()` is the
+ * platform-invocable handler.
+ *
+ * The lifecycle is delegated to decoratable DI abstractions — {@link RootContainerFactory} (build
+ * the root once) and {@link ChildContainerFactory} (create + set up the per-request child) — so
+ * transports/composition layers extend it by decoration (`config.app`) instead of this class
+ * growing new branches. `HandlerApp` is distinct from {@link EventHandler}, which is a single
+ * handler IN the dispatch chain.
+ */
+export declare class HandlerApp {
+    private rootContainerFactory;
+    private childContainerFactory;
+    private constructor();
+    static init(config: HandlerConfig.Interface): HandlerApp;
+    /**
+     * Build (once) and return the root container. Lets a transport that needs the root before the
+     * first request — e.g. the Node server attaching a WebSockets upgrade handler at startup — get
+     * it eagerly. The same memoized root is then reused by every `handle()` call.
+     */
+    getRootContainer(): Promise<Container>;
+    handle(...rawArgs: any[]): Promise<any>;
+}

package/features/events/HandlerApp.js

@@ -0,0 +1,53 @@
+import { Container } from "@webiny/di";
+import { EventType } from "./EventType.js";
+import { ChildContainerFactory, HandlerConfig, RootContainerFactory } from "./abstractions.js";
+import { DefaultRootContainerFactory } from "./RootContainerFactory.js";
+import { DefaultChildContainerFactory } from "./ChildContainerFactory.js";
+import { executeChain } from "./chain.js";
+class HandlerApp {
+    constructor(rootContainerFactory, childContainerFactory){
+        this.rootContainerFactory = rootContainerFactory;
+        this.childContainerFactory = childContainerFactory;
+    }
+    static init(config) {
+        const appContainer = new Container();
+        appContainer.registerInstance(HandlerConfig, config);
+        appContainer.register(DefaultRootContainerFactory).inSingletonScope();
+        appContainer.register(DefaultChildContainerFactory).inSingletonScope();
+        config.app?.(appContainer);
+        return new HandlerApp(appContainer.resolve(RootContainerFactory), appContainer.resolve(ChildContainerFactory));
+    }
+    getRootContainer() {
+        return this.rootContainerFactory.get();
+    }
+    async handle(...rawArgs) {
+        const root = await this.rootContainerFactory.get();
+        const child = await this.childContainerFactory.create(root, rawArgs);
+        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)=>{
+                try {
+                    return String(et.getHandlerAbstraction());
+                } catch  {
+                    return "<unknown>";
+                }
+            });
+            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 { HandlerApp };
+
+//# sourceMappingURL=HandlerApp.js.map

package/features/events/HandlerApp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/events/HandlerApp.js","sources":["../../../src/features/events/HandlerApp.ts"],"sourcesContent":["import { Container } from \"@webiny/di\";\nimport { EventType } from \"./EventType.js\";\nimport { HandlerConfig, RootContainerFactory, ChildContainerFactory } from \"./abstractions.js\";\nimport { DefaultRootContainerFactory } from \"./RootContainerFactory.js\";\nimport { DefaultChildContainerFactory } from \"./ChildContainerFactory.js\";\nimport { executeChain } from \"./chain.js\";\n\n/**\n * The DI-native handler app. `HandlerApp.init(config)` builds a small \"app container\" (distinct\n * from the per-process root container and the per-request child container it goes on to create),\n * wires the default lifecycle abstractions, and returns an app whose `handle()` is the\n * platform-invocable handler.\n *\n * The lifecycle is delegated to decoratable DI abstractions — {@link RootContainerFactory} (build\n * the root once) and {@link ChildContainerFactory} (create + set up the per-request child) — so\n * transports/composition layers extend it by decoration (`config.app`) instead of this class\n * growing new branches. `HandlerApp` is distinct from {@link EventHandler}, which is a single\n * handler IN the dispatch chain.\n */\nexport class HandlerApp {\n    private constructor(\n        private rootContainerFactory: RootContainerFactory.Interface,\n        private childContainerFactory: ChildContainerFactory.Interface\n    ) {}\n\n    static init(config: HandlerConfig.Interface): HandlerApp {\n        const appContainer = new Container();\n\n        // Register the config as-is — the default lifecycle factories resolve HandlerConfig directly.\n        appContainer.registerInstance(HandlerConfig, config);\n\n        // Register the default lifecycle abstractions. Singleton-scoped so the memoized root\n        // container (held by RootContainerFactory) is shared across every warm invocation.\n        appContainer.register(DefaultRootContainerFactory).inSingletonScope();\n        appContainer.register(DefaultChildContainerFactory).inSingletonScope();\n\n        // Seam: let callers decorate the factories before the app is resolved.\n        config.app?.(appContainer);\n\n        // Resolve the factories once (decorators applied) so their state — notably the memoized\n        // root — is reused across every invocation of handle().\n        return new HandlerApp(\n            appContainer.resolve(RootContainerFactory),\n            appContainer.resolve(ChildContainerFactory)\n        );\n    }\n\n    /**\n     * Build (once) and return the root container. Lets a transport that needs the root before the\n     * first request — e.g. the Node server attaching a WebSockets upgrade handler at startup — get\n     * it eagerly. The same memoized root is then reused by every `handle()` call.\n     */\n    getRootContainer(): Promise<Container> {\n        return this.rootContainerFactory.get();\n    }\n\n    async handle(...rawArgs: any[]): Promise<any> {\n        const root = await this.rootContainerFactory.get();\n        const child = await this.childContainerFactory.create(root, rawArgs);\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            // Name each registered type by the handler abstraction it dispatches to, NOT by\n            // `constructor.name`: the production bundle minifies class names, so every entry came\n            // back as \"implementation\" — useless in exactly the place this message matters. An\n            // abstraction's name is a string literal, so it survives bundling.\n            const registered = eventTypes.map(et => {\n                try {\n                    return String(et.getHandlerAbstraction());\n                } catch {\n                    return \"<unknown>\";\n                }\n            });\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":["HandlerApp","rootContainerFactory","childContainerFactory","config","appContainer","Container","HandlerConfig","DefaultRootContainerFactory","DefaultChildContainerFactory","RootContainerFactory","ChildContainerFactory","rawArgs","root","child","event","eventTypes","EventType","matched","et","shape","Object","registered","String","Error","JSON","abstraction","handlers","executeChain"],"mappings":";;;;;;AAmBO,MAAMA;IACT,YACYC,oBAAoD,EACpDC,qBAAsD,CAChE;aAFUD,oBAAoB,GAApBA;aACAC,qBAAqB,GAArBA;IACT;IAEH,OAAO,KAAKC,MAA+B,EAAc;QACrD,MAAMC,eAAe,IAAIC;QAGzBD,aAAa,gBAAgB,CAACE,eAAeH;QAI7CC,aAAa,QAAQ,CAACG,6BAA6B,gBAAgB;QACnEH,aAAa,QAAQ,CAACI,8BAA8B,gBAAgB;QAGpEL,OAAO,GAAG,GAAGC;QAIb,OAAO,IAAIJ,WACPI,aAAa,OAAO,CAACK,uBACrBL,aAAa,OAAO,CAACM;IAE7B;IAOA,mBAAuC;QACnC,OAAO,IAAI,CAAC,oBAAoB,CAAC,GAAG;IACxC;IAEA,MAAM,OAAO,GAAGC,OAAc,EAAgB;QAC1C,MAAMC,OAAO,MAAM,IAAI,CAAC,oBAAoB,CAAC,GAAG;QAChD,MAAMC,QAAQ,MAAM,IAAI,CAAC,qBAAqB,CAAC,MAAM,CAACD,MAAMD;QAG5D,MAAMG,QAAQH,OAAO,CAAC,EAAE;QACxB,MAAMI,aAAaF,MAAM,UAAU,CAACG;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;YAK/B,MAAMO,aAAaN,WAAW,GAAG,CAACG,CAAAA;gBAC9B,IAAI;oBACA,OAAOI,OAAOJ,GAAG,qBAAqB;gBAC1C,EAAE,OAAM;oBACJ,OAAO;gBACX;YACJ;YACA,MAAM,IAAIK,MACN,CAAC,uDAAuD,EAAEC,KAAK,SAAS,CACpEL,OACF,0BAA0B,EAAEK,KAAK,SAAS,CAACH,aAAa;QAElE;QAEA,MAAMI,cAAcR,QAAQ,qBAAqB;QACjD,MAAMS,WAAWb,MAAM,UAAU,CAACY;QAElC,OAAOE,aAAaD,UAAUZ;IAClC;AACJ"}

package/features/events/RootContainerFactory.d.ts

@@ -0,0 +1,12 @@
+import { Container } from "@webiny/di";
+import { HandlerConfig, RootContainerFactory } from "./abstractions.js";
+declare class RootContainerFactoryImpl implements RootContainerFactory.Interface {
+    private config;
+    private rootContainer;
+    constructor(config: HandlerConfig.Interface);
+    get(): Promise<Container>;
+}
+export declare const DefaultRootContainerFactory: typeof RootContainerFactoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IRootContainerFactory>;
+};
+export {};

package/features/events/RootContainerFactory.js

@@ -0,0 +1,24 @@
+import { Container } from "@webiny/di";
+import { HandlerConfig, RootContainerFactory } from "./abstractions.js";
+class RootContainerFactoryImpl {
+    constructor(config){
+        this.config = config;
+        this.rootContainer = null;
+    }
+    async get() {
+        if (!this.rootContainer) {
+            this.rootContainer = new Container();
+            await this.config.root(this.rootContainer);
+        }
+        return this.rootContainer;
+    }
+}
+const DefaultRootContainerFactory = RootContainerFactory.createImplementation({
+    implementation: RootContainerFactoryImpl,
+    dependencies: [
+        HandlerConfig
+    ]
+});
+export { DefaultRootContainerFactory };
+
+//# sourceMappingURL=RootContainerFactory.js.map

package/features/events/RootContainerFactory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/events/RootContainerFactory.js","sources":["../../../src/features/events/RootContainerFactory.ts"],"sourcesContent":["import { Container } from \"@webiny/di\";\nimport { HandlerConfig, RootContainerFactory } from \"./abstractions.js\";\n\nclass RootContainerFactoryImpl implements RootContainerFactory.Interface {\n    private rootContainer: Container | null = null;\n\n    constructor(private config: HandlerConfig.Interface) {}\n\n    async get(): Promise<Container> {\n        if (!this.rootContainer) {\n            this.rootContainer = new Container();\n            await this.config.root(this.rootContainer);\n        }\n        return this.rootContainer;\n    }\n}\n\nexport const DefaultRootContainerFactory = RootContainerFactory.createImplementation({\n    implementation: RootContainerFactoryImpl,\n    dependencies: [HandlerConfig]\n});\n"],"names":["RootContainerFactoryImpl","config","Container","DefaultRootContainerFactory","RootContainerFactory","HandlerConfig"],"mappings":";;AAGA,MAAMA;IAGF,YAAoBC,MAA+B,CAAE;aAAjCA,MAAM,GAANA;aAFZ,aAAa,GAAqB;IAEY;IAEtD,MAAM,MAA0B;QAC5B,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE;YACrB,IAAI,CAAC,aAAa,GAAG,IAAIC;YACzB,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,aAAa;QAC7C;QACA,OAAO,IAAI,CAAC,aAAa;IAC7B;AACJ;AAEO,MAAMC,8BAA8BC,qBAAqB,oBAAoB,CAAC;IACjF,gBAAgBJ;IAChB,cAAc;QAACK;KAAc;AACjC"}

package/features/events/abstractions.d.ts

@@ -0,0 +1,60 @@
+import { Abstraction, Container } from "@webiny/di";
+import type { Transport } from "./Transport.js";
+import type { HandlerSetup } from "./types.js";
+/**
+ * Configuration for `HandlerApp.init` — and the DI value the default lifecycle abstractions
+ * ({@link RootContainerFactory} / {@link ChildContainerFactory}) resolve. The object passed to
+ * `init` is registered as-is under this abstraction (no remapping), so the config the caller writes
+ * is exactly the config the factories read.
+ */
+export interface IHandlerConfig {
+    /** Set up the ROOT container (once per process). */
+    root: HandlerSetup;
+    /** Set up the per-request CHILD container. */
+    child?: 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;
+    /**
+     * Decorate the DI-native handler app before its first use. Runs against the APP container (the
+     * small container holding the lifecycle abstractions), so callers can `registerDecorator(...)`
+     * around any lifecycle step — e.g. wrapping `ChildContainerFactory` to refresh a license before
+     * each request.
+     */
+    app?: (container: Container) => void;
+}
+export declare const HandlerConfig: Abstraction<IHandlerConfig>;
+export declare namespace HandlerConfig {
+    type Interface = IHandlerConfig;
+}
+/**
+ * Builds the ROOT container once per process and reuses it across warm invocations. Decoratable —
+ * wrap it to run process-lifetime setup around the root build. `get()` is idempotent — the root is
+ * built (and `config.root` run) on the first call and the same instance is returned thereafter, so a
+ * transport can call it eagerly (see `HandlerApp.getRootContainer`) without rebuilding.
+ */
+export interface IRootContainerFactory {
+    get(): Promise<Container>;
+}
+export declare const RootContainerFactory: Abstraction<IRootContainerFactory>;
+export declare namespace RootContainerFactory {
+    type Interface = IRootContainerFactory;
+}
+/**
+ * Creates and sets up the per-request (child) container: spawns the child, binds transport
+ * primitives, and runs request setup.
+ *
+ * Decoratable — this is the seam for per-request work that must run BEFORE the register/dispatch
+ * flow (e.g. refreshing a project-level license so register-time checks see it). Since such work
+ * typically needs only root-scoped state, a decorator can act before delegating to `create()`.
+ */
+export interface IChildContainerFactory {
+    create(root: Container, rawArgs: any[]): Promise<Container>;
+}
+export declare const ChildContainerFactory: Abstraction<IChildContainerFactory>;
+export declare namespace ChildContainerFactory {
+    type Interface = IChildContainerFactory;
+}

package/features/events/abstractions.js

@@ -0,0 +1,7 @@
+import { Abstraction } from "@webiny/di";
+const HandlerConfig = new Abstraction("HandlerConfig");
+const RootContainerFactory = new Abstraction("RootContainerFactory");
+const ChildContainerFactory = new Abstraction("ChildContainerFactory");
+export { ChildContainerFactory, HandlerConfig, RootContainerFactory };
+
+//# sourceMappingURL=abstractions.js.map

package/features/events/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/events/abstractions.js","sources":["../../../src/features/events/abstractions.ts"],"sourcesContent":["import { Abstraction, Container } from \"@webiny/di\";\nimport type { Transport } from \"./Transport.js\";\nimport type { HandlerSetup } from \"./types.js\";\n\n/**\n * Configuration for `HandlerApp.init` — and the DI value the default lifecycle abstractions\n * ({@link RootContainerFactory} / {@link ChildContainerFactory}) resolve. The object passed to\n * `init` is registered as-is under this abstraction (no remapping), so the config the caller writes\n * is exactly the config the factories read.\n */\nexport interface IHandlerConfig {\n    /** Set up the ROOT container (once per process). */\n    root: HandlerSetup;\n    /** Set up the per-request CHILD container. */\n    child?: 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     * Decorate the DI-native handler app before its first use. Runs against the APP container (the\n     * small container holding the lifecycle abstractions), so callers can `registerDecorator(...)`\n     * around any lifecycle step — e.g. wrapping `ChildContainerFactory` to refresh a license before\n     * each request.\n     */\n    app?: (container: Container) => void;\n}\n\nexport const HandlerConfig = new Abstraction<IHandlerConfig>(\"HandlerConfig\");\n\nexport namespace HandlerConfig {\n    export type Interface = IHandlerConfig;\n}\n\n/**\n * Builds the ROOT container once per process and reuses it across warm invocations. Decoratable —\n * wrap it to run process-lifetime setup around the root build. `get()` is idempotent — the root is\n * built (and `config.root` run) on the first call and the same instance is returned thereafter, so a\n * transport can call it eagerly (see `HandlerApp.getRootContainer`) without rebuilding.\n */\nexport interface IRootContainerFactory {\n    get(): Promise<Container>;\n}\n\nexport const RootContainerFactory = new Abstraction<IRootContainerFactory>(\"RootContainerFactory\");\n\nexport namespace RootContainerFactory {\n    export type Interface = IRootContainerFactory;\n}\n\n/**\n * Creates and sets up the per-request (child) container: spawns the child, binds transport\n * primitives, and runs request setup.\n *\n * Decoratable — this is the seam for per-request work that must run BEFORE the register/dispatch\n * flow (e.g. refreshing a project-level license so register-time checks see it). Since such work\n * typically needs only root-scoped state, a decorator can act before delegating to `create()`.\n */\nexport interface IChildContainerFactory {\n    create(root: Container, rawArgs: any[]): Promise<Container>;\n}\n\nexport const ChildContainerFactory = new Abstraction<IChildContainerFactory>(\n    \"ChildContainerFactory\"\n);\n\nexport namespace ChildContainerFactory {\n    export type Interface = IChildContainerFactory;\n}\n"],"names":["HandlerConfig","Abstraction","RootContainerFactory","ChildContainerFactory"],"mappings":";AA8BO,MAAMA,gBAAgB,IAAIC,YAA4B;AAgBtD,MAAMC,uBAAuB,IAAID,YAAmC;AAkBpE,MAAME,wBAAwB,IAAIF,YACrC"}

package/features/events/index.d.ts

@@ -1,10 +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 "./abstractions.js";
+export * from "./HandlerApp.js";
+export * from "./RootContainerFactory.js";
+export * from "./ChildContainerFactory.js";
 export * from "./Transport.js";
 export * from "./types.js";
-export * from "./runRequestContextInitializers.js";

package/features/events/index.js

@@ -1,10 +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 "./abstractions.js";
+export * from "./HandlerApp.js";
+export * from "./RootContainerFactory.js";
+export * from "./ChildContainerFactory.js";
 export * from "./Transport.js";
 export * from "./types.js";
-export * from "./runRequestContextInitializers.js";

package/features/http/HttpResponseBuilder.d.ts

@@ -0,0 +1,36 @@
+import type { CookieOptions, IHttpResponse, IHttpResponseBuilder } from "./abstractions.js";
+import type { HttpStreamSource } from "./HttpStreamBody.js";
+/**
+ * Serialize a single `Set-Cookie` value. Kept dependency-free (no `cookie` package) — the attribute
+ * set below is everything the framework needs.
+ */
+export declare function serializeCookie(name: string, value: string, options?: CookieOptions): string;
+export declare class HttpResponseBuilder implements IHttpResponseBuilder {
+    private statusCodeValue;
+    private headerValues;
+    private cookieValues;
+    private bodyValue;
+    private modified;
+    status(statusCode: number): this;
+    header(name: string, value: string): this;
+    setHeaders(headers: Record<string, string>): this;
+    getHeader(name: string): string | undefined;
+    removeHeader(name: string): this;
+    type(contentType: string): this;
+    cookie(name: string, value: string, options?: CookieOptions): this;
+    clearCookie(name: string, options?: Omit<CookieOptions, "expires" | "maxAge">): this;
+    json(body?: any): this;
+    send(body?: any): this;
+    text(body: string): this;
+    html(body: string): this;
+    redirect(url: string, statusCode?: number): this;
+    end(body?: any): this;
+    sse(source: HttpStreamSource): this;
+    /**
+     * Whether anything was set on this builder. The router uses it to decide if builder state needs
+     * merging into a plain IHttpResponse a route returned instead.
+     */
+    isModified(): boolean;
+    toResponse(): IHttpResponse;
+}
+export declare function createHttpResponseBuilder(): HttpResponseBuilder;

package/features/http/HttpResponseBuilder.js

@@ -0,0 +1,133 @@
+import { HttpStreamBody } from "./HttpStreamBody.js";
+const CONTENT_TYPE = "content-type";
+const TYPE_SHORTHANDS = {
+    json: "application/json",
+    text: "text/plain; charset=utf-8",
+    html: "text/html; charset=utf-8",
+    xml: "application/xml",
+    bin: "application/octet-stream"
+};
+function serializeCookie(name, value, options = {}) {
+    const parts = [
+        `${name}=${encodeURIComponent(value)}`
+    ];
+    if (void 0 !== options.maxAge) parts.push(`Max-Age=${Math.floor(options.maxAge)}`);
+    if (options.domain) parts.push(`Domain=${options.domain}`);
+    parts.push(`Path=${options.path ?? "/"}`);
+    if (options.expires) parts.push(`Expires=${options.expires.toUTCString()}`);
+    if (options.httpOnly) parts.push("HttpOnly");
+    if (options.secure) parts.push("Secure");
+    if (options.partitioned) parts.push("Partitioned");
+    if (options.sameSite) {
+        const sameSite = options.sameSite;
+        parts.push(`SameSite=${sameSite.charAt(0).toUpperCase()}${sameSite.slice(1)}`);
+    }
+    return parts.join("; ");
+}
+class HttpResponseBuilder {
+    status(statusCode) {
+        this.statusCodeValue = statusCode;
+        this.modified = true;
+        return this;
+    }
+    header(name, value) {
+        this.headerValues[name.toLowerCase()] = value;
+        this.modified = true;
+        return this;
+    }
+    setHeaders(headers) {
+        for (const [name, value] of Object.entries(headers))this.header(name, value);
+        return this;
+    }
+    getHeader(name) {
+        return this.headerValues[name.toLowerCase()];
+    }
+    removeHeader(name) {
+        delete this.headerValues[name.toLowerCase()];
+        this.modified = true;
+        return this;
+    }
+    type(contentType) {
+        return this.header(CONTENT_TYPE, TYPE_SHORTHANDS[contentType] ?? contentType);
+    }
+    cookie(name, value, options) {
+        this.cookieValues.push(serializeCookie(name, value, options));
+        this.modified = true;
+        return this;
+    }
+    clearCookie(name, options) {
+        return this.cookie(name, "", {
+            ...options,
+            expires: new Date(0),
+            maxAge: 0
+        });
+    }
+    json(body) {
+        if (void 0 === this.getHeader(CONTENT_TYPE)) this.type("json");
+        this.bodyValue = void 0 === body ? void 0 : JSON.stringify(body);
+        this.modified = true;
+        return this;
+    }
+    send(body) {
+        if (null == body) return this.end(body);
+        if ("string" == typeof body) {
+            if (void 0 === this.getHeader(CONTENT_TYPE)) this.type("html");
+            return this.end(body);
+        }
+        if (Buffer.isBuffer(body) || body instanceof Uint8Array) {
+            if (void 0 === this.getHeader(CONTENT_TYPE)) this.type("bin");
+            return this.end(body);
+        }
+        return this.json(body);
+    }
+    text(body) {
+        return this.type("text").end(body);
+    }
+    html(body) {
+        return this.type("html").end(body);
+    }
+    redirect(url, statusCode = 302) {
+        return this.status(statusCode).header("location", url).end();
+    }
+    end(body) {
+        this.bodyValue = body;
+        this.modified = true;
+        return this;
+    }
+    sse(source) {
+        return this.setHeaders({
+            "content-type": "text/event-stream",
+            "cache-control": "no-cache, no-transform",
+            connection: "keep-alive",
+            "x-accel-buffering": "no"
+        }).end(new HttpStreamBody(source));
+    }
+    isModified() {
+        return this.modified;
+    }
+    toResponse() {
+        const response = {
+            statusCode: this.statusCodeValue
+        };
+        if (Object.keys(this.headerValues).length > 0) response.headers = {
+            ...this.headerValues
+        };
+        if (this.cookieValues.length > 0) response.cookies = [
+            ...this.cookieValues
+        ];
+        if (void 0 !== this.bodyValue) response.body = this.bodyValue;
+        return response;
+    }
+    constructor(){
+        this.statusCodeValue = 200;
+        this.headerValues = {};
+        this.cookieValues = [];
+        this.modified = false;
+    }
+}
+function createHttpResponseBuilder() {
+    return new HttpResponseBuilder();
+}
+export { HttpResponseBuilder, createHttpResponseBuilder, serializeCookie };
+
+//# sourceMappingURL=HttpResponseBuilder.js.map

package/features/http/HttpResponseBuilder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/http/HttpResponseBuilder.js","sources":["../../../src/features/http/HttpResponseBuilder.ts"],"sourcesContent":["import type { CookieOptions, IHttpResponse, IHttpResponseBuilder } from \"./abstractions.js\";\nimport { HttpStreamBody } from \"./HttpStreamBody.js\";\nimport type { HttpStreamSource } from \"./HttpStreamBody.js\";\n\nconst CONTENT_TYPE = \"content-type\";\n\nconst TYPE_SHORTHANDS: Record<string, string> = {\n    json: \"application/json\",\n    text: \"text/plain; charset=utf-8\",\n    html: \"text/html; charset=utf-8\",\n    xml: \"application/xml\",\n    bin: \"application/octet-stream\"\n};\n\n/**\n * Serialize a single `Set-Cookie` value. Kept dependency-free (no `cookie` package) — the attribute\n * set below is everything the framework needs.\n */\nexport function serializeCookie(name: string, value: string, options: CookieOptions = {}): string {\n    const parts = [`${name}=${encodeURIComponent(value)}`];\n\n    if (options.maxAge !== undefined) {\n        parts.push(`Max-Age=${Math.floor(options.maxAge)}`);\n    }\n    if (options.domain) {\n        parts.push(`Domain=${options.domain}`);\n    }\n    // Default to \"/\" so a cookie set on e.g. POST /graphql isn't scoped to that one path.\n    parts.push(`Path=${options.path ?? \"/\"}`);\n    if (options.expires) {\n        parts.push(`Expires=${options.expires.toUTCString()}`);\n    }\n    if (options.httpOnly) {\n        parts.push(\"HttpOnly\");\n    }\n    if (options.secure) {\n        parts.push(\"Secure\");\n    }\n    if (options.partitioned) {\n        parts.push(\"Partitioned\");\n    }\n    if (options.sameSite) {\n        const sameSite = options.sameSite;\n        parts.push(`SameSite=${sameSite.charAt(0).toUpperCase()}${sameSite.slice(1)}`);\n    }\n\n    return parts.join(\"; \");\n}\n\nexport class HttpResponseBuilder implements IHttpResponseBuilder {\n    private statusCodeValue = 200;\n    private headerValues: Record<string, string> = {};\n    private cookieValues: string[] = [];\n    private bodyValue: any;\n    private modified = false;\n\n    status(statusCode: number): this {\n        this.statusCodeValue = statusCode;\n        this.modified = true;\n        return this;\n    }\n\n    header(name: string, value: string): this {\n        this.headerValues[name.toLowerCase()] = value;\n        this.modified = true;\n        return this;\n    }\n\n    setHeaders(headers: Record<string, string>): this {\n        for (const [name, value] of Object.entries(headers)) {\n            this.header(name, value);\n        }\n        return this;\n    }\n\n    getHeader(name: string): string | undefined {\n        return this.headerValues[name.toLowerCase()];\n    }\n\n    removeHeader(name: string): this {\n        delete this.headerValues[name.toLowerCase()];\n        this.modified = true;\n        return this;\n    }\n\n    type(contentType: string): this {\n        return this.header(CONTENT_TYPE, TYPE_SHORTHANDS[contentType] ?? contentType);\n    }\n\n    cookie(name: string, value: string, options?: CookieOptions): this {\n        this.cookieValues.push(serializeCookie(name, value, options));\n        this.modified = true;\n        return this;\n    }\n\n    clearCookie(name: string, options?: Omit<CookieOptions, \"expires\" | \"maxAge\">): this {\n        return this.cookie(name, \"\", {\n            ...options,\n            expires: new Date(0),\n            maxAge: 0\n        });\n    }\n\n    json(body?: any): this {\n        if (this.getHeader(CONTENT_TYPE) === undefined) {\n            this.type(\"json\");\n        }\n        // Serialize here rather than leaving an object for the transport, so the body a route\n        // produces is the exact bytes that go out regardless of transport.\n        this.bodyValue = body === undefined ? undefined : JSON.stringify(body);\n        this.modified = true;\n        return this;\n    }\n\n    send(body?: any): this {\n        if (body === undefined || body === null) {\n            return this.end(body);\n        }\n        if (typeof body === \"string\") {\n            if (this.getHeader(CONTENT_TYPE) === undefined) {\n                this.type(\"html\");\n            }\n            return this.end(body);\n        }\n        if (Buffer.isBuffer(body) || body instanceof Uint8Array) {\n            if (this.getHeader(CONTENT_TYPE) === undefined) {\n                this.type(\"bin\");\n            }\n            return this.end(body);\n        }\n        return this.json(body);\n    }\n\n    text(body: string): this {\n        return this.type(\"text\").end(body);\n    }\n\n    html(body: string): this {\n        return this.type(\"html\").end(body);\n    }\n\n    redirect(url: string, statusCode = 302): this {\n        return this.status(statusCode).header(\"location\", url).end();\n    }\n\n    end(body?: any): this {\n        this.bodyValue = body;\n        this.modified = true;\n        return this;\n    }\n\n    sse(source: HttpStreamSource): this {\n        // `no-transform` and `x-accel-buffering: no` are the two that silently matter: without them a\n        // proxy compresses or buffers the body and the response stops being incremental while still\n        // looking correct. See the interface docs.\n        return this.setHeaders({\n            \"content-type\": \"text/event-stream\",\n            \"cache-control\": \"no-cache, no-transform\",\n            connection: \"keep-alive\",\n            \"x-accel-buffering\": \"no\"\n        }).end(new HttpStreamBody(source));\n    }\n\n    /**\n     * Whether anything was set on this builder. The router uses it to decide if builder state needs\n     * merging into a plain IHttpResponse a route returned instead.\n     */\n    isModified(): boolean {\n        return this.modified;\n    }\n\n    toResponse(): IHttpResponse {\n        const response: IHttpResponse = { statusCode: this.statusCodeValue };\n        if (Object.keys(this.headerValues).length > 0) {\n            response.headers = { ...this.headerValues };\n        }\n        if (this.cookieValues.length > 0) {\n            response.cookies = [...this.cookieValues];\n        }\n        if (this.bodyValue !== undefined) {\n            response.body = this.bodyValue;\n        }\n        return response;\n    }\n}\n\nexport function createHttpResponseBuilder(): HttpResponseBuilder {\n    return new HttpResponseBuilder();\n}\n"],"names":["CONTENT_TYPE","TYPE_SHORTHANDS","serializeCookie","name","value","options","parts","encodeURIComponent","undefined","Math","sameSite","HttpResponseBuilder","statusCode","headers","Object","contentType","Date","body","JSON","Buffer","Uint8Array","url","source","HttpStreamBody","response","createHttpResponseBuilder"],"mappings":"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"}

package/features/http/HttpRouter.d.ts

@@ -1,8 +1,22 @@
+import type { Container } from "@webiny/di";
 import { HttpRouter } from "../../features/http/abstractions.js";
-import type { IHttpRoute, IHttpRequest, IHttpResponse } from "../../features/http/abstractions.js";
+import type { IHttpRequest, IHttpResponse } from "../../features/http/abstractions.js";
 declare class HttpRouterImplClass implements HttpRouter.Interface {
-    private routes;
-    constructor(routes: IHttpRoute[]);
+    private container;
+    /**
+     * Takes the container so it can build the matched route — and ONLY the matched route.
+     *
+     * A definition declares no dependencies, so resolving all of them to match a path is a handful
+     * of field assignments. Routes used to be resolved as instances just to read their `path`,
+     * which built every one of their dependency graphs on every request: a static-asset request
+     * constructed the whole GraphQL engine, every contextual schema and the AI provider before
+     * discovering it wanted none of them.
+     *
+     * `resolveImplementation` asks for exactly the matched route's class: it reads that route's
+     * dependencies from its own metadata, resolves them here, and applies decorators registered
+     * for `HttpRouteHandler`, so a route stays decoratable.
+     */
+    constructor(container: Container);
     route(request: IHttpRequest): Promise<IHttpResponse>;
     private match;
 }

package/features/http/HttpRouter.js

@@ -1,4 +1,7 @@
-import { HttpRoute, HttpRouter, RouteNotFoundError } from "./abstractions.js";
+import { HttpRouteDefinition, HttpRouter, RouteNotFoundError } from "./abstractions.js";
+import { HttpResponseBuilder } from "./HttpResponseBuilder.js";
+import { toHttpResponse } from "./invokeHttpRoute.js";
+import { RequestContainer } from "../events/RequestContainer.js";
 function matchPath(pattern, path) {
     if (pattern.endsWith("/*")) {
         const prefix = pattern.slice(0, -2);
@@ -17,33 +20,37 @@ function matchPath(pattern, path) {
     return params;
 }
 class HttpRouterImplClass {
-    constructor(routes){
-        this.routes = routes;
+    constructor(container){
+        this.container = container;
     }
     async route(request) {
-        for (const route of this.routes){
-            const params = this.match(route, request);
-            if (null !== params) return route.handle({
+        for (const definition of this.container.resolveAll(HttpRouteDefinition)){
+            const params = this.match(definition, request);
+            if (null === params) continue;
+            const route = this.container.resolveImplementation(definition.handler);
+            const response = new HttpResponseBuilder();
+            const result = await route.handle({
                 ...request,
-                pathParameters: params
-            });
+                pathParameters: params,
+                route: {
+                    name: definition.name,
+                    method: definition.method,
+                    path: definition.path
+                }
+            }, response);
+            return toHttpResponse(result, response);
         }
         throw new RouteNotFoundError(request.method, request.path);
     }
-    match(route, request) {
-        if (route.method !== request.method) return null;
-        return matchPath(route.path, request.path);
+    match(definition, request) {
+        if (definition.method !== request.method) return null;
+        return matchPath(definition.path, request.path);
     }
 }
 const HttpRouterImpl = HttpRouter.createImplementation({
     implementation: HttpRouterImplClass,
     dependencies: [
-        [
-            HttpRoute,
-            {
-                multiple: true
-            }
-        ]
+        RequestContainer
     ]
 });
 export { HttpRouterImpl };

package/features/http/HttpRouter.js.map

@@ -1 +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"}
+{"version":3,"file":"features/http/HttpRouter.js","sources":["../../../src/features/http/HttpRouter.ts"],"sourcesContent":["import type { Container } from \"@webiny/di\";\nimport {\n    HttpRouter,\n    HttpRouteDefinition,\n    RouteNotFoundError\n} from \"~/features/http/abstractions.js\";\nimport { HttpResponseBuilder } from \"~/features/http/HttpResponseBuilder.js\";\nimport { toHttpResponse } from \"~/features/http/invokeHttpRoute.js\";\nimport { RequestContainer } from \"~/features/events/RequestContainer.js\";\nimport type {\n    IHttpRouteDefinition,\n    IHttpRequest,\n    IHttpResponse\n} 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    /**\n     * Takes the container so it can build the matched route — and ONLY the matched route.\n     *\n     * A definition declares no dependencies, so resolving all of them to match a path is a handful\n     * of field assignments. Routes used to be resolved as instances just to read their `path`,\n     * which built every one of their dependency graphs on every request: a static-asset request\n     * constructed the whole GraphQL engine, every contextual schema and the AI provider before\n     * discovering it wanted none of them.\n     *\n     * `resolveImplementation` asks for exactly the matched route's class: it reads that route's\n     * dependencies from its own metadata, resolves them here, and applies decorators registered\n     * for `HttpRouteHandler`, so a route stays decoratable.\n     */\n    constructor(private container: Container) {}\n\n    async route(request: IHttpRequest): Promise<IHttpResponse> {\n        for (const definition of this.container.resolveAll(HttpRouteDefinition)) {\n            const params = this.match(definition, request);\n            if (params === null) {\n                continue;\n            }\n\n            const route = this.container.resolveImplementation(definition.handler);\n            const response = new HttpResponseBuilder();\n            const result = await route.handle(\n                {\n                    ...request,\n                    pathParameters: params,\n                    // Lets a route — or anything wrapping one — know which route is running.\n                    route: {\n                        name: definition.name,\n                        method: definition.method,\n                        path: definition.path\n                    }\n                },\n                response\n            );\n            return toHttpResponse(result, response);\n        }\n        throw new RouteNotFoundError(request.method, request.path);\n    }\n\n    private match(\n        definition: IHttpRouteDefinition,\n        request: IHttpRequest\n    ): Record<string, string> | null {\n        if (definition.method !== request.method) {\n            return null;\n        }\n        return matchPath(definition.path, request.path);\n    }\n}\n\nexport const HttpRouterImpl = HttpRouter.createImplementation({\n    implementation: HttpRouterImplClass,\n    dependencies: [RequestContainer]\n});\n"],"names":["matchPath","pattern","path","prefix","patternParts","Boolean","pathParts","params","i","pp","pathPart","decodeURIComponent","HttpRouterImplClass","container","request","definition","HttpRouteDefinition","route","response","HttpResponseBuilder","result","toHttpResponse","RouteNotFoundError","HttpRouterImpl","HttpRouter","RequestContainer"],"mappings":";;;;AAeA,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;IAcF,YAAoBC,SAAoB,CAAE;aAAtBA,SAAS,GAATA;IAAuB;IAE3C,MAAM,MAAMC,OAAqB,EAA0B;QACvD,KAAK,MAAMC,cAAc,IAAI,CAAC,SAAS,CAAC,UAAU,CAACC,qBAAsB;YACrE,MAAMT,SAAS,IAAI,CAAC,KAAK,CAACQ,YAAYD;YACtC,IAAIP,AAAW,SAAXA,QACA;YAGJ,MAAMU,QAAQ,IAAI,CAAC,SAAS,CAAC,qBAAqB,CAACF,WAAW,OAAO;YACrE,MAAMG,WAAW,IAAIC;YACrB,MAAMC,SAAS,MAAMH,MAAM,MAAM,CAC7B;gBACI,GAAGH,OAAO;gBACV,gBAAgBP;gBAEhB,OAAO;oBACH,MAAMQ,WAAW,IAAI;oBACrB,QAAQA,WAAW,MAAM;oBACzB,MAAMA,WAAW,IAAI;gBACzB;YACJ,GACAG;YAEJ,OAAOG,eAAeD,QAAQF;QAClC;QACA,MAAM,IAAII,mBAAmBR,QAAQ,MAAM,EAAEA,QAAQ,IAAI;IAC7D;IAEQ,MACJC,UAAgC,EAChCD,OAAqB,EACQ;QAC7B,IAAIC,WAAW,MAAM,KAAKD,QAAQ,MAAM,EACpC,OAAO;QAEX,OAAOd,UAAUe,WAAW,IAAI,EAAED,QAAQ,IAAI;IAClD;AACJ;AAEO,MAAMS,iBAAiBC,WAAW,oBAAoB,CAAC;IAC1D,gBAAgBZ;IAChB,cAAc;QAACa;KAAiB;AACpC"}