@peter.prib/renderengine 0.2.7 → 0.2.11

package/src/charting/datamodel/DataModelChecker.js

@@ -1,5 +1,14 @@
 import { ModelChecker } from '../ModelChecker.js';
 import { BianNotation } from '../../bian.js';
+import { ClassificationScheme } from './ClassificationScheme.js';
+import { DataModelNotation } from '../../datamodel.js';
+import { DataModelContext } from './DataModelContext.js';
+import { NameStyle } from './naming/NameStyle.js';
+
+/** Whether a cardinality is many. */
+const many = (cardinality) => /\*/.test(String(cardinality ?? ''));
+/** The levels whose entities have attributes. */
+const ATTRIBUTED = ['logical', 'physical'];
 
 /**
  * DataModelChecker — checks over a DataModel (a ModelChecker): each business
@@ -8,12 +17,245 @@ import { BianNotation } from '../../bian.js';
  * wrong); service domains complete (a control record, qualifiers that are
  * entities, a pattern BIAN has); mappings joining entities that are there;
  * data types sound (an enumeration with values, each once; one name a type)
- * and used. Each finding names what it is about (`kind`: 'entity',
+ * and used; and the model sound as DMBOK2 has a data model reviewed: keys,
+ * foreign keys agreeing with relationships, no repeating groups, one name one
+ * type, no many-to-many left at the physical level, concepts defined (and not
+ * by their name), names as the model's naming standard says (if it has one).
+ * Each finding names what it is about (`kind`: 'entity', 'relationship',
  * 'perspective', 'mapping', 'data-type') and, for an entity, its `level`.
  */
 export class DataModelChecker extends ModelChecker {
     checks() {
-        return [this.ownedTwice, this.unowned, this.serviceDomains, this.mappings, this.dataTypes];
+        return [
+            this.ownedTwice, this.unowned, this.serviceDomains, this.mappings, this.dataTypes,
+            this.keys, this.foreignKeys, this.manyToMany, this.repeatingGroups, this.typeConflicts, this.definitions, this.naming,
+            this.classification, this.generalizationCycles, this.qualityRules, this.dimensional,
+        ];
+    }
+
+    /** A finding on an entity at a level. @private */
+    _entity(level, entity, code, severity, message) {
+        return { code, severity, kind: 'entity', level, ids: [entity.id], message };
+    }
+
+    /** An entity at a logical or physical level, with attributes, none of them its primary key. */
+    keys() {
+        return ATTRIBUTED.flatMap(level => this.model.level(level).entities
+            .filter(e => (e.attributes ?? []).length && !e.attributes.some(a => a.isPK))
+            .map(e => this._entity(level, e, 'no-primary-key', 'warning', `${level === 'physical' ? 'Table' : 'Entity'} "${e.name}" has no primary key`)));
+    }
+
+    /**
+     * A foreign key that references what is not there, or an entity it has no
+     * relationship with; one that says nothing of what it references, on an
+     * entity with no relationship at all.
+     */
+    foreignKeys() {
+        return ATTRIBUTED.flatMap(level => {
+            const schema = this.model.level(level);
+            const related = (a, b) => schema.relationships.some(r => (r.source === a && r.target === b) || (r.source === b && r.target === a));
+            return schema.entities.flatMap(e => (e.attributes ?? []).filter(a => a.isFK).flatMap(a => {
+                if (!a.references) {
+                    return schema.relationships.some(r => r.source === e.id || r.target === e.id) ? []
+                        : [this._entity(level, e, 'foreign-key-unrelated', 'info', `"${e.name}.${a.name}" is a foreign key, but "${e.name}" has no relationship`)];
+                }
+                const target = schema.resolveReference(a.references)?.entity;
+                if (!target) return [this._entity(level, e, 'reference-missing', 'warning', `"${e.name}.${a.name}" references "${a.references}", which is not at the ${level} level`)];
+                return related(e.id, target.id) ? []
+                    : [this._entity(level, e, 'foreign-key-without-relationship', 'warning', `"${e.name}.${a.name}" references "${target.name}", but they have no relationship`)];
+            }));
+        });
+    }
+
+    /** A many-to-many relationship left at the physical level (an associative table resolves it). */
+    manyToMany() {
+        const schema = this.model.level('physical');
+        return schema.relationships.filter(r => DataModelNotation.relationshipKind(r).hasCardinality && many(r.sourceCardinality) && many(r.targetCardinality)).map(r => ({
+            code: 'many-to-many', severity: 'warning', kind: 'relationship', level: 'physical', ids: [r.id ?? `${r.source}->${r.target}`],
+            message: `"${schema.entity(r.source)?.name ?? r.source}" and "${schema.entity(r.target)?.name ?? r.target}" are many-to-many; a table between them resolves it`,
+        }));
+    }
+
+    /** Attributes of one entity that differ only by a number at the end (phone 1, phone 2): a repeating group. */
+    repeatingGroups() {
+        return ATTRIBUTED.flatMap(level => this.model.level(level).entities.flatMap(e => {
+            const stems = new Map();
+            for (const a of e.attributes ?? []) {
+                const m = /^(.*?\D)[\s_-]*\d+$/.exec(a.name);
+                if (m) stems.set(m[1].toLowerCase(), [...(stems.get(m[1].toLowerCase()) ?? []), a.name]);
+            }
+            return [...stems.values()].filter(names => names.length > 1)
+                .map(names => this._entity(level, e, 'repeating-group', 'warning', `"${e.name}" repeats ${names.join(', ')}: a repeating group, better an entity of its own`));
+        }));
+    }
+
+    /** One attribute name with different types at a level. */
+    typeConflicts() {
+        return ATTRIBUTED.flatMap(level => {
+            const byName = new Map();
+            for (const e of this.model.level(level).entities) {
+                for (const a of e.attributes ?? []) {
+                    if (!a.type) continue;
+                    const key = a.name.toLowerCase();
+                    byName.set(key, [...(byName.get(key) ?? []), [e, a.type]]);
+                }
+            }
+            return [...byName].filter(([, uses]) => new Set(uses.map(([, t]) => t)).size > 1).map(([name, uses]) => ({
+                code: 'type-conflict', severity: 'info', kind: 'entity', level, ids: [...new Set(uses.map(([e]) => e.id))],
+                message: `"${name}" has different types at the ${level} level: ${[...new Set(uses.map(([e, t]) => `${t} (${e.name})`))].join(', ')}`,
+            }));
+        });
+    }
+
+    /** A concept without a definition; any entity whose definition only says its name. */
+    definitions() {
+        const plain = (s) => String(s ?? '').toLowerCase().replace(/[^a-z0-9]+/g, '');
+        return [
+            ...this.model.level('conceptual').entities.filter(e => !String(e.description ?? '').trim())
+                .map(e => this._entity('conceptual', e, 'definition-missing', 'info', `Concept "${e.name}" has no definition`)),
+            ...this.model.constructor.LEVELS.flatMap(level => this.model.level(level).entities
+                .filter(e => e.description && plain(e.description) === plain(e.name))
+                .map(e => this._entity(level, e, 'definition-restates-name', 'info', `"${e.name}" is defined only by its name`))),
+        ];
+    }
+
+    /**
+     * Classification kept down the mappings: what realises a classified
+     * entity is classified at least as high and falls in its categories
+     * (`classification-lost`); a sensitivity the scheme does not have
+     * (`classification-unknown`).
+     */
+    classification() {
+        const scheme = this.model.classificationScheme;
+        const levels = this.model.constructor.LEVELS;
+        const findings = [];
+        for (const level of levels) {
+            for (const e of this.model.level(level).entities) {
+                const unknown = [e, ...(e.attributes ?? [])].filter(p => p.sensitivity && scheme.rank(p.sensitivity) < 0);
+                if (unknown.length) {
+                    findings.push(this._entity(level, e, 'classification-unknown', 'info',
+                        `"${e.name}" is classified ${[...new Set(unknown.map(p => p.sensitivity))].join(', ')}, which the classification scheme does not have`));
+                }
+            }
+        }
+        levels.slice(0, -1).forEach((from, i) => {
+            const to = levels[i + 1];
+            const mapping = this.model.mapping(from, to);
+            for (const e of this.model.level(from).entities) {
+                const own = scheme.effective(e);
+                if (!own.sensitivity && !own.categories.length) continue;
+                for (const id of mapping.targetsOf(e.id)) {
+                    const target = this.model.level(to).entity(id);
+                    if (!target) continue;
+                    const theirs = scheme.effective(target);
+                    const lower = scheme.rank(theirs.sensitivity) < scheme.rank(own.sensitivity);
+                    const missing = own.categories.filter(c => !theirs.categories.includes(c));
+                    if (!lower && !missing.length) continue;
+                    findings.push(this._entity(to, target, 'classification-lost', 'warning',
+                        `"${target.name}" realises "${e.name}" (${ClassificationScheme.describe(own)}) but is ${ClassificationScheme.describe(theirs) || 'unclassified'}`));
+                }
+            }
+        });
+        return findings;
+    }
+
+    /**
+     * A data quality rule on an attribute that nothing realising its concepts
+     * has (at the logical or physical level; names compared as words, so
+     * 'legal name' is 'legal_name'); a dimension DMBOK2 does not name.
+     */
+    qualityRules() {
+        const words = (name) => NameStyle.words(name).map(w => w.toLowerCase()).join(' ');
+        return this.model.contexts.flatMap(context => context.constraints.flatMap(rule => {
+            const findings = [];
+            const about = { kind: 'context', ids: [context.id] };
+            if (rule.dimension && !DataModelContext.QUALITY_DIMENSIONS.includes(rule.dimension)) {
+                findings.push({ ...about, code: 'quality-dimension-unknown', severity: 'info', message: `Rule "${rule.text}" (${context.name}) measures "${rule.dimension}", not a data quality dimension` });
+            }
+            if (rule.attribute) {
+                const want = words(rule.attribute);
+                const has = ATTRIBUTED.some(level => [...(this.model.realising(level, rule.applies) ?? [])]
+                    .some(id => (this.model.level(level).entity(id)?.attributes ?? []).some(a => words(a.name) === want)));
+                if (!has) findings.push({ ...about, code: 'rule-attribute-missing', severity: 'warning', message: `Rule "${rule.text}" (${context.name}) is on "${rule.attribute}", which nothing realising its concepts has` });
+            }
+            return findings;
+        }));
+    }
+
+    /**
+     * A dimensional scheme as Kimball would have it: a fact states its grain
+     * (`fact-no-grain`), is related to a dimension (`fact-no-dimension`) and
+     * has a measure (`fact-no-measure`); a measure is a fact's
+     * (`measure-outside-fact`); two facts are not joined directly (`fact-to-fact`).
+     */
+    dimensional() {
+        return ATTRIBUTED.flatMap(level => {
+            const schema = this.model.level(level);
+            const roleOf = (e) => DataModelNotation.entityRole(e)?.role;
+            const isFact = (id) => roleOf(schema.entity(id)) === 'fact';
+            const findings = [];
+            for (const e of schema.entities) {
+                const measures = (e.attributes ?? []).filter(a => a.measure);
+                if (roleOf(e) !== 'fact') {
+                    if (measures.length) findings.push(this._entity(level, e, 'measure-outside-fact', 'info', `"${e.name}" has measures (${measures.map(a => a.name).join(', ')}) but is no fact`));
+                    continue;
+                }
+                if (!String(e.grain ?? '').trim()) findings.push(this._entity(level, e, 'fact-no-grain', 'warning', `Fact "${e.name}" does not say its grain (what one row is)`));
+                const dims = schema.relationships.filter(r => (r.source === e.id || r.target === e.id))
+                    .map(r => schema.entity(r.source === e.id ? r.target : r.source)).filter(d => roleOf(d) === 'dimension');
+                if (!dims.length) findings.push(this._entity(level, e, 'fact-no-dimension', 'warning', `Fact "${e.name}" is related to no dimension`));
+                if (!measures.length) findings.push(this._entity(level, e, 'fact-no-measure', 'info', `Fact "${e.name}" has no measure`));
+            }
+            for (const r of schema.relationships) {
+                if (isFact(r.source) && isFact(r.target)) {
+                    findings.push({ code: 'fact-to-fact', severity: 'info', kind: 'relationship', level, ids: [r.id ?? `${r.source}->${r.target}`],
+                        message: `Facts "${schema.entity(r.source).name}" and "${schema.entity(r.target).name}" are joined directly; facts meet through their dimensions` });
+                }
+            }
+            return findings;
+        });
+    }
+
+    /** Generalizations that go round: an entity, through its supertypes, its own supertype. */
+    generalizationCycles() {
+        return this.model.constructor.LEVELS.flatMap(level => {
+            const schema = this.model.level(level);
+            const supertypes = new Map();
+            for (const r of schema.relationships) {
+                if (DataModelNotation.relationshipKind(r).hasCardinality) continue;
+                supertypes.set(r.source, [...(supertypes.get(r.source) ?? []), r.target]);
+            }
+            const cycles = new Map();
+            const walk = (id, path) => {
+                if (path.includes(id)) {
+                    const cycle = path.slice(path.indexOf(id));
+                    const key = [...cycle].sort().join(' ');
+                    if (!cycles.has(key)) cycles.set(key, cycle);   // as first found: from the first entity round
+                    return;
+                }
+                for (const up of supertypes.get(id) ?? []) walk(up, [...path, id]);
+            };
+            for (const id of supertypes.keys()) walk(id, []);
+            const name = (id) => schema.entity(id)?.name ?? id;
+            return [...cycles.values()].map(cycle => ({
+                code: 'generalization-cycle', severity: 'warning', kind: 'entity', level, ids: cycle,
+                message: `Generalizations go round at the ${level} level: ${[...cycle, cycle[0]].map(name).join(' is a subtype of ')}`,
+            }));
+        });
+    }
+
+    /** Names that do not keep the model's naming standard (none: nothing to keep). */
+    naming() {
+        const standard = this.model.namingStandard;
+        if (!standard) return [];
+        return this.model.constructor.LEVELS.flatMap(level => this.model.level(level).entities.flatMap(e => {
+            const own = standard.check(level, 'entities', e.name);
+            const attributes = (e.attributes ?? []).map(a => [a, standard.check(level, 'attributes', a.name)]).filter(([, r]) => r.length);
+            return [
+                ...(own.length ? [this._entity(level, e, 'naming', 'info', `"${e.name}" ${own.join('; ')}`)] : []),
+                ...attributes.map(([a, reasons]) => this._entity(level, e, 'naming', 'info', `"${e.name}.${a.name}" ${reasons.join('; ')}`)),
+            ];
+        }));
     }
 
     /** The service domains (perspectives that own business objects). @private */

package/src/charting/datamodel/DataModelContext.js

@@ -7,14 +7,27 @@
  * meaning, scope and constraints.
  */
 export class DataModelContext {
+    /** The dimensions of data quality a rule may measure (DMBOK2's data quality). */
+    static QUALITY_DIMENSIONS = Object.freeze(['Completeness', 'Validity', 'Uniqueness', 'Timeliness', 'Accuracy', 'Consistency']);
+
+    /**
+     * A rule as it reads in a note or on hover: its dimension and the attribute
+     * it is on before its text ('Completeness of legal name: always given').
+     */
+    static ruleText(rule) {
+        const on = [rule.dimension, rule.attribute && (rule.dimension ? `of ${rule.attribute}` : rule.attribute)].filter(Boolean).join(' ');
+        return on ? `${on}: ${rule.text}` : rule.text;
+    }
+
     /**
      * @param {Object} spec
      * @param {string} spec.id
      * @param {string} [spec.name]
      * @param {string} [spec.description]
      * @param {Object<string, string>} [spec.meanings] - What an entity means here, by entity id
-     * @param {Array<{id?: string, text: string, applies?: string[], x?: number, y?: number}>} [spec.constraints]
-     *   Rules that hold here, each on the entities it `applies` to (drawn as notes attached to them)
+     * @param {Array<{id?: string, text: string, applies?: string[], dimension?: string, attribute?: string, x?: number, y?: number}>} [spec.constraints]
+     *   Rules that hold here, each on the entities it `applies` to (drawn as notes attached to them); a data quality
+     *   rule says which dimension it measures (QUALITY_DIMENSIONS) and may be on one attribute of what realises them
      * @param {string} [spec.jurisdiction]
      * @param {string} [spec.validFrom] - ISO date
      * @param {string} [spec.validTo] - ISO date
@@ -37,6 +50,15 @@ export class DataModelContext {
     }
 
     /** The rules that hold here on an entity. */
+    /** Forget a concept removed: what it means here, and the rules' hold on it (a rule on nothing else goes). */
+    forgetEntity(level, id) {
+        if (level !== 'conceptual') return;
+        delete this.meanings[id];
+        this.constraints = this.constraints
+            .filter(c => !(c.applies.length === 1 && c.applies[0] === id))
+            .map(c => ({ ...c, applies: c.applies.filter(a => a !== id) }));
+    }
+
     constraintsOn(entityId) {
         return this.constraints.filter(c => c.applies.includes(entityId));
     }
@@ -70,9 +92,15 @@ export class DataModelContext {
             ...concepts.map(c => ({ key: `meaning:${c.id}`, label: c.name, type: 'textarea', rows: 2, value: context?.meanings[c.id] ?? '', placeholder: 'as the schema describes it' })),
             { type: 'heading', label: 'Rules' },
             {
-                key: 'rules', label: '', type: 'textarea', rows: 5,
-                value: (context?.constraints ?? []).map(c => `${c.text} | ${c.applies.map(nameOf).join(', ')}`).join('\n'),
-                hint: 'One a line: the rule | the concepts it applies to (by name)',
+                key: 'rules', label: '', type: 'rows', addLabel: 'rule',
+                columns: [
+                    { key: 'text', label: 'Rule' },
+                    { key: 'applies', label: 'On concepts', placeholder: 'by name, commas between', suggestions: concepts.map(c => c.name), width: '160px' },
+                    { key: 'dimension', label: 'Quality dimension', type: 'select', choices: [['', '—'], ...DataModelContext.QUALITY_DIMENSIONS.map(d => [d, d])] },
+                    { key: 'attribute', label: 'Attribute', placeholder: 'legal name', width: '120px' },
+                ],
+                // Concepts shown by name, read back by name or id (specFrom).
+                value: (context?.constraints ?? []).map(c => ({ ...c, applies: c.applies.map(nameOf).join(', ') })),
             },
         ];
     }
@@ -85,11 +113,13 @@ export class DataModelContext {
         const concepts = model.concepts;
         const conceptOf = (word) => concepts.find(c => c.id === word || c.name.toLowerCase() === word.toLowerCase())?.id ?? null;
         const meanings = Object.fromEntries(concepts.map(c => [c.id, (values[`meaning:${c.id}`] ?? '').trim()]).filter(([, text]) => text));
-        const constraints = String(values.rules ?? '').split('\n').map(line => line.trim()).filter(Boolean).map(line => {
-            const [text, on = ''] = line.split('|').map(part => part.trim());
-            const applies = on.split(',').map(w => w.trim()).filter(Boolean).map(conceptOf).filter(Boolean);
-            const kept = context?.constraints.find(c => c.text === text);
-            return { text, applies, ...(kept && { id: kept.id, ...(Number.isFinite(kept.x) && { x: kept.x, y: kept.y }) }) };
+        const constraints = (values.rules ?? []).filter(r => String(r.text ?? '').trim()).map(r => {
+            const { text, applies = '', dimension, attribute, ...rest } = r;
+            return {
+                ...rest, text: String(text).trim(),
+                applies: String(applies).split(',').map(w => w.trim()).filter(Boolean).map(conceptOf).filter(Boolean),
+                ...(dimension && { dimension }), ...(attribute && { attribute: String(attribute).trim() }),
+            };
         });
         return {
             name: (values.name ?? '').trim(), description: (values.description ?? '').trim(),

package/src/charting/datamodel/DataModelEditCommand.js

@@ -0,0 +1,47 @@
+import { Command } from '../CommandHistory.js';
+
+/**
+ * DataModelEditCommand — one edit of a DataModel (an entity, an attribute, a
+ * relationship, a delete) as one undo step: run, it makes the change and keeps
+ * the model as it was before and after (DataModel#toJSON); undone or redone, it
+ * puts the model back as it was (DataModel#restore). Any change to a model is
+ * undoable this way, whatever it touches.
+ */
+export class DataModelEditCommand extends Command {
+    /** A model edit is no edit on one view: undoing it shows no other. */
+    viewId = null;
+
+    /**
+     * @param {DataModel} model
+     * @param {string} label - What the undo menu calls it ('Edit Customer')
+     * @param {(model: DataModel) => *} change - Makes the change
+     */
+    constructor(model, label, change) {
+        super(label);
+        this.model = model;
+        this.change = change;
+        this.before = null;
+        this.after = null;
+    }
+
+    execute() {
+        if (this.after) {
+            this.model.restore(this.after);
+        } else {
+            this.before = DataModelEditCommand.snapshot(this.model);
+            this.result = this.change(this.model);
+            this.after = DataModelEditCommand.snapshot(this.model);
+        }
+        this.model.edited();
+    }
+
+    undo() {
+        this.model.restore(this.before);
+        this.model.edited();
+    }
+
+    /** The model as it is, a copy nothing later changes (its toJSON shares some arrays). */
+    static snapshot(model) {
+        return JSON.parse(JSON.stringify(model.toJSON()));
+    }
+}

package/src/charting/datamodel/DataModelPerspective.js

@@ -67,11 +67,21 @@ export class DataModelPerspective {
         return [];
     }
 
-    /** How an entity it shows is marked at a level: `{ color?, details? }` (nothing here). */
-    decorate(entity, level) {
+    /** How an entity it shows is marked at a level (the model given): `{ color?, details? }` (nothing here). */
+    decorate(entity, level, model) {
         return {};
     }
 
+    /**
+     * Forget an entity removed from a level: at the conceptual level, the
+     * concepts it shows and the names it gives them.
+     */
+    forgetEntity(level, id) {
+        if (level !== 'conceptual') return;
+        if (this.entities) this.entities = this.entities.filter(e => e !== id);
+        delete this.names[id];
+    }
+
     /** The business objects (logical entities) it owns, as a BIAN service domain does (none here). */
     ownedEntities() {
         return [];

package/src/charting/datamodel/EnumerationType.js

@@ -1,51 +1,64 @@
-import { DataType } from './DataType.js';
-
-/**
- * EnumerationType — a data type whose values are a fixed list, each perhaps
- * with what it means (BIAN's `…typevalues`, a code list): `values` as
- * `[{ name, description? }]`. Drawn as a box with a row per value.
- */
-export class EnumerationType extends DataType {
-    static kind = 'enumeration';
-    static kindLabel = 'Enumeration';
-
-    /** @param {Object} spec - As DataType, plus `values: [{ name, description? }]` (or plain names) */
-    constructor({ values = [], ...spec } = {}) {
-        super(spec);
-        this.values = values.map(v => (typeof v === 'object' && v ? { name: String(v.name), ...(v.description && { description: v.description }) } : { name: String(v) }));
-    }
-
-    summary() {
-        const shown = this.values.slice(0, 6).map(v => v.name).join(', ');
-        return `${this.name}: one of ${shown}${this.values.length > 6 ? `, … (${this.values.length})` : ''}`;
-    }
-
-    rows() {
-        return this.values.map(v => ({ name: v.name }));
-    }
-
-    toJSON() {
-        return { ...super.toJSON(), values: this.values.map(v => ({ ...v })) };
-    }
-
-    /** A plain type's fields, then its values a line each: `name | what it means`. */
-    static fields(model, type = null) {
-        return [
-            ...DataType.fields(model, type),
-            {
-                key: 'values', label: 'Values', type: 'textarea', rows: 6,
-                value: (type?.values ?? []).map(v => (v.description ? `${v.name} | ${v.description}` : v.name)).join('\n'),
-                hint: 'One a line: value | what it means (optional)',
-            },
-        ];
-    }
-
-    static specFrom(values) {
-        return {
-            ...super.specFrom(values),
-            values: DataType.lines(values.values).map(([name, description]) => ({ name, ...(description && { description }) })),
-        };
-    }
-}
-
-DataType.register(EnumerationType);
+import { DataType } from './DataType.js';
+
+/**
+ * EnumerationType — a data type whose values are a fixed list, each perhaps
+ * with what it means (BIAN's `…typevalues`, a code list): `values` as
+ * `[{ name, description? }]`. As reference data (DMBOK2) a code set also says
+ * where it comes from (`source`: ISO 4217, a regulator, the bank), who keeps it
+ * (`owner`) and which version it is (`version`). Drawn as a box with a row per value.
+ */
+export class EnumerationType extends DataType {
+    static kind = 'enumeration';
+    static kindLabel = 'Enumeration';
+
+    /** @param {Object} spec - As DataType, plus `values: [{ name, description? }]` (or plain names) */
+    constructor({ values = [], source = '', owner = '', version = '', ...spec } = {}) {
+        super(spec);
+        Object.assign(this, { source, owner, version });
+        this.values = values.map(v => (typeof v === 'object' && v ? { name: String(v.name), ...(v.description && { description: v.description }) } : { name: String(v) }));
+    }
+
+    summary() {
+        const shown = this.values.slice(0, 6).map(v => v.name).join(', ');
+        return `${this.name}: one of ${shown}${this.values.length > 6 ? `, … (${this.values.length})` : ''}`;
+    }
+
+    rows() {
+        return this.values.map(v => ({ name: v.name }));
+    }
+
+    /** Where it comes from, who keeps it, which version: what is said of them (none: {}). */
+    get codeSet() {
+        return Object.fromEntries([['source', this.source], ['owner', this.owner], ['version', this.version]].filter(([, v]) => v));
+    }
+
+    toJSON() {
+        return { ...super.toJSON(), ...this.codeSet, values: this.values.map(v => ({ ...v })) };
+    }
+
+    /** A plain type's fields, then its values a line each: `name | what it means`. */
+    static fields(model, type = null) {
+        return [
+            ...DataType.fields(model, type),
+            { key: 'source', label: 'Source', type: 'text', value: type?.source ?? '', placeholder: 'ISO 4217, the regulator, the bank' },
+            { key: 'owner', label: 'Owner', type: 'text', value: type?.owner ?? '' },
+            { key: 'version', label: 'Version', type: 'text', value: type?.version ?? '' },
+            {
+                key: 'values', label: 'Values', type: 'textarea', rows: 6,
+                value: (type?.values ?? []).map(v => (v.description ? `${v.name} | ${v.description}` : v.name)).join('\n'),
+                hint: 'One a line: value | what it means (optional)',
+            },
+        ];
+    }
+
+    static specFrom(values) {
+        const said = (key) => String(values[key] ?? '').trim();
+        return {
+            ...super.specFrom(values),
+            ...Object.fromEntries(['source', 'owner', 'version'].map(k => [k, said(k)]).filter(([, v]) => v)),
+            values: DataType.lines(values.values).map(([name, description]) => ({ name, ...(description && { description }) })),
+        };
+    }
+}
+
+DataType.register(EnumerationType);

package/src/charting/datamodel/LevelSchema.js

@@ -27,6 +27,29 @@ export class LevelSchema {
         return this.entities.find(e => e.id === id) ?? null;
     }
 
+    /** An entity by id, else by name (any case), or null. */
+    named(text) {
+        const s = String(text ?? '').trim();
+        return this.entity(s) ?? this.entities.find(e => String(e.name ?? '').toLowerCase() === s.toLowerCase()) ?? null;
+    }
+
+    /**
+     * What a foreign key's `references` names: `{ entity, column }` (column
+     * null when it names the table alone), or null. `table` or `table.column`,
+     * the table by id or name; a table's own name may hold dots (a
+     * schema-qualified `sales.customer`), so the whole text is tried as a
+     * table first, then what is before its last dot, the rest its column.
+     */
+    resolveReference(ref) {
+        const text = String(ref ?? '').trim();
+        if (!text) return null;
+        const whole = this.named(text);
+        if (whole) return { entity: whole, column: null };
+        const dot = text.lastIndexOf('.');
+        const entity = dot > 0 ? this.named(text.slice(0, dot)) : null;
+        return entity ? { entity, column: text.slice(dot + 1).trim() || null } : null;
+    }
+
     /** Add an entity (its id unique at this level). */
     addEntity(entity) {
         if (!entity?.id) throw new TypeError('An entity needs an id');

package/src/charting/datamodel/ServiceDomain.js

@@ -69,6 +69,15 @@ export class ServiceDomain extends DataModelPerspective {
         });
     }
 
+    /** As a perspective, and at the logical level its control record, its qualifiers' entities and what it owns. */
+    forgetEntity(level, id) {
+        super.forgetEntity(level, id);
+        if (level !== 'logical') return;
+        if (this.controlRecord === id) this.controlRecord = null;
+        this.qualifiers = this.qualifiers.map(q => (q.entity === id ? (({ entity, ...rest }) => rest)(q) : q));
+        this.owns = this.owns.filter(e => e !== id);
+    }
+
     /** The business objects it owns: its control record, its qualifiers' entities, and those it names (`owns`). */
     ownedEntities() {
         return [...new Set([this.controlRecord, ...this.qualifiers.map(q => q.entity), ...this.owns].filter(Boolean))];