@gxp-dev/tools 2.0.6 → 2.0.7

package/runtime/mock-api/socket-triggers.js

@@ -0,0 +1,371 @@
+/**
+ * Socket Triggers
+ *
+ * Parses AsyncAPI specs for x-triggered-by extensions and emits
+ * Socket.IO events after matching API calls complete.
+ */
+
+/**
+ * Parse AsyncAPI spec for socket triggers
+ * @param {object} asyncApiSpec - AsyncAPI specification
+ * @returns {object} Map of operation keys to trigger definitions
+ */
+function parseSocketTriggers(asyncApiSpec) {
+	const triggers = {};
+
+	if (!asyncApiSpec) {
+		return triggers;
+	}
+
+	// Handle AsyncAPI 2.x format
+	if (asyncApiSpec.channels) {
+		parseChannels(asyncApiSpec.channels, asyncApiSpec, triggers);
+	}
+
+	// Handle AsyncAPI 3.x format
+	if (asyncApiSpec.operations) {
+		parseOperations(asyncApiSpec.operations, asyncApiSpec, triggers);
+	}
+
+	// Also check components/messages directly
+	if (asyncApiSpec.components?.messages) {
+		parseMessages(asyncApiSpec.components.messages, triggers);
+	}
+
+	const triggerCount = Object.keys(triggers).length;
+	if (triggerCount > 0) {
+		console.log(`📡 Parsed ${triggerCount} socket trigger definitions`);
+	}
+
+	return triggers;
+}
+
+/**
+ * Parse channels (AsyncAPI 2.x)
+ * @param {object} channels - Channels object
+ * @param {object} spec - Full spec
+ * @param {object} triggers - Triggers map to populate
+ */
+function parseChannels(channels, spec, triggers) {
+	for (const [channelName, channel] of Object.entries(channels)) {
+		// Check publish/subscribe operations
+		const operations = [
+			channel.publish,
+			channel.subscribe,
+		].filter(Boolean);
+
+		for (const operation of operations) {
+			const message = operation.message;
+			if (message) {
+				extractTriggersFromMessage(channelName, message, spec, triggers);
+			}
+		}
+	}
+}
+
+/**
+ * Parse operations (AsyncAPI 3.x)
+ * @param {object} operations - Operations object
+ * @param {object} spec - Full spec
+ * @param {object} triggers - Triggers map to populate
+ */
+function parseOperations(operations, spec, triggers) {
+	for (const [, operation] of Object.entries(operations)) {
+		if (operation.messages) {
+			for (const message of operation.messages) {
+				const channelName = operation.channel?.$ref || "default";
+				extractTriggersFromMessage(channelName, message, spec, triggers);
+			}
+		}
+	}
+}
+
+/**
+ * Parse messages directly from components
+ * @param {object} messages - Messages object
+ * @param {object} triggers - Triggers map to populate
+ */
+function parseMessages(messages, triggers) {
+	for (const [messageName, message] of Object.entries(messages)) {
+		if (message["x-triggered-by"]) {
+			const triggerDefs = Array.isArray(message["x-triggered-by"])
+				? message["x-triggered-by"]
+				: [message["x-triggered-by"]];
+
+			for (const triggerDef of triggerDefs) {
+				const operationKey = triggerDef.operation;
+				if (!operationKey) continue;
+
+				if (!triggers[operationKey]) {
+					triggers[operationKey] = [];
+				}
+
+				triggers[operationKey].push({
+					event: message.name || messageName,
+					channel: triggerDef.channel,
+					delay: triggerDef.delay || 0,
+					condition: triggerDef.condition,
+					payload: triggerDef.payload || message.payload,
+				});
+			}
+		}
+	}
+}
+
+/**
+ * Extract triggers from a message definition
+ * @param {string} channelName - Channel name
+ * @param {object} message - Message object
+ * @param {object} spec - Full spec for $ref resolution
+ * @param {object} triggers - Triggers map to populate
+ */
+function extractTriggersFromMessage(channelName, message, spec, triggers) {
+	// Resolve $ref if needed
+	let resolvedMessage = message;
+	if (message.$ref) {
+		resolvedMessage = resolveRef(message.$ref, spec) || message;
+	}
+
+	// Check for x-triggered-by extension
+	const triggerDefs = resolvedMessage["x-triggered-by"];
+	if (!triggerDefs) return;
+
+	const triggerArray = Array.isArray(triggerDefs) ? triggerDefs : [triggerDefs];
+
+	for (const triggerDef of triggerArray) {
+		const operationKey = triggerDef.operation;
+		if (!operationKey) continue;
+
+		if (!triggers[operationKey]) {
+			triggers[operationKey] = [];
+		}
+
+		triggers[operationKey].push({
+			event: resolvedMessage.name || resolvedMessage.messageId || "unknown",
+			channel: triggerDef.channel || channelName,
+			delay: triggerDef.delay || 0,
+			condition: triggerDef.condition,
+			payload: triggerDef.payload || resolvedMessage.payload,
+		});
+	}
+}
+
+/**
+ * Resolve a $ref reference
+ * @param {string} ref - Reference string
+ * @param {object} spec - Full spec
+ * @returns {object|null} Resolved object
+ */
+function resolveRef(ref, spec) {
+	if (!ref || !ref.startsWith("#/")) {
+		return null;
+	}
+
+	const parts = ref.slice(2).split("/");
+	let current = spec;
+
+	for (const part of parts) {
+		if (current && typeof current === "object" && part in current) {
+			current = current[part];
+		} else {
+			return null;
+		}
+	}
+
+	return current;
+}
+
+/**
+ * Template a payload with request/response data
+ * @param {object} payload - Payload template
+ * @param {object} context - Context with request and response data
+ * @returns {object} Templated payload
+ */
+function templatePayload(payload, context) {
+	if (!payload) return {};
+
+	const payloadStr = JSON.stringify(payload);
+
+	// Replace template variables
+	const templated = payloadStr.replace(/\{\{([^}]+)\}\}/g, (match, path) => {
+		const value = resolvePath(path.trim(), context);
+
+		if (value === undefined) {
+			return match; // Keep original if not found
+		}
+
+		// Handle different types
+		if (typeof value === "string") {
+			return value;
+		}
+
+		return JSON.stringify(value);
+	});
+
+	try {
+		return JSON.parse(templated);
+	} catch {
+		// If JSON parse fails, return original
+		return payload;
+	}
+}
+
+/**
+ * Resolve a dot-notation path in an object
+ * @param {string} path - Dot-notation path (e.g., "response.body.id")
+ * @param {object} obj - Object to resolve in
+ * @returns {*} Resolved value
+ */
+function resolvePath(path, obj) {
+	// Handle special values
+	if (path === "now") {
+		return new Date().toISOString();
+	}
+
+	if (path === "timestamp") {
+		return Date.now();
+	}
+
+	const parts = path.split(".");
+	let current = obj;
+
+	for (const part of parts) {
+		if (current && typeof current === "object" && part in current) {
+			current = current[part];
+		} else {
+			return undefined;
+		}
+	}
+
+	return current;
+}
+
+/**
+ * Evaluate a condition expression
+ * @param {string} condition - Condition expression
+ * @param {object} context - Context with request and response data
+ * @returns {boolean} Condition result
+ */
+function evaluateCondition(condition, context) {
+	if (!condition) return true;
+
+	try {
+		// Simple condition parsing (e.g., "response.status == 200")
+		const match = condition.match(/^([^\s]+)\s*(==|!=|>|<|>=|<=)\s*(.+)$/);
+
+		if (!match) return true;
+
+		const [, path, operator, valueStr] = match;
+		const actualValue = resolvePath(path, context);
+
+		// Parse the expected value
+		let expectedValue;
+		try {
+			expectedValue = JSON.parse(valueStr);
+		} catch {
+			expectedValue = valueStr;
+		}
+
+		switch (operator) {
+			case "==":
+				return actualValue == expectedValue;
+			case "!=":
+				return actualValue != expectedValue;
+			case ">":
+				return actualValue > expectedValue;
+			case "<":
+				return actualValue < expectedValue;
+			case ">=":
+				return actualValue >= expectedValue;
+			case "<=":
+				return actualValue <= expectedValue;
+			default:
+				return true;
+		}
+	} catch {
+		return true;
+	}
+}
+
+/**
+ * Trigger socket events for a completed API operation
+ * @param {object} io - Socket.IO server instance
+ * @param {object} socketTriggers - Parsed trigger definitions
+ * @param {string} operationKey - Operation key (e.g., "POST /events/{eventId}/checkin")
+ * @param {object} context - Request/response context
+ */
+function triggerSocketEvents(io, socketTriggers, operationKey, context) {
+	if (!io || !socketTriggers) return;
+
+	const triggers = socketTriggers[operationKey];
+	if (!triggers || triggers.length === 0) return;
+
+	for (const trigger of triggers) {
+		// Evaluate condition
+		if (!evaluateCondition(trigger.condition, context)) {
+			console.log(`   ⏭️  Skipped socket event (condition not met): ${trigger.event}`);
+			continue;
+		}
+
+		// Template the payload
+		const payload = templatePayload(trigger.payload, context);
+
+		// Template the channel name
+		let channel = trigger.channel || "";
+		channel = channel.replace(/\{([^}]+)\}/g, (match, path) => {
+			const value = resolvePath(`request.params.${path}`, context);
+			return value !== undefined ? value : match;
+		});
+
+		// Schedule the emit
+		const delay = trigger.delay || 0;
+
+		const emit = () => {
+			console.log(`   📡 Emitting socket event: ${trigger.event}`);
+			if (channel) {
+				console.log(`      Channel: ${channel}`);
+			}
+
+			io.emit(trigger.event, payload);
+		};
+
+		if (delay > 0) {
+			console.log(`   ⏱️  Scheduling socket event: ${trigger.event} (${delay}ms delay)`);
+			setTimeout(emit, delay);
+		} else {
+			emit();
+		}
+	}
+}
+
+/**
+ * Get trigger statistics
+ * @param {object} socketTriggers - Parsed trigger definitions
+ * @returns {object} Statistics
+ */
+function getTriggerStats(socketTriggers) {
+	if (!socketTriggers) {
+		return { total: 0, operations: [] };
+	}
+
+	const operations = [];
+	let total = 0;
+
+	for (const [operation, triggers] of Object.entries(socketTriggers)) {
+		total += triggers.length;
+		operations.push({
+			operation,
+			events: triggers.map((t) => t.event),
+		});
+	}
+
+	return { total, operations };
+}
+
+module.exports = {
+	parseSocketTriggers,
+	triggerSocketEvents,
+	templatePayload,
+	evaluateCondition,
+	getTriggerStats,
+};

package/runtime/mock-api/spec-loader.js

@@ -0,0 +1,300 @@
+/**
+ * Spec Loader
+ *
+ * Fetches and caches OpenAPI, AsyncAPI, and Webhook specs from the platform.
+ * Falls back to local files when the platform API is unreachable.
+ */
+
+const fs = require("fs");
+const path = require("path");
+const axios = require("axios");
+const https = require("https");
+
+// Import environment URLs from constants
+let ENVIRONMENT_URLS;
+try {
+	// When running from node_modules
+	ENVIRONMENT_URLS = require("../../bin/lib/constants").ENVIRONMENT_URLS;
+} catch {
+	// Fallback for direct execution
+	ENVIRONMENT_URLS = require(path.join(
+		__dirname,
+		"../../bin/lib/constants"
+	)).ENVIRONMENT_URLS;
+}
+
+// Spec cache
+const cache = {
+	openApi: null,
+	asyncApi: null,
+	webhooks: null,
+	lastFetch: null,
+};
+
+// Default cache TTL (5 minutes)
+const DEFAULT_CACHE_TTL = 5 * 60 * 1000;
+
+/**
+ * Get cache TTL from environment or use default
+ */
+function getCacheTTL() {
+	return parseInt(process.env.MOCK_API_CACHE_TTL) || DEFAULT_CACHE_TTL;
+}
+
+/**
+ * Get environment configuration based on API_ENV
+ * @param {string} env - Environment name (defaults to 'production')
+ * @returns {object} Environment URLs configuration
+ */
+function getEnvironmentConfig(env) {
+	const envName = env || process.env.API_ENV || "production";
+	const config = ENVIRONMENT_URLS[envName];
+
+	if (!config) {
+		console.warn(
+			`⚠️  Unknown environment "${envName}", falling back to production`
+		);
+		return ENVIRONMENT_URLS.production;
+	}
+
+	return config;
+}
+
+/**
+ * Create axios instance with SSL handling for local development
+ */
+function createHttpClient() {
+	return axios.create({
+		timeout: 10000,
+		httpsAgent: new https.Agent({
+			rejectUnauthorized: process.env.NODE_ENV === "production",
+		}),
+	});
+}
+
+/**
+ * Fetch a spec from a URL
+ * @param {string} url - URL to fetch
+ * @param {string} specName - Name for logging
+ * @returns {object|null} Parsed JSON spec or null on error
+ */
+async function fetchSpec(url, specName) {
+	const client = createHttpClient();
+
+	try {
+		console.log(`📡 Fetching ${specName} from ${url}`);
+		const response = await client.get(url);
+		console.log(`✅ ${specName} loaded successfully`);
+		return response.data;
+	} catch (error) {
+		const message = error.response
+			? `HTTP ${error.response.status}`
+			: error.message;
+		console.warn(`⚠️  Failed to fetch ${specName}: ${message}`);
+		return null;
+	}
+}
+
+/**
+ * Load a spec from a local file
+ * @param {string} projectRoot - Project root directory
+ * @param {string} filename - Filename to load
+ * @param {string} specName - Name for logging
+ * @returns {object|null} Parsed JSON spec or null if not found
+ */
+function loadLocalSpec(projectRoot, filename, specName) {
+	const filePath = path.join(projectRoot, filename);
+
+	if (!fs.existsSync(filePath)) {
+		return null;
+	}
+
+	try {
+		console.log(`📁 Loading local ${specName} from ${filename}`);
+		const content = fs.readFileSync(filePath, "utf-8");
+		const spec = JSON.parse(content);
+		console.log(`✅ Local ${specName} loaded successfully`);
+		return spec;
+	} catch (error) {
+		console.warn(`⚠️  Failed to parse local ${specName}: ${error.message}`);
+		return null;
+	}
+}
+
+/**
+ * Fetch OpenAPI spec from platform or local file
+ * @param {string} projectRoot - Project root for local fallback
+ * @returns {object|null} OpenAPI spec
+ */
+async function fetchOpenApiSpec(projectRoot) {
+	const config = getEnvironmentConfig();
+
+	// Try remote first
+	let spec = await fetchSpec(config.openApiSpec, "OpenAPI spec");
+
+	// Fallback to local
+	if (!spec && projectRoot) {
+		spec = loadLocalSpec(projectRoot, "openapi.json", "OpenAPI spec");
+	}
+
+	return spec;
+}
+
+/**
+ * Fetch AsyncAPI spec from platform or local file
+ * @param {string} projectRoot - Project root for local fallback
+ * @returns {object|null} AsyncAPI spec
+ */
+async function fetchAsyncApiSpec(projectRoot) {
+	const config = getEnvironmentConfig();
+
+	// Try remote first
+	let spec = await fetchSpec(config.asyncApiSpec, "AsyncAPI spec");
+
+	// Fallback to local
+	if (!spec && projectRoot) {
+		spec = loadLocalSpec(projectRoot, "asyncapi.json", "AsyncAPI spec");
+	}
+
+	return spec;
+}
+
+/**
+ * Fetch Webhook spec from platform or local file
+ * @param {string} projectRoot - Project root for local fallback
+ * @returns {object|null} Webhook spec
+ */
+async function fetchWebhookSpec(projectRoot) {
+	const config = getEnvironmentConfig();
+
+	// Try remote first
+	let spec = await fetchSpec(config.webhookSpec, "Webhook spec");
+
+	// Fallback to local
+	if (!spec && projectRoot) {
+		spec = loadLocalSpec(projectRoot, "webhooks.json", "Webhook spec");
+	}
+
+	return spec;
+}
+
+/**
+ * Check if cache is still valid
+ * @returns {boolean} True if cache is valid
+ */
+function isCacheValid() {
+	if (!cache.lastFetch) {
+		return false;
+	}
+
+	const elapsed = Date.now() - cache.lastFetch;
+	return elapsed < getCacheTTL();
+}
+
+/**
+ * Load all specs with caching
+ * @param {string} projectRoot - Project root for local fallback
+ * @param {boolean} forceRefresh - Force refresh even if cache is valid
+ * @returns {object} Object containing all specs
+ */
+async function loadSpecs(projectRoot, forceRefresh = false) {
+	// Return cached if valid and not forcing refresh
+	if (!forceRefresh && isCacheValid()) {
+		console.log("📦 Using cached specs");
+		return {
+			openApi: cache.openApi,
+			asyncApi: cache.asyncApi,
+			webhooks: cache.webhooks,
+		};
+	}
+
+	const root = projectRoot || process.cwd();
+
+	console.log("🔄 Loading API specs...");
+	console.log(`   Environment: ${process.env.API_ENV || "production"}`);
+
+	// Fetch all specs in parallel
+	const [openApi, asyncApi, webhooks] = await Promise.all([
+		fetchOpenApiSpec(root),
+		fetchAsyncApiSpec(root),
+		fetchWebhookSpec(root),
+	]);
+
+	// Update cache
+	cache.openApi = openApi;
+	cache.asyncApi = asyncApi;
+	cache.webhooks = webhooks;
+	cache.lastFetch = Date.now();
+
+	// Log summary
+	const loaded = [];
+	if (openApi) loaded.push("OpenAPI");
+	if (asyncApi) loaded.push("AsyncAPI");
+	if (webhooks) loaded.push("Webhooks");
+
+	if (loaded.length > 0) {
+		console.log(`✅ Loaded specs: ${loaded.join(", ")}`);
+	} else {
+		console.warn("⚠️  No specs were loaded");
+	}
+
+	return { openApi, asyncApi, webhooks };
+}
+
+/**
+ * Clear the spec cache and refetch
+ * @param {string} projectRoot - Project root for local fallback
+ * @returns {object} Freshly loaded specs
+ */
+async function refreshSpecs(projectRoot) {
+	console.log("🔄 Refreshing API specs...");
+	cache.openApi = null;
+	cache.asyncApi = null;
+	cache.webhooks = null;
+	cache.lastFetch = null;
+
+	return loadSpecs(projectRoot, true);
+}
+
+/**
+ * Get current cache status
+ * @returns {object} Cache status info
+ */
+function getCacheStatus() {
+	const ttl = getCacheTTL();
+	const elapsed = cache.lastFetch ? Date.now() - cache.lastFetch : null;
+
+	return {
+		hasOpenApi: !!cache.openApi,
+		hasAsyncApi: !!cache.asyncApi,
+		hasWebhooks: !!cache.webhooks,
+		lastFetch: cache.lastFetch ? new Date(cache.lastFetch).toISOString() : null,
+		cacheValid: isCacheValid(),
+		ttlMs: ttl,
+		expiresIn: elapsed !== null ? Math.max(0, ttl - elapsed) : null,
+	};
+}
+
+/**
+ * Get the raw cached specs (for direct access)
+ * @returns {object} Cached specs
+ */
+function getCachedSpecs() {
+	return {
+		openApi: cache.openApi,
+		asyncApi: cache.asyncApi,
+		webhooks: cache.webhooks,
+	};
+}
+
+module.exports = {
+	getEnvironmentConfig,
+	fetchOpenApiSpec,
+	fetchAsyncApiSpec,
+	fetchWebhookSpec,
+	loadSpecs,
+	refreshSpecs,
+	getCacheStatus,
+	getCachedSpecs,
+	isCacheValid,
+};