@riktajs/swagger 0.10.2 → 0.10.3

package/dist/decorators/api-tags.decorator.js

@@ -1,22 +0,0 @@
-import 'reflect-metadata';
-import { API_TAGS_METADATA } from '../constants.js';
-export function ApiTags(...tags) {
-    return (target, propertyKey, descriptor) => {
-        if (propertyKey !== undefined && descriptor !== undefined) {
-            const existingTags = Reflect.getMetadata(API_TAGS_METADATA, target, propertyKey) ?? [];
-            Reflect.defineMetadata(API_TAGS_METADATA, [...existingTags, ...tags], target, propertyKey);
-        }
-        else {
-            const existingTags = Reflect.getMetadata(API_TAGS_METADATA, target) ?? [];
-            Reflect.defineMetadata(API_TAGS_METADATA, [...existingTags, ...tags], target);
-        }
-    };
-}
-export function getApiTags(target, propertyKey) {
-    if (propertyKey !== undefined) {
-        const methodTags = Reflect.getMetadata(API_TAGS_METADATA, target.prototype, propertyKey) ?? [];
-        const classTags = Reflect.getMetadata(API_TAGS_METADATA, target) ?? [];
-        return [...new Set([...classTags, ...methodTags])];
-    }
-    return Reflect.getMetadata(API_TAGS_METADATA, target) ?? [];
-}

package/dist/decorators/index.d.ts

@@ -1,10 +0,0 @@
-export { ApiTags, getApiTags } from './api-tags.decorator.js';
-export { ApiOperation, getApiOperation } from './api-operation.decorator.js';
-export { ApiResponse, ApiOkResponse, ApiCreatedResponse, ApiAcceptedResponse, ApiNoContentResponse, ApiBadRequestResponse, ApiUnauthorizedResponse, ApiForbiddenResponse, ApiNotFoundResponse, ApiConflictResponse, ApiUnprocessableEntityResponse, ApiInternalServerErrorResponse, getApiResponses, } from './api-response.decorator.js';
-export { ApiBody, getApiBody } from './api-body.decorator.js';
-export { ApiParam, getApiParams } from './api-param.decorator.js';
-export { ApiQuery, getApiQueries } from './api-query.decorator.js';
-export { ApiHeader, getApiHeaders } from './api-header.decorator.js';
-export { ApiSecurity, ApiBearerAuth, ApiBasicAuth, ApiOAuth2, ApiCookieAuth, getApiSecurity, } from './api-security.decorator.js';
-export { ApiProperty, ApiPropertyOptional, ApiHideProperty, getApiProperties, } from './api-property.decorator.js';
-export { ApiExcludeEndpoint, ApiExcludeController, isApiExcluded, ApiDeprecated, getApiDeprecated, } from './api-exclude.decorator.js';

package/dist/decorators/index.js

@@ -1,10 +0,0 @@
-export { ApiTags, getApiTags } from './api-tags.decorator.js';
-export { ApiOperation, getApiOperation } from './api-operation.decorator.js';
-export { ApiResponse, ApiOkResponse, ApiCreatedResponse, ApiAcceptedResponse, ApiNoContentResponse, ApiBadRequestResponse, ApiUnauthorizedResponse, ApiForbiddenResponse, ApiNotFoundResponse, ApiConflictResponse, ApiUnprocessableEntityResponse, ApiInternalServerErrorResponse, getApiResponses, } from './api-response.decorator.js';
-export { ApiBody, getApiBody } from './api-body.decorator.js';
-export { ApiParam, getApiParams } from './api-param.decorator.js';
-export { ApiQuery, getApiQueries } from './api-query.decorator.js';
-export { ApiHeader, getApiHeaders } from './api-header.decorator.js';
-export { ApiSecurity, ApiBearerAuth, ApiBasicAuth, ApiOAuth2, ApiCookieAuth, getApiSecurity, } from './api-security.decorator.js';
-export { ApiProperty, ApiPropertyOptional, ApiHideProperty, getApiProperties, } from './api-property.decorator.js';
-export { ApiExcludeEndpoint, ApiExcludeController, isApiExcluded, ApiDeprecated, getApiDeprecated, } from './api-exclude.decorator.js';

package/dist/openapi/generator.d.ts

@@ -1,49 +0,0 @@
-import 'reflect-metadata';
-import type { SwaggerConfig, OpenApiDocument, OpenApiSecurityScheme, OpenApiInfoObject } from '../types.js';
-type Constructor<T = unknown> = new (...args: any[]) => T;
-interface OpenApiGeneratorConfig extends Omit<SwaggerConfig, 'info'> {
-    title?: string;
-    version?: string;
-    description?: string;
-    contact?: OpenApiInfoObject['contact'];
-    license?: OpenApiInfoObject['license'];
-    termsOfService?: string;
-    info?: OpenApiInfoObject;
-}
-export declare class OpenApiGenerator {
-    private config;
-    private controllers;
-    private globalSecuritySchemes;
-    constructor(config?: OpenApiGeneratorConfig);
-    addController(controller: Constructor): this;
-    addControllers(controllers: Constructor[]): this;
-    addSecurityScheme(name: string, scheme: OpenApiSecurityScheme): this;
-    generate(): OpenApiDocument;
-    private getControllerMeta;
-    private getControllerRoutes;
-    private getControllerTags;
-    private isControllerExcluded;
-    private isControllerDeprecated;
-    private isEndpointExcluded;
-    private isEndpointDeprecated;
-    private getOperationMetadata;
-    private getResponseMetadata;
-    private getBodyMetadata;
-    private getSwaggerParamMetadata;
-    private getQueryMetadata;
-    private getHeaderMetadata;
-    private getSecurityMetadata;
-    private getMethodTags;
-    private getHttpStatusCode;
-    private getCoreParams;
-    private normalizePath;
-    private buildOperation;
-    private buildParameters;
-    private extractPathParams;
-    private buildRequestBody;
-    private buildResponses;
-    private getDefaultStatusDescription;
-    private buildSecuritySchemes;
-}
-export declare function createOpenApiGenerator(config?: Partial<SwaggerConfig>): OpenApiGenerator;
-export {};

package/dist/openapi/generator.js

@@ -1,409 +0,0 @@
-import 'reflect-metadata';
-import { ParamType, getControllerMetadata, getRoutes, getParamMetadata as getCoreParamMetadata, getHttpCode, getClassMetadata, getMethodMetadata, } from '@riktajs/core';
-import { API_TAGS_METADATA, API_OPERATION_METADATA, API_RESPONSE_METADATA, API_BODY_METADATA, API_PARAM_METADATA, API_QUERY_METADATA, API_HEADER_METADATA, API_SECURITY_METADATA, API_EXCLUDE_METADATA, API_DEPRECATED_METADATA, } from '../constants.js';
-import { zodToOpenApi, toOpenApiSchema } from './zod-to-openapi.js';
-const DEFAULT_SWAGGER_CONFIG = {
-    info: {
-        title: 'API Documentation',
-        version: '1.0.0',
-    },
-};
-export class OpenApiGenerator {
-    config;
-    controllers = [];
-    globalSecuritySchemes = new Map();
-    constructor(config = {}) {
-        const info = config.info ?? {
-            title: config.title ?? DEFAULT_SWAGGER_CONFIG.info?.title ?? 'API Documentation',
-            version: config.version ?? DEFAULT_SWAGGER_CONFIG.info?.version ?? '1.0.0',
-            description: config.description,
-            contact: config.contact,
-            license: config.license,
-            termsOfService: config.termsOfService,
-        };
-        const { title, version, description, contact, license, termsOfService, ...restConfig } = config;
-        this.config = {
-            ...DEFAULT_SWAGGER_CONFIG,
-            ...restConfig,
-            info,
-        };
-    }
-    addController(controller) {
-        this.controllers.push(controller);
-        return this;
-    }
-    addControllers(controllers) {
-        this.controllers.push(...controllers);
-        return this;
-    }
-    addSecurityScheme(name, scheme) {
-        this.globalSecuritySchemes.set(name, scheme);
-        return this;
-    }
-    generate() {
-        const paths = {};
-        const tags = [];
-        const seenTags = new Set();
-        for (const controller of this.controllers) {
-            if (this.isControllerExcluded(controller)) {
-                continue;
-            }
-            const controllerMeta = this.getControllerMeta(controller);
-            if (!controllerMeta)
-                continue;
-            const controllerTags = this.getControllerTags(controller);
-            const controllerDeprecated = this.isControllerDeprecated(controller);
-            for (const tag of controllerTags) {
-                if (!seenTags.has(tag)) {
-                    seenTags.add(tag);
-                    tags.push({ name: tag });
-                }
-            }
-            const routes = this.getControllerRoutes(controller);
-            for (const route of routes) {
-                if (this.isEndpointExcluded(controller, route.handlerName)) {
-                    continue;
-                }
-                const fullPath = this.normalizePath(controllerMeta.prefix, route.path);
-                const method = route.method.toLowerCase();
-                if (!paths[fullPath]) {
-                    paths[fullPath] = {};
-                }
-                const operation = this.buildOperation(controller, route, controllerTags, controllerDeprecated);
-                paths[fullPath][method] = operation;
-            }
-        }
-        const securitySchemes = this.buildSecuritySchemes();
-        const document = {
-            openapi: '3.0.3',
-            info: this.config.info,
-            paths,
-        };
-        if (tags.length > 0) {
-            document.tags = tags;
-        }
-        if (this.config.servers && this.config.servers.length > 0) {
-            document.servers = this.config.servers;
-        }
-        if (Object.keys(securitySchemes).length > 0) {
-            document.components = {
-                ...document.components,
-                securitySchemes,
-            };
-        }
-        if (this.config.externalDocs) {
-            document.externalDocs = this.config.externalDocs;
-        }
-        return document;
-    }
-    getControllerMeta(controller) {
-        return getControllerMetadata(controller);
-    }
-    getControllerRoutes(controller) {
-        return getRoutes(controller);
-    }
-    getControllerTags(controller) {
-        return getClassMetadata(API_TAGS_METADATA, controller) || [];
-    }
-    isControllerExcluded(controller) {
-        return getClassMetadata(API_EXCLUDE_METADATA, controller) === true;
-    }
-    isControllerDeprecated(controller) {
-        return getClassMetadata(API_DEPRECATED_METADATA, controller) === true;
-    }
-    isEndpointExcluded(controller, handlerName) {
-        return getMethodMetadata(API_EXCLUDE_METADATA, controller, handlerName) === true;
-    }
-    isEndpointDeprecated(controller, handlerName) {
-        const controllerLevel = getClassMetadata(API_DEPRECATED_METADATA, controller);
-        const methodLevel = getMethodMetadata(API_DEPRECATED_METADATA, controller, handlerName);
-        return controllerLevel?.deprecated === true || methodLevel?.deprecated === true;
-    }
-    getOperationMetadata(controller, handlerName) {
-        return getMethodMetadata(API_OPERATION_METADATA, controller, handlerName);
-    }
-    getResponseMetadata(controller, handlerName) {
-        return getMethodMetadata(API_RESPONSE_METADATA, controller, handlerName) || [];
-    }
-    getBodyMetadata(controller, handlerName) {
-        return getMethodMetadata(API_BODY_METADATA, controller, handlerName);
-    }
-    getSwaggerParamMetadata(controller, handlerName) {
-        return getMethodMetadata(API_PARAM_METADATA, controller, handlerName) || [];
-    }
-    getQueryMetadata(controller, handlerName) {
-        return getMethodMetadata(API_QUERY_METADATA, controller, handlerName) || [];
-    }
-    getHeaderMetadata(controller, handlerName) {
-        return getMethodMetadata(API_HEADER_METADATA, controller, handlerName) || [];
-    }
-    getSecurityMetadata(controller, handlerName) {
-        const controllerLevel = getClassMetadata(API_SECURITY_METADATA, controller);
-        const methodLevel = getMethodMetadata(API_SECURITY_METADATA, controller, handlerName);
-        const result = [];
-        if (controllerLevel && typeof controllerLevel === 'object' && 'name' in controllerLevel) {
-            result.push(controllerLevel);
-        }
-        else if (Array.isArray(controllerLevel)) {
-            result.push(...controllerLevel);
-        }
-        if (methodLevel && typeof methodLevel === 'object' && 'name' in methodLevel) {
-            result.push(methodLevel);
-        }
-        else if (Array.isArray(methodLevel)) {
-            result.push(...methodLevel);
-        }
-        return result;
-    }
-    getMethodTags(controller, handlerName) {
-        const operation = this.getOperationMetadata(controller, handlerName);
-        return operation?.tags;
-    }
-    getHttpStatusCode(controller, handlerName) {
-        return getHttpCode(controller, handlerName);
-    }
-    getCoreParams(controller, handlerName) {
-        return getCoreParamMetadata(controller, handlerName);
-    }
-    normalizePath(prefix, path) {
-        let fullPath = '';
-        if (prefix) {
-            fullPath = prefix.startsWith('/') ? prefix : `/${prefix}`;
-        }
-        if (path) {
-            const cleanPath = path.startsWith('/') ? path : `/${path}`;
-            fullPath = fullPath + cleanPath;
-        }
-        if (!fullPath) {
-            fullPath = '/';
-        }
-        fullPath = fullPath.replace(/:([^/]+)/g, '{$1}');
-        if (fullPath !== '/' && fullPath.endsWith('/')) {
-            fullPath = fullPath.slice(0, -1);
-        }
-        return fullPath;
-    }
-    buildOperation(controller, route, controllerTags, controllerDeprecated) {
-        const handlerName = route.handlerName;
-        const operationMeta = this.getOperationMetadata(controller, handlerName);
-        const methodTags = this.getMethodTags(controller, handlerName);
-        const operation = {
-            responses: {},
-        };
-        const tags = methodTags || controllerTags;
-        if (tags.length > 0) {
-            operation.tags = tags;
-        }
-        if (operationMeta?.summary) {
-            operation.summary = operationMeta.summary;
-        }
-        if (operationMeta?.description) {
-            operation.description = operationMeta.description;
-        }
-        if (operationMeta?.operationId) {
-            operation.operationId = operationMeta.operationId;
-        }
-        if (controllerDeprecated || operationMeta?.deprecated || this.isEndpointDeprecated(controller, handlerName)) {
-            operation.deprecated = true;
-        }
-        const parameters = this.buildParameters(controller, handlerName, route.path);
-        if (parameters.length > 0) {
-            operation.parameters = parameters;
-        }
-        if (['POST', 'PUT', 'PATCH'].includes(route.method)) {
-            const requestBody = this.buildRequestBody(controller, handlerName);
-            if (requestBody) {
-                operation.requestBody = requestBody;
-            }
-        }
-        operation.responses = this.buildResponses(controller, handlerName, route.statusCode);
-        const security = this.getSecurityMetadata(controller, handlerName);
-        if (security.length > 0) {
-            operation.security = security.map(s => ({ [s.name]: s.scopes || [] }));
-        }
-        return operation;
-    }
-    buildParameters(controller, handlerName, routePath) {
-        const parameters = [];
-        const pathParams = this.extractPathParams(routePath);
-        const paramDecorators = this.getSwaggerParamMetadata(controller, handlerName);
-        const queryDecorators = this.getQueryMetadata(controller, handlerName);
-        const headerDecorators = this.getHeaderMetadata(controller, handlerName);
-        const coreParams = this.getCoreParams(controller, handlerName);
-        const usedPathParams = new Set();
-        for (const param of paramDecorators) {
-            usedPathParams.add(param.name);
-            const baseSchema = toOpenApiSchema(param.schema);
-            const fallbackSchema = {
-                type: param.type || 'string'
-            };
-            if (param.format) {
-                fallbackSchema.format = param.format;
-            }
-            parameters.push({
-                name: param.name,
-                in: 'path',
-                required: true,
-                deprecated: param.deprecated,
-                description: param.description,
-                schema: baseSchema || fallbackSchema,
-                example: param.example,
-            });
-        }
-        for (const paramName of pathParams) {
-            if (!usedPathParams.has(paramName)) {
-                const coreParam = coreParams.find(p => p.type === ParamType.PARAM && p.key === paramName);
-                const schema = coreParam?.zodSchema ? zodToOpenApi(coreParam.zodSchema) : { type: 'string' };
-                parameters.push({
-                    name: paramName,
-                    in: 'path',
-                    required: true,
-                    schema,
-                });
-            }
-        }
-        for (const query of queryDecorators) {
-            const baseSchema = toOpenApiSchema(query.schema);
-            const fallbackSchema = {
-                type: query.type || 'string'
-            };
-            if (query.format) {
-                fallbackSchema.format = query.format;
-            }
-            parameters.push({
-                name: query.name,
-                in: 'query',
-                required: query.required,
-                deprecated: query.deprecated,
-                description: query.description,
-                schema: baseSchema || fallbackSchema,
-                example: query.example,
-            });
-        }
-        for (const header of headerDecorators) {
-            parameters.push({
-                name: header.name,
-                in: 'header',
-                required: header.required,
-                deprecated: header.deprecated,
-                description: header.description,
-                schema: toOpenApiSchema(header.schema) || {
-                    type: header.type || 'string'
-                },
-                example: header.example,
-            });
-        }
-        return parameters;
-    }
-    extractPathParams(path) {
-        const params = [];
-        const regex = /:([^/]+)|{([^}]+)}/g;
-        let match;
-        while ((match = regex.exec(path)) !== null) {
-            const paramName = match[1] ?? match[2];
-            if (paramName) {
-                params.push(paramName);
-            }
-        }
-        return params;
-    }
-    buildRequestBody(controller, handlerName) {
-        const bodyMeta = this.getBodyMetadata(controller, handlerName);
-        const coreParams = this.getCoreParams(controller, handlerName);
-        if (bodyMeta) {
-            const schema = toOpenApiSchema(bodyMeta.schema);
-            return {
-                description: bodyMeta.description,
-                required: bodyMeta.required ?? true,
-                content: {
-                    [bodyMeta.type || 'application/json']: {
-                        schema: bodyMeta.isArray && schema ? { type: 'array', items: schema } : schema,
-                        example: bodyMeta.example,
-                    },
-                },
-            };
-        }
-        const bodyParam = coreParams.find(p => p.type === ParamType.BODY);
-        if (bodyParam?.zodSchema) {
-            return {
-                required: true,
-                content: {
-                    'application/json': {
-                        schema: zodToOpenApi(bodyParam.zodSchema),
-                    },
-                },
-            };
-        }
-        return undefined;
-    }
-    buildResponses(controller, handlerName, defaultStatusCode) {
-        const responses = {};
-        const responseMeta = this.getResponseMetadata(controller, handlerName);
-        const httpCode = this.getHttpStatusCode(controller, handlerName);
-        if (responseMeta.length > 0) {
-            for (const response of responseMeta) {
-                const statusCode = response.status.toString();
-                const schema = toOpenApiSchema(response.schema);
-                responses[statusCode] = {
-                    description: response.description || this.getDefaultStatusDescription(response.status),
-                };
-                if (schema || response.example) {
-                    responses[statusCode].content = {
-                        [response.type || 'application/json']: {
-                            schema: response.isArray && schema ? { type: 'array', items: schema } : schema,
-                            example: response.example,
-                        },
-                    };
-                }
-            }
-        }
-        else {
-            const status = (httpCode || defaultStatusCode || 200).toString();
-            responses[status] = {
-                description: this.getDefaultStatusDescription(Number(status)),
-            };
-        }
-        return responses;
-    }
-    getDefaultStatusDescription(status) {
-        const descriptions = {
-            200: 'Successful response',
-            201: 'Resource created successfully',
-            204: 'No content',
-            400: 'Bad request',
-            401: 'Unauthorized',
-            403: 'Forbidden',
-            404: 'Not found',
-            409: 'Conflict',
-            422: 'Unprocessable entity',
-            500: 'Internal server error',
-        };
-        return descriptions[status] || 'Response';
-    }
-    buildSecuritySchemes() {
-        const schemes = {};
-        for (const [name, options] of this.globalSecuritySchemes) {
-            schemes[name] = {
-                type: options.type,
-                description: options.description,
-            };
-            if (options.type === 'apiKey') {
-                schemes[name].name = options.name;
-                schemes[name].in = options.in;
-            }
-            else if (options.type === 'http') {
-                schemes[name].scheme = options.scheme;
-                if (options.bearerFormat) {
-                    schemes[name].bearerFormat = options.bearerFormat;
-                }
-            }
-            else if (options.type === 'oauth2' && options.flows) {
-                schemes[name].flows = options.flows;
-            }
-        }
-        return schemes;
-    }
-}
-export function createOpenApiGenerator(config) {
-    return new OpenApiGenerator(config);
-}

package/dist/openapi/index.d.ts

@@ -1,2 +0,0 @@
-export { zodToOpenApi, isZodSchema, toOpenApiSchema } from './zod-to-openapi.js';
-export { OpenApiGenerator, createOpenApiGenerator } from './generator.js';

package/dist/openapi/index.js

@@ -1,2 +0,0 @@
-export { zodToOpenApi, isZodSchema, toOpenApiSchema } from './zod-to-openapi.js';
-export { OpenApiGenerator, createOpenApiGenerator } from './generator.js';

package/dist/openapi/zod-to-openapi.d.ts

@@ -1,5 +0,0 @@
-import { type ZodType } from 'zod';
-import type { OpenApiSchemaObject } from '../types.js';
-export declare function isZodSchema(value: unknown): value is ZodType<unknown>;
-export declare function zodToOpenApi(schema: ZodType): OpenApiSchemaObject;
-export declare function toOpenApiSchema(schemaOrOpenApi: ZodType | OpenApiSchemaObject | undefined): OpenApiSchemaObject | undefined;

package/dist/openapi/zod-to-openapi.js

@@ -1,115 +0,0 @@
-import { z } from 'zod';
-export function isZodSchema(value) {
-    return (value !== null &&
-        typeof value === 'object' &&
-        ('_zod' in value || '_def' in value) &&
-        'safeParse' in value &&
-        typeof value.safeParse === 'function');
-}
-function jsonSchemaToOpenApi(jsonSchema) {
-    if (typeof jsonSchema === 'boolean') {
-        return jsonSchema ? {} : { not: {} };
-    }
-    const result = {};
-    const schema = jsonSchema;
-    if (Array.isArray(schema.type)) {
-        const types = schema.type;
-        const nullIndex = types.indexOf('null');
-        if (nullIndex !== -1) {
-            result.nullable = true;
-            const nonNullTypes = types.filter(t => t !== 'null');
-            if (nonNullTypes.length === 1) {
-                result.type = nonNullTypes[0];
-            }
-            else if (nonNullTypes.length > 1) {
-                result.oneOf = nonNullTypes.map(t => ({ type: t }));
-            }
-        }
-        else if (types.length === 1) {
-            result.type = types[0];
-        }
-    }
-    else if (schema.type) {
-        result.type = schema.type;
-    }
-    const simpleProps = [
-        'format', 'description', 'default', 'example', 'enum',
-        'minimum', 'maximum', 'exclusiveMinimum', 'exclusiveMaximum',
-        'minLength', 'maxLength', 'pattern',
-        'minItems', 'maxItems', 'uniqueItems',
-        'minProperties', 'maxProperties',
-        'required', 'readOnly', 'writeOnly', 'deprecated',
-    ];
-    for (const prop of simpleProps) {
-        if (schema[prop] !== undefined) {
-            result[prop] = schema[prop];
-        }
-    }
-    if (schema.items) {
-        if (Array.isArray(schema.items)) {
-            result.items = { oneOf: schema.items.map(jsonSchemaToOpenApi) };
-        }
-        else {
-            result.items = jsonSchemaToOpenApi(schema.items);
-        }
-    }
-    if (schema.properties) {
-        result.properties = {};
-        for (const [key, value] of Object.entries(schema.properties)) {
-            result.properties[key] = jsonSchemaToOpenApi(value);
-        }
-    }
-    if (schema.additionalProperties !== undefined) {
-        if (typeof schema.additionalProperties === 'boolean') {
-            result.additionalProperties = schema.additionalProperties;
-        }
-        else {
-            result.additionalProperties = jsonSchemaToOpenApi(schema.additionalProperties);
-        }
-    }
-    if (schema.allOf) {
-        result.allOf = schema.allOf.map(jsonSchemaToOpenApi);
-    }
-    if (schema.oneOf) {
-        result.oneOf = schema.oneOf.map(jsonSchemaToOpenApi);
-    }
-    if (schema.anyOf) {
-        result.anyOf = schema.anyOf.map(jsonSchemaToOpenApi);
-    }
-    if (schema.not) {
-        result.not = jsonSchemaToOpenApi(schema.not);
-    }
-    if (schema.const !== undefined) {
-        result.enum = [schema.const];
-    }
-    return result;
-}
-export function zodToOpenApi(schema) {
-    const jsonSchema = z.toJSONSchema(schema, {
-        target: 'openapi-3.0',
-        unrepresentable: 'any',
-        override: (ctx) => {
-            const def = ctx.zodSchema._zod?.def;
-            if (!def)
-                return;
-            if (def.type === 'date') {
-                ctx.jsonSchema.type = 'string';
-                ctx.jsonSchema.format = 'date-time';
-            }
-            if (def.type === 'bigint') {
-                ctx.jsonSchema.type = 'integer';
-                ctx.jsonSchema.format = 'int64';
-            }
-        },
-    });
-    return jsonSchemaToOpenApi(jsonSchema);
-}
-export function toOpenApiSchema(schemaOrOpenApi) {
-    if (!schemaOrOpenApi) {
-        return undefined;
-    }
-    if (isZodSchema(schemaOrOpenApi)) {
-        return zodToOpenApi(schemaOrOpenApi);
-    }
-    return schemaOrOpenApi;
-}

package/dist/plugin/index.d.ts

@@ -1 +0,0 @@
-export { swaggerPlugin, registerSwagger, createSwaggerConfig, type SwaggerPluginOptions, } from './swagger.plugin.js';

package/dist/plugin/index.js

@@ -1 +0,0 @@
-export { swaggerPlugin, registerSwagger, createSwaggerConfig, } from './swagger.plugin.js';

package/dist/plugin/swagger.plugin.d.ts

@@ -1,38 +0,0 @@
-import type { FastifyInstance, FastifyPluginAsync } from 'fastify';
-import { type FastifySwaggerUiOptions } from '@fastify/swagger-ui';
-import type { SwaggerConfig, OpenApiDocument, OpenApiInfoObject } from '../types.js';
-type Constructor<T = unknown> = new (...args: any[]) => T;
-export interface SwaggerPluginOptions {
-    config?: SwaggerConfig;
-    info?: OpenApiInfoObject;
-    controllers?: Constructor[];
-    jsonPath?: string;
-    uiPath?: string;
-    exposeUI?: boolean;
-    exposeSpec?: boolean;
-    logo?: {
-        url: string;
-        altText?: string;
-        backgroundColor?: string;
-    };
-    theme?: 'default' | 'dark';
-    transform?: (spec: OpenApiDocument) => OpenApiDocument | Promise<OpenApiDocument>;
-}
-declare module 'fastify' {
-    interface FastifyInstance {
-        openApiSpec?: OpenApiDocument;
-    }
-}
-export declare const swaggerPlugin: FastifyPluginAsync<SwaggerPluginOptions>;
-export declare function registerSwagger(app: FastifyInstance, options?: SwaggerPluginOptions): Promise<void>;
-export declare function createSwaggerConfig(options?: SwaggerPluginOptions): {
-    swaggerOptions: {
-        mode: 'static';
-        specification: {
-            document: OpenApiDocument;
-        };
-    };
-    swaggerUIOptions: FastifySwaggerUiOptions;
-    specification: OpenApiDocument;
-};
-export {};