@growthub/cli 0.9.12 → 0.9.14

package/assets/worker-kits/growthub-custom-workspace-starter-v1/apps/workspace/app/api/workspace/resolvers/route.js

@@ -0,0 +1,41 @@
+/**
+ * GET /api/workspace/resolvers
+ *
+ * Lists resolver files present in lib/adapters/integrations/resolvers/ and
+ * returns provider-agnostic metadata for each registered resolver.
+ * Used by the generic resolver management panel and ResolverControlPanel in the
+ * widget inspector. No provider names appear in the response shape.
+ *
+ * Response:
+ *   {
+ *     files:         string[],
+ *     registeredIds: string[],
+ *     resolvers: {
+ *       integrationId:   string,
+ *       entityTypes:     string[],
+ *       hasListEntities: boolean,
+ *       configSchema:    SchemaField[] | null
+ *     }[],
+ *     canUpload: boolean
+ *   }
+ */
+
+import { NextResponse } from "next/server";
+import { loadAllResolvers, listResolverFiles } from "@/lib/adapters/integrations/resolver-loader";
+import { describeRegisteredResolvers } from "@/lib/adapters/integrations/source-resolver-registry";
+import { describePersistenceMode } from "@/lib/workspace-config";
+
+async function GET() {
+  await loadAllResolvers();
+  const files = await listResolverFiles();
+  const resolvers = describeRegisteredResolvers();
+  const persistence = describePersistenceMode();
+  return NextResponse.json({
+    files,
+    registeredIds: resolvers.map((r) => r.integrationId),
+    resolvers,
+    canUpload: persistence.canSave
+  });
+}
+
+export { GET };

package/assets/worker-kits/growthub-custom-workspace-starter-v1/apps/workspace/app/api/workspace/test-api-record/route.js

@@ -0,0 +1,126 @@
+import { NextResponse } from "next/server";
+import { readWorkspaceConfig } from "@/lib/workspace-config";
+
+const DEFAULT_TIMEOUT_MS = 15000;
+
+function normalizeMethod(value) {
+  const method = String(value || "GET").trim().toUpperCase();
+  return ["GET", "POST", "PUT", "PATCH", "DELETE"].includes(method) ? method : "GET";
+}
+
+function buildUrl(record) {
+  const baseUrl = String(record?.baseUrl || "").trim();
+  const endpoint = String(record?.endpoint || "").trim();
+  const raw = endpoint || baseUrl;
+  if (!raw) throw new Error("baseUrl or endpoint is required");
+  if (/^https?:\/\//i.test(endpoint)) return endpoint;
+  if (!baseUrl) throw new Error("baseUrl is required when endpoint is relative");
+  return `${baseUrl.replace(/\/+$/, "")}/${endpoint.replace(/^\/+/, "")}`;
+}
+
+function envKeyCandidates(ref) {
+  const token = String(ref || "")
+    .trim()
+    .replace(/[^a-z0-9]+/gi, "_")
+    .replace(/^_+|_+$/g, "")
+    .toUpperCase();
+  return Array.from(new Set([
+    token,
+    token ? `${token}_API_KEY` : "",
+    token ? `${token}_TOKEN` : "",
+  ].filter(Boolean)));
+}
+
+function readServerSecret(authRef) {
+  for (const key of envKeyCandidates(authRef)) {
+    if (process.env[key]) return process.env[key];
+  }
+  return "";
+}
+
+function findRegistryRecord(workspaceConfig, registryId) {
+  const id = String(registryId || "").trim();
+  if (!id) return null;
+  const objects = Array.isArray(workspaceConfig?.dataModel?.objects) ? workspaceConfig.dataModel.objects : [];
+  for (const object of objects) {
+    if (object?.objectType !== "api-registry") continue;
+    const match = (object.rows || []).find((row) => row?.integrationId === id || row?.id === id || row?.Name === id);
+    if (match) return match;
+  }
+  return null;
+}
+
+function buildAuthHeaders(record, secret) {
+  if (!secret) return {};
+  const headerName = String(record?.authHeaderName || record?.authHeader || "x-api-key").trim();
+  if (!headerName) return {};
+  const prefix = String(record?.authPrefix || "").trim();
+  return { [headerName]: prefix ? `${prefix} ${secret}` : secret };
+}
+
+async function POST(request) {
+  let body;
+  try {
+    body = await request.json();
+  } catch {
+    return NextResponse.json({ ok: false, error: "invalid JSON body" }, { status: 400 });
+  }
+
+  const workspaceConfig = await readWorkspaceConfig();
+  const dataSourceRecord = body?.dataSourceRecord && typeof body.dataSourceRecord === "object"
+    ? body.dataSourceRecord
+    : null;
+  const registryRecord = dataSourceRecord ? findRegistryRecord(workspaceConfig, dataSourceRecord.registryId) : null;
+  const record = {
+    ...(registryRecord || {}),
+    ...(body?.record || {}),
+    ...(dataSourceRecord || {}),
+  };
+
+  let url;
+  try {
+    url = buildUrl(record);
+  } catch (error) {
+    return NextResponse.json({ ok: false, error: error.message }, { status: 400 });
+  }
+
+  const method = normalizeMethod(record.method);
+  const authRef = record.authRef || record.integrationId || dataSourceRecord?.registryId;
+  const secret = readServerSecret(authRef);
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), DEFAULT_TIMEOUT_MS);
+
+  try {
+    const response = await fetch(url, {
+      method,
+      headers: {
+        accept: "application/json",
+        ...(method !== "GET" ? { "content-type": "application/json" } : {}),
+        ...buildAuthHeaders(record, secret),
+      },
+      signal: controller.signal,
+    });
+    const contentType = response.headers.get("content-type") || "";
+    const payload = contentType.includes("application/json") ? await response.json() : await response.text();
+    return NextResponse.json({
+      ok: response.ok,
+      status: response.status,
+      statusText: response.statusText,
+      url,
+      authRef: authRef || null,
+      usedServerSecret: Boolean(secret),
+      response: payload,
+    }, { status: response.ok ? 200 : 502 });
+  } catch (error) {
+    return NextResponse.json({
+      ok: false,
+      error: error.name === "AbortError" ? "request timed out" : error.message || "request failed",
+      url,
+      authRef: authRef || null,
+    }, { status: 502 });
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+export { POST };

package/assets/worker-kits/growthub-custom-workspace-starter-v1/apps/workspace/app/api/workspace/test-source/route.js

@@ -0,0 +1,130 @@
+/**
+ * POST /api/workspace/test-source
+ *
+ * Tests a live source binding by calling the registered resolver for the
+ * requested integrationId and returning a preview of normalized records.
+ * Used by the no-code Live Source wizard in the widget source panel before
+ * the user applies the binding and triggers a full refresh.
+ *
+ * Dynamically loads resolver files from lib/adapters/integrations/resolvers/
+ * so operators can drop new resolver files without restarting the server
+ * (effective in Next.js dev mode with filesystem persistence).
+ *
+ * Request body:
+ *   {
+ *     integrationId: string,        // provider slug, e.g. "my-crm"
+ *     binding: {                    // provisional binding config from wizard
+ *       entityType?: string,
+ *       entityId?: string,
+ *       sourceId?: string,
+ *       authMode?: "bridge" | "byo-token"
+ *     }
+ *   }
+ *
+ * Response — success:
+ *   { ok: true, integrationId, recordCount, columns, preview: Record[] }
+ *
+ * Response — no resolver:
+ *   { ok: false, reason: "no-resolver", registeredResolvers: string[] }
+ *
+ * Response — resolver error:
+ *   { ok: false, reason: "fetch-error", error: string }
+ *
+ * Authority contract: tokens never leave the server. The browser sends only
+ * non-secret binding metadata. Provider auth is read from env server-side.
+ */
+
+import { NextResponse } from "next/server";
+import { readAdapterConfig } from "@/lib/adapters/env";
+import { listGovernedWorkspaceIntegrations } from "@/lib/adapters/integrations";
+import { loadAllResolvers } from "@/lib/adapters/integrations/resolver-loader";
+import { getSourceResolver, listRegisteredResolvers } from "@/lib/adapters/integrations/source-resolver-registry";
+
+const PREVIEW_ROW_LIMIT = 8;
+
+function inferColumns(records) {
+  const cols = new Set();
+  for (const record of records.slice(0, 20)) {
+    if (record && typeof record === "object" && !Array.isArray(record)) {
+      for (const key of Object.keys(record)) cols.add(key);
+    }
+  }
+  return Array.from(cols);
+}
+
+async function POST(request) {
+  let body;
+  try {
+    body = await request.json();
+  } catch {
+    return NextResponse.json({ ok: false, reason: "bad-request", error: "invalid JSON body" }, { status: 400 });
+  }
+
+  const { integrationId, binding } = body || {};
+  if (typeof integrationId !== "string" || !integrationId.trim()) {
+    return NextResponse.json({ ok: false, reason: "bad-request", error: "integrationId must be a non-empty string" }, { status: 400 });
+  }
+
+  // Load any resolver files the operator has dropped in the resolvers directory.
+  await loadAllResolvers();
+
+  const resolver = getSourceResolver(integrationId.trim());
+  if (!resolver) {
+    return NextResponse.json({
+      ok: false,
+      reason: "no-resolver",
+      integrationId: integrationId.trim(),
+      registeredResolvers: listRegisteredResolvers(),
+      hint: "Drop a resolver file in lib/adapters/integrations/resolvers/ that calls registerSourceResolver({ integrationId }) and re-run the test."
+    });
+  }
+
+  const adapterConfig = readAdapterConfig();
+
+  // Resolve the live bridge connection for this integration so the resolver
+  // receives the full connection object (connectionId, authPath, metadata).
+  let connection = null;
+  try {
+    const integrations = await listGovernedWorkspaceIntegrations();
+    connection = integrations.find(
+      (i) => i.provider === integrationId.trim() || i.id === integrationId.trim()
+    ) || null;
+  } catch {
+    // Non-fatal — resolver falls back to env-only auth
+  }
+
+  let records;
+  try {
+    records = await resolver.fetchRecords(adapterConfig, connection, binding || {});
+  } catch (err) {
+    return NextResponse.json({
+      ok: false,
+      reason: "fetch-error",
+      integrationId: integrationId.trim(),
+      error: err?.message || "resolver.fetchRecords threw an error"
+    });
+  }
+
+  if (!Array.isArray(records)) {
+    return NextResponse.json({
+      ok: false,
+      reason: "bad-resolver-response",
+      integrationId: integrationId.trim(),
+      error: "resolver.fetchRecords must return an array"
+    });
+  }
+
+  const columns = inferColumns(records);
+  const preview = records.slice(0, PREVIEW_ROW_LIMIT);
+
+  return NextResponse.json({
+    ok: true,
+    integrationId: integrationId.trim(),
+    recordCount: records.length,
+    columns,
+    preview,
+    entityTypes: resolver.entityTypes || []
+  });
+}
+
+export { POST };