@x0k/json-schema-merge 1.0.3 → 1.0.5

package/src/lib/json-schema/compare/compare.ts

@@ -0,0 +1,343 @@
+import type {
+  JSONSchema7Type as SchemaValue,
+  JSONSchema7TypeName as SchemaType,
+  JSONSchema7Definition,
+  JSONSchema7,
+  JSONSchema7Object,
+} from "json-schema";
+
+import { type Comparator, ascComparator } from "../../ord.ts";
+import {
+  createArrayComparator,
+  createDeduplicator,
+  isArrayEmpty,
+} from "../../array.ts";
+import { isRecordEmpty } from "../../object.ts";
+import { weakMemoize } from "../../memoize.ts";
+
+import { isAllowAnySchema, isSchemaObject } from "../json-schema.ts";
+
+const zero = () => 0;
+const isUndefined = <T>(v: T | undefined): v is undefined => v === undefined;
+
+type SchemaPrimitiveTypeExceptNullType = Extract<
+  SchemaType,
+  "string" | "number" | "boolean"
+>;
+type SchemaPrimitiveTypeExceptNull = string | number | boolean;
+
+const isSchemaPrimitiveExceptNull = (
+  value: Exclude<SchemaValue, null>
+): value is SchemaPrimitiveTypeExceptNull => typeof value !== "object";
+
+const PRIMITIVE_TYPE_ORDER: Record<
+  SchemaPrimitiveTypeExceptNullType,
+  0 | 1 | 2
+> = {
+  boolean: 0,
+  number: 1,
+  string: 2,
+};
+
+function compareSchemaPrimitive(
+  a: SchemaPrimitiveTypeExceptNull,
+  b: SchemaPrimitiveTypeExceptNull
+) {
+  const ta = typeof a as SchemaPrimitiveTypeExceptNullType;
+  const tb = typeof b as SchemaPrimitiveTypeExceptNullType;
+  return ta === tb
+    ? ascComparator(a, b)
+    : PRIMITIVE_TYPE_ORDER[ta] - PRIMITIVE_TYPE_ORDER[tb];
+}
+
+function insertUniqueValues<K>(mutableTarget: K[], mutableSource: K[]): K[] {
+  const tl = mutableTarget.length;
+  if (tl === 0) return mutableSource;
+  const sl = mutableSource.length;
+  if (sl === 0) return mutableTarget;
+  if (sl > tl) {
+    const t = mutableTarget;
+    mutableTarget = mutableSource;
+    mutableSource = t;
+  }
+  const seen = new Set(mutableTarget);
+  const l = mutableSource.length;
+  for (let i = 0; i < l; i++) {
+    const key = mutableSource[i]!;
+    if (!seen.has(key)) {
+      mutableTarget.push(key);
+    }
+  }
+  return mutableTarget;
+}
+
+function createCmpMatcher<T, E extends T>(
+  isEmpty: (v: T) => v is E,
+  compare: Comparator<Exclude<T, E>>,
+  compareEmpty: Comparator<E> = zero
+) {
+  return (a: T, b: T) => {
+    if (isEmpty(a)) {
+      if (isEmpty(b)) {
+        return compareEmpty(a, b);
+      }
+      return -1;
+    }
+    if (isEmpty(b)) {
+      return 1;
+    }
+    return compare(a as Exclude<T, E>, b as Exclude<T, E>);
+  };
+}
+
+function createOptionalComparator<T>(compare: Comparator<T>) {
+  return createCmpMatcher<T | undefined, undefined>(isUndefined, compare);
+}
+
+function createNarrowingOptionalComparator<T, E extends T>(
+  isEmpty: (v: T) => v is E,
+  compare: Comparator<Exclude<T, E | undefined>>
+) {
+  return createCmpMatcher<T | undefined, E | undefined>(
+    (v: T | undefined): v is undefined | E => v === undefined || isEmpty(v),
+    compare
+  );
+}
+
+function createArrayOrItemComparator<T, T1>(
+  compare: Comparator<T>,
+  compareArray: Comparator<T1[]>
+) {
+  return createCmpMatcher<T | T1[], T1[]>(Array.isArray, compare, compareArray);
+}
+
+const compareOptionalSameTypeSchemaPrimitives =
+  createOptionalComparator(ascComparator);
+
+const compareNumbersWithZeroDefault = createNarrowingOptionalComparator(
+  (v: number): v is 0 => v === 0,
+  (a, b) => a - b
+);
+
+export interface ComparatorOptions {
+  deduplicationCache?: WeakMap<any[], any[]>;
+  sortedKeysCache?: WeakMap<Record<string, any>, string[]>;
+}
+
+export function createComparator({
+  deduplicationCache = new WeakMap(),
+  sortedKeysCache = new WeakMap(),
+}: ComparatorOptions = {}) {
+  const getSortedKeys = weakMemoize(sortedKeysCache, (obj) =>
+    Object.keys(obj).sort()
+  );
+
+  function createRecordsComparator<R extends Record<string, any>>(
+    compare: <K extends keyof R>(a: R[K], b: R[K]) => number
+  ) {
+    return (a: R, b: R) => {
+      const aKeys = getSortedKeys(a);
+      const bKeys = getSortedKeys(b);
+      const l = Math.min(aKeys.length, bKeys.length);
+      for (let i = 0; i < l; i++) {
+        const cmp = ascComparator(aKeys[i]!, bKeys[i]!);
+        if (cmp !== 0) {
+          return cmp;
+        }
+      }
+      if (aKeys.length !== bKeys.length) {
+        return aKeys.length - bKeys.length;
+      }
+      for (let i = 0; i < l; i++) {
+        const key = aKeys[i]!;
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+        const cmp = compare(a[key], b[key]);
+        if (cmp !== 0) {
+          return cmp;
+        }
+      }
+      return 0;
+    };
+  }
+
+  function createArrayComparatorWithDeduplication<T>(compare: Comparator<T>) {
+    const cmp = createArrayComparator(compare);
+    const deduplicate = weakMemoize(
+      deduplicationCache as WeakMap<T[], T[]>,
+      // NOTE: Always sort output
+      createDeduplicator(compare, { threshold: 0 })
+    );
+    return (a: T[], b: T[]) => cmp(deduplicate(a), deduplicate(b));
+  }
+
+  const compareArrayOfSameTypePrimitivesWithDeduplication =
+    createArrayComparatorWithDeduplication(ascComparator);
+
+  function compareSchemaDefinitions(
+    a: JSONSchema7Definition,
+    b: JSONSchema7Definition
+  ) {
+    if (isSchemaObject(a)) {
+      if (isSchemaObject(b)) {
+        const aKeys = Object.keys(a) as (keyof JSONSchema7)[];
+        const bKeys = Object.keys(b) as (keyof JSONSchema7)[];
+        const allKeys = insertUniqueValues(aKeys, bKeys);
+        const l = allKeys.length;
+        for (let i = 0; i < l; i++) {
+          const key = allKeys[i]!;
+          if (a[key] === b[key]) {
+            continue;
+          }
+          const cmp = COMPARATORS[key] ?? compareOptionalSchemaValues;
+          const d = cmp(a[key] as undefined, b[key] as undefined);
+          if (d !== 0) {
+            return d;
+          }
+        }
+        return 0;
+      }
+      return b === true && isRecordEmpty(a) ? 0 : 1;
+    }
+    if (isSchemaObject(b)) {
+      return a === true && isRecordEmpty(b) ? 0 : -1;
+    }
+    return ascComparator(a, b);
+  }
+
+  const compareOptionalSchemaValues =
+    createOptionalComparator(compareSchemaValues);
+
+  const compareNonNullSchemaValue = createCmpMatcher(
+    isSchemaPrimitiveExceptNull,
+    createArrayOrItemComparator(
+      createRecordsComparator<JSONSchema7Object>(compareOptionalSchemaValues),
+      createArrayComparator(compareSchemaValues)
+    ),
+    compareSchemaPrimitive
+  );
+
+  function compareSchemaValues(a: SchemaValue, b: SchemaValue): number {
+    if (a === null) {
+      return -1;
+    }
+    if (b === null) {
+      return 1;
+    }
+    return compareNonNullSchemaValue(a, b);
+  }
+
+  const compareOptionalSchemaDefinitions = createOptionalComparator(
+    compareSchemaDefinitions
+  );
+
+  const compareRecordOfOptionalSchemasWithEmptyRecordDefault =
+    createNarrowingOptionalComparator(
+      isRecordEmpty,
+      createRecordsComparator<Record<string, JSONSchema7Definition>>(
+        compareOptionalSchemaDefinitions
+      )
+    );
+
+  const compareOptionalArrayOfSchemasWithDeduplication =
+    createOptionalComparator(
+      createArrayComparatorWithDeduplication(compareSchemaDefinitions)
+    );
+
+  const compareSchemaDefinitionsWithEmptyDefinitionDefault =
+    createNarrowingOptionalComparator(
+      isAllowAnySchema,
+      compareSchemaDefinitions
+    );
+
+  const COMPARATORS: {
+    [K in keyof JSONSchema7]-?: Comparator<JSONSchema7[K]>;
+  } = {
+    $id: compareOptionalSameTypeSchemaPrimitives,
+    $comment: compareOptionalSameTypeSchemaPrimitives,
+    $defs: compareRecordOfOptionalSchemasWithEmptyRecordDefault,
+    $ref: compareOptionalSameTypeSchemaPrimitives,
+    $schema: compareOptionalSameTypeSchemaPrimitives,
+    const: compareOptionalSchemaValues,
+    contains: compareOptionalSchemaDefinitions,
+    contentEncoding: compareOptionalSameTypeSchemaPrimitives,
+    contentMediaType: compareOptionalSameTypeSchemaPrimitives,
+    default: compareOptionalSchemaValues,
+    definitions: compareRecordOfOptionalSchemasWithEmptyRecordDefault,
+    description: compareOptionalSameTypeSchemaPrimitives,
+    else: compareOptionalSchemaDefinitions,
+    examples: compareOptionalSchemaValues,
+    exclusiveMaximum: compareOptionalSameTypeSchemaPrimitives,
+    exclusiveMinimum: compareOptionalSameTypeSchemaPrimitives,
+    format: compareOptionalSameTypeSchemaPrimitives,
+    if: compareOptionalSchemaDefinitions,
+    maximum: compareOptionalSameTypeSchemaPrimitives,
+    maxItems: compareOptionalSameTypeSchemaPrimitives,
+    maxLength: compareOptionalSameTypeSchemaPrimitives,
+    maxProperties: compareOptionalSameTypeSchemaPrimitives,
+    minimum: compareOptionalSameTypeSchemaPrimitives,
+    multipleOf: compareOptionalSameTypeSchemaPrimitives,
+    not: compareOptionalSchemaDefinitions,
+    pattern: compareOptionalSameTypeSchemaPrimitives,
+    propertyNames: compareOptionalSchemaDefinitions,
+    readOnly: compareOptionalSameTypeSchemaPrimitives,
+    then: compareOptionalSchemaDefinitions,
+    title: compareOptionalSameTypeSchemaPrimitives,
+    writeOnly: compareOptionalSameTypeSchemaPrimitives,
+    uniqueItems: createNarrowingOptionalComparator(
+      (v): v is false => v === false,
+      zero
+    ),
+    minLength: compareNumbersWithZeroDefault,
+    minItems: compareNumbersWithZeroDefault,
+    minProperties: compareNumbersWithZeroDefault,
+    required: createNarrowingOptionalComparator(
+      isArrayEmpty,
+      compareArrayOfSameTypePrimitivesWithDeduplication
+    ),
+    enum: createNarrowingOptionalComparator(
+      isArrayEmpty,
+      createArrayComparatorWithDeduplication(compareSchemaValues)
+    ),
+    type: createOptionalComparator((a, b) => {
+      const isAArr = Array.isArray(a);
+      const isBArr = Array.isArray(b);
+      if (!isAArr && !isBArr) {
+        return ascComparator(a, b);
+      }
+      return compareArrayOfSameTypePrimitivesWithDeduplication(
+        isAArr ? a : [a],
+        isBArr ? b : [b]
+      );
+    }),
+    items: createNarrowingOptionalComparator(
+      (v): v is true | JSONSchema7 => !Array.isArray(v) && isAllowAnySchema(v),
+      createArrayOrItemComparator(
+        compareSchemaDefinitions,
+        createArrayComparator(compareSchemaDefinitions)
+      )
+    ),
+    anyOf: compareOptionalArrayOfSchemasWithDeduplication,
+    allOf: compareOptionalArrayOfSchemasWithDeduplication,
+    oneOf: compareOptionalArrayOfSchemasWithDeduplication,
+    properties: compareRecordOfOptionalSchemasWithEmptyRecordDefault,
+    patternProperties: compareRecordOfOptionalSchemasWithEmptyRecordDefault,
+    additionalProperties: compareSchemaDefinitionsWithEmptyDefinitionDefault,
+    additionalItems: compareSchemaDefinitionsWithEmptyDefinitionDefault,
+    dependencies: createNarrowingOptionalComparator(
+      isRecordEmpty,
+      createRecordsComparator(
+        createOptionalComparator(
+          createArrayOrItemComparator(
+            compareSchemaDefinitions,
+            compareArrayOfSameTypePrimitivesWithDeduplication
+          )
+        )
+      )
+    ),
+  };
+
+  return {
+    compareSchemaValues,
+    compareSchemaDefinitions,
+  };
+}

package/src/lib/json-schema/compare/index.ts

@@ -0,0 +1 @@
+export * from "./compare.ts";

package/src/lib/json-schema/index.ts

@@ -0,0 +1,5 @@
+export * from "./json-schema.ts";
+export * from "./transform.ts";
+export * from "./traverse.ts";
+export * from "./compare/index.ts";
+export * from "./merge/index.ts";

package/src/lib/json-schema/json-schema.ts

@@ -0,0 +1,113 @@
+import type {
+  JSONSchema7,
+  JSONSchema7TypeName,
+  JSONSchema7Definition,
+} from "json-schema";
+
+import { isRecordEmpty } from "../object.ts";
+
+export const JSON_SCHEMA_TYPE_NAMES: string[] = [
+  "array",
+  "boolean",
+  "integer",
+  "null",
+  "number",
+  "object",
+  "string",
+] as const satisfies JSONSchema7TypeName[];
+
+export const SET_OF_JSON_SCHEMA_TYPE_NAMES = new Set(JSON_SCHEMA_TYPE_NAMES);
+
+export function isJsonSchemaType(type: string): type is JSONSchema7TypeName {
+  return SET_OF_JSON_SCHEMA_TYPE_NAMES.has(type);
+}
+
+type SchemaKeys = Array<keyof JSONSchema7>;
+
+// WARN: Order is important
+export const RECORDS_OF_SUB_SCHEMAS = [
+  "$defs",
+  "definitions",
+  "properties",
+  "patternProperties",
+  "dependencies",
+] as const satisfies SchemaKeys;
+
+export const SET_OF_RECORDS_OF_SUB_SCHEMAS = new Set(RECORDS_OF_SUB_SCHEMAS);
+
+export type SubSchemasRecordKey = (typeof RECORDS_OF_SUB_SCHEMAS)[number];
+
+// WARN: Order is important
+export const ARRAYS_OF_SUB_SCHEMAS = [
+  "items",
+  "allOf",
+  "oneOf",
+  "anyOf",
+] as const satisfies SchemaKeys;
+
+export const SET_OF_ARRAYS_OF_SUB_SCHEMAS = new Set(ARRAYS_OF_SUB_SCHEMAS);
+
+export type SubSchemasArrayKey = (typeof ARRAYS_OF_SUB_SCHEMAS)[number];
+
+// WARN: Order is important
+export const SUB_SCHEMAS = [
+  "items",
+  "additionalItems",
+  "additionalProperties",
+  "propertyNames",
+  "contains",
+  "if",
+  "then",
+  "else",
+  "not",
+] as const satisfies SchemaKeys;
+
+export const SET_OF_SUB_SCHEMAS = new Set(SUB_SCHEMAS);
+
+export type SubSchemaKey = (typeof SUB_SCHEMAS)[number];
+
+// WARN: Order is important
+export const ALL_SUB_SCHEMA_KEYS = [
+  ...RECORDS_OF_SUB_SCHEMAS,
+  ...ARRAYS_OF_SUB_SCHEMAS,
+  ...SUB_SCHEMAS,
+];
+
+export type AnySubSchemaKey = (typeof ALL_SUB_SCHEMA_KEYS)[number];
+
+export type TransformedSchema<R, S> = Omit<S, AnySubSchemaKey> & {
+  items?: R | R[] | undefined;
+  additionalItems?: R | undefined;
+  contains?: R | undefined;
+  additionalProperties?: R | undefined;
+  propertyNames?: R | undefined;
+  if?: R | undefined;
+  then?: R | undefined;
+  else?: R | undefined;
+  not?: R | undefined;
+  // Records
+  $defs?: Record<string, R> | undefined;
+  properties?: Record<string, R> | undefined;
+  patternProperties?: Record<string, R> | undefined;
+  dependencies?: Record<string, R | string[]> | undefined;
+  definitions?: Record<string, R> | undefined;
+  // Arrays
+  allOf?: R[] | undefined;
+  anyOf?: R[] | undefined;
+  oneOf?: R[] | undefined;
+};
+
+export type TransformedSchemaDefinition<R, S> =
+  TransformedSchema<R, S> | boolean;
+
+export function isSchemaObject<D extends JSONSchema7Definition>(
+  schemaDef: D
+): schemaDef is Exclude<D, boolean> {
+  return typeof schemaDef === "object";
+}
+
+export function isAllowAnySchema(
+  def: JSONSchema7Definition
+): def is true | Record<string, never> {
+  return isSchemaObject(def) ? isRecordEmpty(def) : def === true;
+}

package/src/lib/json-schema/merge/all-of-merge.ts

@@ -0,0 +1,44 @@
+import type { JSONSchema7Definition } from "json-schema";
+
+import { transformSchemaDefinition } from "../transform.ts";
+
+function getAllOfSchemas(
+  schema: JSONSchema7Definition
+): JSONSchema7Definition[] {
+  const result: JSONSchema7Definition[] = [];
+  const stack: JSONSchema7Definition[] = [schema];
+  while (stack.length > 0) {
+    const current = stack.pop()!;
+    if (typeof current === "boolean" || current.allOf === undefined) {
+      result.push(current);
+      continue;
+    }
+    const { allOf, ...rest } = current;
+    result.push(rest);
+    for (let i = allOf.length - 1; i >= 0; i--) {
+      stack.push(allOf[i]!);
+    }
+  }
+  return result;
+}
+
+export function createShallowAllOfMerge(
+  mergeArrayOfSchemaDefinitions: (
+    defs: JSONSchema7Definition[]
+  ) => JSONSchema7Definition
+) {
+  return (schema: JSONSchema7Definition) =>
+    mergeArrayOfSchemaDefinitions(getAllOfSchemas(schema));
+}
+
+export function createDeepAllOfMerge(
+  shallowMerge: (def: JSONSchema7Definition) => JSONSchema7Definition
+) {
+  return (schemaDef: JSONSchema7Definition) =>
+    transformSchemaDefinition<JSONSchema7Definition>(schemaDef, (def) => {
+      if (typeof def === "boolean" || def.allOf === undefined) {
+        return def;
+      }
+      return shallowMerge(def);
+    });
+}

package/src/lib/json-schema/merge/index.ts

@@ -0,0 +1,3 @@
+export * from "./merge.ts";
+export * from "./all-of-merge.ts";
+export * from "./patterns.ts";