zova-module-a-openapi 5.0.0 → 5.1.0

package/src/.metadata/index.ts

@@ -0,0 +1,102 @@
+// eslint-disable
+/** model: begin */
+export * from '../model/sdk.js';
+import { IModelOptionsSdk } from '../model/sdk.js';
+import 'zova-module-a-model';
+declare module 'zova-module-a-model' {
+  
+    export interface IModelRecord {
+      'a-openapi:sdk': IModelOptionsSdk;
+    }
+
+  
+}
+declare module 'zova-module-a-openapi' {
+  
+        export interface ModelSdk {
+          /** @internal */
+          get scope(): ScopeModuleAOpenapi;
+        }
+
+        export interface ModelSdk {
+          get $beanFullName(): 'a-openapi.model.sdk';
+          get $onionName(): 'a-openapi:sdk';
+          get $onionOptions(): IModelOptionsSdk;
+        } 
+}
+/** model: end */
+/** model: begin */
+import { ModelSdk } from '../model/sdk.js';
+import 'zova';
+declare module 'zova' {
+  export interface IBeanRecordGeneral {
+    'a-openapi.model.sdk': ModelSdk;
+  }
+}
+/** model: end */
+/** sys: begin */
+export * from '../bean/sys.sdk.js';
+
+import 'zova';
+declare module 'zova' {
+  
+  
+}
+declare module 'zova-module-a-openapi' {
+  
+        export interface SysSdk {
+          /** @internal */
+          get scope(): ScopeModuleAOpenapi;
+        }
+
+        export interface SysSdk {
+          get $beanFullName(): 'a-openapi.sys.sdk';
+          get $onionName(): 'a-openapi:sdk';
+          
+        } 
+}
+/** sys: end */
+/** sys: begin */
+import { SysSdk } from '../bean/sys.sdk.js';
+import 'zova';
+declare module 'zova' {
+  export interface IBeanRecordGeneral {
+    'a-openapi.sys.sdk': SysSdk;
+  }
+}
+/** sys: end */
+/** config: begin */
+export * from '../config/config.js';
+import { config } from '../config/config.js';
+/** config: end */
+/** monkey: begin */
+export * from '../monkey.js';
+/** monkey: end */
+/** scope: begin */
+import { BeanScopeBase, type BeanScopeUtil, TypeModuleConfig } from 'zova';
+import { Scope } from 'zova-module-a-bean';
+
+@Scope()
+export class ScopeModuleAOpenapi extends BeanScopeBase {}
+
+export interface ScopeModuleAOpenapi {
+  util: BeanScopeUtil;
+config: TypeModuleConfig<typeof config>;
+}
+
+import 'zova';
+declare module 'zova' {
+  export interface IBeanScopeRecord {
+    'a-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.js';

package/src/bean/sys.sdk.ts

@@ -0,0 +1,156 @@
+import type { SchemaObject } from 'openapi3-ts/oas31';
+
+import { shallowReactive } from 'vue';
+import { BeanBase, IApiActionConfigPrepareOptions, ILocaleRecord, TypeEventOff } from 'zova';
+import { IApiSchemaOptions } from 'zova-module-a-api';
+import { Sys } from 'zova-module-a-bean';
+import { BeanFetch } from 'zova-module-a-fetch';
+
+import { IOpenapiSchema } from '../types/schema.js';
+import { IOpenapiSdkBootstrap, IOpenapiSdkItem, SymbolOpenapiSchemaName, TypeRequestMethod } from '../types/sdk.js';
+
+// const PATH_PARAM_RE = /\{([^{}/]+)\}/g;
+
+@Sys()
+export class SysSdk extends BeanBase {
+  private locale: keyof ILocaleRecord;
+  bootstraps: Record<string, IOpenapiSdkBootstrap>;
+  schemas: Record<string, SchemaObject>;
+  sdks: Record<string, Record<string, IOpenapiSdkItem>>;
+  private _eventSsrHmrReload: TypeEventOff;
+  private _fetch: BeanFetch;
+
+  protected async __init__(locale: keyof ILocaleRecord) {
+    this.locale = locale;
+    this.bootstraps = shallowReactive({});
+    this.schemas = shallowReactive({});
+    this.sdks = shallowReactive({});
+    // event
+    if (this.sys.env.SSR_HMR === 'true') {
+      this._eventSsrHmrReload = this.sys.meta.event.on('a-ssrhmr:reload', async (_data, next) => {
+        await this.reload();
+        return next();
+      });
+    }
+  }
+
+  protected __dispose__() {
+    if (this._eventSsrHmrReload) {
+      this._eventSsrHmrReload();
+    }
+  }
+
+  private async reload() {
+    // server
+    if (process.env.SERVER) {
+      this.bootstraps = shallowReactive({});
+      this.schemas = shallowReactive({});
+      this.sdks = shallowReactive({});
+      return;
+    }
+    // client
+    // bootstraps
+    const bootstraps = this.bootstraps;
+    this.bootstraps = shallowReactive({});
+    for (const resource in bootstraps) {
+      await this.loadBootstrap(this._fetch, resource);
+    }
+    // sdks
+    const sdks = this.sdks;
+    this.sdks = shallowReactive({});
+    for (const api in sdks) {
+      for (const apiMethod in sdks[api]) {
+        await this.loadSdk(this._fetch, api, apiMethod as any, { authToken: false });
+      }
+    }
+  }
+
+  getBootstrap(resource: string): IOpenapiSdkBootstrap | undefined {
+    return this.bootstraps[resource];
+  }
+
+  getSdk(api: string | undefined, apiMethod: string | undefined): IOpenapiSdkItem | undefined {
+    if (!api) return;
+    const [api2, apiMethod2] = this.prepareApiMeta(api, apiMethod);
+    return this.sdks[api2]?.[apiMethod2];
+  }
+
+  getSchema(schemaName: string): SchemaObject {
+    return this.schemas[schemaName];
+  }
+
+  async loadBootstrap($fetch: BeanFetch, resource: string): Promise<IOpenapiSdkBootstrap> {
+    if (process.env.CLIENT) {
+      this._fetch = $fetch;
+    }
+    if (!this.bootstraps[resource]) {
+      this.bootstraps[resource] = await $fetch.get(
+        this.sys.util.apiActionPathTranslate(this.scope.config.api.bootstrap, { resource }),
+        this.sys.util.apiActionConfigPrepare(undefined, undefined, false),
+      );
+    }
+    return this.bootstraps[resource];
+  }
+
+  async loadSdk(
+    $fetch: BeanFetch,
+    api?: string,
+    apiMethod?: TypeRequestMethod,
+    apiOptions?: IApiSchemaOptions,
+  ): Promise<IOpenapiSdkItem | undefined> {
+    if (process.env.CLIENT) {
+      this._fetch = $fetch;
+    }
+    if (!api) return;
+    const [api2, apiMethod2] = this.prepareApiMeta(api, apiMethod);
+    if (this.sdks[api2]?.[apiMethod2]) return this.sdks[api2][apiMethod2];
+    // params
+    const params: any[] = [this.sys.util.apiActionPathTranslate(api2)];
+    // body
+    if (!['get', 'delete'].includes(apiMethod2)) {
+      params.push(undefined);
+    }
+    // options
+    const options: IApiActionConfigPrepareOptions = { authToken: apiOptions?.authToken, openapiSchema: true, headers: {} };
+    const localeKey = this.sys.env.APP_LOCALE_HEADER_KEY;
+    if (localeKey) {
+      options.headers![localeKey] = this.locale;
+    }
+    params.push(this.sys.util.apiActionConfigPrepare(undefined, options));
+    const data: IOpenapiSchema = await $fetch[apiMethod2](...params);
+    // schemas
+    const schemaNames: string[] = [];
+    const schemas = data.doc.components?.schemas;
+    if (schemas) {
+      for (const key in schemas) {
+        const schema = schemas[key] as unknown as SchemaObject;
+        if (!schema[SymbolOpenapiSchemaName]) {
+          schema[SymbolOpenapiSchemaName] = key;
+        }
+        this.schemas[key] = schema;
+        schemaNames.push(key);
+      }
+    }
+    // paths
+    const paths = data.doc.paths;
+    if (paths) {
+      for (const key in paths) {
+        // const path = key.replace(PATH_PARAM_RE, ':$1');
+        if (!this.sdks[api2]) this.sdks[api2] = shallowReactive({});
+        for (const method in paths[key]) {
+          this.sdks[api2][method] = {
+            schemas: schemaNames,
+            operationObject: paths[key][method],
+            meta: data.meta,
+          };
+        }
+      }
+    }
+    // ok
+    return this.sdks[api2][apiMethod2];
+  }
+
+  prepareApiMeta(api: string, apiMethod?: string) {
+    return [api, apiMethod ?? 'get'];
+  }
+}

package/src/config/config.ts

@@ -0,0 +1,44 @@
+import type { ZovaSys } from 'zova';
+
+import type { IOpenapiOptionsResourceMeta } from '../types/resourceMeta.js';
+
+export const config = (_sys: ZovaSys) => {
+  return {
+    base: {
+      provider: {
+        components: {
+          form: 'a-form:form',
+          table: 'a-table:table',
+        },
+        actions: {
+          actionLog: 'a-actions:log',
+        },
+      },
+      form: {
+        provider: {
+          components: {
+            formField: 'a-form:formField',
+            text: 'input',
+            password: 'input',
+            currency: 'a-currency:formFieldCurrency',
+          },
+          behaviors: {},
+        },
+      },
+      table: {
+        provider: {
+          components: {
+            currency: 'a-currency.tableCell.currency',
+            date: 'a-date.tableCell.date',
+          },
+          actions: {},
+        },
+      },
+    } as IOpenapiOptionsResourceMeta,
+    resourceMeta: {} as IOpenapiOptionsResourceMeta,
+    api: {
+      bootstrap: '/api/openapischema/resource/bootstrap/:resource',
+      permissions: '/api/home/base/permission/:resource',
+    },
+  };
+};

package/src/index.ts

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

package/src/lib/index.ts

@@ -0,0 +1 @@
+export * from './schema.js';

package/src/lib/schema.ts

@@ -0,0 +1,114 @@
+import type { OperationObject, ParameterObject, RequestBodyObject, SchemaObject } from 'openapi3-ts/oas31';
+
+import jsonSchemaToZod from '@cabloy/json-schema-to-zod';
+import { evaluateSimple } from '@cabloy/utils';
+import { toRaw } from 'vue';
+import { z } from 'zod';
+import { cast, deepExtend } from 'zova';
+
+import type { TypeSchemaScene } from '../types/rest.js';
+
+import { OrderUnknownBase } from '../types/database.js';
+
+const __FilterColumnsIgnore = ['columns', 'where', 'orders', 'pageNo', 'pageSize'];
+
+export function loadSchemaProperties(
+  schema: SchemaObject | undefined,
+  onGetSchema: (schemaName: string) => SchemaObject | undefined,
+  scene?: TypeSchemaScene,
+): SchemaObject[] | undefined {
+  if (!schema) return;
+  const properties = schema.properties!;
+  const result: SchemaObject[] = [];
+  // filter
+  for (let key in properties) {
+    let property = properties[key] as SchemaObject;
+    if (property.$ref) {
+      property = onGetSchema(property.$ref)!;
+    }
+    if (!property) continue;
+    const customKey = property.rest?.customKey;
+    if (customKey) {
+      const parts = customKey.split('.');
+      const propertyParent: any = parts[0] === key ? property : result.find(item => item.key === parts[0]);
+      property = propertyParent?.properties[parts[1]];
+      key = customKey;
+    }
+    if (!property) continue;
+    property = deepExtend({ key }, property, scene ? { rest: property.rest?.[scene] ?? {} } : undefined);
+    result.push(property);
+  }
+  // sort
+  result.sort((a, b) => {
+    return (a.rest?.order ?? OrderUnknownBase) - (b.rest?.order ?? OrderUnknownBase);
+  });
+  // ok
+  return result;
+}
+
+export function schemaToZodSchema<T extends z.ZodType = z.ZodType>(
+  schema: SchemaObject,
+  onGetSchema: (schemaName: string) => SchemaObject | undefined,
+): T {
+  const schemaNormalize = _normalizeSchema(toRaw(schema), onGetSchema);
+  const code = jsonSchemaToZod(schemaNormalize);
+  return evaluateSimple(code, { z });
+}
+
+function _normalizeSchema(schema: SchemaObject, onGetSchema: (schemaName: string) => SchemaObject | undefined) {
+  if (!schema.properties) return schema;
+  const schemaNew = Object.assign({}, schema, { properties: {} });
+  for (const key in schema.properties) {
+    let property = schema.properties[key] as SchemaObject | undefined;
+    if (property?.$ref) {
+      property = onGetSchema(property.$ref);
+    }
+    if (!property) continue;
+    schemaNew.properties[key] = _normalizeSchema(property, onGetSchema);
+  }
+  return schemaNew;
+}
+
+export function getSchemaOfRequestBody(operationObject?: OperationObject): SchemaObject | undefined {
+  return cast<RequestBodyObject>(operationObject?.requestBody)?.content?.['application/json']?.schema as any;
+}
+
+export function getSchemaOfResponseBody(operationObject?: OperationObject): SchemaObject | undefined {
+  return operationObject?.responses?.['200']?.content?.['application/json']?.schema;
+}
+
+export function getSchemaOfRequestQuery(operationObject?: OperationObject): SchemaObject | undefined {
+  const parameters = operationObject?.parameters;
+  if (!parameters) return;
+  const schema: SchemaObject = { type: 'object', required: [], properties: {} };
+  for (const _parameter of parameters) {
+    const parameter = _parameter as ParameterObject;
+    if (parameter.in !== 'query') continue;
+    const name = parameter.name;
+    const fieldSchema = parameter.schema! as SchemaObject;
+    schema.properties![name] = fieldSchema;
+    if (parameter.required) schema.required!.push(name);
+  }
+  return schema;
+}
+
+export function getSchemaOfRequestQueryFilter(operationObject?: OperationObject, options?: { where?: boolean; order?: boolean }) {
+  const parameters = operationObject?.parameters;
+  if (!parameters) return;
+  const schema: SchemaObject = { type: 'object', required: [], properties: {} };
+  for (const _parameter of parameters) {
+    const parameter = _parameter as ParameterObject;
+    if (parameter.in !== 'query') continue;
+    const name = parameter.name;
+    if (__FilterColumnsIgnore.includes(name)) continue;
+    const fieldSchema = parameter.schema! as SchemaObject;
+    if (
+      (options?.where === true && fieldSchema.filter?.capabilities?.where !== false) ||
+      (options?.order === true && fieldSchema.filter?.capabilities?.order !== false)
+    ) {
+      schema.properties![name] = fieldSchema;
+      if (parameter.required) schema.required!.push(name);
+    }
+  }
+  return schema;
+}

package/src/model/sdk.ts

@@ -0,0 +1,226 @@
+import { isNil } from '@cabloy/utils';
+import { SchemaObject } from 'openapi3-ts/oas31';
+import z from 'zod';
+import { cast, ILocaleRecord, TypeEventOff, Use, usePrepareArg } from 'zova';
+import { IApiSchemaOptions } from 'zova-module-a-api';
+import { $QueryAutoLoad, BeanModelBase, IDecoratorModelOptions, Model } from 'zova-module-a-model';
+
+import { SysSdk } from '../bean/sys.sdk.js';
+import {
+  getSchemaOfRequestBody,
+  getSchemaOfRequestQuery,
+  getSchemaOfRequestQueryFilter,
+  getSchemaOfResponseBody,
+  loadSchemaProperties,
+  schemaToZodSchema,
+} from '../lib/schema.js';
+import { TypeOpenapiPermissions } from '../types/resourceMeta.js';
+import { TypeSchemaScene } from '../types/rest.js';
+import { IOpenapiSchemas, TypeOpenapiSchemasSdk } from '../types/schema.js';
+import { TypeRequestMethod } from '../types/sdk.js';
+
+const __schemaRefPrefix = '#/components/schemas/';
+
+export interface IModelOptionsSdk extends IDecoratorModelOptions {}
+
+@Model<IModelOptionsSdk>({
+  enableSelector: true,
+})
+export class ModelSdk extends BeanModelBase {
+  private _eventSsrHmrReload: TypeEventOff;
+
+  @Use({ beanFullName: 'a-openapi.sys.sdk' })
+  get $$sysSdk(): SysSdk {
+    return usePrepareArg(this.selector, true);
+  }
+
+  protected async __init__(locale: keyof ILocaleRecord) {
+    if (!locale) throw new Error('locale not specified');
+    await super.__init__(locale);
+    // event
+    if (process.env.CLIENT && this.sys.env.SSR_HMR === 'true') {
+      this._eventSsrHmrReload = this.sys.meta.event.on('a-ssrhmr:reload', async (_data, next) => {
+        await this.$refetchQueries({ queryKey: ['bootstrap'] });
+        await this.$refetchQueries({ queryKey: ['sdk'] });
+        return next();
+      });
+    }
+  }
+
+  protected __dispose__() {
+    if (this._eventSsrHmrReload) {
+      this._eventSsrHmrReload();
+    }
+  }
+
+  getBootstrap(resource: string) {
+    return this.$useStateData({
+      queryKey: ['bootstrap', resource],
+      queryFn: async () => {
+        const bootstrap = await this.$$sysSdk.loadBootstrap(this.$fetch, resource);
+        if (!bootstrap) throw new Error('load bootstrap error');
+        if (process.env.SERVER) {
+          await $QueryAutoLoad(() => this.getPermissions(resource));
+        } else {
+          await this.$refetchQueries({ queryKey: ['permissions', resource] });
+        }
+        return bootstrap ?? null;
+      },
+    });
+  }
+
+  getPermissions(resource: string) {
+    return this.$useStateData({
+      queryKey: ['permissions', resource],
+      queryFn: async () => {
+        // should not use this.getBootstrap(resource);
+        const bootstrap = await this.$$sysSdk.loadBootstrap(this.$fetch, resource);
+        let permissions = bootstrap.resourceMeta.permissions;
+        if (!isNil(permissions)) return permissions;
+        permissions = (await this.$fetch.get(
+          this.sys.util.apiActionPathTranslate(this.scope.config.api.permissions, { resource }),
+          this.sys.util.apiActionConfigPrepare(),
+        )) as TypeOpenapiPermissions;
+        return permissions ?? null;
+      },
+    });
+  }
+
+  getSdk(api: string, apiMethod?: TypeRequestMethod, apiOptions?: IApiSchemaOptions): TypeOpenapiSchemasSdk {
+    if (!api) throw new Error('should specify api');
+    const [api2, apiMethod2] = this.$$sysSdk.prepareApiMeta(api, apiMethod);
+    return this.$useStateData({
+      queryKey: ['sdk', api2, apiMethod2],
+      queryFn: async () => {
+        const sdk = await this.$$sysSdk.loadSdk(this.$fetch, api, apiMethod, apiOptions);
+        if (!sdk) throw new Error('load sdk error');
+        for (const schemaName of sdk.schemas) {
+          if (process.env.SERVER) {
+            await $QueryAutoLoad(() => this.getSchema(schemaName));
+          } else {
+            await this.$refetchQueries({ queryKey: ['schema', schemaName] });
+          }
+        }
+        return sdk;
+      },
+    }) as TypeOpenapiSchemasSdk;
+  }
+
+  getSchema(schemaName: string) {
+    if (schemaName.startsWith(__schemaRefPrefix)) {
+      schemaName = schemaName.substring(__schemaRefPrefix.length);
+    }
+    return this.$useStateData({
+      queryKey: ['schema', schemaName],
+      queryFn: async () => {
+        const schema = this.$$sysSdk.getSchema(schemaName);
+        return schema ?? null;
+      },
+    });
+  }
+
+  getZodSchema(schemaName: string) {
+    return this.$useStateComputed({
+      queryKey: ['zodSchema', schemaName],
+      queryFn: () => {
+        const querySchema = this.getSchema(schemaName);
+        if (!querySchema.data) return null;
+        const zodSchema = this.schemaToZodSchema(querySchema.data);
+        return zodSchema;
+      },
+    });
+  }
+
+  getSchemaDefaultValue(schemaName: string) {
+    return this.$useStateComputed({
+      queryKey: ['schemaDefaultValue', schemaName],
+      queryFn: () => {
+        const querySchema = this.getSchema(schemaName);
+        if (!querySchema.data) return null;
+        const schema = querySchema.data;
+        // const schema = this.$$sysSdk.getSchema(schemaName);
+        // if (!schema) return null;
+        const defaultValues = {};
+        for (const key in schema.properties) {
+          const property = schema.properties[key] as any;
+          if (!isNil(property.default)) {
+            defaultValues[key] = property.default;
+          }
+        }
+        return defaultValues;
+      },
+    });
+  }
+
+  public createApiSchemas(api: string, apiMethod?: TypeRequestMethod, apiOptions?: IApiSchemaOptions): IOpenapiSchemas {
+    const self = this;
+    const sdk = this.getSdk(api, apiMethod, apiOptions);
+    return {
+      get sdk() {
+        return sdk;
+      },
+      get query() {
+        const operationObject = sdk.data?.operationObject;
+        return getSchemaOfRequestQuery(operationObject);
+      },
+      get filter() {
+        const operationObject = sdk.data?.operationObject;
+        return getSchemaOfRequestQueryFilter(operationObject, { where: true });
+      },
+      get requestBody() {
+        const operationObject = sdk.data?.operationObject;
+        const schemaBody = getSchemaOfRequestBody(operationObject);
+        const schemaName = cast(schemaBody)?.$ref;
+        if (!schemaName) return;
+        return self.getSchema(schemaName).data;
+      },
+      get responseBody() {
+        const operationObject = sdk.data?.operationObject;
+        const schemaBody = getSchemaOfResponseBody(operationObject);
+        const schemaName = cast(schemaBody?.properties?.data)?.$ref;
+        if (!schemaName) return;
+        return self.getSchema(schemaName).data;
+      },
+      get paged() {
+        const operationObject = sdk.data?.operationObject;
+        const schemaBody = getSchemaOfResponseBody(operationObject);
+        if (!schemaBody) return;
+        const schemaName = cast(schemaBody?.properties?.data)?.items?.$ref;
+        if (schemaName) return;
+        // pages
+        return this.responseBody;
+      },
+      get row() {
+        const operationObject = sdk.data?.operationObject;
+        const schemaBody = getSchemaOfResponseBody(operationObject);
+        if (!schemaBody) return;
+        // schemaData
+        let schemaData;
+        if (schemaBody?.properties?.data.$ref) {
+          schemaData = self.getSchema(schemaBody?.properties?.data.$ref).data;
+        } else {
+          schemaData = schemaBody?.properties?.data;
+        }
+        // entry
+        const schemaName = cast(schemaData)?.items?.$ref;
+        if (schemaName) {
+          return self.getSchema(schemaName).data;
+        }
+        // pages
+        const schemaRow = cast(schemaData?.properties?.list)?.items;
+        if (schemaRow?.$ref) {
+          return self.getSchema(schemaRow?.$ref).data;
+        }
+        return schemaRow;
+      },
+    };
+  }
+
+  public loadSchemaProperties(schema: SchemaObject | undefined, scene?: TypeSchemaScene): SchemaObject[] | undefined {
+    return loadSchemaProperties(schema, schemaName => this.getSchema(schemaName).data, scene);
+  }
+
+  public schemaToZodSchema<T extends z.ZodType = z.ZodType>(schema: SchemaObject): T {
+    return schemaToZodSchema(schema, schemaName => this.getSchema(schemaName).data);
+  }
+}