chore: add resolved config types for Zod

mrlubos · mrlubos · commit 6293a44739c2 · 2025-06-18T17:37:14.000+08:00
diff --git a/docs/openapi-ts/plugins/custom.md b/docs/openapi-ts/plugins/custom.md
@@ -110,10 +110,10 @@ import type { Plugin } from '@hey-api/openapi-ts';
 
 import type { Config } from './types';
 
-export const handler: Plugin.Handler<Config> = ({ context, plugin }) => {
+export const handler: Plugin.Handler<Config> = ({ plugin }) => {
   // create an output file. it will not be
   // generated until it contains nodes
-  const file = context.createFile({
+  const file = plugin.createFile({
     id: plugin.name,
     path: plugin.output,
   });
diff --git a/packages/openapi-ts-tests/test/openapi-ts.config.ts b/packages/openapi-ts-tests/test/openapi-ts.config.ts
@@ -163,9 +163,15 @@ export default defineConfig(() => {
       },
       {
         // comments: false,
+        definitions: 'z{{name}}Definition',
         // exportFromIndex: true,
         // metadata: true,
         name: 'zod',
+        requests: {
+          case: 'PascalCase',
+          enabled: false,
+        },
+        responses: false,
       },
     ],
     // useOptions: false,
diff --git a/packages/openapi-ts/src/initConfigs.ts b/packages/openapi-ts/src/initConfigs.ts
@@ -158,8 +158,42 @@ const getPluginsConfig = ({
               `missing plugin - no plugin with tag "${tag}" found`,
           );
         },
+        valueToObject: ({ defaultValue, mappers, value }) => {
+          let result = { ...defaultValue };
+          switch (typeof value) {
+            case 'boolean':
+              if ('boolean' in mappers) {
+                const mapper = mappers.boolean as (
+                  value: boolean,
+                ) => Record<string, any>;
+                result = { ...result, ...mapper(value) };
+              }
+              break;
+            case 'number':
+              if ('number' in mappers) {
+                const mapper = mappers.number as (
+                  value: number,
+                ) => Record<string, any>;
+                result = { ...result, ...mapper(value) };
+              }
+              break;
+            case 'string':
+              if ('string' in mappers) {
+                const mapper = mappers.string as (
+                  value: string,
+                ) => Record<string, any>;
+                result = { ...result, ...mapper(value) };
+              }
+              break;
+            case 'object':
+              if (value !== null) {
+                result = { ...result, ...value };
+              }
+              break;
+          }
+          return result;
+        },
       };
-      // @ts-expect-error
       plugin.resolveConfig(plugin, context);
     }
 
diff --git a/packages/openapi-ts/src/plugins/index.ts b/packages/openapi-ts/src/plugins/index.ts
@@ -128,11 +128,7 @@ export type ClientPlugins =
   | Plugin.Config<Zod>;
 
 export const defaultPluginConfigs: {
-  [K in PluginNames]: Plugin.Config<{
-    exportFromIndex?: any;
-    name: any;
-    output?: any;
-  }>;
+  [K in PluginNames]: any;
 } = {
   '@hey-api/client-axios': heyApiClientAxios,
   '@hey-api/client-fetch': heyApiClientFetch,
diff --git a/packages/openapi-ts/src/plugins/shared/utils/config.ts b/packages/openapi-ts/src/plugins/shared/utils/config.ts
@@ -1,10 +1,12 @@
 import type { BaseConfig, Plugin } from '../../types';
 
 export const definePluginConfig =
-  <Config extends BaseConfig>(defaultConfig: Plugin.Config<Config>) =>
+  <Config extends BaseConfig, ResolvedConfig extends BaseConfig = Config>(
+    defaultConfig: Plugin.Config<Config, ResolvedConfig>,
+  ) =>
   (
     userConfig?: Omit<Plugin.UserConfig<Config>, 'name'>,
-  ): Omit<Plugin.Config<Config>, 'name'> & {
+  ): Omit<Plugin.Config<Config, ResolvedConfig>, 'name'> & {
     /**
      * Cast name to `any` so it doesn't throw type error in `plugins` array.
      * We could allow any `string` as plugin `name` in the object syntax, but
diff --git a/packages/openapi-ts/src/plugins/types.d.ts b/packages/openapi-ts/src/plugins/types.d.ts
@@ -34,6 +34,11 @@ export type AnyPluginName = PluginNames | (string & {});
 
 type PluginTag = 'client' | 'transformer' | 'validator';
 
+type ObjectType<T> =
+  Extract<T, Record<string, any>> extends never
+    ? Record<string, any>
+    : Extract<T, Record<string, any>>;
+
 export interface PluginContext {
   pluginByTag: <T extends AnyPluginName | boolean = AnyPluginName>(
     tag: PluginTag,
@@ -42,6 +47,25 @@ export interface PluginContext {
       errorMessage?: string;
     },
   ) => Exclude<T, boolean> | undefined;
+  valueToObject: <
+    T extends undefined | string | boolean | number | Record<string, any>,
+  >(args: {
+    defaultValue: ObjectType<T>;
+    mappers: {
+      boolean: T extends boolean
+        ? (value: boolean) => Partial<ObjectType<T>>
+        : never;
+      number: T extends number
+        ? (value: number) => Partial<ObjectType<T>>
+        : never;
+      string: T extends string
+        ? (value: string) => Partial<ObjectType<T>>
+        : never;
+    } extends infer U
+      ? { [K in keyof U as U[K] extends never ? never : K]: U[K] }
+      : never;
+    value: T;
+  }) => ObjectType<T>;
 }
 
 export interface BaseConfig {
@@ -54,7 +78,10 @@ export interface BaseConfig {
   output?: string;
 }
 
-interface Meta<Config extends BaseConfig> {
+interface Meta<
+  Config extends BaseConfig,
+  ResolvedConfig extends BaseConfig = Config,
+> {
   /**
    * Dependency plugins will be always processed, regardless of whether user
    * explicitly defines them in their `plugins` config.
@@ -66,7 +93,7 @@ interface Meta<Config extends BaseConfig> {
    * should be used for validation.
    */
   resolveConfig?: (
-    config: Omit<Plugin.Config<Config>, 'dependencies'> & {
+    plugin: Omit<Plugin.Config<Config, ResolvedConfig>, 'dependencies'> & {
       dependencies: Set<AnyPluginName>;
     },
     context: PluginContext,
@@ -82,28 +109,32 @@ interface Meta<Config extends BaseConfig> {
  * Public Plugin API.
  */
 export namespace Plugin {
-  export type Config<Config extends BaseConfig> = Pick<
-    Config,
-    'name' | 'output'
-  > &
-    Meta<Config> & {
+  export type Config<
+    Config extends BaseConfig,
+    ResolvedConfig extends BaseConfig = Config,
+  > = Pick<Config, 'name' | 'output'> &
+    Meta<Config, ResolvedConfig> & {
       config: Omit<Config, 'name' | 'output'>;
       handler: Plugin.Handler<
-        Omit<Config, 'name'> & {
+        Omit<ResolvedConfig, 'name'> & {
           name: any;
         }
       >;
       handlerLegacy: Plugin.LegacyHandler<
-        Omit<Config, 'name'> & {
+        Omit<ResolvedConfig, 'name'> & {
           name: any;
         }
       >;
     };
 
   /** @deprecated - use `definePluginConfig()` instead */
-  export type DefineConfig<Config extends BaseConfig> = (
-    config?: Plugin.UserConfig<Omit<Config, 'name'>>,
-  ) => Omit<Plugin.Config<Config>, 'name'> & {
+  export type DefineConfig<
+    Config extends BaseConfig,
+    ResolvedConfig extends BaseConfig = Config,
+  > = (config?: Plugin.UserConfig<Omit<Config, 'name'>>) => Omit<
+    Plugin.Config<Config, ResolvedConfig>,
+    'name'
+  > & {
     /**
      * Cast name to `any` so it doesn't throw type error in `plugins` array.
      * We could allow any `string` as plugin `name` in the object syntax, but
diff --git a/packages/openapi-ts/src/plugins/zod/config.ts b/packages/openapi-ts/src/plugins/zod/config.ts
@@ -1,9 +1,9 @@
 import { definePluginConfig } from '../shared/utils/config';
 import type { Plugin } from '../types';
 import { handler } from './plugin';
-import type { Config } from './types';
+import type { Config, ResolvedConfig } from './types';
 
-export const defaultConfig: Plugin.Config<Config> = {
+export const defaultConfig: Plugin.Config<Config, ResolvedConfig> = {
   config: {
     comments: true,
     exportFromIndex: false,
@@ -13,6 +13,46 @@ export const defaultConfig: Plugin.Config<Config> = {
   handlerLegacy: () => {},
   name: 'zod',
   output: 'zod',
+  resolveConfig: (plugin, context) => {
+    plugin.config.definitions = context.valueToObject({
+      defaultValue: {
+        case: 'camelCase',
+        enabled: true,
+        name: 'z{{name}}',
+      },
+      mappers: {
+        boolean: (enabled) => ({ enabled }),
+        string: (name) => ({ enabled: true, name }),
+      },
+      value: plugin.config.definitions,
+    });
+
+    plugin.config.requests = context.valueToObject({
+      defaultValue: {
+        case: 'camelCase',
+        enabled: true,
+        name: 'z{{name}}Data',
+      },
+      mappers: {
+        boolean: (enabled) => ({ enabled }),
+        string: (name) => ({ enabled: true, name }),
+      },
+      value: plugin.config.requests,
+    });
+
+    plugin.config.responses = context.valueToObject({
+      defaultValue: {
+        case: 'camelCase',
+        enabled: true,
+        name: 'z{{name}}Response',
+      },
+      mappers: {
+        boolean: (enabled) => ({ enabled }),
+        string: (name) => ({ enabled: true, name }),
+      },
+      value: plugin.config.responses,
+    });
+  },
   tags: ['validator'],
 };
 
diff --git a/packages/openapi-ts/src/plugins/zod/plugin.ts b/packages/openapi-ts/src/plugins/zod/plugin.ts
@@ -8,7 +8,7 @@ import { numberRegExp } from '../../utils/regexp';
 import { operationIrRef } from '../shared/utils/ref';
 import { createSchemaComment } from '../shared/utils/schema';
 import type { Plugin } from '../types';
-import type { Config } from './types';
+import type { ResolvedConfig } from './types';
 
 interface SchemaWithType<T extends Required<IR.SchemaObject>['type']>
   extends Omit<IR.SchemaObject, 'type'> {
@@ -50,7 +50,7 @@ const arrayTypeToZodSchema = ({
   schema,
 }: {
   context: IR.Context;
-  plugin: Plugin.Instance<Config>;
+  plugin: Plugin.Instance<ResolvedConfig>;
   result: Result;
   schema: SchemaWithType<'array'>;
 }): ts.CallExpression => {
@@ -389,7 +389,7 @@ const objectTypeToZodSchema = ({
   schema,
 }: {
   context: IR.Context;
-  plugin: Plugin.Instance<Config>;
+  plugin: Plugin.Instance<ResolvedConfig>;
   result: Result;
   schema: SchemaWithType<'object'>;
 }): {
@@ -614,7 +614,7 @@ const tupleTypeToZodSchema = ({
   schema,
 }: {
   context: IR.Context;
-  plugin: Plugin.Instance<Config>;
+  plugin: Plugin.Instance<ResolvedConfig>;
   result: Result;
   schema: SchemaWithType<'tuple'>;
 }) => {
@@ -724,7 +724,7 @@ const schemaTypeToZodSchema = ({
   schema,
 }: {
   context: IR.Context;
-  plugin: Plugin.Instance<Config>;
+  plugin: Plugin.Instance<ResolvedConfig>;
   result: Result;
   schema: IR.SchemaObject;
 }): {
@@ -832,7 +832,7 @@ const operationToZodSchema = ({
 }: {
   context: IR.Context;
   operation: IR.OperationObject;
-  plugin: Plugin.Instance<Config>;
+  plugin: Plugin.Instance<ResolvedConfig>;
   result: Result;
 }) => {
   if (operation.body) {
@@ -911,7 +911,7 @@ const schemaToZodSchema = ({
    * `.default()` which is handled in this function.
    */
   optional?: boolean;
-  plugin: Plugin.Instance<Config>;
+  plugin: Plugin.Instance<ResolvedConfig>;
   result: Result;
   schema: IR.SchemaObject;
 }): ts.Expression => {
@@ -1145,7 +1145,7 @@ const schemaToZodSchema = ({
   return expression!;
 };
 
-export const handler: Plugin.Handler<Config> = ({ plugin }) => {
+export const handler: Plugin.Handler<ResolvedConfig> = ({ plugin }) => {
   const file = plugin.createFile({
     id: zodId,
     identifierCase: 'camelCase',
diff --git a/packages/openapi-ts/src/plugins/zod/types.d.ts b/packages/openapi-ts/src/plugins/zod/types.d.ts
