vona-module-a-openapiutils 5.0.17 → 5.1.1

package/src/lib/schema/v.ts

@@ -0,0 +1,88 @@
+import { schemaComponent } from './v/component.ts';
+import { schemaFilter, schemaFilterDateRange, schemaFilterTransform } from './v/filter.tsx';
+import {
+  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 { schemaCustomKey, schemaOrder, schemaRender, schemaRest, schemaVisible } from './v/rest.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 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,
+  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,
+  // rest
+  rest: schemaRest,
+  customKey: schemaCustomKey,
+  order: schemaOrder,
+  render: schemaRender,
+  visible: schemaVisible,
+  // component
+  component: schemaComponent,
+  // zod
+  refine: schemaZodRefine,
+  transform: schemaZodTransform,
+};

package/src/lib/utils.ts

@@ -0,0 +1,100 @@
+import type { Constructable, ILocaleMagic } from 'vona';
+import type { TypeOpenapiMetadata } from 'vona-module-a-openapi';
+
+import { isClass, isEmptyObject } from '@cabloy/utils';
+import { ZodMetadata } from '@cabloy/zod-openapi';
+import { appMetadata, appResource, cast, deepExtend, registerMappedClassMetadataKey } from 'vona';
+import { z } from 'zod';
+
+import type { TypeDecoratorRules } from '../types/decorator.ts';
+import type { TypeSchemaOrderLevel } from '../types/order.ts';
+
+import { OrderLevelBaseMap } from './const/database.ts';
+import { SymbolDecoratorRule } from './const/decorator.ts';
+
+export function getTargetDecoratorRules(target: object, disableRegisterMetadata?: boolean): TypeDecoratorRules {
+  if (!disableRegisterMetadata) {
+    registerMappedClassMetadataKey(target, SymbolDecoratorRule, {
+      partialClass: (meta: z.ZodType) => {
+        return meta.optional();
+      },
+    });
+  }
+  return appMetadata.getOwnMetadataMap(true, SymbolDecoratorRule, target);
+}
+
+export function getTargetDecoratorRuleColumns(target: object): string[] {
+  const rules = getTargetDecoratorRules(target, true);
+  return Object.keys(rules);
+}
+
+export function getTargetDecoratorRuleColumnsMap(target: object): Record<string, string> {
+  const columns = getTargetDecoratorRuleColumns(target);
+  const map = {};
+  for (const column of columns) {
+    map[column] = column;
+  }
+  return map;
+}
+
+export function mergeFieldsOpenapiMetadata(target: Constructable) {
+  // beanOptions
+  const beanOptions = appResource.getBean(target);
+  const fields = cast(beanOptions?.options)?.fields;
+  if (!fields) return;
+  for (const key in fields) {
+    const field: TypeOpenapiMetadata | z.ZodType = fields[key];
+    if (!field) continue;
+    mergeFieldOpenapiMetadata(target.prototype, key, field);
+  }
+}
+
+// fieldRule maybe undefined
+export function mergeFieldOpenapiMetadata(target: object, prop: string, fieldRule?: TypeOpenapiMetadata | z.ZodType): TypeDecoratorRules {
+  // 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: z.ZodType = fieldRule as any;
+    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 as any);
+      }
+    }
+  }
+  return rules;
+}
+
+export function prepareClassType<T>(classType: (() => Constructable<T>) | Constructable<T>): Constructable<T> {
+  return isClass(classType) ? (classType as Constructable<T>) : cast(classType)();
+}
+
+export function normalizeErrorParams(params?: string | ILocaleMagic | any, errorDefault?: any) {
+  const params2 = params as any;
+  if (!params2) return errorDefault;
+  if (params2.toJSON) {
+    return { error: () => params2 };
+  }
+  return z.util.normalizeParams(params2);
+}
+
+export function $order(order: number, level?: TypeSchemaOrderLevel) {
+  const levelBase = OrderLevelBaseMap[level ?? 'business'];
+  return levelBase + order;
+}

package/src/lib/web.ts

@@ -0,0 +1,11 @@
+import type { IApiPathRecord } from 'vona-module-a-web';
+
+import { combineParamsAndQuery } from '@cabloy/utils';
+
+export function $apiPath<K extends keyof IApiPathRecord>(path: K): K {
+  return path;
+}
+
+export function $apiPathAndCombineParamsAndQuery<K extends keyof IApiPathRecord>(path: K, options?: { params?: object; query?: object }): string {
+  return combineParamsAndQuery(path, options);
+}

package/src/types/api.ts

@@ -0,0 +1,99 @@
+import type { OpenAPIObject as OpenAPIObject30, SchemaObject as SchemaObject30 } from 'openapi3-ts/oas30';
+import type { OpenAPIObject as OpenAPIObject31, SchemaObject as SchemaObject31 } from 'openapi3-ts/oas31';
+import type { ILocaleMagic, VonaApplication } from 'vona';
+import type z from 'zod';
+
+import type { SchemaLikeCreate } from './decorator.ts';
+
+export interface IOpenapiHeader {
+  name: string;
+  description?: string;
+}
+
+export interface IResponseHeaders {
+  [key: string]: string | string[];
+}
+
+export type TypeGenerateJsonScene = 'api' | 'rest';
+
+export type TypeOpenApiVersion = 'V30' | 'V31';
+export interface IOpenapiObject {
+  V30: OpenAPIObject30;
+  V31: OpenAPIObject31;
+}
+export interface IOpenapiSchemaObject {
+  V30: SchemaObject30;
+  V31: SchemaObject31;
+}
+
+export type TypeSecuritySchemes = Record<string, ((this: VonaApplication) => object) | object>;
+
+export interface IOpenapiOptions {
+  public?: boolean;
+  description?: string | ILocaleMagic;
+  summary?: string | ILocaleMagic;
+  httpCode?: number;
+  contentType?: TypeResponseContentType;
+  bodySchema?: z.ZodType;
+  bodySchemaWrapper?: SchemaLikeCreate | false;
+  exclude?: boolean;
+  tags?: string[];
+  operationId?: string;
+  headers?: IOpenapiHeader[];
+  setHeaders?: IResponseHeaders;
+}
+
+export type TypeResponseContentType =
+  | 'application/json'
+  | 'application/xml'
+  | 'application/x-www-form-urlencoded'
+  | 'multipart/form-data'
+  | 'text/plain'
+  | 'text/html'
+  | 'application/octet-stream'
+  | 'application/pdf'
+  | 'image/png'
+  | 'image/jpeg'
+  | 'image/gif'
+  | 'image/webp'
+  | 'image/svg+xml'
+  | 'image/bmp'
+  | 'image/tiff'
+  | 'image/vnd.microsoft.icon'
+  | 'image/vnd.wap.wbmp'
+  | 'image/x-icon'
+  | 'image/x-jng'
+  | 'image/x-ms-bmp'
+  | 'image/x-portable-bitmap'
+  | 'image/x-portable-graymap'
+  | 'image/x-portable-pixmap'
+  | 'image/x-xbitmap'
+  | 'image/x-xpixmap'
+  | 'image/x-xwindowdump'
+  | 'image/bmp'
+  | 'image/x-bmp'
+  | 'image/x-xbitmap'
+  | 'image/x-win-bitmap'
+  | 'image/x-windows-bmp'
+  | 'image/ms-bmp'
+  | 'image/x-ms-bmp'
+  | 'image/x-icon'
+  | 'image/x-ico'
+  | 'image/vnd.microsoft.icon'
+  | 'image/ico'
+  | 'image/icon'
+  | 'text/css'
+  | 'text/csv'
+  | 'text/html'
+  | 'text/javascript'
+  | 'text/plain'
+  | 'text/xml'
+  | 'application/javascript'
+  | 'application/ecmascript'
+  | 'application/json'
+  | 'application/ld+json'
+  | 'application/manifest+json'
+  | 'application/javascript'
+  | 'application/x-javascript'
+  | 'application/x-json'
+  | 'application/x-ms-application';

package/src/types/component.ts

@@ -0,0 +1,19 @@
+import type { CurrencyOptions } from '@zhennann/currency';
+import type {
+  ICaptchaOptions,
+  IResourcePickerOptions,
+  ISelectOptions,
+  ITextareaOptions,
+  IToggleOptions,
+  TypeDateFormat,
+} from 'vona-module-a-openapi';
+
+export interface ISchemaComponentRecord {
+  currency: CurrencyOptions;
+  date: TypeDateFormat;
+  captcha: ICaptchaOptions;
+  toggle: IToggleOptions;
+  select: ISelectOptions;
+  resourcePicker: IResourcePickerOptions;
+  textarea: ITextareaOptions;
+}

package/src/types/decorator.ts

@@ -0,0 +1,7 @@
+import type { Constructable } from 'vona';
+import type z from 'zod';
+
+export type SchemaLikeCreate = (schema: any) => any; // not use z.ZodType
+export type SchemaLike<T = unknown> = SchemaLikeCreate | z.ZodType<T> | Constructable;
+
+export type TypeDecoratorRules = Record<string, z.ZodType | undefined>;

package/src/types/index.ts

@@ -0,0 +1,4 @@
+export * from './api.ts';
+export * from './component.ts';
+export * from './decorator.ts';
+export * from './order.ts';

package/src/types/order.ts

@@ -0,0 +1,9 @@
+import type { TypeSchemaScene } from 'vona-module-a-openapi';
+
+export type TypeSchemaOrderLevel = 'core' | 'business' | 'max';
+
+export interface ISchemaOrderParams {
+  order: number;
+  level?: TypeSchemaOrderLevel;
+  scene?: TypeSchemaScene;
+}