vona-module-a-openapi 5.0.11 → 5.0.13

package/dist/lib/decorator/api.d.ts

@@ -0,0 +1,23 @@
+import type { MetadataKey } from 'vona';
+import type { IOpenApiHeader, TypeResponseContentType } from '../../types/api.ts';
+import type { SchemaLike, SchemaLikeCreate } from '../../types/decorator.ts';
+import { Field } from './field.ts';
+export declare function setPublic(target: object, prop?: MetadataKey, _descriptor?: PropertyDescriptor, value?: boolean): void;
+declare function contentType(contentType: TypeResponseContentType): MethodDecorator;
+declare function body(...schemaLikes: SchemaLike[]): MethodDecorator;
+declare function bodyCustom(bodySchemaWrapper: SchemaLikeCreate | false, ...schemaLikes: SchemaLike[]): MethodDecorator;
+declare function exclude(): ClassDecorator & MethodDecorator;
+declare function tags(tags: string[]): ClassDecorator & MethodDecorator;
+declare function header(header: IOpenApiHeader): ClassDecorator & MethodDecorator;
+declare function headers(headers: IOpenApiHeader[]): ClassDecorator & MethodDecorator;
+export declare const Api: {
+    field: typeof Field;
+    contentType: typeof contentType;
+    body: typeof body;
+    bodyCustom: typeof bodyCustom;
+    exclude: typeof exclude;
+    tags: typeof tags;
+    header: typeof header;
+    headers: typeof headers;
+};
+export {};

package/dist/lib/decorator/arguments.d.ts

@@ -0,0 +1,38 @@
+import type { SchemaLike } from '../../types/decorator.ts';
+declare function Param(): ParameterDecorator;
+declare function Param(...schemaLikes: SchemaLike[]): ParameterDecorator;
+declare function Param(property: string, ...schemaLikes: SchemaLike[]): ParameterDecorator;
+declare function Query(): ParameterDecorator;
+declare function Query(...schemaLikes: SchemaLike[]): ParameterDecorator;
+declare function Query(property: string, ...schemaLikes: SchemaLike[]): ParameterDecorator;
+declare function Body(): ParameterDecorator;
+declare function Body(...schemaLikes: SchemaLike[]): ParameterDecorator;
+declare function Body(property: string, ...schemaLikes: SchemaLike[]): ParameterDecorator;
+declare function Headers(): ParameterDecorator;
+declare function Headers(...schemaLikes: SchemaLike[]): ParameterDecorator;
+declare function Headers(property: string, ...schemaLikes: SchemaLike[]): ParameterDecorator;
+declare function Fields(): ParameterDecorator;
+declare function Fields(...schemaLikes: SchemaLike[]): ParameterDecorator;
+declare function Fields(property: string, ...schemaLikes: SchemaLike[]): ParameterDecorator;
+declare function Field(): ParameterDecorator;
+declare function Field(...schemaLikes: SchemaLike[]): ParameterDecorator;
+declare function Field(property: string, ...schemaLikes: SchemaLike[]): ParameterDecorator;
+declare function Files(): ParameterDecorator;
+declare function Files(...schemaLikes: SchemaLike[]): ParameterDecorator;
+declare function Files(property: string, ...schemaLikes: SchemaLike[]): ParameterDecorator;
+declare function File(): ParameterDecorator;
+declare function File(...schemaLikes: SchemaLike[]): ParameterDecorator;
+declare function File(property: string, ...schemaLikes: SchemaLike[]): ParameterDecorator;
+declare function User(...schemaLikes: SchemaLike[]): ParameterDecorator;
+export declare const Arg: {
+    param: typeof Param;
+    query: typeof Query;
+    body: typeof Body;
+    headers: typeof Headers;
+    fields: typeof Fields;
+    field: typeof Field;
+    files: typeof Files;
+    file: typeof File;
+    user: typeof User;
+};
+export {};

package/dist/lib/decorator/field.d.ts

@@ -0,0 +1,2 @@
+import type { SchemaLike } from '../../types/decorator.ts';
+export declare function Field(...schemaLikes: SchemaLike[]): PropertyDecorator;

package/dist/lib/decorator/index.d.ts

@@ -0,0 +1,3 @@
+export * from './api.ts';
+export * from './arguments.ts';
+export * from './pipesArgument.ts';

package/dist/lib/decorator/pipesArgument.d.ts

@@ -0,0 +1,2 @@
+import type { RouteHandlerArgumentType, SchemaLike, TypeExtractValue } from '../../types/decorator.ts';
+export declare function createPipesArgumentDecorator(paramType: RouteHandlerArgumentType, extractValue?: TypeExtractValue): (field?: string | SchemaLike, ...schemaLikes: SchemaLike[]) => ParameterDecorator;

package/dist/lib/index.d.ts

@@ -0,0 +1,4 @@
+export * from './decorator/index.ts';
+export * from './schema/index.ts';
+export * from './utils.ts';
+export * from './zod/index.ts';

package/dist/lib/schema/bodySchemaWrapper.d.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+export declare function bodySchemaWrapperDefault(bodySchema: any): z.ZodObject<{
+    code: z.ZodString;
+    message: z.ZodString;
+    data: any;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    code: string;
+    data?: any;
+}, {
+    message: string;
+    code: string;
+    data?: any;
+}>;

package/dist/lib/schema/index.d.ts

@@ -0,0 +1,4 @@
+export * from './bodySchemaWrapper.ts';
+export * from './makeSchemaLikes.ts';
+export * from './schema.ts';
+export * from './v.ts';

package/dist/lib/schema/makeSchemaLikes.d.ts

@@ -0,0 +1,4 @@
+import type { z } from 'zod';
+import type { SchemaLike } from '../../types/decorator.ts';
+export declare function makeSchemaLikes(schemaLikes: SchemaLike[], typeInit: any): z.ZodSchema;
+export declare function makeSchemaLike(schemaLike: SchemaLike | undefined, schemaPrevious: z.ZodSchema): z.ZodSchema;

package/dist/lib/schema/schema.d.ts

@@ -0,0 +1,11 @@
+import type { Constructable } from 'vona';
+import type { ISchemaObjectOptions } from '../../types/decorator.ts';
+import { z } from 'zod';
+export declare function $schema(schemaLike: z.ZodSchema): z.ZodSchema;
+export declare function $schema(classType: StringConstructor): z.ZodString;
+export declare function $schema(classType: NumberConstructor): z.ZodNumber;
+export declare function $schema(classType: BooleanConstructor): z.ZodBoolean;
+export declare function $schema(classType: DateConstructor): z.ZodDate;
+export declare function $schema(classType: BigIntConstructor): z.ZodBigInt;
+export declare function $schema(classType: ArrayConstructor): z.ZodArray<z.ZodAny>;
+export declare function $schema<T>(classType: Constructable<T>, options?: ISchemaObjectOptions): z.ZodSchema<T>;

package/dist/lib/schema/v/helpers.d.ts

@@ -0,0 +1,13 @@
+import type { IpVersion } from 'zod';
+import type { errorUtil } from '../../zod/errorUtil.ts';
+import { z } from 'zod';
+export declare function schemaEmail(message?: errorUtil.ErrMessage): (schema: z.ZodString) => z.ZodString;
+export declare function schemaUrl(message?: errorUtil.ErrMessage): (schema: z.ZodString) => z.ZodString;
+export declare function schemaUuid(message?: errorUtil.ErrMessage): (schema: z.ZodString) => z.ZodString;
+export declare function schemaIp(options?: string | {
+    version?: IpVersion;
+    message?: string;
+}): (schema: z.ZodString) => z.ZodString;
+export declare function schemaMin(min: number, message?: errorUtil.ErrMessage): (schema: any) => any;
+export declare function schemaMax(max: number, message?: errorUtil.ErrMessage): (schema: any) => any;
+export declare function schemaTableIdentity(): (_schema: any) => any;

package/dist/lib/schema/v/openapi.d.ts

@@ -0,0 +1,7 @@
+import type { ZodOpenAPIMetadata } from '@asteasolutions/zod-to-openapi';
+import type { z, ZodTypeAny } from 'zod';
+export declare function schemaOpenapi<T extends ZodTypeAny>(metadata: Partial<ZodOpenAPIMetadata<z.input<T>>>): any;
+export declare function schemaOpenapi<T extends ZodTypeAny>(refId: string, metadata?: Partial<ZodOpenAPIMetadata<z.input<T>>>): any;
+export declare function schemaTitle<T extends ZodTypeAny>(title?: string): (schema: T) => T;
+export declare function schemaDescription<T extends ZodTypeAny>(description?: string): (schema: T) => T;
+export declare function schemaExample<T extends ZodTypeAny>(example?: any): (schema: T) => T;

package/dist/lib/schema/v/system.d.ts

@@ -0,0 +1,9 @@
+import type { Constructable } from 'vona';
+import type { ISchemaObjectOptions, SchemaLike } from '../../../types/decorator.ts';
+import { z } from 'zod';
+export declare function schemaDefault<T>(defaultValue: T): (schema: z.ZodSchema) => z.ZodSchema;
+export declare function schemaOptional(): (schema: z.ZodSchema) => z.ZodSchema;
+export declare function schemaObject<T>(classType: Constructable<T>, options?: ISchemaObjectOptions): (_schema: z.ZodSchema) => z.ZodSchema<T>;
+export declare function schemaArray(schemaLike?: SchemaLike, params?: z.RawCreateParams & {
+    separator?: string;
+}): (schema: z.ZodSchema) => z.ZodSchema;

package/dist/lib/schema/v.d.ts

@@ -0,0 +1,20 @@
+import { schemaEmail, schemaIp, schemaMax, schemaMin, schemaTableIdentity, schemaUrl, schemaUuid } from './v/helpers.ts';
+import { schemaDescription, schemaExample, schemaOpenapi, schemaTitle } from './v/openapi.ts';
+import { schemaArray, schemaDefault, schemaObject, schemaOptional } from './v/system.ts';
+export declare const v: {
+    array: typeof schemaArray;
+    default: typeof schemaDefault;
+    object: typeof schemaObject;
+    optional: typeof schemaOptional;
+    email: typeof schemaEmail;
+    url: typeof schemaUrl;
+    uuid: typeof schemaUuid;
+    ip: typeof schemaIp;
+    min: typeof schemaMin;
+    max: typeof schemaMax;
+    tableIdentity: typeof schemaTableIdentity;
+    openapi: typeof schemaOpenapi;
+    title: typeof schemaTitle;
+    description: typeof schemaDescription;
+    example: typeof schemaExample;
+};

package/dist/lib/utils.d.ts

@@ -0,0 +1,4 @@
+import type { Constructable } from 'vona';
+export declare function getTargetDecoratorRules(target: object): Record<PropertyKey, unknown>;
+export declare function getTargetDecoratorRuleColumns(target: object): Record<PropertyKey, unknown>;
+export declare function mergeFieldsOpenAPIMetadata(target: Constructable): void;

package/dist/lib/zod/errorUtil.d.ts

@@ -0,0 +1,9 @@
+export declare namespace errorUtil {
+    type ErrMessage = string | {
+        message?: string;
+    };
+    const errToObj: (message?: ErrMessage) => {
+        message?: string | undefined;
+    };
+    const toString: (message?: ErrMessage) => string | undefined;
+}

package/dist/lib/zod/errorsAdapter.d.ts

@@ -0,0 +1,2 @@
+import type { VonaApplication } from 'vona';
+export declare function errorsAdapter(app: VonaApplication): void;

package/dist/lib/zod/index.d.ts

@@ -0,0 +1,2 @@
+export * from './errorsAdapter.ts';
+export * from './errorUtil.ts';

package/dist/main.d.ts

@@ -0,0 +1,7 @@
+import type { IModuleMain } from 'vona';
+import { BeanSimple } from 'vona';
+export declare class Main extends BeanSimple implements IModuleMain {
+    moduleLoading(): Promise<void>;
+    moduleLoaded(): Promise<void>;
+    configLoaded(_config: any): Promise<void>;
+}

package/dist/service/openapi.d.ts

@@ -0,0 +1,19 @@
+import type { Constructable } from 'vona';
+import type { IOpenAPIObject } from '../types/api.ts';
+import { BeanBase } from 'vona';
+export declare class ServiceOpenapi extends BeanBase {
+    generateJson<K extends keyof IOpenAPIObject>(version?: K): IOpenAPIObject[K];
+    generateJsonOfControllerAction<K extends keyof IOpenAPIObject>(controller: Constructable, actionKey: string, version?: K): IOpenAPIObject[K];
+    private _translate;
+    private _translateSchema;
+    private _translateStrings;
+    private _translateString;
+    private _collectRegistry;
+    private _collectController;
+    private _registerControllerAction;
+    private _collectRequest;
+    private _collectResponses;
+    private _parseBodySchema;
+    private _prepareArgsMeta;
+    private _combineArgHeaders;
+}

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/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/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/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/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/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/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/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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "vona-module-a-openapi",
   "type": "module",
-  "version": "5.0.11",
+  "version": "5.0.13",
   "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 && vona :bin:buildModule && tsc -p tsconfig.build.json"
   }
 }