@contractspec/lib.contracts-transformers 1.44.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Chaman Ventures, SASU
+
+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,95 @@
+# @contractspec/lib.contracts-transformers
+
+Website: https://contractspec.io/
+
+
+Contract format transformations: bidirectional import/export between ContractSpec and external API specification formats.
+
+## Supported Formats
+
+- **OpenAPI 3.x** - Import from and export to OpenAPI specifications (JSON/YAML, URL/file)
+
+## Installation
+
+```bash
+bun add @contractspec/lib.contracts-transformers
+```
+
+## Usage
+
+### Export ContractSpec to OpenAPI
+
+```typescript
+import { openApiForRegistry } from '@contractspec/lib.contracts-transformers/openapi';
+import { OperationSpecRegistry } from '@contractspec/lib.contracts';
+
+const registry = new OperationSpecRegistry();
+// ... register your specs ...
+
+const openApiDoc = openApiForRegistry(registry, {
+  title: 'My API',
+  version: '1.0.0',
+  description: 'API generated from ContractSpec',
+  servers: [{ url: 'https://api.example.com' }],
+});
+```
+
+### Import from OpenAPI
+
+```typescript
+import { parseOpenApi, importFromOpenApi } from '@contractspec/lib.contracts-transformers/openapi';
+
+// Parse OpenAPI from file or URL
+const openApiDoc = await parseOpenApi('./api.yaml');
+// Or from URL
+const openApiDoc = await parseOpenApi('https://api.example.com/openapi.json');
+
+// Convert to ContractSpec specs
+const importResult = importFromOpenApi(openApiDoc, {
+  prefix: 'myApi',
+  tags: ['users', 'orders'], // Optional: filter by tags
+  exclude: ['deprecated_endpoint'], // Optional: exclude by operationId
+  schemaFormat: 'contractspec', // Optional: 'contractspec' | 'zod' | 'json-schema' | 'graphql'
+});
+
+// importResult contains generated spec code as strings
+for (const spec of importResult.specs) {
+  console.log(spec.name, spec.code);
+}
+```
+
+### Diff ContractSpec vs OpenAPI
+
+```typescript
+import { diffSpecs } from '@contractspec/lib.contracts-transformers/openapi';
+
+const diffs = diffSpecs(existingSpecs, importedSpecs);
+
+for (const diff of diffs) {
+  console.log(`${diff.operationId}: ${diff.changes.length} changes`);
+  for (const change of diff.changes) {
+    console.log(`  - ${change.path}: ${change.type}`);
+  }
+}
+```
+
+## Architecture
+
+This library is organized by format:
+
+- `openapi/` - OpenAPI 3.x transformations
+  - `parser.ts` - Parse OpenAPI from JSON/YAML/URL
+  - `importer.ts` - Convert OpenAPI to ContractSpec
+  - `exporter.ts` - Convert ContractSpec to OpenAPI
+  - `differ.ts` - Diff specs for sync operations
+  - `schema-converter.ts` - JSON Schema <-> SchemaModel conversion
+- `common/` - Shared utilities and types
+
+## Future Formats
+
+The library is designed to be extensible for additional formats:
+
+- AsyncAPI (event-driven APIs)
+- gRPC/Protobuf
+- GraphQL Schema
+

package/dist/common/index.d.ts

@@ -0,0 +1,3 @@
+import { DiffChange, DiffChangeType, ImportResult, ImportedOperationSpec, SpecDiff, SpecSource, SyncResult, TransportHints, ValidationResult } from "./types.js";
+import { deepEqual, extractPathParams, getByPath, normalizePath, toCamelCase, toFileName, toKebabCase, toPascalCase, toSnakeCase, toSpecKey, toValidIdentifier } from "./utils.js";
+export { DiffChange, DiffChangeType, ImportResult, ImportedOperationSpec, SpecDiff, SpecSource, SyncResult, TransportHints, ValidationResult, deepEqual, extractPathParams, getByPath, normalizePath, toCamelCase, toFileName, toKebabCase, toPascalCase, toSnakeCase, toSpecKey, toValidIdentifier };

package/dist/common/index.js

@@ -0,0 +1,3 @@
+import { deepEqual, extractPathParams, getByPath, normalizePath, toCamelCase, toFileName, toKebabCase, toPascalCase, toSnakeCase, toSpecKey, toValidIdentifier } from "./utils.js";
+
+export { deepEqual, extractPathParams, getByPath, normalizePath, toCamelCase, toFileName, toKebabCase, toPascalCase, toSnakeCase, toSpecKey, toValidIdentifier };

package/dist/common/types.d.ts

@@ -0,0 +1,159 @@
+import { AnyOperationSpec } from "@contractspec/lib.contracts";
+
+//#region src/common/types.d.ts
+
+/**
+ * Source information for imported specs.
+ */
+interface SpecSource {
+  /** The format the spec was imported from */
+  type: 'openapi' | 'asyncapi' | 'graphql' | 'protobuf';
+  /** URL if fetched from remote */
+  url?: string;
+  /** File path if loaded from local file */
+  file?: string;
+  /** Original identifier in source format */
+  sourceId: string;
+  /** Timestamp of import */
+  importedAt: Date;
+}
+/**
+ * Transport hints preserved from external formats.
+ * These enable accurate round-trip transformations.
+ */
+interface TransportHints {
+  rest?: {
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
+    path: string;
+    params?: {
+      path?: string[];
+      query?: string[];
+      header?: string[];
+      cookie?: string[];
+    };
+  };
+  graphql?: {
+    type: 'query' | 'mutation' | 'subscription';
+    fieldName: string;
+  };
+}
+/**
+ * Result of importing a single spec from an external format.
+ */
+interface ImportedOperationSpec {
+  /**
+   * The generated ContractSpec.
+   * Optional because during code generation the actual spec object is not
+   * available until the generated code is executed at runtime.
+   */
+  operationSpec?: AnyOperationSpec;
+  /** Generated TypeScript code for the spec */
+  code: string;
+  /** Suggested file name for the spec */
+  fileName: string;
+  /** Group folder for organizing the file (based on grouping config) */
+  groupFolder?: string;
+  /** Source information for provenance tracking */
+  source: SpecSource;
+  /** Transport hints for accurate round-trips */
+  transportHints: TransportHints;
+}
+/**
+ * Result of an import operation.
+ */
+interface ImportResult {
+  /** Successfully imported specs */
+  operationSpecs: ImportedOperationSpec[];
+  /** Specs that were skipped (e.g., unsupported features) */
+  skipped: {
+    sourceId: string;
+    reason: string;
+  }[];
+  /** Errors encountered during import */
+  errors: {
+    sourceId: string;
+    error: string;
+  }[];
+  /** Summary statistics */
+  summary: {
+    total: number;
+    imported: number;
+    skipped: number;
+    errors: number;
+  };
+}
+/**
+ * Type of change detected during diff.
+ */
+type DiffChangeType = 'added' | 'removed' | 'modified' | 'type_changed' | 'required_changed';
+/**
+ * A single change detected during diff.
+ */
+interface DiffChange {
+  /** JSON path to the changed property */
+  path: string;
+  /** Type of change */
+  type: DiffChangeType;
+  /** Previous value (for modified/removed) */
+  oldValue?: unknown;
+  /** New value (for modified/added) */
+  newValue?: unknown;
+  /** Human-readable description of the change */
+  description: string;
+}
+/**
+ * Result of diffing two specs.
+ */
+interface SpecDiff {
+  /** Identifier for the operation */
+  operationId: string;
+  /** Existing ContractSpec (if any) */
+  existing?: AnyOperationSpec;
+  /** Incoming imported spec */
+  incoming: ImportedOperationSpec;
+  /** List of detected changes */
+  changes: DiffChange[];
+  /** Whether specs are semantically equivalent */
+  isEquivalent: boolean;
+  /** User's resolution choice (for interactive sync) */
+  resolution?: 'keep' | 'replace' | 'merge' | 'skip';
+}
+/**
+ * Result of a sync operation.
+ */
+interface SyncResult {
+  /** Specs that were added (new imports) */
+  added: ImportedOperationSpec[];
+  /** Specs that were updated */
+  updated: {
+    spec: ImportedOperationSpec;
+    changes: DiffChange[];
+  }[];
+  /** Specs that were kept unchanged */
+  unchanged: string[];
+  /** Specs that had conflicts requiring resolution */
+  conflicts: SpecDiff[];
+  /** Summary statistics */
+  summary: {
+    added: number;
+    updated: number;
+    unchanged: number;
+    conflicts: number;
+  };
+}
+/**
+ * Validation result for a single spec.
+ */
+interface ValidationResult {
+  /** Whether the spec is valid against the source */
+  valid: boolean;
+  /** Detected differences */
+  diffs: DiffChange[];
+  /** Validation errors */
+  errors: string[];
+  /** Validation warnings */
+  warnings: string[];
+}
+//#endregion
+export { DiffChange, DiffChangeType, ImportResult, ImportedOperationSpec, SpecDiff, SpecSource, SyncResult, TransportHints, ValidationResult };
+//# sourceMappingURL=types.d.ts.map

package/dist/common/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../src/common/types.ts"],"sourcesContent":[],"mappings":";;;;AA0BA;AAoBA;;AAcU,UAnDO,UAAA,CAmDP;EAEQ;EAAc,IAAA,EAAA,SAAA,GAAA,UAAA,GAAA,SAAA,GAAA,UAAA;EAMf;EAyBL,GAAA,CAAA,EAAA,MAAA;EAUK;EAgBA,IAAA,CAAA,EAAA,MAAQ;EAIZ;EAED,QAAA,EAAA,MAAA;EAED;EAAU,UAAA,EA5GP,IA4GO;AAUrB;;;;;AAWqB,UA1HJ,cAAA,CA0HI;EAaJ,IAAA,CAAA,EAAA;;;;;;;;;;;;;;;;;;UAnHA,qBAAA;;;;;;kBAMC;;;;;;;;UAQR;;kBAEQ;;;;;UAMD,YAAA;;kBAEC;;;;;;;;;;;;;;;;;;;;;;KAuBN,cAAA;;;;UAUK,UAAA;;;;QAIT;;;;;;;;;;;UAYS,QAAA;;;;aAIJ;;YAED;;WAED;;;;;;;;;UAUM,UAAA;;SAER;;;UAGC;aACG;;;;;aAKA;;;;;;;;;;;;UAaI,gBAAA;;;;SAIR"}

package/dist/common/utils.d.ts

@@ -0,0 +1,52 @@
+//#region src/common/utils.d.ts
+/**
+ * Common utilities for contract transformations.
+ */
+/**
+ * Convert a string to PascalCase.
+ */
+declare function toPascalCase(str: string): string;
+/**
+ * Convert a string to camelCase.
+ */
+declare function toCamelCase(str: string): string;
+/**
+ * Convert a string to kebab-case.
+ */
+declare function toKebabCase(str: string): string;
+/**
+ * Convert a string to snake_case.
+ */
+declare function toSnakeCase(str: string): string;
+/**
+ * Sanitize a string to be a valid TypeScript identifier.
+ */
+declare function toValidIdentifier(str: string): string;
+/**
+ * Generate a ContractSpec key from an operation identifier.
+ */
+declare function toSpecKey(operationId: string, prefix?: string): string;
+/**
+ * Generate a file name from a spec name.
+ */
+declare function toFileName(specName: string): string;
+/**
+ * Deep equality check for objects.
+ */
+declare function deepEqual(a: unknown, b: unknown): boolean;
+/**
+ * Get a value from an object by JSON path.
+ */
+declare function getByPath(obj: unknown, path: string): unknown;
+/**
+ * Extract path parameters from a URL path template.
+ * e.g., "/users/{userId}/orders/{orderId}" -> ["userId", "orderId"]
+ */
+declare function extractPathParams(path: string): string[];
+/**
+ * Normalize a URL path for comparison.
+ */
+declare function normalizePath(path: string): string;
+//#endregion
+export { deepEqual, extractPathParams, getByPath, normalizePath, toCamelCase, toFileName, toKebabCase, toPascalCase, toSnakeCase, toSpecKey, toValidIdentifier };
+//# sourceMappingURL=utils.d.ts.map

package/dist/common/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","names":[],"sources":["../../src/common/utils.ts"],"sourcesContent":[],"mappings":";;AAOA;AASA;AAQA;AAUA;AAUA;AAagB,iBAlDA,YAAA,CAkDS,GAAA,EAAA,MAAA,CAAA,EAAA,MAAA;AAQzB;AAOA;AA4BA;AAiBgB,iBArGA,WAAA,CAqGiB,GAAA,EAAA,MAAA,CAAA,EAAA,MAAA;AAQjC;;;iBArGgB,WAAA;;;;iBAUA,WAAA;;;;iBAUA,iBAAA;;;;iBAaA,SAAA;;;;iBAQA,UAAA;;;;iBAOA,SAAA;;;;iBA4BA,SAAA;;;;;iBAiBA,iBAAA;;;;iBAQA,aAAA"}

package/dist/common/utils.js

@@ -0,0 +1,103 @@
+//#region src/common/utils.ts
+/**
+* Common utilities for contract transformations.
+*/
+/**
+* Convert a string to PascalCase.
+*/
+function toPascalCase(str) {
+	return str.replace(/[-_./\s]+(.)?/g, (_, c) => c ? c.toUpperCase() : "").replace(/^./, (c) => c.toUpperCase());
+}
+/**
+* Convert a string to camelCase.
+*/
+function toCamelCase(str) {
+	const pascal = toPascalCase(str);
+	return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+/**
+* Convert a string to kebab-case.
+*/
+function toKebabCase(str) {
+	return str.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_./]+/g, "-").toLowerCase();
+}
+/**
+* Convert a string to snake_case.
+*/
+function toSnakeCase(str) {
+	return str.replace(/([a-z])([A-Z])/g, "$1_$2").replace(/[\s\-./]+/g, "_").toLowerCase();
+}
+/**
+* Sanitize a string to be a valid TypeScript identifier.
+*/
+function toValidIdentifier(str) {
+	let result = str.replace(/[^a-zA-Z0-9_$]/g, "_");
+	if (/^[0-9]/.test(result)) result = "_" + result;
+	return result;
+}
+/**
+* Generate a ContractSpec key from an operation identifier.
+*/
+function toSpecKey(operationId, prefix) {
+	const key = toCamelCase(operationId);
+	return prefix ? `${prefix}.${key}` : key;
+}
+/**
+* Generate a file name from a spec name.
+*/
+function toFileName(specName) {
+	return toKebabCase(specName.replace(/\./g, "-")) + ".ts";
+}
+/**
+* Deep equality check for objects.
+*/
+function deepEqual(a, b) {
+	if (a === b) return true;
+	if (a === null || b === null) return false;
+	if (typeof a !== typeof b) return false;
+	if (typeof a === "object") {
+		const aObj = a;
+		const bObj = b;
+		const aKeys = Object.keys(aObj);
+		const bKeys = Object.keys(bObj);
+		if (aKeys.length !== bKeys.length) return false;
+		for (const key of aKeys) {
+			if (!bKeys.includes(key)) return false;
+			if (!deepEqual(aObj[key], bObj[key])) return false;
+		}
+		return true;
+	}
+	return false;
+}
+/**
+* Get a value from an object by JSON path.
+*/
+function getByPath(obj, path) {
+	const parts = path.split(".").filter(Boolean);
+	let current = obj;
+	for (const part of parts) {
+		if (current === null || current === void 0) return void 0;
+		if (typeof current !== "object") return void 0;
+		current = current[part];
+	}
+	return current;
+}
+/**
+* Extract path parameters from a URL path template.
+* e.g., "/users/{userId}/orders/{orderId}" -> ["userId", "orderId"]
+*/
+function extractPathParams(path) {
+	return (path.match(/\{([^}]+)\}/g) || []).map((m) => m.slice(1, -1));
+}
+/**
+* Normalize a URL path for comparison.
+*/
+function normalizePath(path) {
+	let normalized = path.replace(/^\/+|\/+$/g, "");
+	normalized = normalized.replace(/\/+/g, "/");
+	return "/" + normalized;
+}
+
+//#endregion
+export { deepEqual, extractPathParams, getByPath, normalizePath, toCamelCase, toFileName, toKebabCase, toPascalCase, toSnakeCase, toSpecKey, toValidIdentifier };
+//# sourceMappingURL=utils.js.map

package/dist/common/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","names":["current: unknown"],"sources":["../../src/common/utils.ts"],"sourcesContent":["/**\n * Common utilities for contract transformations.\n */\n\n/**\n * Convert a string to PascalCase.\n */\nexport function toPascalCase(str: string): string {\n  return str\n    .replace(/[-_./\\s]+(.)?/g, (_, c) => (c ? c.toUpperCase() : ''))\n    .replace(/^./, (c) => c.toUpperCase());\n}\n\n/**\n * Convert a string to camelCase.\n */\nexport function toCamelCase(str: string): string {\n  const pascal = toPascalCase(str);\n  return pascal.charAt(0).toLowerCase() + pascal.slice(1);\n}\n\n/**\n * Convert a string to kebab-case.\n */\nexport function toKebabCase(str: string): string {\n  return str\n    .replace(/([a-z])([A-Z])/g, '$1-$2')\n    .replace(/[\\s_./]+/g, '-')\n    .toLowerCase();\n}\n\n/**\n * Convert a string to snake_case.\n */\nexport function toSnakeCase(str: string): string {\n  return str\n    .replace(/([a-z])([A-Z])/g, '$1_$2')\n    .replace(/[\\s\\-./]+/g, '_')\n    .toLowerCase();\n}\n\n/**\n * Sanitize a string to be a valid TypeScript identifier.\n */\nexport function toValidIdentifier(str: string): string {\n  // Remove invalid characters\n  let result = str.replace(/[^a-zA-Z0-9_$]/g, '_');\n  // Ensure it doesn't start with a number\n  if (/^[0-9]/.test(result)) {\n    result = '_' + result;\n  }\n  return result;\n}\n\n/**\n * Generate a ContractSpec key from an operation identifier.\n */\nexport function toSpecKey(operationId: string, prefix?: string): string {\n  const key = toCamelCase(operationId);\n  return prefix ? `${prefix}.${key}` : key;\n}\n\n/**\n * Generate a file name from a spec name.\n */\nexport function toFileName(specName: string): string {\n  return toKebabCase(specName.replace(/\\./g, '-')) + '.ts';\n}\n\n/**\n * Deep equality check for objects.\n */\nexport function deepEqual(a: unknown, b: unknown): boolean {\n  if (a === b) return true;\n  if (a === null || b === null) return false;\n  if (typeof a !== typeof b) return false;\n\n  if (typeof a === 'object') {\n    const aObj = a as Record<string, unknown>;\n    const bObj = b as Record<string, unknown>;\n\n    const aKeys = Object.keys(aObj);\n    const bKeys = Object.keys(bObj);\n\n    if (aKeys.length !== bKeys.length) return false;\n\n    for (const key of aKeys) {\n      if (!bKeys.includes(key)) return false;\n      if (!deepEqual(aObj[key], bObj[key])) return false;\n    }\n\n    return true;\n  }\n\n  return false;\n}\n\n/**\n * Get a value from an object by JSON path.\n */\nexport function getByPath(obj: unknown, path: string): unknown {\n  const parts = path.split('.').filter(Boolean);\n  let current: unknown = obj;\n\n  for (const part of parts) {\n    if (current === null || current === undefined) return undefined;\n    if (typeof current !== 'object') return undefined;\n    current = (current as Record<string, unknown>)[part];\n  }\n\n  return current;\n}\n\n/**\n * Extract path parameters from a URL path template.\n * e.g., \"/users/{userId}/orders/{orderId}\" -> [\"userId\", \"orderId\"]\n */\nexport function extractPathParams(path: string): string[] {\n  const matches = path.match(/\\{([^}]+)\\}/g) || [];\n  return matches.map((m) => m.slice(1, -1));\n}\n\n/**\n * Normalize a URL path for comparison.\n */\nexport function normalizePath(path: string): string {\n  // Remove leading/trailing slashes\n  let normalized = path.replace(/^\\/+|\\/+$/g, '');\n  // Replace multiple slashes with single\n  normalized = normalized.replace(/\\/+/g, '/');\n  // Add leading slash\n  return '/' + normalized;\n}\n"],"mappings":";;;;;;;AAOA,SAAgB,aAAa,KAAqB;AAChD,QAAO,IACJ,QAAQ,mBAAmB,GAAG,MAAO,IAAI,EAAE,aAAa,GAAG,GAAI,CAC/D,QAAQ,OAAO,MAAM,EAAE,aAAa,CAAC;;;;;AAM1C,SAAgB,YAAY,KAAqB;CAC/C,MAAM,SAAS,aAAa,IAAI;AAChC,QAAO,OAAO,OAAO,EAAE,CAAC,aAAa,GAAG,OAAO,MAAM,EAAE;;;;;AAMzD,SAAgB,YAAY,KAAqB;AAC/C,QAAO,IACJ,QAAQ,mBAAmB,QAAQ,CACnC,QAAQ,aAAa,IAAI,CACzB,aAAa;;;;;AAMlB,SAAgB,YAAY,KAAqB;AAC/C,QAAO,IACJ,QAAQ,mBAAmB,QAAQ,CACnC,QAAQ,cAAc,IAAI,CAC1B,aAAa;;;;;AAMlB,SAAgB,kBAAkB,KAAqB;CAErD,IAAI,SAAS,IAAI,QAAQ,mBAAmB,IAAI;AAEhD,KAAI,SAAS,KAAK,OAAO,CACvB,UAAS,MAAM;AAEjB,QAAO;;;;;AAMT,SAAgB,UAAU,aAAqB,QAAyB;CACtE,MAAM,MAAM,YAAY,YAAY;AACpC,QAAO,SAAS,GAAG,OAAO,GAAG,QAAQ;;;;;AAMvC,SAAgB,WAAW,UAA0B;AACnD,QAAO,YAAY,SAAS,QAAQ,OAAO,IAAI,CAAC,GAAG;;;;;AAMrD,SAAgB,UAAU,GAAY,GAAqB;AACzD,KAAI,MAAM,EAAG,QAAO;AACpB,KAAI,MAAM,QAAQ,MAAM,KAAM,QAAO;AACrC,KAAI,OAAO,MAAM,OAAO,EAAG,QAAO;AAElC,KAAI,OAAO,MAAM,UAAU;EACzB,MAAM,OAAO;EACb,MAAM,OAAO;EAEb,MAAM,QAAQ,OAAO,KAAK,KAAK;EAC/B,MAAM,QAAQ,OAAO,KAAK,KAAK;AAE/B,MAAI,MAAM,WAAW,MAAM,OAAQ,QAAO;AAE1C,OAAK,MAAM,OAAO,OAAO;AACvB,OAAI,CAAC,MAAM,SAAS,IAAI,CAAE,QAAO;AACjC,OAAI,CAAC,UAAU,KAAK,MAAM,KAAK,KAAK,CAAE,QAAO;;AAG/C,SAAO;;AAGT,QAAO;;;;;AAMT,SAAgB,UAAU,KAAc,MAAuB;CAC7D,MAAM,QAAQ,KAAK,MAAM,IAAI,CAAC,OAAO,QAAQ;CAC7C,IAAIA,UAAmB;AAEvB,MAAK,MAAM,QAAQ,OAAO;AACxB,MAAI,YAAY,QAAQ,YAAY,OAAW,QAAO;AACtD,MAAI,OAAO,YAAY,SAAU,QAAO;AACxC,YAAW,QAAoC;;AAGjD,QAAO;;;;;;AAOT,SAAgB,kBAAkB,MAAwB;AAExD,SADgB,KAAK,MAAM,eAAe,IAAI,EAAE,EACjC,KAAK,MAAM,EAAE,MAAM,GAAG,GAAG,CAAC;;;;;AAM3C,SAAgB,cAAc,MAAsB;CAElD,IAAI,aAAa,KAAK,QAAQ,cAAc,GAAG;AAE/C,cAAa,WAAW,QAAQ,QAAQ,IAAI;AAE5C,QAAO,MAAM"}

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+import { DiffChange, DiffChangeType, ImportResult, ImportedOperationSpec, SpecDiff, SpecSource, SyncResult, TransportHints, ValidationResult } from "./common/types.js";
+import { deepEqual, extractPathParams, getByPath, normalizePath, toCamelCase, toFileName, toKebabCase, toPascalCase, toSnakeCase, toSpecKey, toValidIdentifier } from "./common/utils.js";
+import { ContractSpecOpenApiDocument, HttpMethod, OpenApiDocument, OpenApiExportOptions, OpenApiOperation, OpenApiParameter, OpenApiParseOptions, OpenApiSchema, OpenApiServer, OpenApiSource, OpenApiTransportHints, OpenApiVersion, ParameterLocation, ParseResult, ParsedOperation, ParsedParameter } from "./openapi/types.js";
+import { detectFormat, detectVersion, parseOpenApiString } from "./openapi/parser/utils.js";
+import { parseOpenApi, parseOpenApiDocument } from "./openapi/parser/document.js";
+import { OperationsExportResult, defaultRestPath, exportOperations, generateOperationsRegistry, jsonSchemaForSpec, schemaModelToJsonSchema, toHttpMethod, toOperationId, toRestPath, toSchemaName } from "./openapi/exporter/operations.js";
+import { ContractSpecRegistries, contractSpecToJson, contractSpecToYaml, exportContractSpec, openApiForRegistry, openApiToJson, openApiToYaml } from "./openapi/exporter.js";
+import { ExportedEvent, exportEvents, generateEventsExports } from "./openapi/exporter/events.js";
+import { ExportedFeature, exportFeatures, generateFeaturesRegistry } from "./openapi/exporter/features.js";
+import { ExportedPresentation, exportPresentations, exportPresentationsFromArray, generatePresentationsRegistry } from "./openapi/exporter/presentations.js";
+import { ExportedForm, exportForms, generateFormsRegistry } from "./openapi/exporter/forms.js";
+import { ExportedDataView, exportDataViews, generateDataViewsRegistry } from "./openapi/exporter/data-views.js";
+import { ExportedWorkflow, exportWorkflows, generateWorkflowsRegistry } from "./openapi/exporter/workflows.js";
+import { RegistryGenerationOptions, generateRegistryIndex } from "./openapi/exporter/registries.js";
+import { GeneratedModel, SchemaField, TypescriptType, generateImports, generateSchemaModelCode, getScalarType, jsonSchemaToType } from "./openapi/schema-converter.js";
+import { importFromOpenApi, importOperation } from "./openapi/importer/index.js";
+import { DiffOptions, createSpecDiff, diffAll, diffSpecVsOperation, diffSpecs, formatDiffChanges } from "./openapi/differ.js";
+export { ContractSpecOpenApiDocument, ContractSpecRegistries, DiffChange, DiffChangeType, DiffOptions, ExportedDataView, ExportedEvent, ExportedFeature, ExportedForm, ExportedPresentation, ExportedWorkflow, GeneratedModel, HttpMethod, ImportResult, ImportedOperationSpec, OpenApiDocument, OpenApiExportOptions, OpenApiOperation, OpenApiParameter, OpenApiParseOptions, OpenApiSchema, OpenApiServer, OpenApiSource, OpenApiTransportHints, OpenApiVersion, OperationsExportResult, ParameterLocation, ParseResult, ParsedOperation, ParsedParameter, RegistryGenerationOptions, SchemaField, SpecDiff, SpecSource, SyncResult, TransportHints, TypescriptType, ValidationResult, contractSpecToJson, contractSpecToYaml, createSpecDiff, deepEqual, defaultRestPath, detectFormat, detectVersion, diffAll, diffSpecVsOperation, diffSpecs, exportContractSpec, exportDataViews, exportEvents, exportFeatures, exportForms, exportOperations, exportPresentations, exportPresentationsFromArray, exportWorkflows, extractPathParams, formatDiffChanges, generateDataViewsRegistry, generateEventsExports, generateFeaturesRegistry, generateFormsRegistry, generateImports, generateOperationsRegistry, generatePresentationsRegistry, generateRegistryIndex, generateSchemaModelCode, generateWorkflowsRegistry, getByPath, getScalarType, importFromOpenApi, importOperation, jsonSchemaForSpec, jsonSchemaToType, normalizePath, openApiForRegistry, openApiToJson, openApiToYaml, parseOpenApi, parseOpenApiDocument, parseOpenApiString, schemaModelToJsonSchema, toCamelCase, toFileName, toHttpMethod, toKebabCase, toOperationId, toPascalCase, toRestPath, toSchemaName, toSnakeCase, toSpecKey, toValidIdentifier };

package/dist/index.js

@@ -0,0 +1,18 @@
+import { detectFormat, detectVersion, parseOpenApiString } from "./openapi/parser/utils.js";
+import { parseOpenApi, parseOpenApiDocument } from "./openapi/parser/document.js";
+import { defaultRestPath, exportOperations, generateOperationsRegistry, jsonSchemaForSpec, schemaModelToJsonSchema, toHttpMethod, toOperationId, toRestPath, toSchemaName } from "./openapi/exporter/operations.js";
+import { exportEvents, generateEventsExports } from "./openapi/exporter/events.js";
+import { exportFeatures, generateFeaturesRegistry } from "./openapi/exporter/features.js";
+import { exportPresentations, exportPresentationsFromArray, generatePresentationsRegistry } from "./openapi/exporter/presentations.js";
+import { exportForms, generateFormsRegistry } from "./openapi/exporter/forms.js";
+import { exportDataViews, generateDataViewsRegistry } from "./openapi/exporter/data-views.js";
+import { exportWorkflows, generateWorkflowsRegistry } from "./openapi/exporter/workflows.js";
+import { generateRegistryIndex } from "./openapi/exporter/registries.js";
+import { contractSpecToJson, contractSpecToYaml, exportContractSpec, openApiForRegistry, openApiToJson, openApiToYaml } from "./openapi/exporter.js";
+import { deepEqual, extractPathParams, getByPath, normalizePath, toCamelCase, toFileName, toKebabCase, toPascalCase, toSnakeCase, toSpecKey, toValidIdentifier } from "./common/utils.js";
+import { generateImports, generateSchemaModelCode, getScalarType, jsonSchemaToType } from "./openapi/schema-converter.js";
+import { importFromOpenApi, importOperation } from "./openapi/importer/index.js";
+import { createSpecDiff, diffAll, diffSpecVsOperation, diffSpecs, formatDiffChanges } from "./openapi/differ.js";
+import "./openapi/index.js";
+
+export { contractSpecToJson, contractSpecToYaml, createSpecDiff, deepEqual, defaultRestPath, detectFormat, detectVersion, diffAll, diffSpecVsOperation, diffSpecs, exportContractSpec, exportDataViews, exportEvents, exportFeatures, exportForms, exportOperations, exportPresentations, exportPresentationsFromArray, exportWorkflows, extractPathParams, formatDiffChanges, generateDataViewsRegistry, generateEventsExports, generateFeaturesRegistry, generateFormsRegistry, generateImports, generateOperationsRegistry, generatePresentationsRegistry, generateRegistryIndex, generateSchemaModelCode, generateWorkflowsRegistry, getByPath, getScalarType, importFromOpenApi, importOperation, jsonSchemaForSpec, jsonSchemaToType, normalizePath, openApiForRegistry, openApiToJson, openApiToYaml, parseOpenApi, parseOpenApiDocument, parseOpenApiString, schemaModelToJsonSchema, toCamelCase, toFileName, toHttpMethod, toKebabCase, toOperationId, toPascalCase, toRestPath, toSchemaName, toSnakeCase, toSpecKey, toValidIdentifier };

package/dist/openapi/differ.d.ts

@@ -0,0 +1,42 @@
+import { DiffChange, ImportedOperationSpec, SpecDiff } from "../common/types.js";
+import { ParsedOperation } from "./types.js";
+import { AnyOperationSpec } from "@contractspec/lib.contracts";
+
+//#region src/openapi/differ.d.ts
+
+/**
+ * Options for diffing specs.
+ */
+interface DiffOptions {
+  /** Ignore description changes */
+  ignoreDescriptions?: boolean;
+  /** Ignore tag changes */
+  ignoreTags?: boolean;
+  /** Ignore transport changes (path, method) */
+  ignoreTransport?: boolean;
+  /** Custom paths to ignore */
+  ignorePaths?: string[];
+}
+/**
+ * Diff a ContractSpec against an OpenAPI operation.
+ */
+declare function diffSpecVsOperation(spec: AnyOperationSpec, operation: ParsedOperation, options?: DiffOptions): DiffChange[];
+/**
+ * Diff two ContractSpecs.
+ */
+declare function diffSpecs(oldSpec: AnyOperationSpec, newSpec: AnyOperationSpec, options?: DiffOptions): DiffChange[];
+/**
+ * Create a SpecDiff from an existing spec and an imported spec.
+ */
+declare function createSpecDiff(operationId: string, existing: AnyOperationSpec | undefined, incoming: ImportedOperationSpec, options?: DiffOptions): SpecDiff;
+/**
+ * Batch diff multiple specs against OpenAPI operations.
+ */
+declare function diffAll(existingSpecs: Map<string, AnyOperationSpec>, importedSpecs: ImportedOperationSpec[], options?: DiffOptions): SpecDiff[];
+/**
+ * Format diff changes for display.
+ */
+declare function formatDiffChanges(changes: DiffChange[]): string;
+//#endregion
+export { DiffOptions, createSpecDiff, diffAll, diffSpecVsOperation, diffSpecs, formatDiffChanges };
+//# sourceMappingURL=differ.d.ts.map

package/dist/openapi/differ.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"differ.d.ts","names":[],"sources":["../../src/openapi/differ.ts"],"sourcesContent":[],"mappings":";;;;;;;;;AAwIG,UAtHc,WAAA,CAsHd;EAAU;EA2EG,kBAAS,CAAA,EAAA,OAAA;EACd;EACA,UAAA,CAAA,EAAA,OAAA;EACA;EACR,eAAA,CAAA,EAAA,OAAA;EAAU;EA+CG,WAAA,CAAA,EAAA,MAAc,EAAA;;;;;AAKnB,iBAvIK,mBAAA,CAuIL,IAAA,EAtIH,gBAsIG,EAAA,SAAA,EArIE,eAqIF,EAAA,OAAA,CAAA,EApIA,WAoIA,CAAA,EAnIR,UAmIQ,EAAA;AA4CX;;;AAEiB,iBAtGD,SAAA,CAsGC,OAAA,EArGN,gBAqGM,EAAA,OAAA,EApGN,gBAoGM,EAAA,OAAA,CAAA,EAnGN,WAmGM,CAAA,EAlGd,UAkGc,EAAA;;;;AAsDD,iBAzGA,cAAA,CAyG2B,WAAU,EAAA,MAAA,EAAA,QAAA,EAvGzC,gBAuGyC,GAAA,SAAA,EAAA,QAAA,EAtGzC,qBAsGyC,EAAA,OAAA,CAAA,EArG1C,WAqG0C,CAAA,EApGlD,QAoGkD;;;;iBAxDrC,OAAA,gBACC,YAAY,kCACZ,mCACN,cACR;;;;iBAoDa,iBAAA,UAA2B"}