@lssm/lib.contracts-transformers 0.0.0-canary-20251220041653 → 0.0.0-canary-20251221132705

package/dist/openapi/parser/resolvers.js

@@ -0,0 +1,63 @@
+//#region src/openapi/parser/resolvers.ts
+/**
+* Check if a value is a reference object.
+*/
+function isReference(obj) {
+	return typeof obj === "object" && obj !== null && "$ref" in obj;
+}
+/**
+* Resolve a $ref reference in the document.
+*/
+function resolveRef(doc, ref) {
+	if (!ref.startsWith("#/")) return;
+	const path = ref.slice(2).split("/");
+	let current = doc;
+	for (const part of path) {
+		if (current === null || current === void 0) return void 0;
+		if (typeof current !== "object") return void 0;
+		current = current[part];
+	}
+	return current;
+}
+/**
+* Recursively dereference a schema.
+* Replaces all $ref with their resolved values.
+* Preserves `_originalRef` to track where the schema came from.
+*/
+function dereferenceSchema(doc, schema, seen = /* @__PURE__ */ new Set()) {
+	if (!schema) return void 0;
+	if (isReference(schema)) {
+		if (seen.has(schema.$ref)) return schema;
+		const newSeen = new Set(seen);
+		newSeen.add(schema.$ref);
+		const resolved = resolveRef(doc, schema.$ref);
+		if (!resolved) return schema;
+		const dereferenced = dereferenceSchema(doc, resolved, newSeen);
+		if (!dereferenced) return schema;
+		const refParts = schema.$ref.split("/");
+		const typeName = refParts[refParts.length - 1];
+		return {
+			...dereferenced,
+			_originalRef: schema.$ref,
+			_originalTypeName: typeName
+		};
+	}
+	const schemaObj = { ...schema };
+	if (schemaObj.properties) {
+		const props = schemaObj.properties;
+		const newProps = {};
+		for (const [key, prop] of Object.entries(props)) newProps[key] = dereferenceSchema(doc, prop, seen) ?? prop;
+		schemaObj.properties = newProps;
+	}
+	if (schemaObj.items) schemaObj.items = dereferenceSchema(doc, schemaObj.items, seen);
+	for (const comb of [
+		"allOf",
+		"anyOf",
+		"oneOf"
+	]) if (Array.isArray(schemaObj[comb])) schemaObj[comb] = schemaObj[comb].map((s) => dereferenceSchema(doc, s, seen) ?? s);
+	return schemaObj;
+}
+
+//#endregion
+export { dereferenceSchema, isReference, resolveRef };
+//# sourceMappingURL=resolvers.js.map

package/dist/openapi/parser/resolvers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolvers.js","names":["current: unknown","newProps: Record<string, OpenApiSchema>"],"sources":["../../../src/openapi/parser/resolvers.ts"],"sourcesContent":["import type { OpenApiDocument, OpenApiSchema } from '../types';\nimport type { OpenAPIV3, OpenAPIV3_1 } from 'openapi-types';\n\n/**\n * Check if a value is a reference object.\n */\nexport function isReference(\n  obj: unknown\n): obj is OpenAPIV3.ReferenceObject | OpenAPIV3_1.ReferenceObject {\n  return typeof obj === 'object' && obj !== null && '$ref' in obj;\n}\n\n/**\n * Resolve a $ref reference in the document.\n */\nexport function resolveRef<T>(\n  doc: OpenApiDocument,\n  ref: string\n): T | undefined {\n  // Only support local refs for now\n  if (!ref.startsWith('#/')) {\n    return undefined;\n  }\n\n  const path = ref.slice(2).split('/');\n  let current: unknown = doc;\n\n  for (const part of path) {\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 as T;\n}\n\n/**\n * Resolve a schema, following $ref if needed.\n */\nexport function resolveSchema(\n  doc: OpenApiDocument,\n  schema: OpenApiSchema | undefined\n): OpenApiSchema | undefined {\n  if (!schema) return undefined;\n  if (isReference(schema)) {\n    return resolveRef<OpenApiSchema>(doc, schema.$ref) ?? schema;\n  }\n  return schema;\n}\n\n/**\n * Recursively dereference a schema.\n * Replaces all $ref with their resolved values.\n * Preserves `_originalRef` to track where the schema came from.\n */\nexport function dereferenceSchema(\n  doc: OpenApiDocument,\n  schema: OpenApiSchema | undefined,\n  seen = new Set<string>()\n): OpenApiSchema | undefined {\n  if (!schema) return undefined;\n\n  // Handle references\n  if (isReference(schema)) {\n    // Avoid infinite recursion for cycles\n    if (seen.has(schema.$ref)) {\n      return schema; // Keep reference for cycles\n    }\n\n    // Create new seen set for this branch\n    const newSeen = new Set(seen);\n    newSeen.add(schema.$ref);\n\n    const resolved = resolveRef<OpenApiSchema>(doc, schema.$ref);\n    if (!resolved) return schema;\n\n    // Recursively dereference the resolved schema\n    const dereferenced = dereferenceSchema(doc, resolved, newSeen);\n    if (!dereferenced) return schema;\n\n    // IMPORTANT: Preserve the original $ref so we can generate correct imports\n    // Extract the type name from the $ref (e.g., '#/components/schemas/PaginationMeta' -> 'PaginationMeta')\n    const refParts = schema.$ref.split('/');\n    const typeName = refParts[refParts.length - 1];\n    return {\n      ...dereferenced,\n      _originalRef: schema.$ref,\n      _originalTypeName: typeName,\n    } as unknown as OpenApiSchema;\n  }\n\n  // Deep clone to avoid mutating original doc (if we were modifying in place, but here we return new objects mostly)\n  // For simplicity, we just walk properties\n  const schemaObj = { ...schema } as Record<string, unknown>;\n\n  // Handle nested schemas in properties\n  if (schemaObj.properties) {\n    const props = schemaObj.properties as Record<string, OpenApiSchema>;\n    const newProps: Record<string, OpenApiSchema> = {};\n    for (const [key, prop] of Object.entries(props)) {\n      newProps[key] = dereferenceSchema(doc, prop, seen) ?? prop;\n    }\n    schemaObj.properties = newProps;\n  }\n\n  // Handle nested schema in items (array)\n  if (schemaObj.items) {\n    schemaObj.items = dereferenceSchema(\n      doc,\n      schemaObj.items as OpenApiSchema,\n      seen\n    );\n  }\n\n  // Handle allOf, anyOf, oneOf\n  const combinators = ['allOf', 'anyOf', 'oneOf'];\n  for (const comb of combinators) {\n    if (Array.isArray(schemaObj[comb])) {\n      schemaObj[comb] = (schemaObj[comb] as OpenApiSchema[]).map(\n        (s) => dereferenceSchema(doc, s, seen) ?? s\n      );\n    }\n  }\n\n  return schemaObj as OpenApiSchema;\n}\n"],"mappings":";;;;AAMA,SAAgB,YACd,KACgE;AAChE,QAAO,OAAO,QAAQ,YAAY,QAAQ,QAAQ,UAAU;;;;;AAM9D,SAAgB,WACd,KACA,KACe;AAEf,KAAI,CAAC,IAAI,WAAW,KAAK,CACvB;CAGF,MAAM,OAAO,IAAI,MAAM,EAAE,CAAC,MAAM,IAAI;CACpC,IAAIA,UAAmB;AAEvB,MAAK,MAAM,QAAQ,MAAM;AACvB,MAAI,YAAY,QAAQ,YAAY,OAAW,QAAO;AACtD,MAAI,OAAO,YAAY,SAAU,QAAO;AACxC,YAAW,QAAoC;;AAGjD,QAAO;;;;;;;AAsBT,SAAgB,kBACd,KACA,QACA,uBAAO,IAAI,KAAa,EACG;AAC3B,KAAI,CAAC,OAAQ,QAAO;AAGpB,KAAI,YAAY,OAAO,EAAE;AAEvB,MAAI,KAAK,IAAI,OAAO,KAAK,CACvB,QAAO;EAIT,MAAM,UAAU,IAAI,IAAI,KAAK;AAC7B,UAAQ,IAAI,OAAO,KAAK;EAExB,MAAM,WAAW,WAA0B,KAAK,OAAO,KAAK;AAC5D,MAAI,CAAC,SAAU,QAAO;EAGtB,MAAM,eAAe,kBAAkB,KAAK,UAAU,QAAQ;AAC9D,MAAI,CAAC,aAAc,QAAO;EAI1B,MAAM,WAAW,OAAO,KAAK,MAAM,IAAI;EACvC,MAAM,WAAW,SAAS,SAAS,SAAS;AAC5C,SAAO;GACL,GAAG;GACH,cAAc,OAAO;GACrB,mBAAmB;GACpB;;CAKH,MAAM,YAAY,EAAE,GAAG,QAAQ;AAG/B,KAAI,UAAU,YAAY;EACxB,MAAM,QAAQ,UAAU;EACxB,MAAMC,WAA0C,EAAE;AAClD,OAAK,MAAM,CAAC,KAAK,SAAS,OAAO,QAAQ,MAAM,CAC7C,UAAS,OAAO,kBAAkB,KAAK,MAAM,KAAK,IAAI;AAExD,YAAU,aAAa;;AAIzB,KAAI,UAAU,MACZ,WAAU,QAAQ,kBAChB,KACA,UAAU,OACV,KACD;AAKH,MAAK,MAAM,QADS;EAAC;EAAS;EAAS;EAAQ,CAE7C,KAAI,MAAM,QAAQ,UAAU,MAAM,CAChC,WAAU,QAAS,UAAU,MAA0B,KACpD,MAAM,kBAAkB,KAAK,GAAG,KAAK,IAAI,EAC3C;AAIL,QAAO"}

package/dist/openapi/parser/utils.d.ts

@@ -0,0 +1,19 @@
+import { OpenApiDocument, OpenApiVersion } from "../types.js";
+
+//#region src/openapi/parser/utils.d.ts
+
+/**
+ * Parse an OpenAPI document from a string (JSON or YAML).
+ */
+declare function parseOpenApiString(content: string, format?: 'json' | 'yaml'): OpenApiDocument;
+/**
+ * Detect the format of content (JSON or YAML).
+ */
+declare function detectFormat(content: string): 'json' | 'yaml';
+/**
+ * Detect OpenAPI version from document.
+ */
+declare function detectVersion(doc: OpenApiDocument): OpenApiVersion;
+//#endregion
+export { detectFormat, detectVersion, parseOpenApiString };
+//# sourceMappingURL=utils.d.ts.map

package/dist/openapi/parser/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","names":[],"sources":["../../../src/openapi/parser/utils.ts"],"sourcesContent":[],"mappings":";;;;;AAiBA;AAaA;AAWgB,iBAxBA,kBAAA,CAwBmB,OAAkB,EAAA,MAAA,EAAA,MAAc,CAAA,EAAA,MAAA,GAAA,MAAA,CAAA,EArBhE,eAqBgE;;;;iBAXnD,YAAA;;;;iBAWA,aAAA,MAAmB,kBAAkB"}

package/dist/openapi/parser/utils.js

@@ -0,0 +1,48 @@
+import { parse } from "yaml";
+
+//#region src/openapi/parser/utils.ts
+const HTTP_METHODS = [
+	"get",
+	"post",
+	"put",
+	"delete",
+	"patch",
+	"head",
+	"options",
+	"trace"
+];
+/**
+* Parse an OpenAPI document from a string (JSON or YAML).
+*/
+function parseOpenApiString(content, format = "json") {
+	if (format === "yaml") return parse(content);
+	return JSON.parse(content);
+}
+/**
+* Detect the format of content (JSON or YAML).
+*/
+function detectFormat(content) {
+	const trimmed = content.trim();
+	if (trimmed.startsWith("{") || trimmed.startsWith("[")) return "json";
+	return "yaml";
+}
+/**
+* Detect OpenAPI version from document.
+*/
+function detectVersion(doc) {
+	if (doc.openapi.startsWith("3.1")) return "3.1";
+	return "3.0";
+}
+/**
+* Generate an operationId if not present.
+*/
+function generateOperationId(method, path) {
+	return method + path.split("/").filter(Boolean).map((part) => {
+		if (part.startsWith("{") && part.endsWith("}")) return "By" + part.slice(1, -1).charAt(0).toUpperCase() + part.slice(2, -1);
+		return part.charAt(0).toUpperCase() + part.slice(1);
+	}).join("");
+}
+
+//#endregion
+export { HTTP_METHODS, detectFormat, detectVersion, generateOperationId, parseOpenApiString };
+//# sourceMappingURL=utils.js.map

package/dist/openapi/parser/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","names":["HTTP_METHODS: HttpMethod[]","parseYaml"],"sources":["../../../src/openapi/parser/utils.ts"],"sourcesContent":["import { parse as parseYaml } from 'yaml';\nimport type { OpenApiDocument, HttpMethod, OpenApiVersion } from '../types';\n\nexport const HTTP_METHODS: HttpMethod[] = [\n  'get',\n  'post',\n  'put',\n  'delete',\n  'patch',\n  'head',\n  'options',\n  'trace',\n];\n\n/**\n * Parse an OpenAPI document from a string (JSON or YAML).\n */\nexport function parseOpenApiString(\n  content: string,\n  format: 'json' | 'yaml' = 'json'\n): OpenApiDocument {\n  if (format === 'yaml') {\n    return parseYaml(content) as OpenApiDocument;\n  }\n  return JSON.parse(content) as OpenApiDocument;\n}\n\n/**\n * Detect the format of content (JSON or YAML).\n */\nexport function detectFormat(content: string): 'json' | 'yaml' {\n  const trimmed = content.trim();\n  if (trimmed.startsWith('{') || trimmed.startsWith('[')) {\n    return 'json';\n  }\n  return 'yaml';\n}\n\n/**\n * Detect OpenAPI version from document.\n */\nexport function detectVersion(doc: OpenApiDocument): OpenApiVersion {\n  const version = doc.openapi;\n  if (version.startsWith('3.1')) {\n    return '3.1';\n  }\n  return '3.0';\n}\n\n/**\n * Generate an operationId if not present.\n */\nexport function generateOperationId(method: HttpMethod, path: string): string {\n  // Convert path to camelCase operationId\n  const pathParts = path\n    .split('/')\n    .filter(Boolean)\n    .map((part) => {\n      // Remove path parameters\n      if (part.startsWith('{') && part.endsWith('}')) {\n        return (\n          'By' + part.slice(1, -1).charAt(0).toUpperCase() + part.slice(2, -1)\n        );\n      }\n      return part.charAt(0).toUpperCase() + part.slice(1);\n    });\n\n  return method + pathParts.join('');\n}\n"],"mappings":";;;AAGA,MAAaA,eAA6B;CACxC;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACD;;;;AAKD,SAAgB,mBACd,SACA,SAA0B,QACT;AACjB,KAAI,WAAW,OACb,QAAOC,MAAU,QAAQ;AAE3B,QAAO,KAAK,MAAM,QAAQ;;;;;AAM5B,SAAgB,aAAa,SAAkC;CAC7D,MAAM,UAAU,QAAQ,MAAM;AAC9B,KAAI,QAAQ,WAAW,IAAI,IAAI,QAAQ,WAAW,IAAI,CACpD,QAAO;AAET,QAAO;;;;;AAMT,SAAgB,cAAc,KAAsC;AAElE,KADgB,IAAI,QACR,WAAW,MAAM,CAC3B,QAAO;AAET,QAAO;;;;;AAMT,SAAgB,oBAAoB,QAAoB,MAAsB;AAe5E,QAAO,SAbW,KACf,MAAM,IAAI,CACV,OAAO,QAAQ,CACf,KAAK,SAAS;AAEb,MAAI,KAAK,WAAW,IAAI,IAAI,KAAK,SAAS,IAAI,CAC5C,QACE,OAAO,KAAK,MAAM,GAAG,GAAG,CAAC,OAAO,EAAE,CAAC,aAAa,GAAG,KAAK,MAAM,GAAG,GAAG;AAGxE,SAAO,KAAK,OAAO,EAAE,CAAC,aAAa,GAAG,KAAK,MAAM,EAAE;GACnD,CAEsB,KAAK,GAAG"}

package/dist/openapi/parser.js

@@ -1,232 +1,6 @@
-import { parse } from "yaml";
-
-//#region src/openapi/parser.ts
-/**
-* OpenAPI document parser.
-* Parses OpenAPI 3.x documents from JSON/YAML files or URLs.
-*/
-const HTTP_METHODS = [
-	"get",
-	"post",
-	"put",
-	"delete",
-	"patch",
-	"head",
-	"options",
-	"trace"
-];
-/**
-* Parse an OpenAPI document from a string (JSON or YAML).
-*/
-function parseOpenApiString(content, format = "json") {
-	if (format === "yaml") return parse(content);
-	return JSON.parse(content);
-}
-/**
-* Detect the format of content (JSON or YAML).
-*/
-function detectFormat(content) {
-	const trimmed = content.trim();
-	if (trimmed.startsWith("{") || trimmed.startsWith("[")) return "json";
-	return "yaml";
-}
-/**
-* Detect OpenAPI version from document.
-*/
-function detectVersion(doc) {
-	if (doc.openapi.startsWith("3.1")) return "3.1";
-	return "3.0";
-}
-/**
-* Check if a value is a reference object.
-*/
-function isReference(obj) {
-	return typeof obj === "object" && obj !== null && "$ref" in obj;
-}
-/**
-* Resolve a $ref reference in the document.
-*/
-function resolveRef(doc, ref) {
-	if (!ref.startsWith("#/")) return;
-	const path = ref.slice(2).split("/");
-	let current = doc;
-	for (const part of path) {
-		if (current === null || current === void 0) return void 0;
-		if (typeof current !== "object") return void 0;
-		current = current[part];
-	}
-	return current;
-}
-/**
-* Resolve a schema, following $ref if needed.
-*/
-function resolveSchema(doc, schema) {
-	if (!schema) return void 0;
-	if (isReference(schema)) return resolveRef(doc, schema.$ref) ?? schema;
-	return schema;
-}
-/**
-* Parse parameters from an operation.
-*/
-function parseParameters(doc, params) {
-	const result = {
-		path: [],
-		query: [],
-		header: [],
-		cookie: []
-	};
-	if (!params) return result;
-	for (const param of params) {
-		let resolved;
-		if (isReference(param)) {
-			const ref = resolveRef(doc, param.$ref);
-			if (!ref) continue;
-			resolved = ref;
-		} else resolved = param;
-		const parsed = {
-			name: resolved.name,
-			in: resolved.in,
-			required: resolved.required ?? resolved.in === "path",
-			description: resolved.description,
-			schema: resolved.schema,
-			deprecated: resolved.deprecated ?? false
-		};
-		result[resolved.in]?.push(parsed);
-	}
-	return result;
-}
-/**
-* Generate an operationId if not present.
-*/
-function generateOperationId(method, path) {
-	return method + path.split("/").filter(Boolean).map((part) => {
-		if (part.startsWith("{") && part.endsWith("}")) return "By" + part.slice(1, -1).charAt(0).toUpperCase() + part.slice(2, -1);
-		return part.charAt(0).toUpperCase() + part.slice(1);
-	}).join("");
-}
-/**
-* Parse a single operation.
-*/
-function parseOperation(doc, method, path, operation, pathParams) {
-	const params = parseParameters(doc, [...pathParams ?? [], ...operation.parameters ?? []]);
-	let requestBody;
-	if (operation.requestBody) {
-		const body = isReference(operation.requestBody) ? resolveRef(doc, operation.requestBody.$ref) : operation.requestBody;
-		if (body) {
-			const contentType = Object.keys(body.content ?? {})[0] ?? "application/json";
-			const content = body.content?.[contentType];
-			if (content?.schema) requestBody = {
-				required: body.required ?? false,
-				schema: resolveSchema(doc, content.schema) ?? {},
-				contentType
-			};
-		}
-	}
-	const responses = {};
-	for (const [status, response] of Object.entries(operation.responses ?? {})) {
-		const resolved = isReference(response) ? resolveRef(doc, response.$ref) : response;
-		if (resolved) {
-			const contentType = Object.keys(resolved.content ?? {})[0];
-			const content = contentType ? resolved.content?.[contentType] : void 0;
-			responses[status] = {
-				description: resolved.description,
-				schema: content?.schema ? resolveSchema(doc, content.schema) : void 0,
-				contentType
-			};
-		}
-	}
-	const contractSpecMeta = operation?.["x-contractspec"];
-	return {
-		operationId: operation.operationId ?? generateOperationId(method, path),
-		method,
-		path,
-		summary: operation.summary,
-		description: operation.description,
-		tags: operation.tags ?? [],
-		pathParams: params.path,
-		queryParams: params.query,
-		headerParams: params.header,
-		cookieParams: params.cookie,
-		requestBody,
-		responses,
-		deprecated: operation.deprecated ?? false,
-		security: operation.security,
-		contractSpecMeta
-	};
-}
-/**
-* Parse an OpenAPI document into a structured result.
-*/
-function parseOpenApiDocument(doc, _options = {}) {
-	const version = detectVersion(doc);
-	const warnings = [];
-	const operations = [];
-	for (const [path, pathItem] of Object.entries(doc.paths ?? {})) {
-		if (!pathItem) continue;
-		const pathParams = pathItem.parameters;
-		for (const method of HTTP_METHODS) {
-			const operation = pathItem[method];
-			if (operation) try {
-				operations.push(parseOperation(doc, method, path, operation, pathParams));
-			} catch (error) {
-				warnings.push(`Failed to parse ${method.toUpperCase()} ${path}: ${error}`);
-			}
-		}
-	}
-	const schemas = {};
-	const components = doc.components;
-	if (components?.schemas) for (const [name, schema] of Object.entries(components.schemas)) schemas[name] = schema;
-	const servers = (doc.servers ?? []).map((s) => ({
-		url: s.url,
-		description: s.description,
-		variables: s.variables
-	}));
-	return {
-		document: doc,
-		version,
-		info: {
-			title: doc.info.title,
-			version: doc.info.version,
-			description: doc.info.description
-		},
-		operations,
-		schemas,
-		servers,
-		warnings
-	};
-}
-/**
-* Parse OpenAPI from a file path or URL.
-* Note: This is an async function that requires I/O adapters.
-* For pure parsing, use parseOpenApiString or parseOpenApiDocument.
-*/
-async function parseOpenApi(source, options = {}) {
-	const { fetch: fetchFn = globalThis.fetch, readFile, timeout = 3e4 } = options;
-	let content;
-	let format;
-	if (source.startsWith("http://") || source.startsWith("https://")) {
-		const controller = new AbortController();
-		const timeoutId = setTimeout(() => controller.abort(), timeout);
-		try {
-			const response = await fetchFn(source, { signal: controller.signal });
-			if (!response.ok) throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-			content = await response.text();
-		} finally {
-			clearTimeout(timeoutId);
-		}
-		if (source.endsWith(".yaml") || source.endsWith(".yml")) format = "yaml";
-		else if (source.endsWith(".json")) format = "json";
-		else format = detectFormat(content);
-	} else {
-		if (!readFile) throw new Error("readFile adapter required for file paths");
-		content = await readFile(source);
-		if (source.endsWith(".yaml") || source.endsWith(".yml")) format = "yaml";
-		else if (source.endsWith(".json")) format = "json";
-		else format = detectFormat(content);
-	}
-	return parseOpenApiDocument(parseOpenApiString(content, format), options);
-}
-
-//#endregion
-export { detectFormat, detectVersion, parseOpenApi, parseOpenApiDocument, parseOpenApiString };
-//# sourceMappingURL=parser.js.map
+import { HTTP_METHODS, detectFormat, detectVersion, generateOperationId, parseOpenApiString } from "./parser/utils.js";
+import { dereferenceSchema, isReference, resolveRef } from "./parser/resolvers.js";
+import { parseParameters } from "./parser/parameters.js";
+import { parseOperation } from "./parser/operation.js";
+import { parseOpenApi, parseOpenApiDocument } from "./parser/document.js";
+import "./parser/index.js";

package/dist/openapi/schema-converter.d.ts

@@ -1,4 +1,5 @@
 import { OpenApiSchema } from "./types.js";
+import { ContractsrcConfig } from "@lssm/lib.contracts";
 
 //#region src/openapi/schema-converter.d.ts
 
@@ -16,6 +17,8 @@ interface TypescriptType {
   primitive: boolean;
   /** Description for documentation */
   description?: string;
+  /** Whether this type is a reference to another schema (needs import) vs inline */
+  isReference?: boolean;
 }
 /**
  * SchemaModel field representation for code generation.
@@ -63,8 +66,11 @@ declare function jsonSchemaToField(schema: OpenApiSchema, fieldName: string, req
 declare function generateSchemaModelCode(schema: OpenApiSchema, modelName: string, indent?: number): GeneratedModel;
 /**
  * Generate import statements for a SchemaModel.
+ * @param fields - The fields to generate imports for
+ * @param options - Configuration for import generation
+ * @param sameDirectory - If true, imports use './' (for model-to-model). If false, uses '../models/' (for operations/events)
  */
-declare function generateImports(fields: SchemaField[]): string;
+declare function generateImports(fields: SchemaField[], options: ContractsrcConfig, sameDirectory?: boolean): string;
 //#endregion
 export { GeneratedModel, SchemaField, TypescriptType, generateImports, generateSchemaModelCode, getScalarType, jsonSchemaToField, jsonSchemaToType };
 //# sourceMappingURL=schema-converter.d.ts.map

package/dist/openapi/schema-converter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema-converter.d.ts","names":[],"sources":["../../src/openapi/schema-converter.ts"],"sourcesContent":[],"mappings":";;;;AA2CA;AA6CA;AAgGA;AAkBgB,UA/LC,cAAA,CA+LgB;EAmCjB;EA+GA,IAAA,EAAA,MAAA;;;;;;;;;;;;;UAjUC,WAAA;;;;QAIT;;;;;;gBAMQ;;;;;UAMC,cAAA;;;;;;UAMP;;;;;;;iBAuCM,gBAAA,SACN,+BAEP;;;;iBA6Fa,aAAA,SAAsB;;;;iBAkBtB,iBAAA,SACN,sDAGP;;;;iBA+Ba,uBAAA,SACN,oDAGP;;;;iBA2Ga,eAAA,SAAwB"}
+{"version":3,"file":"schema-converter.d.ts","names":[],"sources":["../../src/openapi/schema-converter.ts"],"sourcesContent":[],"mappings":";;;;;AA8CA;AA6CA;AA6GA;AA2BgB,UAvNC,cAAA,CAuNgB;EAmCjB;EAoOA,IAAA,EAAA,MAAA;;;;;;;;;;;;;;;UA5cC,WAAA;;;;QAIT;;;;;;gBAMQ;;;;;UAMC,cAAA;;;;;;UAMP;;;;;;;iBAuCM,gBAAA,SACN,+BAEP;;;;iBA0Ga,aAAA,SAAsB;;;;iBA2BtB,iBAAA,SACN,sDAGP;;;;iBA+Ba,uBAAA,SACN,oDAGP;;;;;;;iBAgOa,eAAA,SACN,wBACC"}

package/dist/openapi/schema-converter.js

@@ -5,13 +5,13 @@ import { toCamelCase, toPascalCase, toValidIdentifier } from "../common/utils.js
 * Map JSON Schema types to ContractSpec ScalarTypeEnum values.
 */
 const JSON_SCHEMA_TO_SCALAR = {
-	string: "ScalarTypeEnum.STRING",
-	integer: "ScalarTypeEnum.INT",
-	number: "ScalarTypeEnum.FLOAT",
-	boolean: "ScalarTypeEnum.BOOLEAN",
-	"string:date": "ScalarTypeEnum.DATE",
-	"string:date-time": "ScalarTypeEnum.DATE_TIME",
-	"string:email": "ScalarTypeEnum.EMAIL",
+	string: "ScalarTypeEnum.String_unsecure",
+	integer: "ScalarTypeEnum.Int_unsecure",
+	number: "ScalarTypeEnum.Float_unsecure",
+	boolean: "ScalarTypeEnum.Boolean",
+	"string:date": "ScalarTypeEnum.Date",
+	"string:date-time": "ScalarTypeEnum.DateTime",
+	"string:email": "ScalarTypeEnum.EmailAddress",
 	"string:uri": "ScalarTypeEnum.URL",
 	"string:uuid": "ScalarTypeEnum.ID"
 };
@@ -36,12 +36,21 @@ function jsonSchemaToType(schema, name) {
 		type: toPascalCase(typeNameFromRef(schema.$ref)),
 		optional: false,
 		array: false,
-		primitive: false
+		primitive: false,
+		isReference: true
 	};
 	const schemaObj = schema;
 	const type = schemaObj["type"];
 	const format = schemaObj["format"];
 	const nullable = schemaObj["nullable"];
+	const originalTypeName = schemaObj["_originalTypeName"];
+	if (originalTypeName) return {
+		type: toPascalCase(originalTypeName),
+		optional: nullable ?? false,
+		array: false,
+		primitive: false,
+		isReference: true
+	};
 	if (type === "array") {
 		const items = schemaObj["items"];
 		if (items) return {
@@ -103,6 +112,11 @@ function getScalarType(schema) {
 	const type = schemaObj["type"];
 	const format = schemaObj["format"];
 	if (!type) return void 0;
+	if (type === "array") {
+		const items = schemaObj["items"];
+		if (items) return getScalarType(items);
+		return;
+	}
 	return JSON_SCHEMA_TO_SCALAR[format ? `${type}:${format}` : type] ?? JSON_SCHEMA_TO_SCALAR[type];
 }
 /**
@@ -142,12 +156,81 @@ function generateSchemaModelCode(schema, modelName, indent = 0) {
 	const description = schemaObj["description"];
 	const properties = schemaObj["properties"];
 	const required = schemaObj["required"] ?? [];
-	if (!properties) return {
-		name: toPascalCase(modelName),
-		description,
-		fields: [],
-		code: `${spaces}// Empty schema for ${modelName}`
-	};
+	const enumValues = schemaObj["enum"];
+	if (enumValues && enumValues.length > 0) {
+		const safeModelName$1 = toPascalCase(toValidIdentifier(modelName));
+		return {
+			name: safeModelName$1,
+			description,
+			fields: [],
+			code: [
+				`${spaces}/**`,
+				`${spaces} * Enum type: ${safeModelName$1}`,
+				description ? `${spaces} * ${description}` : null,
+				`${spaces} */`,
+				`${spaces}export const ${safeModelName$1} = new EnumType('${safeModelName$1}', [${enumValues.map((v) => `'${String(v)}'`).join(", ")}]);`
+			].filter((line) => line !== null).join("\n")
+		};
+	}
+	const schemaType = schemaObj["type"];
+	if (schemaType && !properties && !enumValues) {
+		const safeModelName$1 = toPascalCase(toValidIdentifier(modelName));
+		const format = schemaObj["format"];
+		const scalarType = JSON_SCHEMA_TO_SCALAR[format ? `${schemaType}:${format}` : schemaType] ?? JSON_SCHEMA_TO_SCALAR[schemaType];
+		if (scalarType) return {
+			name: safeModelName$1,
+			description,
+			fields: [],
+			code: [
+				`${spaces}/**`,
+				`${spaces} * Type alias: ${safeModelName$1}`,
+				description ? `${spaces} * ${description}` : null,
+				`${spaces} * Underlying type: ${scalarType}`,
+				`${spaces} */`,
+				`${spaces}export const ${safeModelName$1} = defineSchemaModel({`,
+				`${spaces}  name: '${safeModelName$1}',`,
+				description ? `${spaces}  description: ${JSON.stringify(description)},` : null,
+				`${spaces}  fields: {`,
+				`${spaces}    value: {`,
+				`${spaces}      type: ${scalarType}(),`,
+				`${spaces}      isOptional: false,`,
+				`${spaces}    },`,
+				`${spaces}  },`,
+				`${spaces}});`
+			].filter((line) => line !== null).join("\n")
+		};
+	}
+	if (schemaObj["additionalProperties"] && !properties) {
+		const safeModelName$1 = toPascalCase(toValidIdentifier(modelName));
+		return {
+			name: safeModelName$1,
+			description,
+			fields: [],
+			code: [
+				`${spaces}/**`,
+				`${spaces} * Dictionary/Record type: ${safeModelName$1}`,
+				description ? `${spaces} * ${description}` : null,
+				`${spaces} * Use as: Record<string, unknown> - access via record[key]`,
+				`${spaces} */`,
+				`${spaces}export const ${safeModelName$1} = ScalarTypeEnum.JSONObject();`
+			].filter((line) => line !== null).join("\n")
+		};
+	}
+	if (!properties) {
+		const safeModelName$1 = toPascalCase(toValidIdentifier(modelName));
+		return {
+			name: safeModelName$1,
+			description,
+			fields: [],
+			code: [
+				`${spaces}export const ${safeModelName$1} = defineSchemaModel({`,
+				`${spaces}  name: '${safeModelName$1}',`,
+				description ? `${spaces}  description: ${JSON.stringify(description)},` : null,
+				`${spaces}  fields: {},`,
+				`${spaces}});`
+			].filter((line) => line !== null).join("\n")
+		};
+	}
 	for (const [propName, propSchema] of Object.entries(properties)) {
 		const isRequired = required.includes(propName);
 		fields.push(jsonSchemaToField(propSchema, propName, isRequired));
@@ -178,21 +261,35 @@ function generateFieldCode(field, indent) {
 	const spaces = "  ".repeat(indent);
 	const lines = [];
 	lines.push(`${spaces}${field.name}: {`);
-	if (field.enumValues) lines.push(`${spaces}  type: new EnumType([${field.enumValues.map((v) => `'${v}'`).join(", ")}]),`);
-	else if (field.scalarType) lines.push(`${spaces}  type: ${field.scalarType},`);
-	else lines.push(`${spaces}  type: ${field.type.type}, // TODO: Define or import this type`);
-	if (field.type.optional) lines.push(`${spaces}  isOptional: true,`);
+	if (field.enumValues) {
+		const enumName = toPascalCase(field.name) + "Enum";
+		lines.push(`${spaces}  type: new EnumType('${enumName}', [${field.enumValues.map((v) => `'${v}'`).join(", ")}]),`);
+	} else if (field.scalarType) lines.push(`${spaces}  type: ${field.scalarType}(),`);
+	else if (field.type.primitive) {
+		const fallbackScalar = field.type.type === "number" ? "ScalarTypeEnum.Float_unsecure" : field.type.type === "boolean" ? "ScalarTypeEnum.Boolean_unsecure" : "ScalarTypeEnum.String_unsecure";
+		lines.push(`${spaces}  type: ${fallbackScalar}(),`);
+	} else if (field.type.isReference) lines.push(`${spaces}  type: ${field.type.type},`);
+	else lines.push(`${spaces}  type: ScalarTypeEnum.JSONObject(), // TODO: Define nested model for ${field.type.type}`);
+	lines.push(`${spaces}  isOptional: ${field.type.optional},`);
 	if (field.type.array) lines.push(`${spaces}  isArray: true,`);
 	lines.push(`${spaces}},`);
 	return lines.join("\n");
 }
 /**
 * Generate import statements for a SchemaModel.
+* @param fields - The fields to generate imports for
+* @param options - Configuration for import generation
+* @param sameDirectory - If true, imports use './' (for model-to-model). If false, uses '../models/' (for operations/events)
 */
-function generateImports(fields) {
+function generateImports(fields, options, sameDirectory = true) {
 	const imports = /* @__PURE__ */ new Set();
+	const modelsDir = sameDirectory ? "." : `../${options.conventions.models}`;
 	imports.add("import { defineSchemaModel, ScalarTypeEnum, EnumType } from '@lssm/lib.schema';");
-	for (const field of fields) if (!field.type.primitive && !field.enumValues && !field.scalarType) {}
+	for (const field of fields) if (field.type.isReference && !field.type.primitive && !field.enumValues && !field.scalarType && !field.nestedModel) {
+		const modelName = field.type.type;
+		const kebabName = modelName.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+		imports.add(`import { ${modelName} } from '${modelsDir}/${kebabName}';`);
+	}
 	return Array.from(imports).join("\n");
 }