@contractual/differs.json-schema 0.1.0-dev.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (C) 2025 Omer Morad
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,180 @@
+# @contractual/differs.json-schema
+
+Production-quality breaking change detection for JSON Schema.
+
+Detects and classifies structural changes between JSON Schema versions, recommending semantic version bumps (major/minor/patch).
+
+## Why?
+
+JSON Schema has 150M+ weekly npm downloads but **no production-quality breaking change detection tool**. This package fills that gap.
+
+## Installation
+
+```bash
+npm install @contractual/differs.json-schema
+```
+
+## Usage
+
+### Compare Schema Files
+
+```typescript
+import { diffJsonSchema } from '@contractual/differs.json-schema';
+
+const result = await diffJsonSchema('v1/user.schema.json', 'v2/user.schema.json');
+
+console.log(`Suggested bump: ${result.suggestedBump}`);
+console.log(`Breaking: ${result.summary.breaking}`);
+console.log(`Non-breaking: ${result.summary.nonBreaking}`);
+
+// List breaking changes
+for (const change of result.changes) {
+  if (change.severity === 'breaking') {
+    console.log(`❌ ${change.message}`);
+  }
+}
+```
+
+### Compare Schema Objects
+
+```typescript
+import { diffJsonSchemaObjects } from '@contractual/differs.json-schema';
+
+const oldSchema = { type: 'object', properties: { name: { type: 'string' } } };
+const newSchema = { type: 'object', properties: { name: { type: 'number' } } };
+
+const result = diffJsonSchemaObjects(oldSchema, newSchema);
+// result.suggestedBump === 'major'
+// result.changes[0].message === 'Type changed from "string" to "number"...'
+```
+
+### Quick Breaking Check
+
+```typescript
+import { hasBreakingChanges } from '@contractual/differs.json-schema';
+
+if (hasBreakingChanges(oldSchema, newSchema)) {
+  throw new Error('Breaking changes detected!');
+}
+```
+
+## Change Classifications
+
+### Breaking Changes (→ major bump)
+
+| Category | Example |
+|----------|---------|
+| `property-removed` | Field deleted from schema |
+| `required-added` | Existing field became required |
+| `type-changed` | Type changed incompatibly |
+| `type-narrowed` | Union type reduced |
+| `enum-value-removed` | Enum option removed |
+| `constraint-tightened` | minLength/maxLength made stricter |
+| `additional-properties-denied` | Open schema closed |
+| `min-items-increased` | Array minimum increased |
+| `max-items-decreased` | Array maximum decreased |
+
+### Non-Breaking Changes (→ minor bump)
+
+| Category | Example |
+|----------|---------|
+| `property-added` | New optional field |
+| `required-removed` | Field became optional |
+| `type-widened` | Type accepts more values |
+| `enum-value-added` | New enum option |
+| `constraint-loosened` | Constraints relaxed |
+| `additional-properties-allowed` | Closed schema opened |
+
+### Patch Changes (→ patch bump)
+
+| Category | Example |
+|----------|---------|
+| `description-changed` | Documentation updated |
+| `title-changed` | Title updated |
+| `default-changed` | Default value updated |
+| `examples-changed` | Examples updated |
+
+## Advanced Usage
+
+### Resolve $refs
+
+```typescript
+import { resolveRefs } from '@contractual/differs.json-schema';
+
+const schema = {
+  type: 'object',
+  properties: {
+    user: { $ref: '#/$defs/User' }
+  },
+  $defs: {
+    User: { type: 'object', properties: { name: { type: 'string' } } }
+  }
+};
+
+const { schema: resolved, warnings } = resolveRefs(schema);
+// resolved.properties.user === { type: 'object', properties: { name: { type: 'string' } } }
+```
+
+### Custom Classification
+
+```typescript
+import { walk, classify, CLASSIFICATION_SETS } from '@contractual/differs.json-schema';
+
+// Get raw changes
+const rawChanges = walk(resolvedOld, resolvedNew, '');
+
+// Classify with custom rules
+for (const change of rawChanges) {
+  if (CLASSIFICATION_SETS.BREAKING.has(change.type)) {
+    console.log('Breaking:', change.path);
+  }
+}
+```
+
+## Supported JSON Schema Versions
+
+- Draft-07 (primary target)
+- Draft 2019-09
+- Draft 2020-12
+
+## API Reference
+
+### Main Functions
+
+- `diffJsonSchema(oldPath, newPath)` - Compare two schema files
+- `diffJsonSchemaObjects(oldSchema, newSchema)` - Compare two schema objects
+- `hasBreakingChanges(oldSchema, newSchema)` - Quick boolean check
+
+### Utilities
+
+- `resolveRefs(schema)` - Resolve all $ref pointers
+- `walk(oldSchema, newSchema, basePath)` - Low-level schema walker
+- `classify(change)` - Classify a raw change
+- `classifyPropertyAdded(change, newSchema)` - Context-aware property classification
+
+### Types
+
+```typescript
+interface DiffResult {
+  changes: Change[];
+  summary: DiffSummary;
+  suggestedBump: 'major' | 'minor' | 'patch' | 'none';
+}
+
+interface Change {
+  path: string;
+  severity: 'breaking' | 'non-breaking' | 'patch' | 'unknown';
+  category: string;
+  message: string;
+  oldValue?: unknown;
+  newValue?: unknown;
+}
+```
+
+## Part of Contractual
+
+This package is extracted from [Contractual](https://github.com/contractual-dev/contractual), the schema contract lifecycle orchestrator.
+
+## License
+
+MIT

package/dist/classifiers.d.ts

@@ -0,0 +1,87 @@
+/**
+ * JSON Schema Change Classifiers
+ *
+ * Classifies raw structural changes into severity levels for semantic versioning.
+ * Follows API compatibility principles where breaking changes require major bumps,
+ * additive changes require minor bumps, and metadata changes are patches.
+ */
+import type { RawChange, ChangeType, ChangeSeverity } from './types.js';
+/**
+ * Export classification sets for external analysis
+ */
+export declare const CLASSIFICATION_SETS: {
+    readonly breaking: ReadonlySet<ChangeType>;
+    readonly nonBreaking: ReadonlySet<ChangeType>;
+    readonly patch: ReadonlySet<ChangeType>;
+    readonly unknown: ReadonlySet<ChangeType>;
+};
+/**
+ * Classify a raw change into a severity level
+ *
+ * Uses the Strands API classification rules where:
+ * - Breaking changes require major version bump
+ * - Non-breaking changes require minor version bump
+ * - Patch changes are metadata/annotation only
+ * - Unknown changes require manual review
+ *
+ * @param change - The raw change to classify
+ * @returns The severity classification
+ *
+ * @example
+ * ```typescript
+ * const change: RawChange = {
+ *   path: '/properties/name',
+ *   type: 'property-removed',
+ *   oldValue: { type: 'string' },
+ * };
+ * const severity = classify(change);
+ * // severity === 'breaking'
+ * ```
+ */
+export declare function classify(change: RawChange): ChangeSeverity;
+/**
+ * Classify a property-added change with schema context
+ *
+ * Property additions are breaking if the property is required,
+ * otherwise they are non-breaking (additive).
+ *
+ * @param change - The property-added change
+ * @param newSchema - The new schema for context (to check required array)
+ * @returns The severity classification
+ *
+ * @example
+ * ```typescript
+ * const change: RawChange = {
+ *   path: '/properties/email',
+ *   type: 'property-added',
+ *   newValue: { type: 'string', format: 'email' },
+ * };
+ *
+ * const schema = {
+ *   type: 'object',
+ *   properties: { email: { type: 'string', format: 'email' } },
+ *   required: ['email'], // email is required!
+ * };
+ *
+ * const severity = classifyPropertyAdded(change, schema);
+ * // severity === 'breaking' (because email is in required[])
+ * ```
+ */
+export declare function classifyPropertyAdded(change: RawChange, newSchema: unknown): ChangeSeverity;
+/**
+ * Batch classify multiple changes
+ *
+ * @param changes - Array of raw changes
+ * @param newSchema - Optional schema for context-aware classification
+ * @returns Map of change to severity
+ */
+export declare function classifyAll(changes: readonly RawChange[], newSchema?: unknown): Map<RawChange, ChangeSeverity>;
+/**
+ * Get a human-readable message for a classified change
+ *
+ * @param change - The raw change
+ * @param severity - The classified severity
+ * @returns Human-readable description
+ */
+export declare function getChangeMessage(change: RawChange, severity: ChangeSeverity): string;
+//# sourceMappingURL=classifiers.d.ts.map

package/dist/classifiers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"classifiers.d.ts","sourceRoot":"","sources":["../src/classifiers.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AA6HxE;;GAEG;AACH,eAAO,MAAM,mBAAmB;;;;;CAKtB,CAAC;AAEX;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,SAAS,GAAG,cAAc,CAsB1D;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,SAAS,EAAE,SAAS,EAAE,OAAO,GAAG,cAAc,CA6B3F;AAgGD;;;;;;GAMG;AACH,wBAAgB,WAAW,CACzB,OAAO,EAAE,SAAS,SAAS,EAAE,EAC7B,SAAS,CAAC,EAAE,OAAO,GAClB,GAAG,CAAC,SAAS,EAAE,cAAc,CAAC,CAYhC;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,cAAc,GAAG,MAAM,CAapF"}

package/dist/classifiers.js

@@ -0,0 +1,357 @@
+/**
+ * JSON Schema Change Classifiers
+ *
+ * Classifies raw structural changes into severity levels for semantic versioning.
+ * Follows API compatibility principles where breaking changes require major bumps,
+ * additive changes require minor bumps, and metadata changes are patches.
+ */
+/**
+ * Change types that are always breaking (require major version bump)
+ *
+ * These changes can break existing consumers:
+ * - Removing properties removes data they may depend on
+ * - Adding required fields forces consumers to provide new data
+ * - Type changes can break parsing/validation
+ * - Enum removals can invalidate existing data
+ * - Tightened constraints can reject previously valid data
+ * - Composition option additions can change validation semantics
+ *
+ * Aligned with Strands API classification rules.
+ */
+const BREAKING_CHANGES = new Set([
+    'property-removed',
+    'required-added',
+    'type-changed',
+    'type-narrowed',
+    'enum-value-removed',
+    'enum-added',
+    'constraint-tightened',
+    'additional-properties-denied',
+    'items-changed',
+    'min-items-increased',
+    'max-items-decreased',
+    'ref-target-changed',
+    'dependent-required-added',
+    // Composition breaking changes (per Strands API)
+    'anyof-option-added',
+    'oneof-option-added',
+    'allof-member-added',
+    'not-schema-changed',
+]);
+/**
+ * Change types that are non-breaking (require minor version bump)
+ *
+ * These changes are backward compatible additions/relaxations:
+ * - Adding optional properties extends the schema without breaking
+ * - Removing required constraints makes the schema more permissive
+ * - Type widening accepts more values
+ * - Loosened constraints accept more values
+ * - Composition option removals make schema less restrictive
+ *
+ * Aligned with Strands API classification rules.
+ */
+const NON_BREAKING_CHANGES = new Set([
+    'property-added',
+    'required-removed',
+    'type-widened',
+    'enum-value-added',
+    'enum-removed',
+    'constraint-loosened',
+    'additional-properties-allowed',
+    'additional-properties-changed',
+    'dependent-required-removed',
+    // Composition non-breaking changes (per Strands API)
+    'anyof-option-removed',
+    'oneof-option-removed',
+    'allof-member-removed',
+]);
+/**
+ * Change types that are patches (documentation/metadata only)
+ *
+ * These changes don't affect validation behavior:
+ * - Description changes are documentation only
+ * - Title changes are display metadata
+ * - Default/example changes don't affect validation
+ * - Format is an annotation (per Strands API) - doesn't affect validation
+ * - Annotation keywords (deprecated, readOnly, writeOnly)
+ * - Content keywords (contentEncoding, contentMediaType, contentSchema)
+ *
+ * Aligned with Strands API classification rules.
+ */
+const PATCH_CHANGES = new Set([
+    // Metadata changes
+    'description-changed',
+    'title-changed',
+    'default-changed',
+    'examples-changed',
+    // Format is annotation (patch per Strands API)
+    'format-added',
+    'format-removed',
+    'format-changed',
+    // Annotation keywords (Draft 2019-09+)
+    'deprecated-changed',
+    'read-only-changed',
+    'write-only-changed',
+    // Content keywords
+    'content-encoding-changed',
+    'content-media-type-changed',
+    'content-schema-changed',
+]);
+/**
+ * Change types that require manual review
+ *
+ * These changes are too complex to classify automatically:
+ * - Generic composition changes require semantic analysis
+ * - Complex keywords (propertyNames, dependentSchemas, unevaluated*)
+ * - Conditional schema changes (if/then/else)
+ * - Unknown changes need human evaluation
+ *
+ * Aligned with Strands API classification rules.
+ */
+const UNKNOWN_CHANGES = new Set([
+    // Complex object keywords
+    'property-names-changed',
+    'dependent-schemas-changed',
+    'unevaluated-properties-changed',
+    // Complex array keywords
+    'unevaluated-items-changed',
+    'min-contains-changed',
+    'max-contains-changed',
+    // Conditional schema
+    'if-then-else-changed',
+    // Legacy/generic composition
+    'composition-changed',
+    // Catch-all
+    'unknown-change',
+]);
+/**
+ * Export classification sets for external analysis
+ */
+export const CLASSIFICATION_SETS = {
+    breaking: BREAKING_CHANGES,
+    nonBreaking: NON_BREAKING_CHANGES,
+    patch: PATCH_CHANGES,
+    unknown: UNKNOWN_CHANGES,
+};
+/**
+ * Classify a raw change into a severity level
+ *
+ * Uses the Strands API classification rules where:
+ * - Breaking changes require major version bump
+ * - Non-breaking changes require minor version bump
+ * - Patch changes are metadata/annotation only
+ * - Unknown changes require manual review
+ *
+ * @param change - The raw change to classify
+ * @returns The severity classification
+ *
+ * @example
+ * ```typescript
+ * const change: RawChange = {
+ *   path: '/properties/name',
+ *   type: 'property-removed',
+ *   oldValue: { type: 'string' },
+ * };
+ * const severity = classify(change);
+ * // severity === 'breaking'
+ * ```
+ */
+export function classify(change) {
+    const { type } = change;
+    // Check each category in order of specificity
+    if (BREAKING_CHANGES.has(type)) {
+        return 'breaking';
+    }
+    if (NON_BREAKING_CHANGES.has(type)) {
+        return 'non-breaking';
+    }
+    if (PATCH_CHANGES.has(type)) {
+        return 'patch';
+    }
+    if (UNKNOWN_CHANGES.has(type)) {
+        return 'unknown';
+    }
+    // Defensive: any unhandled type is unknown
+    return 'unknown';
+}
+/**
+ * Classify a property-added change with schema context
+ *
+ * Property additions are breaking if the property is required,
+ * otherwise they are non-breaking (additive).
+ *
+ * @param change - The property-added change
+ * @param newSchema - The new schema for context (to check required array)
+ * @returns The severity classification
+ *
+ * @example
+ * ```typescript
+ * const change: RawChange = {
+ *   path: '/properties/email',
+ *   type: 'property-added',
+ *   newValue: { type: 'string', format: 'email' },
+ * };
+ *
+ * const schema = {
+ *   type: 'object',
+ *   properties: { email: { type: 'string', format: 'email' } },
+ *   required: ['email'], // email is required!
+ * };
+ *
+ * const severity = classifyPropertyAdded(change, schema);
+ * // severity === 'breaking' (because email is in required[])
+ * ```
+ */
+export function classifyPropertyAdded(change, newSchema) {
+    // Validate change type
+    if (change.type !== 'property-added') {
+        return classify(change);
+    }
+    // Extract property name from path
+    const propertyName = extractPropertyName(change.path);
+    if (!propertyName) {
+        // Cannot determine property name, fall back to non-breaking
+        return 'non-breaking';
+    }
+    // Find the parent schema containing this property
+    const parentSchema = findParentSchema(change.path, newSchema);
+    if (!parentSchema) {
+        // Cannot find parent schema, fall back to non-breaking
+        return 'non-breaking';
+    }
+    // Check if property is in the required array
+    const required = getRequiredArray(parentSchema);
+    if (required.includes(propertyName)) {
+        // Adding a required property is breaking
+        return 'breaking';
+    }
+    // Adding an optional property is non-breaking
+    return 'non-breaking';
+}
+/**
+ * Extract the property name from a JSON Pointer path
+ *
+ * @param path - JSON Pointer path (e.g., '/properties/name' or '/properties/user/properties/email')
+ * @returns The property name or null if not found
+ */
+function extractPropertyName(path) {
+    // Match the last /properties/NAME segment
+    const match = path.match(/\/properties\/([^/]+)$/);
+    if (match?.[1] !== undefined) {
+        return decodeJsonPointerSegment(match[1]);
+    }
+    return null;
+}
+/**
+ * Decode a JSON Pointer segment (handles ~0 and ~1 escapes)
+ *
+ * @param segment - The encoded segment
+ * @returns The decoded segment
+ */
+function decodeJsonPointerSegment(segment) {
+    return segment.replace(/~1/g, '/').replace(/~0/g, '~');
+}
+/**
+ * Find the parent schema containing a property
+ *
+ * @param path - JSON Pointer path to the property
+ * @param schema - The root schema
+ * @returns The parent schema or null if not found
+ */
+function findParentSchema(path, schema) {
+    if (!isObject(schema)) {
+        return null;
+    }
+    // Remove the last segment to get parent path
+    // e.g., '/properties/name' -> '' (root)
+    // e.g., '/properties/user/properties/email' -> '/properties/user'
+    const segments = path.split('/').filter(Boolean);
+    // We need to navigate to the schema containing /properties/NAME
+    // So we remove 'properties' and 'NAME' from the end
+    if (segments.length < 2) {
+        // Path is too short, parent is root
+        return schema;
+    }
+    // Remove 'NAME' and 'properties' from the end
+    const parentSegments = segments.slice(0, -2);
+    // Navigate to parent
+    let current = schema;
+    for (const segment of parentSegments) {
+        if (!isObject(current)) {
+            return null;
+        }
+        const decoded = decodeJsonPointerSegment(segment);
+        current = current[decoded];
+    }
+    return current;
+}
+/**
+ * Get the required array from a schema object
+ *
+ * @param schema - The schema object
+ * @returns Array of required property names
+ */
+function getRequiredArray(schema) {
+    if (!isObject(schema)) {
+        return [];
+    }
+    const obj = schema;
+    const required = obj['required'];
+    if (!Array.isArray(required)) {
+        return [];
+    }
+    return required.filter((item) => typeof item === 'string');
+}
+/**
+ * Type guard for objects
+ */
+function isObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/**
+ * Batch classify multiple changes
+ *
+ * @param changes - Array of raw changes
+ * @param newSchema - Optional schema for context-aware classification
+ * @returns Map of change to severity
+ */
+export function classifyAll(changes, newSchema) {
+    const results = new Map();
+    for (const change of changes) {
+        if (change.type === 'property-added' && newSchema !== undefined) {
+            results.set(change, classifyPropertyAdded(change, newSchema));
+        }
+        else {
+            results.set(change, classify(change));
+        }
+    }
+    return results;
+}
+/**
+ * Get a human-readable message for a classified change
+ *
+ * @param change - The raw change
+ * @param severity - The classified severity
+ * @returns Human-readable description
+ */
+export function getChangeMessage(change, severity) {
+    const severityLabel = severity === 'breaking'
+        ? 'BREAKING'
+        : severity === 'non-breaking'
+            ? 'Non-breaking'
+            : severity === 'patch'
+                ? 'Patch'
+                : 'Unknown';
+    const typeLabel = formatChangeType(change.type);
+    return `[${severityLabel}] ${typeLabel} at ${change.path}`;
+}
+/**
+ * Format a change type into a human-readable label
+ */
+function formatChangeType(type) {
+    return type
+        .split('-')
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+        .join(' ');
+}
+//# sourceMappingURL=classifiers.js.map

package/dist/classifiers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"classifiers.js","sourceRoot":"","sources":["../src/classifiers.ts"],"names":[],"mappings":"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"}

package/dist/compare.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Strands-compatible JSON Schema comparison API
+ *
+ * Provides schema comparison with output format matching the Strands API
+ * (https://strands.octue.com/api/compare-schemas)
+ */
+import { type CompareResult, type CompareOptions, type StrandsCompatibility } from './types.js';
+/**
+ * Compare two JSON Schema objects and return Strands-compatible result
+ *
+ * @param sourceSchema - The source (old/baseline) schema object
+ * @param targetSchema - The target (new/current) schema object
+ * @param options - Optional comparison options
+ * @returns CompareResult in Strands API format
+ *
+ * @example
+ * ```typescript
+ * const source = { type: 'object', properties: { name: { type: 'string' } } };
+ * const target = { type: 'object', properties: { name: { type: 'number' } } };
+ *
+ * const result = compareSchemas(source, target, { currentVersion: '1.0.0' });
+ * console.log(result.version);    // 'major'
+ * console.log(result.newVersion); // { major: 2, minor: 0, patch: 0, version: '2.0.0' }
+ * ```
+ */
+export declare function compareSchemas(sourceSchema: unknown, targetSchema: unknown, options?: CompareOptions): CompareResult;
+/**
+ * Compare two JSON Schema objects and return a simple compatibility result
+ *
+ * Convenience function for quick compatibility checks.
+ *
+ * @param sourceSchema - The source (old/baseline) schema object
+ * @param targetSchema - The target (new/current) schema object
+ * @returns 'compatible' | 'incompatible' | 'unknown'
+ */
+export declare function checkCompatibility(sourceSchema: unknown, targetSchema: unknown): StrandsCompatibility;
+//# sourceMappingURL=compare.d.ts.map