@zudojs/openapi 0.1.0 → 1.2.0

package/dist/openApiHttp/openApiHttpAdapter.core.js

@@ -1,61 +1,271 @@
-import { OpenAPIDocumentBuilder } from "../openApiDocument/openApiDocument.builder.js";
 import { OpenAPIRegistryImpl } from "../openApiRegistry/openApiRegistry.core.js";
 import { OpenAPIRouteScannerImpl } from "../openApiRouting/routeScanner.core.js";
-import { OpenAPIValidatorImpl } from "../openApiValidation/openApiValidator.core.js";
+import { OpenAPIValidatorImpl, } from "../openApiValidation/openApiValidator.core.js";
+import { SchemaRegistryImpl } from "../openApiSchema/schemaRegistry.core.js";
 import { toOpenAPIJSON, toOpenAPIYAML, } from "../openApiSerialization/openApiSerializer.core.js";
+import { DEFAULT_MEDIA_TYPE, DEFAULT_OPENAPI_VERSION, DOCUMENT_CACHE_TTL_MS, } from "../openApiConstants/openApiConstants.core.js";
+import { renderOpenAPIUI, zudoLogo, } from "../openApiUi/openApiUi.core.js";
 /**
- * High-level OpenAPI manager that coordinates generation, validation, and serving.
+ * High-level OpenAPI manager that coordinates generation, validation, and
+ * serving.
+ *
+ * Every mutation invalidates the cached document, so a route added after a
+ * first `generate()` appears in the next one, and regeneration is idempotent
+ * rather than throwing on the routes it registered last time.
  */
 export class OpenAPIManager {
     registry;
     scanner;
     validator;
+    schemas;
+    cacheTtlMs;
+    now;
+    logo;
+    /** True when `branding` was a caller-supplied logo rather than the default. */
+    customLogo;
     cachedDocument;
-    constructor(version = "3.1.0") {
-        this.registry = new OpenAPIRegistryImpl(version);
+    cachedAt = 0;
+    /** Whether the cached document was produced by a validating generate. */
+    cachedValidated = false;
+    constructor(versionOrOptions = {}) {
+        const options = typeof versionOrOptions === "string"
+            ? { version: versionOrOptions }
+            : versionOrOptions;
+        this.registry = new OpenAPIRegistryImpl(options.version ?? DEFAULT_OPENAPI_VERSION);
         this.scanner = new OpenAPIRouteScannerImpl();
         this.validator = new OpenAPIValidatorImpl();
+        this.schemas = new SchemaRegistryImpl({
+            version: options.version ?? DEFAULT_OPENAPI_VERSION,
+            onWarning: options.onSchemaWarning,
+        });
+        this.cacheTtlMs = options.cacheTtlMs ?? DOCUMENT_CACHE_TTL_MS;
+        this.now = options.now ?? (() => Date.now());
+        this.logo =
+            options.branding === false
+                ? undefined
+                : options.branding === true || options.branding === undefined
+                    ? zudoLogo()
+                    : options.branding;
+        this.customLogo =
+            typeof options.branding === "object" && options.branding !== null;
+        if (options.info)
+            this.registry.setInfo(options.info);
+        for (const server of options.servers ?? [])
+            this.registry.addServer(server);
+        for (const tag of options.tags ?? [])
+            this.registry.setTag(tag);
+        for (const requirement of options.security ?? []) {
+            this.registry.addSecurityRequirement(requirement);
+        }
+    }
+    /** The document version this manager emits. */
+    get version() {
+        return this.registry.version;
+    }
+    /* ── Mutation ────────────────────────────────────────────────────────── */
+    /** Sets the document's `info` object. */
+    setInfo(info) {
+        this.registry.setInfo(info);
+        return this.invalidateCache();
+    }
+    addServer(server) {
+        this.registry.addServer(server);
+        return this.invalidateCache();
+    }
+    addTag(tag) {
+        this.registry.setTag(tag);
+        return this.invalidateCache();
     }
-    get registryInstance() {
-        return this.registry;
+    addSecurityRequirement(requirement) {
+        this.registry.addSecurityRequirement(requirement);
+        return this.invalidateCache();
     }
-    get scannerInstance() {
-        return this.scanner;
+    addSecurityScheme(name, scheme) {
+        this.registry.registerSecurityScheme(name, scheme);
+        return this.invalidateCache();
     }
+    /** Registers a route. Duplicate method+path combinations are rejected. */
     addRoute(route) {
         this.scanner.addRoute(route);
+        return this.invalidateCache();
     }
+    /** Registers a route, replacing any existing one for the same method+path. */
+    setRoute(route) {
+        this.scanner.setRoute(route);
+        return this.invalidateCache();
+    }
+    /** Removes a route. Returns whether one was removed. */
+    removeRoute(method, path) {
+        const removed = this.scanner.removeRoute(method, path);
+        if (removed)
+            this.invalidateCache();
+        return removed;
+    }
+    /**
+     * Registers a component schema.
+     *
+     * `schema` is converted from a `@zudojs/schema` schema; pass an already
+     * converted {@link OpenAPISchema} to {@link OpenAPIManager.addRawSchema}.
+     */
     addSchema(name, schema) {
+        const converted = this.schemas.register(name, schema);
+        this.registry.registerSchema(name, converted);
+        return this.invalidateCache();
+    }
+    /** Registers an already-converted OpenAPI schema. */
+    addRawSchema(name, schema) {
         this.registry.registerSchema(name, schema);
+        return this.invalidateCache();
     }
+    /** Conversion warnings, keyed by component name. */
+    schemaWarnings() {
+        return this.schemas.warnings();
+    }
+    /* ── Generation ──────────────────────────────────────────────────────── */
+    /**
+     * Builds the document from the registered routes and components.
+     *
+     * Safe to call repeatedly: routes are replaced rather than re-added.
+     */
     generate(validate = false) {
-        const routes = this.scanner.scan();
-        for (const route of routes) {
-            this.registry.registerRoute(route);
+        // The scanner is the source of truth for routes. Re-setting on top of
+        // the previous route set kept routes that had since been removed or
+        // hidden, so `removeRoute()` had no effect once a document had been
+        // generated.
+        this.registry.clearRoutes();
+        for (const route of this.scanner.scan()) {
+            this.registry.setRoute(route);
+        }
+        // Brand the document unless the caller supplied a logo or opted out.
+        const info = this.registry.getInfo();
+        if (this.logo && !info["x-logo"]) {
+            this.registry.setInfo({ ...info, "x-logo": this.logo });
         }
         const document = this.registry.generate();
-        if (validate) {
+        if (validate)
             this.validator.assertValid(document);
-        }
         this.cachedDocument = document;
+        this.cachedAt = this.now();
+        this.cachedValidated = validate;
         return document;
     }
+    /**
+     * Returns the document, rebuilding it when the cache is stale, absent, or
+     * was produced without the validation this call asks for.
+     */
     getDocument(validate = false) {
-        if (this.cachedDocument) {
+        if (this.cachedDocument && this.isCacheFresh()) {
+            if (!validate || this.cachedValidated)
+                return this.cachedDocument;
+            // The cached document was never validated; validating it now is
+            // cheaper than rebuilding, and skipping the check silently is what a
+            // caller passing `true` is explicitly asking us not to do.
+            this.validator.assertValid(this.cachedDocument);
+            this.cachedValidated = true;
             return this.cachedDocument;
         }
         return this.generate(validate);
     }
-    invalidate() {
+    isCacheFresh() {
+        if (this.cacheTtlMs <= 0)
+            return false;
+        return this.now() - this.cachedAt < this.cacheTtlMs;
+    }
+    /** Validates the current document without throwing. */
+    validate() {
+        return this.validator.validate(this.getDocument());
+    }
+    /** Drops the cached document. Called automatically by every mutation. */
+    invalidateCache() {
         this.cachedDocument = undefined;
+        this.cachedAt = 0;
+        this.cachedValidated = false;
+        return this;
+    }
+    /** Drops every registered route, component and the cached document. */
+    reset() {
         this.scanner.clear();
         this.registry.clear();
+        this.schemas.clear();
+        return this.invalidateCache();
     }
+    /**
+     * @deprecated Use {@link OpenAPIManager.reset} — the old name cleared all
+     * registered routes, which is not what "invalidate" suggests.
+     */
+    invalidate() {
+        this.reset();
+    }
+    /* ── Serialization ───────────────────────────────────────────────────── */
     toJSON(validate = false) {
         return toOpenAPIJSON(this.getDocument(validate));
     }
     toYAML(validate = false) {
         return toOpenAPIYAML(this.getDocument(validate));
     }
+    /* ── Serving ─────────────────────────────────────────────────────────── */
+    /**
+     * Builds an HTTP response carrying the document.
+     *
+     * Framework-agnostic on purpose: `{ status, headers, body }` is what every
+     * adapter in this monorepo can turn into its own response type.
+     */
+    toResponse(options) {
+        const format = options?.format ?? "json";
+        const body = format === "yaml"
+            ? this.toYAML(options?.validate ?? false)
+            : this.toJSON(options?.validate ?? false);
+        return Object.freeze({
+            status: 200,
+            headers: Object.freeze({
+                "content-type": format === "yaml"
+                    ? "application/yaml; charset=utf-8"
+                    : `${DEFAULT_MEDIA_TYPE}; charset=utf-8`,
+                "cache-control": options?.cacheControl ?? "public, max-age=300",
+            }),
+            body,
+        });
+    }
+    /**
+     * Builds an HTTP response carrying a branded documentation page (Swagger UI
+     * by default, ReDoc on request) that loads the specification from
+     * `options.specUrl`. Pair it with {@link OpenAPIManager.toResponse}:
+     *
+     * ```ts
+     * app.get("/openapi.json", () => manager.toResponse());
+     * app.get("/docs", () => manager.toUIResponse({ specUrl: "/openapi.json" }));
+     * ```
+     */
+    toUIResponse(options) {
+        const info = this.registry.getInfo();
+        const body = renderOpenAPIUI({
+            title: info.title && info.title !== "API"
+                ? `${info.title} · API reference`
+                : undefined,
+            ...options,
+            // Precedence: an explicit page logo, then the manager's `branding`
+            // (a custom logo is used as-is; `false` renders none), then the
+            // page's own default wordmark.
+            logo: options.logo !== undefined
+                ? options.logo
+                : this.logo === undefined
+                    ? false
+                    : this.customLogo
+                        ? this.logo
+                        : undefined,
+        });
+        return Object.freeze({
+            status: 200,
+            headers: Object.freeze({
+                "content-type": "text/html; charset=utf-8",
+                "cache-control": "public, max-age=300",
+            }),
+            body,
+        });
+    }
+}
+/** Creates an OpenAPI manager. */
+export function createOpenAPIManager(options) {
+    return new OpenAPIManager(options ?? {});
 }
 //# sourceMappingURL=openApiHttpAdapter.core.js.map

package/dist/openApiRegistry/openApiRegistry.core.d.ts

@@ -1,8 +1,12 @@
-import type { OpenAPIDocument, OpenAPIParameter, OpenAPIRequestBody, OpenAPISchema, OpenAPISecurityScheme, OpenAPITag, OpenAPIReference } from "../openApiTypes/openApiTypes.core.js";
+import type { OpenAPIDocument, OpenAPIExample, OpenAPIHeader, OpenAPIInfo, OpenAPILink, OpenAPIParameter, OpenAPIPathItem, OpenAPIRequestBody, OpenAPIResponse, OpenAPISchema, OpenAPISecurityRequirement, OpenAPISecurityScheme, OpenAPIServer, OpenAPITag, OpenAPIReference } from "../openApiTypes/openApiTypes.core.js";
 import type { OpenAPIRoute, OpenAPIRegistry } from "./openApiRegistry.type.js";
+import type { ComponentSection } from "../openApiSchema/references.core.js";
 /** Default OpenAPI registry implementation. */
 export declare class OpenAPIRegistryImpl implements OpenAPIRegistry {
     readonly version: string;
+    private info;
+    private readonly servers;
+    private readonly security;
     private readonly routes;
     private readonly schemas;
     private readonly responses;
@@ -15,16 +19,54 @@ export declare class OpenAPIRegistryImpl implements OpenAPIRegistry {
     private readonly links;
     private readonly callbacks;
     constructor(version?: string);
+    /** Sets the document's `info` object. */
+    setInfo(info: OpenAPIInfo): void;
+    /** The document's current `info` object. */
+    getInfo(): OpenAPIInfo;
+    addServer(server: OpenAPIServer): void;
+    addSecurityRequirement(requirement: OpenAPISecurityRequirement): void;
+    private static routeKey;
     registerRoute(route: OpenAPIRoute): void;
+    /**
+     * Registers a route, replacing any existing one.
+     *
+     * This is what makes regeneration idempotent: re-registering the same routes
+     * into a registry that already holds them used to throw, so calling
+     * `generate()` twice failed.
+     */
+    setRoute(route: OpenAPIRoute): void;
+    /** Removes a route. Returns whether one was registered. */
+    removeRoute(method: string, path: string): boolean;
+    /**
+     * Drops every registered route while keeping components, servers, tags
+     * and security. `OpenAPIManager.generate()` rebuilds the route set from
+     * its scanner on each call; without this a route removed from the
+     * scanner lived on in the registry and in every later document.
+     */
+    clearRoutes(): void;
+    private static register;
     registerSchema(name: string, schema: OpenAPISchema): void;
-    registerResponse(name: string, response: unknown): void;
+    registerResponse(name: string, response: OpenAPIResponse): void;
     registerParameter(name: string, parameter: OpenAPIParameter): void;
     registerRequestBody(name: string, body: OpenAPIRequestBody): void;
-    registerHeader(name: string, header: unknown): void;
-    registerExample(name: string, example: unknown): void;
+    registerHeader(name: string, header: OpenAPIHeader): void;
+    registerExample(name: string, example: OpenAPIExample): void;
     registerSecurityScheme(name: string, scheme: OpenAPISecurityScheme): void;
+    registerLink(name: string, link: OpenAPILink): void;
+    registerCallback(name: string, callback: Readonly<Record<string, OpenAPIPathItem>>): void;
+    /**
+     * Registers a tag.
+     *
+     * Re-registering a tag name conflicts, like every other component: quietly
+     * keeping the first definition discarded corrected descriptions without a
+     * word.
+     */
     registerTag(tag: OpenAPITag): void;
-    ref(section: "schemas" | "responses" | "parameters" | "requestBodies" | "headers" | "examples" | "securitySchemes" | "links" | "callbacks", name: string): OpenAPIReference;
+    /** Registers a tag, replacing any existing one with the same name. */
+    setTag(tag: OpenAPITag): void;
+    ref(section: ComponentSection, name: string): OpenAPIReference;
+    hasComponent(section: ComponentSection, name: string): boolean;
+    private componentMap;
     generate(): OpenAPIDocument;
     clear(): void;
 }

package/dist/openApiRegistry/openApiRegistry.core.js

@@ -1,8 +1,14 @@
-import { COMPONENT_REF_PREFIX, DEFAULT_OPENAPI_VERSION, } from "../openApiConstants/openApiConstants.core.js";
-import { OpenAPIComponentConflictError, OpenAPIDocumentError, OpenAPIOperationError, OpenAPIVersionError, } from "../openApiErrors/openApiError.core.js";
+import { createComponentReference } from "../openApiSchema/references.core.js";
+import { DEFAULT_OPENAPI_VERSION, SUPPORTED_OPENAPI_VERSIONS, } from "../openApiConstants/openApiConstants.core.js";
+import { OpenAPIComponentConflictError, OpenAPIOperationError, OpenAPIVersionError, } from "../openApiErrors/openApiError.types.js";
+/** Placeholder used until {@link OpenAPIRegistryImpl.setInfo} is called. */
+const DEFAULT_INFO = { title: "API", version: "0.0.0" };
 /** Default OpenAPI registry implementation. */
 export class OpenAPIRegistryImpl {
     version;
+    info = DEFAULT_INFO;
+    servers = [];
+    security = [];
     routes = new Map();
     schemas = new Map();
     responses = new Map();
@@ -15,14 +21,55 @@ export class OpenAPIRegistryImpl {
     links = new Map();
     callbacks = new Map();
     constructor(version = DEFAULT_OPENAPI_VERSION) {
+        if (!SUPPORTED_OPENAPI_VERSIONS.includes(version)) {
+            // Fail where the version is chosen, not later inside generate().
+            throw new OpenAPIVersionError(version, SUPPORTED_OPENAPI_VERSIONS);
+        }
         this.version = version;
     }
+    /** Sets the document's `info` object. */
+    setInfo(info) {
+        this.info = { ...info };
+    }
+    /** The document's current `info` object. */
+    getInfo() {
+        return { ...this.info };
+    }
+    addServer(server) {
+        this.servers.push({ ...server });
+    }
+    addSecurityRequirement(requirement) {
+        this.security.push({ ...requirement });
+    }
+    static routeKey(route) {
+        return `${route.method.toLowerCase()}:${route.path}`;
+    }
     registerRoute(route) {
-        const key = `${route.method}:${route.path}`;
+        const key = OpenAPIRegistryImpl.routeKey(route);
         const existing = this.routes.get(key);
-        if (existing)
-            throw new OpenAPIOperationError(`Duplicate operation for ${route.method.toUpperCase()} ${route.path}: ${existing.operation.operationId ?? "unknown"}.`);
-        this.routes.set(key, {
+        if (existing) {
+            throw new OpenAPIOperationError(`Duplicate operation for ${route.method.toUpperCase()} ${route.path}` +
+                (existing.operation.operationId
+                    ? ` (already registered as "${existing.operation.operationId}")`
+                    : ""), {
+                metadata: {
+                    method: route.method,
+                    path: route.path,
+                    operationId: existing.operation.operationId,
+                },
+            });
+        }
+        this.setRoute(route);
+    }
+    /**
+     * Registers a route, replacing any existing one.
+     *
+     * This is what makes regeneration idempotent: re-registering the same routes
+     * into a registry that already holds them used to throw, so calling
+     * `generate()` twice failed.
+     */
+    setRoute(route) {
+        this.routes.set(OpenAPIRegistryImpl.routeKey(route), {
             ...route,
             operation: Object.freeze({
                 ...route.operation,
@@ -30,72 +77,134 @@ export class OpenAPIRegistryImpl {
             }),
         });
     }
+    /** Removes a route. Returns whether one was registered. */
+    removeRoute(method, path) {
+        return this.routes.delete(OpenAPIRegistryImpl.routeKey({ method, path }));
+    }
+    /**
+     * Drops every registered route while keeping components, servers, tags
+     * and security. `OpenAPIManager.generate()` rebuilds the route set from
+     * its scanner on each call; without this a route removed from the
+     * scanner lived on in the registry and in every later document.
+     */
+    clearRoutes() {
+        this.routes.clear();
+    }
+    static register(map, section, name, value) {
+        if (map.has(name)) {
+            throw new OpenAPIComponentConflictError(section, name);
+        }
+        map.set(name, Object.freeze(value));
+    }
     registerSchema(name, schema) {
-        if (this.schemas.has(name))
-            throw new OpenAPIComponentConflictError(`schemas/${name}`);
-        this.schemas.set(name, Object.freeze({ ...schema }));
+        OpenAPIRegistryImpl.register(this.schemas, "schemas", name, { ...schema });
     }
     registerResponse(name, response) {
-        if (this.responses.has(name))
-            throw new OpenAPIComponentConflictError(`responses/${name}`);
-        this.responses.set(name, Object.freeze({ ...response }));
+        OpenAPIRegistryImpl.register(this.responses, "responses", name, {
+            ...response,
+        });
     }
     registerParameter(name, parameter) {
-        if (this.parameters.has(name))
-            throw new OpenAPIComponentConflictError(`parameters/${name}`);
-        this.parameters.set(name, Object.freeze({ ...parameter }));
+        OpenAPIRegistryImpl.register(this.parameters, "parameters", name, {
+            ...parameter,
+        });
     }
     registerRequestBody(name, body) {
-        if (this.requestBodies.has(name))
-            throw new OpenAPIComponentConflictError(`requestBodies/${name}`);
-        this.requestBodies.set(name, Object.freeze({ ...body }));
+        OpenAPIRegistryImpl.register(this.requestBodies, "requestBodies", name, {
+            ...body,
+        });
     }
     registerHeader(name, header) {
-        if (this.headers.has(name))
-            throw new OpenAPIComponentConflictError(`headers/${name}`);
-        this.headers.set(name, Object.freeze({ ...header }));
+        OpenAPIRegistryImpl.register(this.headers, "headers", name, { ...header });
     }
     registerExample(name, example) {
-        if (this.examples.has(name))
-            throw new OpenAPIComponentConflictError(`examples/${name}`);
-        this.examples.set(name, Object.freeze({ ...example }));
+        OpenAPIRegistryImpl.register(this.examples, "examples", name, {
+            ...example,
+        });
     }
     registerSecurityScheme(name, scheme) {
-        if (this.securitySchemes.has(name))
-            throw new OpenAPIComponentConflictError(`securitySchemes/${name}`);
-        this.securitySchemes.set(name, Object.freeze({ ...scheme }));
+        OpenAPIRegistryImpl.register(this.securitySchemes, "securitySchemes", name, {
+            ...scheme,
+        });
+    }
+    registerLink(name, link) {
+        OpenAPIRegistryImpl.register(this.links, "links", name, { ...link });
+    }
+    registerCallback(name, callback) {
+        OpenAPIRegistryImpl.register(this.callbacks, "callbacks", name, {
+            ...callback,
+        });
     }
+    /**
+     * Registers a tag.
+     *
+     * Re-registering a tag name conflicts, like every other component: quietly
+     * keeping the first definition discarded corrected descriptions without a
+     * word.
+     */
     registerTag(tag) {
-        if (!this.tags.has(tag.name))
-            this.tags.set(tag.name, Object.freeze({ ...tag }));
+        if (this.tags.has(tag.name)) {
+            throw new OpenAPIComponentConflictError("tags", tag.name);
+        }
+        this.tags.set(tag.name, Object.freeze({ ...tag }));
+    }
+    /** Registers a tag, replacing any existing one with the same name. */
+    setTag(tag) {
+        this.tags.set(tag.name, Object.freeze({ ...tag }));
     }
     ref(section, name) {
-        return { $ref: `${COMPONENT_REF_PREFIX}/${section}/${name}` };
+        return createComponentReference(section, name);
+    }
+    hasComponent(section, name) {
+        return this.componentMap(section)?.has(name) ?? false;
+    }
+    componentMap(section) {
+        switch (section) {
+            case "schemas":
+                return this.schemas;
+            case "responses":
+                return this.responses;
+            case "parameters":
+                return this.parameters;
+            case "requestBodies":
+                return this.requestBodies;
+            case "headers":
+                return this.headers;
+            case "examples":
+                return this.examples;
+            case "securitySchemes":
+                return this.securitySchemes;
+            case "links":
+                return this.links;
+            case "callbacks":
+                return this.callbacks;
+            default:
+                return undefined;
+        }
     }
     generate() {
-        if (!["3.0.0", "3.0.1", "3.0.2", "3.0.3", "3.1.0", "3.1.1"].includes(this.version))
-            throw new OpenAPIVersionError(this.version);
-        const paths = {};
-        for (const [, route] of this.routes) {
+        // A `Map` rather than an object literal: a route registered at the path
+        // `__proto__` assigned to a literal sets the object's prototype instead
+        // of adding an entry, so the path disappears from the document with no
+        // error raised anywhere. `Object.fromEntries` defines own properties and
+        // has no such hole.
+        const paths = new Map();
+        for (const route of this.routes.values()) {
             const operation = Object.freeze({
                 ...route.operation,
                 responses: Object.freeze({ ...route.operation.responses }),
             });
-            const existing = paths[route.path] ?? {};
-            paths[route.path] = Object.freeze({
-                ...existing,
-                ...(route.method === "get" ? { get: operation } : {}),
-                ...(route.method === "put" ? { put: operation } : {}),
-                ...(route.method === "post" ? { post: operation } : {}),
-                ...(route.method === "delete" ? { delete: operation } : {}),
-                ...(route.method === "options" ? { options: operation } : {}),
-                ...(route.method === "head" ? { head: operation } : {}),
-                ...(route.method === "patch" ? { patch: operation } : {}),
-                ...(route.method === "trace" ? { trace: operation } : {}),
-                ...(route.operation.parameters?.length
-                    ? { parameters: Object.freeze([...route.operation.parameters]) }
-                    : {}),
-            });
+            // Operations keep their own parameters. Hoisting them to the path item
+            // makes them apply to every method on that path, so two methods with
+            // different parameters overwrote one another.
+            //
+            // The method is lower-cased here as well as in the cache key: a path
+            // item field is defined in lower case, and `GET` would emit a field no
+            // consumer recognises while still colliding on the key.
+            paths.set(route.path, Object.freeze({
+                ...(paths.get(route.path) ?? {}),
+                [route.method.toLowerCase()]: operation,
+            }));
         }
         const components = {};
         const componentMaps = [
@@ -113,24 +222,28 @@ export class OpenAPIRegistryImpl {
             if (map.size > 0)
                 components[key] = Object.freeze(Object.fromEntries(map));
         }
-        try {
-            return Object.freeze({
-                openapi: this.version,
-                info: { title: "Zudojs API", version: "1.0.0" },
-                paths: Object.freeze(paths),
-                ...(Object.keys(components).length > 0
-                    ? { components: Object.freeze(components) }
-                    : {}),
-                ...(this.tags.size > 0
-                    ? { tags: Object.freeze(Array.from(this.tags.values())) }
-                    : {}),
-            });
-        }
-        catch (error) {
-            throw new OpenAPIDocumentError(`Failed to generate OpenAPI document: ${error.message}`);
-        }
+        return Object.freeze({
+            openapi: this.version,
+            info: Object.freeze({ ...this.info }),
+            ...(this.servers.length > 0
+                ? { servers: Object.freeze([...this.servers]) }
+                : {}),
+            paths: Object.freeze(Object.fromEntries(paths)),
+            ...(Object.keys(components).length > 0
+                ? { components: Object.freeze(components) }
+                : {}),
+            ...(this.security.length > 0
+                ? { security: Object.freeze([...this.security]) }
+                : {}),
+            ...(this.tags.size > 0
+                ? { tags: Object.freeze([...this.tags.values()]) }
+                : {}),
+        });
     }
     clear() {
+        this.info = DEFAULT_INFO;
+        this.servers.length = 0;
+        this.security.length = 0;
         for (const map of [
             this.routes,
             this.schemas,
@@ -143,8 +256,9 @@ export class OpenAPIRegistryImpl {
             this.tags,
             this.links,
             this.callbacks,
-        ])
+        ]) {
             map.clear();
+        }
     }
 }
 //# sourceMappingURL=openApiRegistry.core.js.map