vona-module-a-openapiutils 5.0.12 → 5.0.14

package/dist/.metadata/locales.d.ts

@@ -7,4 +7,4 @@ export declare const locales: {
         ZodErrorRequired: string;
     };
 };
-export declare function $locale<K extends keyof (typeof locales)[TypeLocaleBase]>(key: K): `a-openapiutils::${K}`;
+export declare function $locale<K extends keyof (typeof locales)[TypeLocaleBase]>(key: K, ...args: any[]): import("vona").ILocaleMagic<`a-openapiutils::${K}`>;

package/dist/index.js

@@ -1,15 +1,15 @@
-import { BeanInfo, BeanScopeBase, registerMappedClassMetadataKey, appMetadata, appResource, cast, deepExtend, useApp, beanFullNameFromOnionName } from 'vona';
+import { BeanInfo, BeanScopeBase, $makeLocaleMagic, registerMappedClassMetadataKey, appMetadata, appResource, cast, deepExtend, useApp, beanFullNameFromOnionName } from 'vona';
+import { __decorate } from 'tslib';
 import { Scope } from 'vona-module-a-bean';
 import { isEmptyObject, isClass, isNil, combineParamsAndQuery } from '@cabloy/utils';
 import { z } from 'zod';
 import { ZodMetadata } from '@cabloy/zod-openapi';
 import { coerceWithNil } from '@cabloy/zod-query';
 
-var _dec, _dec2, _class;
-let ScopeModuleAOpenapiutils = (_dec = Scope(), _dec2 = BeanInfo({
+let ScopeModuleAOpenapiutils = class ScopeModuleAOpenapiutils extends BeanScopeBase {};
+ScopeModuleAOpenapiutils = __decorate([Scope(), BeanInfo({
   module: "a-openapiutils"
-}), _dec(_class = _dec2(_class = class ScopeModuleAOpenapiutils extends BeanScopeBase {}) || _class) || _class);
-
+})], ScopeModuleAOpenapiutils);
 /** scope: end */
 
 var locale_en_us = {
@@ -24,8 +24,8 @@ const locales = {
   'en-us': locale_en_us,
   'zh-cn': locale_zh_cn
 };
-function $locale(key) {
-  return `a-openapiutils::${key}`;
+function $locale(key, ...args) {
+  return $makeLocaleMagic(`a-openapiutils::${key}`, ...args);
 }
 
 const OrderCoreBase = 100;
@@ -38,8 +38,6 @@ const SymbolRouteHandlersArgumentsValue = Symbol('SymbolRouteHandlersArgumentsVa
 
 const SymbolOpenApiOptions = Symbol('SymbolOpenApiOptions');
 
-// not use z.ZodType
-
 const SymbolDecoratorRule = Symbol('SymbolDecoratorRule');
 
 function getTargetDecoratorRules(target, disableRegisterMetadata) {
@@ -75,7 +73,6 @@ function mergeFieldsOpenapiMetadata(target) {
     mergeFieldOpenapiMetadata(target.prototype, key, field);
   }
 }
-
 // fieldRule maybe undefined
 function mergeFieldOpenapiMetadata(target, prop, fieldRule) {
   // rules
@@ -110,6 +107,16 @@ function mergeFieldOpenapiMetadata(target, prop, fieldRule) {
 function prepareClassType(classType) {
   return isClass(classType) ? classType : cast(classType)();
 }
+function normalizeErrorParams(params, errorDefault) {
+  const params2 = params;
+  if (!params2) return errorDefault;
+  if (params2.toJSON) {
+    return {
+      error: () => params2
+    };
+  }
+  return z.util.normalizeParams(params2);
+}
 
 const __schemasDynamic = {};
 const SymbolSchemaDynamicRefId = Symbol('SymbolSchemaDynamicRefId');
@@ -232,44 +239,44 @@ function schemaFilterDateRange(options) {
 
 function schemaEmail(params) {
   return function (_schema) {
-    return z.email(params);
+    return z.email(normalizeErrorParams(params));
   };
 }
 function schemaUrl(params) {
   return function (_schema) {
-    return z.url(params);
+    return z.url(normalizeErrorParams(params));
   };
 }
 function schemaUuid(params) {
   return function (_schema) {
-    return z.uuid(params);
+    return z.uuid(normalizeErrorParams(params));
   };
 }
 function schemaIPv4(params) {
   return function (_schema) {
-    return z.ipv4(params);
+    return z.ipv4(normalizeErrorParams(params));
   };
 }
 function schemaIPv6(params) {
   return function (_schema) {
-    return z.ipv6(params);
+    return z.ipv6(normalizeErrorParams(params));
   };
 }
 function schemaMin(min, params) {
   return function (schema) {
     if (schema.type === 'string') {
-      return schema.min(min, params);
+      return schema.min(min, normalizeErrorParams(params));
     } else {
-      return schema.min(min, params);
+      return schema.min(min, normalizeErrorParams(params));
     }
   };
 }
 function schemaMax(max, params) {
   return function (schema) {
     if (schema.type === 'string') {
-      return schema.max(max, params);
+      return schema.max(max, normalizeErrorParams(params));
     } else {
-      return schema.max(max, params);
+      return schema.max(max, normalizeErrorParams(params));
     }
   };
 }
@@ -290,17 +297,17 @@ function schemaToUpperCase() {
 }
 function schemaLowercase(params) {
   return function (schema) {
-    return schema.lowercase(params);
+    return schema.lowercase(normalizeErrorParams(params));
   };
 }
 function schemaUppercase(params) {
   return function (schema) {
-    return schema.uppercase(params);
+    return schema.uppercase(normalizeErrorParams(params));
   };
 }
 function schemaRegex(regex, params) {
   return function (schema) {
-    return schema.regex(regex, params);
+    return schema.regex(regex, normalizeErrorParams(params));
   };
 }
 function schemaTableIdentity() {
@@ -453,9 +460,7 @@ function schemaArray(schemaLike, params) {
       if (typeof val !== 'string') return val;
       if (val.startsWith('[') && val.endsWith(']')) return JSON.parse(val);
       return val.split(params?.separator ?? ',');
-    }, z.array(makeSchemaLike(schemaLike ?? schema, z.any()), params)
-    // z.array(makeSchemaLike(schemaLike, schema), params),
-    );
+    }, z.array(makeSchemaLike(schemaLike ?? schema, z.any()), params));
   };
 }
 function schemaStrictObject() {
@@ -469,9 +474,11 @@ function schemaLooseObject() {
   };
 }
 function schemaRequired(params) {
-  params = params || $locale('ZodErrorRequired');
+  const errorDefault = {
+    error: () => $locale('ZodErrorRequired')
+  };
   return function (schema) {
-    schema._zod.def.error = z.util.normalizeParams(params).error;
+    schema._zod.def.error = normalizeErrorParams(params, errorDefault).error;
     return schema;
   };
 }
@@ -675,4 +682,4 @@ function $makeFilterTransform(filterTransformName, options) {
   return [filterTransformName, options];
 }
 
-export { $apiPath, $apiPathAndCombineParamsAndQuery, $locale, $makeFilterTransform, $makeSchema, $schema, $schemaLazy, Api, OrderBusinessBase, OrderCoreBase, OrderMaxBase, OrderUnknownBase, ScopeModuleAOpenapiutils, SymbolDecoratorRule, SymbolOpenApiOptions, SymbolRouteHandlersArgumentsMeta, SymbolRouteHandlersArgumentsValue, SymbolSchemaDynamicRefId, addSchemaDynamic, bodySchemaWrapperDefault, getSchemaDynamic, getSchemasDynamic, getTargetDecoratorRuleColumns, getTargetDecoratorRuleColumnsMap, getTargetDecoratorRules, locales, makeSchemaLike, makeSchemaLikes, mergeFieldOpenapiMetadata, mergeFieldsOpenapiMetadata, prepareClassType, setPublic, v };
+export { $apiPath, $apiPathAndCombineParamsAndQuery, $locale, $makeFilterTransform, $makeSchema, $schema, $schemaLazy, Api, OrderBusinessBase, OrderCoreBase, OrderMaxBase, OrderUnknownBase, ScopeModuleAOpenapiutils, SymbolDecoratorRule, SymbolOpenApiOptions, SymbolRouteHandlersArgumentsMeta, SymbolRouteHandlersArgumentsValue, SymbolSchemaDynamicRefId, addSchemaDynamic, bodySchemaWrapperDefault, getSchemaDynamic, getSchemasDynamic, getTargetDecoratorRuleColumns, getTargetDecoratorRuleColumnsMap, getTargetDecoratorRules, locales, makeSchemaLike, makeSchemaLikes, mergeFieldOpenapiMetadata, mergeFieldsOpenapiMetadata, normalizeErrorParams, prepareClassType, setPublic, v };

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

@@ -1,17 +1,18 @@
+import type { ILocaleMagic } from 'vona';
 import type { ISchemaObjectExtensionFieldCaptcha } from 'vona-module-a-openapi';
 import { z } from 'zod';
-export declare function schemaEmail(params?: string | z.core.$ZodEmailParams): (_schema: z.ZodString) => z.ZodEmail;
-export declare function schemaUrl(params?: string | z.core.$ZodURLParams): (_schema: z.ZodString) => z.ZodURL;
-export declare function schemaUuid(params?: string | z.core.$ZodUUIDParams): (_schema: z.ZodString) => z.ZodUUID;
-export declare function schemaIPv4(params?: string | z.core.$ZodIPv4Params): (_schema: z.ZodString) => z.ZodIPv4;
-export declare function schemaIPv6(params?: string | z.core.$ZodIPv6Params): (_schema: z.ZodString) => z.ZodIPv6;
-export declare function schemaMin(min: number, params?: string | z.core.$ZodCheckMinLengthParams | z.core.$ZodCheckGreaterThanParams): (schema: z.ZodString | z.ZodNumber) => z.ZodString | z.ZodNumber;
-export declare function schemaMax(max: number, params?: string | z.core.$ZodCheckMaxLengthParams | z.core.$ZodCheckLessThanParams): (schema: z.ZodString | z.ZodNumber) => z.ZodString | z.ZodNumber;
+export declare function schemaEmail(params?: string | ILocaleMagic | z.core.$ZodEmailParams): (_schema: z.ZodString) => z.ZodEmail;
+export declare function schemaUrl(params?: string | ILocaleMagic | z.core.$ZodURLParams): (_schema: z.ZodString) => z.ZodURL;
+export declare function schemaUuid(params?: string | ILocaleMagic | z.core.$ZodUUIDParams): (_schema: z.ZodString) => z.ZodUUID;
+export declare function schemaIPv4(params?: string | ILocaleMagic | z.core.$ZodIPv4Params): (_schema: z.ZodString) => z.ZodIPv4;
+export declare function schemaIPv6(params?: string | ILocaleMagic | z.core.$ZodIPv6Params): (_schema: z.ZodString) => z.ZodIPv6;
+export declare function schemaMin(min: number, params?: string | ILocaleMagic | z.core.$ZodCheckMinLengthParams | z.core.$ZodCheckGreaterThanParams): (schema: z.ZodString | z.ZodNumber) => z.ZodString | z.ZodNumber;
+export declare function schemaMax(max: number, params?: string | ILocaleMagic | z.core.$ZodCheckMaxLengthParams | z.core.$ZodCheckLessThanParams): (schema: z.ZodString | z.ZodNumber) => z.ZodString | z.ZodNumber;
 export declare function schemaTrim(): (schema: z.ZodString) => z.ZodString;
 export declare function schemaToLowerCase(): (schema: z.ZodString) => z.ZodString;
 export declare function schemaToUpperCase(): (schema: z.ZodString) => z.ZodString;
-export declare function schemaLowercase(params?: string | z.core.$ZodCheckLowerCaseParams): (schema: z.ZodString) => z.ZodString;
-export declare function schemaUppercase(params?: string | z.core.$ZodCheckUpperCaseParams): (schema: z.ZodString) => z.ZodString;
-export declare function schemaRegex(regex: RegExp, params?: string | z.core.$ZodCheckRegexParams): (schema: z.ZodString) => z.ZodString;
+export declare function schemaLowercase(params?: string | ILocaleMagic | z.core.$ZodCheckLowerCaseParams): (schema: z.ZodString) => z.ZodString;
+export declare function schemaUppercase(params?: string | ILocaleMagic | z.core.$ZodCheckUpperCaseParams): (schema: z.ZodString) => z.ZodString;
+export declare function schemaRegex(regex: RegExp, params?: string | ILocaleMagic | z.core.$ZodCheckRegexParams): (schema: z.ZodString) => z.ZodString;
 export declare function schemaTableIdentity(): (_schema?: any) => z.ZodType;
 export declare function schemaCaptcha(options: ISchemaObjectExtensionFieldCaptcha): (schema: z.ZodType) => z.ZodType;

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

@@ -1,7 +1,8 @@
-import type { ZodOpenAPIMetadata } from '@cabloy/zod-to-openapi';
+import type { ILocaleMagic } from 'vona';
+import type { TypeOpenapiMetadata } from 'vona-module-a-openapi';
 import type { z } from 'zod';
-export declare function schemaOpenapi<T extends z.ZodType>(metadata: Partial<ZodOpenAPIMetadata<z.input<T>>>): T;
-export declare function schemaOpenapi<T extends z.ZodType>(refId: string, metadata?: Partial<ZodOpenAPIMetadata<z.input<T>>>): T;
-export declare function schemaTitle<T extends z.ZodType>(title?: string): (schema: T) => T;
-export declare function schemaDescription<T extends z.ZodType>(description?: string): (schema: T) => T;
+export declare function schemaOpenapi<T extends z.ZodType>(metadata: TypeOpenapiMetadata<T>): T;
+export declare function schemaOpenapi<T extends z.ZodType>(refId: string, metadata?: TypeOpenapiMetadata<T>): T;
+export declare function schemaTitle<T extends z.ZodType>(title?: string | ILocaleMagic): (schema: T) => T;
+export declare function schemaDescription<T extends z.ZodType>(description?: string | ILocaleMagic): (schema: T) => T;
 export declare function schemaExample<T extends z.ZodType>(example?: any): (schema: T) => T;

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

@@ -1,4 +1,4 @@
-import type { Constructable } from 'vona';
+import type { Constructable, ILocaleMagic } from 'vona';
 import type { ISchemaObjectOptions } from 'vona-module-a-openapi';
 import type { SchemaLike } from '../../../types/decorator.ts';
 import { z } from 'zod';
@@ -11,4 +11,4 @@ export declare function schemaArray(schemaLike?: SchemaLike, params?: z.core.$Zo
 }): (schema: z.ZodType) => z.ZodType;
 export declare function schemaStrictObject(): (schema: z.ZodObject) => z.ZodObject;
 export declare function schemaLooseObject(): (schema: z.ZodObject) => z.ZodObject;
-export declare function schemaRequired(params?: string | z.core.$ZodStringParams): (schema: z.ZodType) => z.ZodType;
+export declare function schemaRequired(params?: string | ILocaleMagic | z.core.$ZodStringParams): (schema: z.ZodType) => z.ZodType;

package/dist/lib/utils.d.ts

@@ -1,4 +1,4 @@
-import type { Constructable } from 'vona';
+import type { Constructable, ILocaleMagic } from 'vona';
 import type { TypeOpenapiMetadata } from 'vona-module-a-openapi';
 import type { TypeDecoratorRules } from '../types/decorator.ts';
 import { z } from 'zod';
@@ -8,3 +8,4 @@ export declare function getTargetDecoratorRuleColumnsMap(target: object): Record
 export declare function mergeFieldsOpenapiMetadata(target: Constructable): void;
 export declare function mergeFieldOpenapiMetadata(target: object, prop: string, fieldRule?: TypeOpenapiMetadata | z.ZodType): TypeDecoratorRules;
 export declare function prepareClassType<T>(classType: (() => Constructable<T>) | Constructable<T>): Constructable<T>;
+export declare function normalizeErrorParams(params?: string | ILocaleMagic | any, errorDefault?: any): any;

package/dist/types/api.d.ts

@@ -1,6 +1,6 @@
 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 { ILocaleMagic, VonaApplication } from 'vona';
 import type z from 'zod';
 import type { SchemaLikeCreate } from './decorator.ts';
 export declare const SymbolOpenApiOptions: unique symbol;
@@ -24,8 +24,8 @@ export interface IOpenapiSchemaObject {
 export type TypeSecuritySchemes = Record<string, ((this: VonaApplication) => object) | object>;
 export interface IOpenApiOptions {
     public?: boolean;
-    description?: string;
-    summary?: string;
+    description?: string | ILocaleMagic;
+    summary?: string | ILocaleMagic;
     httpCode?: number;
     contentType?: TypeResponseContentType;
     bodySchema?: z.ZodType;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "vona-module-a-openapiutils",
   "type": "module",
-  "version": "5.0.12",
+  "version": "5.0.14",
   "title": "a-openapiutils",
   "vonaModule": {
     "dependencies": {}