vona-module-a-openapiutils 5.0.12 → 5.0.13

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): import("vona").ILocaleMagic<`a-openapiutils::${K}`>;

package/dist/index.js

@@ -1,4 +1,4 @@
-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 { Scope } from 'vona-module-a-bean';
 import { isEmptyObject, isClass, isNil, combineParamsAndQuery } from '@cabloy/utils';
 import { z } from 'zod';
@@ -25,7 +25,7 @@ const locales = {
   'zh-cn': locale_zh_cn
 };
 function $locale(key) {
-  return `a-openapiutils::${key}`;
+  return $makeLocaleMagic(`a-openapiutils::${key}`);
 }
 
 const OrderCoreBase = 100;
@@ -110,6 +110,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 +242,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 +300,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() {
@@ -469,9 +479,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 +687,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.13",
   "title": "a-openapiutils",
   "vonaModule": {
     "dependencies": {}