json-schema-compatibility-checker 1.0.0

package/dist/subset-checker.d.ts

@@ -0,0 +1,76 @@
+import type { JSONSchema7Definition } from "json-schema";
+import type { MergeEngine } from "./merge-engine";
+import type { SubsetResult } from "./types";
+/**
+ * Type de branchement détecté dans un schema.
+ *
+ * Point 6 — Distingue `anyOf` de `oneOf` pour produire des messages
+ * de diff plus précis. `"none"` indique un schema atomique (pas de branches).
+ *
+ * Note : la sémantique d'exclusivité de `oneOf` n'est pas vérifiée
+ * (ce serait un problème NP-hard en général). Le checker traite `oneOf`
+ * comme `anyOf` pour le subset checking, ce qui est correct pour le cas
+ * `sub ⊆ sup` mais peut produire des faux-positifs si les branches
+ * du sub se chevauchent.
+ */
+export type BranchType = "anyOf" | "oneOf" | "none";
+export interface BranchResult {
+    /** Les branches extraites du schema */
+    branches: JSONSchema7Definition[];
+    /** Le type de branchement détecté */
+    type: BranchType;
+}
+/**
+ * Extrait les branches d'un schema et le type de branchement.
+ *
+ * Retourne les éléments de `anyOf`/`oneOf` s'ils existent, sinon retourne
+ * le schema lui-même dans un tableau avec type `"none"`.
+ *
+ * Point 6 — Distingue `anyOf` de `oneOf` dans les paths de diff.
+ */
+export declare function getBranchesTyped(def: JSONSchema7Definition): BranchResult;
+/**
+ * Vérifie si `sub ⊆ sup` pour deux schemas sans anyOf/oneOf (ou avec
+ * anyOf/oneOf uniquement côté sup).
+ *
+ * Point 7 — Intègre un pré-check `not` étendu (`evaluateNot`) avant le merge.
+ *
+ * Quand `evaluateNot` confirme la compatibilité (`true`), on retire le `not`
+ * de `sup` avant le merge pour éviter que le merge engine ajoute une contrainte
+ * `not` que `sub` n'a pas (ce qui ferait échouer `isEqual(merged, sub)`).
+ *
+ * Pattern pre-check — Quand les deux schemas ont des patterns différents,
+ * vérifie l'inclusion par échantillonnage via `isPatternSubset`. Si confirmé,
+ * retire le pattern de sup avant le merge (même stratégie que pour `not`).
+ *
+ * Principe : merge(sub, sup) ≡ sub → sub est un sous-ensemble de sup.
+ *
+ * Utilise `_.some`, `_.has`, `_.omit`, `_.keys`, `_.isEmpty` pour la logique.
+ */
+export declare function isAtomicSubsetOf(sub: JSONSchema7Definition, sup: JSONSchema7Definition, engine: MergeEngine): boolean;
+/**
+ * Vérifie `sub ⊆ sup` pour un sub qui a des branches (anyOf/oneOf).
+ * Chaque branche de sub doit être acceptée par sup.
+ *
+ * Point 6 — Utilise `getBranchesTyped` pour distinguer `anyOf[i]` de
+ * `oneOf[i]` dans les paths de diff.
+ *
+ * Utilise `_.every` / `_.flatMap` / `_.map` pour une itération idiomatique.
+ */
+export declare function checkBranchedSub(subBranches: JSONSchema7Definition[], sup: JSONSchema7Definition, engine: MergeEngine, branchType?: BranchType): SubsetResult;
+/**
+ * Vérifie `sub ⊆ sup` pour un sup qui a des branches (anyOf/oneOf).
+ * Au moins une branche de sup doit accepter sub.
+ *
+ * Point 6 — Utilise le type de branche de sup pour des messages plus précis.
+ *
+ * Utilise `_.some` pour trouver la première branche compatible.
+ */
+export declare function checkBranchedSup(sub: JSONSchema7Definition, supBranches: JSONSchema7Definition[], engine: MergeEngine, branchType?: BranchType): SubsetResult;
+/**
+ * Vérifie `sub ⊆ sup` pour deux schemas atomiques (sans anyOf/oneOf).
+ * Utilise `mergeOrThrow` pour capturer les erreurs d'incompatibilité.
+ *
+ * Utilise `_.isEqual` via engine.isEqual pour la comparaison structurelle.
+ */
+export declare function checkAtomic(sub: JSONSchema7Definition, sup: JSONSchema7Definition, engine: MergeEngine): SubsetResult;

package/dist/subset-checker.js

@@ -0,0 +1,4 @@
+import{b as a,c as b,d as c,e as d,f as e}from"./chunk-e4501gq7.js";import"./chunk-vcwsxmk4.js";import"./chunk-v5tqyc67.js";import"./chunk-g0pfcnm5.js";import"./chunk-pw49kj6f.js";export{b as isAtomicSubsetOf,a as getBranchesTyped,d as checkBranchedSup,c as checkBranchedSub,e as checkAtomic};
+
+//# debugId=E49CFA87DE09786B64756E2164756E21
+//# sourceMappingURL=subset-checker.js.map

package/dist/subset-checker.js.map

@@ -0,0 +1,9 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [
+  ],
+  "mappings": "",
+  "debugId": "E49CFA87DE09786B64756E2164756E21",
+  "names": []
+}

package/dist/types.d.ts

@@ -0,0 +1,31 @@
+import type { JSONSchema7, JSONSchema7Definition } from "json-schema";
+export interface SchemaDiff {
+    /** Chemin JSON-path-like vers la divergence (ex: "properties.user.required") */
+    path: string;
+    /** Type de divergence */
+    type: "added" | "removed" | "changed";
+    /** Valeur dans le schema original (sub) */
+    expected: unknown;
+    /** Valeur dans le schema mergé (intersection) */
+    actual: unknown;
+}
+export interface SubsetResult {
+    /** true si sub ⊆ sup (toute valeur valide pour sub est valide pour sup) */
+    isSubset: boolean;
+    /** Le schema résultant de l'intersection allOf(sub, sup), ou null si incompatible */
+    merged: JSONSchema7Definition | null;
+    /** Différences structurelles détectées entre sub et l'intersection */
+    diffs: SchemaDiff[];
+}
+export interface ConnectionResult extends SubsetResult {
+    /** Direction lisible du check */
+    direction: string;
+}
+export interface ResolvedConditionResult {
+    /** Le schema avec les if/then/else résolus (aplatis) */
+    resolved: JSONSchema7;
+    /** La branche qui a été appliquée ("then" | "else" | null si pas de condition) */
+    branch: "then" | "else" | null;
+    /** Le discriminant utilisé pour résoudre */
+    discriminant: Record<string, unknown>;
+}

package/dist/types.js

@@ -0,0 +1,3 @@
+
+//# debugId=9FCB033A2878230664756E2164756E21
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1,9 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [
+  ],
+  "mappings": "",
+  "debugId": "9FCB033A2878230664756E2164756E21",
+  "names": []
+}

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "json-schema-compatibility-checker",
+  "version": "1.0.0",
+  "license": "MIT",
+  "description": "A tool to check compatibility between two JSON Schemas.",
+  "author": {
+    "email": "arthurtinseau@live.fr",
+    "url": "https://github.com/atinseau/json-schema-compatibility-checker",
+    "name": "atinseau"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "postinstall": "lefthook install",
+    "build:bun": "bun build src/*.ts --outdir ./dist --production --minify --root src --sourcemap --splitting --target node --format esm --packages external --chunk-naming='chunk-[hash].js'",
+    "build:tsc": "tsc --project tsconfig.build.json",
+    "build": "bun --parallel build:bun build:tsc",
+    "prepublishOnly": "bun run build",
+    "check-types": "tsc --noEmit",
+    "check": "biome check --write --unsafe",
+    "test": "bun test"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "2.4.3",
+    "@types/bun": "latest",
+    "@types/lodash": "4.17.23",
+    "lefthook": "^2.1.1"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "dependencies": {
+    "@x0k/json-schema-merge": "1.0.2",
+    "class-validator": "0.14.3",
+    "lodash": "4.17.23",
+    "randexp": "0.5.3"
+  }
+}