@ai-sdk/provider-utils 4.0.4 → 4.0.6

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

@@ -0,0 +1,35 @@
+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/pipeline.ts

@@ -0,0 +1,29 @@
+import { ZodPipelineDef } from 'zod/v3';
+import { parseDef } from '../parse-def';
+import { JsonSchema7Type } from '../parse-types';
+import { Refs } from '../refs';
+import { JsonSchema7AllOfType } from './intersection';
+
+export const parsePipelineDef = (
+  def: ZodPipelineDef<any, any>,
+  refs: Refs,
+): JsonSchema7AllOfType | JsonSchema7Type | undefined => {
+  if (refs.pipeStrategy === 'input') {
+    return parseDef(def.in._def, refs);
+  } else if (refs.pipeStrategy === 'output') {
+    return parseDef(def.out._def, refs);
+  }
+
+  const a = parseDef(def.in._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, 'allOf', '0'],
+  });
+  const b = parseDef(def.out._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, 'allOf', a ? '1' : '0'],
+  });
+
+  return {
+    allOf: [a, b].filter((x): x is JsonSchema7Type => x !== undefined),
+  };
+};

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

@@ -0,0 +1,15 @@
+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/promise.ts

@@ -0,0 +1,11 @@
+import { ZodPromiseDef } from 'zod/v3';
+import { parseDef } from '../parse-def';
+import { JsonSchema7Type } from '../parse-types';
+import { Refs } from '../refs';
+
+export function parsePromiseDef(
+  def: ZodPromiseDef,
+  refs: Refs,
+): JsonSchema7Type | undefined {
+  return parseDef(def.type._def, refs);
+}

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

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

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

@@ -0,0 +1,7 @@
+import { ZodReadonlyDef } from 'zod/v3';
+import { parseDef } from '../parse-def';
+import { Refs } from '../refs';
+
+export const parseReadonlyDef = (def: ZodReadonlyDef<any>, refs: Refs) => {
+  return parseDef(def.innerType._def, refs);
+};

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

@@ -0,0 +1,108 @@
+import { describe, it, expect } from 'vitest';
+import { z } from 'zod/v3';
+import { parseRecordDef } from './record';
+import { getRefs } from '../refs';
+import { JSONSchema7 } from '@ai-sdk/provider';
+
+describe('record', () => {
+  it('should be possible to describe a simple record', () => {
+    const schema = z.record(z.number());
+
+    const parsedSchema = parseRecordDef(schema._def, getRefs());
+
+    expect(parsedSchema).toStrictEqual({
+      type: 'object',
+      additionalProperties: {
+        type: 'number',
+      },
+    } satisfies JSONSchema7);
+  });
+  it('should be possible to describe a simple record with a branded key', () => {
+    const schema = z.record(z.string().brand('MyBrand'), z.number());
+
+    const parsedSchema = parseRecordDef(schema._def, getRefs());
+
+    expect(parsedSchema).toStrictEqual({
+      type: 'object',
+      additionalProperties: {
+        type: 'number',
+      },
+    } satisfies JSONSchema7);
+  });
+
+  it('should be possible to describe a complex record with checks', () => {
+    const schema = z.record(
+      z.object({ foo: z.number().min(2) }).catchall(z.string().cuid()),
+    );
+
+    const parsedSchema = parseRecordDef(schema._def, getRefs());
+
+    expect(parsedSchema).toStrictEqual({
+      type: 'object',
+      additionalProperties: {
+        type: 'object',
+        properties: {
+          foo: {
+            type: 'number',
+            minimum: 2,
+          },
+        },
+        required: ['foo'],
+        additionalProperties: {
+          type: 'string',
+          pattern: '^[cC][^\\s-]{8,}$',
+        },
+      },
+    } satisfies JSONSchema7);
+  });
+
+  it('should be possible to describe a key schema', () => {
+    const schema = z.record(z.string().uuid(), z.number());
+
+    const parsedSchema = parseRecordDef(schema._def, getRefs());
+
+    expect(parsedSchema).toStrictEqual({
+      type: 'object',
+      additionalProperties: {
+        type: 'number',
+      },
+      propertyNames: {
+        format: 'uuid',
+      },
+    } satisfies JSONSchema7);
+  });
+
+  it('should be possible to describe a branded key schema', () => {
+    const schema = z.record(
+      z.string().regex(/.+/).brand('MyBrandedThingo'),
+      z.number(),
+    );
+
+    const parsedSchema = parseRecordDef(schema._def, getRefs());
+
+    expect(parsedSchema).toStrictEqual({
+      type: 'object',
+      additionalProperties: {
+        type: 'number',
+      },
+      propertyNames: {
+        pattern: '.+',
+      },
+    } satisfies JSONSchema7);
+  });
+
+  it('should be possible to describe a key with an enum', () => {
+    const schema = z.record(z.enum(['foo', 'bar']), z.number());
+    const parsedSchema = parseRecordDef(schema._def, getRefs());
+
+    expect(parsedSchema).toStrictEqual({
+      type: 'object',
+      additionalProperties: {
+        type: 'number',
+      },
+      propertyNames: {
+        enum: ['foo', 'bar'],
+      },
+    } satisfies JSONSchema7);
+  });
+});

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

@@ -0,0 +1,71 @@
+import {
+  ZodFirstPartyTypeKind,
+  ZodMapDef,
+  ZodRecordDef,
+  ZodTypeAny,
+} from 'zod/v3';
+import { parseDef } from '../parse-def';
+import { JsonSchema7Type } from '../parse-types';
+import { Refs } from '../refs';
+import { parseBrandedDef } from './branded';
+import { JsonSchema7EnumType } from './enum';
+import { JsonSchema7StringType, parseStringDef } from './string';
+
+type JsonSchema7RecordPropertyNamesType =
+  | Omit<JsonSchema7StringType, 'type'>
+  | Omit<JsonSchema7EnumType, 'type'>;
+
+export type JsonSchema7RecordType = {
+  type: 'object';
+  additionalProperties?: JsonSchema7Type | true;
+  propertyNames?: JsonSchema7RecordPropertyNamesType;
+};
+
+export function parseRecordDef(
+  def: ZodRecordDef<ZodTypeAny, ZodTypeAny> | ZodMapDef,
+  refs: Refs,
+): JsonSchema7RecordType {
+  const schema: JsonSchema7RecordType = {
+    type: 'object',
+    additionalProperties:
+      parseDef(def.valueType._def, {
+        ...refs,
+        currentPath: [...refs.currentPath, 'additionalProperties'],
+      }) ?? refs.allowedAdditionalProperties,
+  };
+
+  if (
+    def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodString &&
+    def.keyType._def.checks?.length
+  ) {
+    const { type, ...keyType } = parseStringDef(def.keyType._def, refs);
+
+    return {
+      ...schema,
+      propertyNames: keyType,
+    };
+  } else if (def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodEnum) {
+    return {
+      ...schema,
+      propertyNames: {
+        enum: def.keyType._def.values,
+      },
+    };
+  } else if (
+    def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodBranded &&
+    def.keyType._def.type._def.typeName === ZodFirstPartyTypeKind.ZodString &&
+    def.keyType._def.type._def.checks?.length
+  ) {
+    const { type, ...keyType } = parseBrandedDef(
+      def.keyType._def,
+      refs,
+    ) as JsonSchema7StringType;
+
+    return {
+      ...schema,
+      propertyNames: keyType,
+    };
+  }
+
+  return schema;
+}

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

@@ -0,0 +1,20 @@
+import { describe, it, expect } from 'vitest';
+import { JSONSchema7 } from '@ai-sdk/provider';
+import { z } from 'zod/v3';
+import { getRefs } from '../refs';
+import { parseSetDef } from './set';
+
+describe('set', () => {
+  it('should map set', () => {
+    const zodSchema = z.set(z.any()).min(5).max(10);
+    const jsonParsedSchema = parseSetDef(zodSchema._def, getRefs());
+
+    expect(jsonParsedSchema).toStrictEqual({
+      type: 'array',
+      minItems: 5,
+      maxItems: 10,
+      uniqueItems: true,
+      items: {},
+    } satisfies JSONSchema7);
+  });
+});

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

@@ -0,0 +1,35 @@
+import { ZodSetDef } from 'zod/v3';
+import { parseDef } from '../parse-def';
+import { JsonSchema7Type } from '../parse-types';
+import { Refs } from '../refs';
+
+export type JsonSchema7SetType = {
+  type: 'array';
+  uniqueItems: true;
+  items?: JsonSchema7Type;
+  minItems?: number;
+  maxItems?: number;
+};
+
+export function parseSetDef(def: ZodSetDef, refs: Refs): JsonSchema7SetType {
+  const items = parseDef(def.valueType._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, 'items'],
+  });
+
+  const schema: JsonSchema7SetType = {
+    type: 'array',
+    uniqueItems: true,
+    items,
+  };
+
+  if (def.minSize) {
+    schema.minItems = def.minSize.value;
+  }
+
+  if (def.maxSize) {
+    schema.maxItems = def.maxSize.value;
+  }
+
+  return schema;
+}