@decohere/http 0.0.1-dev.116

package/commonjs/src/routing/decorators/auth.decorator.js

@@ -0,0 +1,70 @@
+"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 AllowAnonymous () {
+        return AllowAnonymous;
+    },
+    get Authorize () {
+        return Authorize;
+    },
+    get CurrentUser () {
+        return CurrentUser;
+    },
+    get getAuthorizeOptions () {
+        return getAuthorizeOptions;
+    },
+    get isAllowAnonymous () {
+        return isAllowAnonymous;
+    }
+});
+const _reflection = require("@decohere/core/reflection");
+const _const = require("../../const.js");
+function Authorize(action, subject = "all") {
+    const options = {
+        action,
+        subject
+    };
+    return (target, methodName, _descriptor)=>{
+        if (methodName) {
+            const fn = target[methodName];
+            (0, _reflection.defineMeta)(_const.MetadataKeys.authorize, options, fn);
+        } else {
+            (0, _reflection.defineMeta)(_const.MetadataKeys.authorize, options, target.prototype);
+        }
+    };
+}
+function AllowAnonymous() {
+    return (target, methodName, _descriptor)=>{
+        const fn = target[methodName];
+        (0, _reflection.defineMeta)(_const.MetadataKeys.allowAnonymous, true, fn);
+    };
+}
+function getAuthorizeOptions(controllerPrototype, handlerFn) {
+    // Method-level overrides class-level
+    const methodLevel = (0, _reflection.getMeta)(_const.MetadataKeys.authorize, handlerFn);
+    if (methodLevel !== undefined) return methodLevel;
+    return (0, _reflection.getMeta)(_const.MetadataKeys.authorize, controllerPrototype);
+}
+function isAllowAnonymous(_controllerPrototype, handlerFn) {
+    return (0, _reflection.getMeta)(_const.MetadataKeys.allowAnonymous, handlerFn) === true;
+}
+function CurrentUser() {
+    return (target, propertyKey, parameterIndex)=>{
+        const fn = target[propertyKey];
+        const meta = {
+            argumentIndex: parameterIndex,
+            argumentLocation: "principal",
+            mappingKey: undefined,
+            pipes: []
+        };
+        (0, _reflection.defineArgumentMeta)(_const.MetadataKeys.parameter, meta, fn, parameterIndex);
+    };
+}

package/commonjs/src/routing/decorators/controller.decorator.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "Controller", {
+    enumerable: true,
+    get: function() {
+        return Controller;
+    }
+});
+const _const = require("../../const.js");
+function Controller(options) {
+    return (target)=>{
+        Reflect.defineMetadata(_const.MetadataKeys.controller, options, target.prototype);
+    };
+}

package/commonjs/src/routing/decorators/field.decorator.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "Field", {
+    enumerable: true,
+    get: function() {
+        return Field;
+    }
+});
+const _reflection = require("@decohere/core/reflection");
+const _const = require("../../const.js");
+function Field(fieldLocation, mappingKey) {
+    return (target, fieldName)=>{
+        const fieldMap = (0, _reflection.getMeta)(_const.MetadataKeys.fieldMap, target) ?? new Map();
+        const fieldType = (0, _reflection.getFieldType)(target, fieldName);
+        fieldMap.set(fieldName, {
+            fieldKey: fieldName,
+            mappingKey,
+            fieldType,
+            fieldLocation
+        });
+        (0, _reflection.defineMeta)(_const.MetadataKeys.fieldMap, fieldMap, target);
+    };
+}

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./argument.decorator.js"), exports);
+_export_star(require("./auth.decorator.js"), exports);
+_export_star(require("./controller.decorator.js"), exports);
+_export_star(require("./field.decorator.js"), exports);
+_export_star(require("./request.decorator.js"), exports);
+_export_star(require("./response.decorator.js"), exports);
+_export_star(require("./route.decorator.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/decorators/request.decorator.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "Request", {
+    enumerable: true,
+    get: function() {
+        return Request;
+    }
+});
+const _reflection = require("@decohere/core/reflection");
+const _const = require("../../const.js");
+function Request(mappingKey) {
+    return (target)=>{
+        const inst = new target();
+        const fieldMap = (0, _reflection.getMeta)(_const.MetadataKeys.fieldMap, target.prototype) ?? new Map();
+        const fields = (0, _reflection.getFields)(inst);
+        for (const field of fields){
+            const fieldType = (0, _reflection.getFieldType)(target.prototype, field.key);
+            const overrides = fieldMap.get(field.key);
+            fieldMap.set(field.key, {
+                fieldKey: field.key,
+                mappingKey: overrides?.mappingKey ?? field.key,
+                fieldType: overrides?.fieldType ?? fieldType,
+                fieldLocation: overrides?.fieldLocation ?? mappingKey
+            });
+        }
+        (0, _reflection.defineMeta)(_const.MetadataKeys.fieldMap, fieldMap, target.prototype);
+    };
+}

package/commonjs/src/routing/decorators/response.decorator.js

@@ -0,0 +1,34 @@
+"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 Header () {
+        return Header;
+    },
+    get HttpCode () {
+        return HttpCode;
+    }
+});
+const _reflection = require("@decohere/core/reflection");
+const _const = require("../../const.js");
+function HttpCode(statusCode) {
+    return (_target, _methodName, descriptor)=>{
+        (0, _reflection.defineMeta)(_const.MetadataKeys.httpCode, statusCode, descriptor.value);
+    };
+}
+function Header(name, value) {
+    return (_target, _methodName, descriptor)=>{
+        const existing = (0, _reflection.getMeta)(_const.MetadataKeys.headers, descriptor.value) ?? {};
+        (0, _reflection.defineMeta)(_const.MetadataKeys.headers, {
+            ...existing,
+            [name]: value
+        }, descriptor.value);
+    };
+}

package/commonjs/src/routing/decorators/route.decorator.js

@@ -0,0 +1,67 @@
+"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 Delete () {
+        return Delete;
+    },
+    get Get () {
+        return Get;
+    },
+    get Patch () {
+        return Patch;
+    },
+    get Post () {
+        return Post;
+    },
+    get Put () {
+        return Put;
+    },
+    get Route () {
+        return Route;
+    }
+});
+const _reflection = require("@decohere/core/reflection");
+const _const = require("../../const.js");
+const _anviltypes = require("../anvil.types.js");
+function Get(path) {
+    return routeDecorator(_const.HTTPMethods.GET, path);
+}
+function Post(path) {
+    return routeDecorator(_const.HTTPMethods.POST, path);
+}
+function Put(path) {
+    return routeDecorator(_const.HTTPMethods.PUT, path);
+}
+function Patch(path) {
+    return routeDecorator(_const.HTTPMethods.PATCH, path);
+}
+function Delete(path) {
+    return routeDecorator(_const.HTTPMethods.DELETE, path);
+}
+function Route(method, path) {
+    return routeDecorator(method, path);
+}
+/**
+ * Store method + relative path only. Controller / global prefixes are applied
+ * at registration time in RouteRegistry (avoids TS decorator-order issues).
+ */ function routeDecorator(method, path = "") {
+    return (targetClass, functionName, descriptor)=>{
+        if (path !== "" && !path.startsWith("/")) {
+            throw new _anviltypes.RouteConfigurationError(`Error configuring routes. Path defined in controller ${targetClass.constructor.name}.${functionName}() should start '/'`);
+        }
+        const { value: handler } = descriptor;
+        const routeConfig = {
+            method,
+            path
+        };
+        (0, _reflection.defineMeta)(_const.MetadataKeys.route, routeConfig, handler);
+    };
+}

package/commonjs/src/routing/filters/exception-filter-host.js

@@ -0,0 +1,145 @@
+"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 DefaultHttpExceptionFilter () {
+        return DefaultHttpExceptionFilter;
+    },
+    get ExceptionFilterHost () {
+        return ExceptionFilterHost;
+    }
+});
+const _crucible = require("@decohere/crucible");
+const _decorators = require("@decohere/crucible/decorators");
+const _scribe = require("@decohere/scribe");
+const _const = require("../../const.js");
+const _anviltypes = require("../anvil.types.js");
+const _exceptionfilter = require("./exception-filter.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 DefaultHttpExceptionFilter {
+    logger = _scribe.scribe.logger(DefaultHttpExceptionFilter.name);
+    catch(error, _ctx) {
+        if (error instanceof _anviltypes.ValidationError) {
+            return {
+                status: 400,
+                body: {
+                    statusCode: 400,
+                    error: "Bad Request",
+                    message: error.message,
+                    errors: error.errors
+                }
+            };
+        }
+        if (error instanceof _anviltypes.HttpError) {
+            // Never expose internal auth failure details (header shape, issuer, etc.) to clients.
+            if (error.status === 401) {
+                this.logger.warn(error.message);
+                return {
+                    status: 401,
+                    body: {
+                        message: "Unauthorized"
+                    }
+                };
+            }
+            // Sanitize only true 500s. Keep intentional 503 probe messages (e.g. /ready).
+            if (error.status === 500) {
+                this.logger.error(error.message);
+                return {
+                    status: 500,
+                    body: {
+                        message: "Internal Server Error"
+                    }
+                };
+            }
+            return {
+                status: error.status,
+                body: {
+                    message: error.message
+                }
+            };
+        }
+        if (error instanceof Error) {
+            this.logger.error(error.message, error.stack);
+            return {
+                status: 500,
+                body: {
+                    message: "Internal Server Error"
+                }
+            };
+        }
+        return {
+            status: 500,
+            body: {
+                message: "Internal Server Error"
+            }
+        };
+    }
+}
+DefaultHttpExceptionFilter = _ts_decorate([
+    (0, _decorators.injectable)()
+], DefaultHttpExceptionFilter);
+class ExceptionFilterHost {
+    options;
+    scope;
+    filters;
+    constructor(options, scope){
+        this.options = options;
+        this.scope = scope;
+    }
+    async handle(error, ctx) {
+        for (const filter of this.getFilters()){
+            const filterType = filter.constructor;
+            const types = (0, _exceptionfilter.getCatchTypes)(filterType);
+            if (types.length === 0 || types.some((t)=>error instanceof t)) {
+                return await filter.catch(error, ctx);
+            }
+        }
+        return new DefaultHttpExceptionFilter().catch(error, ctx);
+    }
+    getFilters() {
+        if (this.filters != null) {
+            return this.filters;
+        }
+        const custom = this.options?.filterTypes.map((type)=>{
+            if (this.scope == null) {
+                return new type();
+            }
+            return this.scope.resolve(type);
+        }) ?? [];
+        this.filters = [
+            ...custom,
+            new DefaultHttpExceptionFilter()
+        ];
+        return this.filters;
+    }
+}
+ExceptionFilterHost = _ts_decorate([
+    (0, _decorators.injectable)(),
+    _ts_param(0, (0, _decorators.inject)(_const.HttpOptionsToken)),
+    _ts_param(1, (0, _decorators.inject)(_crucible.LifetimeScopeToken)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof HttpOptions === "undefined" ? Object : HttpOptions,
+        typeof LifetimeScope === "undefined" ? Object : LifetimeScope
+    ])
+], ExceptionFilterHost);

package/commonjs/src/routing/filters/exception-filter.js

@@ -0,0 +1,28 @@
+"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 Catch () {
+        return Catch;
+    },
+    get getCatchTypes () {
+        return getCatchTypes;
+    }
+});
+const _reflection = require("@decohere/core/reflection");
+const _const = require("../../const.js");
+function Catch(...types) {
+    return (target)=>{
+        (0, _reflection.defineMeta)(_const.MetadataKeys.catch, types, target);
+    };
+}
+function getCatchTypes(filterType) {
+    return (0, _reflection.getMeta)(_const.MetadataKeys.catch, filterType) ?? [];
+}

package/commonjs/src/routing/index.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./anvil.types.js"), exports);
+_export_star(require("./decorators/index.js"), exports);
+_export_star(require("./filters/exception-filter.js"), exports);
+_export_star(require("./filters/exception-filter-host.js"), exports);
+_export_star(require("./middleware/http-access-log.middleware.js"), exports);
+_export_star(require("./middleware/middleware.js"), exports);
+_export_star(require("./middleware/request-id.js"), exports);
+_export_star(require("./pipes/index.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/middleware/http-access-log.middleware.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "HttpAccessLogMiddleware", {
+    enumerable: true,
+    get: function() {
+        return HttpAccessLogMiddleware;
+    }
+});
+const _decorators = require("@decohere/crucible/decorators");
+const _scribe = require("@decohere/scribe");
+const _anviltypes = require("../anvil.types.js");
+const _requestid = require("./request-id.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;
+}
+class HttpAccessLogMiddleware {
+    async use(ctx, next) {
+        const logger = _scribe.scribe.logger(HttpAccessLogMiddleware.name);
+        const start = performance.now();
+        ctx.request.responseHeaders[_requestid.REQUEST_ID_HEADER] = ctx.request.requestId;
+        let status = ctx.route.httpCode ?? 200;
+        try {
+            return await next();
+        } catch (error) {
+            status = error instanceof _anviltypes.HttpError ? error.status : 500;
+            throw error;
+        } finally{
+            const durationMs = Math.round(performance.now() - start);
+            logger.info({
+                msg: "access",
+                method: ctx.request.method,
+                path: ctx.request.url,
+                status,
+                durationMs,
+                requestId: ctx.request.requestId
+            });
+        }
+    }
+}
+HttpAccessLogMiddleware = _ts_decorate([
+    (0, _decorators.injectable)()
+], HttpAccessLogMiddleware);

package/commonjs/src/routing/middleware/middleware.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "composeMiddleware", {
+    enumerable: true,
+    get: function() {
+        return composeMiddleware;
+    }
+});
+function composeMiddleware(middlewares, handler, ctx) {
+    const dispatch = (index)=>{
+        if (index >= middlewares.length) {
+            return handler();
+        }
+        const middleware = middlewares[index];
+        return middleware.use(ctx, ()=>dispatch(index + 1));
+    };
+    return dispatch(0);
+}

package/commonjs/src/routing/middleware/request-id.js

@@ -0,0 +1,30 @@
+"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 REQUEST_ID_HEADER () {
+        return REQUEST_ID_HEADER;
+    },
+    get resolveRequestId () {
+        return resolveRequestId;
+    }
+});
+const _nodecrypto = require("node:crypto");
+const REQUEST_ID_HEADER = "x-request-id";
+function resolveRequestId(headers, fallback) {
+    const fromHeader = headers[REQUEST_ID_HEADER]?.trim();
+    if (fromHeader) {
+        return fromHeader;
+    }
+    if (fallback?.trim()) {
+        return fallback.trim();
+    }
+    return (0, _nodecrypto.randomUUID)();
+}

package/commonjs/src/routing/path.util.js

@@ -0,0 +1,51 @@
+/** Normalize a prefix to `/foo` form with no trailing slash. Empty → `""`. */ "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 applyGlobalPrefix () {
+        return applyGlobalPrefix;
+    },
+    get joinRoutePath () {
+        return joinRoutePath;
+    },
+    get normalizePrefix () {
+        return normalizePrefix;
+    }
+});
+function normalizePrefix(prefix) {
+    if (prefix == null || prefix === "" || prefix === "/") {
+        return "";
+    }
+    const withSlash = prefix.startsWith("/") ? prefix : `/${prefix}`;
+    return withSlash.replace(/\/+$/, "");
+}
+function joinRoutePath(prefix, routePath) {
+    const p = normalizePrefix(prefix);
+    if (routePath === "" || routePath == null) {
+        return p === "" ? "/" : p;
+    }
+    if (routePath === "/") {
+        return p === "" ? "/" : `${p}/`;
+    }
+    if (!routePath.startsWith("/")) {
+        throw new Error(`Route path must start with '/': ${routePath}`);
+    }
+    return `${p}${routePath}`;
+}
+function applyGlobalPrefix(globalPrefix, path) {
+    const g = normalizePrefix(globalPrefix);
+    if (g === "") {
+        return path === "" ? "/" : path;
+    }
+    if (path === "/") {
+        return `${g}/`;
+    }
+    return `${g}${path.startsWith("/") ? path : `/${path}`}`;
+}

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./pipes.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;
+}