@depup/openai 6.31.0-depup.0

package/src/_vendor/zod-to-json-schema/Refs.ts

@@ -0,0 +1,47 @@
+import type { ZodTypeDef } from 'zod/v3';
+import { getDefaultOptions, Options, Targets } from './Options';
+import { JsonSchema7Type } from './parseDef';
+import { zodDef } from './util';
+
+export type Refs = {
+  seen: Map<ZodTypeDef, Seen>;
+  /**
+   * Set of all the `$ref`s we created, e.g. `Set(['#/$defs/ui'])`
+   * this notable does not include any `definitions` that were
+   * explicitly given as an option.
+   */
+  seenRefs: Set<string>;
+  currentPath: string[];
+  propertyPath: string[] | undefined;
+} & Options<Targets>;
+
+export type Seen = {
+  def: ZodTypeDef;
+  path: string[];
+  jsonSchema: JsonSchema7Type | undefined;
+};
+
+export const getRefs = (options?: string | Partial<Options<Targets>>): Refs => {
+  const _options = getDefaultOptions(options);
+  const currentPath =
+    _options.name !== undefined ?
+      [..._options.basePath, _options.definitionPath, _options.name]
+    : _options.basePath;
+  return {
+    ..._options,
+    currentPath: currentPath,
+    propertyPath: undefined,
+    seenRefs: new Set(),
+    seen: new Map(
+      Object.entries(_options.definitions).map(([name, def]) => [
+        zodDef(def),
+        {
+          def: zodDef(def),
+          path: [..._options.basePath, _options.definitionPath, name],
+          // Resolution of references will be forced even though seen, so it's ok that the schema is undefined here for now.
+          jsonSchema: undefined,
+        },
+      ]),
+    ),
+  };
+};

package/src/_vendor/zod-to-json-schema/errorMessages.ts

@@ -0,0 +1,31 @@
+import { JsonSchema7TypeUnion } from './parseDef';
+import { Refs } from './Refs';
+
+export type ErrorMessages<T extends JsonSchema7TypeUnion, OmitProperties extends string = ''> = Partial<
+  Omit<{ [key in keyof T]: string }, OmitProperties | 'type' | 'errorMessages'>
+>;
+
+export function addErrorMessage<T extends { errorMessage?: ErrorMessages<any> }>(
+  res: T,
+  key: keyof T,
+  errorMessage: string | undefined,
+  refs: Refs,
+) {
+  if (!refs?.errorMessages) return;
+  if (errorMessage) {
+    res.errorMessage = {
+      ...res.errorMessage,
+      [key]: errorMessage,
+    };
+  }
+}
+
+export function setResponseValueAndErrors<
+  Json7Type extends JsonSchema7TypeUnion & {
+    errorMessage?: ErrorMessages<Json7Type>;
+  },
+  Key extends keyof Omit<Json7Type, 'errorMessage'>,
+>(res: Json7Type, key: Key, value: Json7Type[Key], errorMessage: string | undefined, refs: Refs) {
+  res[key] = value;
+  addErrorMessage(res, key, errorMessage, refs);
+}

package/src/_vendor/zod-to-json-schema/index.ts

@@ -0,0 +1,37 @@
+export * from './Options';
+export * from './Refs';
+export * from './errorMessages';
+export * from './parseDef';
+export * from './parsers/any';
+export * from './parsers/array';
+export * from './parsers/bigint';
+export * from './parsers/boolean';
+export * from './parsers/branded';
+export * from './parsers/catch';
+export * from './parsers/date';
+export * from './parsers/default';
+export * from './parsers/effects';
+export * from './parsers/enum';
+export * from './parsers/intersection';
+export * from './parsers/literal';
+export * from './parsers/map';
+export * from './parsers/nativeEnum';
+export * from './parsers/never';
+export * from './parsers/null';
+export * from './parsers/nullable';
+export * from './parsers/number';
+export * from './parsers/object';
+export * from './parsers/optional';
+export * from './parsers/pipeline';
+export * from './parsers/promise';
+export * from './parsers/readonly';
+export * from './parsers/record';
+export * from './parsers/set';
+export * from './parsers/string';
+export * from './parsers/tuple';
+export * from './parsers/undefined';
+export * from './parsers/union';
+export * from './parsers/unknown';
+export * from './zodToJsonSchema';
+import { zodToJsonSchema } from './zodToJsonSchema';
+export default zodToJsonSchema;

package/src/_vendor/zod-to-json-schema/parseDef.ts

@@ -0,0 +1,258 @@
+import { ZodFirstPartyTypeKind, ZodTypeDef } from 'zod/v3';
+import { JsonSchema7AnyType, parseAnyDef } from './parsers/any';
+import { JsonSchema7ArrayType, parseArrayDef } from './parsers/array';
+import { JsonSchema7BigintType, parseBigintDef } from './parsers/bigint';
+import { JsonSchema7BooleanType, parseBooleanDef } from './parsers/boolean';
+import { parseBrandedDef } from './parsers/branded';
+import { parseCatchDef } from './parsers/catch';
+import { JsonSchema7DateType, parseDateDef } from './parsers/date';
+import { parseDefaultDef } from './parsers/default';
+import { parseEffectsDef } from './parsers/effects';
+import { JsonSchema7EnumType, parseEnumDef } from './parsers/enum';
+import { JsonSchema7AllOfType, parseIntersectionDef } from './parsers/intersection';
+import { JsonSchema7LiteralType, parseLiteralDef } from './parsers/literal';
+import { JsonSchema7MapType, parseMapDef } from './parsers/map';
+import { JsonSchema7NativeEnumType, parseNativeEnumDef } from './parsers/nativeEnum';
+import { JsonSchema7NeverType, parseNeverDef } from './parsers/never';
+import { JsonSchema7NullType, parseNullDef } from './parsers/null';
+import { JsonSchema7NullableType, parseNullableDef } from './parsers/nullable';
+import { JsonSchema7NumberType, parseNumberDef } from './parsers/number';
+import { JsonSchema7ObjectType, parseObjectDef } from './parsers/object';
+import { parseOptionalDef } from './parsers/optional';
+import { parsePipelineDef } from './parsers/pipeline';
+import { parsePromiseDef } from './parsers/promise';
+import { JsonSchema7RecordType, parseRecordDef } from './parsers/record';
+import { JsonSchema7SetType, parseSetDef } from './parsers/set';
+import { JsonSchema7StringType, parseStringDef } from './parsers/string';
+import { JsonSchema7TupleType, parseTupleDef } from './parsers/tuple';
+import { JsonSchema7UndefinedType, parseUndefinedDef } from './parsers/undefined';
+import { JsonSchema7UnionType, parseUnionDef } from './parsers/union';
+import { JsonSchema7UnknownType, parseUnknownDef } from './parsers/unknown';
+import { Refs, Seen } from './Refs';
+import { parseReadonlyDef } from './parsers/readonly';
+import { ignoreOverride } from './Options';
+
+type JsonSchema7RefType = { $ref: string };
+type JsonSchema7Meta = {
+  title?: string;
+  default?: any;
+  description?: string;
+  markdownDescription?: string;
+};
+
+export type JsonSchema7TypeUnion =
+  | JsonSchema7StringType
+  | JsonSchema7ArrayType
+  | JsonSchema7NumberType
+  | JsonSchema7BigintType
+  | JsonSchema7BooleanType
+  | JsonSchema7DateType
+  | JsonSchema7EnumType
+  | JsonSchema7LiteralType
+  | JsonSchema7NativeEnumType
+  | JsonSchema7NullType
+  | JsonSchema7NumberType
+  | JsonSchema7ObjectType
+  | JsonSchema7RecordType
+  | JsonSchema7TupleType
+  | JsonSchema7UnionType
+  | JsonSchema7UndefinedType
+  | JsonSchema7RefType
+  | JsonSchema7NeverType
+  | JsonSchema7MapType
+  | JsonSchema7AnyType
+  | JsonSchema7NullableType
+  | JsonSchema7AllOfType
+  | JsonSchema7UnknownType
+  | JsonSchema7SetType;
+
+export type JsonSchema7Type = JsonSchema7TypeUnion & JsonSchema7Meta;
+
+export function parseDef(
+  def: ZodTypeDef,
+  refs: Refs,
+  forceResolution = false, // Forces a new schema to be instantiated even though its def has been seen. Used for improving refs in definitions. See https://github.com/StefanTerdell/zod-to-json-schema/pull/61.
+): JsonSchema7Type | undefined {
+  const seenItem = refs.seen.get(def);
+
+  if (refs.override) {
+    const overrideResult = refs.override?.(def, refs, seenItem, forceResolution);
+
+    if (overrideResult !== ignoreOverride) {
+      return overrideResult;
+    }
+  }
+
+  if (seenItem && !forceResolution) {
+    const seenSchema = get$ref(seenItem, refs);
+
+    if (seenSchema !== undefined) {
+      if ('$ref' in seenSchema) {
+        refs.seenRefs.add(seenSchema.$ref);
+      }
+
+      return seenSchema;
+    }
+  }
+
+  const newItem: Seen = { def, path: refs.currentPath, jsonSchema: undefined };
+
+  refs.seen.set(def, newItem);
+
+  const jsonSchema = selectParser(def, (def as any).typeName, refs, forceResolution);
+
+  if (jsonSchema) {
+    addMeta(def, refs, jsonSchema);
+  }
+
+  newItem.jsonSchema = jsonSchema;
+
+  return jsonSchema;
+}
+
+const get$ref = (
+  item: Seen,
+  refs: Refs,
+):
+  | {
+      $ref: string;
+    }
+  | {}
+  | undefined => {
+  switch (refs.$refStrategy) {
+    case 'root':
+      return { $ref: item.path.join('/') };
+    // this case is needed as OpenAI strict mode doesn't support top-level `$ref`s, i.e.
+    // the top-level schema *must* be `{"type": "object", "properties": {...}}` but if we ever
+    // need to define a `$ref`, relative `$ref`s aren't supported, so we need to extract
+    // the schema to `#/definitions/` and reference that.
+    //
+    // e.g. if we need to reference a schema at
+    // `["#","definitions","contactPerson","properties","person1","properties","name"]`
+    // then we'll extract it out to `contactPerson_properties_person1_properties_name`
+    case 'extract-to-root':
+      const name = item.path.slice(refs.basePath.length + 1).join('_');
+
+      // we don't need to extract the root schema in this case, as it's already
+      // been added to the definitions
+      if (name !== refs.name && refs.nameStrategy === 'duplicate-ref') {
+        refs.definitions[name] = item.def;
+      }
+
+      return { $ref: [...refs.basePath, refs.definitionPath, name].join('/') };
+    case 'relative':
+      return { $ref: getRelativePath(refs.currentPath, item.path) };
+    case 'none':
+    case 'seen': {
+      if (
+        item.path.length < refs.currentPath.length &&
+        item.path.every((value, index) => refs.currentPath[index] === value)
+      ) {
+        console.warn(`Recursive reference detected at ${refs.currentPath.join('/')}! Defaulting to any`);
+
+        return {};
+      }
+
+      return refs.$refStrategy === 'seen' ? {} : undefined;
+    }
+  }
+};
+
+const getRelativePath = (pathA: string[], pathB: string[]) => {
+  let i = 0;
+  for (; i < pathA.length && i < pathB.length; i++) {
+    if (pathA[i] !== pathB[i]) break;
+  }
+  return [(pathA.length - i).toString(), ...pathB.slice(i)].join('/');
+};
+
+const selectParser = (
+  def: any,
+  typeName: ZodFirstPartyTypeKind,
+  refs: Refs,
+  forceResolution: boolean,
+): JsonSchema7Type | undefined => {
+  switch (typeName) {
+    case ZodFirstPartyTypeKind.ZodString:
+      return parseStringDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodNumber:
+      return parseNumberDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodObject:
+      return parseObjectDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodBigInt:
+      return parseBigintDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodBoolean:
+      return parseBooleanDef();
+    case ZodFirstPartyTypeKind.ZodDate:
+      return parseDateDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodUndefined:
+      return parseUndefinedDef();
+    case ZodFirstPartyTypeKind.ZodNull:
+      return parseNullDef(refs);
+    case ZodFirstPartyTypeKind.ZodArray:
+      return parseArrayDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodUnion:
+    case ZodFirstPartyTypeKind.ZodDiscriminatedUnion:
+      return parseUnionDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodIntersection:
+      return parseIntersectionDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodTuple:
+      return parseTupleDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodRecord:
+      return parseRecordDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodLiteral:
+      return parseLiteralDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodEnum:
+      return parseEnumDef(def);
+    case ZodFirstPartyTypeKind.ZodNativeEnum:
+      return parseNativeEnumDef(def);
+    case ZodFirstPartyTypeKind.ZodNullable:
+      return parseNullableDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodOptional:
+      return parseOptionalDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodMap:
+      return parseMapDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodSet:
+      return parseSetDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodLazy:
+      return parseDef(def.getter()._def, refs);
+    case ZodFirstPartyTypeKind.ZodPromise:
+      return parsePromiseDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodNaN:
+    case ZodFirstPartyTypeKind.ZodNever:
+      return parseNeverDef();
+    case ZodFirstPartyTypeKind.ZodEffects:
+      return parseEffectsDef(def, refs, forceResolution);
+    case ZodFirstPartyTypeKind.ZodAny:
+      return parseAnyDef();
+    case ZodFirstPartyTypeKind.ZodUnknown:
+      return parseUnknownDef();
+    case ZodFirstPartyTypeKind.ZodDefault:
+      return parseDefaultDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodBranded:
+      return parseBrandedDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodReadonly:
+      return parseReadonlyDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodCatch:
+      return parseCatchDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodPipeline:
+      return parsePipelineDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodFunction:
+    case ZodFirstPartyTypeKind.ZodVoid:
+    case ZodFirstPartyTypeKind.ZodSymbol:
+      return undefined;
+    default:
+      return ((_: never) => undefined)(typeName);
+  }
+};
+
+const addMeta = (def: ZodTypeDef, refs: Refs, jsonSchema: JsonSchema7Type): JsonSchema7Type => {
+  if (def.description) {
+    jsonSchema.description = def.description;
+
+    if (refs.markdownDescription) {
+      jsonSchema.markdownDescription = def.description;
+    }
+  }
+  return jsonSchema;
+};

package/src/_vendor/zod-to-json-schema/parsers/any.ts

@@ -0,0 +1,5 @@
+export type JsonSchema7AnyType = {};
+
+export function parseAnyDef(): JsonSchema7AnyType {
+  return {};
+}

package/src/_vendor/zod-to-json-schema/parsers/array.ts

@@ -0,0 +1,36 @@
+import { ZodArrayDef, ZodFirstPartyTypeKind } from 'zod/v3';
+import { ErrorMessages, setResponseValueAndErrors } from '../errorMessages';
+import { JsonSchema7Type, parseDef } from '../parseDef';
+import { Refs } from '../Refs';
+
+export type JsonSchema7ArrayType = {
+  type: 'array';
+  items?: JsonSchema7Type | undefined;
+  minItems?: number;
+  maxItems?: number;
+  errorMessages?: ErrorMessages<JsonSchema7ArrayType, 'items'>;
+};
+
+export function parseArrayDef(def: ZodArrayDef, refs: Refs) {
+  const res: JsonSchema7ArrayType = {
+    type: 'array',
+  };
+  if (def.type?._def?.typeName !== ZodFirstPartyTypeKind.ZodAny) {
+    res.items = parseDef(def.type._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, 'items'],
+    });
+  }
+
+  if (def.minLength) {
+    setResponseValueAndErrors(res, 'minItems', def.minLength.value, def.minLength.message, refs);
+  }
+  if (def.maxLength) {
+    setResponseValueAndErrors(res, 'maxItems', def.maxLength.value, def.maxLength.message, refs);
+  }
+  if (def.exactLength) {
+    setResponseValueAndErrors(res, 'minItems', def.exactLength.value, def.exactLength.message, refs);
+    setResponseValueAndErrors(res, 'maxItems', def.exactLength.value, def.exactLength.message, refs);
+  }
+  return res;
+}

package/src/_vendor/zod-to-json-schema/parsers/bigint.ts

@@ -0,0 +1,60 @@
+import { ZodBigIntDef } from 'zod/v3';
+import { Refs } from '../Refs';
+import { ErrorMessages, setResponseValueAndErrors } from '../errorMessages';
+
+export type JsonSchema7BigintType = {
+  type: 'integer';
+  format: 'int64';
+  minimum?: BigInt;
+  exclusiveMinimum?: BigInt;
+  maximum?: BigInt;
+  exclusiveMaximum?: BigInt;
+  multipleOf?: BigInt;
+  errorMessage?: ErrorMessages<JsonSchema7BigintType>;
+};
+
+export function parseBigintDef(def: ZodBigIntDef, refs: Refs): JsonSchema7BigintType {
+  const res: JsonSchema7BigintType = {
+    type: 'integer',
+    format: 'int64',
+  };
+
+  if (!def.checks) return res;
+
+  for (const check of def.checks) {
+    switch (check.kind) {
+      case 'min':
+        if (refs.target === 'jsonSchema7') {
+          if (check.inclusive) {
+            setResponseValueAndErrors(res, 'minimum', check.value, check.message, refs);
+          } else {
+            setResponseValueAndErrors(res, 'exclusiveMinimum', check.value, check.message, refs);
+          }
+        } else {
+          if (!check.inclusive) {
+            res.exclusiveMinimum = true as any;
+          }
+          setResponseValueAndErrors(res, 'minimum', check.value, check.message, refs);
+        }
+        break;
+      case 'max':
+        if (refs.target === 'jsonSchema7') {
+          if (check.inclusive) {
+            setResponseValueAndErrors(res, 'maximum', check.value, check.message, refs);
+          } else {
+            setResponseValueAndErrors(res, 'exclusiveMaximum', check.value, check.message, refs);
+          }
+        } else {
+          if (!check.inclusive) {
+            res.exclusiveMaximum = true as any;
+          }
+          setResponseValueAndErrors(res, 'maximum', check.value, check.message, refs);
+        }
+        break;
+      case 'multipleOf':
+        setResponseValueAndErrors(res, 'multipleOf', check.value, check.message, refs);
+        break;
+    }
+  }
+  return res;
+}

package/src/_vendor/zod-to-json-schema/parsers/boolean.ts

@@ -0,0 +1,9 @@
+export type JsonSchema7BooleanType = {
+  type: 'boolean';
+};
+
+export function parseBooleanDef(): JsonSchema7BooleanType {
+  return {
+    type: 'boolean',
+  };
+}

package/src/_vendor/zod-to-json-schema/parsers/branded.ts

@@ -0,0 +1,7 @@
+import { ZodBrandedDef } from 'zod/v3';
+import { parseDef } from '../parseDef';
+import { Refs } from '../Refs';
+
+export function parseBrandedDef(_def: ZodBrandedDef<any>, refs: Refs) {
+  return parseDef(_def.type._def, refs);
+}

package/src/_vendor/zod-to-json-schema/parsers/catch.ts

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

package/src/_vendor/zod-to-json-schema/parsers/date.ts

@@ -0,0 +1,83 @@
+import { ZodDateDef } from 'zod/v3';
+import { Refs } from '../Refs';
+import { ErrorMessages, setResponseValueAndErrors } from '../errorMessages';
+import { JsonSchema7NumberType } from './number';
+import { DateStrategy } from '../Options';
+
+export type JsonSchema7DateType =
+  | {
+      type: 'integer' | 'string';
+      format: 'unix-time' | 'date-time' | 'date';
+      minimum?: number;
+      maximum?: number;
+      errorMessage?: ErrorMessages<JsonSchema7NumberType>;
+    }
+  | {
+      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, refs);
+  }
+}
+
+const integerDateParser = (def: ZodDateDef, refs: Refs) => {
+  const res: JsonSchema7DateType = {
+    type: 'integer',
+    format: 'unix-time',
+  };
+
+  if (refs.target === 'openApi3') {
+    return res;
+  }
+
+  for (const check of def.checks) {
+    switch (check.kind) {
+      case 'min':
+        setResponseValueAndErrors(
+          res,
+          'minimum',
+          check.value, // This is in milliseconds
+          check.message,
+          refs,
+        );
+        break;
+      case 'max':
+        setResponseValueAndErrors(
+          res,
+          'maximum',
+          check.value, // This is in milliseconds
+          check.message,
+          refs,
+        );
+        break;
+    }
+  }
+
+  return res;
+};

package/src/_vendor/zod-to-json-schema/parsers/default.ts

@@ -0,0 +1,10 @@
+import { ZodDefaultDef } from 'zod/v3';
+import { JsonSchema7Type, parseDef } from '../parseDef';
+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/_vendor/zod-to-json-schema/parsers/effects.ts

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

package/src/_vendor/zod-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: [...def.values],
+  };
+}