@growthub/cli 0.9.12 → 0.9.14

package/assets/worker-kits/growthub-custom-workspace-starter-v1/apps/workspace/lib/workspace-config.js

@@ -155,6 +155,265 @@ async function writeWorkspaceConfig(patch) {
   return next;
 }
 
+function normalizeWorkspaceIdentityPatch(patch) {
+  if (!patch || typeof patch !== "object" || Array.isArray(patch)) {
+    const error = new Error("settings patch must be a plain object");
+    error.code = "INVALID_WORKSPACE_SETTINGS_PATCH";
+    throw error;
+  }
+
+  const allowed = new Set(["name", "branding"]);
+  const unknown = Object.keys(patch).filter((key) => !allowed.has(key));
+  if (unknown.length) {
+    const error = new Error("settings patch contains unknown fields");
+    error.code = "INVALID_WORKSPACE_SETTINGS_PATCH";
+    error.details = unknown;
+    throw error;
+  }
+
+  const normalized = {};
+  if (Object.prototype.hasOwnProperty.call(patch, "name")) {
+    if (typeof patch.name !== "string") {
+      const error = new Error("name must be a string");
+      error.code = "INVALID_WORKSPACE_SETTINGS_PATCH";
+      throw error;
+    }
+    normalized.name = patch.name.trim() || "Growthub Workspace";
+  }
+
+  if (Object.prototype.hasOwnProperty.call(patch, "branding")) {
+    if (!patch.branding || typeof patch.branding !== "object" || Array.isArray(patch.branding)) {
+      const error = new Error("branding must be a plain object");
+      error.code = "INVALID_WORKSPACE_SETTINGS_PATCH";
+      throw error;
+    }
+    const brandingAllowed = new Set(["name", "logoUrl", "accent"]);
+    const brandingUnknown = Object.keys(patch.branding).filter((key) => !brandingAllowed.has(key));
+    if (brandingUnknown.length) {
+      const error = new Error("branding patch contains unknown fields");
+      error.code = "INVALID_WORKSPACE_SETTINGS_PATCH";
+      error.details = brandingUnknown.map((key) => `branding.${key}`);
+      throw error;
+    }
+    normalized.branding = {};
+    for (const key of brandingAllowed) {
+      if (Object.prototype.hasOwnProperty.call(patch.branding, key)) {
+        if (typeof patch.branding[key] !== "string") {
+          const error = new Error(`branding.${key} must be a string`);
+          error.code = "INVALID_WORKSPACE_SETTINGS_PATCH";
+          throw error;
+        }
+        normalized.branding[key] = patch.branding[key].trim();
+      }
+    }
+  }
+
+  return normalized;
+}
+
+async function writeWorkspaceIdentitySettings(patch) {
+  const persistence = describePersistenceMode();
+  const adapter = readAdapterConfig();
+  if (persistence.mode !== PERSISTENCE_ADAPTERS.FILESYSTEM || !persistence.canSave) {
+    const error = new Error(persistence.reason);
+    error.code = "WORKSPACE_PERSISTENCE_READ_ONLY";
+    error.adapter = adapter.integrationAdapter;
+    error.guidance = persistence.guidance || READ_ONLY_GUIDANCE;
+    throw error;
+  }
+
+  const normalized = normalizeWorkspaceIdentityPatch(patch);
+  const current = await readWorkspaceConfig();
+  const next = { ...current };
+  if (normalized.name !== undefined) {
+    next.name = normalized.name;
+  }
+  if (normalized.branding) {
+    next.branding = {
+      ...(current.branding && typeof current.branding === "object" && !Array.isArray(current.branding)
+        ? current.branding
+        : {}),
+      ...normalized.branding
+    };
+    if (!next.branding.name) {
+      next.branding.name = next.name || "Growthub Workspace";
+    }
+  }
+
+  validateWorkspaceConfig({
+    dashboards: next.dashboards,
+    widgetTypes: next.widgetTypes,
+    canvas: next.canvas,
+    dataModel: next.dataModel
+  });
+
+  const configPath = resolveWorkspaceConfigPath();
+  const expectedDir = path.resolve(/*turbopackIgnore: true*/ process.cwd());
+  if (path.dirname(configPath) !== expectedDir) {
+    const error = new Error(`refused to write outside workspace cwd: ${configPath}`);
+    error.code = "WORKSPACE_PERSISTENCE_PATH_REFUSED";
+    throw error;
+  }
+  await fs.writeFile(configPath, `${JSON.stringify(next, null, 2)}\n`, "utf8");
+  return next;
+}
+
+function normalizeApiWebhookRefs(refs) {
+  if (!Array.isArray(refs)) {
+    const error = new Error("refs must be an array");
+    error.code = "INVALID_WORKSPACE_SETTINGS_PATCH";
+    throw error;
+  }
+  return refs
+    .map((item, index) => {
+      if (!item || typeof item !== "object" || Array.isArray(item)) {
+        const error = new Error("each ref must be a plain object");
+        error.code = "INVALID_WORKSPACE_SETTINGS_PATCH";
+        throw error;
+      }
+      const allowed = new Set(["id", "label", "kind", "endpointRef", "status", "hasSecret", "url"]);
+      const unknown = Object.keys(item).filter((key) => !allowed.has(key));
+      if (unknown.length) {
+        const error = new Error("ref contains unknown fields");
+        error.code = "INVALID_WORKSPACE_SETTINGS_PATCH";
+        error.details = unknown;
+        throw error;
+      }
+      const kind = item.kind === "webhook" ? "webhook" : "api";
+      const label = typeof item.label === "string" ? item.label.trim() : "";
+      const endpointRef = typeof item.endpointRef === "string" ? item.endpointRef.trim() : "";
+      const url = typeof item.url === "string" ? item.url.trim() : "";
+      if (!label && !endpointRef && !url && item.hasSecret !== true) return null;
+      return {
+        id: typeof item.id === "string" && item.id.trim() ? item.id.trim() : `custom-${kind}-${index + 1}`,
+        label: label || endpointRef,
+        kind,
+        sourceType: "custom-api-webhooks",
+        endpointRef,
+        url,
+        status: typeof item.status === "string" && item.status.trim() ? item.status.trim() : "configured",
+        hasSecret: item.hasSecret === true
+      };
+    })
+    .filter(Boolean);
+}
+
+async function writeWorkspaceApiWebhookSettings(patch) {
+  const persistence = describePersistenceMode();
+  const adapter = readAdapterConfig();
+  if (persistence.mode !== PERSISTENCE_ADAPTERS.FILESYSTEM || !persistence.canSave) {
+    const error = new Error(persistence.reason);
+    error.code = "WORKSPACE_PERSISTENCE_READ_ONLY";
+    error.adapter = adapter.integrationAdapter;
+    error.guidance = persistence.guidance || READ_ONLY_GUIDANCE;
+    throw error;
+  }
+
+  const refs = normalizeApiWebhookRefs(patch?.refs);
+  const current = await readWorkspaceConfig();
+  const existing = Array.isArray(current.integrations) ? current.integrations : [];
+  const next = {
+    ...current,
+    integrations: [
+      ...existing.filter((item) => item?.sourceType !== "custom-api-webhooks"),
+      ...refs
+    ]
+  };
+
+  validateWorkspaceConfig({
+    dashboards: next.dashboards,
+    widgetTypes: next.widgetTypes,
+    canvas: next.canvas,
+    dataModel: next.dataModel
+  });
+
+  const configPath = resolveWorkspaceConfigPath();
+  const expectedDir = path.resolve(/*turbopackIgnore: true*/ process.cwd());
+  if (path.dirname(configPath) !== expectedDir) {
+    const error = new Error(`refused to write outside workspace cwd: ${configPath}`);
+    error.code = "WORKSPACE_PERSISTENCE_PATH_REFUSED";
+    throw error;
+  }
+  await fs.writeFile(configPath, `${JSON.stringify(next, null, 2)}\n`, "utf8");
+  return next.integrations.filter((item) => item?.sourceType === "custom-api-webhooks");
+}
+
+/**
+ * Source Records persistence — sidecar store for live-backed dataModel objects.
+ *
+ * Records are written by POST /api/workspace/refresh-sources when a resolver
+ * fetches live data for a source with `binding.sourceStorage: "workspace-source-records"`.
+ *
+ * Persistence is keyed by `sourceId` and stored in a JSON sidecar file
+ * (`growthub.source-records.json`) beside `growthub.config.json`. The same
+ * filesystem / read-only / database mode rules apply: in read-only mode writes
+ * are rejected gracefully so the refresh button surface is disabled.
+ *
+ * Shape: { [sourceId]: { records: Record[], integrationId: string, fetchedAt: string } }
+ */
+
+const SOURCE_RECORDS_FILENAME = "growthub.source-records.json";
+
+function resolveSourceRecordsPath() {
+  return path.resolve(/*turbopackIgnore: true*/ process.cwd(), SOURCE_RECORDS_FILENAME);
+}
+
+async function readWorkspaceSourceRecords(sourceId) {
+  const recordsPath = resolveSourceRecordsPath();
+  try {
+    const raw = await fs.readFile(recordsPath, "utf8");
+    const all = JSON.parse(raw);
+    if (sourceId) {
+      return all[sourceId] || null;
+    }
+    return all;
+  } catch {
+    return sourceId ? null : {};
+  }
+}
+
+async function writeWorkspaceSourceRecords(sourceId, records, metadata = {}) {
+  const persistence = describePersistenceMode();
+  if (persistence.mode !== PERSISTENCE_ADAPTERS.FILESYSTEM || !persistence.canSave) {
+    const error = new Error(persistence.reason);
+    error.code = "WORKSPACE_PERSISTENCE_READ_ONLY";
+    error.guidance = persistence.guidance || READ_ONLY_GUIDANCE;
+    throw error;
+  }
+  if (typeof sourceId !== "string" || !sourceId.trim()) {
+    const error = new Error("sourceId must be a non-empty string");
+    error.code = "INVALID_SOURCE_RECORDS_WRITE";
+    throw error;
+  }
+  if (!Array.isArray(records)) {
+    const error = new Error("records must be an array");
+    error.code = "INVALID_SOURCE_RECORDS_WRITE";
+    throw error;
+  }
+  const recordsPath = resolveSourceRecordsPath();
+  const expectedDir = path.resolve(/*turbopackIgnore: true*/ process.cwd());
+  if (path.dirname(recordsPath) !== expectedDir) {
+    const error = new Error(`refused to write outside workspace cwd: ${recordsPath}`);
+    error.code = "WORKSPACE_PERSISTENCE_PATH_REFUSED";
+    throw error;
+  }
+  let all = {};
+  try {
+    const raw = await fs.readFile(recordsPath, "utf8");
+    all = JSON.parse(raw);
+  } catch {
+    all = {};
+  }
+  all[sourceId.trim()] = {
+    records,
+    integrationId: metadata.integrationId || null,
+    fetchedAt: metadata.fetchedAt || new Date().toISOString(),
+    recordCount: records.length
+  };
+  await fs.writeFile(recordsPath, `${JSON.stringify(all, null, 2)}\n`, "utf8");
+  return all[sourceId.trim()];
+}
+
 export {
   GRID_COLUMNS,
   GRID_ROWS,
@@ -163,7 +422,11 @@ export {
   READ_ONLY_GUIDANCE,
   describePersistenceMode,
   readWorkspaceConfig,
+  readWorkspaceSourceRecords,
   resolveWorkspaceConfigPath,
   validateWorkspaceConfig,
-  writeWorkspaceConfig
+  writeWorkspaceConfig,
+  writeWorkspaceApiWebhookSettings,
+  writeWorkspaceIdentitySettings,
+  writeWorkspaceSourceRecords
 };

package/assets/worker-kits/growthub-custom-workspace-starter-v1/apps/workspace/lib/workspace-data-model.js

@@ -171,9 +171,12 @@ function deriveManualObjectTable(object) {
     id: `manual-object:${object.id || source}`,
     label: object.label || object.name || source,
     source,
+    objectType: object.objectType || "custom",
+    icon: object.icon || null,
     columns,
     rows,
     binding: object.binding || { mode: "manual", source: "Data Model" },
+    relations: Array.isArray(object.relations) ? object.relations : [],
     mutable: true,
     storage: "manual-object",
     objectId: object.id,
@@ -313,6 +316,105 @@ function uniqueObjectId(workspaceConfig, name) {
   return `${base}-${index}`;
 }
 
+/**
+ * Top-level object type presets.
+ * Each entry defines: label, icon (Lucide name), description, default columns, and
+ * any built-in relations.  These are the five first-class types the UI offers when
+ * a user clicks "New object" — they act like schema templates, not hard constraints.
+ *
+ * Relation shape:
+ *   {
+ *     id:              string,   // stable slug within this object
+ *     name:            string,   // display label
+ *     field:           string,   // FK column on THIS object
+ *     targetObjectType:string,   // objectType of the referenced object
+ *     type:            "belongs-to" | "has-many",
+ *     description:     string
+ *   }
+ */
+const OBJECT_TYPE_PRESETS = {
+  "data-source": {
+    label: "Data Source",
+    icon: "Globe",
+    description: "Custom API, webhook, or external feed. References an API Registry record while credentials stay in workspace settings.",
+    columns: ["Name", "registryId", "endpoint", "authRef", "baseUrl", "status", "lastTested", "lastResponse"],
+    relations: [
+      {
+        id: "resolver-binding",
+        name: "Resolver",
+        field: "registryId",
+        targetObjectType: "api-registry",
+        type: "belongs-to",
+        description: "The API Registry entry whose fetchRecords function resolves this source. Set registryId to match the resolver integrationId."
+      }
+    ]
+  },
+  "api-registry": {
+    label: "API Registry",
+    icon: "Code2",
+    description: "HTTP API records with endpoint config, auth references, connection status, and stored test output.",
+    columns: ["integrationId", "authRef", "baseUrl", "endpoint", "method", "status", "lastTested", "lastResponse", "entityTypes", "description"],
+    relations: []
+  },
+  "people": {
+    label: "People",
+    icon: "Users",
+    description: "Contacts, leads, or team members with standard CRM fields.",
+    columns: ["Name", "Email", "Phone", "Company", "Status", "Role"],
+    relations: []
+  },
+  "tasks": {
+    label: "Tasks",
+    icon: "CheckSquare",
+    description: "Action items, to-dos, or work items.",
+    columns: ["Name", "Status", "DueDate", "Assignee", "Priority"],
+    relations: []
+  },
+  "custom": {
+    label: "Custom",
+    icon: "Plus",
+    description: "Start with a blank table — define your own fields and records.",
+    columns: ["Name"],
+    relations: []
+  }
+};
+
+/**
+ * Create a typed business object from a preset template.
+ * Accepts objectType (one of the OBJECT_TYPE_PRESETS keys) and an optional icon override.
+ * The object is stored in dataModel.objects[] alongside manual objects.
+ */
+function createTypedBusinessObject(workspaceConfig, { name, objectType = "custom", icon } = {}) {
+  const label = String(name || "").trim();
+  if (!label) return workspaceConfig;
+  const preset = OBJECT_TYPE_PRESETS[objectType] || OBJECT_TYPE_PRESETS.custom;
+  const columns = [...preset.columns];
+  const dataModel =
+    workspaceConfig.dataModel && typeof workspaceConfig.dataModel === "object" && !Array.isArray(workspaceConfig.dataModel)
+      ? workspaceConfig.dataModel
+      : {};
+  const id = uniqueObjectId(workspaceConfig, label);
+  const object = {
+    id,
+    label,
+    source: label,
+    objectType,
+    icon: icon || preset.icon,
+    columns,
+    rows: [],
+    binding: { mode: "manual", source: "Data Model" },
+    relations: preset.relations ? preset.relations.map((r) => ({ ...r })) : [],
+    fieldSettings: { hidden: [], order: columns }
+  };
+  return {
+    ...workspaceConfig,
+    dataModel: {
+      ...dataModel,
+      objects: [...normalizeManualObjects(workspaceConfig), object]
+    }
+  };
+}
+
 function createManualBusinessObject(workspaceConfig, { name, fields } = {}) {
   const label = String(name || "").trim();
   const columns = Array.from(new Set((Array.isArray(fields) ? fields : String(fields || "").split(","))
@@ -417,10 +519,12 @@ function describeBindingMode(binding) {
 }
 
 export {
+  OBJECT_TYPE_PRESETS,
   addTableField,
   addTableRow,
   appendRowsToTable,
   createManualBusinessObject,
+  createTypedBusinessObject,
   deleteTableRow,
   describeBindingLane,
   describeBindingMode,

package/assets/worker-kits/growthub-custom-workspace-starter-v1/apps/workspace/lib/workspace-schema.js

@@ -152,7 +152,9 @@ const WIDGET_SCHEMA_CONTRACTS = {
     lane: "string optional (when mode === 'integration')",
     entityId: "string optional — stable source object ID (never a token or credential)",
     entityType: "string optional — adapter-provided object type",
-    entityLabel: "string optional — display-only resolved label, not authoritative"
+    entityLabel: "string optional — display-only resolved label, not authoritative",
+    sourceStorage: "'workspace-source-records' optional — marks this binding as live-backed; records are written by POST /api/workspace/refresh-sources and keyed by dataModel.objects[].sourceId",
+    sourceId: "string optional — stable key in growthub.source-records.json; required when sourceStorage === 'workspace-source-records'"
   },
   NormalizedIntegrationEntity: {
     id: "non-empty string — stable source object ID",
@@ -200,19 +202,19 @@ const SAMPLE_DATA_BINDINGS = {
 function defaultConfigFor(kind) {
   switch (kind) {
     case "chart":
-      return { values: [58, 36, 72, 48, 64], binding: SAMPLE_DATA_BINDINGS.reportingJson };
+      return { values: [], binding: { mode: "manual", source: "", rows: [] } };
     case "view":
       return {
         source: "",
         layout: "Table",
         columns: [],
         rows: [],
-        binding: { mode: "manual", source: "Static rows", rows: [] }
+        binding: { mode: "manual", source: "", rows: [] }
       };
     case "iframe":
       return { url: "" };
     case "rich-text":
-      return { text: "", binding: { mode: "manual", source: "Manual text", rows: [] } };
+      return { text: "", binding: { mode: "manual", source: "", rows: [] } };
     default:
       return {};
   }
@@ -396,8 +398,11 @@ function validateStaticDataBinding(binding, path, errors) {
     if (typeof binding.integrationId !== "string" || !binding.integrationId.trim()) {
       errors.push(`${path}.integrationId is required when mode is integration`);
     }
-    if (typeof binding.lane !== "string" || !binding.lane.trim()) {
-      errors.push(`${path}.lane is required when mode is integration`);
+    // lane is not required when sourceStorage delegates routing to a registry resolver
+    if (binding.sourceStorage !== "workspace-source-records") {
+      if (typeof binding.lane !== "string" || !binding.lane.trim()) {
+        errors.push(`${path}.lane is required when mode is integration`);
+      }
     }
   }
   if (binding.source !== undefined && typeof binding.source !== "string") {
@@ -439,6 +444,14 @@ function validateStaticDataBinding(binding, path, errors) {
   if (binding.entityLabel !== undefined && typeof binding.entityLabel !== "string") {
     errors.push(`${path}.entityLabel must be a string`);
   }
+  if (binding.sourceStorage !== undefined) {
+    if (binding.sourceStorage !== "workspace-source-records") {
+      errors.push(`${path}.sourceStorage must be "workspace-source-records" when present`);
+    }
+  }
+  if (binding.sourceId !== undefined && typeof binding.sourceId !== "string") {
+    errors.push(`${path}.sourceId must be a string`);
+  }
 }
 
 function validateFieldSettings(fieldSettings, path, errors) {
@@ -805,6 +818,7 @@ function validateDataModelConfig(dataModel, errors) {
     }
     if (typeof object.label !== "string" || !object.label.trim()) errors.push(`${prefix}.label must be a non-empty string`);
     if (object.source !== undefined && typeof object.source !== "string") errors.push(`${prefix}.source must be a string`);
+    if (object.sourceId !== undefined && typeof object.sourceId !== "string") errors.push(`${prefix}.sourceId must be a string`);
     validateStringArray(object.columns, `${prefix}.columns`, errors);
     if (!Array.isArray(object.rows)) {
       errors.push(`${prefix}.rows must be an array`);
@@ -814,6 +828,9 @@ function validateDataModelConfig(dataModel, errors) {
       });
     }
     validateStaticDataBinding(object.binding, `${prefix}.binding`, errors);
+    if (object.binding?.sourceStorage === "workspace-source-records" && typeof object.sourceId !== "string") {
+      errors.push(`${prefix}.sourceId is required when binding.sourceStorage is "workspace-source-records"`);
+    }
     validateFieldSettings(object.fieldSettings, `${prefix}.fieldSettings`, errors);
   });
 }

package/assets/worker-kits/growthub-custom-workspace-starter-v1/apps/workspace/package.json

@@ -10,6 +10,7 @@
     "lint": "next lint"
   },
   "dependencies": {
+    "@tanstack/react-table": "^8.21.3",
     "lucide-react": "^0.468.0",
     "next": "16.2.4",
     "react": "19.2.4",

package/assets/worker-kits/growthub-custom-workspace-starter-v1/kit.json

@@ -76,6 +76,10 @@
     "apps/workspace/app/workspace-builder.jsx",
     "apps/workspace/app/settings/integrations/page.jsx",
     "apps/workspace/app/api/workspace/route.js",
+    "apps/workspace/app/api/workspace/refresh-sources/route.js",
+    "apps/workspace/app/api/workspace/test-source/route.js",
+    "apps/workspace/app/api/workspace/register-resolver/route.js",
+    "apps/workspace/app/api/workspace/resolvers/route.js",
     "apps/workspace/app/api/settings/integrations/route.js",
     "apps/workspace/lib/workspace-schema.js",
     "apps/workspace/lib/workspace-config.js",
@@ -85,6 +89,9 @@
     "apps/workspace/lib/adapters/auth/index.js",
     "apps/workspace/lib/adapters/integrations/index.js",
     "apps/workspace/lib/adapters/integrations/growthub-connection-normalizer.js",
+    "apps/workspace/lib/adapters/integrations/source-resolver-registry.js",
+    "apps/workspace/lib/adapters/integrations/resolver-loader.js",
+    "apps/workspace/lib/adapters/integrations/resolvers/README.md",
     "apps/workspace/lib/adapters/payments/index.js",
     "apps/workspace/lib/adapters/persistence/index.js",
     "apps/workspace/lib/adapters/persistence/postgres.js",