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

package/es6/src/http/http.extensions.js

@@ -1,259 +0,0 @@
-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);
-}
-import { extension } from "@decohere/core/extensibility";
-import { scribe } from "@decohere/scribe";
-import { PrincipalProvider } from "../auth/principal-provider.js";
-import { Builder } from "../builder/builder.js";
-import { ExceptionFilterHostToken, HttpOptionsToken, HttpProviderToken, IPrincipalProviderToken, RouteRegistryToken, RouterToken } from "../const.js";
-import { ExceptionFilterHost } from "../routing/filters/exception-filter-host.js";
-import { HttpAccessLogMiddleware } from "../routing/middleware/http-access-log.middleware.js";
-import { RouteRegistry } from "../routing/services/route-registry.js";
-import { Router } from "../routing/services/router.js";
-import { getOrCreateHttpOptions } from "./http.options.store.js";
-import { staticFiles } from "./http.static.js";
-const httpProviderStore = new WeakMap();
-const controllersStore = new WeakMap();
-export class BuilderExtensions {
-    static withHttpProvider(builder, type) {
-        httpProviderStore.set(builder, type);
-        const httpOptions = getOrCreateHttpOptions(builder);
-        builder.withServices((containerBuilder)=>{
-            const logger = scribe.logger("BuilderExtensions");
-            logger.trace("Configuring Http Provider");
-            const http = httpProviderStore.get(builder);
-            if (!http) {
-                return;
-            }
-            containerBuilder.registerSingleton(HttpOptionsToken, httpOptions);
-            containerBuilder.registerSingleton(HttpProviderToken, http);
-            containerBuilder.registerSingleton(RouterToken, Router);
-            containerBuilder.registerSingleton(RouteRegistryToken, RouteRegistry);
-            containerBuilder.registerSingleton(ExceptionFilterHostToken, ExceptionFilterHost);
-            containerBuilder.registerRequestScoped(IPrincipalProviderToken, PrincipalProvider);
-            for (const middlewareType of httpOptions.middlewareTypes){
-                containerBuilder.registerSingleton(middlewareType);
-            }
-            for (const filterType of httpOptions.filterTypes){
-                containerBuilder.registerSingleton(filterType);
-            }
-            const controllers = controllersStore.get(builder) || [];
-            for (const controllerFn of controllers){
-                containerBuilder.registerRequestScoped(controllerFn);
-            }
-        });
-        builder.registerPostBuildStep((container)=>{
-            const logger = scribe.logger("BuilderExtensions");
-            const registry = container.resolve(RouteRegistryToken);
-            const controllers = controllersStore.get(builder) || [];
-            for (const controllerFn of controllers){
-                logger.trace(`Add routes from ${controllerFn.name}`);
-                registry.addController(controllerFn);
-            }
-        });
-        return builder;
-    }
-    static withHttp(builder, type, options) {
-        const accessLog = options?.accessLog !== false;
-        if (accessLog) {
-            const httpOptions = getOrCreateHttpOptions(builder);
-            if (!httpOptions.middlewareTypes.includes(HttpAccessLogMiddleware)) {
-                httpOptions.middlewareTypes = [
-                    ...httpOptions.middlewareTypes,
-                    HttpAccessLogMiddleware
-                ];
-            }
-        }
-        return BuilderExtensions.withHttpProvider(builder, type);
-    }
-    static withControllers(builder, ...controllers) {
-        const existing = controllersStore.get(builder) || [];
-        controllersStore.set(builder, [
-            ...existing,
-            ...controllers
-        ]);
-        return builder;
-    }
-    static withGlobalPrefix(builder, prefix) {
-        getOrCreateHttpOptions(builder).globalPrefix = prefix;
-        return builder;
-    }
-    static withCors(builder, options) {
-        getOrCreateHttpOptions(builder).cors = options;
-        return builder;
-    }
-    static withHelmet(builder, options = {}) {
-        getOrCreateHttpOptions(builder).helmet = options;
-        return builder;
-    }
-    static withRateLimit(builder, options = {}) {
-        getOrCreateHttpOptions(builder).rateLimit = options;
-        return builder;
-    }
-    static withCompression(builder, options = {}) {
-        getOrCreateHttpOptions(builder).compression = options;
-        return builder;
-    }
-    static withBodyLimit(builder, bytes) {
-        getOrCreateHttpOptions(builder).bodyLimit = bytes;
-        return builder;
-    }
-    static withMiddleware(builder, ...middlewares) {
-        const httpOptions = getOrCreateHttpOptions(builder);
-        httpOptions.middlewareTypes = [
-            ...httpOptions.middlewareTypes,
-            ...middlewares
-        ];
-        return builder;
-    }
-    static withExceptionFilters(builder, ...filters) {
-        const httpOptions = getOrCreateHttpOptions(builder);
-        httpOptions.filterTypes = [
-            ...httpOptions.filterTypes,
-            ...filters
-        ];
-        return builder;
-    }
-    static withOpenApi(builder, options) {
-        getOrCreateHttpOptions(builder).openapi = {
-            validateRequests: true,
-            path: "/openapi.json",
-            ...options
-        };
-        return builder;
-    }
-    static withStatic(builder, prefix, directory, options) {
-        const httpOptions = getOrCreateHttpOptions(builder);
-        httpOptions.statics = [
-            ...httpOptions.statics,
-            staticFiles.toMount(prefix, directory, options)
-        ];
-        return builder;
-    }
-}
-_ts_decorate([
-    extension(Builder),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof Builder === "undefined" ? Object : Builder,
-        typeof Thttp === "undefined" ? Object : Thttp
-    ]),
-    _ts_metadata("design:returntype", void 0)
-], BuilderExtensions, "withHttpProvider", null);
-_ts_decorate([
-    extension(Builder),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof Builder === "undefined" ? Object : Builder,
-        typeof Thttp === "undefined" ? Object : Thttp,
-        typeof WithHttpOptions === "undefined" ? Object : WithHttpOptions
-    ]),
-    _ts_metadata("design:returntype", void 0)
-], BuilderExtensions, "withHttp", null);
-_ts_decorate([
-    extension(Builder),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof Builder === "undefined" ? Object : Builder,
-        Array
-    ]),
-    _ts_metadata("design:returntype", void 0)
-], BuilderExtensions, "withControllers", null);
-_ts_decorate([
-    extension(Builder),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof Builder === "undefined" ? Object : Builder,
-        String
-    ]),
-    _ts_metadata("design:returntype", void 0)
-], BuilderExtensions, "withGlobalPrefix", null);
-_ts_decorate([
-    extension(Builder),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof Builder === "undefined" ? Object : Builder,
-        typeof CorsOptions === "undefined" ? Object : CorsOptions
-    ]),
-    _ts_metadata("design:returntype", void 0)
-], BuilderExtensions, "withCors", null);
-_ts_decorate([
-    extension(Builder),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof Builder === "undefined" ? Object : Builder,
-        typeof HelmetOptions === "undefined" ? Object : HelmetOptions
-    ]),
-    _ts_metadata("design:returntype", void 0)
-], BuilderExtensions, "withHelmet", null);
-_ts_decorate([
-    extension(Builder),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof Builder === "undefined" ? Object : Builder,
-        typeof RateLimitOptions === "undefined" ? Object : RateLimitOptions
-    ]),
-    _ts_metadata("design:returntype", void 0)
-], BuilderExtensions, "withRateLimit", null);
-_ts_decorate([
-    extension(Builder),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof Builder === "undefined" ? Object : Builder,
-        typeof CompressionOptions === "undefined" ? Object : CompressionOptions
-    ]),
-    _ts_metadata("design:returntype", void 0)
-], BuilderExtensions, "withCompression", null);
-_ts_decorate([
-    extension(Builder),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof Builder === "undefined" ? Object : Builder,
-        Number
-    ]),
-    _ts_metadata("design:returntype", void 0)
-], BuilderExtensions, "withBodyLimit", null);
-_ts_decorate([
-    extension(Builder),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof Builder === "undefined" ? Object : Builder,
-        Array
-    ]),
-    _ts_metadata("design:returntype", void 0)
-], BuilderExtensions, "withMiddleware", null);
-_ts_decorate([
-    extension(Builder),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof Builder === "undefined" ? Object : Builder,
-        Array
-    ]),
-    _ts_metadata("design:returntype", void 0)
-], BuilderExtensions, "withExceptionFilters", null);
-_ts_decorate([
-    extension(Builder),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof Builder === "undefined" ? Object : Builder,
-        typeof OpenApiOptions === "undefined" ? Object : OpenApiOptions
-    ]),
-    _ts_metadata("design:returntype", void 0)
-], BuilderExtensions, "withOpenApi", null);
-_ts_decorate([
-    extension(Builder),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof Builder === "undefined" ? Object : Builder,
-        String,
-        String,
-        typeof StaticOptions === "undefined" ? Object : StaticOptions
-    ]),
-    _ts_metadata("design:returntype", void 0)
-], BuilderExtensions, "withStatic", null);

package/es6/src/http/http.options.js

@@ -1,16 +0,0 @@
-/** App-level HTTP options set via builder extensions (`withCors`, `withGlobalPrefix`, …). */ export class HttpOptions {
-    globalPrefix = "";
-    /**
-	 * Controllers put under the global prefix although they declare `globalPrefix: false`
-	 * (`withHealth({ underGlobalPrefix: true })`).
-	 */ underGlobalPrefix = new Set();
-    cors;
-    openapi;
-    /** `undefined` = helmet on with defaults; `false` = off; object = plugin options. */ helmet;
-    /** `undefined` = rate-limit on with defaults; `false` = off; object = plugin options. */ rateLimit;
-    /** `undefined` = compression on with defaults; `false` = off; object = options. See `withCompression`. */ compression;
-    /** Request body size limit in bytes; `undefined` uses the 1 MiB default. */ bodyLimit;
-    /** Built UIs served from this API, see `withStatic`. */ statics = [];
-    middlewareTypes = [];
-    filterTypes = [];
-}

package/es6/src/http/http.options.store.js

@@ -1,13 +0,0 @@
-import { HttpOptions } from "./http.options.js";
-const httpOptionsStore = new WeakMap();
-/**
- * The {@link HttpOptions} a builder collects through its extensions. Internal: lets extensions
- * outside `http.extensions.ts` (`withHealth`) set an option without a public builder method.
- */ export function getOrCreateHttpOptions(builder) {
-    let options = httpOptionsStore.get(builder);
-    if (options == null) {
-        options = new HttpOptions();
-        httpOptionsStore.set(builder, options);
-    }
-    return options;
-}

package/es6/src/http/http.security.js

@@ -1,9 +0,0 @@
-/**
- * Default HTTP security settings applied by {@link FastifyProvider} when
- * `withHttpProvider` is used. Override via `withHelmet` / `withRateLimit` /
- * `withBodyLimit` (pass `false` to disable helmet or rate-limit).
- */ /** Fastify body size limit (bytes). Matches Fastify's built-in default, made explicit and overridable. */ export const DEFAULT_HTTP_BODY_LIMIT = 1_048_576;
-/** Global request rate limit applied unless disabled or customized. */ export const DEFAULT_HTTP_RATE_LIMIT = {
-    max: 100,
-    timeWindow: "1 minute"
-};

package/es6/src/http/http.static.js

@@ -1,224 +0,0 @@
-import path from "node:path";
-import picomatch from "picomatch";
-import { isDevelopmentNodeEnv } from "../auth/auth.types.js";
-/**
- * Serving a module's built UI from its API (`builder.withStatic`). Everything here is
- * provider-neutral: the options, the caching rules and the missing-directory policy.
- * Only the HTTP provider knows how to put files on the wire. See ADR 0007.
- */ /** Cache header for files whose name carries a content hash. The name changes when the content does. */ export const STATIC_IMMUTABLE_CACHE_CONTROL = "public, max-age=31536000, immutable";
-/** Cache header for files that must be revalidated on every use (the entry points of a UI). */ export const STATIC_NO_CACHE_CONTROL = "no-cache";
-/** Cache header for every other file: cacheable, but always revalidated (ETag / Last-Modified). */ export const STATIC_DEFAULT_CACHE_CONTROL = "public, max-age=0, must-revalidate";
-/**
- * The entry points of a UI. `index.html` names the hashed bundles, and a module-federation host
- * loads `remoteEntry.js` by a fixed name to find the current remote, so neither can be cached.
- */ export const STATIC_DEFAULT_NO_CACHE = [
-    "index.html",
-    "remoteEntry.js"
-];
-/**
- * A build tool's hashed file name: `index-DiwrgTda.js`, `chunk.3f9a8c1b.css`, `app-abc123de.js.map`.
- * The hash is 8 or more letters, digits or `_` after a `-` or `.`, and holds a digit or a lowercase
- * letter followed by an uppercase one. Plain words (`logo-background.png`) are not hashes.
- */ export 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 = path.resolve(cwd, mount.directory);
-        if (!await env.directoryExists(root)) {
-            const policy = mount.options.onMissingDirectory ?? (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(path.sep).join("/");
-    const name = path.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 = picomatch([
-        ...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);
-}
-export const staticFiles = {
-    toMount,
-    resolve,
-    cacheControlFor,
-    looksLikeFile,
-    normalizePathname,
-    excluder,
-    routeSegments,
-    isUnderRoute,
-    apiBoundary,
-    acceptsHtml,
-    shouldFallBack
-};

package/es6/src/http/index.js

@@ -1,5 +0,0 @@
-export * from "./http.compression.js";
-export * from "./http.extensions.js";
-export * from "./http.options.js";
-export * from "./http.security.js";
-export * from "./http.static.js";

package/es6/src/openapi/index.js

@@ -1,3 +0,0 @@
-export { generateOpenApiDocument, resolveOpenApiPath, toOpenApiPath } from "./openapi.generator.js";
-export { buildRouteRequestSchemas, mergeObjectSchemas, objectArgToParts, pathParamsToSchema, typeToSchema } from "./request-schema.js";
-export { ValidationError, validateRequest } from "./request-validator.js";

package/es6/src/openapi/openapi.generator.js

@@ -1,82 +0,0 @@
-import { buildRouteRequestSchemas } from "./request-schema.js";
-const DEFAULT_SPEC_PATH = "/openapi.json";
-export function resolveOpenApiPath(options) {
-    const path = options.path?.trim() || DEFAULT_SPEC_PATH;
-    return path.startsWith("/") ? path : `/${path}`;
-}
-/** Convert Fastify-style `:id` path params to OpenAPI `{id}`. */ export function toOpenApiPath(fastifyPath) {
-    return fastifyPath.replace(/:([A-Za-z_][\w]*)/g, "{$1}");
-}
-export 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 } = 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/es6/src/openapi/openapi.types.js

@@ -1 +0,0 @@
-export { };