vona-module-a-openapi 5.0.11 → 5.0.12

package/dist/service/openapi.js

@@ -0,0 +1,352 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { OpenApiGeneratorV3, OpenApiGeneratorV31, OpenAPIRegistry } from '@asteasolutions/zod-to-openapi';
+import * as ModuleInfo from '@cabloy/module-info';
+import { isEmptyObject } from '@cabloy/utils';
+import { toUpperCaseFirstChar } from '@cabloy/word-utils';
+import { appMetadata, appResource, BeanBase, cast, HttpStatus, LocaleModuleNameSeparator, } from 'vona';
+import { RequestMethod, Service, SymbolRequestMappingHandler, } from 'vona-module-a-web';
+import { z } from 'zod';
+import { bodySchemaWrapperDefault } from "../lib/schema/bodySchemaWrapper.js";
+import { $schema } from "../lib/schema/schema.js";
+import { SymbolOpenApiOptions } from "../types/api.js";
+import { SymbolRouteHandlersArgumentsMeta } from "../types/decorator.js";
+const __ArgumentTypes = ['param', 'query', 'body', 'headers', 'fields', 'field', 'files', 'file'];
+let ServiceOpenapi = class ServiceOpenapi extends BeanBase {
+    generateJson(version = 'V31') {
+        const registry = this._collectRegistry();
+        const generator = version === 'V30' ? new OpenApiGeneratorV3(registry.definitions) : new OpenApiGeneratorV31(registry.definitions);
+        const apiObj = generator.generateDocument(this.scope.config.generateDocument[version]);
+        this._translate(apiObj);
+        return apiObj;
+    }
+    generateJsonOfControllerAction(controller, actionKey, version = 'V31') {
+        const registry = new OpenAPIRegistry();
+        const beanOptions = appResource.getBean(controller);
+        if (!beanOptions)
+            throw new Error('invalid controller');
+        this._collectController(registry, beanOptions.module, controller, actionKey);
+        const generator = version === 'V30' ? new OpenApiGeneratorV3(registry.definitions) : new OpenApiGeneratorV31(registry.definitions);
+        const apiObj = generator.generateDocument(this.scope.config.generateDocument[version]);
+        this._translate(apiObj);
+        return apiObj;
+    }
+    _translate(apiObj) {
+        // paths
+        if (apiObj.paths) {
+            for (const key in apiObj.paths) {
+                const pathObj = apiObj.paths[key];
+                for (const method in pathObj) {
+                    const methodObj = pathObj[method];
+                    this._translateStrings(methodObj, ['description', 'summary']);
+                    // parameters
+                    for (const parameterObj of methodObj.parameters || []) {
+                        this._translateSchema(parameterObj.schema);
+                    }
+                    // requestBody
+                    this._translateSchema(methodObj.requestBody?.content?.['application/json']?.schema);
+                }
+            }
+        }
+        // components
+        if (apiObj.components?.schemas) {
+            for (const key in apiObj.components.schemas) {
+                const schema = apiObj.components.schemas[key];
+                this._translateSchema(schema);
+            }
+        }
+    }
+    _translateSchema(schema) {
+        if (!schema)
+            return;
+        if (schema.type === 'object' && schema.required === undefined)
+            schema.required = [];
+        this._translateStrings(schema, ['title', 'description']);
+        const properties = cast(schema).properties;
+        if (properties && typeof properties === 'object') {
+            for (const prop in properties) {
+                const propObj = properties[prop];
+                this._translateSchema(propObj);
+            }
+        }
+    }
+    _translateStrings(obj, keys) {
+        for (const key of keys) {
+            this._translateString(obj, key);
+        }
+    }
+    _translateString(obj, key) {
+        if (!obj)
+            return;
+        if (obj[key] && obj[key].includes(LocaleModuleNameSeparator)) {
+            obj[key] = this.app.meta.text(obj[key]);
+        }
+    }
+    _collectRegistry() {
+        const registry = new OpenAPIRegistry();
+        // securitySchemes
+        const configSecuritySchemes = this.scope.config.securitySchemes;
+        for (const key in configSecuritySchemes) {
+            let securityScheme = configSecuritySchemes[key];
+            if (typeof securityScheme === 'function') {
+                securityScheme = securityScheme.call(this.app);
+            }
+            registry.registerComponent('securitySchemes', key, securityScheme);
+        }
+        // schema: independent
+        for (const sceneName of ['dto', 'entity']) {
+            const onionSlices = this.bean.onion[sceneName].getOnionsEnabled();
+            for (const onionSlice of onionSlices) {
+                if (onionSlice.beanOptions.options?.independent) {
+                    const schema = $schema(onionSlice.beanOptions.beanClass);
+                    registry.register(onionSlice.beanOptions.beanFullName, schema);
+                }
+            }
+        }
+        // controller
+        for (const controller of this.bean.onion.controller.getOnionsEnabled()) {
+            this._collectController(registry, controller.beanOptions.module, controller.beanOptions.beanClass);
+        }
+        return registry;
+    }
+    _collectController(registry, moduleName, controller, actionKey) {
+        // info
+        const info = ModuleInfo.parseInfo(moduleName);
+        // controller options
+        const beanOptions = appResource.getBean(controller);
+        if (!beanOptions)
+            return;
+        const controllerBeanFullName = beanOptions.beanFullName;
+        const controllerOptions = beanOptions.options;
+        const controllerPath = controllerOptions.path;
+        const controllerOpenApiOptions = appMetadata.getMetadata(SymbolOpenApiOptions, controller);
+        if (controllerOpenApiOptions?.exclude)
+            return;
+        // descs
+        const descs = Object.getOwnPropertyDescriptors(controller.prototype);
+        const actionKeys = actionKey ? [actionKey] : Object.keys(descs);
+        for (const actionKey of actionKeys) {
+            const desc = descs[actionKey];
+            if (['constructor'].includes(actionKey))
+                continue;
+            if (!desc.value || typeof desc.value !== 'function')
+                continue;
+            this._registerControllerAction(registry, info, controller, beanOptions, controllerBeanFullName, controllerPath, controllerOpenApiOptions, actionKey, desc);
+        }
+    }
+    _registerControllerAction(registry, info, controller, beanOptions, _controllerBeanFullName, controllerPath, controllerOpenApiOptions, actionKey, _desc) {
+        // app
+        const app = this.app;
+        // action options: should not extend controllerOpenApiOptions
+        const actionOpenApiOptions = appMetadata.getMetadata(SymbolOpenApiOptions, controller.prototype, actionKey);
+        if (actionOpenApiOptions?.exclude)
+            return;
+        // actionPath/actionMethod
+        if (!appMetadata.hasMetadata(SymbolRequestMappingHandler, controller.prototype, actionKey))
+            return;
+        const handlerMetadata = appMetadata.getMetadata(SymbolRequestMappingHandler, controller.prototype, actionKey);
+        const actionPath = handlerMetadata.path || '';
+        const actionMethod = handlerMetadata.method || RequestMethod.GET;
+        // routePath
+        const routePath = app.util.combineApiPathControllerAndAction(info.relativeName, controllerPath, actionPath, true, true);
+        // :id -> {id}
+        const routePath2 = routePath.replace(/:([^/]+)/g, '{$1}');
+        // tags
+        let tags = actionOpenApiOptions?.tags ?? controllerOpenApiOptions?.tags;
+        if (!tags || tags.length === 0) {
+            tags = [toUpperCaseFirstChar(this.app.util.combineResourceName(beanOptions.name, info.relativeName, true, true))];
+        }
+        // operationId
+        let operationId = actionOpenApiOptions?.operationId ?? actionKey;
+        operationId = `${tags[0]}_${operationId}`;
+        // security
+        const _public = actionOpenApiOptions?.public ?? controllerOpenApiOptions?.public;
+        let security;
+        if (!_public) {
+            security = [
+                {
+                    bearerAuth: [],
+                },
+            ];
+        }
+        // registerPath
+        registry.registerPath({
+            tags,
+            method: actionMethod,
+            path: routePath2,
+            operationId,
+            security,
+            description: actionOpenApiOptions?.description,
+            summary: actionOpenApiOptions?.summary,
+            request: this._collectRequest(controller, actionKey, actionOpenApiOptions, controllerOpenApiOptions),
+            responses: this._collectResponses(controller, actionKey, actionOpenApiOptions),
+        });
+    }
+    _collectRequest(controller, actionKey, actionOpenApiOptions, controllerOpenApiOptions) {
+        // meta
+        const argsMeta = this._prepareArgsMeta(controller, actionKey, actionOpenApiOptions, controllerOpenApiOptions);
+        if (!argsMeta)
+            return;
+        // args
+        const argsMapWithField = {};
+        const argsMapIsolate = {};
+        let isUpload;
+        for (const argMeta of argsMeta) {
+            if (!__ArgumentTypes.includes(argMeta.type))
+                continue;
+            if (['fields', 'field', 'files', 'file'].includes(argMeta.type)) {
+                isUpload = true;
+            }
+            if (argMeta.field) {
+                if (!argsMapWithField[argMeta.type]) {
+                    argsMapWithField[argMeta.type] = {};
+                }
+                argsMapWithField[argMeta.type][argMeta.field] = argMeta.schema;
+            }
+            else {
+                if (!argsMapIsolate[argMeta.type]) {
+                    argsMapIsolate[argMeta.type] = argMeta.schema;
+                }
+            }
+        }
+        // request
+        const request = {};
+        if (isUpload) {
+            const schemaObj = {};
+            // not check argsMapIsolate.fields
+            if (argsMapWithField.fields)
+                Object.assign(schemaObj, argsMapWithField.fields);
+            if (argsMapWithField.field)
+                Object.assign(schemaObj, argsMapWithField.field);
+            if (argsMapWithField.files)
+                Object.assign(schemaObj, argsMapWithField.files);
+            if (argsMapWithField.file)
+                Object.assign(schemaObj, argsMapWithField.file);
+            if (argsMapIsolate.files)
+                schemaObj.blobs = argsMapIsolate.files;
+            const schema = z.object(schemaObj);
+            // body
+            request.body = {
+                required: true,
+                content: {
+                    'multipart/form-data': {
+                        schema,
+                    },
+                },
+            };
+        }
+        else {
+            for (const argumentType of __ArgumentTypes) {
+                let schema = argsMapIsolate[argumentType];
+                if (argsMapWithField[argumentType]) {
+                    if (!schema) {
+                        schema = z.object(argsMapWithField[argumentType]);
+                    }
+                    else {
+                        schema = schema.extend(argsMapWithField[argumentType]);
+                    }
+                }
+                if (!schema)
+                    continue;
+                // record
+                if (argumentType === 'body') {
+                    // body
+                    request.body = {
+                        required: !schema.isOptional(),
+                        content: {
+                            'application/json': {
+                                schema,
+                            },
+                        },
+                    };
+                }
+                else {
+                    // others
+                    const name = argumentType === 'param' ? 'params' : argumentType;
+                    request[name] = schema;
+                }
+            }
+        }
+        return request;
+    }
+    _collectResponses(controller, actionKey, actionOpenApiOptions) {
+        // contentType
+        const contentType = actionOpenApiOptions?.contentType || 'application/json';
+        // body schema
+        const bodySchema = this._parseBodySchema(controller, actionKey, actionOpenApiOptions, contentType);
+        // response
+        const response = {
+            description: '',
+            content: {
+                [contentType]: {
+                    schema: bodySchema,
+                },
+            },
+        };
+        // responses
+        const responses = { [HttpStatus.OK]: response };
+        return responses;
+    }
+    _parseBodySchema(controller, actionKey, actionOpenApiOptions, contentType) {
+        // bodySchema
+        let bodySchema;
+        if (actionOpenApiOptions?.bodySchema) {
+            bodySchema = actionOpenApiOptions.bodySchema;
+        }
+        else {
+            const metaType = appMetadata.getDesignReturntype(controller.prototype, actionKey);
+            bodySchema = $schema(metaType);
+        }
+        // wrapper
+        if (contentType !== 'application/json')
+            return bodySchema;
+        if (actionOpenApiOptions?.bodySchemaWrapper === false)
+            return bodySchema;
+        const wrapper = actionOpenApiOptions?.bodySchemaWrapper ?? bodySchemaWrapperDefault;
+        return wrapper(bodySchema);
+    }
+    _prepareArgsMeta(controller, actionKey, actionOpenApiOptions, controllerOpenApiOptions) {
+        // meta
+        let argsMeta = appMetadata.getMetadata(SymbolRouteHandlersArgumentsMeta, controller.prototype, actionKey);
+        // headers
+        const objHeaders = Object.assign({}, this._combineArgHeaders(controllerOpenApiOptions?.headers), this._combineArgHeaders(actionOpenApiOptions?.headers));
+        // public
+        const _public = actionOpenApiOptions?.public ?? controllerOpenApiOptions?.public;
+        if (!_public && !objHeaders.Authorization) {
+            objHeaders.Authorization = z.string().optional();
+        }
+        if (isEmptyObject(objHeaders))
+            return argsMeta;
+        // merge
+        if (!argsMeta)
+            argsMeta = [];
+        let argHeaders = argsMeta.find(item => item.type === 'headers' && !item.field);
+        if (!argHeaders) {
+            argHeaders = { type: 'headers', field: undefined, schema: z.object(objHeaders) };
+            argsMeta.push(argHeaders);
+        }
+        else {
+            if (!argHeaders.schema.extend)
+                throw new Error(`headers schema is not valid: ${actionKey}`);
+            argHeaders.schema = argHeaders.schema.extend(objHeaders);
+        }
+        return argsMeta;
+    }
+    _combineArgHeaders(headers) {
+        if (!headers)
+            return;
+        const objHeaders = {};
+        for (const header of headers) {
+            objHeaders[header.name] = z.string().openapi({ description: header.description });
+        }
+        return objHeaders;
+    }
+};
+ServiceOpenapi = __decorate([
+    Service()
+], ServiceOpenapi);
+export { ServiceOpenapi };

package/dist/types/actions.d.ts

@@ -0,0 +1,15 @@
+export interface IResourceActionTableOptions {
+}
+export interface IResourceActionRowOptions {
+}
+export interface TypeResourceActionTableRecord {
+    create: IResourceActionTableOptions;
+}
+export interface TypeResourceActionRowRecord {
+    view: IResourceActionRowOptions;
+    update: IResourceActionRowOptions;
+    delete: IResourceActionRowOptions;
+}
+export type TypeResourceActionRowRecordRender = {
+    [key in keyof TypeResourceActionRowRecord as `action${Capitalize<key>}`]: TypeResourceActionRowRecord[key];
+};

package/dist/types/actions.js

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

package/dist/types/api.d.ts

@@ -0,0 +1,33 @@
+import type { OpenAPIObject as OpenAPIObject30, SchemaObject as SchemaObject30 } from 'openapi3-ts/oas30';
+import type { OpenAPIObject as OpenAPIObject31, SchemaObject as SchemaObject31 } from 'openapi3-ts/oas31';
+import type { VonaApplication } from 'vona';
+import type { z } from 'zod';
+import type { SchemaLikeCreate } from './decorator.ts';
+export declare const SymbolOpenApiOptions: unique symbol;
+export interface IOpenApiHeader {
+    name: string;
+    description?: string;
+}
+export interface IOpenApiOptions {
+    public?: boolean;
+    description?: string;
+    summary?: string;
+    contentType?: TypeResponseContentType;
+    bodySchema?: z.ZodSchema;
+    bodySchemaWrapper?: SchemaLikeCreate | false;
+    exclude?: boolean;
+    tags?: string[];
+    operationId?: string;
+    headers?: IOpenApiHeader[];
+}
+export type TypeOpenApiVersion = 'V30' | 'V31';
+export interface IOpenAPIObject {
+    V30: OpenAPIObject30;
+    V31: OpenAPIObject31;
+}
+export interface IOpenAPISchemaObject {
+    V30: SchemaObject30;
+    V31: SchemaObject31;
+}
+export type TypeSecuritySchemes = Record<string, ((this: VonaApplication) => object) | object>;
+export type TypeResponseContentType = 'application/json' | 'application/xml' | 'application/x-www-form-urlencoded' | 'multipart/form-data' | 'text/plain' | 'text/html' | 'application/octet-stream' | 'application/pdf' | 'image/png' | 'image/jpeg' | 'image/gif' | 'image/webp' | 'image/svg+xml' | 'image/bmp' | 'image/tiff' | 'image/vnd.microsoft.icon' | 'image/vnd.wap.wbmp' | 'image/x-icon' | 'image/x-jng' | 'image/x-ms-bmp' | 'image/x-portable-bitmap' | 'image/x-portable-graymap' | 'image/x-portable-pixmap' | 'image/x-xbitmap' | 'image/x-xpixmap' | 'image/x-xwindowdump' | 'image/bmp' | 'image/x-bmp' | 'image/x-xbitmap' | 'image/x-win-bitmap' | 'image/x-windows-bmp' | 'image/ms-bmp' | 'image/x-ms-bmp' | 'image/x-icon' | 'image/x-ico' | 'image/vnd.microsoft.icon' | 'image/ico' | 'image/icon' | 'text/css' | 'text/csv' | 'text/html' | 'text/javascript' | 'text/plain' | 'text/xml' | 'application/javascript' | 'application/ecmascript' | 'application/json' | 'application/ld+json' | 'application/manifest+json' | 'application/javascript' | 'application/x-javascript' | 'application/x-json' | 'application/x-ms-application';

package/dist/types/api.js

@@ -0,0 +1 @@
+export const SymbolOpenApiOptions = Symbol('SymbolOpenApiOptions');

package/dist/types/behavior.d.ts

@@ -0,0 +1,10 @@
+export interface IBehaviorRecord {
+}
+export type TypeBehaviorRecordSelector<PREFIX extends string> = {
+    [K in keyof IBehaviorRecord as K extends `${string}:${PREFIX}${string}` ? K : never]: IBehaviorRecord[K];
+};
+export type TypeBehaviorRecordSelectorKeys<PREFIX extends string> = keyof TypeBehaviorRecordSelector<PREFIX>;
+export type TypeBehaviorRecordSelectorStrict<PREFIX extends string> = {
+    [K in keyof IBehaviorRecord as K extends `${string}:${PREFIX}` ? K : never]: IBehaviorRecord[K];
+};
+export type TypeBehaviorRecordSelectorKeysStrict<PREFIX extends string> = keyof TypeBehaviorRecordSelectorStrict<PREFIX>;

package/dist/types/behavior.js

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

package/dist/types/component.d.ts

@@ -0,0 +1,11 @@
+export interface IComponentRecord {
+}
+export type TypeComponentRecordSelector<PREFIX extends string> = {
+    [K in keyof IComponentRecord as K extends `${string}:${PREFIX}${string}` ? K : never]: IComponentRecord[K];
+};
+export type TypeComponentRecordSelectorKeys<PREFIX extends string> = keyof TypeComponentRecordSelector<PREFIX>;
+export type TypeComponentRecordSelectorStrict<PREFIX extends string> = {
+    [K in keyof IComponentRecord as K extends `${string}:${PREFIX}` ? K : never]: IComponentRecord[K];
+};
+export type TypeComponentRecordSelectorKeysStrict<PREFIX extends string> = keyof TypeComponentRecordSelectorStrict<PREFIX>;
+export type TypeComponentLayoutRecord = TypeComponentRecordSelector<'layout'>;

package/dist/types/component.js

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

package/dist/types/database.d.ts

@@ -0,0 +1,4 @@
+export declare const OrderCoreBase = 100;
+export declare const OrderBusinessBase = 1000;
+export declare const OrderUnknownBase = 10000;
+export declare const OrderMaxBase = 100000;

package/dist/types/database.js

@@ -0,0 +1,4 @@
+export const OrderCoreBase = 100;
+export const OrderBusinessBase = 1000;
+export const OrderUnknownBase = 10000;
+export const OrderMaxBase = 100000;

package/dist/types/decorator.d.ts

@@ -0,0 +1,30 @@
+import type { Constructable, Type, VonaContext } from 'vona';
+import type { z } from 'zod';
+export declare const SymbolDecoratorRule: unique symbol;
+export declare const SymbolDecoratorRuleColumn: unique symbol;
+export type SchemaLikeCreate = (schema: any) => any;
+export type SchemaLike = SchemaLikeCreate | z.ZodSchema | Constructable;
+export interface ISchemaObjectOptions {
+    passthrough?: boolean;
+    strict?: boolean;
+}
+export interface RouteHandlerArgumentMetaDecorator {
+    index: number;
+    type: RouteHandlerArgumentType;
+    field?: string;
+    pipes: (Function | z.ZodSchema)[];
+    schema: z.ZodSchema;
+    extractValue?: TypeExtractValue;
+}
+export interface RouteHandlerArgumentMeta {
+    type: RouteHandlerArgumentType;
+    field?: string;
+    metaType?: Type<any>;
+    controller: Constructable;
+    method: string;
+    index: number;
+}
+export type RouteHandlerArgumentType = 'request' | 'response' | 'body' | 'query' | 'param' | 'headers' | 'session' | 'fields' | 'field' | 'files' | 'file' | 'host' | 'ip' | 'rawBody' | 'string' | 'user';
+export declare const SymbolRouteHandlersArgumentsMeta: unique symbol;
+export declare const SymbolRouteHandlersArgumentsValue: unique symbol;
+export type TypeExtractValue = (ctx: VonaContext, argMeta: RouteHandlerArgumentMetaDecorator) => Promise<any>;

package/dist/types/decorator.js

@@ -0,0 +1,4 @@
+export const SymbolDecoratorRule = Symbol('SymbolDecoratorRule');
+export const SymbolDecoratorRuleColumn = Symbol('SymbolDecoratorRuleColumn');
+export const SymbolRouteHandlersArgumentsMeta = Symbol('SymbolRouteHandlersArgumentsMeta');
+export const SymbolRouteHandlersArgumentsValue = Symbol('SymbolRouteHandlersArgumentsValue');

package/dist/types/index.d.ts

@@ -0,0 +1,8 @@
+import '@cabloy/zod-query';
+export * from './actions.ts';
+export * from './api.ts';
+export * from './behavior.ts';
+export * from './component.ts';
+export * from './database.ts';
+export * from './decorator.ts';
+export * from './rest.ts';

package/dist/types/index.js

@@ -0,0 +1,8 @@
+import '@cabloy/zod-query';
+export * from "./actions.js";
+export * from "./api.js";
+export * from "./behavior.js";
+export * from "./component.js";
+export * from "./database.js";
+export * from "./decorator.js";
+export * from "./rest.js";

package/dist/types/rest.d.ts

@@ -0,0 +1,37 @@
+import type { ZodOpenAPIMetadata } from '@asteasolutions/zod-to-openapi';
+import type { CurrencyOptions } from '@zhennann/currency';
+import type { z, ZodTypeAny } from 'zod';
+import type { TypeResourceActionRowRecordRender } from './actions.ts';
+import type { IOpenApiOptions } from './api.ts';
+import type { IComponentRecord } from './component.ts';
+import 'openapi3-ts/oas30';
+import 'openapi3-ts/oas31';
+export interface ISchemaObjectExtensionFieldRest {
+    render?: TypeFieldRenderComponent;
+    currency?: CurrencyOptions | boolean;
+    visible?: boolean;
+    order?: number;
+    table?: Omit<ISchemaObjectExtensionFieldRest, 'table' | 'form'>;
+    form?: Omit<ISchemaObjectExtensionFieldRest, 'table' | 'form'>;
+}
+export interface ISchemaObjectExtensionField {
+    rest?: ISchemaObjectExtensionFieldRest;
+}
+declare module 'openapi3-ts/oas30' {
+    interface SchemaObject extends ISchemaObjectExtensionField {
+    }
+}
+declare module 'openapi3-ts/oas31' {
+    interface SchemaObject extends ISchemaObjectExtensionField {
+    }
+}
+export type TypeFieldRenderComponent = (keyof IComponentRecord) | (keyof TypeResourceActionRowRecordRender) | 'text' | 'textarea' | 'select' | 'checkbox' | 'radio' | 'switch' | 'image' | 'file' | 'color' | 'password' | 'email' | 'url';
+export type TypeFieldRenderComponentProvider = (keyof IComponentRecord) | (keyof TypeResourceActionRowRecordRender) | 'input' | 'textarea' | 'select';
+export type TypeSchemaScene = 'table' | 'form';
+export type TypeOpenAPIMetadata<T extends ZodTypeAny = ZodTypeAny> = Partial<ZodOpenAPIMetadata<z.input<T>>>;
+export type TypeEntityOptionsFields<T extends {}, More extends string | undefined = never> = {
+    [key in ((keyof Omit<T, '$column' | '$columns' | '$table'>) | (More extends string ? More : never))]?: TypeOpenAPIMetadata | z.ZodSchema;
+};
+export type TypeControllerOptionsActions<T extends {}> = {
+    [key in (keyof T)]?: IOpenApiOptions;
+};

package/dist/types/rest.js

@@ -0,0 +1,2 @@
+import 'openapi3-ts/oas30';
+import 'openapi3-ts/oas31';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "vona-module-a-openapi",
   "type": "module",
-  "version": "5.0.11",
+  "version": "5.0.12",
   "title": "a-openapi",
   "vonaModule": {
     "capabilities": {
@@ -40,9 +40,13 @@
     "openapi3-ts": "^4.4.0",
     "zod": "^3.23.8"
   },
+  "devDependencies": {
+    "clean-package": "^2.2.0",
+    "rimraf": "^6.0.1"
+  },
   "gitHead": "0eab9dc4a5622caffe89e7b1b3f02c08ccbc4c4b",
   "scripts": {
-    "clean": "rimraf dist tsconfig.tsbuildinfo",
-    "tsc:publish": "npm run clean && tsc"
+    "clean": "rimraf dist tsconfig.build.tsbuildinfo",
+    "tsc:publish": "npm run clean && tsc -p tsconfig.build.json"
   }
 }