Merge pull request #3396 from hey-api/refactor/valibot-plugin-nullish

refactor: valibot plugin nullish

Author: mrlubos

.changeset/brown-ideas-matter.md

@@ -0,0 +1,5 @@
+---
+"@hey-api/shared": patch
+---
+
+**internal**: export schema walker interfaces

.changeset/clean-singers-stand.md

@@ -0,0 +1,9 @@
+---
+"@hey-api/openapi-ts": minor
+---
+
+**plugin(valibot)**: remove `enum.nodes.nullable` resolver node
+
+### Removed resolver node
+
+Valibot plugin no longer exposes the `enum.nodes.nullable` node. It was refactored so that nullable values are handled outside of resolvers.

.changeset/stale-falcons-raise.md

@@ -0,0 +1,5 @@
+---
+"@hey-api/openapi-ts": patch
+---
+
+**plugin(valibot)**: use `.nullable()` and `.nullish()` methods

docs/openapi-ts/migrating.md

@@ -7,6 +7,12 @@ description: Migrating to @hey-api/openapi-ts.
 
 While we try to avoid breaking changes, sometimes it's unavoidable in order to offer you the latest features. This page lists changes that require updates to your code. If you run into a problem with migration, please [open an issue](https://github.com/hey-api/openapi-ts/issues).
 
+## v0.93.0
+
+### Removed resolver node
+
+Valibot and Zod plugins no longer expose the `enum.nodes.nullable` node. Both plugins were refactored so that nullable values are handled outside of resolvers.
+
 ## v0.92.0
 
 ### Updated Symbol interface

packages/openapi-python/src/plugins/pydantic/shared/export.ts

@@ -1,25 +1,36 @@
-import type { Symbol } from '@hey-api/codegen-core';
-import type { IR } from '@hey-api/shared';
+import { applyNaming, pathToName } from '@hey-api/shared';
 
 // import { createSchemaComment } from '../../../plugins/shared/utils/schema';
 import { $ } from '../../../py-dsl';
+import type { ProcessorContext } from './processor';
 // import { identifiers } from '../v2/constants';
 // import { pipesToNode } from './pipes';
 import type { Ast, IrSchemaToAstOptions } from './types';
 
 export function exportAst({
-  // ast,
+  meta,
+  naming,
+  namingAnchor,
+  path,
   plugin,
-  // schema,
-  // state,
-  symbol,
-}: IrSchemaToAstOptions & {
-  ast: Ast;
-  schema: IR.SchemaObject;
-  symbol: Symbol;
-}): void {
-  // const v = plugin.external('valibot.v');
-  const classDef = $.class(symbol);
+  tags,
+}: Pick<IrSchemaToAstOptions, 'state'> &
+  ProcessorContext & {
+    ast: Ast;
+  }): void {
+  const name = pathToName(path, { anchor: namingAnchor });
+  const symbol = plugin.symbol(applyNaming(name, naming), {
+    meta: {
+      category: 'schema',
+      path,
+      tags,
+      tool: 'pydantic',
+      ...meta,
+    },
+  });
+
+  const baseModel = plugin.external('pydantic.BaseModel');
+  const classDef = $.class(symbol).extends(baseModel);
   // .export()
   // .$if(plugin.config.comments && createSchemaComment(schema), (c, v) => c.doc(v))
   // .$if(state.hasLazyExpression['~ref'], (c) =>

packages/openapi-python/src/plugins/pydantic/shared/processor.ts

@@ -0,0 +1,16 @@
+import type {
+  IR,
+  NamingConfig,
+  SchemaProcessorContext,
+  SchemaProcessorResult,
+} from '@hey-api/shared';
+
+import type { IrSchemaToAstOptions } from './types';
+
+export type ProcessorContext = Pick<IrSchemaToAstOptions, 'plugin'> &
+  SchemaProcessorContext & {
+    naming: NamingConfig;
+    schema: IR.SchemaObject;
+  };
+
+export type ProcessorResult = SchemaProcessorResult<ProcessorContext>;

packages/openapi-python/src/plugins/pydantic/shared/types.ts

@@ -3,6 +3,7 @@ import type { IR, SchemaExtractor } from '@hey-api/shared';
 
 import type { $ } from '../../../py-dsl';
 import type { PydanticPlugin } from '../types';
+import type { ProcessorContext } from './processor';
 
 export type Ast = {
   /**
@@ -32,7 +33,7 @@ export type IrSchemaToAstOptions = {
   /** The plugin instance. */
   plugin: PydanticPlugin['Instance'];
   /** Optional schema extractor function. */
-  schemaExtractor?: SchemaExtractor;
+  schemaExtractor?: SchemaExtractor<ProcessorContext>;
   /** The plugin state references. */
   state: Refs<PluginState>;
 };

packages/openapi-python/src/plugins/pydantic/v2/plugin.ts

@@ -1,12 +1,12 @@
 import type { SymbolMeta } from '@hey-api/codegen-core';
-import { fromRef, ref, refs } from '@hey-api/codegen-core';
+import { fromRef, ref } from '@hey-api/codegen-core';
 import type { IR, SchemaWithType } from '@hey-api/shared';
-import { applyNaming, deduplicateSchema, pathToJsonPointer, refToName } from '@hey-api/shared';
+import { deduplicateSchema, pathToJsonPointer } from '@hey-api/shared';
 
 // import { $ } from '../../../py-dsl';
-import { exportAst } from '../shared/export';
-import type { Ast, IrSchemaToAstOptions, PluginState } from '../shared/types';
+import type { Ast, IrSchemaToAstOptions } from '../shared/types';
 import type { PydanticPlugin } from '../types';
+import { createProcessor } from './processor';
 import { irSchemaWithTypeToAst } from './toAst';
 
 export function irSchemaToAst({
@@ -25,7 +25,9 @@ export function irSchemaToAst({
         resource: 'definition',
         resourceId: pathToJsonPointer(fromRef(state.path)),
       },
+      naming: plugin.config.definitions,
       path: fromRef(state.path),
+      plugin,
       schema,
     });
     if (extracted !== schema) schema = extracted;
@@ -119,39 +121,6 @@ export function irSchemaToAst({
   };
 }
 
-function handleComponent({
-  plugin,
-  schema,
-  state,
-}: IrSchemaToAstOptions & {
-  schema: IR.SchemaObject;
-}): void {
-  const $ref = pathToJsonPointer(fromRef(state.path));
-  const baseName = refToName($ref);
-  const symbol = plugin.symbol(applyNaming(baseName, plugin.config.definitions), {
-    meta: {
-      category: 'schema',
-      path: fromRef(state.path),
-      resource: 'definition',
-      resourceId: $ref,
-      tags: fromRef(state.tags),
-      tool: 'pydantic',
-    },
-  });
-  const ast = irSchemaToAst({
-    plugin,
-    schema,
-    state,
-  });
-  exportAst({
-    ast,
-    plugin,
-    schema,
-    state,
-    symbol,
-  });
-}
-
 export const handlerV2: PydanticPlugin['Handler'] = ({ plugin }) => {
   plugin.symbol('Any', {
     external: 'typing',
@@ -202,36 +171,47 @@ export const handlerV2: PydanticPlugin['Handler'] = ({ plugin }) => {
     },
   });
 
-  plugin.forEach('operation', 'parameter', 'requestBody', 'schema', 'webhook', (event) => {
-    const state = refs<PluginState>({
-      hasLazyExpression: false,
-      path: event._path,
-      tags: event.tags,
-    });
+  const processor = createProcessor(plugin);
 
+  plugin.forEach('operation', 'parameter', 'requestBody', 'schema', 'webhook', (event) => {
     switch (event.type) {
       case 'parameter':
-        handleComponent({
-          // baseName: event.name,
+        processor.process({
+          meta: {
+            resource: 'definition',
+            resourceId: pathToJsonPointer(event._path),
+          },
+          naming: plugin.config.definitions,
+          path: event._path,
           plugin,
           schema: event.parameter.schema,
-          state,
+          tags: event.tags,
         });
         break;
       case 'requestBody':
-        handleComponent({
-          // baseName: event.name,
+        processor.process({
+          meta: {
+            resource: 'definition',
+            resourceId: pathToJsonPointer(event._path),
+          },
+          naming: plugin.config.definitions,
+          path: event._path,
           plugin,
           schema: event.requestBody.schema,
-          state,
+          tags: event.tags,
         });
         break;
       case 'schema':
-        handleComponent({
-          // baseName: event.name,
+        processor.process({
+          meta: {
+            resource: 'definition',
+            resourceId: pathToJsonPointer(event._path),
+          },
+          naming: plugin.config.definitions,
+          path: event._path,
           plugin,
           schema: event.schema,
-          state,
+          tags: event.tags,
         });
         break;
     }

packages/openapi-python/src/plugins/pydantic/v2/processor.ts

@@ -0,0 +1,58 @@
+import { refs } from '@hey-api/codegen-core';
+import type { IR } from '@hey-api/shared';
+import { createSchemaProcessor, pathToJsonPointer } from '@hey-api/shared';
+
+import { exportAst } from '../shared/export';
+import type { ProcessorContext, ProcessorResult } from '../shared/processor';
+import type { PluginState } from '../shared/types';
+import type { PydanticPlugin } from '../types';
+import { irSchemaToAst } from './plugin';
+
+export function createProcessor(plugin: PydanticPlugin['Instance']): ProcessorResult {
+  const processor = createSchemaProcessor();
+
+  const hooks = [plugin.config['~hooks']?.schemas, plugin.context.config.parser.hooks.schemas];
+
+  function extractor(ctx: ProcessorContext): IR.SchemaObject {
+    if (processor.hasEmitted(ctx.path)) {
+      return ctx.schema;
+    }
+
+    for (const hook of hooks) {
+      const result = hook?.shouldExtract?.(ctx);
+      if (result) {
+        process({
+          namingAnchor: processor.context.anchor,
+          tags: processor.context.tags,
+          ...ctx,
+        });
+        return { $ref: pathToJsonPointer(ctx.path) };
+      }
+    }
+
+    return ctx.schema;
+  }
+
+  function process(ctx: ProcessorContext): void {
+    if (!processor.markEmitted(ctx.path)) return;
+
+    processor.withContext({ anchor: ctx.namingAnchor, tags: ctx.tags }, () => {
+      const state = refs<PluginState>({
+        hasLazyExpression: false,
+        path: ctx.path,
+        tags: ctx.tags,
+      });
+
+      const ast = irSchemaToAst({
+        plugin,
+        schema: ctx.schema,
+        schemaExtractor: extractor,
+        state,
+      });
+
+      exportAst({ ...ctx, ast, plugin, state });
+    });
+  }
+
+  return { process };
+}

packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/valibot/default/valibot.gen.ts

@@ -197,8 +197,8 @@ export const vModelWithStringError = v.object({
  * This is a model with one string property
  */
 export const vModelWithNullableString = v.object({
-    nullableProp: v.optional(v.union([v.string(), v.null()])),
-    nullableRequiredProp: v.union([v.string(), v.null()])
+    nullableProp: v.nullish(v.string()),
+    nullableRequiredProp: v.nullable(v.string())
 });
 
 /**
@@ -581,8 +581,8 @@ export const vCallToTestOrderOfParamsData = v.object({
         parameterStringWithDefault: v.optional(v.string(), 'Hello World!'),
         parameterStringWithEmptyDefault: v.optional(v.string(), ''),
         parameterStringWithNoDefault: v.string(),
-        parameterStringNullableWithNoDefault: v.optional(v.union([v.string(), v.null()])),
-        parameterStringNullableWithDefault: v.optional(v.union([v.string(), v.null()]), null)
+        parameterStringNullableWithNoDefault: v.nullish(v.string()),
+        parameterStringNullableWithDefault: v.nullish(v.string(), null)
     })
 });