@ai-sdk/provider-utils 4.0.5 → 4.0.6

package/src/to-json-schema/zod3-to-json-schema/parsers/union.test.ts

@@ -0,0 +1,226 @@
+import { describe, it, expect } from 'vitest';
+import { z } from 'zod/v3';
+import { parseUnionDef } from './union';
+import { getRefs } from '../refs';
+import { JSONSchema7 } from '@ai-sdk/provider';
+
+describe('union', () => {
+  it('Should be possible to get a simple type array from a union of only unvalidated primitives', () => {
+    const parsedSchema = parseUnionDef(
+      z.union([z.string(), z.number(), z.boolean(), z.null()])._def,
+      getRefs(),
+    );
+
+    expect(parsedSchema).toStrictEqual({
+      type: ['string', 'number', 'boolean', 'null'],
+    } satisfies JSONSchema7);
+  });
+
+  it('Should be possible to get a simple type array with enum values from a union of literals', () => {
+    const parsedSchema = parseUnionDef(
+      z.union([
+        z.literal('string'),
+        z.literal(123),
+        z.literal(true),
+        z.literal(null),
+        z.literal(BigInt(50)),
+      ])._def,
+      getRefs(),
+    );
+
+    expect(parsedSchema).toStrictEqual({
+      type: ['string', 'number', 'boolean', 'null', 'integer'],
+      enum: ['string', 123, true, null, BigInt(50) as unknown as number],
+    } satisfies JSONSchema7);
+  });
+
+  it('Should be possible to get an anyOf array with enum values from a union of literals', () => {
+    const parsedSchema = parseUnionDef(
+      z.union([
+        z.literal(undefined),
+        z.literal(Symbol('abc')),
+        // @ts-expect-error Ok
+        z.literal(function () {}),
+      ])._def,
+      getRefs(),
+    );
+
+    expect(parsedSchema).toStrictEqual({
+      anyOf: [
+        {
+          type: 'object',
+        },
+        {
+          type: 'object',
+        },
+        {
+          type: 'object',
+        },
+      ],
+    } satisfies JSONSchema7);
+  });
+
+  it('Should be possible to create a union with objects, arrays and validated primitives as an anyOf', () => {
+    const parsedSchema = parseUnionDef(
+      z.union([
+        z.object({ herp: z.string(), derp: z.boolean() }),
+        z.array(z.number()),
+        z.string().min(3),
+        z.number(),
+      ])._def,
+      getRefs(),
+    );
+
+    expect(parsedSchema).toStrictEqual({
+      anyOf: [
+        {
+          type: 'object',
+          properties: {
+            herp: {
+              type: 'string',
+            },
+            derp: {
+              type: 'boolean',
+            },
+          },
+          required: ['herp', 'derp'],
+          additionalProperties: false,
+        },
+        {
+          type: 'array',
+          items: {
+            type: 'number',
+          },
+        },
+        {
+          type: 'string',
+          minLength: 3,
+        },
+        {
+          type: 'number',
+        },
+      ],
+    } satisfies JSONSchema7);
+  });
+
+  it('should be possible to deref union schemas', () => {
+    const recurring = z.object({ foo: z.boolean() });
+
+    const union = z.union([recurring, recurring, recurring]);
+
+    const jsonSchema = parseUnionDef(union._def, getRefs());
+
+    expect(jsonSchema).toStrictEqual({
+      anyOf: [
+        {
+          type: 'object',
+          properties: {
+            foo: {
+              type: 'boolean',
+            },
+          },
+          required: ['foo'],
+          additionalProperties: false,
+        },
+        {
+          $ref: '#/anyOf/0',
+        },
+        {
+          $ref: '#/anyOf/0',
+        },
+      ],
+    } satisfies JSONSchema7);
+  });
+
+  it('nullable primitives should come out fine', () => {
+    const union = z.union([z.string(), z.null()]);
+
+    const jsonSchema = parseUnionDef(union._def, getRefs());
+
+    expect(jsonSchema).toStrictEqual({
+      type: ['string', 'null'],
+    } satisfies JSONSchema7);
+  });
+
+  it('should join a union of Zod enums into a single enum', () => {
+    const union = z.union([z.enum(['a', 'b', 'c']), z.enum(['c', 'd', 'e'])]);
+
+    const jsonSchema = parseUnionDef(union._def, getRefs());
+
+    expect(jsonSchema).toStrictEqual({
+      type: 'string',
+      enum: ['a', 'b', 'c', 'd', 'e'],
+    } satisfies JSONSchema7);
+  });
+
+  it('should work with discriminated union type', () => {
+    const discUnion = z.discriminatedUnion('kek', [
+      z.object({ kek: z.literal('A'), lel: z.boolean() }),
+      z.object({ kek: z.literal('B'), lel: z.number() }),
+    ]);
+
+    const jsonSchema = parseUnionDef(discUnion._def, getRefs());
+
+    expect(jsonSchema).toStrictEqual({
+      anyOf: [
+        {
+          type: 'object',
+          properties: {
+            kek: {
+              type: 'string',
+              const: 'A',
+            },
+            lel: {
+              type: 'boolean',
+            },
+          },
+          required: ['kek', 'lel'],
+          additionalProperties: false,
+        },
+        {
+          type: 'object',
+          properties: {
+            kek: {
+              type: 'string',
+              const: 'B',
+            },
+            lel: {
+              type: 'number',
+            },
+          },
+          required: ['kek', 'lel'],
+          additionalProperties: false,
+        },
+      ],
+    } satisfies JSONSchema7);
+  });
+
+  it('should not ignore descriptions in literal unions', () => {
+    expect(
+      parseUnionDef(
+        z.union([z.literal(true), z.literal('herp'), z.literal(3)])._def,
+        getRefs(),
+      ),
+    ).toStrictEqual({
+      type: ['boolean', 'string', 'number'],
+      enum: [true, 'herp', 3],
+    } satisfies JSONSchema7);
+
+    expect(
+      parseUnionDef(
+        z.union([
+          z.literal(true),
+          z.literal('herp').describe('derp'),
+          z.literal(3),
+        ])._def,
+        getRefs(),
+      ),
+    ).toStrictEqual({
+      anyOf: [
+        { type: 'boolean', const: true },
+        { type: 'string', const: 'herp', description: 'derp' },
+        { type: 'number', const: 3 },
+      ],
+    } satisfies JSONSchema7);
+  });
+});

package/src/to-json-schema/zod3-to-json-schema/parsers/union.ts

@@ -0,0 +1,144 @@
+import {
+  ZodDiscriminatedUnionDef,
+  ZodLiteralDef,
+  ZodTypeAny,
+  ZodUnionDef,
+} from 'zod/v3';
+import { parseDef } from '../parse-def';
+import { JsonSchema7Type } from '../parse-types';
+import { Refs } from '../refs';
+
+export const primitiveMappings = {
+  ZodString: 'string',
+  ZodNumber: 'number',
+  ZodBigInt: 'integer',
+  ZodBoolean: 'boolean',
+  ZodNull: 'null',
+} as const;
+type ZodPrimitive = keyof typeof primitiveMappings;
+type JsonSchema7Primitive =
+  (typeof primitiveMappings)[keyof typeof primitiveMappings];
+
+export type JsonSchema7UnionType =
+  | JsonSchema7PrimitiveUnionType
+  | JsonSchema7AnyOfType;
+
+type JsonSchema7PrimitiveUnionType =
+  | {
+      type: JsonSchema7Primitive | JsonSchema7Primitive[];
+    }
+  | {
+      type: JsonSchema7Primitive | JsonSchema7Primitive[];
+      enum: (string | number | bigint | boolean | null)[];
+    };
+
+type JsonSchema7AnyOfType = {
+  anyOf: JsonSchema7Type[];
+};
+
+export function parseUnionDef(
+  def: ZodUnionDef | ZodDiscriminatedUnionDef<any, any>,
+  refs: Refs,
+): JsonSchema7PrimitiveUnionType | JsonSchema7AnyOfType | undefined {
+  const options: readonly ZodTypeAny[] =
+    def.options instanceof Map ? Array.from(def.options.values()) : def.options;
+
+  // This blocks tries to look ahead a bit to produce nicer looking schemas with type array instead of anyOf.
+  if (
+    options.every(
+      x =>
+        x._def.typeName in primitiveMappings &&
+        (!x._def.checks || !x._def.checks.length),
+    )
+  ) {
+    // all types in union are primitive and lack checks, so might as well squash into {type: [...]}
+
+    const types = options.reduce((types: JsonSchema7Primitive[], x) => {
+      const type = primitiveMappings[x._def.typeName as ZodPrimitive]; //Can be safely casted due to row 43
+      return type && !types.includes(type) ? [...types, type] : types;
+    }, []);
+
+    return {
+      type: types.length > 1 ? types : types[0],
+    };
+  } else if (
+    options.every(x => x._def.typeName === 'ZodLiteral' && !x.description)
+  ) {
+    // all options literals
+
+    const types = options.reduce(
+      (acc: JsonSchema7Primitive[], x: { _def: ZodLiteralDef }) => {
+        const type = typeof x._def.value;
+        switch (type) {
+          case 'string':
+          case 'number':
+          case 'boolean':
+            return [...acc, type];
+          case 'bigint':
+            return [...acc, 'integer' as const];
+          case 'object':
+            if (x._def.value === null) return [...acc, 'null' as const];
+          case 'symbol':
+          case 'undefined':
+          case 'function':
+          default:
+            return acc;
+        }
+      },
+      [],
+    );
+
+    if (types.length === options.length) {
+      // all the literals are primitive, as far as null can be considered primitive
+
+      const uniqueTypes = types.filter((x, i, a) => a.indexOf(x) === i);
+      return {
+        type: uniqueTypes.length > 1 ? uniqueTypes : uniqueTypes[0],
+        enum: options.reduce(
+          (acc, x) => {
+            return acc.includes(x._def.value) ? acc : [...acc, x._def.value];
+          },
+          [] as (string | number | bigint | boolean | null)[],
+        ),
+      };
+    }
+  } else if (options.every(x => x._def.typeName === 'ZodEnum')) {
+    return {
+      type: 'string',
+      enum: options.reduce(
+        (acc: string[], x) => [
+          ...acc,
+          ...x._def.values.filter((x: string) => !acc.includes(x)),
+        ],
+        [],
+      ),
+    };
+  }
+
+  return asAnyOf(def, refs);
+}
+
+const asAnyOf = (
+  def: ZodUnionDef | ZodDiscriminatedUnionDef<any, any>,
+  refs: Refs,
+): JsonSchema7PrimitiveUnionType | JsonSchema7AnyOfType | undefined => {
+  const anyOf = (
+    (def.options instanceof Map
+      ? Array.from(def.options.values())
+      : def.options) as any[]
+  )
+    .map((x, i) =>
+      parseDef(x._def, {
+        ...refs,
+        currentPath: [...refs.currentPath, 'anyOf', `${i}`],
+      }),
+    )
+    .filter(
+      (x): x is JsonSchema7Type =>
+        !!x &&
+        (!refs.strictUnions ||
+          (typeof x === 'object' && Object.keys(x).length > 0)),
+    );
+
+  return anyOf.length ? { anyOf } : undefined;
+};

package/src/to-json-schema/zod3-to-json-schema/parsers/unknown.ts

@@ -0,0 +1,7 @@
+import { JsonSchema7AnyType, parseAnyDef } from './any';
+
+export type JsonSchema7UnknownType = JsonSchema7AnyType;
+
+export function parseUnknownDef(): JsonSchema7UnknownType {
+  return parseAnyDef();
+}