@peter.prib/renderengine 0.2.6 → 0.2.10

package/src/charting/datamodel/DataModelChecker.js

@@ -0,0 +1,338 @@
+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
+ * object (a logical entity) owned by one service domain, as BIAN has it
+ * (none, once there are service domains, is worth a look; more than one is
+ * 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; 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,
+            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 find = (ref) => {
+                const [name] = String(ref).split('.');
+                return schema.entity(name) ?? schema.entities.find(e => e.name.toLowerCase() === name.trim().toLowerCase()) ?? null;
+            };
+            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 = find(a.references);
+                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 */
+    _owners() {
+        return this.model.perspectives.filter(p => p.ownedEntities().length);
+    }
+
+    /** A business object owned by more than one service domain. */
+    ownedTwice() {
+        return this.model.level('logical').entities
+            .map(e => [e, this.model.ownersOf(e.id)])
+            .filter(([, owners]) => owners.length > 1)
+            .map(([e, owners]) => ({
+                code: 'owned-twice', severity: 'warning', kind: 'entity', level: 'logical', ids: [e.id],
+                message: `"${e.name}" is owned by ${owners.length} service domains (${owners.map(o => o.name).join(', ')}); BIAN gives a business object one`,
+            }));
+    }
+
+    /** A business object no service domain owns, once some own business objects. */
+    unowned() {
+        if (!this._owners().length) return [];
+        return this.model.level('logical').entities
+            .filter(e => !this.model.ownersOf(e.id).length)
+            .map(e => ({
+                code: 'unowned', severity: 'info', kind: 'entity', level: 'logical', ids: [e.id],
+                message: `"${e.name}" is owned by no service domain`,
+            }));
+    }
+
+    /** A service domain with no control record, a pattern BIAN lacks, or a qualifier that is no entity. */
+    serviceDomains() {
+        const logical = this.model.level('logical');
+        return this._serviceDomains().flatMap(sd => [
+            ...(!sd.controlRecord ? [{ code: 'no-control-record', severity: 'warning', message: `Service domain "${sd.name}" has no control record` }]
+                : !logical.entity(sd.controlRecord) ? [{ code: 'control-record-missing', severity: 'warning', message: `Service domain "${sd.name}": its control record "${sd.controlRecord}" is no logical entity` }]
+                    : []),
+            ...(!BianNotation.functionalPattern(sd.pattern) ? [{ code: 'unknown-pattern', severity: 'warning', message: `Service domain "${sd.name}": "${sd.pattern}" is no BIAN functional pattern` }] : []),
+            ...sd.qualifiers.filter(q => !q.entity || !logical.entity(q.entity)).map(q => ({
+                code: 'qualifier-entity-missing', severity: 'info', message: `Service domain "${sd.name}": behaviour qualifier "${q.name}" is no logical entity`,
+            })),
+        ].map(f => ({ ...f, kind: 'perspective', ids: [sd.id] })));
+    }
+
+    /** The service domains among the perspectives. @private */
+    _serviceDomains() {
+        return this.model.perspectives.filter(p => p.constructor.kind === 'service-domain');
+    }
+
+    /** An enumeration with no values or a value twice, two data types of one name, a data type nothing uses. */
+    dataTypes() {
+        const types = this.model.dataTypes;
+        const finding = (t, code, severity, message) => ({ code, severity, kind: 'data-type', ids: [t.id], message });
+        return types.flatMap(t => {
+            const values = (t.values ?? []).map(v => v.name);
+            const twice = [...new Set(values.filter((v, i) => values.indexOf(v) !== i))];
+            const sameName = types.filter(o => o !== t && o.name.toLowerCase() === t.name.toLowerCase());
+            const { attributes, types: users } = this.model.usesOf(t.id);
+            return [
+                ...(t.values && !values.length ? [finding(t, 'enumeration-empty', 'warning', `Enumeration "${t.name}" has no values`)] : []),
+                ...(twice.length ? [finding(t, 'value-twice', 'warning', `Enumeration "${t.name}" has ${twice.map(v => `"${v}"`).join(', ')} more than once`)] : []),
+                ...(sameName.length && types.indexOf(t) < types.indexOf(sameName[0]) ? [finding(t, 'type-name-twice', 'warning', `${sameName.length + 1} data types are called "${t.name}": an attribute naming it gets the first`)] : []),
+                ...(!attributes.length && !users.length ? [finding(t, 'type-unused', 'info', `Data type "${t.name}" is used by no attribute or other data type`)] : []),
+            ];
+        });
+    }
+
+    /** A mapping pair joining an entity that is not there. */
+    mappings() {
+        return this.model.mappings.flatMap(m => m.pairs
+            .filter(([a, b]) => !this.model.level(m.from).entity(a) || !this.model.level(m.to).entity(b))
+            .map(([a, b]) => ({
+                code: 'mapping-dangling', severity: 'warning', kind: 'mapping', ids: [`${m.from}:${a}->${m.to}:${b}`],
+                message: `A mapping from ${m.from} "${a}" to ${m.to} "${b}" joins an entity that is not there`,
+            })));
+    }
+}

package/src/charting/datamodel/DataModelCompared.js

@@ -0,0 +1,127 @@
+import { ComparedKind } from '../diagramModel/ComparedKind.js';
+
+/** A plain copy of JSON-shaped data. */
+const copy = (value) => (value === undefined ? undefined : JSON.parse(JSON.stringify(value)));
+
+/**
+ * The kinds two DataModels are compared on and merged by (ModelComparison,
+ * as for ArchiMate models): each level's entities and relationships, the
+ * mappings between levels, contexts and perspectives, in the order a merge
+ * brings them (what is needed first). Where a box sits is layout, not content:
+ * two models alike but for where their boxes are, are alike.
+ */
+
+/** A list of a model's held in an array (`list(model)`), each by an id; bring puts a copy in place or adds it. */
+class ListCompared extends ComparedKind {
+    constructor() {
+        super();
+        if (new.target === ListCompared) throw new TypeError('ListCompared is abstract — subclass it');
+    }
+
+    /** The array the model holds them in. @abstract */
+    list(model) { throw new Error(`${this.constructor.name} must implement list()`); }
+
+    items(model) { return this.list(model); }
+    get(model, id) { return this.items(model).find(item => this.idOf(item) === id) ?? null; }
+
+    /** Put a copy of `item` at its place (in place of the one with its id, else last); undone, as it was. */
+    bring(model, item) {
+        const list = this.list(model);
+        const twin = this.copyOf(item);
+        const at = list.findIndex(x => this.idOf(x) === this.idOf(item));
+        if (at < 0) {
+            list.push(twin);
+            return () => { const i = list.indexOf(twin); if (i >= 0) list.splice(i, 1); };
+        }
+        const old = list[at];
+        list[at] = twin;
+        return () => { const i = list.indexOf(twin); if (i >= 0) list[i] = old; };
+    }
+
+    /** A copy to put in the other model. */
+    copyOf(item) { return copy(item); }
+}
+
+/** One level's entities: compared on all but where they are drawn. */
+export class LevelEntitiesCompared extends ListCompared {
+    constructor(level) {
+        super();
+        this.level = level;
+    }
+
+    get key() { return `${this.level}-entity`; }
+    get label() { return `${this.level.charAt(0).toUpperCase()}${this.level.slice(1)} entities`; }
+    list(model) { return model.level(this.level).entities; }
+
+    content(entity) {
+        const { x, y, ...rest } = entity;
+        return copy(rest);
+    }
+}
+
+/**
+ * One level's relationships: known by their id, else by their ends and name
+ * (a relationship often has no id); each needs its two ends at that level.
+ */
+export class LevelRelationshipsCompared extends ListCompared {
+    constructor(level) {
+        super();
+        this.level = level;
+    }
+
+    get key() { return `${this.level}-relationship`; }
+    get label() { return `${this.level.charAt(0).toUpperCase()}${this.level.slice(1)} relationships`; }
+    list(model) { return model.level(this.level).relationships; }
+    idOf(r) { return r.id ?? `${r.source}->${r.target}${r.name ? `:${r.name}` : ''}`; }
+    nameOf(r) { return `${r.source} ${r.name || '→'} ${r.target}`; }
+    content(r) { return copy(r); }
+    requires(r) { return [[`${this.level}-entity`, r.source], [`${this.level}-entity`, r.target]]; }
+}
+
+/** The mappings between levels, a pair each: a pair needs its two entities. */
+export class MappingsCompared extends ComparedKind {
+    get key() { return 'mapping'; }
+    get label() { return 'Mappings'; }
+
+    items(model) {
+        return model.mappings.flatMap(m => m.pairs.map(([a, b]) => ({ id: `${m.from}:${a}->${m.to}:${b}`, from: m.from, to: m.to, a, b })));
+    }
+
+    nameOf(p) { return `${p.a} → ${p.b} (${p.from} to ${p.to})`; }
+    content() { return {}; }
+    requires(p) { return [[`${p.from}-entity`, p.a], [`${p.to}-entity`, p.b]]; }
+
+    bring(model, p) {
+        const mapping = model.mapping(p.from, p.to);
+        if (mapping.pairs.some(([a, b]) => a === p.a && b === p.b)) return () => {};
+        mapping.add(p.a, p.b);
+        return () => { mapping.pairs = mapping.pairs.filter(([a, b]) => !(a === p.a && b === p.b)); };
+    }
+}
+
+/** Perspectives and contexts are classes; their JSON is what counts, and a copy is one made from it. */
+class ModelPartsCompared extends ListCompared {
+    content(item) { return copy(item.toJSON()); }
+    copyOf(item) { return new item.constructor(copy(item.toJSON())); }
+}
+
+export class ContextsCompared extends ModelPartsCompared {
+    get key() { return 'context'; }
+    get label() { return 'Contexts'; }
+    list(model) { return model.contexts; }
+}
+
+/** Data types: an attribute names one by its id or name; a structure's fields others. */
+export class DataTypesCompared extends ModelPartsCompared {
+    get key() { return 'data-type'; }
+    get label() { return 'Data types'; }
+    list(model) { return model.dataTypes; }
+}
+
+/** A perspective needs the context it is read in. */
+export class PerspectivesCompared extends ModelPartsCompared {
+    get key() { return 'perspective'; }
+    get label() { return 'Perspectives'; }
+    list(model) { return model.perspectives; }
+    requires(p) { return p.context ? [['context', p.context]] : []; }
+}

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/DataModelFileFormat.js

@@ -0,0 +1,33 @@
+import { ModelFileFormat } from '../ModelFileFormat.js';
+import { DataModel } from './DataModel.js';
+
+/**
+ * DataModelFileFormat — a data model as a file (`.datamodel.json`): its name,
+ * its levels, the mappings between them, where its boxes and notes are, and
+ * its perspectives and contexts (DataModel#toJSON), read back by `new
+ * DataModel(json)`. The older one-entity form reads too.
+ */
+export class DataModelFileFormat extends ModelFileFormat {
+    get label() { return '.datamodel.json'; }
+    get accept() { return '.datamodel.json,.json'; }
+    get fileName() { return 'model.datamodel.json'; }
+    get featureName() { return 'DataModel'; }
+
+    /** JSON with a data model's shape: levels, or the older entities. */
+    recognizes(text) {
+        try {
+            const json = JSON.parse(text);
+            return !!json && typeof json === 'object' && (!!json.levels || Array.isArray(json.entities));
+        } catch {
+            return false;
+        }
+    }
+
+    export(model) {
+        return { data: JSON.stringify(model.toJSON(), null, 2), mimeType: 'application/json' };
+    }
+
+    import(text) {
+        return new DataModel(JSON.parse(text));
+    }
+}