@aigne/afs-mapping 1.11.0-beta.6

package/dist/index.mjs

@@ -0,0 +1,828 @@
+import { readFile, stat } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import { parse } from "yaml";
+import { fromError } from "zod-validation-error";
+import { z } from "zod";
+
+//#region src/binder.ts
+/**
+* Expression binder for evaluating binding expressions
+*/
+var ExpressionBinder = class {
+	/**
+	* Parse a binding expression string
+	*/
+	parseExpression(expr) {
+		const trimmed = expr.trim();
+		const parts = this.splitByPipe(trimmed);
+		const sourcePart = parts[0]?.trim() ?? "";
+		const pipes = parts.slice(1).map((p) => this.parsePipe(p.trim()));
+		if (sourcePart.startsWith("$")) return {
+			source: "jsonpath",
+			key: sourcePart,
+			pipes
+		};
+		const dotIndex = sourcePart.indexOf(".");
+		if (dotIndex === -1) return {
+			source: "literal",
+			key: sourcePart,
+			pipes
+		};
+		const source = sourcePart.slice(0, dotIndex);
+		const key = sourcePart.slice(dotIndex + 1);
+		if (source !== "path" && source !== "query" && source !== "input") return {
+			source: "literal",
+			key: sourcePart,
+			pipes
+		};
+		return {
+			source,
+			key,
+			pipes
+		};
+	}
+	/**
+	* Split expression by pipe operator, respecting parentheses
+	*/
+	splitByPipe(expr) {
+		const parts = [];
+		let current = "";
+		let parenDepth = 0;
+		for (let i = 0; i < expr.length; i++) {
+			const char = expr[i];
+			if (char === "(") {
+				parenDepth++;
+				current += char;
+			} else if (char === ")") {
+				parenDepth--;
+				current += char;
+			} else if (char === "|" && parenDepth === 0) {
+				parts.push(current);
+				current = "";
+			} else current += char;
+		}
+		if (current) parts.push(current);
+		return parts;
+	}
+	/**
+	* Parse a pipe operator string like "default('open')" or "int"
+	*/
+	parsePipe(pipeStr) {
+		const parenIndex = pipeStr.indexOf("(");
+		if (parenIndex === -1) return {
+			name: pipeStr,
+			args: []
+		};
+		const name = pipeStr.slice(0, parenIndex);
+		const argsStr = pipeStr.slice(parenIndex + 1, -1);
+		if (!argsStr) return {
+			name,
+			args: []
+		};
+		return {
+			name,
+			args: this.parseArgs(argsStr)
+		};
+	}
+	/**
+	* Parse comma-separated arguments, handling quoted strings and numbers
+	*/
+	parseArgs(argsStr) {
+		const args = [];
+		let current = "";
+		let inString = false;
+		let stringChar = "";
+		for (let i = 0; i < argsStr.length; i++) {
+			const char = argsStr[i];
+			if (!inString && (char === "\"" || char === "'")) {
+				inString = true;
+				stringChar = char;
+			} else if (inString && char === stringChar) {
+				inString = false;
+				args.push(current);
+				current = "";
+				if (argsStr[i + 1] === ",") i++;
+			} else if (!inString && char === ",") {
+				if (current.trim()) args.push(this.parseValue(current.trim()));
+				current = "";
+			} else current += char;
+		}
+		if (current.trim() && !inString) args.push(this.parseValue(current.trim()));
+		return args;
+	}
+	/**
+	* Parse a value (number or string)
+	*/
+	parseValue(value) {
+		const num = Number(value);
+		if (!Number.isNaN(num)) return num;
+		return value;
+	}
+	/**
+	* Evaluate a binding expression against a context
+	*/
+	evaluate(expr, context) {
+		const parsed = this.parseExpression(expr);
+		let value;
+		switch (parsed.source) {
+			case "path":
+				value = this.getNestedValue(context.path, parsed.key);
+				break;
+			case "query":
+				value = this.getNestedValue(context.query, parsed.key);
+				break;
+			case "input":
+				value = this.getNestedValue(context.input, parsed.key);
+				break;
+			case "jsonpath":
+				value = this.evaluateJsonPath(parsed.key, context.data);
+				break;
+			case "literal":
+				value = parsed.key;
+				break;
+		}
+		for (const pipe of parsed.pipes) value = this.applyPipe(value, pipe);
+		return value;
+	}
+	/**
+	* Get a nested value from an object using dot notation
+	*/
+	getNestedValue(obj, key) {
+		const parts = key.split(".");
+		let current = obj;
+		for (const part of parts) {
+			if (current === null || current === void 0) return;
+			if (typeof current !== "object") return;
+			current = current[part];
+		}
+		return current;
+	}
+	/**
+	* Evaluate a simple JSONPath expression
+	* Note: This is a simplified implementation supporting basic paths
+	*/
+	evaluateJsonPath(jsonPath, data) {
+		if (!jsonPath.startsWith("$")) throw new Error(`Invalid JSONPath: ${jsonPath}`);
+		const path = jsonPath.slice(1);
+		if (!path || path === ".") return data;
+		const parts = this.parseJsonPathParts(path);
+		let current = data;
+		for (const part of parts) {
+			if (current === null || current === void 0) return;
+			if (part === "[*]") continue;
+			if (typeof current !== "object") return;
+			current = current[part];
+		}
+		return current;
+	}
+	/**
+	* Parse JSONPath parts like ".user.login" or "[0].name"
+	*/
+	parseJsonPathParts(path) {
+		const parts = [];
+		let current = "";
+		for (let i = 0; i < path.length; i++) {
+			const char = path[i];
+			if (char === ".") {
+				if (current) parts.push(current);
+				current = "";
+			} else if (char === "[") {
+				if (current) parts.push(current);
+				current = "";
+				const endBracket = path.indexOf("]", i);
+				if (endBracket === -1) throw new Error(`Unmatched bracket in JSONPath: ${path}`);
+				const bracketContent = path.slice(i, endBracket + 1);
+				parts.push(bracketContent);
+				i = endBracket;
+			} else current += char;
+		}
+		if (current) parts.push(current);
+		return parts;
+	}
+	/**
+	* Apply a pipe operator to a value
+	*/
+	applyPipe(value, pipe) {
+		switch (pipe.name) {
+			case "default": return value === void 0 || value === null ? pipe.args[0] : value;
+			case "int":
+				if (value === void 0 || value === null) return void 0;
+				return parseInt(String(value), 10);
+			case "string":
+				if (value === void 0 || value === null) return void 0;
+				return String(value);
+			case "bool": return Boolean(value);
+			case "json": return JSON.stringify(value);
+			default: return value;
+		}
+	}
+	/**
+	* Bind multiple expressions and return result object
+	*/
+	bindAll(bindings, context) {
+		const result = {};
+		for (const [key, expr] of Object.entries(bindings)) result[key] = this.evaluate(expr, context);
+		return result;
+	}
+};
+
+//#endregion
+//#region src/schema.ts
+/**
+* Mapping DSL Schema Definitions
+*
+* Zod schemas for validating mapping configuration files.
+* The DSL allows declarative mapping of AFS paths to external API calls.
+*/
+/**
+* Transform entry mapping - how to convert API response fields to AFS entry fields
+*/
+const transformEntrySchema = z.object({
+	id: z.string().optional(),
+	path: z.string().optional(),
+	summary: z.string().optional(),
+	description: z.string().optional(),
+	content: z.string().optional(),
+	metadata: z.record(z.any()).optional()
+}).passthrough();
+/**
+* Transform configuration - how to convert API response to AFS entries
+*/
+const transformSchema = z.object({
+	items: z.string().optional(),
+	entry: transformEntrySchema.optional()
+});
+/**
+* Operation schema - a single API operation (list, read, write, etc.)
+*/
+const operationSchema = z.object({
+	type: z.enum([
+		"http",
+		"graphql",
+		"mcp-tool"
+	]).optional(),
+	method: z.enum([
+		"GET",
+		"POST",
+		"PUT",
+		"PATCH",
+		"DELETE"
+	]).optional(),
+	path: z.string().optional(),
+	params: z.record(z.string()).optional(),
+	body: z.record(z.string()).optional(),
+	headers: z.record(z.string()).optional(),
+	query: z.string().optional(),
+	variables: z.record(z.string()).optional(),
+	tool: z.string().optional(),
+	transform: transformSchema.optional()
+});
+/**
+* Route definition - operations for a specific path pattern
+*/
+const routeDefinitionSchema = z.object({
+	list: operationSchema.optional(),
+	read: operationSchema.optional(),
+	write: operationSchema.optional(),
+	create: operationSchema.optional(),
+	delete: operationSchema.optional()
+});
+/**
+* Default configuration applied to all operations
+*/
+const defaultsSchema = z.object({
+	baseUrl: z.string().optional(),
+	headers: z.record(z.string()).optional(),
+	timeout: z.number().optional()
+});
+/**
+* Root mapping configuration schema
+*/
+const mappingConfigSchema = z.object({
+	name: z.string(),
+	version: z.string(),
+	description: z.string().optional(),
+	defaults: defaultsSchema.optional(),
+	include: z.array(z.string()).optional(),
+	routes: z.record(routeDefinitionSchema)
+});
+/**
+* Partial mapping config for included files (no name/version required)
+*/
+const partialMappingConfigSchema = z.object({
+	routes: z.record(routeDefinitionSchema).optional(),
+	defaults: defaultsSchema.optional()
+});
+
+//#endregion
+//#region src/parser.ts
+/**
+* YAML Parser for Mapping Configuration
+*
+* Parses YAML mapping files, handles includes, and validates against schema.
+*/
+/**
+* Error thrown when parsing fails
+*/
+var MappingParseError = class extends Error {
+	constructor(message, filePath, cause) {
+		super(filePath ? `${message} (in ${filePath})` : message);
+		this.filePath = filePath;
+		this.cause = cause;
+		this.name = "MappingParseError";
+	}
+};
+/**
+* Parser for mapping configuration files
+*/
+var MappingParser = class {
+	/**
+	* Parse a YAML string into a validated mapping config
+	*/
+	parseString(yaml, filePath) {
+		let parsed;
+		try {
+			parsed = parse(yaml);
+		} catch (e) {
+			throw new MappingParseError(`Invalid YAML: ${e instanceof Error ? e.message : String(e)}`, filePath);
+		}
+		const result = mappingConfigSchema.safeParse(parsed);
+		if (!result.success) throw new MappingParseError(`Schema validation failed: ${fromError(result.error).message}`, filePath);
+		return result.data;
+	}
+	/**
+	* Parse a partial config string (for included files)
+	*/
+	parsePartialString(yaml, filePath) {
+		let parsed;
+		try {
+			parsed = parse(yaml);
+		} catch (e) {
+			throw new MappingParseError(`Invalid YAML: ${e instanceof Error ? e.message : String(e)}`, filePath);
+		}
+		const result = partialMappingConfigSchema.safeParse(parsed);
+		if (!result.success) throw new MappingParseError(`Schema validation failed: ${fromError(result.error).message}`, filePath);
+		return result.data;
+	}
+	/**
+	* Parse a mapping file and resolve includes
+	*/
+	async parseFile(filePath, visitedPaths = /* @__PURE__ */ new Set()) {
+		const absolutePath = resolve(filePath);
+		if (visitedPaths.has(absolutePath)) throw new MappingParseError(`Circular include detected: ${absolutePath}`, filePath);
+		visitedPaths.add(absolutePath);
+		let content;
+		try {
+			content = await readFile(absolutePath, "utf-8");
+		} catch (e) {
+			throw new MappingParseError(`Failed to read file: ${e instanceof Error ? e.message : String(e)}`, absolutePath);
+		}
+		const config = this.parseString(content, absolutePath);
+		if (config.include && config.include.length > 0) {
+			const baseDir = dirname(absolutePath);
+			for (const includePath of config.include) {
+				const includeAbsPath = resolve(baseDir, includePath);
+				if (visitedPaths.has(includeAbsPath)) throw new MappingParseError(`Circular include detected: ${includeAbsPath}`, filePath);
+				const partial = await this.parsePartialFile(includeAbsPath, visitedPaths);
+				if (partial.routes) config.routes = {
+					...config.routes,
+					...partial.routes
+				};
+				if (partial.defaults) config.defaults = {
+					...partial.defaults,
+					...config.defaults,
+					headers: {
+						...partial.defaults.headers,
+						...config.defaults?.headers
+					}
+				};
+			}
+		}
+		return config;
+	}
+	/**
+	* Parse a partial mapping file (for includes)
+	*/
+	async parsePartialFile(filePath, visitedPaths = /* @__PURE__ */ new Set()) {
+		const absolutePath = resolve(filePath);
+		if (visitedPaths.has(absolutePath)) throw new MappingParseError(`Circular include detected: ${absolutePath}`, filePath);
+		visitedPaths.add(absolutePath);
+		let content;
+		try {
+			content = await readFile(absolutePath, "utf-8");
+		} catch (e) {
+			throw new MappingParseError(`Failed to read file: ${e instanceof Error ? e.message : String(e)}`, absolutePath);
+		}
+		const partial = this.parsePartialString(content, absolutePath);
+		const parsed = parse(content);
+		if (parsed.include && parsed.include.length > 0) {
+			const baseDir = dirname(absolutePath);
+			for (const includePath of parsed.include) {
+				const includeAbsPath = resolve(baseDir, includePath);
+				if (visitedPaths.has(includeAbsPath)) throw new MappingParseError(`Circular include detected: ${includeAbsPath}`, filePath);
+				const nestedPartial = await this.parsePartialFile(includeAbsPath, visitedPaths);
+				if (nestedPartial.routes) partial.routes = {
+					...partial.routes,
+					...nestedPartial.routes
+				};
+			}
+		}
+		return partial;
+	}
+	/**
+	* Parse a directory containing index.yaml and potentially included files
+	*/
+	async parseDirectory(dirPath) {
+		const absoluteDir = resolve(dirPath);
+		const indexPath = join(absoluteDir, "index.yaml");
+		try {
+			if (!(await stat(indexPath)).isFile()) throw new MappingParseError(`index.yaml is not a file`, indexPath);
+		} catch (e) {
+			if (e.code === "ENOENT") throw new MappingParseError(`Directory does not contain index.yaml`, absoluteDir);
+			throw e;
+		}
+		return this.parseFile(indexPath);
+	}
+};
+
+//#endregion
+//#region src/projector.ts
+/**
+* Projects API response data to AFS entries
+*/
+var Projector = class {
+	binder = new ExpressionBinder();
+	/**
+	* Project data to AFS entries based on transform config
+	*/
+	project(data, transform, pathParams) {
+		if (transform.items) return this.projectList(data, transform, pathParams);
+		if (transform.entry) return [this.projectItem(data, transform, pathParams)];
+		return [];
+	}
+	/**
+	* Project a list of items
+	*/
+	projectList(data, transform, pathParams) {
+		if (!transform.entry) return [];
+		let items;
+		if (transform.items === "$") {
+			if (!Array.isArray(data)) return [];
+			items = data;
+		} else {
+			const itemsPath = transform.items;
+			const itemsData = this.evaluateJsonPath(itemsPath, data);
+			if (itemsData === void 0 || itemsData === null) return [];
+			if (Array.isArray(itemsData)) items = itemsData;
+			else items = [itemsData];
+		}
+		return items.map((item) => this.projectItem(item, { entry: transform.entry }, pathParams));
+	}
+	/**
+	* Project a single item to an AFS entry
+	*/
+	projectItem(data, transform, pathParams) {
+		if (!transform.entry) throw new Error("Transform must have entry configuration");
+		const entryConfig = transform.entry;
+		const entry = {
+			id: this.evaluateField(entryConfig.id, data, pathParams) ?? "",
+			path: this.interpolatePath(entryConfig.path ?? "", data, pathParams)
+		};
+		if (entryConfig.summary) {
+			const summary = this.evaluateField(entryConfig.summary, data, pathParams);
+			if (summary !== void 0) entry.summary = summary;
+		}
+		if (entryConfig.content) {
+			const content = this.evaluateField(entryConfig.content, data, pathParams);
+			if (content !== void 0) entry.content = content;
+		}
+		if (entryConfig.metadata) entry.metadata = this.projectMetadata(entryConfig.metadata, data, pathParams);
+		if (entryConfig.description) {
+			const description = this.evaluateField(entryConfig.description, data, pathParams);
+			if (description !== void 0) {
+				entry.metadata = entry.metadata || {};
+				entry.metadata.description = description;
+			}
+		}
+		return entry;
+	}
+	/**
+	* Evaluate a single field expression
+	*/
+	evaluateField(expr, data, pathParams) {
+		if (!expr) return void 0;
+		const context = {
+			path: pathParams,
+			query: {},
+			input: {},
+			data
+		};
+		const result = this.binder.evaluate(expr, context);
+		return result === void 0 || result === null ? void 0 : String(result);
+	}
+	/**
+	* Interpolate a path template with data and path params
+	* Handles both {name} for path params and {$.path} for JSONPath
+	*/
+	interpolatePath(template, data, pathParams) {
+		return template.replace(/\{([^}]+)\}/g, (match, expr) => {
+			if (expr.startsWith("$.")) {
+				const value = this.evaluateJsonPath(expr, data);
+				return value !== void 0 && value !== null ? String(value) : match;
+			}
+			return pathParams[expr] ?? match;
+		});
+	}
+	/**
+	* Project metadata object recursively
+	*/
+	projectMetadata(config, data, pathParams) {
+		const result = {};
+		for (const [key, value] of Object.entries(config)) if (typeof value === "string") {
+			const context = {
+				path: pathParams,
+				query: {},
+				input: {},
+				data
+			};
+			result[key] = this.binder.evaluate(value, context);
+		} else if (typeof value === "object" && value !== null && !Array.isArray(value)) result[key] = this.projectMetadata(value, data, pathParams);
+		else result[key] = value;
+		return result;
+	}
+	/**
+	* Evaluate a JSONPath expression
+	*/
+	evaluateJsonPath(jsonPath, data) {
+		if (!jsonPath) return void 0;
+		const context = {
+			path: {},
+			query: {},
+			input: {},
+			data
+		};
+		return this.binder.evaluate(jsonPath, context);
+	}
+};
+
+//#endregion
+//#region src/resolver.ts
+/**
+* Represents a parsed path template
+*/
+var PathTemplate = class PathTemplate {
+	/** Original template string */
+	template;
+	/** Parsed segments */
+	segments;
+	/** Parameter names in order */
+	params;
+	constructor(template, segments, params) {
+		this.template = template;
+		this.segments = segments;
+		this.params = params;
+	}
+	/**
+	* Parse a path template string
+	*/
+	static parse(template) {
+		const segments = (template.endsWith("/") && template !== "/" ? template.slice(0, -1) : template).split("/").filter(Boolean);
+		const params = [];
+		for (const segment of segments) if (segment.startsWith("{") && segment.endsWith("}")) {
+			const paramName = segment.slice(1, -1);
+			params.push(paramName);
+		}
+		return new PathTemplate(template, segments, params);
+	}
+	/**
+	* Try to match a path against this template
+	*/
+	match(path) {
+		const pathSegments = (path.endsWith("/") && path !== "/" ? path.slice(0, -1) : path).split("/").filter(Boolean);
+		if (pathSegments.length !== this.segments.length) return null;
+		const params = {};
+		for (let i = 0; i < this.segments.length; i++) {
+			const templateSeg = this.segments[i];
+			const pathSeg = decodeURIComponent(pathSegments[i]);
+			if (templateSeg.startsWith("{") && templateSeg.endsWith("}")) {
+				const paramName = templateSeg.slice(1, -1);
+				params[paramName] = pathSeg;
+			} else if (templateSeg !== pathSeg) return null;
+		}
+		return { params };
+	}
+};
+/**
+* Path resolver using Trie for O(k) lookup where k = path depth
+*/
+var PathResolver = class {
+	root;
+	constructor() {
+		this.root = this.createNode(false);
+	}
+	createNode(isParam, paramName) {
+		return {
+			children: /* @__PURE__ */ new Map(),
+			isParam,
+			paramName
+		};
+	}
+	/**
+	* Add a route template with associated data
+	*/
+	addRoute(template, data) {
+		const parsed = PathTemplate.parse(template);
+		let current = this.root;
+		for (const segment of parsed.segments) {
+			const isParam = segment.startsWith("{") && segment.endsWith("}");
+			const key = isParam ? "{param}" : segment;
+			if (!current.children.has(key)) {
+				const paramName = isParam ? segment.slice(1, -1) : void 0;
+				current.children.set(key, this.createNode(isParam, paramName));
+			}
+			current = current.children.get(key);
+		}
+		current.data = data;
+		current.template = template;
+	}
+	/**
+	* Resolve a path to a route
+	*/
+	resolve(path) {
+		const segments = (path.endsWith("/") && path !== "/" ? path.slice(0, -1) : path).split("/").filter(Boolean);
+		const params = {};
+		let current = this.root;
+		for (const segment of segments) {
+			const decodedSegment = decodeURIComponent(segment);
+			if (current.children.has(decodedSegment)) current = current.children.get(decodedSegment);
+			else if (current.children.has("{param}")) {
+				const paramNode = current.children.get("{param}");
+				if (paramNode.paramName) params[paramNode.paramName] = decodedSegment;
+				current = paramNode;
+			} else return null;
+		}
+		if (current.data === void 0 || current.template === void 0) return null;
+		return {
+			template: current.template,
+			params,
+			data: current.data
+		};
+	}
+	/**
+	* Get all registered routes
+	*/
+	getAllRoutes() {
+		const routes = [];
+		this.collectRoutes(this.root, routes);
+		return routes;
+	}
+	collectRoutes(node, routes) {
+		if (node.data !== void 0 && node.template !== void 0) routes.push({
+			template: node.template,
+			data: node.data
+		});
+		for (const child of node.children.values()) this.collectRoutes(child, routes);
+	}
+};
+
+//#endregion
+//#region src/compiler.ts
+/**
+* Compiled mapping ready for runtime use
+*/
+var CompiledMapping = class {
+	name;
+	version;
+	description;
+	defaults;
+	resolver;
+	binder = new ExpressionBinder();
+	projector = new Projector();
+	routes = /* @__PURE__ */ new Map();
+	constructor(config) {
+		this.name = config.name;
+		this.version = config.version;
+		this.description = config.description;
+		this.defaults = config.defaults;
+		this.resolver = new PathResolver();
+		for (const [template, routeDef] of Object.entries(config.routes)) {
+			this.resolver.addRoute(template, routeDef);
+			this.routes.set(template, routeDef);
+		}
+	}
+	/**
+	* Get number of routes
+	*/
+	get routeCount() {
+		return this.routes.size;
+	}
+	/**
+	* Get total number of operations
+	*/
+	get operationCount() {
+		let count = 0;
+		for (const route of this.routes.values()) {
+			if (route.list) count++;
+			if (route.read) count++;
+			if (route.write) count++;
+			if (route.create) count++;
+			if (route.delete) count++;
+		}
+		return count;
+	}
+	/**
+	* Resolve a path to route information
+	*/
+	resolve(path) {
+		const result = this.resolver.resolve(path);
+		if (!result) return null;
+		return {
+			template: result.template,
+			params: result.params,
+			operations: {
+				list: result.data.list,
+				read: result.data.read,
+				write: result.data.write,
+				create: result.data.create,
+				delete: result.data.delete
+			}
+		};
+	}
+	/**
+	* Build an HTTP request for a given path and operation
+	*/
+	buildRequest(afsPath, operationType, options) {
+		const resolved = this.resolve(afsPath);
+		if (!resolved) return null;
+		const operation = resolved.operations[operationType];
+		if (!operation) return null;
+		const context = {
+			path: resolved.params,
+			query: options.query ?? {},
+			input: options.input ?? {},
+			data: {}
+		};
+		const boundParams = operation.params ? this.binder.bindAll(operation.params, context) : {};
+		const apiPath = this.interpolatePath(operation.path ?? "", context);
+		const headers = {
+			...this.defaults?.headers,
+			...operation.headers
+		};
+		let body;
+		if (operation.body) body = this.binder.bindAll(operation.body, context);
+		return {
+			method: operation.method ?? "GET",
+			path: apiPath,
+			params: boundParams,
+			headers: Object.keys(headers).length > 0 ? headers : void 0,
+			body
+		};
+	}
+	/**
+	* Project API response to AFS entries
+	*/
+	projectResponse(afsPath, operationType, apiResponse) {
+		const resolved = this.resolve(afsPath);
+		if (!resolved) return [];
+		const operation = resolved.operations[operationType];
+		if (!operation?.transform) return [];
+		return this.projector.project(apiResponse, operation.transform, resolved.params);
+	}
+	/**
+	* Interpolate path template with context values
+	*/
+	interpolatePath(template, context) {
+		return template.replace(/\{([^}]+)\}/g, (match, key) => {
+			const value = context.path[key];
+			return value !== void 0 ? value : match;
+		});
+	}
+};
+/**
+* Compiler for mapping configurations
+*/
+var MappingCompiler = class {
+	parser = new MappingParser();
+	/**
+	* Compile a mapping file
+	*/
+	async compileFile(filePath) {
+		return new CompiledMapping(await this.parser.parseFile(filePath));
+	}
+	/**
+	* Compile a mapping directory
+	*/
+	async compileDirectory(dirPath) {
+		return new CompiledMapping(await this.parser.parseDirectory(dirPath));
+	}
+	/**
+	* Compile from a config object (for testing)
+	*/
+	compileConfig(config) {
+		return new CompiledMapping(config);
+	}
+};
+
+//#endregion
+export { CompiledMapping, ExpressionBinder, MappingCompiler, MappingParseError, MappingParser, PathResolver, PathTemplate, Projector, defaultsSchema, mappingConfigSchema, operationSchema, partialMappingConfigSchema, routeDefinitionSchema, transformEntrySchema, transformSchema };
+//# sourceMappingURL=index.mjs.map