vona-module-a-openapi 5.0.11 → 5.0.12

package/dist/lib/decorator/field.js

@@ -0,0 +1,15 @@
+import { appMetadata } from 'vona';
+import { makeSchemaLikes } from "../schema/makeSchemaLikes.js";
+import { getTargetDecoratorRuleColumns, getTargetDecoratorRules } from "../utils.js";
+export function Field(...schemaLikes) {
+    return function (target, prop) {
+        // rules
+        const rules = getTargetDecoratorRules(target);
+        // rule
+        const metaType = appMetadata.getDesignType(target, prop);
+        rules[prop] = makeSchemaLikes(schemaLikes, metaType);
+        //
+        const columns = getTargetDecoratorRuleColumns(target);
+        columns[prop] = prop;
+    };
+}

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/index.js

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

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/decorator/pipesArgument.js

@@ -0,0 +1,35 @@
+import { appMetadata } from 'vona';
+import { z } from 'zod';
+import { SymbolRouteHandlersArgumentsMeta, } from "../../types/decorator.js";
+import { makeSchemaLikes } from "../schema/makeSchemaLikes.js";
+export function createPipesArgumentDecorator(paramType, extractValue) {
+    return function (field, ...schemaLikes) {
+        return function (target, prop, index) {
+            // not inherit
+            const argsMeta = appMetadata.getOwnMetadataArray(false, SymbolRouteHandlersArgumentsMeta, target, prop);
+            const hasParamField = typeof field === 'string';
+            const paramField = hasParamField ? field : undefined;
+            const paramSchemaLikes = hasParamField ? schemaLikes : [field, ...schemaLikes].filter(item => !!item);
+            const paramtypes = appMetadata.getMetadata('design:paramtypes', target, prop);
+            let metaType;
+            if (paramType === 'file') {
+                metaType = z.string().openapi({ format: 'binary' });
+            }
+            else if (paramType === 'files') {
+                metaType = z.array(z.string().openapi({ format: 'binary' }));
+            }
+            else {
+                metaType = paramtypes[index];
+            }
+            const argSchema = makeSchemaLikes(paramSchemaLikes, metaType);
+            argsMeta.push({
+                index,
+                type: paramType,
+                field: paramField,
+                pipes: [argSchema],
+                schema: argSchema,
+                extractValue,
+            });
+        };
+    };
+}

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/index.js

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

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/bodySchemaWrapper.js

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+export function bodySchemaWrapperDefault(bodySchema) {
+    return z.object({
+        code: z.string(),
+        message: z.string(),
+        data: bodySchema,
+    });
+}

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/index.js

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

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/makeSchemaLikes.js

@@ -0,0 +1,29 @@
+import { cast, isClassStrict } from 'vona';
+import { $schema } from "./schema.js";
+export function makeSchemaLikes(schemaLikes, typeInit) {
+    // default schema
+    let argSchema = $schema(typeInit);
+    // loop
+    for (let index = schemaLikes.length - 1; index >= 0; index--) {
+        const schemaLike = schemaLikes[index];
+        argSchema = makeSchemaLike(schemaLike, argSchema);
+    }
+    return argSchema;
+}
+export function makeSchemaLike(schemaLike, schemaPrevious) {
+    if (!schemaLike)
+        return schemaPrevious;
+    if (Object.prototype.hasOwnProperty.call(schemaLike, 'parseAsync')) {
+        // schema
+        return schemaLike;
+    }
+    else if (isClassStrict(schemaLike) ||
+        ['String', 'Number', 'Boolean', 'Date', 'BigInt', 'Array'].includes(cast(schemaLike).name)) {
+        // class
+        return $schema(cast(schemaLike));
+    }
+    else {
+        // function
+        return cast(schemaLike)(schemaPrevious);
+    }
+}

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/schema.js

@@ -0,0 +1,40 @@
+import { appMetadata, appResource, cast } from 'vona';
+import { z } from 'zod';
+import { SymbolDecoratorRule } from "../../types/decorator.js";
+export function $schema(classType, options) {
+    if (!classType)
+        return z.any();
+    if (classType.parseAsync)
+        return classType;
+    if (classType.name === 'String')
+        return z.string();
+    if (classType.name === 'Number')
+        return z.number();
+    if (classType.name === 'Boolean')
+        return z.boolean();
+    if (classType.name === 'Date')
+        return z.date();
+    if (classType.name === 'BigInt')
+        return z.bigint();
+    if (classType.name === 'Array')
+        return z.array(z.any());
+    // check if object
+    const rules = classType.prototype ? appMetadata.getMetadata(SymbolDecoratorRule, classType.prototype) : undefined;
+    if (!rules) {
+        // not object
+        return z.any();
+    }
+    // object
+    let schema = z.object(rules);
+    if (options?.passthrough)
+        schema = schema.passthrough();
+    if (options?.strict)
+        schema = schema.strict();
+    // refId
+    const beanOptions = appResource.getBean(classType);
+    if (beanOptions) {
+        const openapi = cast(beanOptions.options)?.openapi;
+        schema = schema.openapi(beanOptions.beanFullName, openapi);
+    }
+    return schema;
+}

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/helpers.js

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+export function schemaEmail(message) {
+    return function (schema) {
+        return schema.email(message);
+    };
+}
+export function schemaUrl(message) {
+    return function (schema) {
+        return schema.url(message);
+    };
+}
+export function schemaUuid(message) {
+    return function (schema) {
+        return schema.uuid(message);
+    };
+}
+export function schemaIp(options) {
+    return function (schema) {
+        return schema.ip(options);
+    };
+}
+export function schemaMin(min, message) {
+    return function (schema) {
+        return schema.min(min, message);
+    };
+}
+export function schemaMax(max, message) {
+    return function (schema) {
+        return schema.max(max, message);
+    };
+}
+export function schemaTableIdentity() {
+    return function (_schema) {
+        return z.union([z.string(), z.number()]);
+    };
+}

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/openapi.js

@@ -0,0 +1,20 @@
+export function schemaOpenapi(refId, metadata) {
+    return function (schema) {
+        return schema.openapi(refId, metadata);
+    };
+}
+export function schemaTitle(title) {
+    return function (schema) {
+        return schema.openapi({ title });
+    };
+}
+export function schemaDescription(description) {
+    return function (schema) {
+        return schema.openapi({ description });
+    };
+}
+export function schemaExample(example) {
+    return function (schema) {
+        return schema.openapi({ example });
+    };
+}

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/system.js

@@ -0,0 +1,34 @@
+import { isNil } from '@cabloy/utils';
+import { coerceWithNil } from '@cabloy/zod-query';
+import { z } from 'zod';
+import { makeSchemaLike } from "../makeSchemaLikes.js";
+import { $schema } from "../schema.js";
+export function schemaDefault(defaultValue) {
+    return function (schema) {
+        return schema.default(defaultValue);
+    };
+}
+export function schemaOptional() {
+    return function (schema) {
+        return schema.optional();
+    };
+}
+export function schemaObject(classType, options) {
+    return function (_schema) {
+        return $schema(classType, options);
+    };
+}
+export function schemaArray(schemaLike, params) {
+    return function (schema) {
+        return z.preprocess(val => {
+            val = coerceWithNil(val);
+            if (isNil(val))
+                return val;
+            if (typeof val !== 'string')
+                return val;
+            if (isNil(params?.separator) && val[0] === '[')
+                return JSON.parse(val);
+            return val.split(params?.separator ?? ',');
+        }, z.array(makeSchemaLike(schemaLike ?? schema, z.any()), params));
+    };
+}

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/schema/v.js

@@ -0,0 +1,22 @@
+import { schemaEmail, schemaIp, schemaMax, schemaMin, schemaTableIdentity, schemaUrl, schemaUuid } from "./v/helpers.js";
+import { schemaDescription, schemaExample, schemaOpenapi, schemaTitle } from "./v/openapi.js";
+import { schemaArray, schemaDefault, schemaObject, schemaOptional } from "./v/system.js";
+export const v = {
+    array: schemaArray,
+    default: schemaDefault,
+    object: schemaObject,
+    optional: schemaOptional,
+    // helpers
+    email: schemaEmail,
+    url: schemaUrl,
+    uuid: schemaUuid,
+    ip: schemaIp,
+    min: schemaMin,
+    max: schemaMax,
+    tableIdentity: schemaTableIdentity,
+    // openapi
+    openapi: schemaOpenapi,
+    title: schemaTitle,
+    description: schemaDescription,
+    example: 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/utils.js

@@ -0,0 +1,43 @@
+import { appMetadata, appResource, cast, deepExtend, registerMappedClassMetadataKey } from 'vona';
+import { z } from 'zod';
+import { SymbolDecoratorRule, SymbolDecoratorRuleColumn } from "../types/decorator.js";
+export function getTargetDecoratorRules(target) {
+    registerMappedClassMetadataKey(target, SymbolDecoratorRule, {
+        partialClass: (meta) => {
+            return meta.optional();
+        },
+    });
+    return appMetadata.getOwnMetadataMap(true, SymbolDecoratorRule, target);
+}
+export function getTargetDecoratorRuleColumns(target) {
+    registerMappedClassMetadataKey(target, SymbolDecoratorRuleColumn);
+    return appMetadata.getOwnMetadataMap(true, SymbolDecoratorRuleColumn, target);
+}
+export function mergeFieldsOpenAPIMetadata(target) {
+    // rules
+    const rules = getTargetDecoratorRules(target.prototype);
+    // beanOptions
+    const beanOptions = appResource.getBean(target);
+    const fields = cast(beanOptions?.options)?.fields;
+    if (!fields)
+        return;
+    for (const key in fields) {
+        const field = fields[key];
+        if (!field)
+            continue;
+        const schemaCurrent = rules[key];
+        if (Object.prototype.hasOwnProperty.call(field, 'parseAsync')) {
+            const schema = field;
+            rules[key] = schema.openapi(deepExtend({}, schemaCurrent?._def.openapi?.metadata, schema._def.openapi?.metadata));
+        }
+        else {
+            // use deepExtend for sure strict
+            if (schemaCurrent) {
+                rules[key] = schemaCurrent.openapi(deepExtend({}, schemaCurrent._def.openapi?.metadata, field));
+            }
+            else {
+                rules[key] = z.any().openapi(deepExtend({}, field));
+            }
+        }
+    }
+}

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/errorUtil.js

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

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/errorsAdapter.js

@@ -0,0 +1,9 @@
+import { setErrorMapDefault, setErrorMapSchema } from '@cabloy/zod-errors-custom';
+export function errorsAdapter(app) {
+    setErrorMapDefault((text, ...args) => {
+        return app.meta.text(text, ...args);
+    });
+    setErrorMapSchema((text, ...args) => {
+        return app.meta.text(text, ...args);
+    });
+}

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

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

package/dist/lib/zod/index.js

@@ -0,0 +1,2 @@
+export * from "./errorsAdapter.js";
+export * from "./errorUtil.js";

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/main.js

@@ -0,0 +1,9 @@
+import { BeanSimple } from 'vona';
+import { errorsAdapter } from "./lib/zod/errorsAdapter.js";
+export class Main extends BeanSimple {
+    async moduleLoading() { }
+    async moduleLoaded() {
+        errorsAdapter(this.app);
+    }
+    async configLoaded(_config) { }
+}

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;
+}