@synap-core/workspace-templates 0.9.1 → 0.9.3

package/src/validate.ts

@@ -14,8 +14,8 @@
  *   • `scripts/check-converters.mjs` — injects the real converters, exits non-zero.
  *   • CP / pod / CLI (from dist) — import `validateTemplate` + `SYSTEM_PROFILES`.
  *
- * ZERO RUNTIME IMPORTS BY DESIGN. `build.mjs` loads this file directly under
- * Node's type-stripping BEFORE `tsup` builds `dist/`. A static
+ * NO RUNTIME IMPORT THAT FAILS AT STRIP-TIME. `build.mjs` loads this file
+ * directly under Node's type-stripping BEFORE `tsup` builds `dist/`. A static
  * `import { toWorkspaceDefinition } from "./define.js"` would fail to resolve at
  * that moment (define → templates.js does not exist pre-build, and Node's
  * type-stripper does not remap a `.js` specifier to its `.ts` source). So the
@@ -23,6 +23,14 @@
  * YAML/bento rules run everywhere; the converter-parity rules run wherever the
  * caller can supply the compiled converters (check-converters.mjs, from dist).
  * `import type` lines are fully erased by the type-stripper, so they are safe.
+ *
+ * THE ONE RUNTIME IMPORT: `./validate-flow.ts` (the pure automation-flow
+ * validator). It is imported with the `.ts` extension SPECIFICALLY so it resolves
+ * under Node's type-stripper at build.mjs time (a `.js` specifier would NOT — see
+ * above), and it has NO generated dependency (unlike `./define.js` → templates)
+ * so it is always present. It is DB-free (only `import type` internally), so it
+ * needs no injection: the flow-node contract check runs for every caller
+ * (build / check-converters / CLI / CP) automatically.
  */
 
 import type {
@@ -31,6 +39,9 @@ import type {
   TemplateProfile,
 } from "./types.js";
 
+// eslint-disable-next-line import/extensions -- .ts extension is intentional; see header.
+import { validateFlowDefinition } from "./validate-flow.ts";
+
 // ── Result shape ─────────────────────────────────────────────────────────────
 
 export interface ValidationError {
@@ -271,12 +282,86 @@ export function validateTemplate(
   else {
     for (const f of REQUIRED_WORKSPACE_FIELDS) {
       if (!tpl.workspace[f])
-        add("workspace-field-required", `workspace.${f}`, `workspace.${f} is required`);
+        add(
+          "workspace-field-required", `workspace.${f}`, `workspace.${f} is required`
+        );
     }
   }
   if (!tpl.profiles || tpl.profiles.length === 0) {
     add("profiles-required", "profiles", "At least one profile is required");
   }
+  if (
+    tpl.app &&
+    tpl.layout &&
+    Object.prototype.hasOwnProperty.call(tpl.layout, "primarySurface")
+  ) {
+    add(
+      "primary-surface-authoring-conflict",
+      "layout.primarySurface",
+      "Declare either top-level app or layout.primarySurface, not both"
+    );
+  }
+  if (tpl.app?.kind === "native" && !tpl.app.appId) {
+    add(
+      "app-native-id-required",
+      "app.appId",
+      "A native workspace app requires appId"
+    );
+  }
+  if (tpl.app?.kind === "url" && (!tpl.app.appId || !tpl.app.url)) {
+    add(
+      "app-url-identity-required",
+      "app",
+      "A hosted workspace app requires both appId and url"
+    );
+  }
+  if (tpl.app?.kind === "stored" && !tpl.app.cellKey) {
+    add(
+      "app-cell-key-required",
+      "app.cellKey",
+      "A stored workspace app requires cellKey"
+    );
+  }
+  const authoredPrimary = tpl.layout?.primarySurface;
+  if (authoredPrimary?.kind === "view" && !("viewId" in authoredPrimary)) {
+    const viewName = authoredPrimary.viewName;
+    const viewSlug = authoredPrimary.viewSlug;
+    if (!viewName && !viewSlug) {
+      add(
+        "primary-view-reference-required",
+        "layout.primarySurface",
+        "A view primary surface requires viewName or viewSlug"
+      );
+    } else {
+      const declaredViews = [
+        ...(tpl.views ?? []).map((view) => ({
+          name: view.name,
+          slug: view.slug,
+        })),
+        ...(tpl.bento?.viewName
+          ? [{ name: tpl.bento.viewName, slug: undefined }]
+          : []),
+      ];
+      const matches = declaredViews.filter(
+        (view) =>
+          (!viewName || view.name === viewName) &&
+          (!viewSlug || view.slug === viewSlug)
+      );
+      if (matches.length === 0) {
+        add(
+          "primary-view-reference-unknown",
+          "layout.primarySurface",
+          `Primary surface references an unknown view (${viewName ?? viewSlug})`
+        );
+      } else if (matches.length > 1) {
+        add(
+          "primary-view-reference-ambiguous",
+          "layout.primarySurface",
+          `Primary surface view reference matches ${matches.length} authored views; add a unique viewSlug`
+        );
+      }
+    }
+  }
 
   // ── Referential integrity: build the known-profile predicate ──────────────
   const baseProfileSlugs = collectBaseProfileSlugs(tpl, resolveDepFrom(opts));
@@ -371,11 +456,37 @@ export function validateTemplate(
   // SILENTLY at runtime.
   for (const a of tpl.automations || []) {
     const refs: Array<{ where: string; slug: string }> = [];
-    collectProfileSlugRefs(a.triggerConfig, `automation "${a.name}".triggerConfig`, refs);
+    collectProfileSlugRefs(
+      a.triggerConfig, `automation "${a.name}".triggerConfig`,
+      refs
+    );
     collectProfileSlugRefs(a.flow, `automation "${a.name}".flow`, refs);
     for (const r of refs)
       if (!known(r.slug))
-        add("automation-ref-unknown", r.where, `${r.where} references unknown profile "${r.slug}"`);
+        add(
+          "automation-ref-unknown", r.where, `${r.where} references unknown profile "${r.slug}"`
+        );
+
+    // Node-contract validation. Previously validate.ts checked automations for
+    // profileSlug refs ONLY, so a bogus node type / dangling edge / cycle / typo'd
+    // channelType / verb-less capability node passed the template gate green and
+    // then SILENTLY never fired at runtime (validateFlowDefinition only ran
+    // server-side at install). Run the SAME contract validator here, at author
+    // time. Catalog-existence checks are resolver-gated and skipped (no catalog at
+    // author time); the structural + per-node contract checks always run.
+    const flow = a.flow ?? (a as { flowDefinition?: unknown }).flowDefinition;
+    if (flow != null) {
+      const { errors: flowErrors
+  } = validateFlowDefinition(flow);
+  for (const fe of flowErrors) {
+        const loc = fe.nodeId
+          ? `automation "${a.name}".flow.node "${fe.nodeId}"`
+          : fe.edgeId
+            ? `automation "${a.name}".flow.edge "${fe.edgeId}"`
+            : `automation "${a.name}".flow`;
+        add(`automation-flow-${fe.code}`, loc, `${loc}: ${fe.message}`);
+      }
+    }
   }
   for (const pb of tpl.playbooks || []) {
     const ps = pb.subjectProfile?.profileSlug;
@@ -426,7 +537,9 @@ export function validateTemplate(
   // its base's workspace. The additive reconcile OVERWRITES workspace-level
   // settings, so an overlay MUST set workspace.subtype to its compose-base's slug
   // and MUST OMIT workspace.visibility — else it clobbers the base's identity.
-  const composeDeps = (tpl.dependencies || []).filter((d) => d.relation === "compose");
+  const composeDeps = (tpl.dependencies || []).filter(
+    (d) => d.relation === "compose"
+  );
   for (const dep of composeDeps) {
     if (tpl.workspace?.visibility !== undefined) {
       add(
@@ -448,7 +561,9 @@ export function validateTemplate(
   const blocks: TemplateBentoBlock[] = tpl.bento?.blocks ?? [];
   const authoredWidgets = blocks.filter((b) => b.kind === "widget");
   const authoredViews = blocks.filter((b) => b.kind === "view");
-  const unknownKind = blocks.filter((b) => b.kind !== "widget" && b.kind !== "view");
+  const unknownKind = blocks.filter(
+    (b) => b.kind !== "widget" && b.kind !== "view"
+  );
   if (unknownKind.length) {
     add(
       "bento-unknown-kind",
@@ -485,8 +600,14 @@ export function validateTemplate(
       const expectW = authoredWidgets.length - badWidgets.length;
       const expectV = authoredViews.length - badViews.length;
 
-      const doors: Array<[string, Array<{ widgetType?: unknown }>, Array<{ viewName?: unknown; kind?: unknown }>]> = [
-        ["tRPC createFromDefinition", definition.bentoLayout ?? [], definition.bentoViewBlocks ?? []],
+      const doors: Array<
+        [
+          string, Array<{ widgetType?: unknown }>, Array<{ viewName?: unknown; kind?: unknown }>,
+        ]
+      > = [
+        [
+          "tRPC createFromDefinition", definition.bentoLayout ?? [], definition.bentoViewBlocks ?? [],
+        ],
         ["CP packages/apply", pkg.bentoLayout ?? [], pkg.bentoViewBlocks ?? []],
       ];
       for (const [door, layout, viewBlocks] of doors) {
@@ -497,7 +618,9 @@ export function validateTemplate(
             `[${door}]: authored ${expectW} widget/${expectV} view → got ${layout.length} bentoLayout/${viewBlocks.length} bentoViewBlocks`
           );
         }
-        const layoutBad = layout.filter((b) => typeof b.widgetType !== "string");
+        const layoutBad = layout.filter(
+          (b) => typeof b.widgetType !== "string"
+        );
         const viewsBad = viewBlocks.filter(
           (b) => typeof b.viewName !== "string" || b.kind !== "view"
         );