@decohere/http 0.0.1-dev.20261105.97 → 0.0.1-dev.20261106.132

package/commonjs/src/http/http.static.js

@@ -1,248 +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 STATIC_DEFAULT_CACHE_CONTROL () {
-        return STATIC_DEFAULT_CACHE_CONTROL;
-    },
-    get STATIC_DEFAULT_IMMUTABLE () {
-        return STATIC_DEFAULT_IMMUTABLE;
-    },
-    get STATIC_DEFAULT_NO_CACHE () {
-        return STATIC_DEFAULT_NO_CACHE;
-    },
-    get STATIC_IMMUTABLE_CACHE_CONTROL () {
-        return STATIC_IMMUTABLE_CACHE_CONTROL;
-    },
-    get STATIC_NO_CACHE_CONTROL () {
-        return STATIC_NO_CACHE_CONTROL;
-    },
-    get staticFiles () {
-        return staticFiles;
-    }
-});
-const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
-const _picomatch = /*#__PURE__*/ _interop_require_default(require("picomatch"));
-const _authtypes = require("../auth/auth.types.js");
-function _interop_require_default(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-const STATIC_IMMUTABLE_CACHE_CONTROL = "public, max-age=31536000, immutable";
-const STATIC_NO_CACHE_CONTROL = "no-cache";
-const STATIC_DEFAULT_CACHE_CONTROL = "public, max-age=0, must-revalidate";
-const STATIC_DEFAULT_NO_CACHE = [
-    "index.html",
-    "remoteEntry.js"
-];
-const STATIC_DEFAULT_IMMUTABLE = /[.-](?=[A-Za-z0-9_]*(?:\d|[a-z][A-Z]))[A-Za-z0-9_]{8,}\.[A-Za-z0-9]+(?:\.map)?$/;
-/** `"ui"`, `"/ui"` and `"/ui/"` all mean `/ui/`; `"/"` is the root. Refuses an empty prefix. */ function normalizePrefix(prefix) {
-    const segments = prefix.split("/").filter((segment)=>segment !== "");
-    if (segments.length === 0) {
-        if (prefix.trim() === "") {
-            throw new Error('withStatic needs a prefix, such as "/ui/" or "/" for the root.');
-        }
-        return "/";
-    }
-    if (segments.some((segment)=>segment === "." || segment === ".." || /[*:?]/.test(segment))) {
-        throw new Error(`withStatic prefix "${prefix}" must be plain path segments, such as "/ui/".`);
-    }
-    return `/${segments.join("/")}/`;
-}
-function toMount(prefix, directory, options = {}) {
-    if (directory.trim() === "") {
-        throw new Error(`withStatic("${prefix}") needs the directory that holds the built files.`);
-    }
-    return {
-        prefix: normalizePrefix(prefix),
-        directory,
-        options
-    };
-}
-/**
- * Checks every mount at start. Returns the ones that can be served; a missing directory fails or
- * warns according to the mount's `onMissingDirectory`. Two mounts on one prefix always fail.
- */ async function resolve(mounts, env) {
-    const cwd = env.cwd ?? process.cwd();
-    const resolved = [];
-    const seen = new Set();
-    for (const mount of mounts){
-        if (seen.has(mount.prefix)) {
-            throw new Error(`withStatic: ${mount.prefix} is mounted twice.`);
-        }
-        seen.add(mount.prefix);
-        const root = _nodepath.default.resolve(cwd, mount.directory);
-        if (!await env.directoryExists(root)) {
-            const policy = mount.options.onMissingDirectory ?? ((0, _authtypes.isDevelopmentNodeEnv)(env.nodeEnv) ? "warn" : "fail");
-            const message = `withStatic("${mount.prefix}", "${mount.directory}"): ${root} does not exist. ` + "Build the UI first, or run the app from the folder that holds it.";
-            if (policy === "fail") {
-                throw new Error(message);
-            }
-            env.warn(`${message} ${mount.prefix} will answer 404 until it is built and the app restarts.`);
-            continue;
-        }
-        const options = mount.options;
-        resolved.push({
-            prefix: mount.prefix,
-            root,
-            spaFallback: options.spaFallback ?? true,
-            index: options.index ?? "index.html",
-            noCache: options.noCache ?? STATIC_DEFAULT_NO_CACHE,
-            immutable: options.immutable ?? STATIC_DEFAULT_IMMUTABLE,
-            cacheControl: options.cacheControl ?? STATIC_DEFAULT_CACHE_CONTROL,
-            exclude: options.exclude ?? []
-        });
-    }
-    return resolved;
-}
-/** `Cache-Control` for a file, given its path relative to the mount's directory. */ function cacheControlFor(mount, relativePath) {
-    const posix = relativePath.split(_nodepath.default.sep).join("/");
-    const name = _nodepath.default.posix.basename(posix);
-    if (mount.noCache.some((entry)=>entry === name || entry === posix)) {
-        return STATIC_NO_CACHE_CONTROL;
-    }
-    if (mount.immutable !== false && mount.immutable.test(posix)) {
-        return STATIC_IMMUTABLE_CACHE_CONTROL;
-    }
-    return mount.cacheControl;
-}
-/**
- * Does this path look like a file: an extension on the last segment, or a dotfile anywhere?
- * Then a miss is a real 404, not a client-side route.
- */ function looksLikeFile(pathname) {
-    const segments = pathname.split("/").filter((segment)=>segment !== "");
-    if (segments.some((segment)=>segment.startsWith("."))) {
-        return true;
-    }
-    const last = pathname.endsWith("/") ? undefined : segments.at(-1);
-    return last?.includes(".") === true;
-}
-/** The request path as the mount sees it: no query, decoded, repeated slashes collapsed. */ function normalizePathname(url) {
-    const raw = url.split("?")[0] ?? "";
-    let decoded = raw;
-    try {
-        decoded = decodeURIComponent(raw);
-    } catch  {
-    // Keep the raw text: a malformed escape is matched as written.
-    }
-    return decoded.replace(/\/{2,}/g, "/");
-}
-/** Builds the test for a mount's `exclude` patterns. Matches on the normalised path. */ function excluder(patterns) {
-    if (patterns.length === 0) {
-        return ()=>false;
-    }
-    const matches = (0, _picomatch.default)([
-        ...patterns
-    ], {
-        dot: true
-    });
-    return (pathname)=>matches(pathname);
-}
-/**
- * The first path segment of every registered route, for {@link isUnderRoute}. A segment that is a
- * parameter or wildcard (`:id`, `*`) says nothing about the path and is skipped.
- */ function routeSegments(routePaths) {
-    const segments = new Set();
-    for (const routePath of routePaths){
-        const first = routePath.split("/").find((segment)=>segment !== "");
-        if (first != null && !/[:*]/.test(first)) {
-            segments.add(first);
-        }
-    }
-    return segments;
-}
-/**
- * Is this path under one of the app's own routes? True when its first segment is the first
- * segment of a registered route: with a controller route `/lp/portfolio`, `/lp/portfolo` and
- * `/lp/anything/else` belong to the API and keep the JSON 404, while `/lpx` does not.
- */ function isUnderRoute(pathname, segments) {
-    const first = pathname.split("/").find((segment)=>segment !== "");
-    return first != null && segments.has(first);
-}
-/** Is `pathname` the path `base` or below it? `/api` holds `/api` and `/api/x`, not `/apiary`. */ function isWithin(pathname, base) {
-    const trimmed = base.replace(/\/+$/, "");
-    return pathname === trimmed || pathname.startsWith(`${trimmed}/`);
-}
-/**
- * The literal start of a route path, up to its first parameter or wildcard: `/webhooks/:id` gives
- * `/webhooks`, `/:id` gives `""`.
- */ function staticStem(routePath) {
-    const stem = [];
-    for (const segment of routePath.split("/")){
-        if (segment.startsWith(":") || segment.includes("*")) {
-            break;
-        }
-        if (segment !== "") {
-            stem.push(segment);
-        }
-    }
-    return stem.length === 0 ? "" : `/${stem.join("/")}`;
-}
-/**
- * What the fallback treats as the API, as a test on the normalised path. With a global prefix it
- * is the prefix, the OpenAPI path and every route left outside the prefix
- * (`@Controller({ globalPrefix: false })`, such as `/health`), each with the paths below it, so a
- * client route may share a first segment with a controller. Without a prefix it is
- * {@link isUnderRoute} (the first segment of every registered route), the safe guess when nothing
- * says where the API lives.
- */ function apiBoundary(boundary) {
-    if (boundary.globalPrefix === "") {
-        const segments = routeSegments([
-            ...boundary.routePaths,
-            ...boundary.openApiPath == null ? [] : [
-                boundary.openApiPath
-            ]
-        ]);
-        return (pathname)=>isUnderRoute(pathname, segments);
-    }
-    const outside = [
-        ...boundary.routePaths
-    ].filter((routePath)=>!isWithin(routePath, boundary.globalPrefix)).map(staticStem).filter((stem)=>stem !== "");
-    const bases = [
-        boundary.globalPrefix,
-        boundary.openApiPath,
-        ...outside
-    ].filter((base)=>base != null);
-    return (pathname)=>bases.some((base)=>isWithin(pathname, base));
-}
-/** Does the `Accept` header ask for HTML (a browser navigation)? `text/html;q=0` does not. */ function acceptsHtml(accept) {
-    if (accept == null) {
-        return false;
-    }
-    return accept.split(",").some((entry)=>{
-        const [type = "", ...params] = entry.split(";").map((part)=>part.trim().toLowerCase());
-        if (type !== "text/html") {
-            return false;
-        }
-        const quality = params.find((param)=>param.startsWith("q="));
-        return quality == null || Number.parseFloat(quality.slice(2)) > 0;
-    });
-}
-/**
- * Should an unknown path get the app's `index.html`? Only a browser navigation: GET or HEAD, no
- * file extension and no dotfile in the path, an `Accept` that includes `text/html`, and not under
- * the API (see {@link apiBoundary}). Everything else keeps the normal JSON 404.
- */ function shouldFallBack(request, belongsToApi) {
-    return (request.method === "GET" || request.method === "HEAD") && acceptsHtml(request.accept) && !looksLikeFile(request.pathname) && !belongsToApi(request.pathname);
-}
-const staticFiles = {
-    toMount,
-    resolve,
-    cacheControlFor,
-    looksLikeFile,
-    normalizePathname,
-    excluder,
-    routeSegments,
-    isUnderRoute,
-    apiBoundary,
-    acceptsHtml,
-    shouldFallBack
-};

package/commonjs/src/http/index.js

@@ -1,22 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-_export_star(require("./http.compression.js"), exports);
-_export_star(require("./http.extensions.js"), exports);
-_export_star(require("./http.options.js"), exports);
-_export_star(require("./http.security.js"), exports);
-_export_star(require("./http.static.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/index.js

@@ -1,27 +0,0 @@
-// Resolve StartOptions re-export ambiguity (app vs routing) — prefer app's shape
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-_export_star(require("./app/index.js"), exports);
-_export_star(require("./auth/index.js"), exports);
-_export_star(require("./builder/index.js"), exports);
-_export_star(require("./const.js"), exports);
-_export_star(require("./health/index.js"), exports);
-_export_star(require("./hosting/index.js"), exports);
-_export_star(require("./openapi/index.js"), exports);
-_export_star(require("./routing/index.js"), exports);
-_export_star(require("./sse/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/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 _httptypes = require("../routing/http.types.js");
-function buildRouteRequestSchemas(route) {
-    const queryParams = [];
-    const pathParams = [];
-    let bodySchema;
-    for (const routeArg of route.routeArgs ?? []){
-        if (routeArg.argumentLocation != null && _httptypes.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
-    };
-}