@decohere/http 0.0.1-dev.130 → 0.0.1-dev.20261105.103

package/commonjs/src/routing/pipes/pipes.js

@@ -1,145 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: Object.getOwnPropertyDescriptor(all, name).get
-    });
-}
-_export(exports, {
-    get BooleanPipe () {
-        return BooleanPipe;
-    },
-    get DatePipe () {
-        return DatePipe;
-    },
-    get JsonPipe () {
-        return JsonPipe;
-    },
-    get NumberPipe () {
-        return NumberPipe;
-    },
-    get Pipe () {
-        return Pipe;
-    }
-});
-const _reflection = require("@decohere/core/reflection");
-const _httptypes = require("../http.types.js");
-const invalidBooleanIssue = {
-    path: "/value",
-    message: "Invalid boolean",
-    keyword: "type"
-};
-const invalidNumberIssue = {
-    path: "/value",
-    message: "Invalid number",
-    keyword: "type"
-};
-const invalidDateIssue = {
-    path: "/value",
-    message: "Invalid date",
-    keyword: "format"
-};
-class Pipe {
-}
-class BooleanPipe extends Pipe {
-    transform(value, _context) {
-        if (typeof value === "boolean") {
-            return value;
-        }
-        const normalized = typeof value === "string" ? value.trim().toLowerCase() : value;
-        switch(normalized){
-            case "true":
-            case "1":
-            case 1:
-                return true;
-            case "false":
-            case "0":
-            case 0:
-                return false;
-            default:
-                throw new _httptypes.ValidationError("Validation failed", [
-                    invalidBooleanIssue
-                ]);
-        }
-    }
-}
-class DatePipe extends Pipe {
-    transform(value, _context) {
-        if (value instanceof Date) {
-            if (Number.isNaN(value.getTime())) {
-                throw new _httptypes.ValidationError("Validation failed", [
-                    invalidDateIssue
-                ]);
-            }
-            return value;
-        }
-        if (typeof value === "string") {
-            const trimmed = value.trim();
-            if (trimmed === "") {
-                throw new _httptypes.ValidationError("Validation failed", [
-                    invalidDateIssue
-                ]);
-            }
-            if (/^-?\d+(\.\d+)?$/.test(trimmed)) {
-                return new Date(Number(trimmed));
-            }
-            const parsed = new Date(trimmed);
-            if (Number.isNaN(parsed.getTime())) {
-                throw new _httptypes.ValidationError("Validation failed", [
-                    invalidDateIssue
-                ]);
-            }
-            return parsed;
-        }
-        if (typeof value === "number" && !Number.isNaN(value)) {
-            return new Date(value);
-        }
-        throw new _httptypes.ValidationError("Validation failed", [
-            invalidDateIssue
-        ]);
-    }
-}
-class JsonPipe extends Pipe {
-    transform(value, context) {
-        try {
-            const obj = JSON.parse(value, (fieldKey, fieldValue)=>{
-                const val = this.reviver(context?.fieldTypes, fieldKey, fieldValue);
-                return val;
-            });
-            return obj;
-        } catch (err) {
-            throw new _httptypes.TransformError(`Error parsing json ${err}`);
-        }
-    }
-    reviver(fieldTypes, fieldKey, value) {
-        if (!fieldKey) {
-            return value;
-        }
-        if (!fieldTypes) {
-            return value;
-        }
-        const fieldType = fieldTypes[fieldKey];
-        if (fieldType == null) {
-            return value;
-        }
-        if (!(0, _reflection.isDateType)(fieldType)) {
-            return value;
-        }
-        return new Date(value.toString());
-    }
-}
-class NumberPipe extends Pipe {
-    /** Finite numbers only. Blank or non-numeric input is a 400, not `undefined`. */ transform(value, _context) {
-        const text = typeof value === "number" ? null : String(value).trim();
-        const number = text == null ? value : text === "" ? Number.NaN : Number(text);
-        if (!Number.isFinite(number)) {
-            throw new _httptypes.ValidationError("Validation failed", [
-                invalidNumberIssue
-            ]);
-        }
-        return number;
-    }
-}

package/commonjs/src/routing/services/index.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-_export_star(require("./router.js"), exports);
-function _export_star(from, to) {
-    Object.keys(from).forEach(function(k) {
-        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
-            Object.defineProperty(to, k, {
-                enumerable: true,
-                get: function() {
-                    return from[k];
-                }
-            });
-        }
-    });
-    return from;
-}

package/commonjs/src/routing/services/route-argument-resolver.js

@@ -1,77 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "RouteArgumentResolve", {
-    enumerable: true,
-    get: function() {
-        return RouteArgumentResolve;
-    }
-});
-const _reflection = require("@decohere/core/reflection");
-class RouteArgumentResolve {
-    resolveArguments(httpRequest, routeArgs, principalProvider) {
-        const argsValues = [];
-        for (const [argIdx, routeArg] of routeArgs.entries()){
-            const val = this.getValue(httpRequest, routeArg, principalProvider);
-            argsValues[argIdx] = val;
-        }
-        return argsValues;
-    }
-    getValue(httpRequest, routeArg, principalProvider) {
-        switch(routeArg.argumentLocation){
-            case "principal":
-                return principalProvider?.currentPrincipal;
-            case "signal":
-                return httpRequest.signal;
-            case "lastEventId":
-                return httpRequest.headers["last-event-id"];
-        }
-        const value = (0, _reflection.isPrimitiveOrDateType)(routeArg.argumentType) ? this.mapPrimitive(httpRequest, routeArg) : this.mapObject(httpRequest, routeArg);
-        return value;
-    }
-    mapPrimitive(httpRequest, routeArg) {
-        const { argumentLocation, mappingKey, pipes } = routeArg;
-        const value = httpRequest[argumentLocation][mappingKey];
-        const tranformedValue = this.transform(value, pipes, routeArg.fieldMap);
-        return tranformedValue;
-    }
-    mapObject(httpRequest, routeArg) {
-        const { argumentType } = routeArg;
-        const inst = new argumentType();
-        const { fieldMap } = routeArg;
-        for (const [fieldKey, meta] of fieldMap.entries()){
-            const { fieldLocation, mappingKey, pipes } = meta;
-            const value = httpRequest[fieldLocation][mappingKey];
-            const transformedValue = this.transform(value, pipes, fieldMap);
-            inst[fieldKey] = transformedValue;
-        }
-        return inst;
-    }
-    transform(value, pipes, fieldMap) {
-        let transformed = value;
-        if (value == null) {
-            return value;
-        }
-        const context = this.pipeContext(fieldMap);
-        for (const pipeConstructor of pipes ?? []){
-            const pipe = new pipeConstructor();
-            transformed = pipe.transform(transformed, context);
-        }
-        return transformed;
-    }
-    pipeContext(fieldMap) {
-        if (fieldMap == null || fieldMap.size === 0) {
-            return undefined;
-        }
-        const fieldTypes = {};
-        for (const [key, meta] of fieldMap.entries()){
-            if (meta.fieldType != null) {
-                fieldTypes[key] = meta.fieldType;
-            }
-        }
-        return Object.keys(fieldTypes).length > 0 ? {
-            fieldTypes
-        } : undefined;
-    }
-}

package/commonjs/src/routing/services/route-registry.js

@@ -1,194 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "RouteRegistry", {
-    enumerable: true,
-    get: function() {
-        return RouteRegistry;
-    }
-});
-const _decorators = require("@decohere/crucible/decorators");
-const _reflection = require("@decohere/core/reflection");
-const _const = require("../../const.js");
-const _httptypes = require("../http.types.js");
-const _pathutil = require("../path.util.js");
-const _pipes = require("../pipes/pipes.js");
-function _ts_decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-function _ts_metadata(k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-function _ts_param(paramIndex, decorator) {
-    return function(target, key) {
-        decorator(target, key, paramIndex);
-    };
-}
-class RouteRegistry {
-    routeMap = new Map();
-    httpOptions;
-    constructor(httpOptions){
-        this.httpOptions = httpOptions;
-    }
-    addController(controller) {
-        const funcs = (0, _reflection.getFunctions)(controller);
-        for (const func of funcs){
-            this.addControllerRoute(controller, func);
-        }
-    }
-    get routes() {
-        return this.routeMap.values();
-    }
-    getRoute(key) {
-        return this.routeMap.get(key);
-    }
-    addControllerRoute(controller, prop) {
-        const func = prop.value;
-        const handler = func.name;
-        const route = (0, _reflection.getMeta)(_const.MetadataKeys.route, func);
-        if (route == null) {
-            return;
-        }
-        const globalPrefix = this.takesGlobalPrefix(controller) ? (0, _pathutil.normalizePrefix)(this.httpOptions?.globalPrefix) : "";
-        const controllerPrefix = this.getControllerPrefix(controller);
-        const path = (0, _pathutil.applyGlobalPrefix)(globalPrefix, (0, _pathutil.joinRoutePath)(controllerPrefix, route.path));
-        const { method } = route;
-        const key = `${method}|${path}`;
-        const existing = this.routeMap.get(key);
-        if (existing != null) {
-            // Last one used to win silently, leaving the other handler unreachable.
-            throw new _httptypes.RouteConfigurationError(`Duplicate route ${method.toUpperCase()} ${path}: ${existing.controller.name}.${existing.handler} and ${controller.name}.${handler}`);
-        }
-        const routeArgs = this.getRouteArguments(controller, func);
-        const httpCode = (0, _reflection.getMeta)(_const.MetadataKeys.httpCode, func);
-        const headers = (0, _reflection.getMeta)(_const.MetadataKeys.headers, func);
-        const sse = (0, _reflection.getMeta)(_const.MetadataKeys.sse, func);
-        this.routeMap.set(key, {
-            key,
-            controller,
-            handler,
-            path,
-            method,
-            routeArgs,
-            httpCode,
-            headers,
-            sse
-        });
-    }
-    /** `@Controller({ globalPrefix: false })` opts out, unless the app put it back under. */ takesGlobalPrefix(controller) {
-        const meta = (0, _reflection.getMeta)(_const.MetadataKeys.controller, controller.prototype);
-        return meta?.globalPrefix !== false || this.httpOptions?.underGlobalPrefix.has(controller) === true;
-    }
-    getControllerPrefix(controller) {
-        const meta = (0, _reflection.getMeta)(_const.MetadataKeys.controller, controller.prototype);
-        if (meta?.prefix) {
-            return (0, _pathutil.normalizePrefix)(meta.prefix);
-        }
-        const controllerName = controller.name.toLowerCase().replace("controller", "");
-        return controllerName !== "" ? `/${controllerName}` : "";
-    }
-    getRouteArguments(controller, handler) {
-        const types = (0, _reflection.getFunctionArgs)(controller.prototype, handler) ?? [];
-        const args = [];
-        for (const [argumentIndex, argumentType] of types.entries()){
-            const argMeta = (0, _reflection.getArgumentMeta)(_const.MetadataKeys.parameter, handler, argumentIndex);
-            if (argMeta == null && !(0, _reflection.isConstructable)(argumentType)) {
-                continue;
-            }
-            args.push(this.getRouteArgument(argumentType, argumentIndex, handler));
-        }
-        return args;
-    }
-    getRouteArgument(argumentType, argumentIndex, handler) {
-        const argMeta = (0, _reflection.getArgumentMeta)(_const.MetadataKeys.parameter, handler, argumentIndex);
-        // @CurrentUser() / interface params are Object (or other non-DTO types) — no field map.
-        if (isInjectedPart(argMeta?.argumentLocation) || !(0, _reflection.isConstructable)(argumentType)) {
-            return {
-                ...argMeta,
-                pipes: [],
-                argumentIndex,
-                argumentType: (0, _reflection.isConstructable)(argumentType) ? argumentType : Object,
-                fieldMap: new Map()
-            };
-        }
-        const pipes = argMeta != null ? this.getDefaultPipes(argumentType) : [];
-        const fieldMap = this.getFields(argumentType, argumentIndex, argMeta);
-        const routeArg = {
-            ...argMeta,
-            pipes,
-            argumentIndex,
-            argumentType,
-            fieldMap
-        };
-        return routeArg;
-    }
-    getFields(argumentType, argumentIndex, argMeta) {
-        const inst = new argumentType();
-        const fields = (0, _reflection.getFields)(inst);
-        const fieldMap = (0, _reflection.getMeta)(_const.MetadataKeys.fieldMap, argumentType.prototype) ?? new Map();
-        for (const field of fields){
-            const fieldKey = field.key;
-            const fieldMeta = fieldMap.get(field.key);
-            if (fieldMeta && fieldMeta.fieldLocation == null && argMeta?.argumentLocation == null) {
-                throw new _httptypes.RouteConfigurationError(`field ${fieldMeta.fieldKey} must specify a location because location was not specified for the route argument at idx ${argumentIndex}`);
-            }
-            const enriched = this.enrichField(field, fieldMeta, argMeta);
-            fieldMap.set(fieldKey, enriched);
-        }
-        return fieldMap;
-    }
-    enrichField(field, fieldMeta, argMeta) {
-        const fieldLocation = fieldMeta?.fieldLocation ?? argMeta.argumentLocation;
-        const pipes = this.getDefaultPipes(fieldMeta?.fieldType);
-        return {
-            fieldKey: field.key,
-            mappingKey: field.key,
-            ...fieldMeta,
-            fieldLocation,
-            pipes
-        };
-    }
-    getDefaultPipes(argumentType) {
-        if (argumentType == null) {
-            return [];
-        }
-        let pipe;
-        if (!(0, _reflection.isPrimitiveOrDateType)(argumentType)) {
-            pipe = _pipes.JsonPipe;
-            return [
-                pipe
-            ];
-        }
-        switch(argumentType.name){
-            case "Number":
-                pipe = _pipes.NumberPipe;
-                break;
-            case "Boolean":
-                pipe = _pipes.BooleanPipe;
-                break;
-            case "Date":
-                pipe = _pipes.DatePipe;
-                break;
-            default:
-                return [];
-        }
-        return [
-            pipe
-        ];
-    }
-}
-RouteRegistry = _ts_decorate([
-    (0, _decorators.injectable)(),
-    _ts_param(0, (0, _decorators.inject)(_const.HttpOptionsToken)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof HttpOptions === "undefined" ? Object : HttpOptions
-    ])
-], RouteRegistry);
-function isInjectedPart(location) {
-    return location != null && _httptypes.InjectedParts.includes(location);
-}

package/commonjs/src/routing/services/router.js

@@ -1,158 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "Router", {
-    enumerable: true,
-    get: function() {
-        return Router;
-    }
-});
-const _crucible = require("@decohere/crucible");
-const _decorators = require("@decohere/crucible/decorators");
-const _scribe = require("@decohere/scribe");
-const _const = require("../../const.js");
-const _requestvalidator = require("../../openapi/request-validator.js");
-const _ssetypes = require("../../sse/sse.types.js");
-const _httptypes = require("../http.types.js");
-const _authdecorator = require("../decorators/auth.decorator.js");
-const _middleware = require("../middleware/middleware.js");
-const _routeargumentresolver = require("./route-argument-resolver.js");
-const _routeregistry = require("./route-registry.js");
-function _ts_decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-function _ts_metadata(k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-function _ts_param(paramIndex, decorator) {
-    return function(target, key) {
-        decorator(target, key, paramIndex);
-    };
-}
-class Router {
-    argResolver = new _routeargumentresolver.RouteArgumentResolve();
-    lifetimeScope;
-    routeRegistry;
-    authService;
-    httpOptions;
-    logger = _scribe.scribe.logger(Router.name);
-    constructor(routeRegistry, lifetimeScope, authService, httpOptions){
-        this.routeRegistry = routeRegistry;
-        this.lifetimeScope = lifetimeScope;
-        this.authService = authService;
-        this.httpOptions = httpOptions;
-        this.assertAuthConfiguredForProtectedRoutes();
-    }
-    /**
-	 * Without an authorization service nothing checks tokens, so a route marked @Authorize
-	 * would be served to anyone. Refuse to start instead of failing open.
-	 */ assertAuthConfiguredForProtectedRoutes() {
-        if (this.authService != null) {
-            return;
-        }
-        const protectedRoutes = [
-            ...this.routeRegistry.routes
-        ].filter(({ controller, handler })=>(0, _authdecorator.getAuthorizeOptions)(controller.prototype, controller.prototype[handler])).map(({ controller, handler })=>`${controller.name}.${String(handler)}`);
-        if (protectedRoutes.length > 0) {
-            throw new _httptypes.RoutingError(`Routes use @Authorize but auth is not configured, so they would be open to anyone: ${protectedRoutes.join(", ")}. Add .withAuth() to the builder, or remove @Authorize.`);
-        }
-    }
-    async route(routeKey, httpRequest) {
-        const routeConfig = this.routeRegistry.getRoute(routeKey);
-        if (!routeConfig) {
-            throw new _httptypes.RoutingError(`Route was not configured for key ${routeKey}`);
-        }
-        const { controller, handler, routeArgs } = routeConfig;
-        // Unnamed: the request id comes from the client, so it is not unique.
-        // Disposed before we respond, so async cleanup (e.g. rolling back a DB transaction)
-        // finishes first. An SSE route is the exception: its scope lives as long as the stream.
-        const scope = this.lifetimeScope.beginScope();
-        let scopeHandedOff = false;
-        // Runs inside the middleware chain so rejections (401/403/400) reach middleware such as
-        // the access log. Auth comes first so anonymous callers learn nothing about the body.
-        const handle = async ()=>{
-            const principal = await this.authorize(routeConfig, httpRequest);
-            if (this.httpOptions?.openapi?.validateRequests !== false && this.httpOptions?.openapi) {
-                (0, _requestvalidator.validateRequest)(routeConfig, httpRequest);
-            }
-            const provider = scope.resolve(_const.IPrincipalProviderToken);
-            provider.setPrincipal(principal);
-            const controllerInstance = scope.resolve(controller);
-            const func = controllerInstance[handler];
-            const argValues = this.argResolver.resolveArguments(httpRequest, routeArgs, provider);
-            try {
-                const result = await func.apply(controllerInstance, argValues);
-                if (routeConfig.sse == null) {
-                    return result;
-                }
-                if (typeof result?.[Symbol.asyncIterator] !== "function") {
-                    throw new _httptypes.RoutingError(`${controller.name}.${String(handler)} is marked @Sse() so it must return an AsyncIterable (an async generator method works)`);
-                }
-                scopeHandedOff = true;
-                return new _ssetypes.SseResponse(result, ()=>scope[Symbol.asyncDispose]());
-            } catch (error) {
-                this.logger.error(error.message, error.stack);
-                throw error;
-            }
-        };
-        try {
-            const middlewares = this.resolveMiddlewares(scope);
-            if (middlewares.length === 0) {
-                return await handle();
-            }
-            return await (0, _middleware.composeMiddleware)(middlewares, handle, {
-                request: httpRequest,
-                route: routeConfig
-            });
-        } catch (error) {
-            // A middleware failed after the handler returned: nobody will consume the stream.
-            scopeHandedOff = false;
-            throw error;
-        } finally{
-            if (!scopeHandedOff) {
-                await scope[Symbol.asyncDispose]();
-            }
-        }
-    }
-    resolveMiddlewares(scope) {
-        const types = this.httpOptions?.middlewareTypes ?? [];
-        return types.map((type)=>scope.resolve(type));
-    }
-    async authorize(routeConfig, httpRequest) {
-        // Optional DI may resolve as null when auth is not registered.
-        if (this.authService == null) {
-            return;
-        }
-        const { controller, handler } = routeConfig;
-        const handlerFn = controller.prototype[handler];
-        if ((0, _authdecorator.isAllowAnonymous)(controller.prototype, handlerFn)) {
-            return;
-        }
-        const authOptions = (0, _authdecorator.getAuthorizeOptions)(controller.prototype, handlerFn);
-        if (authOptions === undefined) {
-            // Auth is enabled but the route has no @Authorize — require a valid
-            // token (fail closed) without checking a specific ability.
-            return this.authService.authenticateRequest(httpRequest);
-        }
-        return this.authService.authorizeRequest(httpRequest, authOptions.action, authOptions.subject);
-    }
-}
-Router = _ts_decorate([
-    (0, _decorators.injectable)(),
-    _ts_param(0, (0, _decorators.inject)(_const.RouteRegistryToken)),
-    _ts_param(1, (0, _decorators.inject)(_crucible.LifetimeScopeToken)),
-    _ts_param(2, (0, _decorators.inject)(_const.AuthorizationServiceToken)),
-    _ts_param(2, (0, _decorators.optional)()),
-    _ts_param(3, (0, _decorators.inject)(_const.HttpOptionsToken)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof _routeregistry.RouteRegistry === "undefined" ? Object : _routeregistry.RouteRegistry,
-        typeof LifetimeScope === "undefined" ? Object : LifetimeScope,
-        typeof IAuthorizationService === "undefined" ? Object : IAuthorizationService,
-        typeof HttpOptions === "undefined" ? Object : HttpOptions
-    ])
-], Router);

package/commonjs/src/sse/index.js

@@ -1,26 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: Object.getOwnPropertyDescriptor(all, name).get
-    });
-}
-_export(exports, {
-    get LastEventId () {
-        return _ssedecorator.LastEventId;
-    },
-    get Signal () {
-        return _ssedecorator.Signal;
-    },
-    get Sse () {
-        return _ssedecorator.Sse;
-    },
-    get SseResponse () {
-        return _ssetypes.SseResponse;
-    }
-});
-const _ssedecorator = require("./sse.decorator.js");
-const _ssetypes = require("./sse.types.js");

package/commonjs/src/sse/sse.decorator.js

@@ -1,42 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: Object.getOwnPropertyDescriptor(all, name).get
-    });
-}
-_export(exports, {
-    get LastEventId () {
-        return LastEventId;
-    },
-    get Signal () {
-        return Signal;
-    },
-    get Sse () {
-        return Sse;
-    }
-});
-const _reflection = require("@decohere/core/reflection");
-const _const = require("../const.js");
-function Sse(options = {}) {
-    return (_target, _methodName, descriptor)=>{
-        (0, _reflection.defineMeta)(_const.MetadataKeys.sse, options, descriptor.value);
-    };
-}
-function injected(location) {
-    return ()=>(target, propertyKey, parameterIndex)=>{
-            const fn = target[propertyKey];
-            const meta = {
-                argumentIndex: parameterIndex,
-                argumentLocation: location,
-                mappingKey: undefined,
-                pipes: []
-            };
-            (0, _reflection.defineArgumentMeta)(_const.MetadataKeys.parameter, meta, fn, parameterIndex);
-        };
-}
-const Signal = injected("signal");
-const LastEventId = injected("lastEventId");