@ai-sdk/provider-utils 4.0.7 → 4.0.9

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

@@ -1,48 +0,0 @@
-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/native-enum.test.ts

@@ -1,102 +0,0 @@
-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);
-  });
-});

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

@@ -1,67 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { z } from 'zod/v3';
-import { parseObjectDef } from './object';
-import { getRefs } from '../refs';
-import { JSONSchema7 } from '@ai-sdk/provider';
-
-describe('nullable', () => {
-  it('should be possible to properly reference nested nullable primitives', () => {
-    const nullablePrimitive = z.string().nullable();
-
-    const schema = z.object({
-      one: nullablePrimitive,
-      two: nullablePrimitive,
-    });
-
-    const jsonSchema: any = parseObjectDef(schema._def, getRefs());
-
-    expect(jsonSchema).toStrictEqual({
-      additionalProperties: false,
-      type: 'object',
-      properties: {
-        one: { type: ['string', 'null'] },
-        two: { $ref: '#/properties/one' },
-      },
-      required: ['one', 'two'],
-    } satisfies JSONSchema7);
-  });
-
-  it('should be possible to properly reference nested nullable primitives', () => {
-    const three = z.string();
-
-    const nullableObject = z
-      .object({
-        three,
-      })
-      .nullable();
-
-    const schema = z.object({
-      one: nullableObject,
-      two: nullableObject,
-      three,
-    });
-
-    const jsonSchema: any = parseObjectDef(schema._def, getRefs());
-
-    expect(jsonSchema).toStrictEqual({
-      type: 'object',
-      properties: {
-        one: {
-          anyOf: [
-            {
-              type: 'object',
-              additionalProperties: false,
-              required: ['three'],
-              properties: { three: { type: 'string' } },
-            },
-            { type: 'null' },
-          ],
-        },
-        two: { $ref: '#/properties/one' },
-        three: { $ref: '#/properties/one/anyOf/0/properties/three' },
-      },
-      required: ['one', 'two', 'three'],
-      additionalProperties: false,
-    } satisfies JSONSchema7);
-  });
-});

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

@@ -1,65 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { JSONSchema7 } from '@ai-sdk/provider';
-import { z } from 'zod/v3';
-import { parseNumberDef } from './number';
-
-describe('number', () => {
-  it('should be possible to describe minimum number', () => {
-    const parsedSchema = parseNumberDef(z.number().min(5)._def);
-
-    expect(parsedSchema).toStrictEqual({
-      type: 'number',
-      minimum: 5,
-    } satisfies JSONSchema7);
-  });
-
-  it('should be possible to describe maximum number', () => {
-    const parsedSchema = parseNumberDef(z.number().max(5)._def);
-
-    expect(parsedSchema).toStrictEqual({
-      type: 'number',
-      maximum: 5,
-    } satisfies JSONSchema7);
-  });
-
-  it('should be possible to describe both minimum and maximum number', () => {
-    const parsedSchema = parseNumberDef(z.number().min(5).max(5)._def);
-
-    expect(parsedSchema).toStrictEqual({
-      type: 'number',
-      minimum: 5,
-      maximum: 5,
-    } satisfies JSONSchema7);
-  });
-
-  it('should be possible to describe an integer', () => {
-    const parsedSchema = parseNumberDef(z.number().int()._def);
-
-    expect(parsedSchema).toStrictEqual({
-      type: 'integer',
-    } satisfies JSONSchema7);
-  });
-
-  it('should be possible to describe multiples of n', () => {
-    const parsedSchema = parseNumberDef(z.number().multipleOf(2)._def);
-
-    expect(parsedSchema).toStrictEqual({
-      type: 'number',
-      multipleOf: 2,
-    } satisfies JSONSchema7);
-  });
-
-  it('should be possible to describe positive, negative, nonpositive and nonnegative numbers', () => {
-    const parsedSchema = parseNumberDef(
-      z.number().positive().negative().nonpositive().nonnegative()._def,
-    );
-
-    expect(parsedSchema).toStrictEqual({
-      type: 'number',
-      minimum: 0,
-      maximum: 0,
-      exclusiveMaximum: 0,
-      exclusiveMinimum: 0,
-    } satisfies JSONSchema7);
-  });
-});

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

@@ -1,149 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { z } from 'zod/v3';
-import { parseObjectDef } from './object';
-import { getRefs } from '../refs';
-import { JSONSchema7 } from '@ai-sdk/provider';
-
-describe('object', () => {
-  it('should be possible to describe catchAll schema', () => {
-    const schema = z
-      .object({ normalProperty: z.string() })
-      .catchall(z.boolean());
-
-    const parsedSchema = parseObjectDef(schema._def, getRefs());
-
-    expect(parsedSchema).toStrictEqual({
-      type: 'object',
-      properties: {
-        normalProperty: { type: 'string' },
-      },
-      required: ['normalProperty'],
-      additionalProperties: {
-        type: 'boolean',
-      },
-    } satisfies JSONSchema7);
-  });
-
-  it('should be possible to use selective partial', () => {
-    const schema = z
-      .object({ foo: z.boolean(), bar: z.number() })
-      .partial({ foo: true });
-
-    const parsedSchema = parseObjectDef(schema._def, getRefs());
-
-    expect(parsedSchema).toStrictEqual({
-      type: 'object',
-      properties: {
-        foo: { type: 'boolean' },
-        bar: { type: 'number' },
-      },
-      required: ['bar'],
-      additionalProperties: false,
-    } satisfies JSONSchema7);
-  });
-
-  it('should allow additional properties unless strict when removeAdditionalStrategy is strict', () => {
-    const schema = z.object({ foo: z.boolean(), bar: z.number() });
-
-    const parsedSchema = parseObjectDef(
-      schema._def,
-      getRefs({ removeAdditionalStrategy: 'strict' }),
-    );
-
-    expect(parsedSchema).toStrictEqual({
-      type: 'object',
-      properties: {
-        foo: { type: 'boolean' },
-        bar: { type: 'number' },
-      },
-      required: ['foo', 'bar'],
-      additionalProperties: true,
-    } satisfies JSONSchema7);
-
-    const strictSchema = z
-      .object({ foo: z.boolean(), bar: z.number() })
-      .strict();
-
-    const parsedStrictSchema = parseObjectDef(
-      strictSchema._def,
-      getRefs({ removeAdditionalStrategy: 'strict' }),
-    );
-
-    expect(parsedStrictSchema).toStrictEqual({
-      type: 'object',
-      properties: {
-        foo: { type: 'boolean' },
-        bar: { type: 'number' },
-      },
-      required: ['foo', 'bar'],
-      additionalProperties: false,
-    } satisfies JSONSchema7);
-  });
-
-  it('should allow additional properties with catchall when removeAdditionalStrategy is strict', () => {
-    const schema = z
-      .object({ foo: z.boolean(), bar: z.number() })
-      .catchall(z.boolean());
-
-    const parsedSchema = parseObjectDef(
-      schema._def,
-      getRefs({ removeAdditionalStrategy: 'strict' }),
-    );
-
-    expect(parsedSchema).toStrictEqual({
-      type: 'object',
-      properties: {
-        foo: { type: 'boolean' },
-        bar: { type: 'number' },
-      },
-      required: ['foo', 'bar'],
-      additionalProperties: {
-        type: 'boolean',
-      },
-    } satisfies JSONSchema7);
-  });
-
-  it('should be possible to not set additionalProperties at all when allowed', () => {
-    const schema = z
-      .object({ foo: z.boolean(), bar: z.number() })
-      .passthrough();
-
-    const parsedSchema = parseObjectDef(
-      schema._def,
-      getRefs({
-        removeAdditionalStrategy: 'passthrough',
-        allowedAdditionalProperties: undefined,
-      }),
-    );
-
-    expect(parsedSchema).toStrictEqual({
-      type: 'object',
-      properties: {
-        foo: { type: 'boolean' },
-        bar: { type: 'number' },
-      },
-      required: ['foo', 'bar'],
-    } satisfies JSONSchema7);
-  });
-
-  it('should be possible to not set additionalProperties at all when rejected', () => {
-    const schema = z.object({ foo: z.boolean(), bar: z.number() }).strict();
-
-    const parsedSchema = parseObjectDef(
-      schema._def,
-      getRefs({
-        removeAdditionalStrategy: 'passthrough',
-        rejectedAdditionalProperties: undefined,
-      }),
-    );
-
-    expect(parsedSchema).toStrictEqual({
-      type: 'object',
-      properties: {
-        foo: { type: 'boolean' },
-        bar: { type: 'number' },
-      },
-      required: ['foo', 'bar'],
-    } satisfies JSONSchema7);
-  });
-});

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

@@ -1,147 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { z } from 'zod/v3';
-import { parseDef } from '../parse-def';
-import { getRefs } from '../refs';
-import { JSONSchema7 } from '@ai-sdk/provider';
-
-describe('Standalone optionals', () => {
-  it('should work as unions with undefined', () => {
-    const parsedSchema = parseDef(z.string().optional()._def, getRefs());
-
-    expect(parsedSchema).toStrictEqual({
-      anyOf: [
-        {
-          not: {},
-        },
-        {
-          type: 'string',
-        },
-      ],
-    } satisfies JSONSchema7);
-  });
-
-  it('should work as unions with void', () => {
-    const parsedSchema = parseDef(z.void().optional()._def, getRefs());
-
-    expect(parsedSchema).toStrictEqual({} satisfies JSONSchema7);
-  });
-
-  it('should not affect object properties', () => {
-    const parsedSchema = parseDef(
-      z.object({ myProperty: z.string().optional() })._def,
-      getRefs(),
-    );
-
-    expect(parsedSchema).toStrictEqual({
-      type: 'object',
-      properties: {
-        myProperty: {
-          type: 'string',
-        },
-      },
-      additionalProperties: false,
-    } satisfies JSONSchema7);
-  });
-
-  it('should work with nested properties', () => {
-    const parsedSchema = parseDef(
-      z.object({ myProperty: z.string().optional().array() })._def,
-      getRefs(),
-    );
-
-    expect(parsedSchema).toStrictEqual({
-      type: 'object',
-      properties: {
-        myProperty: {
-          type: 'array',
-          items: {
-            anyOf: [{ not: {} }, { type: 'string' }],
-          },
-        },
-      },
-      required: ['myProperty'],
-      additionalProperties: false,
-    } satisfies JSONSchema7);
-  });
-
-  it('should work with nested properties as object properties', () => {
-    const parsedSchema = parseDef(
-      z.object({
-        myProperty: z.object({ myInnerProperty: z.string().optional() }),
-      })._def,
-      getRefs(),
-    );
-
-    expect(parsedSchema).toStrictEqual({
-      type: 'object',
-      properties: {
-        myProperty: {
-          type: 'object',
-          properties: {
-            myInnerProperty: {
-              type: 'string',
-            },
-          },
-          additionalProperties: false,
-        },
-      },
-      required: ['myProperty'],
-      additionalProperties: false,
-    } satisfies JSONSchema7);
-  });
-
-  it('should work with nested properties with nested object property parents', () => {
-    const parsedSchema = parseDef(
-      z.object({
-        myProperty: z.object({
-          myInnerProperty: z.string().optional().array(),
-        }),
-      })._def,
-      getRefs(),
-    );
-
-    expect(parsedSchema).toStrictEqual({
-      type: 'object',
-      properties: {
-        myProperty: {
-          type: 'object',
-          properties: {
-            myInnerProperty: {
-              type: 'array',
-              items: {
-                anyOf: [
-                  { not: {} },
-                  {
-                    type: 'string',
-                  },
-                ],
-              },
-            },
-          },
-          required: ['myInnerProperty'],
-          additionalProperties: false,
-        },
-      },
-      required: ['myProperty'],
-      additionalProperties: false,
-    } satisfies JSONSchema7);
-  });
-
-  it('should work with ref pathing', () => {
-    const recurring = z.string();
-
-    const schema = z.tuple([recurring.optional(), recurring]);
-
-    const parsedSchema = parseDef(schema._def, getRefs());
-
-    expect(parsedSchema).toStrictEqual({
-      type: 'array',
-      minItems: 2,
-      maxItems: 2,
-      items: [
-        { anyOf: [{ not: {} }, { type: 'string' }] },
-        { $ref: '#/items/0/anyOf/1' },
-      ],
-    } satisfies JSONSchema7);
-  });
-});

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

@@ -1,35 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { z } from 'zod/v3';
-import { parsePipelineDef } from './pipeline';
-import { getRefs } from '../refs';
-import { JSONSchema7 } from '@ai-sdk/provider';
-
-describe('pipe', () => {
-  it('Should create an allOf schema with all its inner schemas represented', () => {
-    const schema = z.number().pipe(z.number().int());
-
-    expect(parsePipelineDef(schema._def, getRefs())).toStrictEqual({
-      allOf: [{ type: 'number' }, { type: 'integer' }],
-    } satisfies JSONSchema7);
-  });
-
-  it('Should parse the input schema if that strategy is selected', () => {
-    const schema = z.number().pipe(z.number().int());
-
-    expect(
-      parsePipelineDef(schema._def, getRefs({ pipeStrategy: 'input' })),
-    ).toStrictEqual({
-      type: 'number',
-    } satisfies JSONSchema7);
-  });
-
-  it('Should parse the output schema (last schema in pipe) if that strategy is selected', () => {
-    const schema = z.string().pipe(z.date()).pipe(z.number().int());
-
-    expect(
-      parsePipelineDef(schema._def, getRefs({ pipeStrategy: 'output' })),
-    ).toStrictEqual({
-      type: 'integer',
-    } satisfies JSONSchema7);
-  });
-});

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

@@ -1,15 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { z } from 'zod/v3';
-import { parsePromiseDef } from './promise';
-import { getRefs } from '../refs';
-import { JSONSchema7 } from '@ai-sdk/provider';
-
-describe('promise', () => {
-  it('should be possible to use promise', () => {
-    const parsedSchema = parsePromiseDef(z.promise(z.string())._def, getRefs());
-
-    expect(parsedSchema).toStrictEqual({
-      type: 'string',
-    } satisfies JSONSchema7);
-  });
-});

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

@@ -1,20 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { z } from 'zod/v3';
-import { parseReadonlyDef } from './readonly';
-import { getRefs } from '../refs';
-import { JSONSchema7 } from '@ai-sdk/provider';
-
-describe('readonly', () => {
-  it('should be possible to use readonly', () => {
-    const parsedSchema = parseReadonlyDef(
-      z.object({}).readonly()._def,
-      getRefs(),
-    );
-
-    expect(parsedSchema).toStrictEqual({
-      type: 'object',
-      properties: {},
-      additionalProperties: false,
-    } satisfies JSONSchema7);
-  });
-});