@ai-sdk/provider-utils 4.0.4 → 4.0.6

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

@@ -0,0 +1,97 @@
+import { describe, it, expect } from 'vitest';
+import { z } from 'zod/v3';
+import { parseDateDef } from './date';
+import { getRefs } from '../refs';
+import { JSONSchema7 } from '@ai-sdk/provider';
+
+describe('Date validations', it => {
+  it('should be possible to date as a string type', () => {
+    const zodDateSchema = z.date();
+    const parsedSchemaWithOption = parseDateDef(
+      zodDateSchema._def,
+      getRefs({ dateStrategy: 'string' }),
+    );
+    const parsedSchemaFromDefault = parseDateDef(zodDateSchema._def, getRefs());
+
+    const jsonSchema: JSONSchema7 = {
+      type: 'string',
+      format: 'date-time',
+    };
+
+    expect(parsedSchemaWithOption).toStrictEqual(jsonSchema);
+    expect(parsedSchemaFromDefault).toStrictEqual(jsonSchema);
+  });
+
+  it('should be possible to describe minimum date', () => {
+    const zodDateSchema = z
+      .date()
+      .min(new Date('1970-01-02'), { message: 'Too old' });
+    const parsedSchema = parseDateDef(
+      zodDateSchema._def,
+      getRefs({ dateStrategy: 'integer' }),
+    );
+
+    expect(parsedSchema).toStrictEqual({
+      type: 'integer',
+      format: 'unix-time',
+      minimum: 86400000,
+    } satisfies JSONSchema7);
+  });
+
+  it('should be possible to describe maximum date', () => {
+    const zodDateSchema = z.date().max(new Date('1970-01-02'));
+    const parsedSchema = parseDateDef(
+      zodDateSchema._def,
+      getRefs({ dateStrategy: 'integer' }),
+    );
+
+    expect(parsedSchema).toStrictEqual({
+      type: 'integer',
+      format: 'unix-time',
+      maximum: 86400000,
+    } satisfies JSONSchema7);
+  });
+
+  it('should be possible to describe both maximum and minimum date', () => {
+    const zodDateSchema = z
+      .date()
+      .min(new Date('1970-01-02'))
+      .max(new Date('1972-01-02'));
+    const parsedSchema = parseDateDef(
+      zodDateSchema._def,
+      getRefs({ dateStrategy: 'integer' }),
+    );
+
+    expect(parsedSchema).toStrictEqual({
+      type: 'integer',
+      format: 'unix-time',
+      minimum: 86400000,
+      maximum: 63158400000,
+    } satisfies JSONSchema7);
+  });
+
+  it('multiple choices of strategy should result in anyOf', () => {
+    const zodDateSchema = z.date();
+    const parsedSchema = parseDateDef(
+      zodDateSchema._def,
+      getRefs({ dateStrategy: ['format:date-time', 'format:date', 'integer'] }),
+    );
+
+    expect(parsedSchema).toStrictEqual({
+      anyOf: [
+        {
+          type: 'string',
+          format: 'date-time',
+        },
+        {
+          type: 'string',
+          format: 'date',
+        },
+        {
+          type: 'integer',
+          format: 'unix-time',
+        },
+      ],
+    } satisfies JSONSchema7);
+  });
+});

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

@@ -0,0 +1,64 @@
+import { ZodDateDef } from 'zod/v3';
+import { Refs } from '../refs';
+import { DateStrategy } from '../options';
+
+export type JsonSchema7DateType =
+  | {
+      type: 'integer' | 'string';
+      format: 'unix-time' | 'date-time' | 'date';
+      minimum?: number;
+      maximum?: number;
+    }
+  | {
+      anyOf: JsonSchema7DateType[];
+    };
+
+export function parseDateDef(
+  def: ZodDateDef,
+  refs: Refs,
+  overrideDateStrategy?: DateStrategy,
+): JsonSchema7DateType {
+  const strategy = overrideDateStrategy ?? refs.dateStrategy;
+
+  if (Array.isArray(strategy)) {
+    return {
+      anyOf: strategy.map((item, i) => parseDateDef(def, refs, item)),
+    };
+  }
+
+  switch (strategy) {
+    case 'string':
+    case 'format:date-time':
+      return {
+        type: 'string',
+        format: 'date-time',
+      };
+    case 'format:date':
+      return {
+        type: 'string',
+        format: 'date',
+      };
+    case 'integer':
+      return integerDateParser(def);
+  }
+}
+
+const integerDateParser = (def: ZodDateDef) => {
+  const res: JsonSchema7DateType = {
+    type: 'integer',
+    format: 'unix-time',
+  };
+
+  for (const check of def.checks) {
+    switch (check.kind) {
+      case 'min':
+        res.minimum = check.value;
+        break;
+      case 'max':
+        res.maximum = check.value;
+        break;
+    }
+  }
+
+  return res;
+};

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

@@ -0,0 +1,54 @@
+import { describe, it, expect } from 'vitest';
+import { z } from 'zod/v3';
+import { parseDefaultDef } from './default';
+import { getRefs } from '../refs';
+import { JSONSchema7 } from '@ai-sdk/provider';
+
+describe('default', () => {
+  it('should be possible to use default on objects', () => {
+    const parsedSchema = parseDefaultDef(
+      z.object({ foo: z.boolean() }).default({ foo: true })._def,
+      getRefs(),
+    );
+
+    expect(parsedSchema).toStrictEqual({
+      type: 'object',
+      additionalProperties: false,
+      required: ['foo'],
+      properties: {
+        foo: {
+          type: 'boolean',
+        },
+      },
+      default: {
+        foo: true,
+      },
+    } satisfies JSONSchema7);
+  });
+
+  it('should be possible to use default on primitives', () => {
+    const parsedSchema = parseDefaultDef(
+      z.string().default('default')._def,
+      getRefs(),
+    );
+
+    expect(parsedSchema).toStrictEqual({
+      type: 'string',
+      default: 'default',
+    } satisfies JSONSchema7);
+  });
+
+  it('default with transform', () => {
+    const stringWithDefault = z
+      .string()
+      .transform(val => val.toUpperCase())
+      .default('default');
+
+    const parsedSchema = parseDefaultDef(stringWithDefault._def, getRefs());
+
+    expect(parsedSchema).toStrictEqual({
+      type: 'string',
+      default: 'default',
+    } satisfies JSONSchema7);
+  });
+});

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

@@ -0,0 +1,14 @@
+import { ZodDefaultDef } from 'zod/v3';
+import { parseDef } from '../parse-def';
+import { JsonSchema7Type } from '../parse-types';
+import { Refs } from '../refs';
+
+export function parseDefaultDef(
+  _def: ZodDefaultDef,
+  refs: Refs,
+): JsonSchema7Type & { default: any } {
+  return {
+    ...parseDef(_def.innerType._def, refs),
+    default: _def.defaultValue(),
+  };
+}

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

@@ -0,0 +1,41 @@
+import { describe, it, expect, test } from 'vitest';
+import { z } from 'zod/v3';
+import { parseEffectsDef } from './effects';
+import { getRefs } from '../refs';
+import { JSONSchema7 } from '@ai-sdk/provider';
+
+describe('effects', () => {
+  it('should be possible to use refine', () => {
+    const parsedSchema = parseEffectsDef(
+      z.number().refine(x => x + 1)._def,
+      getRefs(),
+    );
+
+    expect(parsedSchema).toStrictEqual({
+      type: 'number',
+    } satisfies JSONSchema7);
+  });
+
+  it('should default to the input type', () => {
+    const schema = z.string().transform(arg => parseInt(arg));
+
+    const jsonSchema = parseEffectsDef(schema._def, getRefs());
+
+    expect(jsonSchema).toStrictEqual({
+      type: 'string',
+    } satisfies JSONSchema7);
+  });
+
+  test("should return object based on 'any' strategy", () => {
+    const schema = z.string().transform(arg => parseInt(arg));
+
+    const jsonSchema = parseEffectsDef(
+      schema._def,
+      getRefs({
+        effectStrategy: 'any',
+      }),
+    );
+
+    expect(jsonSchema).toStrictEqual({} satisfies JSONSchema7);
+  });
+});

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

@@ -0,0 +1,14 @@
+import { ZodEffectsDef } from 'zod/v3';
+import { parseDef } from '../parse-def';
+import { JsonSchema7Type } from '../parse-types';
+import { Refs } from '../refs';
+import { parseAnyDef } from './any';
+
+export function parseEffectsDef(
+  _def: ZodEffectsDef,
+  refs: Refs,
+): JsonSchema7Type | undefined {
+  return refs.effectStrategy === 'input'
+    ? parseDef(_def.schema._def, refs)
+    : parseAnyDef();
+}

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

@@ -0,0 +1,13 @@
+import { ZodEnumDef } from 'zod/v3';
+
+export type JsonSchema7EnumType = {
+  type: 'string';
+  enum: string[];
+};
+
+export function parseEnumDef(def: ZodEnumDef): JsonSchema7EnumType {
+  return {
+    type: 'string',
+    enum: Array.from(def.values),
+  };
+}

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

@@ -0,0 +1,92 @@
+import { describe, it, expect } from 'vitest';
+import { z } from 'zod/v3';
+import { parseIntersectionDef } from './intersection';
+import { getRefs } from '../refs';
+import { JSONSchema7 } from '@ai-sdk/provider';
+
+describe('intersection', () => {
+  it('should be possible to use intersections', () => {
+    const intersection = z.intersection(z.string().min(1), z.string().max(3));
+
+    const jsonSchema = parseIntersectionDef(intersection._def, getRefs());
+
+    expect(jsonSchema).toStrictEqual({
+      allOf: [
+        {
+          type: 'string',
+          minLength: 1,
+        },
+        {
+          type: 'string',
+          maxLength: 3,
+        },
+      ],
+    } satisfies JSONSchema7);
+  });
+
+  it('should be possible to deref intersections', () => {
+    const schema = z.string();
+    const intersection = z.intersection(schema, schema);
+    const jsonSchema = parseIntersectionDef(intersection._def, getRefs());
+
+    expect(jsonSchema).toStrictEqual({
+      allOf: [
+        {
+          type: 'string',
+        },
+        {
+          $ref: '#/allOf/0',
+        },
+      ],
+    } satisfies JSONSchema7);
+  });
+
+  it('should return `unevaluatedProperties` only if all of the multiple sub-schemas have additionalProperties set to false', () => {
+    const schema1 = z.object({
+      foo: z.string(),
+    });
+    const schema2 = z.object({
+      bar: z.string(),
+    });
+    const schema3 = z
+      .object({
+        baz: z.string(),
+      })
+      .passthrough();
+    const intersection = schema1.and(schema2).and(schema3);
+    const jsonSchema = parseIntersectionDef(intersection._def, getRefs());
+
+    expect(jsonSchema).toStrictEqual({
+      allOf: [
+        {
+          properties: {
+            foo: {
+              type: 'string',
+            },
+          },
+          required: ['foo'],
+          type: 'object',
+        },
+        {
+          properties: {
+            bar: {
+              type: 'string',
+            },
+          },
+          required: ['bar'],
+          type: 'object',
+        },
+        {
+          additionalProperties: true,
+          properties: {
+            baz: {
+              type: 'string',
+            },
+          },
+          required: ['baz'],
+          type: 'object',
+        },
+      ],
+    } satisfies JSONSchema7);
+  });
+});

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

@@ -0,0 +1,52 @@
+import { ZodIntersectionDef } from 'zod/v3';
+import { parseDef } from '../parse-def';
+import { JsonSchema7Type } from '../parse-types';
+import { Refs } from '../refs';
+import { JsonSchema7StringType } from './string';
+
+export type JsonSchema7AllOfType = {
+  allOf: JsonSchema7Type[];
+  unevaluatedProperties?: boolean;
+};
+
+const isJsonSchema7AllOfType = (
+  type: JsonSchema7Type | JsonSchema7StringType,
+): type is JsonSchema7AllOfType => {
+  if ('type' in type && type.type === 'string') return false;
+  return 'allOf' in type;
+};
+
+export function parseIntersectionDef(
+  def: ZodIntersectionDef,
+  refs: Refs,
+): JsonSchema7AllOfType | JsonSchema7Type | undefined {
+  const allOf = [
+    parseDef(def.left._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, 'allOf', '0'],
+    }),
+    parseDef(def.right._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, 'allOf', '1'],
+    }),
+  ].filter((x): x is JsonSchema7Type => !!x);
+
+  const mergedAllOf: JsonSchema7Type[] = [];
+  // If either of the schemas is an allOf, merge them into a single allOf
+  allOf.forEach(schema => {
+    if (isJsonSchema7AllOfType(schema)) {
+      mergedAllOf.push(...schema.allOf);
+    } else {
+      let nestedSchema: JsonSchema7Type = schema;
+      if (
+        'additionalProperties' in schema &&
+        schema.additionalProperties === false
+      ) {
+        const { additionalProperties, ...rest } = schema;
+        nestedSchema = rest;
+      }
+      mergedAllOf.push(nestedSchema);
+    }
+  });
+  return mergedAllOf.length ? { allOf: mergedAllOf } : undefined;
+}

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

@@ -0,0 +1,29 @@
+import { ZodLiteralDef } from 'zod/v3';
+
+export type JsonSchema7LiteralType =
+  | {
+      type: 'string' | 'number' | 'integer' | 'boolean';
+      const: string | number | boolean;
+    }
+  | {
+      type: 'object' | 'array';
+    };
+
+export function parseLiteralDef(def: ZodLiteralDef): JsonSchema7LiteralType {
+  const parsedType = typeof def.value;
+  if (
+    parsedType !== 'bigint' &&
+    parsedType !== 'number' &&
+    parsedType !== 'boolean' &&
+    parsedType !== 'string'
+  ) {
+    return {
+      type: Array.isArray(def.value) ? 'array' : 'object',
+    };
+  }
+
+  return {
+    type: parsedType === 'bigint' ? 'integer' : parsedType,
+    const: def.value,
+  };
+}

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

@@ -0,0 +1,48 @@
+import { describe, it, expect } from 'vitest';
+import { z } from 'zod/v3';
+import { parseMapDef } from './map';
+import { getRefs } from '../refs';
+import { JSONSchema7 } from '@ai-sdk/provider';
+
+describe('map', () => {
+  it('should be possible to use Map', () => {
+    const mapSchema = z.map(z.string(), z.number());
+
+    const parsedSchema = parseMapDef(mapSchema._def, getRefs());
+
+    expect(parsedSchema).toStrictEqual({
+      type: 'array',
+      maxItems: 125,
+      items: {
+        type: 'array',
+        items: [
+          {
+            type: 'string',
+          },
+          {
+            type: 'number',
+          },
+        ],
+        minItems: 2,
+        maxItems: 2,
+      },
+    } satisfies JSONSchema7);
+  });
+
+  it('should be possible to use additionalProperties-pattern (record)', () => {
+    expect(
+      parseMapDef(
+        z.map(z.string().min(1), z.number())._def,
+        getRefs({ mapStrategy: 'record' }),
+      ),
+    ).toStrictEqual({
+      type: 'object',
+      additionalProperties: {
+        type: 'number',
+      },
+      propertyNames: {
+        minLength: 1,
+      },
+    } satisfies JSONSchema7);
+  });
+});

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

@@ -0,0 +1,47 @@
+import { ZodMapDef } from 'zod/v3';
+import { parseDef } from '../parse-def';
+import { JsonSchema7Type } from '../parse-types';
+import { Refs } from '../refs';
+import { parseAnyDef } from './any';
+import { JsonSchema7RecordType, parseRecordDef } from './record';
+
+export type JsonSchema7MapType = {
+  type: 'array';
+  maxItems: 125;
+  items: {
+    type: 'array';
+    items: [JsonSchema7Type, JsonSchema7Type];
+    minItems: 2;
+    maxItems: 2;
+  };
+};
+
+export function parseMapDef(
+  def: ZodMapDef,
+  refs: Refs,
+): JsonSchema7MapType | JsonSchema7RecordType {
+  if (refs.mapStrategy === 'record') {
+    return parseRecordDef(def, refs);
+  }
+
+  const keys =
+    parseDef(def.keyType._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, 'items', 'items', '0'],
+    }) || parseAnyDef();
+  const values =
+    parseDef(def.valueType._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, 'items', 'items', '1'],
+    }) || parseAnyDef();
+  return {
+    type: 'array',
+    maxItems: 125,
+    items: {
+      type: 'array',
+      items: [keys, values],
+      minItems: 2,
+      maxItems: 2,
+    },
+  };
+}

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

@@ -0,0 +1,102 @@
+import { describe, it, expect } from 'vitest';
+import { z } from 'zod/v3';
+import { parseNativeEnumDef } from './native-enum';
+import { JSONSchema7 } from '@ai-sdk/provider';
+
+describe('native enum', () => {
+  it('should be possible to convert a basic native number enum', () => {
+    enum MyEnum {
+      val1,
+      val2,
+      val3,
+    }
+
+    const parsedSchema = parseNativeEnumDef(z.nativeEnum(MyEnum)._def);
+
+    expect(parsedSchema).toStrictEqual({
+      type: 'number',
+      enum: [0, 1, 2],
+    } satisfies JSONSchema7);
+  });
+
+  it('should be possible to convert a native string enum', () => {
+    enum MyEnum {
+      val1 = 'a',
+      val2 = 'b',
+      val3 = 'c',
+    }
+
+    const parsedSchema = parseNativeEnumDef(z.nativeEnum(MyEnum)._def);
+
+    expect(parsedSchema).toStrictEqual({
+      type: 'string',
+      enum: ['a', 'b', 'c'],
+    } satisfies JSONSchema7);
+  });
+
+  it('should be possible to convert a mixed value native enum', () => {
+    enum MyEnum {
+      val1 = 'a',
+      val2 = 1,
+      val3 = 'c',
+    }
+
+    const parsedSchema = parseNativeEnumDef(z.nativeEnum(MyEnum)._def);
+
+    expect(parsedSchema).toStrictEqual({
+      type: ['string', 'number'],
+      enum: ['a', 1, 'c'],
+    } satisfies JSONSchema7);
+  });
+
+  it('should be possible to convert a native const assertion object', () => {
+    const MyConstAssertionObject = {
+      val1: 0,
+      val2: 1,
+      val3: 2,
+    } as const;
+
+    const parsedSchema = parseNativeEnumDef(
+      z.nativeEnum(MyConstAssertionObject)._def,
+    );
+
+    expect(parsedSchema).toStrictEqual({
+      type: 'number',
+      enum: [0, 1, 2],
+    } satisfies JSONSchema7);
+  });
+
+  it('should be possible to convert a native const assertion string object', () => {
+    const MyConstAssertionObject = {
+      val1: 'a',
+      val2: 'b',
+      val3: 'c',
+    } as const;
+
+    const parsedSchema = parseNativeEnumDef(
+      z.nativeEnum(MyConstAssertionObject)._def,
+    );
+
+    expect(parsedSchema).toStrictEqual({
+      type: 'string',
+      enum: ['a', 'b', 'c'],
+    } satisfies JSONSchema7);
+  });
+
+  it('should be possible to convert a mixed value native const assertion string object', () => {
+    const MyConstAssertionObject = {
+      val1: 'a',
+      val2: 1,
+      val3: 'c',
+    } as const;
+
+    const parsedSchema = parseNativeEnumDef(
+      z.nativeEnum(MyConstAssertionObject)._def,
+    );
+
+    expect(parsedSchema).toStrictEqual({
+      type: ['string', 'number'],
+      enum: ['a', 1, 'c'],
+    } satisfies JSONSchema7);
+  });
+});