@diagc/core 0.1.0 → 0.2.1

package/dist/validate.js

@@ -1,7 +1,9 @@
 import { BUILTIN_NOTATIONS, EDGE_LABEL_SIDES, FONT_SCALES, LEGEND_POSITIONS, LEGEND_SECTIONS, RELATION_LINES, RELATION_MARKERS, RELATION_SHAPES, RESERVED_NODE_ID, SIDES, STRIDE, TEXT_ALIGNS, THREAT_SEVERITIES, THREAT_STATUSES, } from './types.js';
 import { childrenOf } from './children.js';
+import { isIsoDate } from './dates.js';
 import { FB_CATEGORY_TYPE, FB_CAUSE_TYPE, FB_EFFECT_TYPE, FISHBONE_NOTATION, fishboneParents, fishboneTree, isFishboneNode } from './fishbone.js';
 import { GIT_NOTATION, GIT_STAGE_TYPE, gitGraph, isGitKind, stageCommit } from './git.js';
+import { PLAN_NOTATION, atOf, dayOf, isPlanEvent, isPlanRole, isPlanZone, planGraph, spanOf } from './plan.js';
 import { SECOND_ORDER_NOTATION, SO_DECISION_TYPE, consequenceOrders, isSecondOrderNode } from './second-order.js';
 import { TM_BOUNDARY_TYPE, TM_FLOW_KIND, TM_NOTATION } from './threat-model.js';
 export class DiagramValidationError extends Error {
@@ -336,6 +338,53 @@ function validateThreats(ctx) {
     for (const r of m.relations)
         check(r.id, r.threats);
 }
+/** `comments` (nodes and relations) and `links` (nodes) are generic fields:
+ * checked for shape wherever they appear, the element as `ref` — the same
+ * contract as validateThreats, for the same reason (the bubble reads them
+ * unguarded). */
+function validateComments(ctx) {
+    const { issues, m } = ctx;
+    const comments = (ref, list) => {
+        if (list === undefined)
+            return;
+        if (!Array.isArray(list) || list.some((c) => c === null || typeof c !== 'object')) {
+            report(issues, 'invalid-comments', `'comments' on '${ref}' must be a list of comments`, ref);
+            return;
+        }
+        const seen = new Set();
+        for (const c of list) {
+            const id = c.id;
+            if (typeof id !== 'string' || id === '')
+                report(issues, 'comment-id', `A comment on '${ref}' has no id`, ref);
+            else if (seen.has(id))
+                report(issues, 'comment-id', `Comment id '${id}' repeats on '${ref}'`, ref);
+            else
+                seen.add(id);
+            if (typeof c.text !== 'string' || c.text === '')
+                report(issues, 'comment-text', `Comment '${String(id)}' on '${ref}' has no text`, ref);
+            if (c.at !== undefined && !isIsoDate(c.at))
+                report(issues, 'comment-at', `Comment '${String(id)}' on '${ref}': 'at' must be a YYYY-MM-DD date`, ref);
+        }
+    };
+    const links = (ref, list) => {
+        if (list === undefined)
+            return;
+        if (!Array.isArray(list) || list.some((l) => l === null || typeof l !== 'object')) {
+            report(issues, 'invalid-links', `'links' on '${ref}' must be a list of { label, url }`, ref);
+            return;
+        }
+        for (const l of list) {
+            if (typeof l.label !== 'string' || l.label === '' || typeof l.url !== 'string' || l.url === '')
+                report(issues, 'invalid-links', `A link on '${ref}' needs a non-empty label and url`, ref);
+        }
+    };
+    for (const n of m.nodes) {
+        comments(n.id, n.comments);
+        links(n.id, n.links);
+    }
+    for (const r of m.relations)
+        comments(r.id, r.comments);
+}
 /** Containment cycles are checked per plane — an edge pair spanning two planes
  * is legal. Emits one `containment-cycle` issue per offending plane. */
 function validateCycles(ctx) {
@@ -628,6 +677,76 @@ function validateThreatModel(ctx) {
             report(issues, 'tm-flow-boundary', `Data flow '${r.id}' touches the trust boundary '${end}'; flows connect elements, a boundary only surrounds them`, r.id);
     }
 }
+/**
+ * Plan conventions. Dates are checked wherever they are (a plan-zone on any
+ * notation is still a zone, like a threat on any element); nesting is checked
+ * against the plan plane's containment when a plane declares the notation,
+ * else the default plane's. Only `plan-role-target` is notation-gated, the
+ * same plane pick as validateThreatModel — outside a plan, `owns` is just a
+ * relation kind somebody chose.
+ */
+function validatePlan(ctx) {
+    const { issues, m } = ctx;
+    const dateOr = (n, key) => {
+        const raw = n.metadata?.[key];
+        if (raw === undefined) {
+            report(issues, 'plan-missing', `'${n.id}' (${n.type}) has no '${key}' date`, n.id);
+            return undefined;
+        }
+        if (!isIsoDate(raw)) {
+            report(issues, 'plan-date', `'${n.id}': '${key}' must be a real YYYY-MM-DD date, got ${JSON.stringify(raw)}`, n.id);
+            return undefined;
+        }
+        return dayOf(raw);
+    };
+    for (const n of m.nodes) {
+        if (isPlanZone(n)) {
+            const start = dateOr(n, 'start');
+            const end = dateOr(n, 'end');
+            if (start !== undefined && end !== undefined && end < start) {
+                report(issues, 'plan-span', `'${n.id}': end ${String(n.metadata?.end)} is before start ${String(n.metadata?.start)}`, n.id);
+            }
+        }
+        else if (isPlanEvent(n)) {
+            dateOr(n, 'at');
+        }
+    }
+    const plane = ctx.planes.find((p) => (p.notation ?? m.notation) === PLAN_NOTATION);
+    const byId = new Map(m.nodes.map((n) => [n.id, n]));
+    // `planGraph` is a full `buildHierarchy`, and this function runs on EVERY
+    // model — validateGit and validateFishbone return before their derivations,
+    // but this one cannot, because dates are checked whatever the notation. So
+    // the graph is paid for only where there is something to nest; the date loop
+    // above and the role-target loop below never touch it.
+    if (m.nodes.some((n) => isPlanZone(n) || isPlanEvent(n))) {
+        const g = planGraph(m, plane?.id);
+        for (const [child, parentId] of g.parent) {
+            const outer = spanOf(byId.get(parentId));
+            const node = byId.get(child);
+            if (outer === undefined)
+                continue;
+            const inner = spanOf(node) ?? (atOf(node) !== undefined ? { start: atOf(node), end: atOf(node) } : undefined);
+            if (inner === undefined)
+                continue;
+            if (inner.start < outer.start || inner.end > outer.end) {
+                report(issues, 'plan-nested', `'${child}' lies outside its zone '${parentId}' (${String(byId.get(parentId).metadata?.start)} … ${String(byId.get(parentId).metadata?.end)})`, child);
+            }
+        }
+    }
+    const modelLevel = plane === undefined && ctx.planes.length === 0 && m.notation === PLAN_NOTATION;
+    if (plane === undefined && !modelLevel)
+        return;
+    for (const r of m.relations) {
+        if (!isPlanRole(r.kind))
+            continue;
+        if (!ctx.nodeIds.has(r.from) || !ctx.nodeIds.has(r.to))
+            continue; // dangling ends are validateRelations' finding
+        const target = byId.get(r.to);
+        if (target !== undefined && !isPlanZone(target)) {
+            report(issues, 'plan-role-target', `Relation '${r.id}' (${r.kind}) must point at a plan-zone; '${r.to}' is ${target.type ?? 'untyped'}`, r.id);
+        }
+    }
+}
 export function validate(m) {
     const ctx = {
         issues: [],
@@ -649,12 +768,14 @@ export function validate(m) {
     validateContainment(ctx);
     validateRelations(ctx);
     validateThreats(ctx);
+    validateComments(ctx);
     validateCycles(ctx);
     validateGit(ctx);
     validateActivity(ctx);
     validateSecondOrder(ctx);
     validateFishbone(ctx);
     validateThreatModel(ctx);
+    validatePlan(ctx);
     return ctx.issues;
 }
 function findContainmentCycle(edges) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@diagc/core",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "Diagram model, validator, and builder DSL for diagc — no React, no filesystem.",
   "license": "AGPL-3.0-only",
   "author": "Bogdan Frankovskyi",