vona-module-a-openapi 5.0.72 → 5.1.2

package/src/.metadata/index.ts

@@ -0,0 +1,139 @@
+// eslint-disable
+/** bean: begin */
+export * from '../bean/bean.openapi.ts';
+
+import 'vona';
+declare module 'vona' {
+  
+  
+}
+declare module 'vona-module-a-openapi' {
+  
+        export interface BeanOpenapi {
+          /** @internal */
+          get scope(): ScopeModuleAOpenapi;
+        } 
+}
+/** bean: end */
+/** bean: begin */
+import type { BeanOpenapi } from '../bean/bean.openapi.ts';
+import 'vona';  
+declare module 'vona' {
+  export interface IBeanRecordGlobal {
+    'openapi': BeanOpenapi;
+  }
+}
+/** bean: end */
+/** service: begin */
+export * from '../service/openapi.ts';
+
+import 'vona-module-a-bean';
+declare module 'vona-module-a-bean' {
+  
+    export interface IServiceRecord {
+      'a-openapi:openapi': never;
+    }
+
+  
+}
+declare module 'vona-module-a-openapi' {
+  
+        export interface ServiceOpenapi {
+          /** @internal */
+          get scope(): ScopeModuleAOpenapi;
+        }
+
+          export interface ServiceOpenapi {
+            get $beanFullName(): 'a-openapi.service.openapi';
+            get $onionName(): 'a-openapi:openapi';
+            
+          } 
+}
+/** service: end */
+/** service: begin */
+import type { ServiceOpenapi } from '../service/openapi.ts';
+export interface IModuleService {
+  'openapi': ServiceOpenapi;
+}
+/** service: end */
+/** service: begin */
+
+import 'vona';
+declare module 'vona' {
+  export interface IBeanRecordGeneral {
+    'a-openapi.service.openapi': ServiceOpenapi;
+  }
+}
+/** service: end */
+/** summerCache: begin */
+export * from '../bean/summerCache.json.ts';
+
+import { type IDecoratorSummerCacheOptions } from 'vona-module-a-summer';
+declare module 'vona-module-a-summer' {
+  
+    export interface ISummerCacheRecord {
+      'a-openapi:json': IDecoratorSummerCacheOptions;
+    }
+
+  
+}
+declare module 'vona-module-a-openapi' {
+  
+        export interface SummerCacheJson {
+          /** @internal */
+          get scope(): ScopeModuleAOpenapi;
+        }
+
+          export interface SummerCacheJson {
+            get $beanFullName(): 'a-openapi.summerCache.json';
+            get $onionName(): 'a-openapi:json';
+            get $onionOptions(): IDecoratorSummerCacheOptions;
+          } 
+}
+/** summerCache: end */
+/** summerCache: begin */
+import type { SummerCacheJson } from '../bean/summerCache.json.ts';
+export interface IModuleSummerCache {
+  'json': SummerCacheJson;
+}
+/** summerCache: end */
+/** config: begin */
+export * from '../config/config.ts';
+import type { config } from '../config/config.ts';
+/** config: end */
+/** main: begin */
+export * from '../main.ts';
+/** main: end */
+/** scope: begin */
+import { BeanScopeBase, type BeanScopeUtil, type TypeModuleConfig } from 'vona';
+import { Scope } from 'vona-module-a-bean';
+
+@Scope()
+export class ScopeModuleAOpenapi extends BeanScopeBase {}
+
+export interface ScopeModuleAOpenapi {
+  util: BeanScopeUtil;
+config: TypeModuleConfig<typeof config>;
+service: IModuleService;
+summerCache: IModuleSummerCache;
+}
+
+import 'vona';
+declare module 'vona' {
+  export interface IBeanScopeRecord {
+    'a-openapi': ScopeModuleAOpenapi;
+  }
+
+  export interface IBeanScopeContainer {
+    openapi: ScopeModuleAOpenapi;
+  }
+  
+  export interface IBeanScopeConfig {
+    'a-openapi': ReturnType<typeof config>;
+  }
+
+  
+
+  
+}
+/** scope: end */

package/src/.metadata/this.ts

@@ -0,0 +1,2 @@
+export const __ThisModule__ = 'a-openapi';
+export { ScopeModuleAOpenapi as ScopeModule } from './index.ts';

package/src/bean/bean.openapi.ts

@@ -0,0 +1,84 @@
+import type { Constructable } from 'vona';
+import type { ICachingActionKeyInfo } from 'vona-module-a-caching';
+import type { IOpenapiObject } from 'vona-module-a-openapiutils';
+
+import { OpenApiGeneratorV3, OpenApiGeneratorV31, OpenAPIRegistry } from '@cabloy/zod-to-openapi';
+import { appResource, BeanBase, beanFullNameFromOnionName } from 'vona';
+import { Bean } from 'vona-module-a-bean';
+import { Caching } from 'vona-module-a-caching';
+import { $schema } from 'vona-module-a-openapiutils';
+
+@Bean()
+export class BeanOpenapi extends BeanBase {
+  public async clearAllCaches() {
+    const cacheOpenapiSchema = this.bean.summer.cache(beanFullNameFromOnionName('a-openapi:json', 'summerCache'));
+    await cacheOpenapiSchema.clear();
+    const cacheSwagger = this.bean.summer.cache(beanFullNameFromOnionName('a-swagger:swagger', 'summerCache'));
+    await cacheSwagger.clear();
+    const cacheRapidoc = this.bean.summer.cache(beanFullNameFromOnionName('a-swagger:rapidoc', 'summerCache'));
+    await cacheRapidoc.clear();
+  }
+
+  // need not cache
+  async generateJsonOfClass<K extends keyof IOpenapiObject>(schemaClass: Constructable, version: K = 'V31' as any): Promise<IOpenapiObject[K]> {
+    return await this.generateJsonOfClasses([schemaClass], version);
+  }
+
+  // need not cache
+  async generateJsonOfClasses<K extends keyof IOpenapiObject>(schemaClasses: Constructable[], version: K = 'V31' as any): Promise<IOpenapiObject[K]> {
+    const registry = new OpenAPIRegistry();
+    // schema: independent
+    let counter = 0;
+    for (const schemaClass of schemaClasses) {
+      const schema = $schema(schemaClass);
+      let beanFullName = appResource.getBeanFullName(schemaClass);
+      if (!beanFullName) {
+        beanFullName = `${schemaClass.name}_${counter++}`;
+      }
+      registry.register(beanFullName, schema);
+    }
+    const generator = version === 'V30' ? new OpenApiGeneratorV3(registry.definitions) : new OpenApiGeneratorV31(registry.definitions);
+    const apiObj = generator.generateDocument(this.scope.config.generateDocument[version]);
+    this.scope.service.openapi.translate(apiObj, 'rest');
+    return apiObj as IOpenapiObject[K];
+  }
+
+  protected generateJsonCacheKey(info: ICachingActionKeyInfo) {
+    const version = info.args[0] ?? 'V31';
+    const locale = this.ctx.locale;
+    return `${info.prop}_${version}_${locale}`;
+  }
+
+  protected generateJsonOfControllerActionCacheKey(info: ICachingActionKeyInfo) {
+    const [controller, actionKey, version] = info.args;
+    const beanOptions = appResource.getBean(controller)!;
+    const beanFullName = beanOptions.beanFullName;
+    const locale = this.ctx.locale;
+    return `${info.prop}_${beanFullName}_${actionKey}_${version ?? 'V31'}_${locale}`;
+  }
+
+  @Caching.get({ cacheName: 'a-openapi:json', cacheKeyFn: 'generateJsonCacheKey' })
+  async generateJson<K extends keyof IOpenapiObject>(version: K = 'V31' as any): Promise<IOpenapiObject[K]> {
+    const registry = this.scope.service.openapi.collectRegistry();
+    const generator = version === 'V30' ? new OpenApiGeneratorV3(registry.definitions) : new OpenApiGeneratorV31(registry.definitions);
+    const apiObj = generator.generateDocument(this.scope.config.generateDocument[version]);
+    this.scope.service.openapi.translate(apiObj, 'api');
+    return apiObj as IOpenapiObject[K];
+  }
+
+  @Caching.get({ cacheName: 'a-openapi:json', cacheKeyFn: 'generateJsonOfControllerActionCacheKey' })
+  async generateJsonOfControllerAction<K extends keyof IOpenapiObject>(
+    controller: Constructable,
+    actionKey: string,
+    version: K = 'V31' as any,
+  ): Promise<IOpenapiObject[K]> {
+    const registry = new OpenAPIRegistry();
+    const beanOptions = appResource.getBean(controller);
+    if (!beanOptions) throw new Error('invalid controller');
+    this.scope.service.openapi.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.scope.service.openapi.translate(apiObj, 'rest');
+    return apiObj as IOpenapiObject[K];
+  }
+}

package/src/bean/summerCache.json.ts

@@ -0,0 +1,17 @@
+import type { ISummerCacheGet, TSummerCacheActionOptions } from 'vona-module-a-summer';
+
+import { BeanSummerCacheBase, SummerCache } from 'vona-module-a-summer';
+
+export type TSummerCacheJsonKey = any;
+export type TSummerCacheJsonData = any;
+
+@SummerCache({ preset: 'mem' })
+export class SummerCacheJson
+  extends BeanSummerCacheBase<TSummerCacheJsonKey, TSummerCacheJsonData>
+  implements ISummerCacheGet<TSummerCacheJsonKey, TSummerCacheJsonData>
+{
+  async getNative(
+    _key?: TSummerCacheJsonKey,
+    _options?: TSummerCacheActionOptions<TSummerCacheJsonKey, TSummerCacheJsonData>,
+  ): Promise<TSummerCacheJsonData | undefined> {}
+}

package/src/config/config.ts

@@ -0,0 +1,35 @@
+import type { OpenAPIObjectConfig as OpenAPIObjectConfigV30 } from '@cabloy/zod-to-openapi/dist/v3.0/openapi-generator.ts';
+import type { OpenAPIObjectConfigV31 } from '@cabloy/zod-to-openapi/dist/v3.1/openapi-generator.ts';
+import type { VonaApplication } from 'vona';
+import type { TypeOpenApiVersion, TypeSecuritySchemes } from 'vona-module-a-openapiutils';
+
+export function config(_app: VonaApplication) {
+  return {
+    defaultVersion: 'V31' as TypeOpenApiVersion,
+    generateDocument: {
+      V30: {
+        openapi: '3.0.0',
+        info: {
+          version: '5.0.0',
+          title: 'Vona',
+          description: 'Vona API',
+        },
+      } as OpenAPIObjectConfigV30,
+      V31: {
+        openapi: '3.1.0',
+        info: {
+          version: '5.0.0',
+          title: 'Vona',
+          description: 'Vona API',
+        },
+      } as OpenAPIObjectConfigV31,
+    },
+    securitySchemes: {
+      bearerAuth: {
+        type: 'http',
+        scheme: 'bearer',
+        bearerFormat: 'JWT',
+      },
+    } as TypeSecuritySchemes,
+  };
+}

package/src/index.ts

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

package/src/lib/index.ts

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

package/src/lib/zod/index.ts

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

package/src/lib/zod/schemaRefCustomAdapter.ts

@@ -0,0 +1,29 @@
+import type { VonaApplication } from 'vona';
+
+import { ZodMetadata } from '@cabloy/zod-openapi';
+import { OpenApiGeneratorV31, OpenAPIRegistry } from '@cabloy/zod-to-openapi';
+import { cast } from 'vona';
+
+export function schemaRefCustomAdapter(_app: VonaApplication) {
+  const registry = new OpenAPIRegistry();
+  const generator31 = new OpenApiGeneratorV31(registry.definitions);
+  _patchGenerator(generator31);
+}
+
+function _patchGenerator(generator: any) {
+  const gen = Object.getPrototypeOf(cast(generator).generator);
+  gen.generateSchemaWithRef = function (zodSchema) {
+    // schema ref
+    zodSchema = ZodMetadata.resolveLazySchema(zodSchema);
+    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) };
+  };
+}

package/src/main.ts

@@ -0,0 +1,14 @@
+import type { IModuleMain } from 'vona';
+
+import { BeanSimple } from 'vona';
+
+import { schemaRefCustomAdapter } from './lib/zod/schemaRefCustomAdapter.ts';
+
+export class Main extends BeanSimple implements IModuleMain {
+  async moduleLoading() {}
+  async moduleLoaded() {
+    schemaRefCustomAdapter(this.app);
+  }
+
+  async configLoaded(_config: any) {}
+}