@gxp-dev/tools 2.0.63 → 2.0.65

package/runtime/main.js

@@ -1,40 +1,42 @@
-import { createApp } from "vue";
-import * as Vue from "vue";
-import * as Pinia from "pinia";
-import { createPinia, setActivePinia } from "pinia";
+import { createApp } from "vue"
+import * as Vue from "vue"
+import * as Pinia from "pinia"
+import { createPinia, setActivePinia } from "pinia"
 
 // Create and configure Pinia before any store imports
-const pinia = createPinia();
-setActivePinia(pinia);
+const pinia = createPinia()
+setActivePinia(pinia)
 
 // Expose Vue and Pinia to window for dynamically loaded plugins
-window.Vue = Vue;
-window.Pinia = Pinia;
-window.pinia = pinia;
+window.Vue = Vue
+window.Pinia = Pinia
+window.pinia = pinia
 
 // Dynamic imports ensure pinia is set up before stores load
 async function init() {
-	const { default: App } = await import("@gx-runtime/PortalContainer.vue");
-	const { useGxpStore } = await import("@/stores/index.js");
-	const { createGxpStringsPlugin } = await import("@gx-runtime/gxpStringsPlugin.js");
+	const { default: App } = await import("@gx-runtime/PortalContainer.vue")
+	const { useGxpStore } = await import("@/stores/index.js")
+	const { createGxpStringsPlugin } =
+		await import("@gx-runtime/gxpStringsPlugin.js")
 
-	window.useGxpStore = useGxpStore;
+	window.useGxpStore = useGxpStore
 
-	const app = createApp(App);
-	app.use(pinia);
+	const app = createApp(App)
+	app.use(pinia)
 
-	const gxpStore = useGxpStore();
+	const gxpStore = useGxpStore()
 
 	// Build the dev server base URL so gxp-src default paths resolve to the
 	// local dev server instead of the current domain (important when the app
 	// is injected into the cloud platform via browser extension).
-	const devProtocol = import.meta.env.VITE_USE_HTTPS !== "false" ? "https" : "http";
-	const devPort = import.meta.env.VITE_NODE_PORT || "3060";
-	const devServerBaseUrl = `${devProtocol}://localhost:${devPort}`;
+	const devProtocol =
+		import.meta.env.VITE_USE_HTTPS !== "false" ? "https" : "http"
+	const devPort = import.meta.env.VITE_NODE_PORT || "3060"
+	const devServerBaseUrl = `${devProtocol}://localhost:${devPort}`
 
-	app.use(createGxpStringsPlugin(gxpStore, { devServerBaseUrl }));
+	app.use(createGxpStringsPlugin(gxpStore, { devServerBaseUrl }))
 
-	app.mount("#app");
+	app.mount("#app")
 }
 
-init();
+init()

package/runtime/mock-api/auth-middleware.js

@@ -12,7 +12,7 @@
  * @param {function} next - Next middleware
  */
 function authMiddleware(req, res, next) {
-	const auth = req.headers.authorization;
+	const auth = req.headers.authorization
 
 	// Check if Authorization header exists
 	if (!auth) {
@@ -20,7 +20,7 @@ function authMiddleware(req, res, next) {
 			error: "Unauthorized",
 			message: "Missing Authorization header",
 			hint: "Include 'Authorization: Bearer <token>' header",
-		});
+		})
 	}
 
 	// Check Bearer token format
@@ -29,11 +29,11 @@ function authMiddleware(req, res, next) {
 			error: "Unauthorized",
 			message: "Invalid Authorization format",
 			hint: "Use 'Bearer <token>' format",
-		});
+		})
 	}
 
 	// Extract token
-	const token = auth.slice(7).trim();
+	const token = auth.slice(7).trim()
 
 	// Check token is not empty
 	if (!token) {
@@ -41,14 +41,14 @@ function authMiddleware(req, res, next) {
 			error: "Unauthorized",
 			message: "Empty token",
 			hint: "Provide a non-empty token after 'Bearer '",
-		});
+		})
 	}
 
 	// Token format is valid, attach to request for potential use
-	req.mockToken = token;
+	req.mockToken = token
 
 	// Continue to next middleware/handler
-	next();
+	next()
 }
 
 /**
@@ -58,13 +58,13 @@ function authMiddleware(req, res, next) {
  * @param {function} next - Next middleware
  */
 function optionalAuthMiddleware(req, res, next) {
-	const auth = req.headers.authorization;
+	const auth = req.headers.authorization
 
 	if (auth && auth.startsWith("Bearer ")) {
-		req.mockToken = auth.slice(7).trim();
+		req.mockToken = auth.slice(7).trim()
 	}
 
-	next();
+	next()
 }
 
 /**
@@ -74,24 +74,24 @@ function optionalAuthMiddleware(req, res, next) {
  */
 function createAuthMiddleware(operation) {
 	// Check if operation has security requirements
-	const security = operation.security;
+	const security = operation.security
 
 	// If security is explicitly empty array, no auth required
 	if (Array.isArray(security) && security.length === 0) {
-		return optionalAuthMiddleware;
+		return optionalAuthMiddleware
 	}
 
 	// If security is defined, require auth
 	if (security && security.length > 0) {
-		return authMiddleware;
+		return authMiddleware
 	}
 
 	// Default: require auth (safer default for mock API)
-	return authMiddleware;
+	return authMiddleware
 }
 
 module.exports = {
 	authMiddleware,
 	optionalAuthMiddleware,
 	createAuthMiddleware,
-};
+}

package/runtime/mock-api/image-generator.js

@@ -21,9 +21,9 @@ function randomColor() {
 		"#e91e63", // Pink
 		"#00bcd4", // Cyan
 		"#ff5722", // Deep orange
-	];
+	]
 
-	return colors[Math.floor(Math.random() * colors.length)];
+	return colors[Math.floor(Math.random() * colors.length)]
 }
 
 /**
@@ -33,17 +33,17 @@ function randomColor() {
  */
 function getContrastColor(hexColor) {
 	// Remove # if present
-	const hex = hexColor.replace("#", "");
+	const hex = hexColor.replace("#", "")
 
 	// Convert to RGB
-	const r = parseInt(hex.substr(0, 2), 16);
-	const g = parseInt(hex.substr(2, 2), 16);
-	const b = parseInt(hex.substr(4, 2), 16);
+	const r = parseInt(hex.substr(0, 2), 16)
+	const g = parseInt(hex.substr(2, 2), 16)
+	const b = parseInt(hex.substr(4, 2), 16)
 
 	// Calculate luminance
-	const luminance = (0.299 * r + 0.587 * g + 0.114 * b) / 255;
+	const luminance = (0.299 * r + 0.587 * g + 0.114 * b) / 255
 
-	return luminance > 0.5 ? "#000000" : "#ffffff";
+	return luminance > 0.5 ? "#000000" : "#ffffff"
 }
 
 /**
@@ -52,25 +52,25 @@ function getContrastColor(hexColor) {
  * @returns {string} Valid hex color
  */
 function parseColor(color) {
-	if (!color) return randomColor();
+	if (!color) return randomColor()
 
 	// Remove # if present
-	let hex = color.replace("#", "");
+	let hex = color.replace("#", "")
 
 	// Expand 3-digit hex
 	if (hex.length === 3) {
 		hex = hex
 			.split("")
 			.map((c) => c + c)
-			.join("");
+			.join("")
 	}
 
 	// Validate
 	if (/^[0-9a-fA-F]{6}$/.test(hex)) {
-		return `#${hex}`;
+		return `#${hex}`
 	}
 
-	return randomColor();
+	return randomColor()
 }
 
 /**
@@ -85,17 +85,17 @@ function parseColor(color) {
  * @returns {string} SVG string
  */
 function generateSvg(width, height, options = {}) {
-	const bgColor = parseColor(options.color);
-	const textColor = options.textColor || getContrastColor(bgColor);
-	const text = options.text || `${width}×${height}`;
+	const bgColor = parseColor(options.color)
+	const textColor = options.textColor || getContrastColor(bgColor)
+	const text = options.text || `${width}×${height}`
 
 	// Calculate font size based on dimensions
-	const minDim = Math.min(width, height);
-	const fontSize = options.fontSize || Math.max(12, Math.floor(minDim / 8));
+	const minDim = Math.min(width, height)
+	const fontSize = options.fontSize || Math.max(12, Math.floor(minDim / 8))
 
 	// Calculate text position
-	const textX = width / 2;
-	const textY = height / 2;
+	const textX = width / 2
+	const textY = height / 2
 
 	return `<?xml version="1.0" encoding="UTF-8"?>
 <svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}" viewBox="0 0 ${width} ${height}">
@@ -109,7 +109,7 @@ function generateSvg(width, height, options = {}) {
     text-anchor="middle"
     dominant-baseline="middle"
   >${escapeXml(text)}</text>
-</svg>`;
+</svg>`
 }
 
 /**
@@ -123,7 +123,7 @@ function escapeXml(text) {
 		.replace(/</g, "&lt;")
 		.replace(/>/g, "&gt;")
 		.replace(/"/g, "&quot;")
-		.replace(/'/g, "&apos;");
+		.replace(/'/g, "&apos;")
 }
 
 /**
@@ -133,25 +133,25 @@ function escapeXml(text) {
  */
 function parseDimensions(dimStr) {
 	if (!dimStr) {
-		return { width: 400, height: 300 };
+		return { width: 400, height: 300 }
 	}
 
 	// Try width x height format
-	const match = dimStr.match(/^(\d+)[x×:](\d+)$/i);
+	const match = dimStr.match(/^(\d+)[x×:](\d+)$/i)
 	if (match) {
 		return {
 			width: parseInt(match[1], 10),
 			height: parseInt(match[2], 10),
-		};
+		}
 	}
 
 	// Single number = square
-	const single = parseInt(dimStr, 10);
+	const single = parseInt(dimStr, 10)
 	if (!isNaN(single)) {
-		return { width: single, height: single };
+		return { width: single, height: single }
 	}
 
-	return { width: 400, height: 300 };
+	return { width: 400, height: 300 }
 }
 
 /**
@@ -161,24 +161,24 @@ function parseDimensions(dimStr) {
  */
 function imageHandler(req, res) {
 	// Parse dimensions from URL
-	const { width: widthParam, height: heightParam } = req.params;
+	const { width: widthParam, height: heightParam } = req.params
 
-	let width, height;
+	let width, height
 
 	if (heightParam) {
 		// /image/:width/:height format
-		width = parseInt(widthParam, 10) || 400;
-		height = parseInt(heightParam, 10) || 300;
+		width = parseInt(widthParam, 10) || 400
+		height = parseInt(heightParam, 10) || 300
 	} else {
 		// /image/:dimensions format (e.g., 400x300)
-		const dims = parseDimensions(widthParam);
-		width = dims.width;
-		height = dims.height;
+		const dims = parseDimensions(widthParam)
+		width = dims.width
+		height = dims.height
 	}
 
 	// Clamp dimensions
-	width = Math.min(Math.max(width, 1), 4000);
-	height = Math.min(Math.max(height, 1), 4000);
+	width = Math.min(Math.max(width, 1), 4000)
+	height = Math.min(Math.max(height, 1), 4000)
 
 	// Parse options from query string
 	const options = {
@@ -186,15 +186,15 @@ function imageHandler(req, res) {
 		text: req.query.text,
 		textColor: req.query.textColor || req.query.fg,
 		fontSize: req.query.fontSize ? parseInt(req.query.fontSize, 10) : undefined,
-	};
+	}
 
 	// Generate SVG
-	const svg = generateSvg(width, height, options);
+	const svg = generateSvg(width, height, options)
 
 	// Send response
-	res.set("Content-Type", "image/svg+xml");
-	res.set("Cache-Control", "public, max-age=86400"); // Cache for 24 hours
-	res.send(svg);
+	res.set("Content-Type", "image/svg+xml")
+	res.set("Cache-Control", "public, max-age=86400") // Cache for 24 hours
+	res.send(svg)
 }
 
 /**
@@ -205,9 +205,9 @@ function imageHandler(req, res) {
  * @returns {string} Data URL
  */
 function generateDataUrl(width, height, options = {}) {
-	const svg = generateSvg(width, height, options);
-	const base64 = Buffer.from(svg).toString("base64");
-	return `data:image/svg+xml;base64,${base64}`;
+	const svg = generateSvg(width, height, options)
+	const base64 = Buffer.from(svg).toString("base64")
+	return `data:image/svg+xml;base64,${base64}`
 }
 
 module.exports = {
@@ -218,4 +218,4 @@ module.exports = {
 	generateDataUrl,
 	randomColor,
 	getContrastColor,
-};
+}

package/runtime/mock-api/index.js

@@ -5,21 +5,21 @@
  * Creates an Express router that mounts onto the existing server.
  */
 
-const express = require("express");
+const express = require("express")
 const {
 	loadSpecs,
 	refreshSpecs,
 	getCacheStatus,
 	getCachedSpecs,
-} = require("./spec-loader");
-const { generateRoutes, getRouteStats } = require("./route-generator");
-const { parseSocketTriggers, getTriggerStats } = require("./socket-triggers");
-const { imageHandler } = require("./image-generator");
+} = require("./spec-loader")
+const { generateRoutes, getRouteStats } = require("./route-generator")
+const { parseSocketTriggers, getTriggerStats } = require("./socket-triggers")
+const { imageHandler } = require("./image-generator")
 
 // Store state for status endpoint
-let currentSpecs = null;
-let currentSocketTriggers = null;
-let routeStats = null;
+let currentSpecs = null
+let currentSocketTriggers = null
+let routeStats = null
 
 /**
  * Create the mock API router
@@ -29,40 +29,40 @@ let routeStats = null;
  * @returns {express.Router} Express router
  */
 async function createMockApiRouter(io, options = {}) {
-	const router = express.Router();
-	const projectRoot = options.projectRoot || process.cwd();
+	const router = express.Router()
+	const projectRoot = options.projectRoot || process.cwd()
 
-	console.log("\n🎭 Initializing Mock API Server...");
+	console.log("\n🎭 Initializing Mock API Server...")
 
 	// Load specs
-	const specs = await loadSpecs(projectRoot);
-	currentSpecs = specs;
+	const specs = await loadSpecs(projectRoot)
+	currentSpecs = specs
 
 	// Parse socket triggers from AsyncAPI
 	if (specs.asyncApi) {
-		currentSocketTriggers = parseSocketTriggers(specs.asyncApi);
+		currentSocketTriggers = parseSocketTriggers(specs.asyncApi)
 	}
 
 	// Generate routes from OpenAPI
 	if (specs.openApi) {
-		console.log("\n📍 Generating mock routes from OpenAPI spec:");
+		console.log("\n📍 Generating mock routes from OpenAPI spec:")
 		const apiRouter = generateRoutes(specs.openApi, {
 			io,
 			socketTriggers: currentSocketTriggers,
-		});
-		routeStats = getRouteStats(specs.openApi);
+		})
+		routeStats = getRouteStats(specs.openApi)
 
 		// Mount API routes under /api
-		router.use("/api", apiRouter);
+		router.use("/api", apiRouter)
 	} else {
-		console.log("⚠️  No OpenAPI spec available, mock API routes not generated");
-		routeStats = { total: 0, byMethod: {}, paths: [] };
+		console.log("⚠️  No OpenAPI spec available, mock API routes not generated")
+		routeStats = { total: 0, byMethod: {}, paths: [] }
 	}
 
 	// Status endpoint
 	router.get("/_mock/status", (req, res) => {
-		const cacheStatus = getCacheStatus();
-		const triggerStats = getTriggerStats(currentSocketTriggers);
+		const cacheStatus = getCacheStatus()
+		const triggerStats = getTriggerStats(currentSocketTriggers)
 
 		res.json({
 			enabled: true,
@@ -75,25 +75,25 @@ async function createMockApiRouter(io, options = {}) {
 			routes: routeStats,
 			socketTriggers: triggerStats,
 			cache: cacheStatus,
-		});
-	});
+		})
+	})
 
 	// Refresh endpoint
 	router.post("/_mock/refresh", async (req, res) => {
-		console.log("\n🔄 Refreshing mock API specs...");
+		console.log("\n🔄 Refreshing mock API specs...")
 
 		try {
-			const newSpecs = await refreshSpecs(projectRoot);
-			currentSpecs = newSpecs;
+			const newSpecs = await refreshSpecs(projectRoot)
+			currentSpecs = newSpecs
 
 			// Re-parse socket triggers
 			if (newSpecs.asyncApi) {
-				currentSocketTriggers = parseSocketTriggers(newSpecs.asyncApi);
+				currentSocketTriggers = parseSocketTriggers(newSpecs.asyncApi)
 			}
 
 			// Update route stats
 			if (newSpecs.openApi) {
-				routeStats = getRouteStats(newSpecs.openApi);
+				routeStats = getRouteStats(newSpecs.openApi)
 			}
 
 			res.json({
@@ -104,19 +104,19 @@ async function createMockApiRouter(io, options = {}) {
 					asyncApi: !!newSpecs.asyncApi,
 					webhooks: !!newSpecs.webhooks,
 				},
-			});
+			})
 		} catch (error) {
-			console.error("❌ Failed to refresh specs:", error.message);
+			console.error("❌ Failed to refresh specs:", error.message)
 			res.status(500).json({
 				success: false,
 				error: error.message,
-			});
+			})
 		}
-	});
+	})
 
 	// Image generation endpoints
-	router.get("/_mock/image/:width/:height", imageHandler);
-	router.get("/_mock/image/:width", imageHandler); // Square or WxH format
+	router.get("/_mock/image/:width/:height", imageHandler)
+	router.get("/_mock/image/:width", imageHandler) // Square or WxH format
 
 	// Info endpoint
 	router.get("/_mock/info", (req, res) => {
@@ -135,43 +135,43 @@ async function createMockApiRouter(io, options = {}) {
 				MOCK_API_DELAY: process.env.MOCK_API_DELAY || "0",
 				MOCK_API_CACHE_TTL: process.env.MOCK_API_CACHE_TTL || "300000",
 			},
-		});
-	});
+		})
+	})
 
 	// Spec endpoints (for debugging)
 	router.get("/_mock/specs/openapi", (req, res) => {
 		if (currentSpecs?.openApi) {
-			res.json(currentSpecs.openApi);
+			res.json(currentSpecs.openApi)
 		} else {
-			res.status(404).json({ error: "OpenAPI spec not loaded" });
+			res.status(404).json({ error: "OpenAPI spec not loaded" })
 		}
-	});
+	})
 
 	router.get("/_mock/specs/asyncapi", (req, res) => {
 		if (currentSpecs?.asyncApi) {
-			res.json(currentSpecs.asyncApi);
+			res.json(currentSpecs.asyncApi)
 		} else {
-			res.status(404).json({ error: "AsyncAPI spec not loaded" });
+			res.status(404).json({ error: "AsyncAPI spec not loaded" })
 		}
-	});
+	})
 
 	router.get("/_mock/specs/webhooks", (req, res) => {
 		if (currentSpecs?.webhooks) {
-			res.json(currentSpecs.webhooks);
+			res.json(currentSpecs.webhooks)
 		} else {
-			res.status(404).json({ error: "Webhook spec not loaded" });
+			res.status(404).json({ error: "Webhook spec not loaded" })
 		}
-	});
+	})
 
-	console.log("\n✅ Mock API Server initialized");
-	console.log("   Status: GET /_mock/status");
-	console.log("   Refresh: POST /_mock/refresh");
-	console.log("   Images: GET /_mock/image/:width/:height");
+	console.log("\n✅ Mock API Server initialized")
+	console.log("   Status: GET /_mock/status")
+	console.log("   Refresh: POST /_mock/refresh")
+	console.log("   Images: GET /_mock/image/:width/:height")
 	if (routeStats?.total > 0) {
-		console.log(`   API Routes: ${routeStats.total} endpoints under /api/*`);
+		console.log(`   API Routes: ${routeStats.total} endpoints under /api/*`)
 	}
 
-	return router;
+	return router
 }
 
 /**
@@ -179,7 +179,7 @@ async function createMockApiRouter(io, options = {}) {
  * @returns {object} Current specs
  */
 function getSpecs() {
-	return currentSpecs;
+	return currentSpecs
 }
 
 /**
@@ -187,11 +187,11 @@ function getSpecs() {
  * @returns {object} Current socket triggers
  */
 function getSocketTriggers() {
-	return currentSocketTriggers;
+	return currentSocketTriggers
 }
 
 module.exports = {
 	createMockApiRouter,
 	getSpecs,
 	getSocketTriggers,
-};
+}