vona-module-a-openapiutils 5.0.9 → 5.0.11

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

@@ -1,9 +1,13 @@
+/** locale: begin */
+import { locales } from './locales.ts';
+/** locale: end */
 /** scope: begin */
-import { BeanScopeBase, type BeanScopeUtil } from 'vona';
+import { BeanScopeBase, type BeanScopeUtil, type TypeModuleLocales, type TypeLocaleBase } from 'vona';
 export declare class ScopeModuleAOpenapiutils extends BeanScopeBase {
 }
 export interface ScopeModuleAOpenapiutils {
     util: BeanScopeUtil;
+    locale: TypeModuleLocales<(typeof locales)[TypeLocaleBase]>;
 }
 import 'vona';
 declare module 'vona' {
@@ -13,5 +17,8 @@ declare module 'vona' {
     interface IBeanScopeContainer {
         openapiutils: ScopeModuleAOpenapiutils;
     }
+    interface IBeanScopeLocale {
+        'a-openapiutils': (typeof locales)[TypeLocaleBase];
+    }
 }
 /** scope: end */

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

@@ -0,0 +1,10 @@
+import type { TypeLocaleBase } from 'vona';
+export declare const locales: {
+    'en-us': {
+        ZodErrorRequired: string;
+    };
+    'zh-cn': {
+        ZodErrorRequired: string;
+    };
+};
+export declare function $locale<K extends keyof (typeof locales)[TypeLocaleBase]>(key: K): `a-openapiutils::${K}`;

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

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

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

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

package/dist/index.d.ts

@@ -1,3 +1,4 @@
 export * from './.metadata/index.ts';
+export * from './.metadata/locales.ts';
 export * from './lib/index.ts';
 export * from './types/index.ts';

package/dist/index.js

@@ -1,5 +1,9 @@
-import { BeanInfo, BeanScopeBase, appMetadata } from 'vona';
+import { BeanInfo, BeanScopeBase, 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';
+import { ZodMetadata } from '@cabloy/zod-openapi';
+import { coerceWithNil } from '@cabloy/zod-query';
 
 var _dec, _dec2, _class;
 let ScopeModuleAOpenapiutils = (_dec = Scope(), _dec2 = BeanInfo({
@@ -8,15 +12,667 @@ let ScopeModuleAOpenapiutils = (_dec = Scope(), _dec2 = BeanInfo({
 
 /** scope: end */
 
+var locale_en_us = {
+  ZodErrorRequired: 'Required'
+};
+
+var locale_zh_cn = {
+  ZodErrorRequired: '必填项'
+};
+
+const locales = {
+  'en-us': locale_en_us,
+  'zh-cn': locale_zh_cn
+};
+function $locale(key) {
+  return `a-openapiutils::${key}`;
+}
+
+const OrderCoreBase = 100;
+const OrderBusinessBase = 1000;
+const OrderUnknownBase = 10000;
+const OrderMaxBase = 100000;
+
+const SymbolRouteHandlersArgumentsMeta = Symbol('SymbolRouteHandlersArgumentsMeta');
+const SymbolRouteHandlersArgumentsValue = Symbol('SymbolRouteHandlersArgumentsValue');
+
 const SymbolOpenApiOptions = Symbol('SymbolOpenApiOptions');
 
+// not use z.ZodType
+
+const SymbolDecoratorRule = Symbol('SymbolDecoratorRule');
+
+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)();
+}
+
+const __schemasDynamic = {};
+const SymbolSchemaDynamicRefId = Symbol('SymbolSchemaDynamicRefId');
+function addSchemaDynamic(dynamicName, classType) {
+  __schemasDynamic[dynamicName] = classType;
+}
+function getSchemaDynamic(dynamicName) {
+  return __schemasDynamic[dynamicName];
+}
+function getSchemasDynamic() {
+  return __schemasDynamic;
+}
+
+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);
+  }
+}
+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;
+}
+
+function schemaFilter(options) {
+  return function (schema) {
+    return schema.openapi({
+      filter: options
+    });
+  };
+}
+function schemaFilterTransform(filterTransformName, options) {
+  return function (schema) {
+    return schema.openapi({
+      filter: {
+        transform: [filterTransformName, options]
+      }
+    });
+  };
+}
+function schemaFilterDateRange(options) {
+  return function (schema) {
+    return schema.openapi({
+      filter: {
+        transform: ['a-web:dateRange', options]
+      }
+    });
+  };
+}
+
+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() {
+  return function (_schema) {
+    const schema = z.union([z.number(), z.string()]);
+    return schema.transform(value => {
+      const app = useApp();
+      const ormConfig = app.util.getModuleConfigRaw('a-orm');
+      const _identityType = ormConfig?.table?.identityType ?? 'bigint';
+      if (_identityType === 'number') {
+        return Number.parseInt(value);
+      } else if (_identityType === 'bigint') {
+        return String(value);
+      } else {
+        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,
+  filter: schemaFilter,
+  filterTransform: schemaFilterTransform,
+  filterDateRange: schemaFilterDateRange,
+  // 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
+};
 function setPublic(target, prop, _descriptor, value) {
   const options = appMetadata.getOwnMetadataMap(false, SymbolOpenApiOptions, target, prop);
   options.public = value;
 }
 
-// not use z.ZodType
+function bodySchemaWrapperDefault(bodySchema) {
+  return z.object({
+    code: z.string(),
+    message: z.string(),
+    data: bodySchema
+  });
+}
 
-const SymbolDecoratorRule = Symbol('SymbolDecoratorRule');
+function $apiPath(path) {
+  return path;
+}
+function $apiPathAndCombineParamsAndQuery(path, options) {
+  return combineParamsAndQuery(path, options);
+}
+function $makeFilterTransform(filterTransformName, options) {
+  return [filterTransformName, options];
+}
 
-export { ScopeModuleAOpenapiutils, SymbolDecoratorRule, SymbolOpenApiOptions, setPublic };
+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 };

package/dist/lib/const/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/lib/const/decorator.d.ts

@@ -0,0 +1,2 @@
+export declare const SymbolRouteHandlersArgumentsMeta: unique symbol;
+export declare const SymbolRouteHandlersArgumentsValue: unique symbol;

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

@@ -0,0 +1,2 @@
+export * from './database.ts';
+export * from './decorator.ts';

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

@@ -1,2 +1,30 @@
 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';
+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 declare function setPublic(target: object, prop?: MetadataKey, _descriptor?: PropertyDescriptor, value?: boolean): void;
+export {};

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

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

package/dist/lib/index.d.ts

@@ -1 +1,6 @@
+export * from './const/index.ts';
 export * from './decorator/index.ts';
+export * from './decorator/index.ts';
+export * from './schema/index.ts';
+export * from './utils.ts';
+export * from './web.ts';

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

@@ -0,0 +1,6 @@
+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

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

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

@@ -0,0 +1,16 @@
+import type { Constructable } from 'vona';
+import type { ISchemaObjectOptions } from 'vona-module-a-openapi';
+import type { SchemaLike } from '../../types/decorator.ts';
+import { 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>;
+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

@@ -0,0 +1,5 @@
+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/filter.d.ts

@@ -0,0 +1,5 @@
+import type { IFilterTransformOptionsDateRange, IFilterTransformRecord, ISchemaObjectExtensionFieldFilter } from 'vona-module-a-web';
+import type z from 'zod';
+export declare function schemaFilter(options: ISchemaObjectExtensionFieldFilter): (schema: z.ZodType) => z.ZodType;
+export declare function schemaFilterTransform<T extends keyof IFilterTransformRecord>(filterTransformName: T, options?: Partial<IFilterTransformRecord[T]>): (schema: z.ZodType) => z.ZodType;
+export declare function schemaFilterDateRange(options?: Partial<IFilterTransformOptionsDateRange>): (schema: z.ZodType) => z.ZodType;

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

@@ -0,0 +1,17 @@
+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 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.ZodType;
+export declare function schemaCaptcha(options: ISchemaObjectExtensionFieldCaptcha): (schema: z.ZodType) => z.ZodType;

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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,14 @@
+import type { Constructable } from 'vona';
+import type { ISchemaObjectOptions } from 'vona-module-a-openapi';
+import type { SchemaLike } 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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,45 @@
+import { schemaFilter, schemaFilterDateRange, schemaFilterTransform } from './v/filter.ts';
+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;
+    filter: typeof schemaFilter;
+    filterTransform: typeof schemaFilterTransform;
+    filterDateRange: typeof schemaFilterDateRange;
+    openapi: typeof schemaOpenapi;
+    title: typeof schemaTitle;
+    description: typeof schemaDescription;
+    example: typeof schemaExample;
+    refine: typeof schemaZodRefine;
+    transform: typeof schemaZodTransform;
+};

package/dist/lib/utils.d.ts

@@ -0,0 +1,10 @@
+import type { Constructable } from 'vona';
+import type { TypeOpenapiMetadata } from 'vona-module-a-openapi';
+import type { TypeDecoratorRules } from '../types/decorator.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/lib/web.d.ts

@@ -0,0 +1,7 @@
+import type { IApiPathRecord, IFilterTransformRecord, TypeSchemaObjectExtensionFieldFilterTransform } from 'vona-module-a-web';
+export declare function $apiPath<K extends keyof IApiPathRecord>(path: K): K;
+export declare function $apiPathAndCombineParamsAndQuery<K extends keyof IApiPathRecord>(path: K, options?: {
+    params?: object;
+    query?: object;
+}): string;
+export declare function $makeFilterTransform<T extends keyof IFilterTransformRecord>(filterTransformName: T, options?: Partial<IFilterTransformRecord[T]>): TypeSchemaObjectExtensionFieldFilterTransform;

package/package.json

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