@decohere/http 0.0.1-dev.126 → 0.0.1-dev.5

package/commonjs/src/openapi/index.js

@@ -1,45 +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 ValidationError () {
-        return _requestvalidator.ValidationError;
-    },
-    get buildRouteRequestSchemas () {
-        return _requestschema.buildRouteRequestSchemas;
-    },
-    get generateOpenApiDocument () {
-        return _openapigenerator.generateOpenApiDocument;
-    },
-    get mergeObjectSchemas () {
-        return _requestschema.mergeObjectSchemas;
-    },
-    get objectArgToParts () {
-        return _requestschema.objectArgToParts;
-    },
-    get pathParamsToSchema () {
-        return _requestschema.pathParamsToSchema;
-    },
-    get resolveOpenApiPath () {
-        return _openapigenerator.resolveOpenApiPath;
-    },
-    get toOpenApiPath () {
-        return _openapigenerator.toOpenApiPath;
-    },
-    get typeToSchema () {
-        return _requestschema.typeToSchema;
-    },
-    get validateRequest () {
-        return _requestvalidator.validateRequest;
-    }
-});
-const _openapigenerator = require("./openapi.generator.js");
-const _requestschema = require("./request-schema.js");
-const _requestvalidator = require("./request-validator.js");

package/commonjs/src/openapi/openapi.generator.js

@@ -1,103 +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 generateOpenApiDocument () {
-        return generateOpenApiDocument;
-    },
-    get resolveOpenApiPath () {
-        return resolveOpenApiPath;
-    },
-    get toOpenApiPath () {
-        return toOpenApiPath;
-    }
-});
-const _requestschema = require("./request-schema.js");
-const DEFAULT_SPEC_PATH = "/openapi.json";
-function resolveOpenApiPath(options) {
-    const path = options.path?.trim() || DEFAULT_SPEC_PATH;
-    return path.startsWith("/") ? path : `/${path}`;
-}
-function toOpenApiPath(fastifyPath) {
-    return fastifyPath.replace(/:([A-Za-z_][\w]*)/g, "{$1}");
-}
-function generateOpenApiDocument(registry, options) {
-    const paths = {};
-    for (const route of registry.routes){
-        const path = toOpenApiPath(route.path);
-        const method = route.method.toLowerCase();
-        let pathItem = paths[path];
-        if (pathItem == null) {
-            pathItem = {};
-            paths[path] = pathItem;
-        }
-        pathItem[method] = buildOperation(route);
-    }
-    const document = {
-        openapi: "3.0.3",
-        info: options.info,
-        paths
-    };
-    if (options.servers?.length) {
-        document.servers = options.servers;
-    }
-    return document;
-}
-function buildOperation(route) {
-    const { queryParams, pathParams, body: bodySchema } = (0, _requestschema.buildRouteRequestSchemas)(route);
-    const parameters = [
-        ...queryParams,
-        ...pathParams
-    ];
-    const status = String(route.httpCode ?? 200);
-    const operation = {
-        operationId: `${route.controller.name}.${route.handler}`,
-        tags: [
-            route.controller.name
-        ],
-        responses: {
-            [status]: route.sse ? {
-                description: "Server-sent event stream",
-                content: {
-                    "text/event-stream": {
-                        schema: {
-                            type: "string"
-                        }
-                    }
-                }
-            } : {
-                description: "Successful response"
-            }
-        }
-    };
-    if (route.routeArgs?.some((arg)=>arg.argumentLocation === "lastEventId")) {
-        parameters.push({
-            name: "Last-Event-ID",
-            in: "header",
-            schema: {
-                type: "string"
-            }
-        });
-    }
-    if (parameters.length > 0) {
-        operation.parameters = parameters;
-    }
-    if (bodySchema != null) {
-        operation.requestBody = {
-            required: true,
-            content: {
-                "application/json": {
-                    schema: bodySchema
-                }
-            }
-        };
-    }
-    return operation;
-}

package/commonjs/src/openapi/openapi.types.js

@@ -1,4 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});

package/commonjs/src/openapi/request-schema.js

@@ -1,187 +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 buildRouteRequestSchemas () {
-        return buildRouteRequestSchemas;
-    },
-    get mergeObjectSchemas () {
-        return mergeObjectSchemas;
-    },
-    get objectArgToParts () {
-        return objectArgToParts;
-    },
-    get pathParamsToSchema () {
-        return pathParamsToSchema;
-    },
-    get typeToSchema () {
-        return typeToSchema;
-    }
-});
-const _reflection = require("@decohere/core/reflection");
-const _anviltypes = require("../routing/anvil.types.js");
-function buildRouteRequestSchemas(route) {
-    const queryParams = [];
-    const pathParams = [];
-    let bodySchema;
-    for (const routeArg of route.routeArgs ?? []){
-        if (routeArg.argumentLocation != null && _anviltypes.InjectedParts.includes(routeArg.argumentLocation)) {
-            continue;
-        }
-        if ((0, _reflection.isPrimitiveOrDateType)(routeArg.argumentType)) {
-            const location = routeArg.argumentLocation;
-            if (location === "query" || location === "params") {
-                const param = {
-                    name: routeArg.mappingKey ?? "value",
-                    in: location === "params" ? "path" : "query",
-                    required: location === "params",
-                    schema: typeToSchema(routeArg.argumentType.name)
-                };
-                if (location === "params") {
-                    pathParams.push(param);
-                } else {
-                    queryParams.push(param);
-                }
-            }
-            continue;
-        }
-        const parts = objectArgToParts(routeArg);
-        queryParams.push(...parts.queryParams);
-        pathParams.push(...parts.pathParams);
-        if (parts.body != null) {
-            bodySchema = mergeObjectSchemas(bodySchema, parts.body);
-        }
-    }
-    return {
-        queryParams,
-        pathParams,
-        body: bodySchema
-    };
-}
-function objectArgToParts(routeArg) {
-    const queryParams = [];
-    const pathParams = [];
-    const bodyProperties = {};
-    const bodyRequired = [];
-    const argLocation = routeArg.argumentLocation;
-    for (const [, meta] of routeArg.fieldMap?.entries() ?? []){
-        const location = meta.fieldLocation ?? argLocation;
-        const name = meta.mappingKey || meta.fieldKey;
-        const schema = typeToSchema(meta.fieldType?.name);
-        if (location === "query") {
-            queryParams.push({
-                name,
-                in: "query",
-                required: false,
-                schema
-            });
-        } else if (location === "params") {
-            pathParams.push({
-                name,
-                in: "path",
-                required: true,
-                schema
-            });
-        } else if (location === "body" || location == null && argLocation === "body") {
-            bodyProperties[name] = schema;
-            bodyRequired.push(name);
-        } else if (location == null && argLocation == null) {
-            // Unlocated object fields default to body for OpenAPI (common DTO pattern).
-            bodyProperties[name] = schema;
-            bodyRequired.push(name);
-        }
-    }
-    // Whole-object body argument with no fields still advertises an object body.
-    if (argLocation === "body" && Object.keys(bodyProperties).length === 0) {
-        return {
-            queryParams,
-            pathParams,
-            body: {
-                type: "object",
-                additionalProperties: true
-            }
-        };
-    }
-    const body = Object.keys(bodyProperties).length > 0 ? {
-        type: "object",
-        properties: bodyProperties,
-        required: bodyRequired,
-        additionalProperties: false
-    } : undefined;
-    return {
-        queryParams,
-        pathParams,
-        body
-    };
-}
-function mergeObjectSchemas(a, b) {
-    if (a == null) {
-        return b;
-    }
-    return {
-        type: "object",
-        properties: {
-            ...a.properties,
-            ...b.properties
-        },
-        required: [
-            ...new Set([
-                ...a.required ?? [],
-                ...b.required ?? []
-            ])
-        ],
-        additionalProperties: false
-    };
-}
-function typeToSchema(typeName) {
-    switch(typeName){
-        case "Number":
-            return {
-                type: "number"
-            };
-        case "Boolean":
-            return {
-                type: "boolean"
-            };
-        case "Date":
-            return {
-                type: "string",
-                format: "date-time"
-            };
-        case "String":
-            return {
-                type: "string"
-            };
-        default:
-            return {};
-    }
-}
-function pathParamsToSchema(params) {
-    if (params.length === 0) {
-        return undefined;
-    }
-    const properties = {};
-    const required = [];
-    for (const param of params){
-        properties[param.name] = {
-            type: "string",
-            minLength: 1
-        };
-        if (param.required !== false) {
-            required.push(param.name);
-        }
-    }
-    return {
-        type: "object",
-        properties,
-        required,
-        additionalProperties: true
-    };
-}

package/commonjs/src/openapi/request-validator.js

@@ -1,85 +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 ValidationError () {
-        return _anviltypes.ValidationError;
-    },
-    get validateRequest () {
-        return validateRequest;
-    }
-});
-const _ajv = require("ajv");
-const _anviltypes = require("../routing/anvil.types.js");
-const _requestschema = require("./request-schema.js");
-function validateRequest(route, request) {
-    const { params, body } = getValidators(route);
-    const issues = [];
-    if (params != null) {
-        collectIssues(params, request.params ?? {}, "/params", issues);
-    }
-    if (body != null) {
-        collectIssues(body, request.body, "/body", issues);
-    }
-    if (issues.length > 0) {
-        throw new _anviltypes.ValidationError("Validation failed", issues);
-    }
-}
-const ajv = new _ajv.Ajv({
-    allErrors: true,
-    coerceTypes: false,
-    removeAdditional: false,
-    useDefaults: false,
-    strict: false
-});
-/**
- * Compiled once per route and reused. Compiling per request was slow, and AJV keeps every
- * schema it compiles, so memory grew with traffic.
- */ const validatorsByRoute = new WeakMap();
-function getValidators(route) {
-    let validators = validatorsByRoute.get(route);
-    if (validators == null) {
-        const schemas = (0, _requestschema.buildRouteRequestSchemas)(route);
-        const paramsSchema = (0, _requestschema.pathParamsToSchema)(schemas.pathParams);
-        validators = {
-            params: paramsSchema != null ? ajv.compile(paramsSchema) : undefined,
-            body: schemas.body != null ? ajv.compile(schemas.body) : undefined
-        };
-        validatorsByRoute.set(route, validators);
-    }
-    return validators;
-}
-function collectIssues(validate, data, rootPath, issues) {
-    if (validate(data)) {
-        return;
-    }
-    for (const err of validate.errors ?? []){
-        issues.push(toIssue(err, rootPath));
-    }
-}
-function toIssue(err, rootPath) {
-    const instance = err.instancePath ?? "";
-    const path = instance.length > 0 ? `${rootPath}${instance}` : rootPath;
-    const message = err.message ?? "is invalid";
-    return {
-        path,
-        message: formatAjvMessage(err, message),
-        keyword: err.keyword
-    };
-}
-function formatAjvMessage(err, fallback) {
-    if (err.keyword === "required" && typeof err.params?.missingProperty === "string") {
-        return `must have required property '${err.params.missingProperty}'`;
-    }
-    if (err.keyword === "additionalProperties" && typeof err.params?.additionalProperty === "string") {
-        return `must NOT have additional property '${err.params.additionalProperty}'`;
-    }
-    return fallback;
-}