@gxp-dev/tools 2.0.62 → 2.0.64

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

@@ -11,33 +11,33 @@
  * @returns {object} Map of operation keys to trigger definitions
  */
 function parseSocketTriggers(asyncApiSpec) {
-	const triggers = {};
+	const triggers = {}
 
 	if (!asyncApiSpec) {
-		return triggers;
+		return triggers
 	}
 
 	// Handle AsyncAPI 2.x format
 	if (asyncApiSpec.channels) {
-		parseChannels(asyncApiSpec.channels, asyncApiSpec, triggers);
+		parseChannels(asyncApiSpec.channels, asyncApiSpec, triggers)
 	}
 
 	// Handle AsyncAPI 3.x format
 	if (asyncApiSpec.operations) {
-		parseOperations(asyncApiSpec.operations, asyncApiSpec, triggers);
+		parseOperations(asyncApiSpec.operations, asyncApiSpec, triggers)
 	}
 
 	// Also check components/messages directly
 	if (asyncApiSpec.components?.messages) {
-		parseMessages(asyncApiSpec.components.messages, triggers);
+		parseMessages(asyncApiSpec.components.messages, triggers)
 	}
 
-	const triggerCount = Object.keys(triggers).length;
+	const triggerCount = Object.keys(triggers).length
 	if (triggerCount > 0) {
-		console.log(`📡 Parsed ${triggerCount} socket trigger definitions`);
+		console.log(`📡 Parsed ${triggerCount} socket trigger definitions`)
 	}
 
-	return triggers;
+	return triggers
 }
 
 /**
@@ -49,15 +49,12 @@ function parseSocketTriggers(asyncApiSpec) {
 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);
+		const operations = [channel.publish, channel.subscribe].filter(Boolean)
 
 		for (const operation of operations) {
-			const message = operation.message;
+			const message = operation.message
 			if (message) {
-				extractTriggersFromMessage(channelName, message, spec, triggers);
+				extractTriggersFromMessage(channelName, message, spec, triggers)
 			}
 		}
 	}
@@ -73,8 +70,8 @@ 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);
+				const channelName = operation.channel?.$ref || "default"
+				extractTriggersFromMessage(channelName, message, spec, triggers)
 			}
 		}
 	}
@@ -90,14 +87,14 @@ function parseMessages(messages, triggers) {
 		if (message["x-triggered-by"]) {
 			const triggerDefs = Array.isArray(message["x-triggered-by"])
 				? message["x-triggered-by"]
-				: [message["x-triggered-by"]];
+				: [message["x-triggered-by"]]
 
 			for (const triggerDef of triggerDefs) {
-				const operationKey = triggerDef.operation;
-				if (!operationKey) continue;
+				const operationKey = triggerDef.operation
+				if (!operationKey) continue
 
 				if (!triggers[operationKey]) {
-					triggers[operationKey] = [];
+					triggers[operationKey] = []
 				}
 
 				triggers[operationKey].push({
@@ -106,7 +103,7 @@ function parseMessages(messages, triggers) {
 					delay: triggerDef.delay || 0,
 					condition: triggerDef.condition,
 					payload: triggerDef.payload || message.payload,
-				});
+				})
 			}
 		}
 	}
@@ -121,23 +118,23 @@ function parseMessages(messages, triggers) {
  */
 function extractTriggersFromMessage(channelName, message, spec, triggers) {
 	// Resolve $ref if needed
-	let resolvedMessage = message;
+	let resolvedMessage = message
 	if (message.$ref) {
-		resolvedMessage = resolveRef(message.$ref, spec) || message;
+		resolvedMessage = resolveRef(message.$ref, spec) || message
 	}
 
 	// Check for x-triggered-by extension
-	const triggerDefs = resolvedMessage["x-triggered-by"];
-	if (!triggerDefs) return;
+	const triggerDefs = resolvedMessage["x-triggered-by"]
+	if (!triggerDefs) return
 
-	const triggerArray = Array.isArray(triggerDefs) ? triggerDefs : [triggerDefs];
+	const triggerArray = Array.isArray(triggerDefs) ? triggerDefs : [triggerDefs]
 
 	for (const triggerDef of triggerArray) {
-		const operationKey = triggerDef.operation;
-		if (!operationKey) continue;
+		const operationKey = triggerDef.operation
+		if (!operationKey) continue
 
 		if (!triggers[operationKey]) {
-			triggers[operationKey] = [];
+			triggers[operationKey] = []
 		}
 
 		triggers[operationKey].push({
@@ -146,7 +143,7 @@ function extractTriggersFromMessage(channelName, message, spec, triggers) {
 			delay: triggerDef.delay || 0,
 			condition: triggerDef.condition,
 			payload: triggerDef.payload || resolvedMessage.payload,
-		});
+		})
 	}
 }
 
@@ -158,21 +155,21 @@ function extractTriggersFromMessage(channelName, message, spec, triggers) {
  */
 function resolveRef(ref, spec) {
 	if (!ref || !ref.startsWith("#/")) {
-		return null;
+		return null
 	}
 
-	const parts = ref.slice(2).split("/");
-	let current = spec;
+	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];
+			current = current[part]
 		} else {
-			return null;
+			return null
 		}
 	}
 
-	return current;
+	return current
 }
 
 /**
@@ -182,31 +179,31 @@ function resolveRef(ref, spec) {
  * @returns {object} Templated payload
  */
 function templatePayload(payload, context) {
-	if (!payload) return {};
+	if (!payload) return {}
 
-	const payloadStr = JSON.stringify(payload);
+	const payloadStr = JSON.stringify(payload)
 
 	// Replace template variables
 	const templated = payloadStr.replace(/\{\{([^}]+)\}\}/g, (match, path) => {
-		const value = resolvePath(path.trim(), context);
+		const value = resolvePath(path.trim(), context)
 
 		if (value === undefined) {
-			return match; // Keep original if not found
+			return match // Keep original if not found
 		}
 
 		// Handle different types
 		if (typeof value === "string") {
-			return value;
+			return value
 		}
 
-		return JSON.stringify(value);
-	});
+		return JSON.stringify(value)
+	})
 
 	try {
-		return JSON.parse(templated);
+		return JSON.parse(templated)
 	} catch {
 		// If JSON parse fails, return original
-		return payload;
+		return payload
 	}
 }
 
@@ -219,25 +216,25 @@ function templatePayload(payload, context) {
 function resolvePath(path, obj) {
 	// Handle special values
 	if (path === "now") {
-		return new Date().toISOString();
+		return new Date().toISOString()
 	}
 
 	if (path === "timestamp") {
-		return Date.now();
+		return Date.now()
 	}
 
-	const parts = path.split(".");
-	let current = obj;
+	const parts = path.split(".")
+	let current = obj
 
 	for (const part of parts) {
 		if (current && typeof current === "object" && part in current) {
-			current = current[part];
+			current = current[part]
 		} else {
-			return undefined;
+			return undefined
 		}
 	}
 
-	return current;
+	return current
 }
 
 /**
@@ -247,43 +244,43 @@ function resolvePath(path, obj) {
  * @returns {boolean} Condition result
  */
 function evaluateCondition(condition, context) {
-	if (!condition) return true;
+	if (!condition) return true
 
 	try {
 		// Simple condition parsing (e.g., "response.status == 200")
-		const match = condition.match(/^([^\s]+)\s*(==|!=|>|<|>=|<=)\s*(.+)$/);
+		const match = condition.match(/^([^\s]+)\s*(==|!=|>|<|>=|<=)\s*(.+)$/)
 
-		if (!match) return true;
+		if (!match) return true
 
-		const [, path, operator, valueStr] = match;
-		const actualValue = resolvePath(path, context);
+		const [, path, operator, valueStr] = match
+		const actualValue = resolvePath(path, context)
 
 		// Parse the expected value
-		let expectedValue;
+		let expectedValue
 		try {
-			expectedValue = JSON.parse(valueStr);
+			expectedValue = JSON.parse(valueStr)
 		} catch {
-			expectedValue = valueStr;
+			expectedValue = valueStr
 		}
 
 		switch (operator) {
 			case "==":
-				return actualValue == expectedValue;
+				return actualValue == expectedValue
 			case "!=":
-				return actualValue != expectedValue;
+				return actualValue != expectedValue
 			case ">":
-				return actualValue > expectedValue;
+				return actualValue > expectedValue
 			case "<":
-				return actualValue < expectedValue;
+				return actualValue < expectedValue
 			case ">=":
-				return actualValue >= expectedValue;
+				return actualValue >= expectedValue
 			case "<=":
-				return actualValue <= expectedValue;
+				return actualValue <= expectedValue
 			default:
-				return true;
+				return true
 		}
 	} catch {
-		return true;
+		return true
 	}
 }
 
@@ -295,45 +292,49 @@ function evaluateCondition(condition, context) {
  * @param {object} context - Request/response context
  */
 function triggerSocketEvents(io, socketTriggers, operationKey, context) {
-	if (!io || !socketTriggers) return;
+	if (!io || !socketTriggers) return
 
-	const triggers = socketTriggers[operationKey];
-	if (!triggers || triggers.length === 0) 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;
+			console.log(
+				`   ⏭️  Skipped socket event (condition not met): ${trigger.event}`,
+			)
+			continue
 		}
 
 		// Template the payload
-		const payload = templatePayload(trigger.payload, context);
+		const payload = templatePayload(trigger.payload, context)
 
 		// Template the channel name
-		let channel = trigger.channel || "";
+		let channel = trigger.channel || ""
 		channel = channel.replace(/\{([^}]+)\}/g, (match, path) => {
-			const value = resolvePath(`request.params.${path}`, context);
-			return value !== undefined ? value : match;
-		});
+			const value = resolvePath(`request.params.${path}`, context)
+			return value !== undefined ? value : match
+		})
 
 		// Schedule the emit
-		const delay = trigger.delay || 0;
+		const delay = trigger.delay || 0
 
 		const emit = () => {
-			console.log(`   📡 Emitting socket event: ${trigger.event}`);
+			console.log(`   📡 Emitting socket event: ${trigger.event}`)
 			if (channel) {
-				console.log(`      Channel: ${channel}`);
+				console.log(`      Channel: ${channel}`)
 			}
 
-			io.emit(trigger.event, payload);
-		};
+			io.emit(trigger.event, payload)
+		}
 
 		if (delay > 0) {
-			console.log(`   ⏱️  Scheduling socket event: ${trigger.event} (${delay}ms delay)`);
-			setTimeout(emit, delay);
+			console.log(
+				`   ⏱️  Scheduling socket event: ${trigger.event} (${delay}ms delay)`,
+			)
+			setTimeout(emit, delay)
 		} else {
-			emit();
+			emit()
 		}
 	}
 }
@@ -345,21 +346,21 @@ function triggerSocketEvents(io, socketTriggers, operationKey, context) {
  */
 function getTriggerStats(socketTriggers) {
 	if (!socketTriggers) {
-		return { total: 0, operations: [] };
+		return { total: 0, operations: [] }
 	}
 
-	const operations = [];
-	let total = 0;
+	const operations = []
+	let total = 0
 
 	for (const [operation, triggers] of Object.entries(socketTriggers)) {
-		total += triggers.length;
+		total += triggers.length
 		operations.push({
 			operation,
 			events: triggers.map((t) => t.event),
-		});
+		})
 	}
 
-	return { total, operations };
+	return { total, operations }
 }
 
 module.exports = {
@@ -368,4 +369,4 @@ module.exports = {
 	templatePayload,
 	evaluateCondition,
 	getTriggerStats,
-};
+}