refactor: valibot plugin internals

Author: mrlubos

…s/src/plugins/valibot/resolvers/types.ts …napi-ts/src/plugins/valibot/resolvers.tspackages/openapi-ts/src/plugins/valibot/resolvers/types.ts renamed to packages/openapi-ts/src/plugins/valibot/resolvers.ts packages/openapi-ts/src/plugins/valibot/resolvers/types.ts renamed to packages/openapi-ts/src/plugins/valibot/resolvers.ts

@@ -1,12 +1,12 @@
-import type { Refs, Symbol } from '@hey-api/codegen-core';
+import type { Symbol } from '@hey-api/codegen-core';
 import type { IR, Plugin, SchemaVisitorContext, SchemaWithType, Walker } from '@hey-api/shared';
 
-import type { MaybeBigInt, ShouldCoerceToBigInt } from '../../../plugins/shared/utils/coerce';
-import type { GetIntegerLimit } from '../../../plugins/shared/utils/formats';
-import type { $, DollarTsDsl } from '../../../ts-dsl';
-import type { Pipe, PipeResult, Pipes, PipesUtils } from '../shared/pipes';
-import type { Ast, IrSchemaToAstOptions, PluginState, ValibotSchemaResult } from '../shared/types';
-import type { ValibotPlugin } from '../types';
+import type { MaybeBigInt, ShouldCoerceToBigInt } from '../../plugins/shared/utils/coerce';
+import type { GetIntegerLimit } from '../../plugins/shared/utils/formats';
+import type { $, DollarTsDsl } from '../../ts-dsl';
+import type { Pipe, PipeResult, Pipes, PipesUtils } from './shared/pipes';
+import type { ValibotFinal, ValibotResult } from './shared/types';
+import type { ValibotPlugin } from './types';
 
 export type Resolvers = Plugin.Resolvers<{
   /**
@@ -16,31 +16,31 @@ export type Resolvers = Plugin.Resolvers<{
    *
    * Returning `undefined` will execute the default resolver logic.
    */
-  enum?: (ctx: EnumResolverContext) => PipeResult | undefined;
+  enum?: (ctx: EnumResolverContext) => PipeResult;
   /**
    * Resolver for number schemas.
    *
    * Allows customization of how number types are rendered.
    *
    * Returning `undefined` will execute the default resolver logic.
    */
-  number?: (ctx: NumberResolverContext) => PipeResult | undefined;
+  number?: (ctx: NumberResolverContext) => PipeResult;
   /**
    * Resolver for object schemas.
    *
    * Allows customization of how object types are rendered.
    *
    * Returning `undefined` will execute the default resolver logic.
    */
-  object?: (ctx: ObjectResolverContext) => PipeResult | undefined;
+  object?: (ctx: ObjectResolverContext) => PipeResult;
   /**
    * Resolver for string schemas.
    *
    * Allows customization of how string types are rendered.
    *
    * Returning `undefined` will execute the default resolver logic.
    */
-  string?: (ctx: StringResolverContext) => PipeResult | undefined;
+  string?: (ctx: StringResolverContext) => PipeResult;
   /**
    * Resolvers for request and response validators.
    *
@@ -70,34 +70,35 @@ export type Resolvers = Plugin.Resolvers<{
 
 type ValidatorResolver = (ctx: ValidatorResolverContext) => PipeResult | null | undefined;
 
-type BaseContext = DollarTsDsl &
-  Pick<IrSchemaToAstOptions, 'plugin'> & {
-    /**
-     * Functions for working with pipes.
-     */
-    pipes: PipesUtils & {
-      /**
-       * The current pipe.
-       *
-       * In Valibot, this represents a list of call expressions ("pipes")
-       * being assembled to form a schema definition.
-       *
-       * Each pipe can be extended, modified, or replaced to customize
-       * the resulting schema.
-       */
-      current: Pipes;
-    };
+interface BaseContext extends DollarTsDsl {
+  /**
+   * Functions for working with pipes.
+   */
+  pipes: PipesUtils & {
     /**
-     * Provides access to commonly used symbols within the plugin.
+     * The current pipe.
+     *
+     * In Valibot, this represents a list of call expressions ("pipes")
+     * being assembled to form a schema definition.
+     *
+     * Each pipe can be extended, modified, or replaced to customize
+     * the resulting schema.
      */
-    symbols: {
-      v: Symbol;
-    };
+    current: Pipes;
   };
+  /** The plugin instance. */
+  plugin: ValibotPlugin['Instance'];
+  /**
+   * Provides access to commonly used symbols within the plugin.
+   */
+  symbols: {
+    v: Symbol;
+  };
+}
 
 export interface EnumResolverContext extends BaseContext {
   /**
-   * Nodes used to build different parts of the enum schema.
+   * Nodes used to build different parts of the schema.
    */
   nodes: {
     /**
@@ -119,23 +120,17 @@ export interface EnumResolverContext extends BaseContext {
     };
   };
   schema: SchemaWithType<'enum'>;
-  /**
-   * Utility functions for enum schema processing.
-   */
-  utils: {
-    state: Refs<PluginState>;
-  };
 }
 
 export interface NumberResolverContext extends BaseContext {
   /**
-   * Nodes used to build different parts of the number schema.
+   * Nodes used to build different parts of the schema.
    */
   nodes: {
     base: (ctx: NumberResolverContext) => PipeResult;
-    const: (ctx: NumberResolverContext) => PipeResult | undefined;
-    max: (ctx: NumberResolverContext) => PipeResult | undefined;
-    min: (ctx: NumberResolverContext) => PipeResult | undefined;
+    const: (ctx: NumberResolverContext) => PipeResult;
+    max: (ctx: NumberResolverContext) => PipeResult;
+    min: (ctx: NumberResolverContext) => PipeResult;
   };
   schema: SchemaWithType<'integer' | 'number'>;
   /**
@@ -149,43 +144,39 @@ export interface NumberResolverContext extends BaseContext {
 }
 
 export interface ObjectResolverContext extends BaseContext {
-  applyModifiers: (result: ValibotSchemaResult, opts: { optional?: boolean }) => Ast;
+  _childResults: Array<ValibotResult>;
+  applyModifiers: (result: ValibotResult, opts: { optional?: boolean }) => ValibotFinal;
   /**
-   * Nodes used to build different parts of the object schema.
+   * Nodes used to build different parts of the schema.
    */
   nodes: {
-    /**
-     * If `additionalProperties` is `false` or `{ type: 'never' }`, returns `null`
-     * to indicate no additional properties are allowed.
-     */
     additionalProperties: (ctx: ObjectResolverContext) => Pipe | null | undefined;
-    base: (ctx: ObjectResolverContext) => PipeResult;
+    base: (ctx: ObjectResolverContext) => Pipes | Pipe;
     shape: (ctx: ObjectResolverContext) => ReturnType<typeof $.object>;
   };
   schema: SchemaWithType<'object'>;
   /**
    * Utility functions for object schema processing.
    */
   utils: {
-    ast: Partial<Omit<Ast, 'typeName'>>;
-    state: Refs<PluginState>;
+    ast: Partial<{ hasLazy: boolean }>;
   };
-  walk: Walker<ValibotSchemaResult, ValibotPlugin['Instance']>;
+  walk: Walker<ValibotResult, ValibotPlugin['Instance']>;
   walkerCtx: SchemaVisitorContext<ValibotPlugin['Instance']>;
 }
 
 export interface StringResolverContext extends BaseContext {
   /**
-   * Nodes used to build different parts of the string schema.
+   * Nodes used to build different parts of the schema.
    */
   nodes: {
     base: (ctx: StringResolverContext) => PipeResult;
-    const: (ctx: StringResolverContext) => PipeResult | undefined;
-    format: (ctx: StringResolverContext) => PipeResult | undefined;
-    length: (ctx: StringResolverContext) => PipeResult | undefined;
-    maxLength: (ctx: StringResolverContext) => PipeResult | undefined;
-    minLength: (ctx: StringResolverContext) => PipeResult | undefined;
-    pattern: (ctx: StringResolverContext) => PipeResult | undefined;
+    const: (ctx: StringResolverContext) => PipeResult;
+    format: (ctx: StringResolverContext) => PipeResult;
+    length: (ctx: StringResolverContext) => PipeResult;
+    maxLength: (ctx: StringResolverContext) => PipeResult;
+    minLength: (ctx: StringResolverContext) => PipeResult;
+    pattern: (ctx: StringResolverContext) => PipeResult;
   };
   schema: SchemaWithType<'string'>;
 }

packages/openapi-ts/src/plugins/valibot/resolvers/index.ts

@@ -2,25 +2,24 @@ import { applyNaming, pathToName } from '@hey-api/shared';
 
 import { createSchemaComment } from '../../../plugins/shared/utils/schema';
 import { $ } from '../../../ts-dsl';
-import { identifiers } from '../v1/constants';
+import type { ValibotPlugin } from '../types';
 import { pipesToNode } from './pipes';
 import type { ProcessorContext } from './processor';
-import type { Ast, IrSchemaToAstOptions } from './types';
+import type { ValibotFinal } from './types';
 
 export function exportAst({
-  ast,
+  final,
   meta,
   naming,
   namingAnchor,
   path,
   plugin,
   schema,
-  state,
   tags,
-}: Pick<IrSchemaToAstOptions, 'state'> &
-  ProcessorContext & {
-    ast: Ast;
-  }): void {
+}: ProcessorContext & {
+  final: ValibotFinal;
+  plugin: ValibotPlugin['Instance'];
+}): void {
   const v = plugin.external('valibot.v');
 
   const name = pathToName(path, { anchor: namingAnchor });
@@ -37,9 +36,8 @@ export function exportAst({
   const statement = $.const(symbol)
     .export()
     .$if(plugin.config.comments && createSchemaComment(schema), (c, v) => c.doc(v))
-    .$if(state.hasLazyExpression['~ref'], (c) =>
-      c.type($.type(v).attr(ast.typeName || identifiers.types.GenericSchema)),
-    )
-    .assign(pipesToNode(ast.pipes, plugin));
+    .$if(final.typeName, (c) => c.type($.type(v).attr(final.typeName!)))
+    .assign(pipesToNode(final.pipes, plugin));
+
   plugin.node(statement);
 }

packages/openapi-ts/src/plugins/valibot/shared/export.ts

@@ -0,0 +1,59 @@
+import type { IR } from '@hey-api/shared';
+
+import type { ValibotMeta, ValibotResult } from './types';
+
+/**
+ * Creates default metadata from a schema.
+ */
+export function defaultMeta(schema: IR.SchemaObject): ValibotMeta {
+  return {
+    default: schema.default,
+    format: schema.format,
+    hasLazy: false,
+    nullable: false,
+    readonly: schema.accessScope === 'read',
+  };
+}
+
+/**
+ * Composes metadata from child results.
+ *
+ * Automatically propagates hasLazy, nullable, readonly from children.
+ *
+ * @param children - Results from walking child schemas
+ * @param overrides - Explicit overrides (e.g., from parent schema)
+ */
+export function composeMeta(
+  children: ReadonlyArray<ValibotResult>,
+  overrides?: Partial<ValibotMeta>,
+): ValibotMeta {
+  const hasLazy = overrides?.hasLazy ?? children.some((c) => c.meta.hasLazy);
+  const nullable = overrides?.nullable ?? children.some((c) => c.meta.nullable);
+  const readonly = overrides?.readonly ?? children.some((c) => c.meta.readonly);
+
+  return {
+    default: overrides?.default,
+    format: overrides?.format,
+    hasLazy,
+    nullable,
+    readonly,
+  };
+}
+
+/**
+ * Merges parent schema metadata with composed child metadata.
+ *
+ * @param parent - The parent schema
+ * @param children - Results from walking child schemas
+ */
+export function inheritMeta(
+  parent: IR.SchemaObject,
+  children: ReadonlyArray<ValibotResult>,
+): ValibotMeta {
+  return composeMeta(children, {
+    default: parent.default,
+    format: parent.format,
+    nullable: false,
+    readonly: parent.accessScope === 'read',
+  });
+}

packages/openapi-ts/src/plugins/valibot/shared/meta.ts

@@ -3,19 +3,17 @@ import { operationResponsesMap } from '@hey-api/shared';
 
 import { buildOperationSchema } from './operation-schema';
 import type { ProcessorContext, ProcessorResult } from './processor';
-import type { IrSchemaToAstOptions } from './types';
 
 export function irOperationToAst({
   operation,
   path,
   plugin,
   processor,
   tags,
-}: Pick<IrSchemaToAstOptions, 'plugin'> &
-  Pick<ProcessorContext, 'path' | 'tags'> & {
-    operation: IR.OperationObject;
-    processor: ProcessorResult;
-  }): void {
+}: Pick<ProcessorContext, 'path' | 'plugin' | 'tags'> & {
+  operation: IR.OperationObject;
+  processor: ProcessorResult;
+}): void {
   if (plugin.config.requests.enabled) {
     const { schema } = buildOperationSchema(operation);