vona-module-a-openapi 5.0.12 → 5.0.13

package/dist/index.js

@@ -1,3 +1,779 @@
-export * from "./.metadata/index.js";
-export * from "./lib/index.js";
-export * from "./types/index.js";
+import { BeanSimple, appMetadata, appResource, cast, BeanInfo, BeanBase, LocaleModuleNameSeparator, HttpStatus, BeanScopeBase, isClassStrict, registerMappedClassMetadataKey, deepExtend } from 'vona';
+import { Scope } from 'vona-module-a-bean';
+import { locales as locales$1, setErrorMapDefault, setErrorMapSchema } from '@cabloy/zod-errors-custom';
+import { OpenApiGeneratorV3, OpenApiGeneratorV31, OpenAPIRegistry } from '@asteasolutions/zod-to-openapi';
+import * as ModuleInfo from '@cabloy/module-info';
+import { isEmptyObject, isNil } from '@cabloy/utils';
+import { toUpperCaseFirstChar } from '@cabloy/word-utils';
+import { Service, SymbolRequestMappingHandler, RequestMethod } from 'vona-module-a-web';
+import { z } from 'zod';
+import { coerceWithNil } from '@cabloy/zod-query';
+import 'openapi3-ts/oas30';
+import 'openapi3-ts/oas31';
+
+var locale_en_us = locales$1['en-us'];
+
+var locale_zh_cn = locales$1['zh-cn'];
+
+function config(_app) {
+  return {
+    defaultVersion: 'V31',
+    generateDocument: {
+      V30: {
+        openapi: '3.0.0',
+        info: {
+          version: '5.0.0',
+          title: 'Vona',
+          description: 'Vona API'
+        }
+      },
+      V31: {
+        openapi: '3.1.0',
+        info: {
+          version: '5.0.0',
+          title: 'Vona',
+          description: 'Vona API'
+        }
+      }
+    },
+    securitySchemes: {
+      bearerAuth: {
+        type: 'http',
+        scheme: 'bearer',
+        bearerFormat: 'JWT'
+      }
+    }
+  };
+}
+
+function errorsAdapter(app) {
+  setErrorMapDefault((text, ...args) => {
+    return app.meta.text(text, ...args);
+  });
+  setErrorMapSchema((text, ...args) => {
+    return app.meta.text(text, ...args);
+  });
+}
+
+class Main extends BeanSimple {
+  async moduleLoading() {}
+  async moduleLoaded() {
+    errorsAdapter(this.app);
+  }
+  async configLoaded(_config) {}
+}
+
+function bodySchemaWrapperDefault(bodySchema) {
+  return z.object({
+    code: z.string(),
+    message: z.string(),
+    data: bodySchema
+  });
+}
+
+const SymbolDecoratorRule = Symbol('SymbolDecoratorRule');
+const SymbolDecoratorRuleColumn = Symbol('SymbolDecoratorRuleColumn');
+
+// not use z.ZodSchema
+
+const SymbolRouteHandlersArgumentsMeta = Symbol('SymbolRouteHandlersArgumentsMeta');
+const SymbolRouteHandlersArgumentsValue = Symbol('SymbolRouteHandlersArgumentsValue');
+
+function $schema(classType, options) {
+  if (!classType) return z.any();
+  if (classType.parseAsync) return classType;
+  if (classType.name === 'String') return z.string();
+  if (classType.name === 'Number') return z.number();
+  if (classType.name === 'Boolean') return z.boolean();
+  if (classType.name === 'Date') return z.date();
+  if (classType.name === 'BigInt') return z.bigint();
+  if (classType.name === 'Array') return z.array(z.any());
+  // check if object
+  const rules = classType.prototype ? appMetadata.getMetadata(SymbolDecoratorRule, classType.prototype) : undefined;
+  if (!rules) {
+    // not object
+    return z.any();
+  }
+  // object
+  let schema = z.object(rules);
+  if (options?.passthrough) schema = schema.passthrough();
+  if (options?.strict) schema = schema.strict();
+  // refId
+  const beanOptions = appResource.getBean(classType);
+  if (beanOptions) {
+    const openapi = cast(beanOptions.options)?.openapi;
+    schema = schema.openapi(beanOptions.beanFullName, openapi);
+  }
+  return schema;
+}
+
+const SymbolOpenApiOptions = Symbol('SymbolOpenApiOptions');
+
+var _dec$1, _dec2$1, _class$1;
+const __ArgumentTypes = ['param', 'query', 'body', 'headers', 'fields', 'field', 'files', 'file'];
+let ServiceOpenapi = (_dec$1 = Service(), _dec2$1 = BeanInfo({
+  module: "a-openapi"
+}), _dec$1(_class$1 = _dec2$1(_class$1 = class ServiceOpenapi extends BeanBase {
+  generateJson(version = 'V31') {
+    const registry = this._collectRegistry();
+    const generator = version === 'V30' ? new OpenApiGeneratorV3(registry.definitions) : new OpenApiGeneratorV31(registry.definitions);
+    const apiObj = generator.generateDocument(this.scope.config.generateDocument[version]);
+    this._translate(apiObj);
+    return apiObj;
+  }
+  generateJsonOfControllerAction(controller, actionKey, version = 'V31') {
+    const registry = new OpenAPIRegistry();
+    const beanOptions = appResource.getBean(controller);
+    if (!beanOptions) throw new Error('invalid controller');
+    this._collectController(registry, beanOptions.module, controller, actionKey);
+    const generator = version === 'V30' ? new OpenApiGeneratorV3(registry.definitions) : new OpenApiGeneratorV31(registry.definitions);
+    const apiObj = generator.generateDocument(this.scope.config.generateDocument[version]);
+    this._translate(apiObj);
+    return apiObj;
+  }
+  _translate(apiObj) {
+    // paths
+    if (apiObj.paths) {
+      for (const key in apiObj.paths) {
+        const pathObj = apiObj.paths[key];
+        for (const method in pathObj) {
+          const methodObj = pathObj[method];
+          this._translateStrings(methodObj, ['description', 'summary']);
+          // parameters
+          for (const parameterObj of methodObj.parameters || []) {
+            this._translateSchema(parameterObj.schema);
+          }
+          // requestBody
+          this._translateSchema(methodObj.requestBody?.content?.['application/json']?.schema);
+        }
+      }
+    }
+    // components
+    if (apiObj.components?.schemas) {
+      for (const key in apiObj.components.schemas) {
+        const schema = apiObj.components.schemas[key];
+        this._translateSchema(schema);
+      }
+    }
+  }
+  _translateSchema(schema) {
+    if (!schema) return;
+    if (schema.type === 'object' && schema.required === undefined) schema.required = [];
+    this._translateStrings(schema, ['title', 'description']);
+    const properties = cast(schema).properties;
+    if (properties && typeof properties === 'object') {
+      for (const prop in properties) {
+        const propObj = properties[prop];
+        this._translateSchema(propObj);
+      }
+    }
+  }
+  _translateStrings(obj, keys) {
+    for (const key of keys) {
+      this._translateString(obj, key);
+    }
+  }
+  _translateString(obj, key) {
+    if (!obj) return;
+    if (obj[key] && obj[key].includes(LocaleModuleNameSeparator)) {
+      obj[key] = this.app.meta.text(obj[key]);
+    }
+  }
+  _collectRegistry() {
+    const registry = new OpenAPIRegistry();
+    // securitySchemes
+    const configSecuritySchemes = this.scope.config.securitySchemes;
+    for (const key in configSecuritySchemes) {
+      let securityScheme = configSecuritySchemes[key];
+      if (typeof securityScheme === 'function') {
+        securityScheme = securityScheme.call(this.app);
+      }
+      registry.registerComponent('securitySchemes', key, securityScheme);
+    }
+    // schema: independent
+    for (const sceneName of ['dto', 'entity']) {
+      const onionSlices = this.bean.onion[sceneName].getOnionsEnabled();
+      for (const onionSlice of onionSlices) {
+        if (onionSlice.beanOptions.options?.independent) {
+          const schema = $schema(onionSlice.beanOptions.beanClass);
+          registry.register(onionSlice.beanOptions.beanFullName, schema);
+        }
+      }
+    }
+    // controller
+    for (const controller of this.bean.onion.controller.getOnionsEnabled()) {
+      this._collectController(registry, controller.beanOptions.module, controller.beanOptions.beanClass);
+    }
+    return registry;
+  }
+  _collectController(registry, moduleName, controller, actionKey) {
+    // info
+    const info = ModuleInfo.parseInfo(moduleName);
+    // controller options
+    const beanOptions = appResource.getBean(controller);
+    if (!beanOptions) return;
+    const controllerBeanFullName = beanOptions.beanFullName;
+    const controllerOptions = beanOptions.options;
+    const controllerPath = controllerOptions.path;
+    const controllerOpenApiOptions = appMetadata.getMetadata(SymbolOpenApiOptions, controller);
+    if (controllerOpenApiOptions?.exclude) return;
+    // descs
+    const descs = Object.getOwnPropertyDescriptors(controller.prototype);
+    const actionKeys = actionKey ? [actionKey] : Object.keys(descs);
+    for (const actionKey of actionKeys) {
+      const desc = descs[actionKey];
+      if (['constructor'].includes(actionKey)) continue;
+      if (!desc.value || typeof desc.value !== 'function') continue;
+      this._registerControllerAction(registry, info, controller, beanOptions, controllerBeanFullName, controllerPath, controllerOpenApiOptions, actionKey, desc);
+    }
+  }
+  _registerControllerAction(registry, info, controller, beanOptions, _controllerBeanFullName, controllerPath, controllerOpenApiOptions, actionKey, _desc) {
+    // app
+    const app = this.app;
+
+    // action options: should not extend controllerOpenApiOptions
+    const actionOpenApiOptions = appMetadata.getMetadata(SymbolOpenApiOptions, controller.prototype, actionKey);
+    if (actionOpenApiOptions?.exclude) return;
+
+    // actionPath/actionMethod
+    if (!appMetadata.hasMetadata(SymbolRequestMappingHandler, controller.prototype, actionKey)) return;
+    const handlerMetadata = appMetadata.getMetadata(SymbolRequestMappingHandler, controller.prototype, actionKey);
+    const actionPath = handlerMetadata.path || '';
+    const actionMethod = handlerMetadata.method || RequestMethod.GET;
+
+    // routePath
+    const routePath = app.util.combineApiPathControllerAndAction(info.relativeName, controllerPath, actionPath, true, true);
+    // :id -> {id}
+    const routePath2 = routePath.replace(/:([^/]+)/g, '{$1}');
+
+    // tags
+    let tags = actionOpenApiOptions?.tags ?? controllerOpenApiOptions?.tags;
+    if (!tags || tags.length === 0) {
+      tags = [toUpperCaseFirstChar(this.app.util.combineResourceName(beanOptions.name, info.relativeName, true, true))];
+    }
+    // operationId
+    let operationId = actionOpenApiOptions?.operationId ?? actionKey;
+    operationId = `${tags[0]}_${operationId}`;
+    // security
+    const _public = actionOpenApiOptions?.public ?? controllerOpenApiOptions?.public;
+    let security;
+    if (!_public) {
+      security = [{
+        bearerAuth: []
+      }];
+    }
+    // registerPath
+    registry.registerPath({
+      tags,
+      method: actionMethod,
+      path: routePath2,
+      operationId,
+      security,
+      description: actionOpenApiOptions?.description,
+      summary: actionOpenApiOptions?.summary,
+      request: this._collectRequest(controller, actionKey, actionOpenApiOptions, controllerOpenApiOptions),
+      responses: this._collectResponses(controller, actionKey, actionOpenApiOptions)
+    });
+  }
+  _collectRequest(controller, actionKey, actionOpenApiOptions, controllerOpenApiOptions) {
+    // meta
+    const argsMeta = this._prepareArgsMeta(controller, actionKey, actionOpenApiOptions, controllerOpenApiOptions);
+    if (!argsMeta) return;
+    // args
+    const argsMapWithField = {};
+    const argsMapIsolate = {};
+    let isUpload;
+    for (const argMeta of argsMeta) {
+      if (!__ArgumentTypes.includes(argMeta.type)) continue;
+      if (['fields', 'field', 'files', 'file'].includes(argMeta.type)) {
+        isUpload = true;
+      }
+      if (argMeta.field) {
+        if (!argsMapWithField[argMeta.type]) {
+          argsMapWithField[argMeta.type] = {};
+        }
+        argsMapWithField[argMeta.type][argMeta.field] = argMeta.schema;
+      } else {
+        if (!argsMapIsolate[argMeta.type]) {
+          argsMapIsolate[argMeta.type] = argMeta.schema;
+        }
+      }
+    }
+    // request
+    const request = {};
+    if (isUpload) {
+      const schemaObj = {};
+      // not check argsMapIsolate.fields
+      if (argsMapWithField.fields) Object.assign(schemaObj, argsMapWithField.fields);
+      if (argsMapWithField.field) Object.assign(schemaObj, argsMapWithField.field);
+      if (argsMapWithField.files) Object.assign(schemaObj, argsMapWithField.files);
+      if (argsMapWithField.file) Object.assign(schemaObj, argsMapWithField.file);
+      if (argsMapIsolate.files) schemaObj.blobs = argsMapIsolate.files;
+      const schema = z.object(schemaObj);
+      // body
+      request.body = {
+        required: true,
+        content: {
+          'multipart/form-data': {
+            schema
+          }
+        }
+      };
+    } else {
+      for (const argumentType of __ArgumentTypes) {
+        let schema = argsMapIsolate[argumentType];
+        if (argsMapWithField[argumentType]) {
+          if (!schema) {
+            schema = z.object(argsMapWithField[argumentType]);
+          } else {
+            schema = schema.extend(argsMapWithField[argumentType]);
+          }
+        }
+        if (!schema) continue;
+        // record
+        if (argumentType === 'body') {
+          // body
+          request.body = {
+            required: !schema.isOptional(),
+            content: {
+              'application/json': {
+                schema
+              }
+            }
+          };
+        } else {
+          // others
+          const name = argumentType === 'param' ? 'params' : argumentType;
+          request[name] = schema;
+        }
+      }
+    }
+    return request;
+  }
+  _collectResponses(controller, actionKey, actionOpenApiOptions) {
+    // contentType
+    const contentType = actionOpenApiOptions?.contentType || 'application/json';
+    // body schema
+    const bodySchema = this._parseBodySchema(controller, actionKey, actionOpenApiOptions, contentType);
+    // response
+    const response = {
+      description: '',
+      content: {
+        [contentType]: {
+          schema: bodySchema
+        }
+      }
+    };
+    // responses
+    const responses = {
+      [HttpStatus.OK]: response
+    };
+    return responses;
+  }
+  _parseBodySchema(controller, actionKey, actionOpenApiOptions, contentType) {
+    // bodySchema
+    let bodySchema;
+    if (actionOpenApiOptions?.bodySchema) {
+      bodySchema = actionOpenApiOptions.bodySchema;
+    } else {
+      const metaType = appMetadata.getDesignReturntype(controller.prototype, actionKey);
+      bodySchema = $schema(metaType);
+    }
+    // wrapper
+    if (contentType !== 'application/json') return bodySchema;
+    if (actionOpenApiOptions?.bodySchemaWrapper === false) return bodySchema;
+    const wrapper = actionOpenApiOptions?.bodySchemaWrapper ?? bodySchemaWrapperDefault;
+    return wrapper(bodySchema);
+  }
+  _prepareArgsMeta(controller, actionKey, actionOpenApiOptions, controllerOpenApiOptions) {
+    // meta
+    let argsMeta = appMetadata.getMetadata(SymbolRouteHandlersArgumentsMeta, controller.prototype, actionKey);
+    // headers
+    const objHeaders = Object.assign({}, this._combineArgHeaders(controllerOpenApiOptions?.headers), this._combineArgHeaders(actionOpenApiOptions?.headers));
+    // public
+    const _public = actionOpenApiOptions?.public ?? controllerOpenApiOptions?.public;
+    if (!_public && !objHeaders.Authorization) {
+      objHeaders.Authorization = z.string().optional();
+    }
+    if (isEmptyObject(objHeaders)) return argsMeta;
+    // merge
+    if (!argsMeta) argsMeta = [];
+    let argHeaders = argsMeta.find(item => item.type === 'headers' && !item.field);
+    if (!argHeaders) {
+      argHeaders = {
+        type: 'headers',
+        field: undefined,
+        schema: z.object(objHeaders)
+      };
+      argsMeta.push(argHeaders);
+    } else {
+      if (!argHeaders.schema.extend) throw new Error(`headers schema is not valid: ${actionKey}`);
+      argHeaders.schema = argHeaders.schema.extend(objHeaders);
+    }
+    return argsMeta;
+  }
+  _combineArgHeaders(headers) {
+    if (!headers) return;
+    const objHeaders = {};
+    for (const header of headers) {
+      objHeaders[header.name] = z.string().openapi({
+        description: header.description
+      });
+    }
+    return objHeaders;
+  }
+}) || _class$1) || _class$1);
+
+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 makeSchemaLikes(schemaLikes, typeInit) {
+  // default schema
+  let argSchema = $schema(typeInit);
+  // loop
+  for (let index = schemaLikes.length - 1; index >= 0; index--) {
+    const schemaLike = schemaLikes[index];
+    argSchema = makeSchemaLike(schemaLike, argSchema);
+  }
+  return argSchema;
+}
+function makeSchemaLike(schemaLike, schemaPrevious) {
+  if (!schemaLike) return schemaPrevious;
+  if (Object.prototype.hasOwnProperty.call(schemaLike, 'parseAsync')) {
+    // schema
+    return schemaLike;
+  } else if (isClassStrict(schemaLike) || ['String', 'Number', 'Boolean', 'Date', 'BigInt', 'Array'].includes(cast(schemaLike).name)) {
+    // class
+    return $schema(cast(schemaLike));
+  } else {
+    // function
+    return cast(schemaLike)(schemaPrevious);
+  }
+}
+
+function getTargetDecoratorRules(target) {
+  registerMappedClassMetadataKey(target, SymbolDecoratorRule, {
+    partialClass: meta => {
+      return meta.optional();
+    }
+  });
+  return appMetadata.getOwnMetadataMap(true, SymbolDecoratorRule, target);
+}
+function getTargetDecoratorRuleColumns(target) {
+  registerMappedClassMetadataKey(target, SymbolDecoratorRuleColumn);
+  return appMetadata.getOwnMetadataMap(true, SymbolDecoratorRuleColumn, target);
+}
+function mergeFieldsOpenAPIMetadata(target) {
+  // rules
+  const rules = getTargetDecoratorRules(target.prototype);
+  // beanOptions
+  const beanOptions = appResource.getBean(target);
+  const fields = cast(beanOptions?.options)?.fields;
+  if (!fields) return;
+  for (const key in fields) {
+    const field = fields[key];
+    if (!field) continue;
+    const schemaCurrent = rules[key];
+    if (Object.prototype.hasOwnProperty.call(field, 'parseAsync')) {
+      const schema = field;
+      rules[key] = schema.openapi(deepExtend({}, schemaCurrent?._def.openapi?.metadata, schema._def.openapi?.metadata));
+    } else {
+      // use deepExtend for sure strict
+      if (schemaCurrent) {
+        rules[key] = schemaCurrent.openapi(deepExtend({}, schemaCurrent._def.openapi?.metadata, field));
+      } else {
+        rules[key] = z.any().openapi(deepExtend({}, field));
+      }
+    }
+  }
+}
+
+function Field$1(...schemaLikes) {
+  return function (target, prop) {
+    // rules
+    const rules = getTargetDecoratorRules(target);
+    // rule
+    const metaType = appMetadata.getDesignType(target, prop);
+    rules[prop] = makeSchemaLikes(schemaLikes, metaType);
+    //
+    const columns = getTargetDecoratorRuleColumns(target);
+    columns[prop] = prop;
+  };
+}
+
+function setPublic(target, prop, _descriptor, value) {
+  const options = appMetadata.getOwnMetadataMap(false, SymbolOpenApiOptions, target, prop);
+  options.public = value;
+}
+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;
+  };
+}
+const Api = {
+  field: Field$1,
+  contentType,
+  body,
+  bodyCustom,
+  exclude,
+  tags,
+  header,
+  headers
+};
+
+function createPipesArgumentDecorator(paramType, extractValue) {
+  return function (field, ...schemaLikes) {
+    return function (target, prop, index) {
+      // not inherit
+      const argsMeta = appMetadata.getOwnMetadataArray(false, SymbolRouteHandlersArgumentsMeta, target, prop);
+      const hasParamField = typeof field === 'string';
+      const paramField = hasParamField ? field : undefined;
+      const paramSchemaLikes = hasParamField ? schemaLikes : [field, ...schemaLikes].filter(item => !!item);
+      const paramtypes = appMetadata.getMetadata('design:paramtypes', target, prop);
+      let metaType;
+      if (paramType === 'file') {
+        metaType = z.string().openapi({
+          format: 'binary'
+        });
+      } else if (paramType === 'files') {
+        metaType = z.array(z.string().openapi({
+          format: 'binary'
+        }));
+      } else {
+        metaType = paramtypes[index];
+      }
+      const argSchema = makeSchemaLikes(paramSchemaLikes, metaType);
+      argsMeta.push({
+        index,
+        type: paramType,
+        field: paramField,
+        pipes: [argSchema],
+        schema: argSchema,
+        extractValue
+      });
+    };
+  };
+}
+
+function Param(property, ...schemaLikes) {
+  return createPipesArgumentDecorator('param')(property, ...schemaLikes);
+}
+function Query(property, ...schemaLikes) {
+  return createPipesArgumentDecorator('query')(property, ...schemaLikes);
+}
+function Body(property, ...schemaLikes) {
+  return createPipesArgumentDecorator('body')(property, ...schemaLikes);
+}
+function Headers(property, ...schemaLikes) {
+  return createPipesArgumentDecorator('headers')(property, ...schemaLikes);
+}
+function Fields(property, ...schemaLikes) {
+  return createPipesArgumentDecorator('fields')(property, ...schemaLikes);
+}
+function Field(property, ...schemaLikes) {
+  return createPipesArgumentDecorator('field')(property, ...schemaLikes);
+}
+function Files(property, ...schemaLikes) {
+  return createPipesArgumentDecorator('files')(property, ...schemaLikes);
+}
+function File(property, ...schemaLikes) {
+  return createPipesArgumentDecorator('file')(property, ...schemaLikes);
+}
+function User(...schemaLikes) {
+  return createPipesArgumentDecorator('user')(undefined, ...schemaLikes);
+}
+const Arg = {
+  param: Param,
+  query: Query,
+  body: Body,
+  headers: Headers,
+  fields: Fields,
+  field: Field,
+  files: Files,
+  file: File,
+  user: User
+};
+
+function schemaEmail(message) {
+  return function (schema) {
+    return schema.email(message);
+  };
+}
+function schemaUrl(message) {
+  return function (schema) {
+    return schema.url(message);
+  };
+}
+function schemaUuid(message) {
+  return function (schema) {
+    return schema.uuid(message);
+  };
+}
+function schemaIp(options) {
+  return function (schema) {
+    return schema.ip(options);
+  };
+}
+function schemaMin(min, message) {
+  return function (schema) {
+    return schema.min(min, message);
+  };
+}
+function schemaMax(max, message) {
+  return function (schema) {
+    return schema.max(max, message);
+  };
+}
+function schemaTableIdentity() {
+  return function (_schema) {
+    return z.union([z.string(), z.number()]);
+  };
+}
+
+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 schemaDefault(defaultValue) {
+  return function (schema) {
+    return schema.default(defaultValue);
+  };
+}
+function schemaOptional() {
+  return function (schema) {
+    return schema.optional();
+  };
+}
+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 (isNil(params?.separator) && val[0] === '[') return JSON.parse(val);
+      return val.split(params?.separator ?? ',');
+    }, z.array(makeSchemaLike(schemaLike ?? schema, z.any()), params)
+    // z.array(makeSchemaLike(schemaLike, schema), params),
+    );
+  };
+}
+
+const v = {
+  array: schemaArray,
+  default: schemaDefault,
+  object: schemaObject,
+  optional: schemaOptional,
+  // helpers
+  email: schemaEmail,
+  url: schemaUrl,
+  uuid: schemaUuid,
+  ip: schemaIp,
+  min: schemaMin,
+  max: schemaMax,
+  tableIdentity: schemaTableIdentity,
+  // openapi
+  openapi: schemaOpenapi,
+  title: schemaTitle,
+  description: schemaDescription,
+  example: schemaExample
+};
+
+const OrderCoreBase = 100;
+const OrderBusinessBase = 1000;
+const OrderUnknownBase = 10000;
+const OrderMaxBase = 100000;
+
+export { $locale, $schema, Api, Arg, Main, OrderBusinessBase, OrderCoreBase, OrderMaxBase, OrderUnknownBase, ScopeModuleAOpenapi, ServiceOpenapi, SymbolDecoratorRule, SymbolDecoratorRuleColumn, SymbolOpenApiOptions, SymbolRouteHandlersArgumentsMeta, SymbolRouteHandlersArgumentsValue, bodySchemaWrapperDefault, config, createPipesArgumentDecorator, errorsAdapter, getTargetDecoratorRuleColumns, getTargetDecoratorRules, locales, makeSchemaLike, makeSchemaLikes, mergeFieldsOpenAPIMetadata, setPublic, v };