vona-module-a-openapi 5.0.25 → 5.0.26

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

@@ -9,6 +9,10 @@ declare module 'vona-module-a-bean' {
 declare module 'vona-module-a-openapi' {
     interface ServiceOpenapi {
     }
+    interface ServiceOpenapi {
+        get $beanFullName(): 'a-openapi.service.openapi';
+        get $onionName(): 'a-openapi:openapi';
+    }
 }
 /** service: end */
 /** service: begin */
@@ -36,6 +40,10 @@ declare module 'vona-module-a-summer' {
 declare module 'vona-module-a-openapi' {
     interface SummerCacheJson {
     }
+    interface SummerCacheJson {
+        get $beanFullName(): 'a-openapi.summerCache.json';
+        get $onionName(): 'a-openapi:json';
+    }
 }
 /** summerCache: end */
 /** summerCache: begin */

package/dist/index.js

@@ -1,12 +1,12 @@
-import { appMetadata, appResource, cast, BeanInfo, BeanBase, LocaleModuleNameSeparator, HttpStatus, BeanSimple, BeanScopeBase, isClassStrict, registerMappedClassMetadataKey, deepExtend } from 'vona';
+import { registerMappedClassMetadataKey, appMetadata, appResource, cast, deepExtend, BeanInfo, BeanBase, LocaleModuleNameSeparator, HttpStatus, BeanSimple, BeanScopeBase } from 'vona';
 import { OpenApiGeneratorV3, OpenApiGeneratorV31, OpenAPIRegistry } from '@asteasolutions/zod-to-openapi';
 import * as ModuleInfo from '@cabloy/module-info';
-import { isEmptyObject, isNil } from '@cabloy/utils';
+import { isClass, isEmptyObject, isNil } from '@cabloy/utils';
 import { toUpperCaseFirstChar } from '@cabloy/word-utils';
-import { getTypeName, coerceWithNil } from '@cabloy/zod-query';
+import { getTypeName, ZodMetadata, coerceWithNil } from '@cabloy/zod-query';
 import { Service, Scope } from 'vona-module-a-bean';
 import { Caching } from 'vona-module-a-caching';
-import { SymbolDecoratorRule, SymbolOpenApiOptions, SymbolDecoratorRuleColumn } from 'vona-module-a-openapiutils';
+import { SymbolDecoratorRule, SymbolDecoratorRuleColumn, SymbolOpenApiOptions } from 'vona-module-a-openapiutils';
 import { SymbolRequestMappingHandler } from 'vona-module-a-web';
 import { z } from 'zod';
 import { SummerCache, BeanSummerCacheBase } from 'vona-module-a-summer';
@@ -31,6 +31,82 @@ function bodySchemaWrapperDefault(bodySchema) {
   });
 }
 
+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 prepareClassType(classType) {
+  return isClass(classType) ? classType : cast(classType)();
+}
+
+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 (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;
@@ -47,15 +123,37 @@ function $schema(classType, options) {
     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 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?.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;
 }
 
@@ -456,10 +554,39 @@ function errorsAdapter(app) {
   });
 }
 
+function schemaRefCustomAdapter(_app) {
+  const registry = new OpenAPIRegistry();
+  const generator31 = new OpenApiGeneratorV31(registry.definitions);
+  _patchGenerator(generator31);
+}
+function _patchGenerator(generator) {
+  const gen = Object.getPrototypeOf(cast(generator).generator);
+  gen.generateSchemaWithRef = function (zodSchema) {
+    // schema ref
+    const lazySchema = ZodMetadata.getLazySchema(zodSchema);
+    if (lazySchema) {
+      zodSchema = lazySchema();
+    }
+    const refId = ZodMetadata.getRefId(zodSchema);
+    if (!refId) {
+      return this.generateSimpleSchema(zodSchema);
+    }
+    if (this.schemaRefs[refId] === undefined) {
+      this.schemaRefs[refId] = null;
+      const result = this.generateSimpleSchema(zodSchema);
+      this.schemaRefs[refId] = result;
+    }
+    return {
+      $ref: this.generateSchemaRef(refId)
+    };
+  };
+}
+
 class Main extends BeanSimple {
   async moduleLoading() {}
   async moduleLoaded() {
     errorsAdapter(this.app);
+    schemaRefCustomAdapter(this.app);
   }
   async configLoaded(_config) {}
 }
@@ -477,67 +604,6 @@ function $locale(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
@@ -751,6 +817,11 @@ function schemaTableIdentity() {
     return z.union([z.string(), z.number()]);
   };
 }
+function schemaBigNumber() {
+  return function (_schema) {
+    return z.union([z.string(), z.number()]);
+  };
+}
 
 function schemaOpenapi(refId, metadata) {
   return function (schema) {
@@ -789,6 +860,11 @@ function schemaOptional() {
     return schema.optional();
   };
 }
+function schemaLazy(...schemaLikes) {
+  return function (_schema) {
+    return $schemaLazy(...schemaLikes);
+  };
+}
 function schemaObject(classType, options) {
   return function (_schema) {
     return $schema(classType, options);
@@ -809,6 +885,7 @@ function schemaArray(schemaLike, params) {
 }
 
 const v = {
+  lazy: schemaLazy,
   array: schemaArray,
   default: schemaDefault,
   object: schemaObject,
@@ -821,6 +898,7 @@ const v = {
   min: schemaMin,
   max: schemaMax,
   tableIdentity: schemaTableIdentity,
+  bigNumber: schemaBigNumber,
   // openapi
   openapi: schemaOpenapi,
   title: schemaTitle,
@@ -833,4 +911,4 @@ const OrderBusinessBase = 1000;
 const OrderUnknownBase = 10000;
 const OrderMaxBase = 100000;
 
-export { $locale, $schema, Api, Arg, Main, OrderBusinessBase, OrderCoreBase, OrderMaxBase, OrderUnknownBase, ScopeModuleAOpenapi, ServiceOpenapi, SummerCacheJson, SymbolRouteHandlersArgumentsMeta, SymbolRouteHandlersArgumentsValue, bodySchemaWrapperDefault, config, createPipesArgumentDecorator, errorsAdapter, getTargetDecoratorRuleColumns, getTargetDecoratorRules, locales, makeSchemaLike, makeSchemaLikes, mergeFieldsOpenapiMetadata, v };
+export { $locale, $schema, $schemaLazy, Api, Arg, Main, OrderBusinessBase, OrderCoreBase, OrderMaxBase, OrderUnknownBase, ScopeModuleAOpenapi, ServiceOpenapi, SummerCacheJson, SymbolRouteHandlersArgumentsMeta, SymbolRouteHandlersArgumentsValue, SymbolSchemaDynamicRefId, addSchemaDynamic, bodySchemaWrapperDefault, config, createPipesArgumentDecorator, errorsAdapter, getSchemaDynamic, getSchemasDynamic, getTargetDecoratorRuleColumns, getTargetDecoratorRules, locales, makeSchemaLike, makeSchemaLikes, mergeFieldsOpenapiMetadata, prepareClassType, schemaRefCustomAdapter, v };

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

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

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

@@ -1,4 +1,5 @@
 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(schemaLike: z.ZodSchema): z.ZodSchema;
@@ -9,3 +10,4 @@ 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.ZodSchema<T>;
+export declare function $schemaLazy<T>(...schemaLikes: SchemaLike[]): z.ZodSchema<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/helpers.d.ts

@@ -11,3 +11,4 @@ export declare function schemaIp(options?: string | {
 export declare function schemaMin(min: number, message?: errorUtil.ErrMessage): (schema: any) => any;
 export declare function schemaMax(max: number, message?: errorUtil.ErrMessage): (schema: any) => any;
 export declare function schemaTableIdentity(): (_schema: any) => any;
+export declare function schemaBigNumber(): (_schema: any) => any;

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

@@ -2,9 +2,10 @@ 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<T>(defaultValue: T): (schema: z.ZodSchema) => z.ZodSchema;
+export declare function schemaDefault(defaultValue: any | Function): (schema: z.ZodSchema) => z.ZodSchema;
 export declare function schemaOptional(): (schema: z.ZodSchema) => z.ZodSchema;
-export declare function schemaObject<T>(classType: Constructable<T>, options?: ISchemaObjectOptions): (_schema: z.ZodSchema) => z.ZodSchema<T>;
+export declare function schemaLazy<T>(...schemaLikes: SchemaLike[]): (_schema?: z.ZodSchema) => z.ZodSchema<T>;
+export declare function schemaObject<T>(classType: Constructable<T>, options?: ISchemaObjectOptions): (_schema?: z.ZodSchema) => z.ZodSchema<T>;
 export declare function schemaArray(schemaLike?: SchemaLike, params?: z.RawCreateParams & {
     separator?: string;
 }): (schema: z.ZodSchema) => z.ZodSchema;

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

@@ -1,7 +1,8 @@
-import { schemaEmail, schemaIp, schemaMax, schemaMin, schemaTableIdentity, schemaUrl, schemaUuid } from './v/helpers.ts';
+import { schemaBigNumber, schemaEmail, schemaIp, schemaMax, schemaMin, schemaTableIdentity, schemaUrl, schemaUuid } from './v/helpers.ts';
 import { schemaDescription, schemaExample, schemaOpenapi, schemaTitle } from './v/openapi.ts';
-import { schemaArray, schemaDefault, schemaObject, schemaOptional } from './v/system.ts';
+import { schemaArray, schemaDefault, schemaLazy, schemaObject, schemaOptional } from './v/system.ts';
 export declare const v: {
+    lazy: typeof schemaLazy;
     array: typeof schemaArray;
     default: typeof schemaDefault;
     object: typeof schemaObject;
@@ -13,6 +14,7 @@ export declare const v: {
     min: typeof schemaMin;
     max: typeof schemaMax;
     tableIdentity: typeof schemaTableIdentity;
+    bigNumber: typeof schemaBigNumber;
     openapi: typeof schemaOpenapi;
     title: typeof schemaTitle;
     description: typeof schemaDescription;

package/dist/lib/utils.d.ts

@@ -2,3 +2,4 @@ import type { Constructable } from 'vona';
 export declare function getTargetDecoratorRules(target: object): Record<PropertyKey, unknown>;
 export declare function getTargetDecoratorRuleColumns(target: object): Record<PropertyKey, unknown>;
 export declare function mergeFieldsOpenapiMetadata(target: Constructable): void;
+export declare function prepareClassType<T>(classType: (() => Constructable<T>) | Constructable<T>): Constructable<T>;

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

@@ -1,2 +1,3 @@
 export * from './errorsAdapter.ts';
 export * from './errorUtil.ts';
+export * from './schemaRefCustomAdapter.ts';

package/dist/lib/zod/schemaRefCustomAdapter.d.ts

@@ -0,0 +1,2 @@
+import type { VonaApplication } from 'vona';
+export declare function schemaRefCustomAdapter(_app: VonaApplication): void;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "vona-module-a-openapi",
   "type": "module",
-  "version": "5.0.25",
+  "version": "5.0.26",
   "title": "a-openapi",
   "vonaModule": {
     "capabilities": {
@@ -35,7 +35,7 @@
   "dependencies": {
     "@asteasolutions/zod-to-openapi": "^7.3.0",
     "@cabloy/zod-errors-custom": "^1.0.13",
-    "@cabloy/zod-query": "^1.0.15",
+    "@cabloy/zod-query": "^1.0.16",
     "@zhennann/currency": "^2.0.0",
     "openapi3-ts": "^4.4.0",
     "zod": "^3.25.58"