vona-module-a-openapi 5.0.54 → 5.0.55

package/dist/.metadata/index.d.ts

@@ -75,26 +75,17 @@ export interface IModuleSummerCache {
 /** config: begin */
 export * from '../config/config.ts';
 import type { config } from '../config/config.ts';
-export declare const locales: {
-    'en-us': {
-        ZodErrorRequired: string;
-    };
-    'zh-cn': {
-        ZodErrorRequired: string;
-    };
-};
-/** locale: end */
+/** config: end */
 /** main: begin */
 export * from '../main.ts';
 /** main: end */
 /** scope: begin */
-import { BeanScopeBase, type BeanScopeUtil, type TypeModuleConfig, type TypeModuleLocales, type TypeLocaleBase } from 'vona';
+import { BeanScopeBase, type BeanScopeUtil, type TypeModuleConfig } from 'vona';
 export declare class ScopeModuleAOpenapi extends BeanScopeBase {
 }
 export interface ScopeModuleAOpenapi {
     util: BeanScopeUtil;
     config: TypeModuleConfig<typeof config>;
-    locale: TypeModuleLocales<(typeof locales)[TypeLocaleBase]>;
     service: IModuleService;
     summerCache: IModuleSummerCache;
 }
@@ -109,9 +100,5 @@ declare module 'vona' {
     interface IBeanScopeConfig {
         'a-openapi': ReturnType<typeof config>;
     }
-    interface IBeanScopeLocale {
-        'a-openapi': (typeof locales)[TypeLocaleBase];
-    }
 }
-export declare function $locale<K extends keyof (typeof locales)[TypeLocaleBase]>(key: K): `a-openapi::${K}`;
 /** scope: end */

package/dist/bean/bean.openapi.d.ts

@@ -1,11 +1,12 @@
 import type { Constructable } from 'vona';
+import type { ICachingActionKeyInfo } from 'vona-module-a-caching';
 import type { IOpenapiObject } from 'vona-module-a-openapiutils';
 import { BeanBase } from 'vona';
 export declare class BeanOpenapi extends BeanBase {
     generateJsonOfClass<K extends keyof IOpenapiObject>(schemaClass: Constructable, version?: K): Promise<IOpenapiObject[K]>;
     generateJsonOfClasses<K extends keyof IOpenapiObject>(schemaClasses: Constructable[], version?: K): Promise<IOpenapiObject[K]>;
-    protected generateJsonCacheKey(args: any[], prop: string): string;
-    protected generateJsonOfControllerActionCacheKey(args: any[], prop: string): string;
+    protected generateJsonCacheKey(info: ICachingActionKeyInfo): string;
+    protected generateJsonOfControllerActionCacheKey(info: ICachingActionKeyInfo): string;
     generateJson<K extends keyof IOpenapiObject>(version?: K): Promise<IOpenapiObject[K]>;
     generateJsonOfControllerAction<K extends keyof IOpenapiObject>(controller: Constructable, actionKey: string, version?: K): Promise<IOpenapiObject[K]>;
 }

package/dist/index.js

@@ -1,17 +1,17 @@
-import { registerMappedClassMetadataKey, appMetadata, appResource, cast, deepExtend, BeanInfo, BeanBase, LocaleModuleNameSeparator, BeanSimple, BeanScopeBase, useApp, beanFullNameFromOnionName } from 'vona';
+import { BeanInfo, BeanBase, appResource, cast, LocaleModuleNameSeparator, appMetadata, BeanSimple, BeanScopeBase } from 'vona';
 import { OpenAPIRegistry, OpenApiGeneratorV3, OpenApiGeneratorV31 } from '@cabloy/zod-to-openapi';
 import { Bean, Service, Scope } from 'vona-module-a-bean';
 import { Caching } from 'vona-module-a-caching';
-import { SymbolDecoratorRule, SymbolOpenApiOptions } from 'vona-module-a-openapiutils';
-import { z } from 'zod';
-import { isEmptyObject, isClass, isNil } from '@cabloy/utils';
-import { ZodMetadata } from '@cabloy/zod-openapi';
+import { $schema, SymbolOpenApiOptions, bodySchemaWrapperDefault, SymbolRouteHandlersArgumentsMeta } from 'vona-module-a-openapiutils';
 import * as ModuleInfo from '@cabloy/module-info';
+import { isNil, isEmptyObject } from '@cabloy/utils';
 import { toUpperCaseFirstChar } from '@cabloy/word-utils';
 import { translateError } from '@cabloy/zod-errors-custom';
-import { getInnerTypeName, coerceWithNil } from '@cabloy/zod-query';
+import { getInnerTypeName } from '@cabloy/zod-query';
 import { SymbolRequestMappingHandler } from 'vona-module-a-web';
+import { z } from 'zod';
 import { SummerCache, BeanSummerCacheBase } from 'vona-module-a-summer';
+import { ZodMetadata } from '@cabloy/zod-openapi';
 import 'openapi3-ts/oas30';
 import 'openapi3-ts/oas31';
 
@@ -24,169 +24,6 @@ function _applyDecoratedDescriptor(i, e, r, n, l) {
   }, a), l && void 0 !== a.initializer && (a.value = a.initializer ? a.initializer.call(l) : void 0, a.initializer = void 0), void 0 === a.initializer ? (Object.defineProperty(i, e, a), null) : a;
 }
 
-function getTargetDecoratorRules(target, disableRegisterMetadata) {
-  if (!disableRegisterMetadata) {
-    registerMappedClassMetadataKey(target, SymbolDecoratorRule, {
-      partialClass: meta => {
-        return meta.optional();
-      }
-    });
-  }
-  return appMetadata.getOwnMetadataMap(true, SymbolDecoratorRule, target);
-}
-function getTargetDecoratorRuleColumns(target) {
-  const rules = getTargetDecoratorRules(target, true);
-  return Object.keys(rules);
-}
-function getTargetDecoratorRuleColumnsMap(target) {
-  const columns = getTargetDecoratorRuleColumns(target);
-  const map = {};
-  for (const column of columns) {
-    map[column] = column;
-  }
-  return map;
-}
-function mergeFieldsOpenapiMetadata(target) {
-  // 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;
-    mergeFieldOpenapiMetadata(target.prototype, key, field);
-  }
-}
-
-// fieldRule maybe undefined
-function mergeFieldOpenapiMetadata(target, prop, fieldRule) {
-  // rules
-  const rules = getTargetDecoratorRules(target);
-  // rule
-  const schemaCurrent = rules[prop];
-  const metadataCurrent = schemaCurrent ? ZodMetadata.getOpenapiMetadata(schemaCurrent) : undefined;
-  // merge
-  if (Object.prototype.hasOwnProperty.call(fieldRule, 'parseAsync')) {
-    const schema = fieldRule;
-    if (isEmptyObject(metadataCurrent)) {
-      rules[prop] = schema;
-    } else {
-      const metadataCustom = ZodMetadata.getOpenapiMetadata(schema);
-      rules[prop] = schema.openapi(deepExtend({}, metadataCurrent, metadataCustom));
-    }
-  } else {
-    if (schemaCurrent) {
-      if (!isEmptyObject(fieldRule)) {
-        rules[prop] = schemaCurrent.openapi(deepExtend({}, metadataCurrent, fieldRule));
-      }
-    } else {
-      if (isEmptyObject(fieldRule)) {
-        rules[prop] = z.any();
-      } else {
-        rules[prop] = z.any().openapi(fieldRule);
-      }
-    }
-  }
-  return rules;
-}
-function prepareClassType(classType) {
-  return isClass(classType) ? classType : cast(classType)();
-}
-
-function $makeSchema(...schemaLikes) {
-  return makeSchemaLikes(schemaLikes, undefined);
-}
-function makeSchemaLikes(schemaLikes, typeInit) {
-  if (!Array.isArray(schemaLikes)) schemaLikes = [schemaLikes];
-  // 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;
-}
-function makeSchemaLike(schemaLike, schemaPrevious) {
-  if (!schemaLike) return schemaPrevious;
-  if (Object.prototype.hasOwnProperty.call(schemaLike, 'parseAsync')) {
-    // schema
-    return schemaLike;
-  } else if (isClass(schemaLike) || ['String', 'Number', 'Boolean', 'Date', 'BigInt', 'Array'].includes(cast(schemaLike).name)) {
-    // class
-    return $schema(cast(schemaLike));
-  } else {
-    // function
-    return cast(schemaLike)(schemaPrevious);
-  }
-}
-
-const __schemasDynamic = {};
-const SymbolSchemaDynamicRefId = Symbol('SymbolSchemaDynamicRefId');
-function addSchemaDynamic(dynamicName, classType) {
-  __schemasDynamic[dynamicName] = classType;
-}
-function getSchemaDynamic(dynamicName) {
-  return __schemasDynamic[dynamicName];
-}
-function getSchemasDynamic() {
-  return __schemasDynamic;
-}
-
-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 = _createSchemaObject(rules, options);
-  // refId
-  const schemaDynamicRefId = classType[SymbolSchemaDynamicRefId];
-  if (schemaDynamicRefId) {
-    // dynamic
-    schema = schema.openapi(schemaDynamicRefId);
-  } else {
-    // static
-    const beanOptions = appResource.getBean(classType);
-    if (beanOptions) {
-      const pipes = cast(beanOptions.options)?.pipes;
-      if (pipes) {
-        schema = makeSchemaLikes(pipes, schema);
-      }
-      const openapi = cast(beanOptions.options)?.openapi;
-      schema = schema.openapi(beanOptions.beanFullName, openapi);
-    }
-  }
-  return schema;
-}
-function $schemaLazy(...schemaLikes) {
-  return z.lazy(() => {
-    return _createSchemaLazy(schemaLikes);
-  });
-}
-function _createSchemaLazy(schemaLikes) {
-  const classType = schemaLikes[schemaLikes.length - 1];
-  schemaLikes = schemaLikes.slice(0, schemaLikes.length - 1);
-  const classType2 = prepareClassType(classType);
-  return makeSchemaLikes(schemaLikes, $schema(classType2));
-}
-function _createSchemaObject(rules, options) {
-  let schema = z.object(rules);
-  if (options?.loose) schema = z.looseObject(schema.shape);
-  if (options?.strict) schema = z.strictObject(schema.shape);
-  return schema;
-}
-
 var _dec$3, _dec2$3, _dec3, _dec4, _dec5, _dec6, _dec7, _dec8, _class$3, _class2;
 let BeanOpenapi = (_dec$3 = Bean(), _dec2$3 = BeanInfo({
   module: "a-openapi"
@@ -220,17 +57,17 @@ let BeanOpenapi = (_dec$3 = Bean(), _dec2$3 = BeanInfo({
     this.scope.service.openapi.translate(apiObj, 'rest');
     return apiObj;
   }
-  generateJsonCacheKey(args, prop) {
-    const version = args[0] ?? 'V31';
+  generateJsonCacheKey(info) {
+    const version = info.args[0] ?? 'V31';
     const locale = this.ctx.locale;
-    return `${prop}_${version}_${locale}`;
+    return `${info.prop}_${version}_${locale}`;
   }
-  generateJsonOfControllerActionCacheKey(args, prop) {
-    const [controller, actionKey, version] = args;
+  generateJsonOfControllerActionCacheKey(info) {
+    const [controller, actionKey, version] = info.args;
     const beanOptions = appResource.getBean(controller);
     const beanFullName = beanOptions.beanFullName;
     const locale = this.ctx.locale;
-    return `${prop}_${beanFullName}_${actionKey}_${version ?? 'V31'}_${locale}`;
+    return `${info.prop}_${beanFullName}_${actionKey}_${version ?? 'V31'}_${locale}`;
   }
   async generateJson(version = 'V31') {
     const registry = this.scope.service.openapi.collectRegistry();
@@ -251,17 +88,6 @@ let BeanOpenapi = (_dec$3 = Bean(), _dec2$3 = BeanInfo({
   }
 }, _applyDecoratedDescriptor(_class2.prototype, "generateJson", [_dec3, _dec4, _dec5], Object.getOwnPropertyDescriptor(_class2.prototype, "generateJson"), _class2.prototype), _applyDecoratedDescriptor(_class2.prototype, "generateJsonOfControllerAction", [_dec6, _dec7, _dec8], Object.getOwnPropertyDescriptor(_class2.prototype, "generateJsonOfControllerAction"), _class2.prototype), _class2)) || _class$3) || _class$3);
 
-function bodySchemaWrapperDefault(bodySchema) {
-  return z.object({
-    code: z.string(),
-    message: z.string(),
-    data: bodySchema
-  });
-}
-
-const SymbolRouteHandlersArgumentsMeta = Symbol('SymbolRouteHandlersArgumentsMeta');
-const SymbolRouteHandlersArgumentsValue = Symbol('SymbolRouteHandlersArgumentsValue');
-
 var _dec$2, _dec2$2, _class$2;
 const __ArgumentTypes = ['param', 'query', 'body', 'headers', 'fields', 'field', 'files', 'file'];
 let ServiceOpenapi = (_dec$2 = Service(), _dec2$2 = BeanInfo({
@@ -297,6 +123,17 @@ let ServiceOpenapi = (_dec$2 = Service(), _dec2$2 = BeanInfo({
     if (schema.type === 'object' && schema.required === undefined) schema.required = [];
     // serializerTransforms
     delete schema.serializerTransforms;
+    // filter
+    if (schema.filter) {
+      const filterCapabilities = schema.filter.capabilities;
+      if (filterCapabilities) {
+        schema.filter = {
+          capabilities: filterCapabilities
+        };
+      } else {
+        delete schema.filter;
+      }
+    }
     // schema
     this._translateStrings(schema, ['title', 'description']);
     if (generateJsonScene === 'api' && !schema.description && schema.title) {
@@ -632,14 +469,6 @@ function config(_app) {
   };
 }
 
-var locale_en_us = {
-  ZodErrorRequired: 'Required'
-};
-
-var locale_zh_cn = {
-  ZodErrorRequired: '必填项'
-};
-
 function schemaRefCustomAdapter(_app) {
   const registry = new OpenAPIRegistry();
   const generator31 = new OpenApiGeneratorV31(registry.definitions);
@@ -674,437 +503,10 @@ class Main extends BeanSimple {
 }
 
 var _dec, _dec2, _class;
-const locales = {
-  'en-us': locale_en_us,
-  'zh-cn': locale_zh_cn
-};
 let ScopeModuleAOpenapi = (_dec = Scope(), _dec2 = BeanInfo({
   module: "a-openapi"
 }), _dec(_class = _dec2(_class = class ScopeModuleAOpenapi extends BeanScopeBase {}) || _class) || _class);
-function $locale(key) {
-  return `a-openapi::${key}`;
-}
-/** scope: end */
-
-function schemaEmail(params) {
-  return function (_schema) {
-    return z.email(params);
-  };
-}
-function schemaUrl(params) {
-  return function (_schema) {
-    return z.url(params);
-  };
-}
-function schemaUuid(params) {
-  return function (_schema) {
-    return z.uuid(params);
-  };
-}
-function schemaIPv4(params) {
-  return function (_schema) {
-    return z.ipv4(params);
-  };
-}
-function schemaIPv6(params) {
-  return function (_schema) {
-    return z.ipv6(params);
-  };
-}
-function schemaMin(min, params) {
-  return function (schema) {
-    if (schema.type === 'string') {
-      return schema.min(min, params);
-    } else {
-      return schema.min(min, params);
-    }
-  };
-}
-function schemaMax(max, params) {
-  return function (schema) {
-    if (schema.type === 'string') {
-      return schema.max(max, params);
-    } else {
-      return schema.max(max, params);
-    }
-  };
-}
-function schemaTrim() {
-  return function (schema) {
-    return schema.trim();
-  };
-}
-function schemaToLowerCase() {
-  return function (schema) {
-    return schema.toLowerCase();
-  };
-}
-function schemaToUpperCase() {
-  return function (schema) {
-    return schema.toUpperCase();
-  };
-}
-function schemaLowercase(params) {
-  return function (schema) {
-    return schema.lowercase(params);
-  };
-}
-function schemaUppercase(params) {
-  return function (schema) {
-    return schema.uppercase(params);
-  };
-}
-function schemaRegex(regex, params) {
-  return function (schema) {
-    return schema.regex(regex, params);
-  };
-}
-function schemaTableIdentity() {
-  const app = useApp();
-  const ormConfig = app.util.getModuleConfigRaw('a-orm');
-  const _identityType = ormConfig?.table?.identityType ?? 'bigint';
-  return function (_schema) {
-    if (_identityType === 'number') {
-      return z.number();
-    } else if (_identityType === 'bigint') {
-      return z.string().regex(/^\d+$/);
-    }
-    throw new Error('not support');
-  };
-}
-function schemaCaptcha(options) {
-  return function (schema) {
-    return schema.openapi({
-      captcha: options
-    });
-  };
-}
-
-function schemaOpenapi(refId, metadata) {
-  return function (schema) {
-    return schema.openapi(refId, metadata);
-  };
-}
-function schemaTitle(title) {
-  return function (schema) {
-    return schema.openapi({
-      title
-    });
-  };
-}
-function schemaDescription(description) {
-  return function (schema) {
-    return schema.openapi({
-      description
-    });
-  };
-}
-function schemaExample(example) {
-  return function (schema) {
-    return schema.openapi({
-      example
-    });
-  };
-}
 
-function schemaSerializerTransform(serializerTransformName, options) {
-  return function (schema) {
-    return schema.openapi({
-      serializerTransforms: {
-        [serializerTransformName]: options
-      }
-    });
-  };
-}
-function schemaSerializerExclude(param) {
-  let options;
-  if (!param || typeof param === 'boolean') {
-    options = {
-      exclude: param
-    };
-  } else {
-    options = param;
-  }
-  return function (schema) {
-    return schema.openapi({
-      serializerTransforms: {
-        'a-serialization:exclude': options
-      }
-    });
-  };
-}
-function schemaSerializerReplace(options) {
-  return function (schema) {
-    return schema.openapi({
-      serializerTransforms: {
-        'a-serialization:replace': options
-      }
-    });
-  };
-}
-function schemaSerializerGetter(param) {
-  let options;
-  if (typeof param === 'function') {
-    options = {
-      getter: param
-    };
-  } else {
-    options = param;
-  }
-  return function (schema) {
-    return schema.openapi({
-      serializerTransforms: {
-        'a-serialization:getter': options
-      }
-    });
-  };
-}
-function schemaSerializerCustom(param) {
-  let options;
-  if (typeof param === 'function') {
-    options = {
-      custom: param
-    };
-  } else {
-    options = param;
-  }
-  return function (schema) {
-    return schema.openapi({
-      serializerTransforms: {
-        'a-serialization:custom': options
-      }
-    });
-  };
-}
-
-function schemaDefault(defaultValue) {
-  return function (schema) {
-    return schema.default(defaultValue);
-  };
-}
-function schemaOptional() {
-  return function (schema) {
-    return schema.optional();
-  };
-}
-function schemaLazy(...schemaLikes) {
-  return function (_schema) {
-    return $schemaLazy(...schemaLikes);
-  };
-}
-function schemaObject(classType, options) {
-  return function (_schema) {
-    return $schema(classType, options);
-  };
-}
-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 (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),
-    );
-  };
-}
-function schemaStrictObject() {
-  return function (schema) {
-    return z.strictObject(schema.shape);
-  };
-}
-function schemaLooseObject() {
-  return function (schema) {
-    return z.looseObject(schema.shape);
-  };
-}
-function schemaRequired(params) {
-  params = params || $locale('ZodErrorRequired');
-  return function (schema) {
-    schema._zod.def.error = z.util.normalizeParams(params).error;
-    return schema;
-  };
-}
-
-function schemaZodRefine(zodRefineName, options) {
-  return function (schema) {
-    return schema.superRefine(async (value, refinementCtx) => {
-      const app = useApp();
-      const options2 = app.bean.onion.zodRefine.getOnionOptionsDynamic(zodRefineName, options);
-      // execute
-      const beanFullName = beanFullNameFromOnionName(zodRefineName, 'zodRefine');
-      const beanInstance = app.bean._getBean(beanFullName);
-      if (!beanInstance) {
-        throw new Error(`zodRefine bean not found: ${beanFullName}`);
-      }
-      return await beanInstance.execute(value, refinementCtx, options2);
-    });
-  };
-}
-function schemaZodTransform(zodTransformName, options) {
-  return function (schema) {
-    return schema.transform(async value => {
-      const app = useApp();
-      const options2 = app.bean.onion.zodTransform.getOnionOptionsDynamic(zodTransformName, options);
-      // execute
-      const beanFullName = beanFullNameFromOnionName(zodTransformName, 'zodTransform');
-      const beanInstance = app.bean._getBean(beanFullName);
-      if (!beanInstance) {
-        throw new Error(`zodTransform bean not found: ${beanFullName}`);
-      }
-      return await beanInstance.execute(value, options2);
-    });
-  };
-}
-
-const v = {
-  required: schemaRequired,
-  optional: schemaOptional,
-  default: schemaDefault,
-  object: schemaObject,
-  strictObject: schemaStrictObject,
-  looseObject: schemaLooseObject,
-  array: schemaArray,
-  lazy: schemaLazy,
-  // helpers
-  email: schemaEmail,
-  url: schemaUrl,
-  uuid: schemaUuid,
-  ipv4: schemaIPv4,
-  ipv6: schemaIPv6,
-  min: schemaMin,
-  max: schemaMax,
-  trim: schemaTrim,
-  toLowerCase: schemaToLowerCase,
-  toUpperCase: schemaToUpperCase,
-  lowercase: schemaLowercase,
-  uppercase: schemaUppercase,
-  regex: schemaRegex,
-  tableIdentity: schemaTableIdentity,
-  captcha: schemaCaptcha,
-  serializerExclude: schemaSerializerExclude,
-  serializerTransform: schemaSerializerTransform,
-  serializerReplace: schemaSerializerReplace,
-  serializerGetter: schemaSerializerGetter,
-  serializerCustom: schemaSerializerCustom,
-  // openapi
-  openapi: schemaOpenapi,
-  title: schemaTitle,
-  description: schemaDescription,
-  example: schemaExample,
-  // zod
-  refine: schemaZodRefine,
-  transform: schemaZodTransform
-};
-
-function Field(...schemaLikes) {
-  return function (target, prop, descriptor) {
-    const metaType = appMetadata.getDesignType(target, prop);
-    const schema = makeSchemaLikes(schemaLikes, metaType);
-    const rules = mergeFieldOpenapiMetadata(target, prop, schema);
-    if (descriptor?.get) {
-      rules[prop] = v.serializerGetter(descriptor.get)(rules[prop]);
-    }
-  };
-}
-
-function httpCode(httpCode) {
-  return function (target, prop, descriptor) {
-    const options = appMetadata.getOwnMetadataMap(false, SymbolOpenApiOptions, target, prop);
-    options.httpCode = httpCode;
-    return descriptor;
-  };
-}
-function contentType(contentType) {
-  return function (target, prop, descriptor) {
-    const options = appMetadata.getOwnMetadataMap(false, SymbolOpenApiOptions, target, prop);
-    options.contentType = contentType;
-    return descriptor;
-  };
-}
-function body(...schemaLikes) {
-  return function (target, prop, descriptor) {
-    // schema
-    const metaType = appMetadata.getDesignReturntype(target, prop);
-    const schema = makeSchemaLikes(schemaLikes, metaType);
-    // options
-    const options = appMetadata.getOwnMetadataMap(false, SymbolOpenApiOptions, target, prop);
-    options.bodySchema = schema;
-    return descriptor;
-  };
-}
-function bodyCustom(bodySchemaWrapper, ...schemaLikes) {
-  return function (target, prop, descriptor) {
-    // schema
-    const metaType = appMetadata.getDesignReturntype(target, prop);
-    const schema = makeSchemaLikes(schemaLikes, metaType);
-    // options
-    const options = appMetadata.getOwnMetadataMap(false, SymbolOpenApiOptions, target, prop);
-    options.bodySchema = schema;
-    options.bodySchemaWrapper = bodySchemaWrapper;
-    return descriptor;
-  };
-}
-function exclude() {
-  return function (target, prop, descriptor) {
-    const options = appMetadata.getOwnMetadataMap(false, SymbolOpenApiOptions, target, prop);
-    options.exclude = true;
-    return descriptor;
-  };
-}
-function tags(tags) {
-  return function (target, prop, descriptor) {
-    const options = appMetadata.getOwnMetadataMap(false, SymbolOpenApiOptions, target, prop);
-    options.tags = tags;
-    return descriptor;
-  };
-}
-function header(header) {
-  return function (target, prop, descriptor) {
-    const options = appMetadata.getOwnMetadataMap(false, SymbolOpenApiOptions, target, prop);
-    if (!options.headers) options.headers = [];
-    options.headers.push(header);
-    return descriptor;
-  };
-}
-function headers(headers) {
-  return function (target, prop, descriptor) {
-    const options = appMetadata.getOwnMetadataMap(false, SymbolOpenApiOptions, target, prop);
-    if (!options.headers) options.headers = [];
-    options.headers.push(...headers);
-    return descriptor;
-  };
-}
-function setHeader(field, val) {
-  return function (target, prop, descriptor) {
-    const options = appMetadata.getOwnMetadataMap(false, SymbolOpenApiOptions, target, prop);
-    if (!options.setHeaders) options.setHeaders = {};
-    if (typeof field === 'string') {
-      options.setHeaders[field] = val;
-    } else {
-      Object.assign(options.setHeaders, field);
-    }
-    return descriptor;
-  };
-}
-const Api = {
-  field: Field,
-  httpCode,
-  contentType,
-  body,
-  bodyCustom,
-  exclude,
-  tags,
-  header,
-  headers,
-  setHeader
-};
-
-const OrderCoreBase = 100;
-const OrderBusinessBase = 1000;
-const OrderUnknownBase = 10000;
-const OrderMaxBase = 100000;
+/** scope: end */
 
-export { $locale, $makeSchema, $schema, $schemaLazy, Api, BeanOpenapi, Main, OrderBusinessBase, OrderCoreBase, OrderMaxBase, OrderUnknownBase, ScopeModuleAOpenapi, ServiceOpenapi, SummerCacheJson, SymbolRouteHandlersArgumentsMeta, SymbolRouteHandlersArgumentsValue, SymbolSchemaDynamicRefId, addSchemaDynamic, bodySchemaWrapperDefault, config, getSchemaDynamic, getSchemasDynamic, getTargetDecoratorRuleColumns, getTargetDecoratorRuleColumnsMap, getTargetDecoratorRules, locales, makeSchemaLike, makeSchemaLikes, mergeFieldOpenapiMetadata, mergeFieldsOpenapiMetadata, prepareClassType, schemaRefCustomAdapter, v };
+export { BeanOpenapi, Main, ScopeModuleAOpenapi, ServiceOpenapi, SummerCacheJson, config, schemaRefCustomAdapter };

package/dist/lib/index.d.ts

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

package/dist/types/decorator.d.ts

@@ -21,6 +21,4 @@ export interface RouteHandlerArgumentMeta {
     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

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

package/dist/types/rest.d.ts

@@ -5,7 +5,6 @@ import type { z } from 'zod';
 import type { TypeResourceActionRowRecordRender } from './actions.ts';
 import type { ISchemaObjectExtensionFieldCaptcha } from './captcha.ts';
 import type { IComponentRecord } from './component.ts';
-import type { ISchemaObjectExtensionFieldQuery } from './query.ts';
 import 'openapi3-ts/oas30';
 import 'openapi3-ts/oas31';
 export interface ISchemaObjectExtensionFieldRest {
@@ -18,7 +17,6 @@ export interface ISchemaObjectExtensionFieldRest {
 }
 export interface ISchemaObjectExtensionField {
     rest?: ISchemaObjectExtensionFieldRest;
-    query?: ISchemaObjectExtensionFieldQuery;
     captcha?: ISchemaObjectExtensionFieldCaptcha;
 }
 declare module 'openapi3-ts/oas30' {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "vona-module-a-openapi",
   "type": "module",
-  "version": "5.0.54",
+  "version": "5.0.55",
   "title": "a-openapi",
   "vonaModule": {
     "capabilities": {
@@ -35,12 +35,12 @@
     "dist"
   ],
   "dependencies": {
-    "@cabloy/zod-openapi": "^1.0.3",
+    "@cabloy/zod-openapi": "^1.0.6",
     "@cabloy/zod-query": "^2.0.3",
     "@cabloy/zod-to-openapi": "^8.1.4",
     "@zhennann/currency": "^2.0.0",
     "openapi3-ts": "^4.5.0",
-    "zod": "^4.1.5"
+    "zod": "^4.1.13"
   },
   "devDependencies": {
     "clean-package": "^2.2.0",

package/dist/config/locale/en-us.d.ts

@@ -1,4 +0,0 @@
-declare const _default: {
-    ZodErrorRequired: string;
-};
-export default _default;

package/dist/config/locale/zh-cn.d.ts

@@ -1,4 +0,0 @@
-declare const _default: {
-    ZodErrorRequired: string;
-};
-export default _default;

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

@@ -1,27 +0,0 @@
-import type { IOpenApiHeader, SchemaLike, SchemaLikeCreate, TypeResponseContentType } from 'vona-module-a-openapiutils';
-import { Field } from './field.ts';
-declare function httpCode(httpCode: number): MethodDecorator;
-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;
-declare function setHeader(field: {
-    [key: string]: string | string[];
-}): ClassDecorator & MethodDecorator;
-declare function setHeader(field: string, val: string | string[]): ClassDecorator & MethodDecorator;
-export declare const Api: {
-    field: typeof Field;
-    httpCode: typeof httpCode;
-    contentType: typeof contentType;
-    body: typeof body;
-    bodyCustom: typeof bodyCustom;
-    exclude: typeof exclude;
-    tags: typeof tags;
-    header: typeof header;
-    headers: typeof headers;
-    setHeader: typeof setHeader;
-};
-export {};

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

@@ -1,2 +0,0 @@
-import type { SchemaLike } from 'vona-module-a-openapiutils';
-export declare function Field(...schemaLikes: SchemaLike[]): PropertyDecorator;

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

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

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

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

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

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

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

@@ -1,5 +0,0 @@
-import type { SchemaLike } from 'vona-module-a-openapiutils';
-import type { z } from 'zod';
-export declare function $makeSchema(...schemaLikes: SchemaLike[]): z.ZodType;
-export declare function makeSchemaLikes<T>(schemaLikes: SchemaLike<T> | SchemaLike<T>[], typeInit: any): z.ZodType<T>;
-export declare function makeSchemaLike<T>(schemaLike: SchemaLike<T> | undefined, schemaPrevious: z.ZodType<T>): z.ZodType<T>;

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

@@ -1,13 +0,0 @@
-import type { Constructable } from 'vona';
-import type { SchemaLike } from 'vona-module-a-openapiutils';
-import type { ISchemaObjectOptions } from '../../types/decorator.ts';
-import { z } from 'zod';
-export declare function $schema<T>(schemaLike: z.ZodType<T>): z.ZodType<T>;
-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.ZodType<T>;
-export declare function $schemaLazy<T>(...schemaLikes: SchemaLike<T>[]): z.ZodType<T>;

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

@@ -1,5 +0,0 @@
-import type { Constructable } from 'vona';
-export declare const SymbolSchemaDynamicRefId: unique symbol;
-export declare function addSchemaDynamic(dynamicName: string, classType: Constructable): void;
-export declare function getSchemaDynamic(dynamicName: string): Constructable;
-export declare function getSchemasDynamic(): Record<string, Constructable>;

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

@@ -1,17 +0,0 @@
-import type { ISchemaObjectExtensionFieldCaptcha } from '../../../types/captcha.ts';
-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 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 schemaTableIdentity(): (_schema?: any) => z.ZodString | z.ZodNumber;
-export declare function schemaCaptcha(options: ISchemaObjectExtensionFieldCaptcha): (schema: z.ZodType) => z.ZodType;

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

@@ -1,7 +0,0 @@
-import type { ZodOpenAPIMetadata } from '@cabloy/zod-to-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 schemaExample<T extends z.ZodType>(example?: any): (schema: T) => T;

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

@@ -1,10 +0,0 @@
-import type { ISerializerTransformOptionsCustom, ISerializerTransformOptionsExclude, ISerializerTransformOptionsGetter, ISerializerTransformRecord, TypeSerializerTransformCustom, TypeSerializerTransformGetter } from 'vona-module-a-serialization';
-import type z from 'zod';
-export declare function schemaSerializerTransform<T extends keyof ISerializerTransformRecord>(serializerTransformName: T, options?: Partial<ISerializerTransformRecord[T]>): (schema: z.ZodType) => z.ZodType;
-export declare function schemaSerializerExclude(options: Partial<ISerializerTransformOptionsExclude>): any;
-export declare function schemaSerializerExclude(exclude?: boolean): any;
-export declare function schemaSerializerReplace(options: ISerializerTransformRecord['a-serialization:replace']): (schema: z.ZodType) => z.ZodType;
-export declare function schemaSerializerGetter(options: Partial<ISerializerTransformOptionsGetter>): any;
-export declare function schemaSerializerGetter(getter: TypeSerializerTransformGetter): any;
-export declare function schemaSerializerCustom(options: Partial<ISerializerTransformOptionsCustom>): any;
-export declare function schemaSerializerCustom(getter: TypeSerializerTransformCustom): any;

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

@@ -1,14 +0,0 @@
-import type { Constructable } from 'vona';
-import type { SchemaLike } from 'vona-module-a-openapiutils';
-import type { ISchemaObjectOptions } from '../../../types/decorator.ts';
-import { z } from 'zod';
-export declare function schemaDefault(defaultValue: any | Function): (schema: z.ZodType) => z.ZodType;
-export declare function schemaOptional(): (schema: z.ZodType) => z.ZodType;
-export declare function schemaLazy<T>(...schemaLikes: SchemaLike<T>[]): (_schema?: z.ZodType) => z.ZodType<T>;
-export declare function schemaObject<T>(classType: Constructable<T>, options?: ISchemaObjectOptions): (_schema?: z.ZodType) => z.ZodType<T>;
-export declare function schemaArray(schemaLike?: SchemaLike, params?: z.core.$ZodArrayParams & {
-    separator?: string;
-}): (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;

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

@@ -1,4 +0,0 @@
-import type { IZodRefineRecord, IZodTransformRecord } from 'vona-module-a-zod';
-import type z from 'zod';
-export declare function schemaZodRefine<T extends keyof IZodRefineRecord>(zodRefineName: T, options?: Partial<IZodRefineRecord[T]>): (schema: z.ZodType) => z.ZodType;
-export declare function schemaZodTransform<T extends keyof IZodTransformRecord>(zodTransformName: T, options?: Partial<IZodTransformRecord[T]>): (schema: z.ZodType) => z.ZodType;

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

@@ -1,41 +0,0 @@
-import { schemaCaptcha, schemaEmail, schemaIPv4, schemaIPv6, schemaLowercase, schemaMax, schemaMin, schemaRegex, schemaTableIdentity, schemaToLowerCase, schemaToUpperCase, schemaTrim, schemaUppercase, schemaUrl, schemaUuid } from './v/helpers.ts';
-import { schemaDescription, schemaExample, schemaOpenapi, schemaTitle } from './v/openapi.ts';
-import { schemaSerializerCustom, schemaSerializerExclude, schemaSerializerGetter, schemaSerializerReplace, schemaSerializerTransform } from './v/serializer.ts';
-import { schemaArray, schemaDefault, schemaLazy, schemaLooseObject, schemaObject, schemaOptional, schemaRequired, schemaStrictObject } from './v/system.ts';
-import { schemaZodRefine, schemaZodTransform } from './v/zod.ts';
-export declare const v: {
-    required: typeof schemaRequired;
-    optional: typeof schemaOptional;
-    default: typeof schemaDefault;
-    object: typeof schemaObject;
-    strictObject: typeof schemaStrictObject;
-    looseObject: typeof schemaLooseObject;
-    array: typeof schemaArray;
-    lazy: typeof schemaLazy;
-    email: typeof schemaEmail;
-    url: typeof schemaUrl;
-    uuid: typeof schemaUuid;
-    ipv4: typeof schemaIPv4;
-    ipv6: typeof schemaIPv6;
-    min: typeof schemaMin;
-    max: typeof schemaMax;
-    trim: typeof schemaTrim;
-    toLowerCase: typeof schemaToLowerCase;
-    toUpperCase: typeof schemaToUpperCase;
-    lowercase: typeof schemaLowercase;
-    uppercase: typeof schemaUppercase;
-    regex: typeof schemaRegex;
-    tableIdentity: typeof schemaTableIdentity;
-    captcha: typeof schemaCaptcha;
-    serializerExclude: typeof schemaSerializerExclude;
-    serializerTransform: typeof schemaSerializerTransform;
-    serializerReplace: typeof schemaSerializerReplace;
-    serializerGetter: typeof schemaSerializerGetter;
-    serializerCustom: typeof schemaSerializerCustom;
-    openapi: typeof schemaOpenapi;
-    title: typeof schemaTitle;
-    description: typeof schemaDescription;
-    example: typeof schemaExample;
-    refine: typeof schemaZodRefine;
-    transform: typeof schemaZodTransform;
-};

package/dist/lib/utils.d.ts

@@ -1,10 +0,0 @@
-import type { Constructable } from 'vona';
-import type { TypeDecoratorRules } from 'vona-module-a-openapiutils';
-import type { TypeOpenapiMetadata } from '../types/rest.ts';
-import { z } from 'zod';
-export declare function getTargetDecoratorRules(target: object, disableRegisterMetadata?: boolean): TypeDecoratorRules;
-export declare function getTargetDecoratorRuleColumns(target: object): string[];
-export declare function getTargetDecoratorRuleColumnsMap(target: object): Record<string, string>;
-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>;

package/dist/types/database.d.ts

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

package/dist/types/query.d.ts

@@ -1,13 +0,0 @@
-import type { IModelSelectParamsJoinType, ITableRecord, TypeOpsNormal } from 'vona-module-a-orm';
-export interface ISchemaObjectExtensionFieldQueryJoin {
-    type?: IModelSelectParamsJoinType;
-    table: keyof ITableRecord;
-    on: [string, string];
-}
-export interface ISchemaObjectExtensionFieldQuery {
-    table?: keyof ITableRecord;
-    joinType?: IModelSelectParamsJoinType;
-    joinOn?: [string, string];
-    originalName?: string;
-    op?: TypeOpsNormal;
-}