@x12i/memorix-metadata 3.4.0 → 3.4.1

package/dist/validate.js

@@ -110,6 +110,219 @@ function validateAgent(raw, path, issues) {
         }
     }
 }
+function validateContentTypeProfile(raw, path, issues) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        issues.push(issue(path, "META-REQUIRED", `${path} is required (declare allowSnapshotBuckets)`));
+        return;
+    }
+    const profile = raw;
+    if (typeof profile.allowSnapshotBuckets !== "boolean") {
+        issues.push(issue(`${path}.allowSnapshotBuckets`, "META-REQUIRED", `${path}.allowSnapshotBuckets must be a boolean`));
+    }
+}
+function validateContentTypeDiscriminator(raw, path, issues) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        issues.push(issue(path, "META-TYPE", `${path} must be an object`));
+        return;
+    }
+    const disc = raw;
+    requireNonEmptyString(disc.path, `${path}.path`, issues);
+    if (disc.required !== undefined && typeof disc.required !== "boolean") {
+        issues.push(issue(`${path}.required`, "META-TYPE", `${path}.required must be a boolean`));
+    }
+    if (disc.defaultValue !== undefined &&
+        (typeof disc.defaultValue !== "string" || !disc.defaultValue.trim())) {
+        issues.push(issue(`${path}.defaultValue`, "META-TYPE", `${path}.defaultValue must be a non-empty string`));
+    }
+}
+function validateFieldMappings(raw, path, issues) {
+    if (!Array.isArray(raw)) {
+        issues.push(issue(path, "META-TYPE", `${path} must be an array`));
+        return;
+    }
+    for (let i = 0; i < raw.length; i++) {
+        const item = raw[i];
+        const itemPath = `${path}[${i}]`;
+        if (!item || typeof item !== "object" || Array.isArray(item)) {
+            issues.push(issue(itemPath, "META-TYPE", `${itemPath} must be an object`));
+            continue;
+        }
+        const profile = item;
+        requireNonEmptyString(profile.id, `${itemPath}.id`, issues);
+        requireNonEmptyString(profile.namespace, `${itemPath}.namespace`, issues);
+        if (profile.format !== "memorix-field-map/1") {
+            issues.push(issue(`${itemPath}.format`, "META-TYPE", `${itemPath}.format must be memorix-field-map/1`));
+        }
+        if (!profile.fieldMap || typeof profile.fieldMap !== "object" || Array.isArray(profile.fieldMap)) {
+            issues.push(issue(`${itemPath}.fieldMap`, "META-TYPE", `${itemPath}.fieldMap must be an object`));
+        }
+    }
+}
+const PRESENTATION_TABS = new Set(["always", "whenPresent", "hidden"]);
+const ORIGIN_PRODUCERS = new Set(["model", "code", "mixed"]);
+const ORIGIN_USES = new Set(["always", "conditional"]);
+const FUNCTION_KINDS = new Set(["spine", "threads"]);
+function validateContentTypePresentation(raw, path, issues) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        issues.push(issue(path, "META-TYPE", `${path} must be an object`));
+        return;
+    }
+    const presentation = raw;
+    if (presentation.label !== undefined && typeof presentation.label !== "string") {
+        issues.push(issue(`${path}.label`, "META-TYPE", `${path}.label must be a string`));
+    }
+    if (presentation.order !== undefined && typeof presentation.order !== "number") {
+        issues.push(issue(`${path}.order`, "META-TYPE", `${path}.order must be a number`));
+    }
+    if (presentation.tab !== undefined &&
+        (typeof presentation.tab !== "string" || !PRESENTATION_TABS.has(presentation.tab))) {
+        issues.push(issue(`${path}.tab`, "META-TYPE", `${path}.tab must be always, whenPresent, or hidden`));
+    }
+    if (presentation.values === undefined)
+        return;
+    if (!Array.isArray(presentation.values)) {
+        issues.push(issue(`${path}.values`, "META-TYPE", `${path}.values must be an array`));
+        return;
+    }
+    for (let i = 0; i < presentation.values.length; i++) {
+        const value = presentation.values[i];
+        const valuePath = `${path}.values[${i}]`;
+        if (!value || typeof value !== "object" || Array.isArray(value)) {
+            issues.push(issue(valuePath, "META-TYPE", `${valuePath} must be an object`));
+            continue;
+        }
+        requireNonEmptyString(value.value, `${valuePath}.value`, issues);
+    }
+}
+function validateContentTypeOrigin(raw, path, issues) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        issues.push(issue(path, "META-TYPE", `${path} must be an object`));
+        return;
+    }
+    const origin = raw;
+    if (origin.producer !== undefined &&
+        (typeof origin.producer !== "string" || !ORIGIN_PRODUCERS.has(origin.producer))) {
+        issues.push(issue(`${path}.producer`, "META-TYPE", `${path}.producer must be model, code, or mixed`));
+    }
+    if (origin.use !== undefined && (typeof origin.use !== "string" || !ORIGIN_USES.has(origin.use))) {
+        issues.push(issue(`${path}.use`, "META-TYPE", `${path}.use must be always or conditional`));
+    }
+    if (origin.record !== undefined && (typeof origin.record !== "string" || !origin.record.trim())) {
+        issues.push(issue(`${path}.record`, "META-TYPE", `${path}.record must be a non-empty string`));
+    }
+}
+function validateFunctionRead(raw, path, issues) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        issues.push(issue(path, "META-TYPE", `${path} must be an object`));
+        return;
+    }
+    const read = raw;
+    for (const key of ["objectType", "contentType", "recordId", "template"]) {
+        const value = read[key];
+        if (value !== undefined && (typeof value !== "string" || !value.trim())) {
+            issues.push(issue(`${path}.${key}`, "META-TYPE", `${path}.${key} must be a non-empty string`));
+        }
+    }
+    if (read.sameSubject !== undefined && typeof read.sameSubject !== "boolean") {
+        issues.push(issue(`${path}.sameSubject`, "META-TYPE", `${path}.sameSubject must be a boolean`));
+    }
+}
+function validateObjectTypeFunctions(raw, path, issues) {
+    if (!Array.isArray(raw)) {
+        issues.push(issue(path, "META-TYPE", `${path} must be an array`));
+        return;
+    }
+    requireUniqueIds(raw, path, issues);
+    const templates = new Map();
+    for (let i = 0; i < raw.length; i++) {
+        const item = raw[i];
+        const itemPath = `${path}[${i}]`;
+        if (!item || typeof item !== "object" || Array.isArray(item)) {
+            issues.push(issue(itemPath, "META-TYPE", `${itemPath} must be an object`));
+            continue;
+        }
+        const fn = item;
+        requireNonEmptyString(fn.id, `${itemPath}.id`, issues);
+        requireNonEmptyString(fn.question, `${itemPath}.question`, issues);
+        requireNonEmptyString(fn.page, `${itemPath}.page`, issues);
+        if (typeof fn.composes !== "boolean") {
+            issues.push(issue(`${itemPath}.composes`, "META-TYPE", `${itemPath}.composes must be a boolean`));
+        }
+        if (typeof fn.pageStory !== "boolean") {
+            issues.push(issue(`${itemPath}.pageStory`, "META-TYPE", `${itemPath}.pageStory must be a boolean`));
+        }
+        if (fn.template !== undefined) {
+            if (typeof fn.template !== "string" || !fn.template.trim()) {
+                issues.push(issue(`${itemPath}.template`, "META-TYPE", `${itemPath}.template must be a non-empty string`));
+            }
+            else {
+                const template = fn.template.trim();
+                const previous = templates.get(template);
+                if (previous !== undefined) {
+                    issues.push(issue(`${itemPath}.template`, "META-STORY-TEMPLATE", `template "${template}" is already used by ${path}[${previous}]`));
+                }
+                else {
+                    templates.set(template, i);
+                }
+            }
+        }
+        if (fn.kind !== undefined && (typeof fn.kind !== "string" || !FUNCTION_KINDS.has(fn.kind))) {
+            issues.push(issue(`${itemPath}.kind`, "META-TYPE", `${itemPath}.kind must be spine or threads`));
+        }
+        if (!Array.isArray(fn.reads)) {
+            issues.push(issue(`${itemPath}.reads`, "META-TYPE", `${itemPath}.reads must be an array`));
+        }
+        else {
+            for (let r = 0; r < fn.reads.length; r++) {
+                validateFunctionRead(fn.reads[r], `${itemPath}.reads[${r}]`, issues);
+            }
+        }
+    }
+}
+function storyPresentationTemplates(contentTypes) {
+    if (!Array.isArray(contentTypes))
+        return [];
+    const templates = [];
+    for (const contentType of contentTypes) {
+        if (!contentType || typeof contentType !== "object" || Array.isArray(contentType))
+            continue;
+        const spec = contentType;
+        if (spec.id !== "story")
+            continue;
+        const values = spec.presentation?.values;
+        if (!Array.isArray(values))
+            continue;
+        for (const value of values) {
+            if (!value || typeof value !== "object" || Array.isArray(value))
+                continue;
+            const raw = value.value;
+            if (typeof raw === "string" && raw.trim())
+                templates.push(raw.trim());
+        }
+    }
+    return templates;
+}
+function assertStoryFunctionTemplates(contentTypes, functions, path, issues) {
+    const counts = new Map();
+    for (const fn of functions) {
+        if (!fn || typeof fn !== "object" || Array.isArray(fn))
+            continue;
+        const template = fn.template;
+        if (typeof template !== "string" || !template.trim())
+            continue;
+        const key = template.trim();
+        counts.set(key, (counts.get(key) ?? 0) + 1);
+    }
+    const seen = new Set();
+    for (const template of storyPresentationTemplates(contentTypes)) {
+        if (seen.has(template))
+            continue;
+        seen.add(template);
+        if ((counts.get(template) ?? 0) === 0) {
+            issues.push(issue(`${path}.functions`, "META-STORY-TEMPLATE", `story template "${template}" must have exactly one function on this object type`));
+        }
+    }
+}
 function validateObjectType(raw, path, issues) {
     if (!raw || typeof raw !== "object") {
         issues.push(issue(path, "META-TYPE", `${path} must be an object`));
@@ -134,12 +347,53 @@ function validateObjectType(raw, path, issues) {
             }
         }
     }
+    let declaredContentTypes = new Set();
     if (!Array.isArray(o.contentTypes) || o.contentTypes.length === 0) {
         issues.push(issue(`${path}.contentTypes`, "META-REQUIRED", `${path}.contentTypes must be a non-empty array`));
     }
     else {
+        let leadingCount = 0;
         for (let i = 0; i < o.contentTypes.length; i++) {
-            requireNonEmptyString(o.contentTypes[i]?.id, `${path}.contentTypes[${i}].id`, issues);
+            const ct = o.contentTypes[i];
+            const cp = `${path}.contentTypes[${i}]`;
+            if (!ct || typeof ct !== "object" || Array.isArray(ct)) {
+                issues.push(issue(cp, "META-TYPE", `${cp} must be an object`));
+                continue;
+            }
+            if (requireNonEmptyString(ct.id, `${cp}.id`, issues)) {
+                declaredContentTypes.add(ct.id);
+            }
+            validateContentTypeProfile(ct.profile, `${cp}.profile`, issues);
+            if (ct.required !== undefined && typeof ct.required !== "boolean") {
+                issues.push(issue(`${cp}.required`, "META-TYPE", `${cp}.required must be a boolean`));
+            }
+            else if (ct.required === true) {
+                requireNonEmptyString(ct.requiredReason, `${cp}.requiredReason`, issues);
+            }
+            if (ct.leading !== undefined) {
+                if (typeof ct.leading !== "boolean") {
+                    issues.push(issue(`${cp}.leading`, "META-TYPE", `${cp}.leading must be a boolean`));
+                }
+                else if (ct.leading) {
+                    leadingCount += 1;
+                }
+            }
+            if (ct.discriminator !== undefined) {
+                validateContentTypeDiscriminator(ct.discriminator, `${cp}.discriminator`, issues);
+            }
+            if (ct.fieldMappings !== undefined) {
+                validateFieldMappings(ct.fieldMappings, `${cp}.fieldMappings`, issues);
+            }
+            if (ct.presentation !== undefined) {
+                validateContentTypePresentation(ct.presentation, `${cp}.presentation`, issues);
+            }
+            if (ct.origin !== undefined) {
+                validateContentTypeOrigin(ct.origin, `${cp}.origin`, issues);
+            }
+        }
+        requireUniqueIds(o.contentTypes, `${path}.contentTypes`, issues);
+        if (leadingCount > 1) {
+            issues.push(issue(`${path}.contentTypes`, "META-LEADING", `object type "${typeof o.id === "string" ? o.id : ""}" has more than one leading content type`));
         }
     }
     if (o.fields !== undefined) {
@@ -156,12 +410,26 @@ function validateObjectType(raw, path, issues) {
                 }
                 requireNonEmptyString(f.path, `${fp}.path`, issues);
                 requireNonEmptyString(f.valueType, `${fp}.valueType`, issues);
+                if (f.contentType !== undefined) {
+                    if (typeof f.contentType !== "string" || !f.contentType.trim()) {
+                        issues.push(issue(`${fp}.contentType`, "META-TYPE", `${fp}.contentType must be a non-empty string`));
+                    }
+                    else if (!declaredContentTypes.has(f.contentType)) {
+                        issues.push(issue(`${fp}.contentType`, "META-REF-CONTENT", `content type "${f.contentType}" is not registered on this object type`));
+                    }
+                }
                 if (f.enum !== undefined) {
                     validateEnumList(f.enum, `${fp}.enum`, issues);
                 }
             }
         }
     }
+    if (o.functions !== undefined) {
+        validateObjectTypeFunctions(o.functions, `${path}.functions`, issues);
+        if (Array.isArray(o.functions)) {
+            assertStoryFunctionTemplates(o.contentTypes, o.functions, path, issues);
+        }
+    }
 }
 function validateAbstractType(raw, path, issues) {
     if (!raw || typeof raw !== "object") {
@@ -419,6 +687,28 @@ function rejectReservedBuckets(buckets, path, issues) {
         }
     }
 }
+/** A measure, group, or split names an abstract or a stored object type and content type. */
+function requireRecordSelector(node, path, issues) {
+    const abs = typeof node?.abstractType === "string" && node.abstractType.trim().length > 0;
+    const ot = typeof node?.objectType === "string" && node.objectType.trim().length > 0;
+    const ct = typeof node?.contentType === "string" && node.contentType.trim().length > 0;
+    if (abs && (ot || ct)) {
+        issues.push(issue(path, "META-ANALYTICS", `${path} names abstractType or objectType and contentType, not both`));
+        return;
+    }
+    if (abs)
+        return;
+    if (ot && ct)
+        return;
+    if (!ot && !ct) {
+        issues.push(issue(path, "META-REQUIRED", `${path} must name abstractType or objectType and contentType`));
+        return;
+    }
+    if (!ot)
+        requireNonEmptyString(node?.objectType, `${path}.objectType`, issues);
+    if (!ct)
+        requireNonEmptyString(node?.contentType, `${path}.contentType`, issues);
+}
 function validateAnalytics(raw, path, issues) {
     if (!raw || typeof raw !== "object") {
         issues.push(issue(path, "META-TYPE", `${path} must be an object`));
@@ -486,7 +776,7 @@ function validateAnalytics(raw, path, issues) {
                 const m = a.measures[i];
                 const mp = `${path}.measures[${i}]`;
                 requireNonEmptyString(m?.key, `${mp}.key`, issues);
-                requireNonEmptyString(m?.abstractType, `${mp}.abstractType`, issues);
+                requireRecordSelector(m, mp, 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`));
@@ -524,7 +814,7 @@ function validateAnalytics(raw, path, issues) {
                 const g = a.groups[i];
                 const gp = `${path}.groups[${i}]`;
                 requireNonEmptyString(g?.key, `${gp}.key`, issues);
-                requireNonEmptyString(g?.abstractType, `${gp}.abstractType`, issues);
+                requireRecordSelector(g, gp, issues);
                 requireNonEmptyString(g?.property, `${gp}.property`, issues);
                 const openBuckets = g?.property === "@datasource" && g.buckets === undefined;
                 if (!openBuckets) {
@@ -618,7 +908,7 @@ function validateAnalytics(raw, path, issues) {
                 const s = a.splits[i];
                 const sp = `${path}.splits[${i}]`;
                 requireNonEmptyString(s?.key, `${sp}.key`, issues);
-                requireNonEmptyString(s?.abstractType, `${sp}.abstractType`, issues);
+                requireRecordSelector(s, sp, issues);
                 requireNonEmptyString(s?.property, `${sp}.property`, issues);
                 requireNonEmptyString(s?.totalKey, `${sp}.totalKey`, issues);
                 requireNonEmptyString(s?.subsetKey, `${sp}.subsetKey`, issues);
@@ -1157,6 +1447,30 @@ function validateReferenceIntegrity(pack, issues) {
         }
         absProps.set(abs.id, props);
     }
+    const otContent = new Map();
+    const otFields = new Map();
+    const snapshotBucketsByContentType = new Map();
+    for (const ot of pack.objectTypes) {
+        otContent.set(ot.id, new Set((ot.contentTypes ?? []).map((c) => c.id).filter(Boolean)));
+        for (const c of ot.contentTypes ?? []) {
+            const flag = c?.profile?.allowSnapshotBuckets;
+            if (!c?.id || typeof flag !== "boolean")
+                continue;
+            const previous = snapshotBucketsByContentType.get(c.id);
+            if (previous !== undefined && previous !== flag) {
+                issues.push(issue(`objectTypes/${ot.id}.contentTypes`, "META-CT-PROFILE", `content type "${c.id}" must declare allowSnapshotBuckets the same way on every object type`));
+            }
+            else {
+                snapshotBucketsByContentType.set(c.id, flag);
+            }
+        }
+        const fields = new Map();
+        for (const f of ot.fields ?? []) {
+            if (f?.path)
+                fields.set(f.path, { enum: f.enum });
+        }
+        otFields.set(ot.id, fields);
+    }
     const measureKeysByAnalytics = new Map();
     for (const an of pack.analytics ?? []) {
         const measureKeys = new Set((an.measures ?? []).map((m) => m.key).filter(Boolean));
@@ -1175,6 +1489,26 @@ function validateReferenceIntegrity(pack, issues) {
             }
             return props?.get(property) ?? null;
         };
+        const namesContent = (node) => Boolean((node.objectType?.trim() || node.contentType?.trim()) && !node.abstractType?.trim());
+        const checkStored = (node, path) => {
+            const objectType = node.objectType?.trim() ?? "";
+            const contentType = node.contentType?.trim() ?? "";
+            if (!objectTypeIds.has(objectType)) {
+                issues.push(issue(path, "META-REF-OBJECT", `analytics references unknown object type "${objectType}"`));
+                return;
+            }
+            if (!otContent.get(objectType)?.has(contentType)) {
+                issues.push(issue(path, "META-REF-CONTENT", `content type "${contentType}" is not registered on "${objectType}"`));
+            }
+        };
+        const storedEnum = (objectType, property) => {
+            if (!objectType || !property)
+                return null;
+            if (ANALYTICS_PSEUDO_PROPERTIES.includes(property))
+                return null;
+            const en = otFields.get(objectType)?.get(property)?.enum;
+            return en?.length ? { enum: en } : null;
+        };
         for (const s of an.scope ?? []) {
             if (s?.abstractType && s?.property) {
                 checkAbsProp(s.abstractType, s.property, `analytics/${an.id}.scope`);
@@ -1187,6 +1521,10 @@ function validateReferenceIntegrity(pack, issues) {
             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 (namesContent(m)) {
+                checkStored(m, `analytics/${an.id}.measures/${m.key}`);
+                continue;
+            }
             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}"`));
             }
@@ -1210,6 +1548,16 @@ function validateReferenceIntegrity(pack, issues) {
         };
         const groupBuckets = new Map();
         for (const g of an.groups ?? []) {
+            if (namesContent(g)) {
+                checkStored(g, `analytics/${an.id}.groups/${g.key}`);
+                checkBucketsInEnum(storedEnum(g.objectType, g.property), g.buckets, `analytics/${an.id}.groups/${g.key}.buckets`, `${g.objectType}.${g.property}`);
+                if (g.key)
+                    groupBuckets.set(g.key, Array.isArray(g.buckets) ? new Set(g.buckets) : "open");
+                if (g.split?.property) {
+                    checkBucketsInEnum(storedEnum(g.objectType, g.split.property), g.split.buckets, `analytics/${an.id}.groups/${g.key}.split.buckets`, `${g.objectType}.${g.split.property}`);
+                }
+                continue;
+            }
             const prop = g.abstractType && g.property
                 ? checkAbsProp(g.abstractType, g.property, `analytics/${an.id}.groups/${g.key}`)
                 : null;
@@ -1245,6 +1593,18 @@ function validateReferenceIntegrity(pack, issues) {
                 derivedSoFar.add(d.key);
         }
         for (const s of an.splits ?? []) {
+            if (namesContent(s)) {
+                checkStored(s, `analytics/${an.id}.splits/${s.key}`);
+                const prop = storedEnum(s.objectType, s.property);
+                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.objectType}.${s.property}`));
+                        }
+                    }
+                }
+                continue;
+            }
             const prop = s.abstractType && s.property
                 ? checkAbsProp(s.abstractType, s.property, `analytics/${an.id}.splits/${s.key}`)
                 : null;