Merge pull request #481 from traversable/json-schema-refs

feat(json-schema,json-schema-types): adds support for recursive refs

Author: ahrjarrett

.changeset/olive-comics-tease.md

@@ -0,0 +1,7 @@
+---
+"@traversable/json-schema-types": patch
+"@traversable/json-schema-test": patch
+"@traversable/json-schema": patch
+---
+
+feat(json-schema,json-schema-types): adds support for recursive refs for `JsonSchema.toType` and `JsonSchema.check`

.changeset/olive-pens-happen.md

@@ -0,0 +1,6 @@
+---
+"@traversable/json-schema-types": patch
+"@traversable/json-schema": patch
+---
+
+break(json-schema,json-schema-types): renames `canonicalizeRefName` to `canonizeRefName`

.changeset/spicy-falcons-study.md

@@ -0,0 +1,9 @@
+---
+"@traversable/json-schema-types": patch
+"@traversable/json-schema-test": patch
+"@traversable/arktype-test": patch
+"@traversable/json-schema": patch
+"@traversable/arktype": patch
+---
+
+feat(json-schema,json-schema-types): adds `JsonSchema.deepClone` support for $ref nodes

.changeset/thick-sheep-do.md

@@ -0,0 +1,11 @@
+---
+"@traversable/json-schema-types": patch
+"@traversable/json-schema-test": patch
+"@traversable/arktype-test": patch
+"@traversable/json-schema": patch
+"@traversable/arktype": patch
+---
+
+break(json-schema,json-schema-test,json-schema-types): renames `JsonSchema.Union` to `JsonSchema.AnyOf` and `JsonSchema.Intersection` to `JsonSchema.AllOf`
+
+feat(json-schema,json-schema-test,json-schema-types): adds `JsonSchema.OneOf`

.changeset/yummy-geckos-allow.md

@@ -0,0 +1,7 @@
+---
+"@traversable/json-schema-types": patch
+"@traversable/json-schema-test": patch
+"@traversable/json-schema": patch
+---
+
+feat(json-schema,json-schema-types): adds `JsonSchema.deepEqual` support for $ref nodes

package.json

@@ -57,5 +57,5 @@
     "typescript": "catalog:",
     "vitest": "catalog:"
   },
-  "packageManager": "pnpm@10.14.0"
+  "packageManager": "pnpm@10.15.1"
 }

packages/arktype-test/src/generator-options.ts

@@ -85,7 +85,7 @@ export type Constraints = {
   date?: {}
   enum?: {}
   // int?: { min: undefined | number, max: undefined | number, multipleOf?: number } & fc.IntegerConstraints
-  intersection?: {}
+  allOf?: {}
   literal?: {}
   never?: {}
   null?: {}
@@ -97,7 +97,8 @@ export type Constraints = {
   symbol?: {}
   tuple?: fc.ArrayConstraints
   undefined?: {}
-  union?: fc.ArrayConstraints
+  anyOf?: fc.ArrayConstraints
+  oneOf?: fc.ArrayConstraints
   unknown?: {}
   ['*']?: fc.OneOfConstraints
 }
@@ -143,7 +144,7 @@ export const defaultConstraints = {
   //   max: undefined,
   //   multipleOf: Number.NaN,
   // },
-  intersection: {},
+  allOf: {},
   literal: {},
   never: {},
   null: {},
@@ -179,7 +180,13 @@ export const defaultConstraints = {
     depthIdentifier: fc.createDepthIdentifier(),
   } satisfies fc.ArrayConstraints,
   undefined: {},
-  union: {
+  anyOf: {
+    depthIdentifier: fc.createDepthIdentifier(),
+    minLength: 1,
+    maxLength: 3,
+    size: 'xsmall',
+  } satisfies fc.ArrayConstraints,
+  oneOf: {
     depthIdentifier: fc.createDepthIdentifier(),
     minLength: 1,
     maxLength: 3,
@@ -236,7 +243,7 @@ export function parseOptions(options: Options<any> = defaults as never): Config
     //   min: intMin,
     //   // ...INT
     // } = defaultConstraints.int,
-    intersection = defaultConstraints.intersection,
+    allOf = defaultConstraints.allOf,
     literal = defaultConstraints.literal,
     never = defaultConstraints.never,
     null: null_ = defaultConstraints.null,
@@ -267,12 +274,18 @@ export function parseOptions(options: Options<any> = defaults as never): Config
       ...TUPLE
     } = defaultConstraints.tuple,
     undefined: undefined_ = defaultConstraints.undefined,
-    union: {
-      minLength: unionMinLength = defaultConstraints.union.minLength,
-      maxLength: unionMaxLength = defaultConstraints.union.maxLength,
-      size: unionSize = defaultConstraints.union.size,
-      ...UNION
-    } = defaultConstraints.union,
+    anyOf: {
+      minLength: anyOfMinLength = defaultConstraints.anyOf.minLength,
+      maxLength: anyOfMaxLength = defaultConstraints.anyOf.maxLength,
+      size: anyOfSize = defaultConstraints.anyOf.size,
+      ...ANY_OF
+    } = defaultConstraints.anyOf,
+    oneOf: {
+      minLength: oneOfMinLength = defaultConstraints.oneOf.minLength,
+      maxLength: oneOfMaxLength = defaultConstraints.oneOf.maxLength,
+      size: oneOfSize = defaultConstraints.oneOf.size,
+      ...ONE_OF
+    } = defaultConstraints.oneOf,
     unknown = defaultConstraints.unknown,
     object: {
       maxKeys: objectMaxKeys = defaultConstraints.object.maxKeys,
@@ -321,7 +334,7 @@ export function parseOptions(options: Options<any> = defaults as never): Config
     //   max: intMax,
     //   min: intMin,
     // },
-    intersection,
+    allOf,
     literal,
     never,
     null: null_,
@@ -351,11 +364,17 @@ export function parseOptions(options: Options<any> = defaults as never): Config
       maxLength: tupleMaxLength,
     },
     undefined: undefined_,
-    union: {
-      ...UNION,
-      minLength: unionMinLength,
-      maxLength: unionMaxLength,
-      size: unionSize,
+    anyOf: {
+      ...ANY_OF,
+      minLength: anyOfMinLength,
+      maxLength: anyOfMaxLength,
+      size: anyOfSize,
+    },
+    oneOf: {
+      ...ONE_OF,
+      minLength: oneOfMinLength,
+      maxLength: oneOfMaxLength,
+      size: oneOfSize,
     },
     unknown,
   }

packages/arktype-test/src/generator-seed.ts

@@ -23,11 +23,12 @@ export const byTag = {
   literal: 550,
   array: 1000,
   optional: 2500,
-  intersection: 6000,
+  allOf: 6000,
   record: 7000,
   object: 7500,
   tuple: 8000,
-  union: 8500,
+  anyOf: 8500,
+  oneOf: 9000,
 } as const satisfies Record<AnyTypeName, number>
 
 export function invert<T extends Record<keyof any, keyof any>>(x: T): { [K in keyof T as T[K]]: K }
@@ -62,9 +63,9 @@ export declare namespace Seed {
     | Seed.Record<T>
     | Seed.Object<T>
     | Seed.Tuple<T>
-    | Seed.Union<T>
-    // | Seed.Optional<T>
-    | Seed.Intersection<T>
+    | Seed.AnyOf<T>
+    | Seed.OneOf<T>
+    | Seed.AllOf<T>
 
   interface Free extends T.HKT { [-1]: Seed.F<this[0]> }
   ////////////////
@@ -115,9 +116,9 @@ export declare namespace Seed {
     record: Seed.Record<T>
     object: Seed.Object<T>
     tuple: Seed.Tuple<T>
-    union: Seed.Union<T>
-    // optional: Seed.Optional<T>
-    intersection: Seed.Intersection<T>
+    anyOf: Seed.AnyOf<T>
+    oneOf: Seed.OneOf<T>
+    allOf: Seed.AllOf<T>
   }
   type Composite =
     | Seed.Array
@@ -139,12 +140,13 @@ export declare namespace Seed {
   ////////////////
   /// applicative
   interface Object<T = unknown> extends newtype<[seed: byTag['object'], def: [K: string, V: T][]]> {}
-  interface Union<T = unknown> extends newtype<[seed: byTag['union'], def: T[]]> {}
+  interface AnyOf<T = unknown> extends newtype<[seed: byTag['anyOf'], def: T[]]> {}
+  interface OneOf<T = unknown> extends newtype<[seed: byTag['oneOf'], def: T[]]> {}
   interface Tuple<T = unknown> extends newtype<[seed: byTag['tuple'], def: T[]]> {}
   ////////////////
   /// binary
   interface Record<T = unknown> extends newtype<[seed: byTag['record'], def: T]> {}
-  interface Intersection<T = unknown> extends newtype<[seed: byTag['intersection'], def: [A: T, B: T]]> {}
+  interface AllOf<T = unknown> extends newtype<[seed: byTag['allOf'], def: [A: T, B: T]]> {}
 }
 
 export const Functor: T.Functor.Ix<boolean, Seed.Free, Seed.F<unknown>> = {
@@ -166,11 +168,12 @@ export const Functor: T.Functor.Ix<boolean, Seed.Free, Seed.F<unknown>> = {
         case x[0] === byTag.literal: return x
         case x[0] === byTag.array: return [x[0], f(x[1]), x[2]]
         // case x[0] === byTag.optional: return [x[0], f(x[1])]
-        case x[0] === byTag.intersection: return [x[0], [f(x[1][0]), f(x[1][1])]]
+        case x[0] === byTag.allOf: return [x[0], [f(x[1][0]), f(x[1][1])]]
         case x[0] === byTag.record: return [x[0], f(x[1])]
         case x[0] === byTag.object: return [x[0], x[1].map(([k, v]) => [k, f(v)] satisfies [any, any])]
         case x[0] === byTag.tuple: return [x[0], x[1].map(f)]
-        case x[0] === byTag.union: return [x[0], x[1].map(f)]
+        case x[0] === byTag.anyOf: return [x[0], x[1].map(f)]
+        case x[0] === byTag.oneOf: return [x[0], x[1].map(f)]
       }
     }
   },
@@ -192,9 +195,10 @@ export const Functor: T.Functor.Ix<boolean, Seed.Free, Seed.F<unknown>> = {
         case x[0] === byTag.literal: return x
         case x[0] === byTag.array: return [x[0], f(x[1], false, x), x[2]]
         // case x[0] === byTag.optional: return [x[0], f(x[1], isProperty, x)]
-        case x[0] === byTag.intersection: return [x[0], [f(x[1][0], false, x), f(x[1][1], false, x)]]
+        case x[0] === byTag.allOf: return [x[0], [f(x[1][0], false, x), f(x[1][1], false, x)]]
         case x[0] === byTag.record: return [x[0], f(x[1], false, x)]
-        case x[0] === byTag.union: return [x[0], x[1].map((_) => f(_, false, x))]
+        case x[0] === byTag.anyOf: return [x[0], x[1].map((_) => f(_, false, x))]
+        case x[0] === byTag.oneOf: return [x[0], x[1].map((_) => f(_, false, x))]
         case x[0] === byTag.tuple: return [x[0], x[1].map((_) => f(_, true, x))]
         case x[0] === byTag.object: return [x[0], x[1].map(([k, v]) => [k, f(v, true, x)] satisfies [any, any])]
       }

packages/arktype-test/src/generator.ts

@@ -4,7 +4,6 @@ import * as fc from 'fast-check'
 import type { newtype, inline } from '@traversable/registry'
 import {
   Array_isArray,
-  escape,
   fn,
   getRandomElementOf,
   isKeyOf,
@@ -101,8 +100,9 @@ const UnaryMap = {
     fc.uniqueArray(fc.tuple(identifier, tie('*')), $)
   ),
   tuple: (tie, $) => fc.tuple(fc.constant(byTag.tuple), fc.array(tie('*'), $)),
-  union: (tie, $) => fc.tuple(fc.constant(byTag.union), fc.array(tie('*'), $)),
-  intersection: (tie) => entries(tie('*'), { minLength: 2 }).map(fn.flow(
+  anyOf: (tie, $) => fc.tuple(fc.constant(byTag.anyOf), fc.array(tie('*'), $)),
+  oneOf: (tie, $) => fc.tuple(fc.constant(byTag.oneOf), fc.array(tie('*'), $)),
+  allOf: (tie) => entries(tie('*'), { minLength: 2 }).map(fn.flow(
     (xs) => pair(
       xs.slice(0, Math.ceil(xs.length / 2)),
       xs.slice(Math.ceil(xs.length / 2)),
@@ -111,7 +111,7 @@ const UnaryMap = {
       pair(byTag.object, l),
       pair(byTag.object, r),
     ),
-    (both) => pair(byTag.intersection, both),
+    (both) => pair(byTag.allOf, both),
   )),
 } satisfies { [K in keyof Seed.UnaryMap<never>]: SeedBuilder<K> }
 
@@ -327,9 +327,10 @@ const GeneratorByTag = {
   // optional: (x, _$, isProperty) => isProperty ? x[1] : fc.option(x[1], { nil: undefined }),
   record: (x) => fc.dictionary(fc.string(), x[1]),
   tuple: (x) => fc.tuple(...x[1]),
-  union: (x) => fc.oneof(...(x[1] || [fc.constant(void 0 as never)])),
+  anyOf: (x) => fc.oneof(...(x[1] || [fc.constant(void 0 as never)])),
+  oneOf: (x) => fc.oneof(...(x[1] || [fc.constant(void 0 as never)])),
   object: (x) => fc.record(Object_fromEntries(x[1]), { requiredKeys: x[1].filter(([k]) => !k.endsWith('?')).map(([k]) => k) }),
-  intersection: (x) => fc.tuple(...x[1]).map(([x, y]) => intersect(x, y)),
+  allOf: (x) => fc.tuple(...x[1]).map(([x, y]) => intersect(x, y)),
 } satisfies {
   [K in keyof Seed]: (x: Seed<fc.Arbitrary<unknown>>[K], $: Config<never>, isProperty: boolean) => fc.Arbitrary<unknown>
 }
@@ -565,10 +566,11 @@ export function seedToSchema<T>(seed: Seed.F<T>) {
       case x[0] === byTag.enum: return type.enumerated(...Object_values(x[1]))
       case x[0] === byTag.array: return x[1].array()
       // case x[0] === byTag.optional: return x[1]
-      case x[0] === byTag.intersection: return x[1].reduce((l, r) => l.and(r))
+      case x[0] === byTag.allOf: return x[1].reduce((l, r) => l.and(r))
       case x[0] === byTag.record: return type.Record(type.string, x[1])
       case x[0] === byTag.tuple: return type(x[1] as [])
-      case x[0] === byTag.union: return x[1].reduce((l, r) => l.or(r))
+      case x[0] === byTag.anyOf: return x[1].reduce((l, r) => l.or(r))
+      case x[0] === byTag.oneOf: return x[1].reduce((l, r) => l.or(r))
       case x[0] === byTag.object: return type(Object_fromEntries(x[1]))
       case x[0] === byTag.literal: return type(
         // typeof x[1] === 'string' ? `"${escape(x[1])}"` : (typeof x[1] === 'bigint' ? `${x[1]}n` : `${x[1]}`) as '""'

packages/arktype-test/src/typename.ts

@@ -14,8 +14,9 @@ export const TypeName = {
   record: 'record',
   unknown: 'unknown',
   never: 'never',
-  intersection: 'intersection',
-  union: 'union',
+  allOf: 'allOf',
+  anyOf: 'anyOf',
+  oneOf: 'oneOf',
   enum: 'enum',
   literal: 'literal',
   // bigint: 'bigint',