@midwayjs/swagger 1.2.0 → 3.0.0-beta.12

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiExtension = void 0;
+const constants_1 = require("../constants");
+const helpers_1 = require("./helpers");
+function ApiExtension(extensionKey, extensionProperties) {
+    if (!extensionKey.startsWith('x-')) {
+        throw new Error('Extension key is not prefixed. Please ensure you prefix it with `x-`.');
+    }
+    const extensionObject = {
+        [extensionKey]: JSON.parse(JSON.stringify(extensionProperties)),
+    };
+    return (0, helpers_1.createMixedDecorator)(constants_1.DECORATORS.API_EXTENSION, extensionObject);
+}
+exports.ApiExtension = ApiExtension;
+//# sourceMappingURL=api-extension.decorator.js.map

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

@@ -0,0 +1,7 @@
+import { SwaggerEnumType, ParameterObject } from '../interfaces';
+export interface ApiHeaderOptions extends Omit<ParameterObject, 'in'> {
+    enum?: SwaggerEnumType;
+}
+export declare function ApiHeader(options: ApiHeaderOptions): any;
+export declare const ApiHeaders: (headers: ApiHeaderOptions[]) => MethodDecorator & ClassDecorator;
+//# sourceMappingURL=api-header.decorator.d.ts.map

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

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiHeaders = exports.ApiHeader = void 0;
+const constants_1 = require("../constants");
+const enum_utils_1 = require("../common/enum.utils");
+const helpers_1 = require("./helpers");
+const decorator_1 = require("@midwayjs/decorator");
+const defaultHeaderOptions = {
+    name: '',
+};
+function ApiHeader(options) {
+    const param = {
+        name: !options.name ? defaultHeaderOptions.name : options.name,
+        in: 'header',
+        description: options.description,
+        required: options.required,
+        schema: {
+            ...(options.schema || {}),
+            type: 'string',
+        },
+    };
+    if (options.enum) {
+        const enumValues = (0, enum_utils_1.getEnumValues)(options.enum);
+        param.schema = {
+            enum: enumValues,
+            type: (0, enum_utils_1.getEnumType)(enumValues),
+        };
+    }
+    return (target, key, descriptor) => {
+        if (descriptor) {
+            return (0, helpers_1.createParamDecorator)(param, defaultHeaderOptions)(target, key, descriptor);
+        }
+        return (0, decorator_1.createCustomMethodDecorator)(constants_1.DECORATORS.API_HEADERS, param)(target, undefined, undefined);
+    };
+}
+exports.ApiHeader = ApiHeader;
+const ApiHeaders = (headers) => {
+    return (target, key, descriptor) => {
+        headers.forEach(options => ApiHeader(options)(target, key, descriptor));
+    };
+};
+exports.ApiHeaders = ApiHeaders;
+//# sourceMappingURL=api-header.decorator.js.map

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

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

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

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiOAuth2 = void 0;
+const api_security_decorator_1 = require("./api-security.decorator");
+function ApiOAuth2(scopes, name = 'oauth2') {
+    return (0, api_security_decorator_1.ApiSecurity)(name, scopes);
+}
+exports.ApiOAuth2 = ApiOAuth2;
+//# sourceMappingURL=api-oauth2.decorator.js.map

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

@@ -0,0 +1,4 @@
+import { OperationObject } from '../interfaces';
+export declare type ApiOperationOptions = Partial<OperationObject>;
+export declare function ApiOperation(options: ApiOperationOptions): MethodDecorator;
+//# sourceMappingURL=api-operation.decorator.d.ts.map

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiOperation = void 0;
+const decorator_1 = require("@midwayjs/decorator");
+const constants_1 = require("../constants");
+const defaultOperationOptions = {
+    summary: '',
+};
+function ApiOperation(options) {
+    return (0, decorator_1.createCustomMethodDecorator)(constants_1.DECORATORS.API_OPERATION, {
+        ...defaultOperationOptions,
+        ...options,
+    });
+}
+exports.ApiOperation = ApiOperation;
+//# sourceMappingURL=api-operation.decorator.js.map

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

@@ -0,0 +1,15 @@
+import { Type, ParameterObject, SchemaObject, SwaggerEnumType } from '../interfaces';
+declare type ParameterOptions = Omit<ParameterObject, 'in' | 'schema'>;
+interface ApiParamMetadata extends ParameterOptions {
+    type?: Type | string;
+    format?: string;
+    enum?: SwaggerEnumType;
+    enumName?: string;
+}
+interface ApiParamSchemaHost extends ParameterOptions {
+    schema: SchemaObject;
+}
+export declare type ApiParamOptions = ApiParamMetadata | ApiParamSchemaHost;
+export declare function ApiParam(options: ApiParamOptions): MethodDecorator;
+export {};
+//# sourceMappingURL=api-param.decorator.d.ts.map

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

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiParam = void 0;
+const helpers_1 = require("./helpers");
+const enum_utils_1 = require("../common/enum.utils");
+const defaultParamOptions = {
+    name: '',
+    required: true,
+};
+function ApiParam(options) {
+    const param = {
+        name: !options.name ? defaultParamOptions.name : options.name,
+        in: 'path',
+        ...options,
+    };
+    const apiParamMetadata = options;
+    if (apiParamMetadata.enum) {
+        param.schema = param.schema || {};
+        const paramSchema = param.schema;
+        const enumValues = (0, enum_utils_1.getEnumValues)(apiParamMetadata.enum);
+        paramSchema.type = (0, enum_utils_1.getEnumType)(enumValues);
+        paramSchema.enum = enumValues;
+        if (apiParamMetadata.enumName) {
+            param.enumName = apiParamMetadata.enumName;
+        }
+    }
+    return (0, helpers_1.createParamDecorator)(param, defaultParamOptions);
+}
+exports.ApiParam = ApiParam;
+//# sourceMappingURL=api-param.decorator.js.map

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,55 @@
+"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,
+    };
+    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 (isArray) {
+        options.type = 'array';
+        options.items = {
+            type: type,
+        };
+    }
+    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 | 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