Zod: use `.nullish()`

[mrlubos]

Instead of

z.union([z.string(), z.null()]).optional()

we could generate

z.string().nullish()

Verify if there's a similar API in Valibot

[Daschi1]

Valibot does have nullish, but its behavior might not be identical to Zod’s (I’m not familiar with Zod). Valibot docs explain this quite nicely:

Note that nullish accepts undefined and null as an input. If you want to accept only null inputs, use nullable, and if you want to accept only undefined inputs, use optional instead. Also, if you want to set a default output value for any invalid input, you should use fallback instead.

[mrlubos]

@Daschi1 it works the same way!

[JasonWeinzierl]

Is it supported to do this with ~resolvers currently? I let an LLM try and brute-force this for a while (since I struggled to find more complex examples documenting how to do this), but the LLM just ended up using private & protected properties instead of any public API.

AI Slop resolver

      '~resolvers': {
        // Transform from z.optional(z.union([z.null(), T])) to T.nullish().
        object(ctx) {
          const { $, schema, symbols } = ctx;
          const { z } = symbols;
          
          // Get the default shape first
          const shape = ctx.nodes.shape(ctx);

          if (!shape._props) return undefined;

          // Check if this object has any nullable properties to transform
          let hasTransformations = false;

          for (const prop of shape._props) {
            const node = prop._value['~ref'];

            // Check if this property is an optional call containing a union
            if (node._callExpr && 
                node._callExpr['~ref'] && 
                node._callExpr['~ref']._name && 
                node._callExpr['~ref']._name['~ref'] === 'optional') {

              // Check if the optional wraps a union with null
              const optionalArg = node._args[0]['~ref'];
              if (optionalArg._callExpr && 
                  optionalArg._callExpr['~ref'] && 
                  optionalArg._callExpr['~ref']._name && 
                  optionalArg._callExpr['~ref']._name['~ref'] === 'union') {
                
                // Extract the union elements
                const unionArgs = optionalArg._args[0]['~ref']._elements;
                let hasNull = false;
                let nonNullElements = [];
                
                for (const element of unionArgs) {
                  const elementNode = element.expr;
                  
                  if (elementNode && elementNode._callExpr && elementNode._callExpr['~ref']) {
                    const callExpr = elementNode._callExpr['~ref'];
                    const methodName = callExpr._name && callExpr._name['~ref'];
                    
                    if (methodName === 'null') {
                      hasNull = true;
                    } else {
                      nonNullElements.push(element); // Keep the whole element, not just the expr
                    }
                  } else if (elementNode && elementNode['~dsl'] === 'ExprTsDsl') {
                    // This is a schema reference (like zAuthor)
                    nonNullElements.push(element); // Keep the whole element
                  }
                }
                
                // If we found null and non-null elements, transform appropriately
                if (hasNull && nonNullElements.length > 0) {
                  if (nonNullElements.length === 1) {
                    // Simple case: z.optional(z.union([z.null(), T])) → T.nullish()
                    const singleElement = nonNullElements[0].expr;
                    const newNode = $(singleElement).attr('nullish').call();
                    prop._value = { '~ref': newNode };
                    hasTransformations = true;
                  } else {
                    // Complex case: z.optional(z.union([z.null(), T1, T2, ...])) → z.union([T1, T2, ...]).nullish()
                    // Modify the existing union by removing null elements
                    optionalArg._args[0]['~ref']._elements = nonNullElements;
                    const newNode = $(optionalArg).attr('nullish').call();
                    prop._value = { '~ref': newNode };
                    hasTransformations = true;
                  }
                }
              }
            }
          }
          
          if (hasTransformations) {
            return $(z).attr('object').call(shape);
          }
          
          return undefined;
        },
      },

[mrlubos]

@JasonWeinzierl I don't think you can work around it in a clean way (hence this issue). One of the things that would move the needle forward is refactoring this .optional() call. I'm not prioritizing this since it's just a syntax sugar

[JasonWeinzierl]

0.90.9 now makes this possible, at least for the simplest use-case of string().nullish():

        object(ctx) {
          const { $, schema, symbols } = ctx;
          const { z } = symbols;
          
          const shape = ctx.nodes.shape(ctx);
          for (const [key, propSchema] of Object.entries(schema.properties || {})) {
            if (!propSchema.items) continue;
            if (
              propSchema.items.length === 2
              && propSchema.items.some(x => x.type === 'null')
              && propSchema.items.some(x => x.type === 'string' && !x.format)
              && schema.required?.includes(key) === false
            ) {
              shape.prop(key, $(z).attr('string').call().attr('nullish').call());
            }
          }

          return $(z).attr('object').call(shape);
        }

[nghiepdev]

I've found that changing optional: "optional" to optional: "nullish" also resolves the issue.

openapi-ts/packages/openapi-ts/src/plugins/zod/constants.ts

Line 44 in 403b72d

optional: 'optional',

I'm currently using pnpm patch to adjust this behavior as a temporary workaround. For example:
In patches/@hey-api__openapi-ts@0.92.3.patch

diff --git a/dist/init-W7OZahc5.mjs b/dist/init-W7OZahc5.mjs
index ea4d72b9c856c5221730235d591b1f0c0672b9b3..9371262044f7021df9ba611878dbaf17434624d4 100644
--- a/dist/init-W7OZahc5.mjs
+++ b/dist/init-W7OZahc5.mjs
@@ -10743,7 +10743,7 @@ const identifiers = {
 	nullable: "nullable",
 	number: "number",
 	object: "object",
-	optional: "optional",
+	optional: "nullish",
 	parseAsync: "parseAsync",
 	readonly: "readonly",
 	record: "record",