@lssm/bundle.contractspec-workspace 0.0.0-canary-20251217063201 → 0.0.0-canary-20251217072406

package/dist/libs/contracts/dist/spec.js

@@ -1 +1,35 @@
-const e=e=>`ref`in e,t=e=>({...e,meta:{...e.meta,kind:`command`},policy:{...e.policy,idempotent:e.policy?.policy?.idempotent??!1}}),n=e=>({...e,meta:{...e.meta,kind:`query`},policy:{...e.policy,idempotent:!0}});export{e,n,t};
+//#region ../../libs/contracts/dist/spec.js
+const isEmitDeclRef = (e) => "ref" in e;
+/**
+* Helper to define a Command (write operation).
+* Sets `kind: 'command'` and defaults `idempotent: false`.
+*/
+const defineCommand = (spec) => ({
+	...spec,
+	meta: {
+		...spec.meta,
+		kind: "command"
+	},
+	policy: {
+		...spec.policy,
+		idempotent: spec.policy?.["policy"]?.idempotent ?? false
+	}
+});
+/**
+* Helper to define a Query (read-only operation).
+* Sets `kind: 'query'` and forces `idempotent: true`.
+*/
+const defineQuery = (spec) => ({
+	...spec,
+	meta: {
+		...spec.meta,
+		kind: "query"
+	},
+	policy: {
+		...spec.policy,
+		idempotent: true
+	}
+});
+
+//#endregion
+export { defineCommand, defineQuery, isEmitDeclRef };

package/dist/libs/contracts/dist/telemetry/index.js

@@ -1 +1 @@
-import"./tracker.js";
+import "./tracker.js";

package/dist/libs/contracts/dist/telemetry/tracker.js

@@ -1 +1 @@
-import"crypto";
+import "crypto";

package/dist/libs/contracts/dist/tests/index.js

@@ -1 +1 @@
-import{t as e}from"./runner.js";
+import { TestRunner } from "./runner.js";

package/dist/libs/contracts/dist/tests/runner.js

@@ -1 +1,150 @@
-import"../index.js";import{deepStrictEqual as e}from"node:assert";var t=class{constructor(e){this.config=e}async run(e){let t=[],n=0,r=0;for(let i of e.scenarios){await this.config.beforeEach?.(i);let a=await this.runScenario(e,i);t.push(a),a.status===`passed`?n+=1:r+=1,await this.config.afterEach?.(i,a)}return{spec:e,scenarios:t,passed:n,failed:r}}async runScenario(e,t){let n=[];try{let r=await this.createContext(),i=[...e.fixtures??[],...t.given??[]],a=[];for(let e of i)await this.executeOperation(e,r,a);let o=await this.executeOperation(t.when,r,a),s=t.then??[];for(let e of s){let t=this.evaluateAssertion(e,o,a);n.push(t)}return{scenario:t,status:n.some(e=>e.status===`failed`)?`failed`:`passed`,assertionResults:n}}catch(e){return{scenario:t,status:`failed`,error:e,assertionResults:n}}}async createContext(){return{...await this.config.createContext?.()??{}}}async executeOperation(e,t,n){let r={...t,eventPublisher:async e=>{n.push({name:e.name,version:e.version,payload:e.payload}),await t.eventPublisher?.(e)}};try{return{output:await this.config.registry.execute(e.operation.name,e.operation.version,e.input??null,r),events:n}}catch(e){return{error:e,events:n}}}evaluateAssertion(e,t,n){switch(e.type){case`expectOutput`:return this.evaluateOutputAssertion(e,t);case`expectError`:return this.evaluateErrorAssertion(e,t);case`expectEvents`:return this.evaluateEventsAssertion(e,n);default:return{assertion:e,status:`failed`,message:`Unknown assertion type ${e.type}`}}}evaluateOutputAssertion(t,n){if(n.error)return{assertion:t,status:`failed`,message:`Expected output but operation threw error: ${n.error.message}`};try{return e(n.output,t.match),{assertion:t,status:`passed`}}catch(e){return{assertion:t,status:`failed`,message:e instanceof Error?e.message:`Output assertion failed`}}}evaluateErrorAssertion(e,t){return t.error?e.messageIncludes&&!t.error.message.includes(e.messageIncludes)?{assertion:e,status:`failed`,message:`Error message "${t.error.message}" did not include expected substring "${e.messageIncludes}"`}:{assertion:e,status:`passed`}:{assertion:e,status:`failed`,message:`Expected an error but operation completed successfully`}}evaluateEventsAssertion(e,t){let n=[];for(let r of e.events){let e=t.filter(e=>e.name===r.name&&e.version===r.version).length;typeof r.min==`number`&&e<r.min||typeof r.max==`number`&&e>r.max?n.push(`Event ${r.name}.v${r.version} occurred ${e} times (expected ${r.min??0} - ${r.max??`∞`})`):r.min===void 0&&r.max===void 0&&e===0&&n.push(`Event ${r.name}.v${r.version} did not occur`)}return n.length>0?{assertion:e,status:`failed`,message:n.join(`; `)}:{assertion:e,status:`passed`}}};export{t};
+import "../index.js";
+import { deepStrictEqual } from "node:assert";
+
+//#region ../../libs/contracts/dist/tests/runner.js
+var TestRunner = class {
+	constructor(config) {
+		this.config = config;
+	}
+	async run(spec) {
+		const scenarios = [];
+		let passed = 0;
+		let failed = 0;
+		for (const scenario of spec.scenarios) {
+			await this.config.beforeEach?.(scenario);
+			const result = await this.runScenario(spec, scenario);
+			scenarios.push(result);
+			if (result.status === "passed") passed += 1;
+			else failed += 1;
+			await this.config.afterEach?.(scenario, result);
+		}
+		return {
+			spec,
+			scenarios,
+			passed,
+			failed
+		};
+	}
+	async runScenario(spec, scenario) {
+		const assertionResults = [];
+		try {
+			const context = await this.createContext();
+			const fixtures = [...spec.fixtures ?? [], ...scenario.given ?? []];
+			const events = [];
+			for (const fixture of fixtures) await this.executeOperation(fixture, context, events);
+			const actionResult = await this.executeOperation(scenario.when, context, events);
+			const assertions = scenario.then ?? [];
+			for (const assertion of assertions) {
+				const assertionResult = this.evaluateAssertion(assertion, actionResult, events);
+				assertionResults.push(assertionResult);
+			}
+			return {
+				scenario,
+				status: assertionResults.some((assertion) => assertion.status === "failed") ? "failed" : "passed",
+				assertionResults
+			};
+		} catch (error) {
+			return {
+				scenario,
+				status: "failed",
+				error,
+				assertionResults
+			};
+		}
+	}
+	async createContext() {
+		return { ...await this.config.createContext?.() ?? {} };
+	}
+	async executeOperation(action, baseCtx, recordedEvents) {
+		const ctx = {
+			...baseCtx,
+			eventPublisher: async (event) => {
+				recordedEvents.push({
+					name: event.name,
+					version: event.version,
+					payload: event.payload
+				});
+				await baseCtx.eventPublisher?.(event);
+			}
+		};
+		try {
+			return {
+				output: await this.config.registry.execute(action.operation.name, action.operation.version, action.input ?? null, ctx),
+				events: recordedEvents
+			};
+		} catch (error) {
+			return {
+				error,
+				events: recordedEvents
+			};
+		}
+	}
+	evaluateAssertion(assertion, result, events) {
+		switch (assertion.type) {
+			case "expectOutput": return this.evaluateOutputAssertion(assertion, result);
+			case "expectError": return this.evaluateErrorAssertion(assertion, result);
+			case "expectEvents": return this.evaluateEventsAssertion(assertion, events);
+			default: return {
+				assertion,
+				status: "failed",
+				message: `Unknown assertion type ${assertion.type}`
+			};
+		}
+	}
+	evaluateOutputAssertion(assertion, result) {
+		if (result.error) return {
+			assertion,
+			status: "failed",
+			message: `Expected output but operation threw error: ${result.error.message}`
+		};
+		try {
+			deepStrictEqual(result.output, assertion.match);
+			return {
+				assertion,
+				status: "passed"
+			};
+		} catch (error) {
+			return {
+				assertion,
+				status: "failed",
+				message: error instanceof Error ? error.message : "Output assertion failed"
+			};
+		}
+	}
+	evaluateErrorAssertion(assertion, result) {
+		if (!result.error) return {
+			assertion,
+			status: "failed",
+			message: "Expected an error but operation completed successfully"
+		};
+		if (assertion.messageIncludes && !result.error.message.includes(assertion.messageIncludes)) return {
+			assertion,
+			status: "failed",
+			message: `Error message "${result.error.message}" did not include expected substring "${assertion.messageIncludes}"`
+		};
+		return {
+			assertion,
+			status: "passed"
+		};
+	}
+	evaluateEventsAssertion(assertion, events) {
+		const failures = [];
+		for (const expected of assertion.events) {
+			const count = events.filter((event) => event.name === expected.name && event.version === expected.version).length;
+			if (typeof expected.min === "number" && count < expected.min || typeof expected.max === "number" && count > expected.max) failures.push(`Event ${expected.name}.v${expected.version} occurred ${count} times (expected ${expected.min ?? 0} - ${expected.max ?? "∞"})`);
+			else if (typeof expected.min === "undefined" && typeof expected.max === "undefined" && count === 0) failures.push(`Event ${expected.name}.v${expected.version} did not occur`);
+		}
+		if (failures.length > 0) return {
+			assertion,
+			status: "failed",
+			message: failures.join("; ")
+		};
+		return {
+			assertion,
+			status: "passed"
+		};
+	}
+};
+
+//#endregion
+export { TestRunner };

package/dist/libs/contracts/dist/workflow/index.js

@@ -1 +1 @@
-import"./runner.js";
+import "./runner.js";

package/dist/libs/contracts/dist/workflow/runner.js

@@ -1 +1 @@
-import"node:crypto";
+import "node:crypto";

package/dist/libs/contracts-transformers/dist/common/utils.js

@@ -1 +1,47 @@
-function e(e){return e.replace(/[-_./\s]+(.)?/g,(e,t)=>t?t.toUpperCase():``).replace(/^./,e=>e.toUpperCase())}function t(t){let n=e(t);return n.charAt(0).toLowerCase()+n.slice(1)}function n(e){return e.replace(/([a-z])([A-Z])/g,`$1-$2`).replace(/[\s_./]+/g,`-`).toLowerCase()}function r(e){let t=e.replace(/[^a-zA-Z0-9_$]/g,`_`);return/^[0-9]/.test(t)&&(t=`_`+t),t}function i(e,n){let r=t(e);return n?`${n}.${r}`:r}function a(e){return n(e.replace(/\./g,`-`))+`.ts`}export{i as a,e,r as i,a as o,t};
+//#region ../../libs/contracts-transformers/dist/common/utils.js
+/**
+* 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();
+}
+/**
+* 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 name from an operation identifier.
+*/
+function toSpecName(operationId, prefix) {
+	const name = toCamelCase(operationId);
+	return prefix ? `${prefix}.${name}` : name;
+}
+/**
+* Generate a file name from a spec name.
+*/
+function toFileName(specName) {
+	return toKebabCase(specName.replace(/\./g, "-")) + ".ts";
+}
+
+//#endregion
+export { toCamelCase, toFileName, toPascalCase, toSpecName, toValidIdentifier };

package/dist/libs/contracts-transformers/dist/openapi/exporter.js

@@ -1 +1 @@
-import"zod";
+import "zod";

package/dist/libs/contracts-transformers/dist/openapi/importer.js

@@ -1,2 +1,255 @@
-import{a as e,e as t,i as n,o as r}from"../common/utils.js";import{d as i,l as a}from"./schema-converter.js";const o=[`post`,`put`,`delete`,`patch`];function s(e){return o.includes(e.toLowerCase())?`command`:`query`}function c(e,t){if(!e.security||e.security.length===0)return t;for(let t of e.security)if(Object.keys(t).length===0)return`anonymous`;return`user`}function l(e){let t=[];for(let n of e.pathParams)t.push({name:n.name,schema:n.schema,required:!0});for(let n of e.queryParams)t.push({name:n.name,schema:n.schema,required:n.required});let n=[`authorization`,`content-type`,`accept`,`user-agent`];for(let r of e.headerParams)n.includes(r.name.toLowerCase())||t.push({name:r.name,schema:r.schema,required:r.required});if(e.requestBody?.schema){let n=e.requestBody.schema;if(`$ref`in n)t.push({name:`body`,schema:n,required:e.requestBody.required});else{let e=n,r=e.properties,i=e.required??[];if(r)for(let[e,n]of Object.entries(r))t.push({name:e,schema:n,required:i.includes(e)})}}return t.length===0?{schema:null,fields:[]}:{schema:{type:`object`,properties:t.reduce((e,t)=>(e[t.name]=t.schema,e),{}),required:t.filter(e=>e.required).map(e=>e.name)},fields:t}}function u(e){for(let t of[`200`,`201`,`202`,`204`]){let n=e.responses[t];if(n?.schema)return n.schema}for(let[t,n]of Object.entries(e.responses))if(t.startsWith(`2`)&&n.schema)return n.schema;return null}function d(r,a,o,l){let u=e(r.operationId,a.prefix),d=s(r.method),f=c(r,a.defaultAuth??`user`),p=[];p.push(`import { defineCommand, defineQuery } from '@lssm/lib.contracts';`),(o||l)&&p.push(i([...o?.fields??[],...l?.fields??[]])),p.push(``),o&&o.code&&(p.push(`// Input schema`),p.push(o.code),p.push(``)),l&&l.code&&(p.push(`// Output schema`),p.push(l.code),p.push(``));let m=d===`command`?`defineCommand`:`defineQuery`,h=n(t(r.operationId));return p.push(`/**`),p.push(` * ${r.summary??r.operationId}`),r.description&&(p.push(` *`),p.push(` * ${r.description}`)),p.push(` *`),p.push(` * @source OpenAPI: ${r.method.toUpperCase()} ${r.path}`),p.push(` */`),p.push(`export const ${h}Spec = ${m}({`),p.push(`  meta: {`),p.push(`    name: '${u}',`),p.push(`    version: 1,`),p.push(`    stability: '${a.defaultStability??`stable`}',`),p.push(`    owners: [${(a.defaultOwners??[]).map(e=>`'${e}'`).join(`, `)}],`),p.push(`    tags: [${r.tags.map(e=>`'${e}'`).join(`, `)}],`),p.push(`    description: ${JSON.stringify(r.summary??r.operationId)},`),p.push(`    goal: ${JSON.stringify(r.description??`Imported from OpenAPI`)},`),p.push(`    context: 'Imported from OpenAPI: ${r.method.toUpperCase()} ${r.path}',`),p.push(`  },`),p.push(`  io: {`),o?p.push(`    input: ${o.name},`):p.push(`    input: null,`),l?p.push(`    output: ${l.name},`):p.push(`    output: null, // TODO: Define output schema`),p.push(`  },`),p.push(`  policy: {`),p.push(`    auth: '${f}',`),p.push(`  },`),p.push(`  transport: {`),p.push(`    rest: {`),p.push(`      method: '${r.method.toUpperCase()}',`),p.push(`      path: '${r.path}',`),p.push(`    },`),p.push(`  },`),p.push(`});`),p.join(`
-`)}function f(t,n={}){let{tags:i,exclude:o=[],include:s}=n,c=[],f=[],p=[];for(let m of t.operations){if(i&&i.length>0&&!m.tags.some(e=>i.includes(e))){f.push({sourceId:m.operationId,reason:`No matching tags (has: ${m.tags.join(`, `)})`});continue}if(s&&s.length>0){if(!s.includes(m.operationId)){f.push({sourceId:m.operationId,reason:`Not in include list`});continue}}else if(o.includes(m.operationId)){f.push({sourceId:m.operationId,reason:`In exclude list`});continue}if(m.deprecated&&n.defaultStability!==`deprecated`){f.push({sourceId:m.operationId,reason:`Deprecated operation`});continue}try{let{schema:i}=l(m),o=i?a(i,`${m.operationId}Input`):null,s=u(m),f=d(m,n,o,s?a(s,`${m.operationId}Output`):null),p=r(e(m.operationId,n.prefix)),h={rest:{method:m.method.toUpperCase(),path:m.path,params:{path:m.pathParams.map(e=>e.name),query:m.queryParams.map(e=>e.name),header:m.headerParams.map(e=>e.name),cookie:m.cookieParams.map(e=>e.name)}}},g={type:`openapi`,sourceId:m.operationId,operationId:m.operationId,openApiVersion:t.version,importedAt:new Date};c.push({spec:{},code:f,fileName:p,source:g,transportHints:h})}catch(e){p.push({sourceId:m.operationId,error:e instanceof Error?e.message:String(e)})}}return{specs:c,skipped:f,errors:p,summary:{total:t.operations.length,imported:c.length,skipped:f.length,errors:p.length}}}export{f};
+import { toFileName, toPascalCase, toSpecName, toValidIdentifier } from "../common/utils.js";
+import { generateImports, generateSchemaModelCode } from "./schema-converter.js";
+
+//#region ../../libs/contracts-transformers/dist/openapi/importer.js
+/**
+* HTTP methods that typically indicate a command (state-changing).
+*/
+const COMMAND_METHODS = [
+	"post",
+	"put",
+	"delete",
+	"patch"
+];
+/**
+* Determine if an operation is a command or query based on HTTP method.
+*/
+function inferOpKind(method) {
+	return COMMAND_METHODS.includes(method.toLowerCase()) ? "command" : "query";
+}
+/**
+* Determine auth level based on security requirements.
+*/
+function inferAuthLevel(operation, defaultAuth) {
+	if (!operation.security || operation.security.length === 0) return defaultAuth;
+	for (const sec of operation.security) if (Object.keys(sec).length === 0) return "anonymous";
+	return "user";
+}
+/**
+* Build a merged input schema from all parameter sources.
+*/
+function buildInputSchema(operation) {
+	const fields = [];
+	for (const param of operation.pathParams) fields.push({
+		name: param.name,
+		schema: param.schema,
+		required: true
+	});
+	for (const param of operation.queryParams) fields.push({
+		name: param.name,
+		schema: param.schema,
+		required: param.required
+	});
+	const excludedHeaders = [
+		"authorization",
+		"content-type",
+		"accept",
+		"user-agent"
+	];
+	for (const param of operation.headerParams) if (!excludedHeaders.includes(param.name.toLowerCase())) fields.push({
+		name: param.name,
+		schema: param.schema,
+		required: param.required
+	});
+	if (operation.requestBody?.schema) {
+		const bodySchema = operation.requestBody.schema;
+		if (!("$ref" in bodySchema)) {
+			const schemaObj = bodySchema;
+			const properties = schemaObj["properties"];
+			const required = schemaObj["required"] ?? [];
+			if (properties) for (const [propName, propSchema] of Object.entries(properties)) fields.push({
+				name: propName,
+				schema: propSchema,
+				required: required.includes(propName)
+			});
+		} else fields.push({
+			name: "body",
+			schema: bodySchema,
+			required: operation.requestBody.required
+		});
+	}
+	if (fields.length === 0) return {
+		schema: null,
+		fields: []
+	};
+	return {
+		schema: {
+			type: "object",
+			properties: fields.reduce((acc, f) => {
+				acc[f.name] = f.schema;
+				return acc;
+			}, {}),
+			required: fields.filter((f) => f.required).map((f) => f.name)
+		},
+		fields
+	};
+}
+/**
+* Get the output schema from the operation responses.
+*/
+function getOutputSchema(operation) {
+	for (const code of [
+		"200",
+		"201",
+		"202",
+		"204"
+	]) {
+		const response = operation.responses[code];
+		if (response?.schema) return response.schema;
+	}
+	for (const [code, response] of Object.entries(operation.responses)) if (code.startsWith("2") && response.schema) return response.schema;
+	return null;
+}
+/**
+* Generate ContractSpec TypeScript code for an operation.
+*/
+function generateSpecCode(operation, options, inputModel, outputModel) {
+	const specName = toSpecName(operation.operationId, options.prefix);
+	const kind = inferOpKind(operation.method);
+	const auth = inferAuthLevel(operation, options.defaultAuth ?? "user");
+	const lines = [];
+	lines.push("import { defineCommand, defineQuery } from '@lssm/lib.contracts';");
+	if (inputModel || outputModel) lines.push(generateImports([...inputModel?.fields ?? [], ...outputModel?.fields ?? []]));
+	lines.push("");
+	if (inputModel && inputModel.code) {
+		lines.push("// Input schema");
+		lines.push(inputModel.code);
+		lines.push("");
+	}
+	if (outputModel && outputModel.code) {
+		lines.push("// Output schema");
+		lines.push(outputModel.code);
+		lines.push("");
+	}
+	const defineFunc = kind === "command" ? "defineCommand" : "defineQuery";
+	const safeName = toValidIdentifier(toPascalCase(operation.operationId));
+	lines.push(`/**`);
+	lines.push(` * ${operation.summary ?? operation.operationId}`);
+	if (operation.description) {
+		lines.push(` *`);
+		lines.push(` * ${operation.description}`);
+	}
+	lines.push(` *`);
+	lines.push(` * @source OpenAPI: ${operation.method.toUpperCase()} ${operation.path}`);
+	lines.push(` */`);
+	lines.push(`export const ${safeName}Spec = ${defineFunc}({`);
+	lines.push("  meta: {");
+	lines.push(`    name: '${specName}',`);
+	lines.push("    version: 1,");
+	lines.push(`    stability: '${options.defaultStability ?? "stable"}',`);
+	lines.push(`    owners: [${(options.defaultOwners ?? []).map((o) => `'${o}'`).join(", ")}],`);
+	lines.push(`    tags: [${operation.tags.map((t) => `'${t}'`).join(", ")}],`);
+	lines.push(`    description: ${JSON.stringify(operation.summary ?? operation.operationId)},`);
+	lines.push(`    goal: ${JSON.stringify(operation.description ?? "Imported from OpenAPI")},`);
+	lines.push(`    context: 'Imported from OpenAPI: ${operation.method.toUpperCase()} ${operation.path}',`);
+	lines.push("  },");
+	lines.push("  io: {");
+	if (inputModel) lines.push(`    input: ${inputModel.name},`);
+	else lines.push("    input: null,");
+	if (outputModel) lines.push(`    output: ${outputModel.name},`);
+	else lines.push("    output: null, // TODO: Define output schema");
+	lines.push("  },");
+	lines.push("  policy: {");
+	lines.push(`    auth: '${auth}',`);
+	lines.push("  },");
+	lines.push("  transport: {");
+	lines.push("    rest: {");
+	lines.push(`      method: '${operation.method.toUpperCase()}',`);
+	lines.push(`      path: '${operation.path}',`);
+	lines.push("    },");
+	lines.push("  },");
+	lines.push("});");
+	return lines.join("\n");
+}
+/**
+* Import operations from a parsed OpenAPI document.
+*/
+function importFromOpenApi(parseResult, options = {}) {
+	const { tags, exclude = [], include } = options;
+	const specs = [];
+	const skipped = [];
+	const errors = [];
+	for (const operation of parseResult.operations) {
+		if (tags && tags.length > 0) {
+			if (!operation.tags.some((t) => tags.includes(t))) {
+				skipped.push({
+					sourceId: operation.operationId,
+					reason: `No matching tags (has: ${operation.tags.join(", ")})`
+				});
+				continue;
+			}
+		}
+		if (include && include.length > 0) {
+			if (!include.includes(operation.operationId)) {
+				skipped.push({
+					sourceId: operation.operationId,
+					reason: "Not in include list"
+				});
+				continue;
+			}
+		} else if (exclude.includes(operation.operationId)) {
+			skipped.push({
+				sourceId: operation.operationId,
+				reason: "In exclude list"
+			});
+			continue;
+		}
+		if (operation.deprecated && options.defaultStability !== "deprecated") {
+			skipped.push({
+				sourceId: operation.operationId,
+				reason: "Deprecated operation"
+			});
+			continue;
+		}
+		try {
+			const { schema: inputSchema } = buildInputSchema(operation);
+			const inputModel = inputSchema ? generateSchemaModelCode(inputSchema, `${operation.operationId}Input`) : null;
+			const outputSchema = getOutputSchema(operation);
+			const code = generateSpecCode(operation, options, inputModel, outputSchema ? generateSchemaModelCode(outputSchema, `${operation.operationId}Output`) : null);
+			const fileName = toFileName(toSpecName(operation.operationId, options.prefix));
+			const transportHints = { rest: {
+				method: operation.method.toUpperCase(),
+				path: operation.path,
+				params: {
+					path: operation.pathParams.map((p) => p.name),
+					query: operation.queryParams.map((p) => p.name),
+					header: operation.headerParams.map((p) => p.name),
+					cookie: operation.cookieParams.map((p) => p.name)
+				}
+			} };
+			const source = {
+				type: "openapi",
+				sourceId: operation.operationId,
+				operationId: operation.operationId,
+				openApiVersion: parseResult.version,
+				importedAt: /* @__PURE__ */ new Date()
+			};
+			specs.push({
+				spec: {},
+				code,
+				fileName,
+				source,
+				transportHints
+			});
+		} catch (error) {
+			errors.push({
+				sourceId: operation.operationId,
+				error: error instanceof Error ? error.message : String(error)
+			});
+		}
+	}
+	return {
+		specs,
+		skipped,
+		errors,
+		summary: {
+			total: parseResult.operations.length,
+			imported: specs.length,
+			skipped: skipped.length,
+			errors: errors.length
+		}
+	};
+}
+
+//#endregion
+export { importFromOpenApi };

package/dist/libs/contracts-transformers/dist/openapi/index.js

@@ -1 +1,4 @@
-import{d as e,f as t,i as n,n as r,r as i}from"./parser.js";import"./exporter.js";import{c as a,d as o,l as s,o as c,s as l}from"./schema-converter.js";import{f as u}from"./importer.js";
+import { detectFormat, detectVersion, parseOpenApi, parseOpenApiDocument, parseOpenApiString } from "./parser.js";
+import "./exporter.js";
+import { generateImports, generateSchemaModelCode, getScalarType, jsonSchemaToField, jsonSchemaToType } from "./schema-converter.js";
+import { importFromOpenApi } from "./importer.js";