@midwayjs/swagger 1.3.0 → 3.0.0-beta.9

package/dist/decorators/api-property.decorator.d.ts

@@ -0,0 +1,11 @@
+import { SchemaObjectMetadata } from '../interfaces';
+export interface ApiPropertyOptions extends Omit<SchemaObjectMetadata, 'name' | 'enum'> {
+    name?: string;
+    enum?: any[] | Record<string, any>;
+    enumName?: string;
+}
+export declare function ApiProperty(options?: ApiPropertyOptions): PropertyDecorator;
+export declare function createApiPropertyDecorator(options?: ApiPropertyOptions): PropertyDecorator;
+export declare function ApiPropertyOptional(options?: ApiPropertyOptions): PropertyDecorator;
+export declare function ApiResponseProperty(options?: Pick<ApiPropertyOptions, 'type' | 'example' | 'format' | 'enum' | 'deprecated'>): PropertyDecorator;
+//# sourceMappingURL=api-property.decorator.d.ts.map

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

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiResponseProperty = exports.ApiPropertyOptional = exports.createApiPropertyDecorator = exports.ApiProperty = void 0;
+const constants_1 = require("../constants");
+const enum_utils_1 = require("../common/enum.utils");
+const helpers_1 = require("./helpers");
+const isEnumArray = (obj) => obj.isArray && !!obj.enum;
+function ApiProperty(options = {}) {
+    return createApiPropertyDecorator(options);
+}
+exports.ApiProperty = ApiProperty;
+function createApiPropertyDecorator(options = {}) {
+    const [type, isArray] = (0, helpers_1.getTypeIsArrayTuple)(options.type, options.isArray);
+    options = {
+        ...options,
+        type,
+        isArray,
+    };
+    if (isEnumArray(options)) {
+        options.type = 'array';
+        const enumValues = (0, enum_utils_1.getEnumValues)(options.enum);
+        options.items = {
+            type: (0, enum_utils_1.getEnumType)(enumValues),
+            enum: enumValues,
+        };
+        delete options.enum;
+    }
+    else if (options.enum) {
+        const enumValues = (0, enum_utils_1.getEnumValues)(options.enum);
+        options.enum = enumValues;
+        options.type = (0, enum_utils_1.getEnumType)(enumValues);
+    }
+    if (Array.isArray(options.type)) {
+        options.type = 'array';
+        options.items = {
+            type: options.type[0],
+        };
+    }
+    return (0, helpers_1.createPropertyDecorator)(constants_1.DECORATORS.API_MODEL_PROPERTIES, options);
+}
+exports.createApiPropertyDecorator = createApiPropertyDecorator;
+function ApiPropertyOptional(options = {}) {
+    return ApiProperty({
+        ...options,
+        required: false,
+    });
+}
+exports.ApiPropertyOptional = ApiPropertyOptional;
+function ApiResponseProperty(options = {}) {
+    return ApiProperty({
+        readOnly: true,
+        ...options,
+    });
+}
+exports.ApiResponseProperty = ApiResponseProperty;
+//# sourceMappingURL=api-property.decorator.js.map

package/dist/decorators/api-query.decorator.d.ts

@@ -0,0 +1,17 @@
+import { Type, ParameterObject, ReferenceObject, SchemaObject, SwaggerEnumType } from '../interfaces';
+declare type ParameterOptions = Omit<ParameterObject, 'in' | 'schema' | 'name'>;
+interface ApiQueryMetadata extends ParameterOptions {
+    name?: string;
+    type?: Type | string;
+    isArray?: boolean;
+    enum?: SwaggerEnumType;
+    enumName?: string;
+}
+interface ApiQuerySchemaHost extends ParameterOptions {
+    name?: string;
+    schema: SchemaObject | ReferenceObject;
+}
+export declare type ApiQueryOptions = ApiQueryMetadata | ApiQuerySchemaHost;
+export declare function ApiQuery(options: ApiQueryOptions): MethodDecorator;
+export {};
+//# sourceMappingURL=api-query.decorator.d.ts.map

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiQuery = void 0;
+const enum_utils_1 = require("../common/enum.utils");
+const helpers_1 = require("./helpers");
+const defaultQueryOptions = {
+    name: '',
+    required: true,
+};
+function ApiQuery(options) {
+    const apiQueryMetadata = options;
+    const [type, isArray] = (0, helpers_1.getTypeIsArrayTuple)(apiQueryMetadata.type, apiQueryMetadata.isArray);
+    const param = {
+        name: !options.name ? defaultQueryOptions.name : options.name,
+        in: 'query',
+        ...options,
+        type,
+    };
+    if ((0, enum_utils_1.isEnumArray)(options)) {
+        (0, enum_utils_1.addEnumArraySchema)(param, options);
+    }
+    else if ((0, enum_utils_1.isEnumDefined)(options)) {
+        (0, enum_utils_1.addEnumSchema)(param, options);
+    }
+    if (isArray) {
+        param.isArray = isArray;
+    }
+    return (0, helpers_1.createParamDecorator)(param, defaultQueryOptions);
+}
+exports.ApiQuery = ApiQuery;
+//# sourceMappingURL=api-query.decorator.js.map

package/dist/decorators/api-response.decorator.d.ts

@@ -0,0 +1,41 @@
+import { ResponseObject, SchemaObject, ReferenceObject, Type } from '../interfaces';
+export interface ApiResponseMetadata extends Omit<ResponseObject, 'description'> {
+    status?: number | 'default';
+    type?: Type | string | Record<string, any>;
+    isArray?: boolean;
+    description?: string;
+}
+export interface ApiResponseSchemaHost extends Omit<ResponseObject, 'description'> {
+    schema: SchemaObject & Partial<ReferenceObject>;
+    status?: number;
+    description?: string;
+}
+export declare type ApiResponseOptions = ApiResponseMetadata | ApiResponseSchemaHost;
+export declare function ApiResponse(options: ApiResponseOptions): any;
+export declare const ApiOkResponse: (options?: ApiResponseOptions) => any;
+export declare const ApiCreatedResponse: (options?: ApiResponseOptions) => any;
+export declare const ApiAcceptedResponse: (options?: ApiResponseOptions) => any;
+export declare const ApiNoContentResponse: (options?: ApiResponseOptions) => any;
+export declare const ApiMovedPermanentlyResponse: (options?: ApiResponseOptions) => any;
+export declare const ApiFoundResponse: (options?: ApiResponseOptions) => any;
+export declare const ApiBadRequestResponse: (options?: ApiResponseOptions) => any;
+export declare const ApiUnauthorizedResponse: (options?: ApiResponseOptions) => any;
+export declare const ApiTooManyRequestsResponse: (options?: ApiResponseOptions) => any;
+export declare const ApiNotFoundResponse: (options?: ApiResponseOptions) => any;
+export declare const ApiInternalServerErrorResponse: (options?: ApiResponseOptions) => any;
+export declare const ApiBadGatewayResponse: (options?: ApiResponseOptions) => any;
+export declare const ApiConflictResponse: (options?: ApiResponseOptions) => any;
+export declare const ApiForbiddenResponse: (options?: ApiResponseOptions) => any;
+export declare const ApiGatewayTimeoutResponse: (options?: ApiResponseOptions) => any;
+export declare const ApiGoneResponse: (options?: ApiResponseOptions) => any;
+export declare const ApiMethodNotAllowedResponse: (options?: ApiResponseOptions) => any;
+export declare const ApiNotAcceptableResponse: (options?: ApiResponseOptions) => any;
+export declare const ApiNotImplementedResponse: (options?: ApiResponseOptions) => any;
+export declare const ApiPreconditionFailedResponse: (options?: ApiResponseOptions) => any;
+export declare const ApiPayloadTooLargeResponse: (options?: ApiResponseOptions) => any;
+export declare const ApiRequestTimeoutResponse: (options?: ApiResponseOptions) => any;
+export declare const ApiServiceUnavailableResponse: (options?: ApiResponseOptions) => any;
+export declare const ApiUnprocessableEntityResponse: (options?: ApiResponseOptions) => any;
+export declare const ApiUnsupportedMediaTypeResponse: (options?: ApiResponseOptions) => any;
+export declare const ApiDefaultResponse: (options?: ApiResponseOptions) => any;
+//# sourceMappingURL=api-response.decorator.d.ts.map

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

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiDefaultResponse = exports.ApiUnsupportedMediaTypeResponse = exports.ApiUnprocessableEntityResponse = exports.ApiServiceUnavailableResponse = exports.ApiRequestTimeoutResponse = exports.ApiPayloadTooLargeResponse = exports.ApiPreconditionFailedResponse = exports.ApiNotImplementedResponse = exports.ApiNotAcceptableResponse = exports.ApiMethodNotAllowedResponse = exports.ApiGoneResponse = exports.ApiGatewayTimeoutResponse = exports.ApiForbiddenResponse = exports.ApiConflictResponse = exports.ApiBadGatewayResponse = exports.ApiInternalServerErrorResponse = exports.ApiNotFoundResponse = exports.ApiTooManyRequestsResponse = exports.ApiUnauthorizedResponse = exports.ApiBadRequestResponse = exports.ApiFoundResponse = exports.ApiMovedPermanentlyResponse = exports.ApiNoContentResponse = exports.ApiAcceptedResponse = exports.ApiCreatedResponse = exports.ApiOkResponse = exports.ApiResponse = void 0;
+const constants_1 = require("../constants");
+const helpers_1 = require("./helpers");
+const httpStatus_1 = require("../common/httpStatus");
+const decorator_1 = require("@midwayjs/decorator");
+function ApiResponse(options) {
+    const [type, isArray] = (0, helpers_1.getTypeIsArrayTuple)(options.type, options.isArray);
+    options.type = type;
+    options.isArray = isArray;
+    options.description = options.description ? options.description : '';
+    const groupedMetadata = {
+        [options.status || 'default']: options,
+    };
+    return (0, decorator_1.createCustomMethodDecorator)(constants_1.DECORATORS.API_RESPONSE, groupedMetadata);
+}
+exports.ApiResponse = ApiResponse;
+const ApiOkResponse = (options = {}) => ApiResponse({
+    ...options,
+    status: httpStatus_1.HttpStatus.OK,
+});
+exports.ApiOkResponse = ApiOkResponse;
+const ApiCreatedResponse = (options = {}) => ApiResponse({
+    ...options,
+    status: httpStatus_1.HttpStatus.CREATED,
+});
+exports.ApiCreatedResponse = ApiCreatedResponse;
+const ApiAcceptedResponse = (options = {}) => ApiResponse({
+    ...options,
+    status: httpStatus_1.HttpStatus.ACCEPTED,
+});
+exports.ApiAcceptedResponse = ApiAcceptedResponse;
+const ApiNoContentResponse = (options = {}) => ApiResponse({
+    ...options,
+    status: httpStatus_1.HttpStatus.NO_CONTENT,
+});
+exports.ApiNoContentResponse = ApiNoContentResponse;
+const ApiMovedPermanentlyResponse = (options = {}) => ApiResponse({
+    ...options,
+    status: httpStatus_1.HttpStatus.MOVED_PERMANENTLY,
+});
+exports.ApiMovedPermanentlyResponse = ApiMovedPermanentlyResponse;
+const ApiFoundResponse = (options = {}) => ApiResponse({
+    ...options,
+    status: httpStatus_1.HttpStatus.FOUND,
+});
+exports.ApiFoundResponse = ApiFoundResponse;
+const ApiBadRequestResponse = (options = {}) => ApiResponse({
+    ...options,
+    status: httpStatus_1.HttpStatus.BAD_REQUEST,
+});
+exports.ApiBadRequestResponse = ApiBadRequestResponse;
+const ApiUnauthorizedResponse = (options = {}) => ApiResponse({
+    ...options,
+    status: httpStatus_1.HttpStatus.UNAUTHORIZED,
+});
+exports.ApiUnauthorizedResponse = ApiUnauthorizedResponse;
+const ApiTooManyRequestsResponse = (options = {}) => ApiResponse({
+    ...options,
+    status: httpStatus_1.HttpStatus.TOO_MANY_REQUESTS,
+});
+exports.ApiTooManyRequestsResponse = ApiTooManyRequestsResponse;
+const ApiNotFoundResponse = (options = {}) => ApiResponse({
+    ...options,
+    status: httpStatus_1.HttpStatus.NOT_FOUND,
+});
+exports.ApiNotFoundResponse = ApiNotFoundResponse;
+const ApiInternalServerErrorResponse = (options = {}) => ApiResponse({
+    ...options,
+    status: httpStatus_1.HttpStatus.INTERNAL_SERVER_ERROR,
+});
+exports.ApiInternalServerErrorResponse = ApiInternalServerErrorResponse;
+const ApiBadGatewayResponse = (options = {}) => ApiResponse({
+    ...options,
+    status: httpStatus_1.HttpStatus.BAD_GATEWAY,
+});
+exports.ApiBadGatewayResponse = ApiBadGatewayResponse;
+const ApiConflictResponse = (options = {}) => ApiResponse({
+    ...options,
+    status: httpStatus_1.HttpStatus.CONFLICT,
+});
+exports.ApiConflictResponse = ApiConflictResponse;
+const ApiForbiddenResponse = (options = {}) => ApiResponse({
+    ...options,
+    status: httpStatus_1.HttpStatus.FORBIDDEN,
+});
+exports.ApiForbiddenResponse = ApiForbiddenResponse;
+const ApiGatewayTimeoutResponse = (options = {}) => ApiResponse({
+    ...options,
+    status: httpStatus_1.HttpStatus.GATEWAY_TIMEOUT,
+});
+exports.ApiGatewayTimeoutResponse = ApiGatewayTimeoutResponse;
+const ApiGoneResponse = (options = {}) => ApiResponse({
+    ...options,
+    status: httpStatus_1.HttpStatus.GONE,
+});
+exports.ApiGoneResponse = ApiGoneResponse;
+const ApiMethodNotAllowedResponse = (options = {}) => ApiResponse({
+    ...options,
+    status: httpStatus_1.HttpStatus.METHOD_NOT_ALLOWED,
+});
+exports.ApiMethodNotAllowedResponse = ApiMethodNotAllowedResponse;
+const ApiNotAcceptableResponse = (options = {}) => ApiResponse({
+    ...options,
+    status: httpStatus_1.HttpStatus.NOT_ACCEPTABLE,
+});
+exports.ApiNotAcceptableResponse = ApiNotAcceptableResponse;
+const ApiNotImplementedResponse = (options = {}) => ApiResponse({
+    ...options,
+    status: httpStatus_1.HttpStatus.NOT_IMPLEMENTED,
+});
+exports.ApiNotImplementedResponse = ApiNotImplementedResponse;
+const ApiPreconditionFailedResponse = (options = {}) => ApiResponse({
+    ...options,
+    status: httpStatus_1.HttpStatus.PRECONDITION_FAILED,
+});
+exports.ApiPreconditionFailedResponse = ApiPreconditionFailedResponse;
+const ApiPayloadTooLargeResponse = (options = {}) => ApiResponse({
+    ...options,
+    status: httpStatus_1.HttpStatus.PAYLOAD_TOO_LARGE,
+});
+exports.ApiPayloadTooLargeResponse = ApiPayloadTooLargeResponse;
+const ApiRequestTimeoutResponse = (options = {}) => ApiResponse({
+    ...options,
+    status: httpStatus_1.HttpStatus.REQUEST_TIMEOUT,
+});
+exports.ApiRequestTimeoutResponse = ApiRequestTimeoutResponse;
+const ApiServiceUnavailableResponse = (options = {}) => ApiResponse({
+    ...options,
+    status: httpStatus_1.HttpStatus.SERVICE_UNAVAILABLE,
+});
+exports.ApiServiceUnavailableResponse = ApiServiceUnavailableResponse;
+const ApiUnprocessableEntityResponse = (options = {}) => ApiResponse({
+    ...options,
+    status: httpStatus_1.HttpStatus.UNPROCESSABLE_ENTITY,
+});
+exports.ApiUnprocessableEntityResponse = ApiUnprocessableEntityResponse;
+const ApiUnsupportedMediaTypeResponse = (options = {}) => ApiResponse({
+    ...options,
+    status: httpStatus_1.HttpStatus.UNSUPPORTED_MEDIA_TYPE,
+});
+exports.ApiUnsupportedMediaTypeResponse = ApiUnsupportedMediaTypeResponse;
+const ApiDefaultResponse = (options = {}) => ApiResponse({
+    ...options,
+    status: 'default',
+});
+exports.ApiDefaultResponse = ApiDefaultResponse;
+//# sourceMappingURL=api-response.decorator.js.map

package/dist/decorators/api-security.decorator.d.ts

@@ -0,0 +1,3 @@
+import { SecurityRequirementObject } from '../interfaces';
+export declare function ApiSecurity(name: string | SecurityRequirementObject, requirements?: string[]): any;
+//# sourceMappingURL=api-security.decorator.d.ts.map

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiSecurity = void 0;
+const decorator_1 = require("@midwayjs/decorator");
+const constants_1 = require("../constants");
+function ApiSecurity(name, requirements = []) {
+    let metadata;
+    if (typeof name === 'string') {
+        metadata = { [name]: requirements || [] };
+    }
+    else {
+        metadata = name;
+    }
+    return (0, decorator_1.createCustomMethodDecorator)(constants_1.DECORATORS.API_SECURITY, metadata);
+}
+exports.ApiSecurity = ApiSecurity;
+//# sourceMappingURL=api-security.decorator.js.map

package/dist/decorators/api-tags.decorator.d.ts

@@ -0,0 +1,2 @@
+export declare function ApiTags(...tags: string[]): any;
+//# sourceMappingURL=api-tags.decorator.d.ts.map

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

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiTags = void 0;
+const constants_1 = require("../constants");
+const helpers_1 = require("./helpers");
+function ApiTags(...tags) {
+    return (0, helpers_1.createMixedDecorator)(constants_1.DECORATORS.API_TAGS, tags);
+}
+exports.ApiTags = ApiTags;
+//# sourceMappingURL=api-tags.decorator.js.map

package/dist/decorators/helpers.d.ts

@@ -0,0 +1,7 @@
+import type { Type } from '../interfaces';
+export declare function createPropertyDecorator<T extends Record<string, any> = any>(metakey: string, metadata: T): PropertyDecorator;
+export declare function createMixedDecorator<T = any>(metakey: string, metadata: T): any;
+export declare function createParamDecorator<T extends Record<string, any> = any>(metadata: T, initial: Partial<T>): MethodDecorator;
+export declare function getTypeIsArrayTuple(input: Type | undefined | string | Record<string, any>, isArrayFlag: boolean): [Type | undefined | string | Record<string, any>, boolean];
+export declare function getSchemaPath(clzz: Type | string): string;
+//# sourceMappingURL=helpers.d.ts.map

package/dist/decorators/helpers.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSchemaPath = exports.getTypeIsArrayTuple = exports.createParamDecorator = exports.createMixedDecorator = exports.createPropertyDecorator = void 0;
+const decorator_1 = require("@midwayjs/decorator");
+const constants_1 = require("../constants");
+function createPropertyDecorator(metakey, metadata) {
+    return (0, decorator_1.createCustomPropertyDecorator)(metakey, metadata);
+}
+exports.createPropertyDecorator = createPropertyDecorator;
+function createMixedDecorator(metakey, metadata) {
+    return (0, decorator_1.createCustomMethodDecorator)(metakey, metadata);
+}
+exports.createMixedDecorator = createMixedDecorator;
+function createParamDecorator(metadata, initial) {
+    return (0, decorator_1.createCustomMethodDecorator)(constants_1.DECORATORS.API_PARAMETERS, {
+        ...initial,
+        ...metadata,
+    });
+}
+exports.createParamDecorator = createParamDecorator;
+function getTypeIsArrayTuple(input, isArrayFlag) {
+    if (!input) {
+        return [input, isArrayFlag];
+    }
+    if (isArrayFlag) {
+        return [input, isArrayFlag];
+    }
+    const isInputArray = Array.isArray(input);
+    const type = isInputArray ? input[0] : input;
+    return [type, isInputArray];
+}
+exports.getTypeIsArrayTuple = getTypeIsArrayTuple;
+function getSchemaPath(clzz) {
+    let str = clzz;
+    if (typeof clzz === 'object') {
+        str = clzz ? clzz.name : clzz;
+    }
+    return `#/components/schemas/${str}`;
+}
+exports.getSchemaPath = getSchemaPath;
+//# sourceMappingURL=helpers.js.map

package/dist/decorators/index.d.ts

@@ -0,0 +1,18 @@
+export * from './api-body.decorator';
+export * from './api-exclude-endpoint.decorator';
+export * from './api-exclude-controller.decorator';
+export * from './api-header.decorator';
+export * from './api-operation.decorator';
+export * from './api-param.decorator';
+export { ApiProperty, ApiPropertyOptional, ApiPropertyOptions, ApiResponseProperty, } from './api-property.decorator';
+export * from './api-query.decorator';
+export * from './api-response.decorator';
+export * from './api-tags.decorator';
+export * from './api-extension.decorator';
+export * from './api-basic.decorator';
+export * from './api-bearer.decorator';
+export * from './api-cookie.decorator';
+export * from './api-oauth2.decorator';
+export * from './api-security.decorator';
+export { getSchemaPath } from './helpers';
+//# sourceMappingURL=index.d.ts.map

package/dist/decorators/index.js

@@ -0,0 +1,35 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSchemaPath = exports.ApiResponseProperty = exports.ApiPropertyOptional = exports.ApiProperty = void 0;
+__exportStar(require("./api-body.decorator"), exports);
+__exportStar(require("./api-exclude-endpoint.decorator"), exports);
+__exportStar(require("./api-exclude-controller.decorator"), exports);
+__exportStar(require("./api-header.decorator"), exports);
+__exportStar(require("./api-operation.decorator"), exports);
+__exportStar(require("./api-param.decorator"), exports);
+var api_property_decorator_1 = require("./api-property.decorator");
+Object.defineProperty(exports, "ApiProperty", { enumerable: true, get: function () { return api_property_decorator_1.ApiProperty; } });
+Object.defineProperty(exports, "ApiPropertyOptional", { enumerable: true, get: function () { return api_property_decorator_1.ApiPropertyOptional; } });
+Object.defineProperty(exports, "ApiResponseProperty", { enumerable: true, get: function () { return api_property_decorator_1.ApiResponseProperty; } });
+__exportStar(require("./api-query.decorator"), exports);
+__exportStar(require("./api-response.decorator"), exports);
+__exportStar(require("./api-tags.decorator"), exports);
+__exportStar(require("./api-extension.decorator"), exports);
+__exportStar(require("./api-basic.decorator"), exports);
+__exportStar(require("./api-bearer.decorator"), exports);
+__exportStar(require("./api-cookie.decorator"), exports);
+__exportStar(require("./api-oauth2.decorator"), exports);
+__exportStar(require("./api-security.decorator"), exports);
+var helpers_1 = require("./helpers");
+Object.defineProperty(exports, "getSchemaPath", { enumerable: true, get: function () { return helpers_1.getSchemaPath; } });
+//# sourceMappingURL=index.js.map

package/dist/documentBuilder.d.ts

@@ -0,0 +1,25 @@
+import { OpenAPIObject, ExternalDocumentationObject, SecurityRequirementObject, SecuritySchemeObject, ServerVariableObject, PathItemObject, SchemaObject } from './interfaces';
+export declare class DocumentBuilder {
+    private readonly document;
+    setTitle(title: string): this;
+    setDescription(description: string): this;
+    setVersion(version: string): this;
+    setTermsOfService(termsOfService: string): this;
+    setContact(name: string, url: string, email: string): this;
+    setLicense(name: string, url: string): this;
+    addServer(url: string, description?: string, variables?: Record<string, ServerVariableObject>): this;
+    setExternalDoc(description: string, url: string): this;
+    setBasePath(path: string): this;
+    addPaths(paths: Record<string, PathItemObject>): this;
+    addSchema(schema: Record<string, SchemaObject>): this;
+    addTag(name: string, description?: string, externalDocs?: ExternalDocumentationObject): this;
+    addSecurity(name: string, options: SecuritySchemeObject): this;
+    addSecurityRequirements(name: string | SecurityRequirementObject, requirements?: string[]): this;
+    addBearerAuth(options?: SecuritySchemeObject, name?: string): this;
+    addOAuth2(options?: SecuritySchemeObject, name?: string): this;
+    addApiKey(options?: SecuritySchemeObject, name?: string): this;
+    addBasicAuth(options?: SecuritySchemeObject, name?: string): this;
+    addCookieAuth(cookieName?: string, options?: SecuritySchemeObject, securityName?: string): this;
+    build(): Omit<OpenAPIObject, 'paths'>;
+}
+//# sourceMappingURL=documentBuilder.d.ts.map

package/dist/documentBuilder.js

@@ -0,0 +1,192 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DocumentBuilder = void 0;
+class DocumentBuilder {
+    constructor() {
+        this.document = {
+            openapi: '3.0.1',
+            info: {
+                title: '',
+                description: '',
+                version: '1.0.0',
+                contact: {},
+            },
+            tags: [],
+            servers: [],
+            components: {},
+            paths: {},
+        };
+    }
+    setTitle(title) {
+        this.document.info.title = title;
+        return this;
+    }
+    setDescription(description) {
+        this.document.info.description = description;
+        return this;
+    }
+    setVersion(version) {
+        this.document.info.version = version;
+        return this;
+    }
+    setTermsOfService(termsOfService) {
+        this.document.info.termsOfService = termsOfService;
+        return this;
+    }
+    setContact(name, url, email) {
+        this.document.info.contact = { name, url, email };
+        return this;
+    }
+    setLicense(name, url) {
+        this.document.info.license = { name, url };
+        return this;
+    }
+    addServer(url, description, variables) {
+        this.document.servers.push({ url, description, variables });
+        return this;
+    }
+    setExternalDoc(description, url) {
+        this.document.externalDocs = { description, url };
+        return this;
+    }
+    setBasePath(path) {
+        if (this.document.basePath) {
+            if (Array.isArray(this.document.basePath)) {
+                this.document.basePath.push(path);
+            }
+            else {
+                this.document.basePath = [
+                    this.document.basePath,
+                    path,
+                ];
+            }
+        }
+        else {
+            this.document.basePath = path;
+        }
+        return this;
+    }
+    addPaths(paths) {
+        Object.assign(this.document.paths, paths);
+        return this;
+    }
+    addSchema(schema) {
+        if (!this.document.components.schemas) {
+            this.document.components.schemas = {};
+        }
+        Object.assign(this.document.components.schemas, schema);
+        return this;
+    }
+    addTag(name, description = '', externalDocs) {
+        if (Array.isArray(name)) {
+            const arr = name;
+            for (const s of arr) {
+                this.document.tags.push({
+                    name: s,
+                    description: '',
+                });
+            }
+            return this;
+        }
+        this.document.tags.push({
+            name,
+            description,
+            externalDocs,
+        });
+        return this;
+    }
+    addSecurity(name, options) {
+        this.document.components.securitySchemes = {
+            ...(this.document.components.securitySchemes || {}),
+            [name]: options,
+        };
+        return this;
+    }
+    addSecurityRequirements(name, requirements = []) {
+        let securityRequirement;
+        if (typeof name === 'string') {
+            securityRequirement = { [name]: requirements };
+        }
+        else {
+            securityRequirement = name;
+        }
+        this.document.security = (this.document.security || []).concat({
+            ...securityRequirement,
+        });
+        return this;
+    }
+    addBearerAuth(options = {
+        type: 'http',
+    }, name = 'bearer') {
+        this.addSecurity(name, {
+            type: 'http',
+            scheme: 'bearer',
+            bearerFormat: 'JWT',
+            ...options,
+        });
+        return this;
+    }
+    addOAuth2(options = {
+        type: 'oauth2',
+    }, name = 'oauth2') {
+        if (!name) {
+            name = 'oauth2';
+        }
+        this.addSecurity(name, {
+            type: 'oauth2',
+            flows: {
+                ...options === null || options === void 0 ? void 0 : options.flows,
+            },
+        });
+        return this;
+    }
+    addApiKey(options = {
+        type: 'apiKey',
+    }, name = 'api_key') {
+        if (!name) {
+            name = 'api_key';
+        }
+        this.addSecurity(name, {
+            type: 'apiKey',
+            in: 'header',
+            name,
+            ...options,
+        });
+        return this;
+    }
+    addBasicAuth(options = {
+        type: 'http',
+    }, name = 'basic') {
+        if (!name) {
+            name = 'basic';
+        }
+        this.addSecurity(name, {
+            type: 'http',
+            scheme: 'basic',
+            ...options,
+        });
+        return this;
+    }
+    addCookieAuth(cookieName = 'connect.sid', options = {
+        type: 'apiKey',
+    }, securityName = 'cookie') {
+        if (!cookieName) {
+            cookieName = 'connect.sid';
+        }
+        if (!securityName) {
+            securityName = 'cookie';
+        }
+        this.addSecurity(securityName, {
+            type: 'apiKey',
+            in: 'cookie',
+            name: cookieName,
+            ...options,
+        });
+        return this;
+    }
+    build() {
+        return this.document;
+    }
+}
+exports.DocumentBuilder = DocumentBuilder;
+//# sourceMappingURL=documentBuilder.js.map