vona-module-a-openapiutils 5.0.16 → 5.1.1

package/src/lib/schema/makeSchemaLikes.ts

@@ -0,0 +1,107 @@
+import type { Constructable } from 'vona';
+import type { ISchemaObjectOptions, TypeOpenapiMetadata } from 'vona-module-a-openapi';
+
+import { isClass } from '@cabloy/utils';
+import { appMetadata, appResource, cast } from 'vona';
+import { z } from 'zod';
+
+import type { SchemaLike, SchemaLikeCreate } from '../../types/decorator.ts';
+
+import { SymbolDecoratorRule } from '../const/decorator.ts';
+import { prepareClassType } from '../utils.ts';
+import { SymbolSchemaDynamicRefId } from './schemaDynamic.ts';
+
+export function $makeSchema<T>(...schemaLikes: SchemaLike<T>[]): z.ZodType<T> {
+  return makeSchemaLikes(schemaLikes, undefined);
+}
+
+export function makeSchemaLikes<T>(schemaLikes: SchemaLike<T> | SchemaLike<T>[], typeInit: any): z.ZodType<T> {
+  if (!Array.isArray(schemaLikes)) schemaLikes = [schemaLikes];
+  // default schema
+  let argSchema: z.ZodType<T> = $schema(typeInit);
+  // loop
+  for (let index = schemaLikes.length - 1; index >= 0; index--) {
+    const schemaLike = schemaLikes[index];
+    argSchema = makeSchemaLike(schemaLike, argSchema);
+  }
+  return argSchema;
+}
+
+export function makeSchemaLike<T>(schemaLike: SchemaLike<T> | undefined, schemaPrevious: z.ZodType<T>): z.ZodType<T> {
+  if (!schemaLike) return schemaPrevious;
+  if (Object.prototype.hasOwnProperty.call(schemaLike, 'parseAsync')) {
+    // schema
+    return schemaLike as z.ZodType<T>;
+  } else if (isClass(schemaLike) || ['String', 'Number', 'Boolean', 'Date', 'BigInt', 'Array'].includes(cast<Function>(schemaLike).name)) {
+    // class
+    return $schema(cast<Constructable>(schemaLike)) as z.ZodType<T>;
+  } else {
+    // function
+    return cast<SchemaLikeCreate>(schemaLike)(schemaPrevious);
+  }
+}
+
+export function $schema<T>(schemaLike: z.ZodType<T>): z.ZodType<T>;
+export function $schema(classType: StringConstructor): z.ZodString;
+export function $schema(classType: NumberConstructor): z.ZodNumber;
+export function $schema(classType: BooleanConstructor): z.ZodBoolean;
+export function $schema(classType: DateConstructor): z.ZodDate;
+export function $schema(classType: BigIntConstructor): z.ZodBigInt;
+export function $schema(classType: ArrayConstructor): z.ZodArray<z.ZodAny>;
+export function $schema<T>(classType: Constructable<T>, options?: ISchemaObjectOptions): z.ZodType<T>;
+export function $schema(classType: any, options?: ISchemaObjectOptions): any {
+  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 = _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 pipes: SchemaLike | SchemaLike[] = cast(beanOptions.options)?.pipes;
+      if (pipes) {
+        schema = makeSchemaLikes(pipes, schema) as any;
+      }
+      const openapi: TypeOpenapiMetadata = cast(beanOptions.options)?.openapi;
+      schema = schema.openapi(beanOptions.beanFullName, openapi);
+    }
+  }
+  return schema as any;
+}
+
+export function $schemaLazy<T>(...schemaLikes: SchemaLike<T>[]): z.ZodType<T> {
+  return z.lazy(() => {
+    return _createSchemaLazy(schemaLikes);
+  });
+}
+
+function _createSchemaLazy<T>(schemaLikes: SchemaLike<T>[]): z.ZodType<T> {
+  const classType = schemaLikes[schemaLikes.length - 1];
+  schemaLikes = schemaLikes.slice(0, schemaLikes.length - 1);
+  const classType2 = prepareClassType(classType as any);
+  return makeSchemaLikes(schemaLikes, $schema(classType2));
+}
+
+function _createSchemaObject(rules: {}, options?: ISchemaObjectOptions) {
+  let schema = z.object(rules as z.ZodRawShape);
+  if (options?.loose) schema = z.looseObject(schema.shape) as any;
+  if (options?.strict) schema = z.strictObject(schema.shape) as any;
+  return schema;
+}

package/src/lib/schema/schemaDynamic.ts

@@ -0,0 +1,17 @@
+import type { Constructable } from 'vona';
+
+const __schemasDynamic: Record<string, Constructable> = {};
+
+export const SymbolSchemaDynamicRefId = Symbol('SymbolSchemaDynamicRefId');
+
+export function addSchemaDynamic(dynamicName: string, classType: Constructable) {
+  __schemasDynamic[dynamicName] = classType;
+}
+
+export function getSchemaDynamic(dynamicName: string) {
+  return __schemasDynamic[dynamicName];
+}
+
+export function getSchemasDynamic() {
+  return __schemasDynamic;
+}

package/src/lib/schema/v/component.ts

@@ -0,0 +1,78 @@
+import type { CurrencyOptions } from '@zhennann/currency';
+import type {
+  ICaptchaOptions,
+  IResourcePickerOptions,
+  ISelectOptions,
+  ITextareaOptions,
+  IToggleOptions,
+  TypeDateFormat,
+  TypeSchemaScene,
+} from 'vona-module-a-openapi';
+import type z from 'zod';
+
+import type { ISchemaComponentRecord } from '../../../types/component.ts';
+
+import { _generalSchemaRest } from './utils.ts';
+
+const __schemaComponents = {
+  currency: schemaCurrency,
+  date: schemaDate,
+  captcha: schemaCaptcha,
+  toggle: schemaToggle,
+  select: schemaSelect,
+  resourcePicker: schemaResourcePicker,
+  textarea: schemaTextarea,
+} as const;
+
+export function schemaComponent<K extends keyof ISchemaComponentRecord>(name: K, options?: ISchemaComponentRecord[K], scene?: TypeSchemaScene) {
+  return __schemaComponents[name](options as any, scene);
+}
+
+function schemaCurrency<T extends z.ZodType>(currency?: CurrencyOptions, scene?: TypeSchemaScene) {
+  return function (schema: T): T {
+    const options = currency !== undefined ? { render: 'currency', currency } : { render: 'currency' };
+    return _generalSchemaRest(schema, options, scene);
+  };
+}
+
+function schemaDate<T extends z.ZodType>(dateFormat?: TypeDateFormat, scene?: TypeSchemaScene) {
+  return function (schema: T): T {
+    const options = dateFormat !== undefined ? { render: 'date', dateFormat } : { render: 'date' };
+    return _generalSchemaRest(schema, options, scene);
+  };
+}
+
+function schemaCaptcha<T extends z.ZodType>(captcha?: ICaptchaOptions, scene?: TypeSchemaScene) {
+  return function (schema: T): T {
+    const options = captcha !== undefined ? { render: 'captcha', captcha } : { render: 'captcha' };
+    return _generalSchemaRest(schema, options, scene);
+  };
+}
+
+function schemaToggle<T extends z.ZodType>(toggle?: IToggleOptions, scene?: TypeSchemaScene) {
+  return function (schema: T): T {
+    const options = toggle !== undefined ? { render: 'toggle', toggle } : { render: 'toggle' };
+    return _generalSchemaRest(schema, options, scene);
+  };
+}
+
+function schemaSelect<T extends z.ZodType>(select?: ISelectOptions, scene?: TypeSchemaScene) {
+  return function (schema: T): T {
+    const options = select !== undefined ? { render: 'select', select } : { render: 'select' };
+    return _generalSchemaRest(schema, options, scene);
+  };
+}
+
+function schemaResourcePicker<T extends z.ZodType>(resourcePicker?: IResourcePickerOptions, scene?: TypeSchemaScene) {
+  return function (schema: T): T {
+    const options = resourcePicker !== undefined ? { render: 'resourcePicker', resourcePicker } : { render: 'resourcePicker' };
+    return _generalSchemaRest(schema, options, scene);
+  };
+}
+
+function schemaTextarea<T extends z.ZodType>(textarea?: ITextareaOptions, scene?: TypeSchemaScene) {
+  return function (schema: T): T {
+    const options = textarea !== undefined ? { render: 'textarea', textarea } : { render: 'textarea' };
+    return _generalSchemaRest(schema, options, scene);
+  };
+}

package/src/lib/schema/v/filter.tsx

@@ -0,0 +1,40 @@
+import type { IFilterTransformOptionsDateRange, IFilterTransformRecord, ISchemaObjectExtensionFieldFilter } from 'vona-module-a-web';
+import type z from 'zod';
+
+import React from 'react';
+
+export function schemaFilter(options: ISchemaObjectExtensionFieldFilter) {
+  return function (schema: z.ZodType): z.ZodType {
+    return schema.openapi({
+      filter: options,
+    });
+  };
+}
+
+export function schemaFilterTransform<T extends keyof IFilterTransformRecord>(filterTransformName: T, options?: Partial<IFilterTransformRecord[T]>) {
+  return function (schema: z.ZodType): z.ZodType {
+    return schema.openapi({
+      filter: {
+        transform: [filterTransformName, options],
+      },
+    });
+  };
+}
+
+export function schemaFilterDateRange(options?: Partial<IFilterTransformOptionsDateRange>) {
+  const separator = options?.separator;
+  const DateRange = 'dateRange' as any;
+  const filterRender = separator ? <DateRange separator={separator}></DateRange> : 'dateRange';
+  return function (schema: z.ZodType): z.ZodType {
+    return schema.openapi({
+      filter: {
+        transform: ['a-web:dateRange', options],
+      },
+      rest: {
+        filter: {
+          render: filterRender,
+        },
+      },
+    });
+  };
+}

package/src/lib/schema/v/helpers.ts

@@ -0,0 +1,110 @@
+import type { ILocaleMagic } from 'vona';
+
+import { useApp } from 'vona';
+import { z } from 'zod';
+
+import { normalizeErrorParams } from '../../utils.ts';
+
+export function schemaEmail(params?: string | ILocaleMagic | z.core.$ZodEmailParams) {
+  return function (_schema: z.ZodString): z.ZodEmail {
+    return z.email(normalizeErrorParams(params));
+  };
+}
+
+export function schemaUrl(params?: string | ILocaleMagic | z.core.$ZodURLParams) {
+  return function (_schema: z.ZodString): z.ZodURL {
+    return z.url(normalizeErrorParams(params));
+  };
+}
+
+export function schemaUuid(params?: string | ILocaleMagic | z.core.$ZodUUIDParams) {
+  return function (_schema: z.ZodString): z.ZodUUID {
+    return z.uuid(normalizeErrorParams(params));
+  };
+}
+
+export function schemaIPv4(params?: string | ILocaleMagic | z.core.$ZodIPv4Params) {
+  return function (_schema: z.ZodString): z.ZodIPv4 {
+    return z.ipv4(normalizeErrorParams(params));
+  };
+}
+
+export function schemaIPv6(params?: string | ILocaleMagic | z.core.$ZodIPv6Params) {
+  return function (_schema: z.ZodString): z.ZodIPv6 {
+    return z.ipv6(normalizeErrorParams(params));
+  };
+}
+
+export function schemaMin(min: number, params?: string | ILocaleMagic | z.core.$ZodCheckMinLengthParams | z.core.$ZodCheckGreaterThanParams) {
+  return function (schema: z.ZodString | z.ZodNumber): z.ZodString | z.ZodNumber {
+    if (schema.type === 'string') {
+      return schema.min(min, normalizeErrorParams(params) as string | z.core.$ZodCheckMinLengthParams);
+    } else {
+      return schema.min(min, normalizeErrorParams(params) as string | z.core.$ZodCheckGreaterThanParams);
+    }
+  };
+}
+
+export function schemaMax(max: number, params?: string | ILocaleMagic | z.core.$ZodCheckMaxLengthParams | z.core.$ZodCheckLessThanParams) {
+  return function (schema: z.ZodString | z.ZodNumber): z.ZodString | z.ZodNumber {
+    if (schema.type === 'string') {
+      return schema.max(max, normalizeErrorParams(params) as string | z.core.$ZodCheckMaxLengthParams);
+    } else {
+      return schema.max(max, normalizeErrorParams(params) as string | z.core.$ZodCheckLessThanParams);
+    }
+  };
+}
+
+export function schemaTrim() {
+  return function (schema: z.ZodString): z.ZodString {
+    return schema.trim();
+  };
+}
+
+export function schemaToLowerCase() {
+  return function (schema: z.ZodString): z.ZodString {
+    return schema.toLowerCase();
+  };
+}
+
+export function schemaToUpperCase() {
+  return function (schema: z.ZodString): z.ZodString {
+    return schema.toUpperCase();
+  };
+}
+
+export function schemaLowercase(params?: string | ILocaleMagic | z.core.$ZodCheckLowerCaseParams) {
+  return function (schema: z.ZodString): z.ZodString {
+    return schema.lowercase(normalizeErrorParams(params));
+  };
+}
+
+export function schemaUppercase(params?: string | ILocaleMagic | z.core.$ZodCheckUpperCaseParams) {
+  return function (schema: z.ZodString): z.ZodString {
+    return schema.uppercase(normalizeErrorParams(params));
+  };
+}
+
+export function schemaRegex(regex: RegExp, params?: string | ILocaleMagic | z.core.$ZodCheckRegexParams) {
+  return function (schema: z.ZodString): z.ZodString {
+    return schema.regex(regex, normalizeErrorParams(params));
+  };
+}
+
+export function schemaTableIdentity() {
+  return function (_schema?: any): z.ZodType {
+    const schema = z.union([z.number(), z.string()]);
+    return schema.transform(value => {
+      const app = useApp();
+      const ormConfig = app.util.getModuleConfigRaw('a-orm');
+      const _identityType = ormConfig?.table?.identityType ?? 'bigint';
+      if (_identityType === 'number') {
+        return Number.parseInt(value as any);
+      } else if (_identityType === 'bigint') {
+        return String(value);
+      } else {
+        throw new Error('not support');
+      }
+    });
+  };
+}

package/src/lib/schema/v/openapi.ts

@@ -0,0 +1,29 @@
+import type { ILocaleMagic } from 'vona';
+import type { TypeOpenapiMetadata } from 'vona-module-a-openapi';
+import type { z } from 'zod';
+
+export function schemaOpenapi<T extends z.ZodType>(metadata: TypeOpenapiMetadata<T>): T;
+export function schemaOpenapi<T extends z.ZodType>(refId: string, metadata?: TypeOpenapiMetadata<T>): T;
+export function schemaOpenapi<T extends z.ZodType>(refId: any, metadata?: any) {
+  return function (schema: T): T {
+    return schema.openapi(refId, metadata);
+  };
+}
+
+export function schemaTitle<T extends z.ZodType>(title?: string | ILocaleMagic) {
+  return function (schema: T): T {
+    return schema.openapi({ title });
+  };
+}
+
+export function schemaDescription<T extends z.ZodType>(description?: string | ILocaleMagic) {
+  return function (schema: T): T {
+    return schema.openapi({ description });
+  };
+}
+
+export function schemaExample<T extends z.ZodType>(example?: any) {
+  return function (schema: T): T {
+    return schema.openapi({ example });
+  };
+}

package/src/lib/schema/v/rest.ts

@@ -0,0 +1,50 @@
+import type {
+  ISchemaObjectExtensionFieldRest,
+  ISchemaObjectExtensionFieldRestScene,
+  TypeRenderComponent,
+  TypeSchemaScene,
+} from 'vona-module-a-openapi';
+import type z from 'zod';
+
+import type { TypeSchemaOrderLevel } from '../../../types/order.ts';
+
+import { $order } from '../../utils.ts';
+import { _generalSchemaRest } from './utils.ts';
+
+export function schemaRest<T extends z.ZodType>(
+  rest?: ISchemaObjectExtensionFieldRestScene | ISchemaObjectExtensionFieldRest,
+  scene?: TypeSchemaScene,
+) {
+  return function (schema: T): T {
+    return _generalSchemaRest(schema, rest, scene);
+  };
+}
+
+export function schemaCustomKey<T extends z.ZodType>(customKey: string, scene?: TypeSchemaScene) {
+  return function (schema: T): T {
+    const options = { customKey };
+    return _generalSchemaRest(schema, options, scene);
+  };
+}
+
+export function schemaOrder<T extends z.ZodType>(order: number, level?: TypeSchemaOrderLevel, scene?: TypeSchemaScene) {
+  const orderReal = $order(order, level);
+  return function (schema: T): T {
+    const options = { order: orderReal };
+    return _generalSchemaRest(schema, options, scene);
+  };
+}
+
+export function schemaRender<T extends z.ZodType>(render: TypeRenderComponent, scene?: TypeSchemaScene) {
+  return function (schema: T): T {
+    const options = { render };
+    return _generalSchemaRest(schema, options, scene);
+  };
+}
+
+export function schemaVisible<T extends z.ZodType>(visible?: boolean, scene?: TypeSchemaScene) {
+  return function (schema: T): T {
+    const options = { visible };
+    return _generalSchemaRest(schema, options, scene);
+  };
+}

package/src/lib/schema/v/serializer.ts

@@ -0,0 +1,86 @@
+import type {
+  ISerializerTransformOptionsCustom,
+  ISerializerTransformOptionsExclude,
+  ISerializerTransformOptionsGetter,
+  ISerializerTransformRecord,
+  TypeSerializerTransformCustom,
+  TypeSerializerTransformGetter,
+} from 'vona-module-a-serialization';
+import type z from 'zod';
+
+export function schemaSerializerTransform<T extends keyof ISerializerTransformRecord>(
+  serializerTransformName: T,
+  options?: Partial<ISerializerTransformRecord[T]>,
+) {
+  return function (schema: z.ZodType): z.ZodType {
+    return schema.openapi({
+      serializerTransforms: {
+        [serializerTransformName]: options,
+      },
+    });
+  };
+}
+
+export function schemaSerializerExclude(options: Partial<ISerializerTransformOptionsExclude>);
+export function schemaSerializerExclude(exclude?: boolean);
+export function schemaSerializerExclude(param?: boolean | Partial<ISerializerTransformOptionsExclude>) {
+  let options: Partial<ISerializerTransformOptionsExclude>;
+  if (!param || typeof param === 'boolean') {
+    options = { exclude: param };
+  } else {
+    options = param;
+  }
+  return function (schema: z.ZodType): z.ZodType {
+    return schema.openapi({
+      serializerTransforms: {
+        'a-serialization:exclude': options,
+      },
+    });
+  };
+}
+
+export function schemaSerializerReplace(options: ISerializerTransformRecord['a-serialization:replace']) {
+  return function (schema: z.ZodType): z.ZodType {
+    return schema.openapi({
+      serializerTransforms: {
+        'a-serialization:replace': options,
+      },
+    });
+  };
+}
+
+export function schemaSerializerGetter(options: Partial<ISerializerTransformOptionsGetter>);
+export function schemaSerializerGetter(getter: TypeSerializerTransformGetter);
+export function schemaSerializerGetter(param: TypeSerializerTransformGetter | Partial<ISerializerTransformOptionsGetter>) {
+  let options: Partial<ISerializerTransformOptionsGetter>;
+  if (typeof param === 'function') {
+    options = { getter: param };
+  } else {
+    options = param;
+  }
+  return function (schema: z.ZodType): z.ZodType {
+    return schema.openapi({
+      serializerTransforms: {
+        'a-serialization:getter': options,
+      },
+    });
+  };
+}
+
+export function schemaSerializerCustom(options: Partial<ISerializerTransformOptionsCustom>);
+export function schemaSerializerCustom(getter: TypeSerializerTransformCustom);
+export function schemaSerializerCustom(param: TypeSerializerTransformCustom | Partial<ISerializerTransformOptionsCustom>) {
+  let options: Partial<ISerializerTransformOptionsCustom>;
+  if (typeof param === 'function') {
+    options = { custom: param };
+  } else {
+    options = param;
+  }
+  return function (schema: z.ZodType): z.ZodType {
+    return schema.openapi({
+      serializerTransforms: {
+        'a-serialization:custom': options,
+      },
+    });
+  };
+}

package/src/lib/schema/v/system.ts

@@ -0,0 +1,72 @@
+import type { Constructable, ILocaleMagic } from 'vona';
+import type { ISchemaObjectOptions } from 'vona-module-a-openapi';
+
+import { isNil } from '@cabloy/utils';
+import { coerceWithNil } from '@cabloy/zod-query';
+import { z } from 'zod';
+
+import type { SchemaLike } from '../../../types/decorator.ts';
+
+import { $locale } from '../../../.metadata/locales.ts';
+import { normalizeErrorParams } from '../../utils.ts';
+import { $schema, $schemaLazy, makeSchemaLike } from '../makeSchemaLikes.ts';
+
+export function schemaDefault(defaultValue: any | Function) {
+  return function (schema: z.ZodType): z.ZodType {
+    return schema.default(defaultValue);
+  };
+}
+
+export function schemaOptional() {
+  return function (schema: z.ZodType): z.ZodType {
+    return schema.optional();
+  };
+}
+
+export function schemaLazy<T>(...schemaLikes: SchemaLike<T>[]) {
+  return function (_schema?: z.ZodType): z.ZodType<T> {
+    return $schemaLazy(...schemaLikes);
+  };
+}
+
+export function schemaObject<T>(classType: Constructable<T>, options?: ISchemaObjectOptions) {
+  return function (_schema?: z.ZodType): z.ZodType<T> {
+    return $schema(classType, options);
+  };
+}
+
+export function schemaArray(schemaLike?: SchemaLike, params?: z.core.$ZodArrayParams & { separator?: string }) {
+  return function (schema: z.ZodType): z.ZodType {
+    return z.preprocess(
+      val => {
+        val = coerceWithNil(val);
+        if (isNil(val)) return val;
+        if (typeof val !== 'string') return val;
+        if (val.startsWith('[') && val.endsWith(']')) return JSON.parse(val);
+        return val.split(params?.separator ?? ',');
+      },
+      z.array(makeSchemaLike(schemaLike ?? schema, z.any()), params),
+      // z.array(makeSchemaLike(schemaLike, schema), params),
+    );
+  };
+}
+
+export function schemaStrictObject() {
+  return function (schema: z.ZodObject): z.ZodObject {
+    return z.strictObject(schema.shape);
+  };
+}
+
+export function schemaLooseObject() {
+  return function (schema: z.ZodObject): z.ZodObject {
+    return z.looseObject(schema.shape);
+  };
+}
+
+export function schemaRequired(params?: string | ILocaleMagic | z.core.$ZodStringParams) {
+  const errorDefault = { error: () => $locale('ZodErrorRequired') };
+  return function (schema: z.ZodType): z.ZodType {
+    schema._zod.def.error = normalizeErrorParams(params, errorDefault).error;
+    return schema;
+  };
+}

package/src/lib/schema/v/utils.ts

@@ -0,0 +1,6 @@
+import type { TypeSchemaScene } from 'vona-module-a-openapi';
+import type z from 'zod';
+
+export function _generalSchemaRest<T extends z.ZodType>(schema: T, options: any, scene?: TypeSchemaScene) {
+  return schema.openapi(scene ? { rest: { [scene]: options } } : { rest: options });
+}

package/src/lib/schema/v/zod.ts

@@ -0,0 +1,36 @@
+import type { IZodRefineExecute, IZodRefineRecord, IZodTransformExecute, IZodTransformRecord } from 'vona-module-a-zod';
+import type z from 'zod';
+
+import { beanFullNameFromOnionName, useApp } from 'vona';
+
+export function schemaZodRefine<T extends keyof IZodRefineRecord>(zodRefineName: T, options?: Partial<IZodRefineRecord[T]>) {
+  return function (schema: z.ZodType): z.ZodType {
+    return schema.superRefine(async (value, refinementCtx) => {
+      const app = useApp();
+      const options2 = app.bean.onion.zodRefine.getOnionOptionsDynamic(zodRefineName, options);
+      // execute
+      const beanFullName = beanFullNameFromOnionName(zodRefineName, 'zodRefine');
+      const beanInstance = app.bean._getBean(beanFullName) as unknown as IZodRefineExecute;
+      if (!beanInstance) {
+        throw new Error(`zodRefine bean not found: ${beanFullName}`);
+      }
+      return await beanInstance.execute(value, refinementCtx, options2);
+    });
+  };
+}
+
+export function schemaZodTransform<T extends keyof IZodTransformRecord>(zodTransformName: T, options?: Partial<IZodTransformRecord[T]>) {
+  return function (schema: z.ZodType): z.ZodType {
+    return schema.transform(async value => {
+      const app = useApp();
+      const options2 = app.bean.onion.zodTransform.getOnionOptionsDynamic(zodTransformName, options);
+      // execute
+      const beanFullName = beanFullNameFromOnionName(zodTransformName, 'zodTransform');
+      const beanInstance = app.bean._getBean(beanFullName) as IZodTransformExecute;
+      if (!beanInstance) {
+        throw new Error(`zodTransform bean not found: ${beanFullName}`);
+      }
+      return await beanInstance.execute(value, options2);
+    });
+  };
+}