@gxp-dev/tools 2.0.71 → 2.0.73

package/mcp/lib/test-tools.js

@@ -0,0 +1,358 @@
+/**
+ * MCP tools for plugin testing:
+ *
+ *   - test_scaffold_component_test : writes a Vitest + Vue Test Utils file
+ *     for a given Vue component, with render/props/events placeholders.
+ *
+ *   - test_api_route : resolves an OpenAPI operationId to method+path,
+ *     substitutes path parameters, and hits the local mock API (default
+ *     http://localhost:3069/api) with optional query and body, returning
+ *     status, headers, and response body.
+ */
+
+const fs = require("fs")
+const path = require("path")
+
+const { fetchSpec } = require("./specs")
+
+function contentResult(obj) {
+	return {
+		content: [{ type: "text", text: JSON.stringify(obj, null, 2) }],
+	}
+}
+
+function resolveProjectPath(p) {
+	if (!p) throw new Error("`path` argument is required")
+	return path.isAbsolute(p) ? p : path.resolve(process.cwd(), p)
+}
+
+/* ------------------------- scaffold_component_test ----------------------- */
+
+function componentNameFromFile(componentPath) {
+	const base = path.basename(componentPath).replace(/\.vue$/i, "")
+	return base.replace(/[^A-Za-z0-9_$]/g, "_") || "Component"
+}
+
+function defaultTestPathFor(componentAbsPath, projectRoot) {
+	const rel = path.relative(projectRoot, componentAbsPath)
+	const base = path.basename(rel, ".vue")
+	// Siblings to the project root: tests/<Component>.test.js
+	return path.join(projectRoot, "tests", `${base}.test.js`)
+}
+
+function renderScaffold({ componentName, importPath }) {
+	return `import { describe, it, expect } from "vitest"
+import { mount } from "@vue/test-utils"
+import ${componentName} from "${importPath}"
+
+describe("${componentName}", () => {
+	it("renders the component", () => {
+		const wrapper = mount(${componentName})
+		expect(wrapper.exists()).toBe(true)
+	})
+
+	it.todo("renders expected headings/labels")
+
+	it.todo("accepts props")
+
+	it.todo("emits events on interaction")
+})
+`
+}
+
+function toImportPath(absComponent, absTestFile, projectRoot) {
+	// Prefer the "@/…" alias when the component lives under <projectRoot>/src.
+	const srcDir = path.join(projectRoot, "src")
+	if (absComponent.startsWith(srcDir + path.sep) || absComponent === srcDir) {
+		const rel = path.relative(srcDir, absComponent).replace(/\\/g, "/")
+		return `@/${rel}`
+	}
+	// Fall back to a relative path from the test file.
+	const rel = path.relative(path.dirname(absTestFile), absComponent)
+	const norm = rel.replace(/\\/g, "/")
+	return norm.startsWith(".") ? norm : `./${norm}`
+}
+
+function scaffoldComponentTest({
+	componentPath,
+	testPath,
+	componentName,
+	overwrite = false,
+	projectRoot,
+}) {
+	const projRoot = projectRoot || process.cwd()
+	const absComponent = resolveProjectPath(componentPath)
+	if (!fs.existsSync(absComponent)) {
+		return { ok: false, error: `Component not found: ${absComponent}` }
+	}
+
+	const absTest = testPath
+		? resolveProjectPath(testPath)
+		: defaultTestPathFor(absComponent, projRoot)
+	const name = componentName || componentNameFromFile(absComponent)
+	const importPath = toImportPath(absComponent, absTest, projRoot)
+
+	if (fs.existsSync(absTest) && !overwrite) {
+		return {
+			ok: false,
+			error: `Test already exists at ${absTest}. Pass overwrite: true to replace.`,
+			test_path: absTest,
+		}
+	}
+
+	fs.mkdirSync(path.dirname(absTest), { recursive: true })
+	fs.writeFileSync(
+		absTest,
+		renderScaffold({ componentName: name, importPath }),
+		"utf-8",
+	)
+	return {
+		ok: true,
+		test_path: absTest,
+		component_name: name,
+		import_path: importPath,
+		run_with: "npx vitest run " + path.relative(projRoot, absTest),
+	}
+}
+
+/* ------------------------------ test_api_route --------------------------- */
+
+function substitutePathParams(rawPath, params = {}) {
+	// Replace /path/{name} and /path/:name with the given values.
+	const missing = []
+	let out = rawPath.replace(/\{([^}]+)\}/g, (_m, name) => {
+		if (params[name] === undefined || params[name] === null) {
+			missing.push(name)
+			return `{${name}}`
+		}
+		return encodeURIComponent(String(params[name]))
+	})
+	out = out.replace(/:([A-Za-z_][A-Za-z0-9_]*)/g, (_m, name) => {
+		if (params[name] === undefined || params[name] === null) {
+			missing.push(name)
+			return `:${name}`
+		}
+		return encodeURIComponent(String(params[name]))
+	})
+	return { path: out, missing }
+}
+
+function buildQueryString(query) {
+	if (!query || typeof query !== "object") return ""
+	const params = new URLSearchParams()
+	for (const [k, v] of Object.entries(query)) {
+		if (v === undefined || v === null) continue
+		if (Array.isArray(v)) {
+			for (const item of v) params.append(k, String(item))
+		} else {
+			params.set(k, String(v))
+		}
+	}
+	const s = params.toString()
+	return s ? `?${s}` : ""
+}
+
+function findOperation(spec, operationId) {
+	if (!spec?.paths) return null
+	for (const [p, methods] of Object.entries(spec.paths)) {
+		for (const [method, op] of Object.entries(methods)) {
+			if (typeof op === "object" && op?.operationId === operationId) {
+				return { path: p, method: method.toUpperCase(), op }
+			}
+		}
+	}
+	return null
+}
+
+async function testApiRoute({
+	operationId,
+	pathParams,
+	query,
+	body,
+	headers,
+	baseUrl,
+	timeoutMs,
+}) {
+	const spec = await fetchSpec("openapi")
+	const found = findOperation(spec, operationId)
+	if (!found) {
+		return { ok: false, error: `Operation not found: ${operationId}` }
+	}
+
+	const { path: rawPath, method } = found
+	const { path: resolvedPath, missing } = substitutePathParams(
+		rawPath,
+		pathParams,
+	)
+	if (missing.length > 0) {
+		return {
+			ok: false,
+			error: `Missing required path parameters: ${missing.join(", ")}`,
+			required_parameters: missing,
+		}
+	}
+
+	const base = (baseUrl || "http://localhost:3069/api").replace(/\/+$/, "")
+	const url = `${base}${resolvedPath}${buildQueryString(query)}`
+
+	const controller = new AbortController()
+	const timer = setTimeout(
+		() => controller.abort(),
+		Math.max(1000, timeoutMs ?? 10000),
+	)
+	const t0 = Date.now()
+	try {
+		const hasBody =
+			body !== undefined && body !== null && !["GET", "HEAD"].includes(method)
+		const res = await fetch(url, {
+			method,
+			signal: controller.signal,
+			headers: {
+				Accept: "application/json",
+				...(hasBody ? { "Content-Type": "application/json" } : {}),
+				...(headers || {}),
+			},
+			body: hasBody ? JSON.stringify(body) : undefined,
+		})
+
+		const duration_ms = Date.now() - t0
+		const respHeaders = {}
+		res.headers.forEach((v, k) => {
+			respHeaders[k] = v
+		})
+		const raw = await res.text()
+		let parsedBody = raw
+		try {
+			parsedBody = JSON.parse(raw)
+		} catch {
+			// keep as text
+		}
+
+		return {
+			ok: res.ok,
+			request: {
+				method,
+				url,
+			},
+			response: {
+				status: res.status,
+				statusText: res.statusText,
+				headers: respHeaders,
+				body: parsedBody,
+			},
+			duration_ms,
+		}
+	} catch (err) {
+		const duration_ms = Date.now() - t0
+		return {
+			ok: false,
+			request: { method, url },
+			error: err.name === "AbortError" ? "Request timed out" : err.message,
+			duration_ms,
+		}
+	} finally {
+		clearTimeout(timer)
+	}
+}
+
+/* ------------------------------- tool schemas ----------------------------- */
+
+const TEST_TOOLS = [
+	{
+		name: "test_scaffold_component_test",
+		description:
+			"Create a Vitest + Vue Test Utils test file for a given Vue component. Picks an import path via the @/ alias when the component lives under src/, else falls back to a relative path. Refuses to overwrite unless overwrite=true.",
+		inputSchema: {
+			type: "object",
+			properties: {
+				componentPath: {
+					type: "string",
+					description:
+						"Absolute or project-relative path to the .vue file to test.",
+				},
+				testPath: {
+					type: "string",
+					description:
+						"Optional override for where to write the test file. Default: tests/<ComponentName>.test.js at the project root.",
+				},
+				componentName: {
+					type: "string",
+					description:
+						"Optional override for the identifier used in the test. Default: the component filename without extension.",
+				},
+				overwrite: { type: "boolean", default: false },
+			},
+			required: ["componentPath"],
+		},
+	},
+	{
+		name: "test_api_route",
+		description:
+			"Exercise a single API endpoint by operationId. Resolves the OpenAPI spec to method+path, substitutes path params, and issues a request. Defaults to the local mock API at http://localhost:3069/api — override via baseUrl to hit staging/develop. Returns status, headers, parsed body, and duration.",
+		inputSchema: {
+			type: "object",
+			properties: {
+				operationId: {
+					type: "string",
+					description: "OpenAPI operationId (e.g. 'attendees.index').",
+				},
+				pathParams: {
+					type: "object",
+					description:
+						"Values for {param} / :param segments in the path, keyed by parameter name.",
+				},
+				query: {
+					type: "object",
+					description:
+						"Query-string values keyed by parameter name. Arrays send repeated keys.",
+				},
+				body: {
+					description: "Request body. Sent as JSON for non-GET/HEAD methods.",
+				},
+				headers: {
+					type: "object",
+					description: "Additional headers to include.",
+				},
+				baseUrl: {
+					type: "string",
+					description:
+						"Override the base URL. Default: http://localhost:3069/api (the toolkit's mock API mount).",
+				},
+				timeoutMs: {
+					type: "integer",
+					description: "Abort after N ms. Default 10000.",
+				},
+			},
+			required: ["operationId"],
+		},
+	},
+]
+
+async function handleTestToolCall(name, args = {}) {
+	switch (name) {
+		case "test_scaffold_component_test":
+			return contentResult(scaffoldComponentTest(args))
+
+		case "test_api_route":
+			return contentResult(await testApiRoute(args))
+
+		default:
+			throw new Error(`Unknown test tool: ${name}`)
+	}
+}
+
+function isTestTool(name) {
+	return TEST_TOOLS.some((t) => t.name === name)
+}
+
+module.exports = {
+	TEST_TOOLS,
+	handleTestToolCall,
+	isTestTool,
+	// Exported for testing
+	scaffoldComponentTest,
+	substitutePathParams,
+	buildQueryString,
+	findOperation,
+	testApiRoute,
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@gxp-dev/tools",
-	"version": "2.0.71",
+	"version": "2.0.73",
 	"description": "Dev tools to create platform plugins",
 	"type": "commonjs",
 	"publishConfig": {
@@ -60,6 +60,8 @@
 		"@gramercytech/gx-componentkit": "^1.0.23",
 		"@vitejs/plugin-vue": "^6.0.6",
 		"adm-zip": "^0.5.17",
+		"ajv": "^8.18.0",
+		"ajv-formats": "^3.0.1",
 		"chrome-launcher": "^1.2.1",
 		"concurrently": "^9.2.1",
 		"cors": "^2.8.6",

package/runtime/stores/gxpPortalConfigStore.js

@@ -244,8 +244,8 @@ export const useGxpStore = defineStore("gxp-portal-app", () => {
 
 		if (manifest.dependencies && Array.isArray(manifest.dependencies)) {
 			dependencies.value = manifest.dependencies // Store full dependency objects
-			dependencyList.value = manifest.dependencies.reduce((acc, dependency) => {
-				acc[dependency.identifier] = "1"
+			dependencyList.value = manifest.dependencies.reduce((acc, permission) => {
+				acc[permission.identifier] = "1"
 				return acc
 			}, {})
 			console.log("[GxP Store] Dependency List:", dependencyList.value)
@@ -379,58 +379,16 @@ export const useGxpStore = defineStore("gxp-portal-app", () => {
 
 		// Initialize dependency-based sockets based on the new structure
 		if (Array.isArray(dependencies.value)) {
-			dependencies.value.forEach((dependency) => {
-				if (
-					dependency.operations &&
-					Object.keys(dependency.operations).length > 0
-				) {
-					// Object.keys(dependency.operations).forEach((operation) => {
-					// 	if (
-					// 		Object.keys(apiOperations.value[dependency.identifier]).every(
-					// 			(key) =>
-					// 				[
-					// 					"identifier",
-					// 					"model",
-					// 					"permissionKey",
-					// 					"operations",
-					// 				].includes(key)
-					// 		)
-					// 	) {
-					// 		let method = "get";
-					// 		let path = dependency.operations[operation];
-					// 		if (path.includes(":")) {
-					// 			let pathSplit = path.split(":");
-					// 			method = pathSplit[0];
-					// 			path = pathSplit[1];
-					// 		}
-					// 		path = path.replace(
-					// 			"{teamSlug}/{projectSlug}",
-					// 			pluginVars.value.projectId
-					// 		);
-					// 		path = path.replace(
-					// 			`{${dependency.permissionKey}}`,
-					// 			dependencyList.value[dependency.identifier]
-					// 		);
-					// 		if (!apiOperations.value[dependency.identifier]) {
-					// 			apiOperations.value[dependency.identifier] = {};
-					// 		}
-					// 		apiOperations.value[dependency.identifier][operation] = {
-					// 			method: method,
-					// 			path: path,
-					// 			model_key: dependency.permissionKey,
-					// 		};
-					// 	}
-					// });
-				}
-				if (dependency.events && Object.keys(dependency.events).length > 0) {
+			dependencies.value.forEach((permission) => {
+				if (permission.events && Object.keys(permission.events).length > 0) {
 					// Create socket listeners for each event type
-					sockets[dependency.identifier] = {}
+					sockets[permission.identifier] = {}
 
-					Object.keys(dependency.events).forEach((eventType) => {
-						const eventName = dependency.events[eventType]
-						const channel = `private.${dependency.model}.${dependency.identifier}`
+					Object.keys(permission.events).forEach((eventType) => {
+						const eventName = permission.events[eventType]
+						const channel = `private.${permission.model}.${permission.identifier}`
 
-						sockets[dependency.identifier][eventType] = {
+						sockets[permission.identifier][eventType] = {
 							listen: function (callback) {
 								// Listen for the specific event on the primary socket
 								return primarySocket.on(eventName, (data) => {
@@ -445,7 +403,7 @@ export const useGxpStore = defineStore("gxp-portal-app", () => {
 					})
 				} else {
 					// For dependencies without events, create empty listeners
-					sockets[dependency.identifier] = {
+					sockets[permission.identifier] = {
 						created: { listen: () => () => {} },
 						updated: { listen: () => () => {} },
 						deleted: { listen: () => () => {} },
@@ -500,7 +458,7 @@ export const useGxpStore = defineStore("gxp-portal-app", () => {
 			throw new Error(`DELETE ${endpoint}: ${error.message}`)
 		}
 	}
-	async function callApi(operationId, identifier, data = {}) {
+	async function callApi(operationId, permissionIdentifier, data = {}) {
 		// Initialize operations if not done
 		if (Object.keys(apiOperations.value).length === 0) {
 			await initializeApiOperations()
@@ -520,7 +478,7 @@ export const useGxpStore = defineStore("gxp-portal-app", () => {
 
 		// Build context parameters from multiple sources:
 		// 1. Auto-inject teamSlug and projectSlug from portal context
-		// 2. Look up identifier value from dependencyList (if identifier provided)
+		// 2. Look up permissionIdentifier value from dependencyList (if permissionIdentifier provided)
 		// 3. Merge in additional data parameters
 
 		let projectTeamId = pluginVars.value?.projectId?.split("/")
@@ -537,14 +495,19 @@ export const useGxpStore = defineStore("gxp-portal-app", () => {
 		if (parameters.includes("form") && pluginVars.value?.formId) {
 			contextParams["form"] = pluginVars.value?.formId
 		}
-		// If identifier is provided, look up its value from dependencyList
-		// dependencyList stores parent object IDs as { 'identifier': idValue }
-		if (identifier !== null && identifier !== undefined) {
-			const identifierValue = dependencyList.value?.[identifier]
-			if (identifierValue !== undefined) {
-				// Add the identifier value using the identifier key as the param name
-				// e.g., identifier='form' with dependencyList.form='quiz-123' adds { form: 'quiz-123' }
-				contextParams[identifier] = identifierValue
+		// If permissionIdentifier is provided, look up its value from dependencyList
+		// dependencyList stores parent object IDs as { 'permissionIdentifier': idValue }
+		if (
+			permissionIdentifier !== null &&
+			permissionIdentifier !== undefined &&
+			permissionIdentifier !== "project"
+		) {
+			const permissionIdentifierValue =
+				dependencyList.value?.[permissionIdentifier]
+			if (permissionIdentifierValue !== undefined) {
+				// Add the permissionIdentifier value using the permissionIdentifier key as the param name
+				// e.g., permissionIdentifier='form' with dependencyList.form='quiz-123' adds { form: 'quiz-123' }
+				contextParams[permissionIdentifier] = permissionIdentifierValue
 			}
 		}
 		const parsedData = {}
@@ -582,9 +545,9 @@ export const useGxpStore = defineStore("gxp-portal-app", () => {
 		for (const param of parameters) {
 			delete bodyData[param]
 		}
-		// Also remove identifier from body if it was in data
-		if (identifier && bodyData[identifier] !== undefined) {
-			delete bodyData[identifier]
+		// Also remove permissionIdentifier from body if it was in data
+		if (permissionIdentifier && bodyData[permissionIdentifier] !== undefined) {
+			delete bodyData[permissionIdentifier]
 		}
 
 		try {
@@ -611,20 +574,6 @@ export const useGxpStore = defineStore("gxp-portal-app", () => {
 			)
 			throw new Error(`${method.toUpperCase()} ${resolvedPath}: ${message}`)
 		}
-
-		// try {
-		// 	const operationConfig = apiOperations.value[identifier][operation];
-		// 	if (!operationConfig) {
-		// 		throw new Error(`Operation not found: ${operation}`);
-		// 	}
-		// 	const response = await apiClient[operationConfig.method](
-		// 		operationConfig.path,
-		// 		data
-		// 	);
-		// 	return response.data;
-		// } catch (error) {
-		// 	throw new Error(`${method} ${endpoint}: ${error.message}`);
-		// }
 	}
 
 	// Utility methods
@@ -643,8 +592,8 @@ export const useGxpStore = defineStore("gxp-portal-app", () => {
 	function getState(key, fallback = null) {
 		return triggerState.value[key] || fallback
 	}
-	function findDependency(identifier) {
-		return dependencyList.value[identifier]
+	function findDependency(permissionIdentifier) {
+		return dependencyList.value[permissionIdentifier]
 	}
 	function hasPermission(flag) {
 		return permissionFlags.value.includes(flag)
@@ -661,13 +610,65 @@ export const useGxpStore = defineStore("gxp-portal-app", () => {
 	}
 
 	// Standard Socket helper methods
-	function listen(socketName, event, callback) {
-		if (sockets[socketName] && sockets[socketName].listen) {
-			return sockets[socketName].listen(event, callback)
-		} else {
-			console.warn(`Socket not found: ${socketName}`)
-			return () => {}
+	//
+	// Polymorphic — supports two forms:
+	//
+	//   1. listen(socketName, event, callback)
+	//      Subscribes to `event` on the named socket (e.g. 'primary' or a
+	//      dependency identifier whose socket was initialized via
+	//      initializeDependencySockets). This matches the legacy shape.
+	//
+	//   2. listen(eventName, permissionIdentifier, callback)
+	//      Subscribes to an AsyncAPI-defined platform event on the primary
+	//      socket, scoped to a permission identifier from dependencyList
+	//      (or the reserved "project" identifier). Use this for events whose
+	//      `x-triggered-by` matches a callApi operationId.
+	//
+	// Disambiguation: if arg1 names a registered socket we take form 1,
+	// otherwise we fall through to form 2.
+	function listen(arg1, arg2, arg3) {
+		const hasRegisteredSocket =
+			sockets[arg1] && typeof sockets[arg1].listen === "function"
+
+		if (hasRegisteredSocket && typeof arg3 === "function") {
+			return sockets[arg1].listen(arg2, arg3)
+		}
+
+		if (typeof arg3 === "function") {
+			const eventName = arg1
+			const permissionIdentifier = arg2
+			const callback = arg3
+			const primary = socketConnections.primary
+			if (!primary) {
+				console.warn(
+					"[GxP Store] listen(): primary socket not initialized",
+				)
+				return () => {}
+			}
+			if (
+				permissionIdentifier !== "project" &&
+				dependencyList.value?.[permissionIdentifier] === undefined
+			) {
+				console.warn(
+					`[GxP Store] listen("${eventName}", "${permissionIdentifier}"): permission identifier not bound in dependencyList`,
+				)
+			}
+			const handler = (data) => {
+				try {
+					callback(data)
+				} catch (err) {
+					console.error(
+						`[GxP Store] listen callback error for ${eventName}:`,
+						err,
+					)
+				}
+			}
+			primary.on(eventName, handler)
+			return () => primary.off(eventName, handler)
 		}
+
+		console.warn(`Socket not found: ${arg1}`)
+		return () => {}
 	}
 
 	function broadcast(socketName, event, data) {

package/runtime/vite.config.js

@@ -320,9 +320,11 @@ export default defineConfig(async (ctx) => {
 					"@/stores/gxpPortalConfigStore":
 						"(window.useGxpStore || (() => { console.warn('useGxpStore not found on window, using fallback'); return {}; }))",
 				},
-				{
-					include: ["src/**"],
-				},
+				// No `include` filter — rewrite `from "vue"` / `from "pinia"`
+				// in every module of the final bundle, including transitive deps
+				// from node_modules (component libraries, etc.). Without this,
+				// deps' internal `import { h } from "vue"` leak through as bare
+				// specifiers and crash at runtime on the platform.
 			),
 			// Custom request logging and CORS plugin
 			{