@x0k/json-schema-merge 1.0.4 → 1.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@x0k/json-schema-merge",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "description": "A minimal JSON Schema merging library.",
   "type": "module",
   "license": "MIT",
@@ -13,8 +13,13 @@
     "url": "git+https://github.com/x0k/json-schema-merge.git"
   },
   "author": "Roman Krasilnikov",
+  "sideEffects": false,
   "files": [
-    "dist"
+    "dist",
+    "src",
+    "!src/**/*.test.ts",
+    "!src/**/*.bench.ts",
+    "!src/**/fixtures"
   ],
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",

package/src/index.ts

@@ -0,0 +1 @@
+export * from "./lib/json-schema/index.ts";

package/src/lib/array.ts

@@ -0,0 +1,172 @@
+import type { Comparator } from "./ord.ts";
+
+export function union<T>(larger: T[], smaller: T[]): T[] {
+  const ll = larger.length;
+  if (ll === 0) {
+    return smaller;
+  }
+  let sl = smaller.length;
+  if (sl === 0) {
+    return larger;
+  }
+  if (ll < sl) {
+    const tmp = larger;
+    larger = smaller;
+    smaller = tmp;
+    sl = ll;
+  }
+  const data = new Set(larger);
+  for (let i = 0; i < sl; i++) {
+    data.add(smaller[i]!);
+  }
+  return Array.from(data);
+}
+
+export function intersection<T>(a: T[], b: T[]): T[] {
+  const result: T[] = [];
+
+  if (a.length === 0 || b.length === 0) {
+    return result;
+  }
+
+  if (a.length > b.length) {
+    const tmp = a;
+    a = b;
+    b = tmp;
+  }
+
+  const setB = new Set(b);
+  for (let i = 0; i < a.length && setB.size > 0; i++) {
+    const val = a[i]!;
+    if (setB.delete(val)) {
+      result.push(val);
+    }
+  }
+
+  return result;
+}
+
+export function isArrayEmpty<T>(arr: T[]): arr is [] {
+  return arr.length === 0;
+}
+
+export function createArrayComparator<T>(compare: (a: T, b: T) => number) {
+  return (a: T[], b: T[]) => {
+    const d = a.length - b.length;
+    if (d !== 0) {
+      return d;
+    }
+    for (let i = 0; i < a.length; i++) {
+      if (a[i] !== b[i]) {
+        const d = compare(a[i]!, b[i]!);
+        if (d !== 0) {
+          return d;
+        }
+      }
+    }
+    return 0;
+  };
+}
+
+/**
+ * Function type for removing duplicates from an array.
+ */
+export type Deduplicator<T> = (data: T[]) => T[];
+
+export interface DeduplicatorOptions {
+  /** @default 12 */
+  threshold?: number;
+}
+
+export function createDeduplicator<T>(
+  compare: Comparator<T>,
+  { threshold = 12 }: DeduplicatorOptions = {}
+): Deduplicator<T> {
+  return (arr) => {
+    const al = arr.length;
+
+    if (al === 0) {
+      return arr;
+    }
+
+    if (al <= threshold) {
+      const result: T[] = [];
+      let rl = 0;
+      outer: for (let i = 0; i < al; i++) {
+        const item = arr[i]!;
+        for (let j = 0; j < rl; j++) {
+          if (compare(item, result[j]!) === 0) {
+            continue outer;
+          }
+        }
+        rl = result.push(item);
+      }
+      return result;
+    }
+
+    const sorted = arr.slice().sort(compare);
+    let wIndex = 0;
+
+    for (let rIndex = 1; rIndex < al; rIndex++) {
+      if (compare(sorted[wIndex]!, sorted[rIndex]!) !== 0) {
+        if (++wIndex !== rIndex) {
+          sorted[wIndex] = sorted[rIndex]!;
+        }
+      }
+    }
+    sorted.length = wIndex + 1;
+    return sorted;
+  };
+}
+
+/**
+ * Function type for intersecting two arrays of the same type.
+ */
+export type Intersector<T> = (a: T[], b: T[]) => T[];
+
+export function createIntersector<T>(compare: Comparator<T>): Intersector<T> {
+  return (a, b) => {
+    const result: T[] = [];
+    let al = a.length;
+    let bl = b.length;
+
+    if (al === 0 || bl === 0) {
+      return result;
+    }
+
+    if (al > bl) {
+      const tmpArr = a;
+      a = b;
+      b = tmpArr;
+      const tmpL = al;
+      al = bl;
+      bl = tmpL;
+    }
+
+    const aSorted = [...a].sort(compare);
+    const bSorted = [...b].sort(compare);
+
+    let i = 0,
+      j = 0;
+    while (i < al && j < bl) {
+      const cmp = compare(aSorted[i]!, bSorted[j]!);
+      if (cmp === 0) {
+        // Only push if result is empty OR last pushed value is different
+        if (
+          result.length === 0 ||
+          compare(result[result.length - 1]!, aSorted[i]!) !== 0
+        ) {
+          result.push(aSorted[i]!);
+        }
+        i++;
+        j++;
+      } else if (cmp < 0) {
+        i++;
+      } else {
+        j++;
+      }
+    }
+
+    return result;
+  };
+}

package/src/lib/function.ts

@@ -0,0 +1,3 @@
+export function identity<T>(v: T): T {
+  return v;
+}

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);
+    });
+}