@sdd-method/author-cli 0.0.0-stage → 0.1.0

package/dist/lib/catalogue/builders/products.js

@@ -0,0 +1,162 @@
+/**
+ * Products discoverer — emits the SDD-as-Product row from the manifest.
+ *
+ * Per ADR 0134 + catalogue-metamodel.md: every SDD is one Product. The
+ * canonical builder emits ONE products.csv row per SDD — the SDD itself.
+ * Sibling SDDs (apps, integrations) get their own products.csv rows in
+ * their own builds; the aggregator merges by primary key.
+ *
+ * domain_id selection (per ADR 0136):
+ *   - For platform-profile SDDs: manifest.domainId when declared, else
+ *     a sensible default for platform-profile categories (where a real
+ *     `platform` domain exists locally).
+ *   - For application-product / integration-product / support-repo
+ *     SDDs: always empty. App and integration products do not have a
+ *     primary domain — they are federation nodes that consume
+ *     capabilities across multiple domains via product_capability. Any
+ *     domain_id declared in the manifest of a non-platform SDD is
+ *     typically the umbrella name (e.g. "applications", "integrations")
+ *     used as a structural-organisation convention; that umbrella is
+ *     not a domain row in any SDD's domains.csv (only platform-profile
+ *     SDDs emit domain rows post-v0.14.0), so propagating it would
+ *     produce a dangling FK reference.
+ *
+ *     When such a manifest declaration is present, we clear the field
+ *     and emit an "inferred" finding so the override is traceable.
+ */
+import { PACKAGING_DEFAULT } from "../manifest-loader.js";
+/**
+ * Default domain_id per category when the manifest doesn't declare one.
+ * Per ADR 0136 only platform-profile categories carry a default — app
+ * and integration products legitimately have an empty domain_id.
+ */
+const DEFAULT_DOMAIN_BY_CATEGORY = {
+    "platform-root": "platform",
+    "platform-subsystem": "platform",
+};
+export function buildProducts(inputs) {
+    const m = inputs.manifest;
+    const defaulted = DEFAULT_DOMAIN_BY_CATEGORY[m.category];
+    let domainId;
+    if (m.profile === "platform-profile") {
+        const usable = defaulted !== undefined && (inputs.knownDomainIds?.has(defaulted) ?? true) ? defaulted : undefined;
+        domainId = m.domainId ?? usable ?? "";
+        if (m.domainId === undefined && defaulted !== undefined && usable === undefined) {
+            inputs.findings.add("inferred", `products: domain_id left empty: the category=${m.category} default "${defaulted}" is not a domain of this SDD yet (manifest had no domain_id)`);
+        }
+        else if (m.domainId === undefined && defaulted !== undefined) {
+            inputs.findings.add("inferred", `products: domain_id="${defaulted}" inferred from category=${m.category} (manifest had no domain_id)`);
+        }
+    }
+    else {
+        // Per ADR 0136: app/integration/support products do not have a
+        // primary domain. Even if the manifest declares one (typically the
+        // umbrella name like "applications" or "integrations"), clear it
+        // here so the products.domain_id FK reference does not dangle
+        // against domains.csv (which only platform-profile SDDs populate
+        // post-v0.14.0). Emit a finding when the manifest declared a value
+        // so the override is traceable.
+        domainId = "";
+        if (m.domainId !== undefined && m.domainId.length > 0) {
+            inputs.findings.add("inferred", `products: domain_id cleared (manifest declared "${m.domainId}") for profile=${m.profile} per ADR 0136 — app/integration/support products do not have a primary domain`);
+        }
+    }
+    // Lifecycle (schema 2.22.0): owner-declared in the manifest, default
+    // "active". The companion fields are only meaningful when deprecated —
+    // per sdd-manifest-schema 1.1.0 they are "ignored otherwise", so a
+    // declared-but-inapplicable value is cleared with a convention finding
+    // rather than emitted.
+    const lifecycle = m.lifecycle ?? "active";
+    let deprecatedDate = "";
+    let successorSddId = "";
+    if (lifecycle === "deprecated") {
+        deprecatedDate = m.deprecatedDate ?? "";
+        successorSddId = m.successorSddId ?? "";
+    }
+    else {
+        for (const [field, value] of [
+            ["deprecated_date", m.deprecatedDate],
+            ["successor_sdd_id", m.successorSddId],
+        ]) {
+            if (value !== undefined) {
+                inputs.findings.add("convention", `products: ${field}="${value}" declared but lifecycle is "${lifecycle}" — ` +
+                    `field is only meaningful when lifecycle=deprecated (ignored per sdd-manifest-schema 1.1.0)`);
+            }
+        }
+    }
+    // Application-product traits (surface 0167, packaging 0175,
+    // application_archetype 0191; sdd-manifest-schema 1.2.0 / 1.7.0). The three
+    // scalar axes M-ADR 0194 §3.1 coordinates, and they compose freely — column
+    // order here follows that table. All are application-product-only: emitted
+    // with their defaults for application-product, empty for other profiles. A
+    // value declared on a non-application-product manifest is cleared with a
+    // convention finding (mirrors domain_id). Resolution of the archetype value
+    // against the active vocabulary — and the "defaulted to unclassified" /
+    // "unresolved value" findings — happen in the build's resolution step,
+    // which has the bundle cache; here we only emit the column value.
+    const isApp = m.profile === "application-product";
+    let surface = "";
+    let packaging = "";
+    let applicationArchetype = "";
+    if (isApp) {
+        surface = m.surface ?? "ui";
+        // Absent packaging is the unmarked norm, not unknown — a self-operated
+        // product is the overwhelming majority case (M-ADR 0175).
+        packaging = m.packaging ?? PACKAGING_DEFAULT;
+        applicationArchetype = m.applicationArchetype ?? "unclassified";
+    }
+    else {
+        for (const [field, value] of [
+            ["surface", m.surface],
+            ["packaging", m.packaging],
+            ["application_archetype", m.applicationArchetype],
+        ]) {
+            if (value !== undefined) {
+                inputs.findings.add("convention", `products: ${field}="${value}" declared on profile=${m.profile} — ` +
+                    `${field} is an application-product-only trait (ignored, cleared)`);
+            }
+        }
+    }
+    // Reference-exemplar trait (sdd-manifest-schema 1.8.0, catalogue 2.46.0).
+    // Deliberately OUTSIDE the isApp block above: this trait is profile-agnostic,
+    // so it is neither defaulted per-profile nor cleared with a convention finding
+    // off application-product. Absent is the unmarked norm — a real SDD — and
+    // raises no finding, matching `packaging`'s absent-resolves-to-norm shape.
+    // Emitted as the string "true" or empty rather than "true"/"false": empty is
+    // how every other nullable column spells "unmarked", and a column of mostly
+    // "false" would invite a consumer to treat the trait as a required decision.
+    const exemplar = m.exemplar === true ? "true" : "";
+    // Shared-library trait (M-ADR 0217 §4.4): same spelling and same derivation as exemplar.
+    const sharedLibrary = m.sharedLibrary === true ? "true" : "";
+    return [
+        {
+            id: m.sddId,
+            name: titleCase(m.sddId),
+            domain_id: domainId,
+            profile: m.profile,
+            category: m.category,
+            doc_path: ".",
+            lifecycle,
+            deprecated_date: deprecatedDate,
+            successor_sdd_id: successorSddId,
+            exemplar,
+            shared_library: sharedLibrary,
+            surface,
+            packaging,
+            application_archetype: applicationArchetype,
+            synthesis_quality: "",
+            synthesis_band: "",
+            last_assessed: "",
+            highest_snapshot_impact: "",
+            repo_count: inputs.repoCount,
+            source_sdd_id: "",
+        },
+    ];
+}
+function titleCase(slug) {
+    return slug
+        .split("-")
+        .map((p) => (p.length === 0 ? p : p[0].toUpperCase() + p.slice(1)))
+        .join(" ");
+}
+//# sourceMappingURL=products.js.map