@x12i/memorix-metadata 3.2.3 → 3.3.0

package/dist/validate.js

@@ -142,6 +142,26 @@ function validateObjectType(raw, path, issues) {
             requireNonEmptyString(o.contentTypes[i]?.id, `${path}.contentTypes[${i}].id`, issues);
         }
     }
+    if (o.fields !== undefined) {
+        if (!Array.isArray(o.fields)) {
+            issues.push(issue(`${path}.fields`, "META-TYPE", `${path}.fields must be an array`));
+        }
+        else {
+            for (let i = 0; i < o.fields.length; i++) {
+                const f = o.fields[i];
+                const fp = `${path}.fields[${i}]`;
+                if (!f || typeof f !== "object") {
+                    issues.push(issue(fp, "META-TYPE", `${fp} must be an object`));
+                    continue;
+                }
+                requireNonEmptyString(f.path, `${fp}.path`, issues);
+                requireNonEmptyString(f.valueType, `${fp}.valueType`, issues);
+                if (f.enum !== undefined) {
+                    validateEnumList(f.enum, `${fp}.enum`, issues);
+                }
+            }
+        }
+    }
 }
 function validateAbstractType(raw, path, issues) {
     if (!raw || typeof raw !== "object") {
@@ -167,6 +187,9 @@ function validateAbstractType(raw, path, issues) {
                 const p = a.properties[i];
                 requireNonEmptyString(p?.id, `${path}.properties[${i}].id`, issues);
                 requireNonEmptyString(p?.valueType, `${path}.properties[${i}].valueType`, issues);
+                if (p?.enum !== undefined) {
+                    validateEnumList(p.enum, `${path}.properties[${i}].enum`, issues);
+                }
             }
         }
     }
@@ -331,6 +354,294 @@ function validateWrite(raw, path, issues) {
     requireNonEmptyString(w.objectType, `${path}.objectType`, issues);
     requireNonEmptyString(w.contentType, `${path}.contentType`, issues);
 }
+function validateEnumList(value, path, issues) {
+    if (!Array.isArray(value) || value.length === 0) {
+        issues.push(issue(path, "META-ENUM", `${path} must be a non-empty string array`));
+        return;
+    }
+    const seen = new Set();
+    for (let i = 0; i < value.length; i++) {
+        const v = value[i];
+        if (typeof v !== "string" || !v.trim()) {
+            issues.push(issue(`${path}[${i}]`, "META-ENUM", `${path}[${i}] must be a non-empty string (empty string is never a vocabulary member)`));
+            continue;
+        }
+        if (seen.has(v)) {
+            issues.push(issue(`${path}[${i}]`, "META-DUP", `${path} duplicate value "${v}"`));
+        }
+        seen.add(v);
+    }
+}
+function requirePredicate(raw, path, issues) {
+    if (!raw || typeof raw !== "object") {
+        issues.push(issue(path, "META-TYPE", `${path} must be an object`));
+        return;
+    }
+    const p = raw;
+    requireNonEmptyString(p.property, `${path}.property`, issues);
+    if (!("equals" in p)) {
+        issues.push(issue(`${path}.equals`, "META-REQUIRED", `${path}.equals is required`));
+    }
+}
+function validateAnalytics(raw, path, issues) {
+    if (!raw || typeof raw !== "object") {
+        issues.push(issue(path, "META-TYPE", `${path} must be an object`));
+        return;
+    }
+    const a = raw;
+    requireNonEmptyString(a.id, `${path}.id`, issues);
+    requireNonEmptyString(a.name, `${path}.name`, issues);
+    if (!Array.isArray(a.scope) || a.scope.length !== 2) {
+        issues.push(issue(`${path}.scope`, "META-ANALYTICS-SCOPE", `${path}.scope must be an ordered pair of two properties`));
+    }
+    else {
+        for (let i = 0; i < 2; i++) {
+            const s = a.scope[i];
+            const sp = `${path}.scope[${i}]`;
+            if (!s || typeof s !== "object") {
+                issues.push(issue(sp, "META-TYPE", `${sp} must be an object`));
+                continue;
+            }
+            requireNonEmptyString(s.key, `${sp}.key`, issues);
+            requireNonEmptyString(s.abstractType, `${sp}.abstractType`, issues);
+            requireNonEmptyString(s.property, `${sp}.property`, issues);
+        }
+    }
+    if (a.clock !== undefined) {
+        if (!a.clock || typeof a.clock !== "object") {
+            issues.push(issue(`${path}.clock`, "META-TYPE", `${path}.clock must be an object`));
+        }
+        else {
+            requireNonEmptyString(a.clock.abstractType, `${path}.clock.abstractType`, issues);
+            requireNonEmptyString(a.clock.property, `${path}.clock.property`, issues);
+        }
+    }
+    if (!a.target || typeof a.target !== "object") {
+        issues.push(issue(`${path}.target`, "META-REQUIRED", `${path}.target is required`));
+    }
+    else {
+        requireNonEmptyString(a.target.objectType, `${path}.target.objectType`, issues);
+        requireNonEmptyString(a.target.contentType, `${path}.target.contentType`, issues);
+        requireNonEmptyString(a.target.recordId, `${path}.target.recordId`, issues);
+    }
+    if (a.history !== undefined) {
+        if (!a.history || typeof a.history !== "object") {
+            issues.push(issue(`${path}.history`, "META-TYPE", `${path}.history must be an object`));
+        }
+        else {
+            requireNonEmptyString(a.history.recordId, `${path}.history.recordId`, issues);
+            if (a.history.limit !== undefined) {
+                if (typeof a.history.limit !== "number" || !Number.isInteger(a.history.limit) || a.history.limit < 1) {
+                    issues.push(issue(`${path}.history.limit`, "META-TYPE", `${path}.history.limit must be a positive integer`));
+                }
+            }
+        }
+    }
+    if (a.measures !== undefined) {
+        if (!Array.isArray(a.measures)) {
+            issues.push(issue(`${path}.measures`, "META-TYPE", `${path}.measures must be an array`));
+        }
+        else {
+            requireUniqueIds(a.measures.map((m) => ({ id: m.key })), `${path}.measures`, issues);
+            for (let i = 0; i < a.measures.length; i++) {
+                const m = a.measures[i];
+                const mp = `${path}.measures[${i}]`;
+                requireNonEmptyString(m?.key, `${mp}.key`, issues);
+                requireNonEmptyString(m?.abstractType, `${mp}.abstractType`, issues);
+                if (!m?.kind ||
+                    !["count", "distinct", "sum", "mean", "max"].includes(m.kind)) {
+                    issues.push(issue(`${mp}.kind`, "META-ANALYTICS", `${mp}.kind must be count|distinct|sum|mean|max`));
+                }
+                if (m?.kind && m.kind !== "count" && !(typeof m.property === "string" && m.property.trim())) {
+                    issues.push(issue(`${mp}.property`, "META-REQUIRED", `${mp}.property is required for kind ${m.kind}`));
+                }
+                if (m?.where !== undefined)
+                    requirePredicate(m.where, `${mp}.where`, issues);
+            }
+        }
+    }
+    if (a.groups !== undefined) {
+        if (!Array.isArray(a.groups)) {
+            issues.push(issue(`${path}.groups`, "META-TYPE", `${path}.groups must be an array`));
+        }
+        else {
+            for (let i = 0; i < a.groups.length; i++) {
+                const g = a.groups[i];
+                const gp = `${path}.groups[${i}]`;
+                requireNonEmptyString(g?.key, `${gp}.key`, issues);
+                requireNonEmptyString(g?.abstractType, `${gp}.abstractType`, issues);
+                requireNonEmptyString(g?.property, `${gp}.property`, issues);
+                if (!Array.isArray(g?.buckets) || g.buckets.length === 0) {
+                    issues.push(issue(`${gp}.buckets`, "META-REQUIRED", `${gp}.buckets must be a non-empty array`));
+                }
+                else {
+                    validateEnumList(g.buckets, `${gp}.buckets`, issues);
+                }
+            }
+        }
+    }
+    if (a.ratios !== undefined) {
+        if (!Array.isArray(a.ratios)) {
+            issues.push(issue(`${path}.ratios`, "META-TYPE", `${path}.ratios must be an array`));
+        }
+        else {
+            for (let i = 0; i < a.ratios.length; i++) {
+                const r = a.ratios[i];
+                const rp = `${path}.ratios[${i}]`;
+                requireNonEmptyString(r?.key, `${rp}.key`, issues);
+                requireNonEmptyString(r?.numerator, `${rp}.numerator`, issues);
+                requireNonEmptyString(r?.denominator, `${rp}.denominator`, issues);
+            }
+        }
+    }
+    if (a.splits !== undefined) {
+        if (!Array.isArray(a.splits)) {
+            issues.push(issue(`${path}.splits`, "META-TYPE", `${path}.splits must be an array`));
+        }
+        else {
+            for (let i = 0; i < a.splits.length; i++) {
+                const s = a.splits[i];
+                const sp = `${path}.splits[${i}]`;
+                requireNonEmptyString(s?.key, `${sp}.key`, issues);
+                requireNonEmptyString(s?.abstractType, `${sp}.abstractType`, issues);
+                requireNonEmptyString(s?.property, `${sp}.property`, issues);
+                requireNonEmptyString(s?.totalKey, `${sp}.totalKey`, issues);
+                requireNonEmptyString(s?.subsetKey, `${sp}.subsetKey`, issues);
+                if (!Array.isArray(s?.buckets) || s.buckets.length === 0) {
+                    issues.push(issue(`${sp}.buckets`, "META-REQUIRED", `${sp}.buckets must be a non-empty array`));
+                }
+                else {
+                    validateEnumList(s.buckets, `${sp}.buckets`, issues);
+                }
+                if (s?.subset !== undefined)
+                    requirePredicate(s.subset, `${sp}.subset`, issues);
+                else
+                    issues.push(issue(`${sp}.subset`, "META-REQUIRED", `${sp}.subset is required`));
+            }
+        }
+    }
+    if (a.unwinds !== undefined) {
+        if (!Array.isArray(a.unwinds)) {
+            issues.push(issue(`${path}.unwinds`, "META-TYPE", `${path}.unwinds must be an array`));
+        }
+        else {
+            for (let i = 0; i < a.unwinds.length; i++) {
+                const u = a.unwinds[i];
+                const up = `${path}.unwinds[${i}]`;
+                requireNonEmptyString(u?.key, `${up}.key`, issues);
+                requireNonEmptyString(u?.abstractType, `${up}.abstractType`, issues);
+                requireNonEmptyString(u?.arrayProperty, `${up}.arrayProperty`, issues);
+                if (!Array.isArray(u?.columns) || u.columns.length === 0) {
+                    issues.push(issue(`${up}.columns`, "META-REQUIRED", `${up}.columns must be a non-empty array`));
+                }
+                else {
+                    for (let j = 0; j < u.columns.length; j++) {
+                        requireNonEmptyString(u.columns[j]?.key, `${up}.columns[${j}].key`, issues);
+                        requireNonEmptyString(u.columns[j]?.path, `${up}.columns[${j}].path`, issues);
+                    }
+                }
+            }
+        }
+    }
+    if (a.leaders !== undefined) {
+        if (!Array.isArray(a.leaders)) {
+            issues.push(issue(`${path}.leaders`, "META-TYPE", `${path}.leaders must be an array`));
+        }
+        else {
+            for (let i = 0; i < a.leaders.length; i++) {
+                const l = a.leaders[i];
+                const lp = `${path}.leaders[${i}]`;
+                requireNonEmptyString(l?.key, `${lp}.key`, issues);
+                requireNonEmptyString(l?.abstractType, `${lp}.abstractType`, issues);
+                requireNonEmptyString(l?.idProperty, `${lp}.idProperty`, issues);
+                requireNonEmptyString(l?.labelProperty, `${lp}.labelProperty`, issues);
+                if (!Array.isArray(l?.sort) || l.sort.length === 0) {
+                    issues.push(issue(`${lp}.sort`, "META-REQUIRED", `${lp}.sort must be a non-empty array`));
+                }
+                else {
+                    for (let j = 0; j < l.sort.length; j++) {
+                        requireNonEmptyString(l.sort[j]?.property, `${lp}.sort[${j}].property`, issues);
+                    }
+                }
+            }
+        }
+    }
+    if (a.coverage !== undefined) {
+        if (!Array.isArray(a.coverage)) {
+            issues.push(issue(`${path}.coverage`, "META-TYPE", `${path}.coverage must be an array`));
+        }
+        else {
+            for (let i = 0; i < a.coverage.length; i++) {
+                const c = a.coverage[i];
+                const cp = `${path}.coverage[${i}]`;
+                requireNonEmptyString(c?.key, `${cp}.key`, issues);
+                requireNonEmptyString(c?.abstractType, `${cp}.abstractType`, issues);
+                if (typeof c?.expected === "number") {
+                    if (!Number.isFinite(c.expected) || c.expected < 0) {
+                        issues.push(issue(`${cp}.expected`, "META-TYPE", `${cp}.expected must be a non-negative number`));
+                    }
+                }
+                else if (c?.expected && typeof c.expected === "object" && "measure" in c.expected) {
+                    requireNonEmptyString(c.expected.measure, `${cp}.expected.measure`, issues);
+                }
+                else {
+                    issues.push(issue(`${cp}.expected`, "META-REQUIRED", `${cp}.expected must be a number or { measure }`));
+                }
+                if (c?.where !== undefined)
+                    requirePredicate(c.where, `${cp}.where`, issues);
+            }
+        }
+    }
+    if (a.deltas !== undefined) {
+        if (!Array.isArray(a.deltas)) {
+            issues.push(issue(`${path}.deltas`, "META-TYPE", `${path}.deltas must be an array`));
+        }
+        else {
+            for (let i = 0; i < a.deltas.length; i++) {
+                requireNonEmptyString(a.deltas[i]?.key, `${path}.deltas[${i}].key`, issues);
+                requireNonEmptyString(a.deltas[i]?.measure, `${path}.deltas[${i}].measure`, issues);
+            }
+        }
+    }
+    if (a.transitions !== undefined) {
+        if (!Array.isArray(a.transitions)) {
+            issues.push(issue(`${path}.transitions`, "META-TYPE", `${path}.transitions must be an array`));
+        }
+        else {
+            for (let i = 0; i < a.transitions.length; i++) {
+                const t = a.transitions[i];
+                const tp = `${path}.transitions[${i}]`;
+                requireNonEmptyString(t?.key, `${tp}.key`, issues);
+                requireNonEmptyString(t?.abstractType, `${tp}.abstractType`, issues);
+                requireNonEmptyString(t?.property, `${tp}.property`, issues);
+            }
+        }
+    }
+    if (a.trends !== undefined) {
+        if (!Array.isArray(a.trends)) {
+            issues.push(issue(`${path}.trends`, "META-TYPE", `${path}.trends must be an array`));
+        }
+        else {
+            for (let i = 0; i < a.trends.length; i++) {
+                const t = a.trends[i];
+                const tp = `${path}.trends[${i}]`;
+                requireNonEmptyString(t?.key, `${tp}.key`, issues);
+                requireNonEmptyString(t?.label, `${tp}.label`, issues);
+                requireNonEmptyString(t?.measure, `${tp}.measure`, issues);
+                if (!Array.isArray(t?.windows) || t.windows.length === 0) {
+                    issues.push(issue(`${tp}.windows`, "META-REQUIRED", `${tp}.windows must be a non-empty array`));
+                }
+                else {
+                    for (let j = 0; j < t.windows.length; j++) {
+                        if (!["snapshots", "7d", "30d"].includes(t.windows[j])) {
+                            issues.push(issue(`${tp}.windows[${j}]`, "META-ANALYTICS", `${tp}.windows[${j}] must be snapshots|7d|30d`));
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
 function validateSource(raw, path, issues) {
     if (!raw || typeof raw !== "object") {
         issues.push(issue(path, "META-TYPE", `${path} must be an object`));
@@ -708,6 +1019,119 @@ function validateReferenceIntegrity(pack, issues) {
             issues.push(issue(`writes/${w.id}.objectType`, "META-REF-OBJECT", `write references unknown object type "${w.objectType}"`));
         }
     }
+    const absProps = new Map();
+    for (const abs of pack.abstractTypes) {
+        const props = new Map();
+        for (const p of abs.properties ?? []) {
+            if (p?.id)
+                props.set(p.id, { enum: p.enum });
+        }
+        absProps.set(abs.id, props);
+    }
+    const measureKeysByAnalytics = new Map();
+    for (const an of pack.analytics ?? []) {
+        const measureKeys = new Set((an.measures ?? []).map((m) => m.key).filter(Boolean));
+        measureKeysByAnalytics.set(an.id, measureKeys);
+        const checkAbsProp = (abstractType, property, path) => {
+            if (!abstractIds.has(abstractType)) {
+                issues.push(issue(path, "META-REF-ABSTRACT", `analytics references unknown abstract "${abstractType}"`));
+                return null;
+            }
+            const props = absProps.get(abstractType);
+            if (props && props.size > 0 && !props.has(property)) {
+                issues.push(issue(path, "META-REF-PROP", `analytics references unknown property "${property}" on "${abstractType}"`));
+                return null;
+            }
+            return props?.get(property) ?? null;
+        };
+        for (const s of an.scope ?? []) {
+            if (s?.abstractType && s?.property) {
+                checkAbsProp(s.abstractType, s.property, `analytics/${an.id}.scope`);
+            }
+        }
+        if (an.clock?.abstractType && an.clock.property) {
+            checkAbsProp(an.clock.abstractType, an.clock.property, `analytics/${an.id}.clock`);
+        }
+        if (an.target?.objectType && !objectTypeIds.has(an.target.objectType)) {
+            issues.push(issue(`analytics/${an.id}.target.objectType`, "META-REF-OBJECT", `analytics target references unknown object type "${an.target.objectType}"`));
+        }
+        for (const m of an.measures ?? []) {
+            if (m.abstractType && !abstractIds.has(m.abstractType)) {
+                issues.push(issue(`analytics/${an.id}.measures/${m.key}`, "META-REF-ABSTRACT", `analytics references unknown abstract "${m.abstractType}"`));
+            }
+            if (m.property && m.abstractType) {
+                checkAbsProp(m.abstractType, m.property, `analytics/${an.id}.measures/${m.key}.property`);
+            }
+            if (m.where?.property && m.abstractType) {
+                checkAbsProp(m.abstractType, m.where.property, `analytics/${an.id}.measures/${m.key}.where`);
+            }
+        }
+        for (const g of an.groups ?? []) {
+            const prop = g.abstractType && g.property
+                ? checkAbsProp(g.abstractType, g.property, `analytics/${an.id}.groups/${g.key}`)
+                : null;
+            if (prop?.enum && Array.isArray(g.buckets)) {
+                for (const b of g.buckets) {
+                    if (!prop.enum.includes(b)) {
+                        issues.push(issue(`analytics/${an.id}.groups/${g.key}.buckets`, "META-ENUM-BUCKET", `bucket "${b}" is not in enum for ${g.abstractType}.${g.property}`));
+                    }
+                }
+            }
+        }
+        for (const s of an.splits ?? []) {
+            const prop = s.abstractType && s.property
+                ? checkAbsProp(s.abstractType, s.property, `analytics/${an.id}.splits/${s.key}`)
+                : null;
+            if (prop?.enum && Array.isArray(s.buckets)) {
+                for (const b of s.buckets) {
+                    if (!prop.enum.includes(b)) {
+                        issues.push(issue(`analytics/${an.id}.splits/${s.key}.buckets`, "META-ENUM-BUCKET", `bucket "${b}" is not in enum for ${s.abstractType}.${s.property}`));
+                    }
+                }
+            }
+        }
+        for (const u of an.unwinds ?? []) {
+            if (u.abstractType && u.arrayProperty) {
+                checkAbsProp(u.abstractType, u.arrayProperty, `analytics/${an.id}.unwinds/${u.key}`);
+            }
+        }
+        for (const l of an.leaders ?? []) {
+            if (l.abstractType) {
+                checkAbsProp(l.abstractType, l.idProperty, `analytics/${an.id}.leaders/${l.key}.idProperty`);
+                checkAbsProp(l.abstractType, l.labelProperty, `analytics/${an.id}.leaders/${l.key}.labelProperty`);
+            }
+        }
+        for (const c of an.coverage ?? []) {
+            if (c.abstractType && !abstractIds.has(c.abstractType)) {
+                issues.push(issue(`analytics/${an.id}.coverage/${c.key}`, "META-REF-ABSTRACT", `analytics references unknown abstract "${c.abstractType}"`));
+            }
+            if (c.where?.property && c.abstractType) {
+                checkAbsProp(c.abstractType, c.where.property, `analytics/${an.id}.coverage/${c.key}.where`);
+            }
+            if (typeof c.expected === "object" && c.expected?.measure && !measureKeys.has(c.expected.measure)) {
+                issues.push(issue(`analytics/${an.id}.coverage/${c.key}.expected`, "META-REF-MEASURE", `coverage expected measure "${c.expected.measure}" unknown`));
+            }
+        }
+        for (const d of an.deltas ?? []) {
+            if (d.measure && !measureKeys.has(d.measure)) {
+                issues.push(issue(`analytics/${an.id}.deltas/${d.key}`, "META-REF-MEASURE", `delta references unknown measure "${d.measure}"`));
+            }
+        }
+        for (const t of an.trends ?? []) {
+            if (t.measure && !measureKeys.has(t.measure)) {
+                issues.push(issue(`analytics/${an.id}.trends/${t.key}`, "META-REF-MEASURE", `trend references unknown measure "${t.measure}"`));
+            }
+        }
+        for (const r of an.ratios ?? []) {
+            if (r.numerator && !measureKeys.has(r.numerator)) {
+                issues.push(issue(`analytics/${an.id}.ratios/${r.key}`, "META-REF-MEASURE", `ratio numerator "${r.numerator}" unknown`));
+            }
+            if (r.denominator && !measureKeys.has(r.denominator)) {
+                issues.push(issue(`analytics/${an.id}.ratios/${r.key}`, "META-REF-MEASURE", `ratio denominator "${r.denominator}" unknown`));
+            }
+        }
+    }
+    void measureKeysByAnalytics;
     for (const p of pack.pipelines) {
         for (const step of p.steps) {
             if (step.sourceId && !sourceIds.has(step.sourceId)) {
@@ -823,6 +1247,7 @@ export function validateMetadataPack(input, opts) {
         ["services", pack.services, validateService],
         ["pipelines", pack.pipelines, validatePipeline],
         ["schedules", pack.schedules, validateSchedule],
+        ["analytics", pack.analytics ?? [], validateAnalytics],
         ["kindDeclarations", pack.kindDeclarations ?? [], validateKindDeclaration],
     ];
     for (const [name, value, validator] of arrays) {