@peter.prib/renderengine 0.2.6 → 0.2.10

package/src/charting/datamodel/DataModel.js

@@ -1,8 +1,24 @@
 import { DataModelPerspective } from './DataModelPerspective.js';
 import { DataModelContext } from './DataModelContext.js';
+import { DataType } from './DataType.js';
+import './EnumerationType.js';
+import './StructuredType.js';
 import { LevelSchema } from './LevelSchema.js';
 import { LevelMapping } from './LevelMapping.js';
 import { NodeGeometry } from '../diagrams/NodeGeometry.js';
+import { ModelComparison } from '../diagramModel/ModelComparison.js';
+import { DataModelChecker } from './DataModelChecker.js';
+import { CommandHistory } from '../CommandHistory.js';
+import { MergeModelCommand } from '../diagramModel/MergeModelCommand.js';
+import { DataModelEditCommand } from './DataModelEditCommand.js';
+import { DataModelNotation } from '../../datamodel.js';
+import { NamingStandard } from './naming/NamingStandard.js';
+import { ClassificationScheme } from './ClassificationScheme.js';
+import { ModelScorecard } from './scorecard/ModelScorecard.js';
+import { ServiceLandscape } from './ServiceLandscape.js';
+import {
+    LevelEntitiesCompared, LevelRelationshipsCompared, MappingsCompared, ContextsCompared, PerspectivesCompared, DataTypesCompared,
+} from './DataModelCompared.js';
 
 /** The levels, outermost first: each realised by the next. */
 const LEVELS = Object.freeze(['conceptual', 'logical', 'physical']);
@@ -21,6 +37,10 @@ const LEVELS = Object.freeze(['conceptual', 'logical', 'physical']);
  * The older form, one entity per thing with each level's detail on it
  * (`{ entities, relationships }`, as dataModelDiagram takes them), is read as
  * three levels mapped one to one.
+ *
+ * It knows whether it changed since it was saved (`edited()`, `markSaved()`,
+ * `isDirty()`, `onEdit(fn)`), as a ViewSetModel does, so a part can show it,
+ * keep it and ask before it is lost.
  */
 export class DataModel {
     /** The levels, outermost first. */
@@ -29,6 +49,57 @@ export class DataModel {
     /** The view of how the levels map (a `level` for view()). */
     static MAPPING = 'mapping';
 
+    /** The view of its service domains in their business areas and domains (a `level` for view()). */
+    static LANDSCAPE = 'landscape';
+
+    /** The view of its data types (a `level` for view()). */
+    static DATA_TYPES = 'datatypes';
+
+    /** The view of its star schemas (a `level` for view()). */
+    static STAR = 'star';
+
+    /** How far a star's dimensions sit from its fact, and how far apart stars are. */
+    static STAR_RADIUS = 300;
+    static STAR_SPACING = 820;
+
+    /** How many data type boxes side by side in the data types view, and how far apart. */
+    static DATA_TYPE_COLUMNS = 4;
+    static DATA_TYPE_SPACING = { x: 260, gap: 40 };
+
+    /**
+     * The views that are no level of the schema, each one way to read the
+     * whole model: its name (a `level` for view()), label and description,
+     * whether a model has it to show (`offered`), whether a box dragged in it
+     * keeps its place (`keepsPlaces`), and what it draws.
+     */
+    static OTHER_VIEWS = Object.freeze([
+        Object.freeze({
+            name: 'mapping', label: 'Mapping', description: 'The levels side by side, joined where one realises another',
+            offered: () => true, keepsPlaces: true,
+            view: (model, choice) => model.mappingView(choice),
+        }),
+        Object.freeze({
+            name: 'datatypes', label: 'Data types', description: 'Its data types: enumerations with their values, structures with their fields',
+            offered: (model) => model.dataTypes.length > 0, keepsPlaces: false,
+            view: (model) => model.dataTypesView(),
+        }),
+        Object.freeze({
+            name: 'star', label: 'Star schemas', description: 'Each fact with its dimensions around it (a dimensional scheme)',
+            offered: (model) => !!model.starLevel(), keepsPlaces: false,
+            view: (model) => model.starView(),
+        }),
+        Object.freeze({
+            name: 'landscape', label: 'Service landscape', description: 'The service domains in their business areas and business domains (BIAN)',
+            offered: (model) => model.serviceDomains().length > 0, keepsPlaces: false,
+            view: (model) => ServiceLandscape.view(model.serviceDomains()),
+        }),
+    ]);
+
+    /** One of OTHER_VIEWS by name, or null for a level of the schema. */
+    static otherView(name) {
+        return DataModel.OTHER_VIEWS.find(v => v.name === name) ?? null;
+    }
+
     /** The room between the mapping view's columns, and between the boxes in one. */
     static MAPPING_COLUMN = 380;
     static MAPPING_GAP = 40;
@@ -46,10 +117,20 @@ export class DataModel {
      *   (the conceptual level's is the rule's own x, y)
      * @param {Array<Object|DataModelPerspective>} [spec.perspectives]
      * @param {Array<Object|DataModelContext>} [spec.contexts]
+     * @param {Array<Object|DataType>} [spec.dataTypes] - Its data types (DataType and its kinds)
+     * @param {Object|NamingStandard|null} [spec.namingStandard] - How its names are written (none: no standard)
+     * @param {Object|ClassificationScheme} [spec.classificationScheme] - How its data is classified (the default if none)
+     * @param {{weights?: Object, reviews?: Object}} [spec.scorecard] - Its reviewer's scores and weights (ModelScorecard)
      * @param {Array<Object>} [spec.entities] - The older, one-entity form (levelsFromCombined)
      * @param {Array<Object>} [spec.relationships]
+     * @param {string} [spec.name] - What the model is called
      */
     constructor(spec = {}) {
+        /** What the model is called. */
+        this.name = spec.name ?? '';
+        this._version = 0;
+        this._saved = 0;
+        this._editListeners = [];
         const { levels, mappings = [], mappingLayout = {}, noteLayout = {} } = spec.levels ? spec : DataModel.levelsFromCombined(spec);
         this.levels = Object.fromEntries(LEVELS.map(level => [level, new LevelSchema(level, levels?.[level] ?? {})]));
         this.mappings = LEVELS.slice(1).map((to, i) => {
@@ -59,8 +140,28 @@ export class DataModel {
         });
         this.mappingLayout = { ...mappingLayout };
         this.noteLayout = Object.fromEntries(Object.entries(noteLayout).map(([level, at]) => [level, { ...at }]));
-        this.perspectives = (spec.perspectives ?? []).map(p => (p instanceof DataModelPerspective ? p : new DataModelPerspective(p)));
+        this.perspectives = (spec.perspectives ?? []).map(p => (p instanceof DataModelPerspective ? p : DataModelPerspective.from(p)));
         this.contexts = (spec.contexts ?? []).map(c => (c instanceof DataModelContext ? c : new DataModelContext(c)));
+        /** Its data types: the types attributes name (`attribute.type`, a data type's id or name). */
+        this.dataTypes = (spec.dataTypes ?? []).map(t => (t instanceof DataType ? t : DataType.from(t)));
+        /** How its names are written (NamingStandard), or null: no standard, nothing checked. */
+        this.namingStandard = spec.namingStandard ? (spec.namingStandard instanceof NamingStandard ? spec.namingStandard : new NamingStandard(spec.namingStandard)) : null;
+        /** How its data is classified (ClassificationScheme): the default unless it keeps its own. */
+        this.classificationScheme = spec.classificationScheme instanceof ClassificationScheme ? spec.classificationScheme : new ClassificationScheme(spec.classificationScheme ?? {});
+        /** What a reviewer said on the Scorecard, and the weights reviewed by (ModelScorecard), or null. */
+        this.scorecard = spec.scorecard ? JSON.parse(JSON.stringify(spec.scorecard)) : null;
+    }
+
+    /** The model scored on the Data Model Scorecard (ModelScorecard). */
+    scored() {
+        return new ModelScorecard(this);
+    }
+
+    /** Keep a reviewer's scores and the weights (ModelScorecard.specFrom's), as one undo step. */
+    scorecardCommand(spec) {
+        return this.editCommand('Score the model', (model) => {
+            model.scorecard = spec && Object.keys(spec).length ? JSON.parse(JSON.stringify(spec)) : null;
+        });
     }
 
     /**
@@ -85,6 +186,64 @@ export class DataModel {
         return { levels, mappings: [oneToOne('conceptual', 'logical'), oneToOne('logical', 'physical')] };
     }
 
+    // ===== Compared and merged =====
+
+    /**
+     * What two data models are compared on and merged by, what is needed first:
+     * each level's entities, then each level's relationships, the mappings,
+     * contexts and perspectives.
+     */
+    comparedKinds() {
+        return [
+            ...LEVELS.map(level => new LevelEntitiesCompared(level)),
+            ...LEVELS.map(level => new LevelRelationshipsCompared(level)),
+            new MappingsCompared(),
+            new ContextsCompared(),
+            new DataTypesCompared(),
+            new PerspectivesCompared(),
+        ];
+    }
+
+    /** How this model differs from another (ModelComparison), which can merge the other's into it. */
+    compareWith(other) {
+        return new ModelComparison(this, other);
+    }
+
+    /** Its undo history: a merge is one step on it. */
+    get history() {
+        return (this._history ??= new CommandHistory());
+    }
+
+    // ===== Changed since saved =====
+
+    /** Something changed (a perspective or context, a box or note moved): listeners hear of it. */
+    edited() {
+        this._version++;
+        this._emitEdit();
+    }
+
+    /** This state is the saved one (a file opened or saved). */
+    markSaved() {
+        this._saved = this._version;
+        this._emitEdit();
+    }
+
+    /** Whether it changed since markSaved. */
+    isDirty() {
+        return this._version !== this._saved;
+    }
+
+    /** Call `fn(model)` after every change (and markSaved). Returns an unsubscribe function. */
+    onEdit(fn) {
+        this._editListeners.push(fn);
+        return () => { this._editListeners = this._editListeners.filter(l => l !== fn); };
+    }
+
+    /** @private */
+    _emitEdit() {
+        for (const fn of this._editListeners) fn(this);
+    }
+
     /** A level's schema (LevelSchema). */
     level(name) {
         const schema = this.levels[name];
@@ -123,6 +282,47 @@ export class DataModel {
         return [...ids];
     }
 
+    /**
+     * An entity's lineage across the levels: what it realises (`up`, level by
+     * level to the concepts) and what realises it (`down`, to the tables), each
+     * `{ level, entity }`, as the mappings say, any number either way.
+     */
+    lineage(level, id) {
+        const at = LEVELS.indexOf(level);
+        const walk = (from, step) => {
+            const out = [];
+            let ids = [id];
+            for (let i = from; i >= 0 && i < LEVELS.length; i += step) {
+                const [a, b] = step < 0 ? [LEVELS[i], LEVELS[i + 1]] : [LEVELS[i - 1], LEVELS[i]];
+                const mapping = this.mapping(a, b);
+                ids = [...new Set(ids.flatMap(x => (step < 0 ? mapping.sourcesOf(x) : mapping.targetsOf(x))))];
+                out.push(...ids.map(x => ({ level: LEVELS[i], entity: this.level(LEVELS[i]).entity(x) })).filter(e => e.entity));
+            }
+            return out;
+        };
+        return { up: walk(at - 1, -1), down: walk(at + 1, 1) };
+    }
+
+    /** Lineage in words, for a hover: 'Party (conceptual) → Person (logical)'. */
+    lineageText(level, id) {
+        const { up, down } = this.lineage(level, id);
+        const name = ({ level: l, entity }) => `${entity.name} (${l})`;
+        return {
+            ...(up.length && { realises: up.map(name).join(', ') }),
+            ...(down.length && { 'realised by': down.map(name).join(', ') }),
+        };
+    }
+
+    /** The perspectives (service domains) that own a business object (a logical entity). */
+    ownersOf(entityId) {
+        return this.perspectives.filter(p => p.ownedEntities().includes(entityId));
+    }
+
+    /** The checks this model is held to (DataModelChecker): ownership, service domains, mappings. */
+    checker() {
+        return new DataModelChecker(this);
+    }
+
     /** A perspective by id, or null (the whole schema). */
     perspective(id) {
         return this.perspectives.find(p => p.id === id) ?? null;
@@ -148,11 +348,14 @@ export class DataModel {
      * @returns {{entities, relationships, annotations, links}}
      */
     view({ perspective = null, context = null, level = 'conceptual' } = {}) {
-        if (level === DataModel.MAPPING) return this.mappingView({ perspective, context });
+        const other = DataModel.otherView(level);
+        if (other) return other.view(this, { perspective, context });
         const lens = this.perspective(perspective);
         const meaning = this.context(context);
         const schema = this.level(level);
         const allowed = this.realising(level, lens ? this.concepts.filter(c => lens.shows(c.id)).map(c => c.id) : null);
+        // A kind of perspective may show more at a level (a service domain: its control record and qualifiers).
+        for (const id of lens?.alsoShows(level) ?? []) allowed?.add(id);
         const shown = schema.entities.filter(e => !allowed || allowed.has(e.id));
         const ids = new Set(shown.map(e => e.id));
         const conceptName = (id) => {
@@ -163,32 +366,47 @@ export class DataModel {
             const concepts = this.conceptsOf(level, entity.id);
             const name = level === 'conceptual' && lens ? lens.nameOf(entity) : entity.name;
             const meanings = meaning ? concepts.map(c => meaning.meaningOf(c)).filter(Boolean) : [];
-            const rules = meaning ? [...new Set(concepts.flatMap(c => meaning.constraintsOn(c).map(r => r.text)))] : [];
+            const rules = meaning ? [...new Set(concepts.flatMap(c => meaning.constraintsOn(c).map(r => DataModelContext.ruleText(r))))] : [];
+            const owners = level === 'logical' ? this.ownersOf(entity.id).map(o => o.name) : [];
+            const typed = this.typedAttributes(entity);
+            const iso = this.iso20022Of(entity);
+            const classified = ClassificationScheme.describe(this.classificationScheme.effective(entity));
             const details = {
                 ...entity.details,
+                ...(owners.length && { 'owned by': owners.join(', ') }),
+                ...Object.fromEntries(Object.entries(entity.stewardship ?? {}).filter(([, v]) => v)),
+                ...(classified && { classification: classified }),
+                ...DataModelNotation.entityRole(entity).details(entity),
+                ...this.lineageText(level, entity.id),
+                ...(typed.length && { 'data types': typed.map(({ attribute, type }) => `${attribute.name}: ${type.summary()}`) }),
+                ...(iso.length && { 'ISO 20022': iso }),
                 ...(name !== entity.name && { schema: entity.name }),
                 ...(level !== 'conceptual' && concepts.length && { concepts: concepts.map(conceptName).join(', ') }),
                 ...(meaning && { context: meaning.name }),
                 ...(rules.length && { rules }),
             };
             const { attributes, ...rest } = entity;
+            const mark = lens?.decorate(entity, level, this) ?? {};
+            const allDetails = { ...details, ...mark.details };
             return {
                 ...rest,
                 name,
+                ...(mark.color && { color: mark.color }),
                 description: meanings.length ? meanings.join(' ') : entity.description,
                 ...(level !== 'conceptual' && { [level]: { attributes: attributes ?? [], ...(level === 'physical' && { tableName: entity.name }) } }),
-                ...(Object.keys(details).length && { details }),
+                ...(Object.keys(allDetails).length && { details: allDetails }),
             };
         });
         const relationships = schema.relationships
             .filter(r => ids.has(r.source) && ids.has(r.target))
             .map(r => (lens && level === 'conceptual' ? { ...r, name: lens.relationshipNameOf(r) } : r));
-        const notes = (meaning?.constraints ?? [])
-            .map(c => {
+        const notes = [
+            ...(meaning?.constraints ?? []).map(c => {
                 const on = this.realising(level, c.applies) ?? new Set(c.applies);
-                return { id: c.id, text: c.text, attachTo: [...on].filter(id => ids.has(id)), ...this.notePlace(level, c) };
-            })
-            .filter(a => a.attachTo.length);
+                return { id: c.id, text: DataModelContext.ruleText(c), attachTo: [...on].filter(id => ids.has(id)), ...this.notePlace(level, c) };
+            }),
+            ...(lens?.notes(level) ?? []).map(n => ({ ...n, attachTo: n.attachTo.filter(id => ids.has(id)), ...this.notePlace(level, n) })),
+        ].filter(a => a.attachTo.length);
         // A note with no place on this level goes in a row below every box, so it covers none.
         const below = Math.max(0, ...shown.map(e => (Number.isFinite(e.y) ? e.y : 0))) + DataModel.NOTE_ROW;
         let free = 0;
@@ -241,10 +459,342 @@ export class DataModel {
 
     // ===== Perspectives and contexts of one's own =====
 
+    // ===== Editing what a level holds (each a DataModelEditCommand: one undo step) =====
+
+    /** Put the model back as a snapshot says (DataModelEditCommand): its levels, mappings, layout, perspectives, contexts, data types. */
+    restore(json) {
+        const back = new DataModel(JSON.parse(JSON.stringify(json)));
+        for (const key of ['name', 'levels', 'mappings', 'mappingLayout', 'noteLayout', 'perspectives', 'contexts', 'dataTypes', 'namingStandard', 'classificationScheme', 'scorecard']) this[key] = back[key];
+    }
+
+    /** Set how its data is classified (a ClassificationScheme spec), as one undo step. */
+    classificationSchemeCommand(spec) {
+        return this.editCommand('Set the classification scheme', (model) => {
+            model.classificationScheme = new ClassificationScheme(spec);
+        });
+    }
+
+    /** Set how its names are written (a NamingStandard spec; null: none), as one undo step. */
+    namingStandardCommand(spec) {
+        return this.editCommand(spec ? 'Set the naming standard' : 'Remove the naming standard', (model) => {
+            model.namingStandard = spec ? new NamingStandard(spec) : null;
+        });
+    }
+
+    /** A change made as one undo step. */
+    editCommand(label, change) {
+        return new DataModelEditCommand(this, label, change);
+    }
+
+    /**
+     * Add an entity at a level (`id` null: one made from its name) or change
+     * one (what the spec leaves out, where it is drawn among it, kept).
+     * The command's `result` is the entity.
+     */
+    saveEntityCommand(level, id, spec) {
+        const noun = DataModelNotation.level(level)?.entityNoun ?? 'entity';
+        return this.editCommand(id ? `Edit ${spec.name || id}` : `New ${noun.toLowerCase()} ${spec.name ?? ''}`.trim(), (model) => {
+            const schema = model.level(level);
+            if (!id) return schema.addEntity({ ...spec, id: spec.id ?? model._freshId(spec.name || noun, schema.entities) });
+            const i = schema.entities.findIndex(e => e.id === id);
+            const { x, y } = schema.entities[i];
+            schema.entities[i] = { x, y, ...spec, id };
+            return schema.entities[i];
+        });
+    }
+
+    /**
+     * Remove an entity from a level, with what refers to it: its
+     * relationships, its mapping pairs, and what perspectives and contexts
+     * say of it (each forgets it: forgetEntity).
+     */
+    removeEntityCommand(level, id) {
+        const name = this.level(level).entity(id)?.name ?? id;
+        return this.editCommand(`Delete ${name}`, (model) => {
+            const schema = model.level(level);
+            schema.entities = schema.entities.filter(e => e.id !== id);
+            schema.relationships = schema.relationships.filter(r => r.source !== id && r.target !== id);
+            for (const m of model.mappings) {
+                m.pairs = m.pairs.filter(([a, b]) => !(m.from === level && a === id) && !(m.to === level && b === id));
+            }
+            for (const holder of [...model.perspectives, ...model.contexts]) holder.forgetEntity(level, id);
+        });
+    }
+
+    /**
+     * Which of a level's relationships something drawn is (a line, or a
+     * Chen diamond), by its id, the id a diamond is given, else its ends and
+     * name; -1 for none.
+     */
+    relationshipIndex(level, drawn) {
+        const rels = this.level(level).relationships;
+        const diamond = (r, i) => r.id || `${r.source}__${r.target}__rel${i}`;
+        const byId = rels.findIndex((r, i) => drawn?.id && (r.id === drawn.id || diamond(r, i) === drawn.id));
+        if (byId >= 0) return byId;
+        // A line to or from a Chen diamond is its relationship's.
+        const ends = [drawn?.source, drawn?.target];
+        const toDiamond = rels.findIndex((r, i) => ends.includes(diamond(r, i)));
+        if (toDiamond >= 0) return toDiamond;
+        return rels.findIndex(r => r.source === drawn?.source && r.target === drawn?.target && (r.name ?? '') === (drawn?.name ?? r.name ?? ''));
+    }
+
+    /** Add a relationship at a level (`index` null) or change the one at `index`. The command's `result` is it. */
+    saveRelationshipCommand(level, index, spec) {
+        return this.editCommand(index == null ? `New relationship ${spec.name ?? ''}`.trim() : `Edit relationship ${spec.name ?? ''}`.trim(), (model) => {
+            const rels = model.level(level).relationships;
+            if (index == null) {
+                const relationship = { id: spec.id ?? model._freshId(`${spec.source}-${spec.target}`, rels), ...spec };
+                rels.push(relationship);
+                return relationship;
+            }
+            rels[index] = { ...spec };
+            return rels[index];
+        });
+    }
+
+    removeRelationshipCommand(level, index) {
+        const r = this.level(level).relationships[index];
+        return this.editCommand(`Delete relationship ${r?.name ?? ''}`.trim(), (model) => {
+            model.level(level).relationships.splice(index, 1);
+        });
+    }
+
+    // ===== Data types =====
+
+    /** A data type by its id, else its name (any case), or null. */
+    dataType(ref) {
+        if (!ref) return null;
+        const name = String(ref).toLowerCase();
+        return this.dataTypes.find(t => t.id === ref) ?? this.dataTypes.find(t => t.name.toLowerCase() === name) ?? null;
+    }
+
+    /** An attribute's data type (its `type` naming one), or null for a plain type ('VARCHAR(20)'). */
+    typeOf(attribute) {
+        return this.dataType(attribute?.type);
+    }
+
+    /** An entity's attributes that have a data type: `[{ attribute, type }]`. */
+    typedAttributes(entity) {
+        return (entity.attributes ?? []).map(attribute => ({ attribute, type: this.typeOf(attribute) })).filter(a => a.type);
+    }
+
+    /**
+     * What an entity says of ISO 20022, a line each: its own type, then each
+     * attribute's (its own `iso20022`, else its data type's).
+     */
+    iso20022Of(entity) {
+        return [
+            ...(entity.iso20022 ? [`${entity.name}: ${entity.iso20022}`] : []),
+            ...(entity.attributes ?? []).map(a => [a.name, a.iso20022 || this.typeOf(a)?.iso20022]).filter(([, t]) => t).map(([n, t]) => `${n}: ${t}`),
+        ];
+    }
+
+    /** Where a data type is used: `{ attributes: [{ level, entity, attribute }], types: [DataType] }`. */
+    usesOf(id) {
+        const type = this.dataType(id);
+        if (!type) return { attributes: [], types: [] };
+        const names = (ref) => this.dataType(ref) === type;
+        return {
+            attributes: LEVELS.flatMap(level => this.level(level).entities.flatMap(entity => (entity.attributes ?? [])
+                .filter(a => names(a.type)).map(attribute => ({ level, entity, attribute })))),
+            types: this.dataTypes.filter(t => t !== type && t.uses().some(names)),
+        };
+    }
+
+    /** Add a data type (a DataType spec, its `kind` saying which; an id is made from its name when it has none). */
+    addDataType(spec) {
+        const type = DataType.from({ ...spec, id: spec.id ?? this._freshId(spec.name, this.dataTypes) });
+        this.dataTypes.push(type);
+        this.edited();
+        return type;
+    }
+
+    /** Change a data type (its id and kind stay). */
+    updateDataType(id, spec) {
+        const i = this.dataTypes.findIndex(t => t.id === id);
+        if (i < 0) return null;
+        this.dataTypes[i] = DataType.from({ ...spec, kind: this.dataTypes[i].constructor.kind, id });
+        this.edited();
+        return this.dataTypes[i];
+    }
+
+    removeDataType(id) {
+        this.dataTypes = this.dataTypes.filter(t => t.id !== id);
+        this.edited();
+    }
+
+    /**
+     * The data types view: each a box with a row per value or field (as a
+     * table), enumerations and structures coloured apart, in a grid; a link
+     * from a structure to each data type its fields are.
+     */
+    dataTypesView() {
+        const { x: across, gap } = DataModel.DATA_TYPE_SPACING;
+        const columns = DataModel.DATA_TYPE_COLUMNS;
+        const color = { enumeration: '#fef3c7', structure: '#e0f2fe', type: '#f3f4f6' };
+        const heights = this.dataTypes.map(t => DataModel.boxHeight('datatypes', { datatypes: { attributes: t.rows() } }));
+        const tops = [];
+        this.dataTypes.forEach((t, i) => {
+            const above = i - columns;
+            tops.push(above < 0 ? 60 : tops[above] + heights[above] + gap);
+        });
+        const entities = this.dataTypes.map((t, i) => ({
+            id: `type:${t.id}`, name: `${t.constructor === DataType ? '' : `«${t.constructor.kindLabel.toLowerCase()}» `}${t.name}`,
+            level: 'datatypes', datatypes: { attributes: t.rows().length ? t.rows() : [{ name: t.basedOn || '—' }] },
+            x: 140 + (i % columns) * across, y: tops[i] + heights[i] / 2,
+            color: color[t.constructor.kind] ?? color.type,
+            description: t.description,
+            details: { kind: t.constructor.kindLabel, ...t.codeSet, ...(t.iso20022 && { 'ISO 20022': t.iso20022 }), used: this._usedSummary(t) },
+        }));
+        const links = this.dataTypes.flatMap(t => [...new Set(t.uses().map(ref => this.dataType(ref)).filter(u => u && u !== t))]
+            .map(u => ({ id: `uses:${t.id}->${u.id}`, source: `type:${t.id}`, target: `type:${u.id}` })));
+        return { entities, relationships: [], annotations: [], links, notation: 'crowsfoot' };
+    }
+
+    /** Where a data type is used, in a few words. @private */
+    _usedSummary(type) {
+        const { attributes, types } = this.usesOf(type.id);
+        const parts = [
+            ...(attributes.length ? [`${attributes.length} attribute${attributes.length === 1 ? '' : 's'}`] : []),
+            ...(types.length ? [`by ${types.map(t => t.name).join(', ')}`] : []),
+        ];
+        return parts.join('; ') || 'nowhere';
+    }
+
+    /** The level its dimensional scheme is at: the physical if it has a fact there, else the logical, else null. */
+    starLevel() {
+        return ['physical', 'logical'].find(level => this.level(level).entities.some(e => DataModelNotation.entityRole(e).role === 'fact')) ?? null;
+    }
+
+    /**
+     * The star view: at the level with facts (starLevel), each fact in a row
+     * of stars with the dimensions it is related to around it, a dimension two
+     * share drawn once, by the first; facts and dimensions in their role's
+     * colour, as tables, with the relationships between them.
+     */
+    starView() {
+        const level = this.starLevel();
+        if (!level) return { entities: [], relationships: [], annotations: [], links: [] };
+        const schema = this.level(level);
+        const roleOf = (e) => DataModelNotation.entityRole(e);
+        const facts = schema.entities.filter(e => roleOf(e).role === 'fact');
+        const placed = new Map();
+        facts.forEach((fact, i) => {
+            const centre = { x: 400 + i * DataModel.STAR_SPACING, y: 420 };
+            placed.set(fact.id, centre);
+            const dims = schema.relationships
+                .filter(r => r.source === fact.id || r.target === fact.id)
+                .map(r => schema.entity(r.source === fact.id ? r.target : r.source))
+                .filter(d => d && roleOf(d).role === 'dimension' && !placed.has(d.id));
+            dims.forEach((d, k) => {
+                const angle = -Math.PI / 2 + (2 * Math.PI * k) / Math.max(dims.length, 1);
+                placed.set(d.id, { x: Math.round(centre.x + DataModel.STAR_RADIUS * Math.cos(angle)), y: Math.round(centre.y + DataModel.STAR_RADIUS * Math.sin(angle)) });
+            });
+        });
+        const base = this.view({ level });
+        const entities = base.entities.filter(e => placed.has(e.id)).map(e => ({ ...e, ...placed.get(e.id), color: roleOf(e).color ?? e.color }));
+        const shown = new Set(entities.map(e => e.id));
+        return {
+            entities, relationships: base.relationships.filter(r => shown.has(r.source) && shown.has(r.target)),
+            annotations: [], links: [], level, notation: 'crowsfoot',
+        };
+    }
+
+    /** Its service domains (the perspectives that are ServiceDomains). */
+    serviceDomains() {
+        return this.perspectives.filter(p => p.constructor.kind === 'service-domain');
+    }
+
+    /**
+     * Service domains read from elsewhere (BianLandscapeReader), as one undo
+     * step (bringCommand). Null when there is nothing to bring.
+     * @param {Array<Object>} specs - ServiceDomain specs
+     * @param {string} [source] - Where they were read from, for the undo label
+     * @returns {MergeModelCommand|null}
+     */
+    serviceDomainsCommand(specs, source = 'a service landscape') {
+        return this.bringCommand({ serviceDomains: specs },
+            `Read ${specs.length} service domain${specs.length === 1 ? '' : 's'} from ${source}`);
+    }
+
+    /**
+     * Things read from elsewhere (a BIAN landscape, a BIAN semantic API)
+     * brought in as one undo step (a MergeModelCommand). A logical entity
+     * already here (by id, else by name) stays as it is, and what was read
+     * refers to it; so does a data type already here by name. Only the data
+     * types what is brought needs come (those its new entities' attributes
+     * are, and theirs in turn). A service domain already here (by id, else by
+     * name) keeps all it has, taking its business area and domain from what
+     * was read, its asset, pattern and control record where it has none, and
+     * the behaviour qualifiers it lacks (by name or entity); one that would
+     * come out the same is left alone. Null when there is nothing to bring.
+     * @param {Object} read
+     * @param {Array<Object>} [read.entities] - Logical entities
+     * @param {Array<Object>} [read.relationships] - Logical relationships between them
+     * @param {Array<Object>} [read.dataTypes] - DataType specs
+     * @param {Array<Object>} [read.serviceDomains] - ServiceDomain specs
+     * @param {string} label - The undo label
+     * @returns {MergeModelCommand|null}
+     */
+    bringCommand({ entities = [], relationships = [], dataTypes = [], serviceDomains = [] }, label) {
+        const logical = this.level('logical');
+        const sameName = (list, name) => list.find(x => String(x.name).toLowerCase() === String(name).toLowerCase());
+        // What was read refers to an entity already here by that one's id.
+        const idHere = new Map(entities.map(e => [e.id, (logical.entity(e.id) ?? sameName(logical.entities, e.name))?.id ?? null]));
+        const as = (id) => idHere.get(id) ?? id;
+        const newEntities = entities.filter(e => !idHere.get(e.id));
+        const newRelationships = relationships.map(r => ({ ...r, source: as(r.source), target: as(r.target) }))
+            .filter(r => !logical.relationships.some(h => h.source === r.source && h.target === r.target && (h.name ?? '') === (r.name ?? '')));
+        // The data types the new entities need, then the ones those need; none already here by id or name.
+        const readType = (ref) => dataTypes.find(t => t.id === ref) ?? sameName(dataTypes, ref);
+        const needed = new Set();
+        const need = (ref) => {
+            const t = readType(ref);
+            if (!t || needed.has(t) || this.dataType(t.id) || sameName(this.dataTypes, t.name)) return;
+            needed.add(t);
+            DataType.from(t).uses().forEach(need);
+        };
+        newEntities.flatMap(e => e.attributes ?? []).forEach(a => need(a.type));
+        const newTypes = dataTypes.filter(t => needed.has(t));
+        const domains = serviceDomains.map(spec => {
+            const read = { ...spec, controlRecord: spec.controlRecord ? as(spec.controlRecord) : spec.controlRecord, qualifiers: (spec.qualifiers ?? []).map(q => ({ ...q, ...(q.entity && { entity: as(q.entity) }) })) };
+            const here = this.perspective(read.id) ?? this.perspectives.find(p => p.name.toLowerCase() === String(read.name).toLowerCase());
+            if (!here) return read;
+            const kept = here.toJSON();
+            return {
+                ...kept, kind: read.kind,
+                businessArea: read.businessArea || kept.businessArea || '', businessDomain: read.businessDomain || kept.businessDomain || '',
+                asset: kept.asset || read.asset || '', pattern: here.functionalPattern ? kept.pattern : (read.pattern || kept.pattern || ''),
+                controlRecord: kept.controlRecord || read.controlRecord || null,
+                qualifiers: [...kept.qualifiers, ...read.qualifiers.filter(q => !kept.qualifiers.some(k =>
+                    k.name.toLowerCase() === String(q.name).toLowerCase() || (q.entity && k.entity === q.entity)))],
+            };
+        }).filter(spec => {
+            // One here that would come out the same is nothing to bring.
+            const here = this.perspective(spec.id);
+            return !here || JSON.stringify(DataModelPerspective.from(spec).toJSON()) !== JSON.stringify(here.toJSON());
+        });
+        if (!newEntities.length && !newRelationships.length && !newTypes.length && !domains.length) return null;
+        const from = new DataModel({
+            name: label,
+            levels: { logical: { entities: newEntities, relationships: newRelationships } },
+            dataTypes: newTypes, perspectives: domains,
+        });
+        const kinds = new Map(this.comparedKinds().map(k => [k.key, k]));
+        const steps = [
+            ...from.level('logical').entities.map(item => ({ kind: kinds.get('logical-entity'), item })),
+            ...from.level('logical').relationships.map(item => ({ kind: kinds.get('logical-relationship'), item })),
+            ...from.dataTypes.map(item => ({ kind: kinds.get('data-type'), item })),
+            ...from.perspectives.map(item => ({ kind: kinds.get('perspective'), item })),
+        ];
+        return new MergeModelCommand(this, from, steps, label);
+    }
+
     /** Add a perspective (DataModelPerspective spec; an id is made from its name when it has none). */
     addPerspective(spec) {
-        const perspective = new DataModelPerspective({ ...spec, id: spec.id ?? this._freshId(spec.name, this.perspectives) });
+        const perspective = DataModelPerspective.from({ ...spec, id: spec.id ?? this._freshId(spec.name, this.perspectives) });
         this.perspectives.push(perspective);
+        this.edited();
         return perspective;
     }
 
@@ -252,17 +802,21 @@ export class DataModel {
     updatePerspective(id, spec) {
         const i = this.perspectives.findIndex(p => p.id === id);
         if (i < 0) return null;
-        return (this.perspectives[i] = new DataModelPerspective({ ...spec, id }));
+        this.perspectives[i] = DataModelPerspective.from({ kind: this.perspectives[i].constructor.kind, ...spec, id });
+        this.edited();
+        return this.perspectives[i];
     }
 
     removePerspective(id) {
         this.perspectives = this.perspectives.filter(p => p.id !== id);
+        this.edited();
     }
 
     /** Add a context (DataModelContext spec; an id is made from its name when it has none). */
     addContext(spec) {
         const context = new DataModelContext({ ...spec, id: spec.id ?? this._freshId(spec.name, this.contexts) });
         this.contexts.push(context);
+        this.edited();
         return context;
     }
 
@@ -270,13 +824,16 @@ export class DataModel {
     updateContext(id, spec) {
         const i = this.contexts.findIndex(c => c.id === id);
         if (i < 0) return null;
-        return (this.contexts[i] = new DataModelContext({ ...spec, id }));
+        this.contexts[i] = new DataModelContext({ ...spec, id });
+        this.edited();
+        return this.contexts[i];
     }
 
     /** Remove a context; a perspective read in it is then read in none. */
     removeContext(id) {
         this.contexts = this.contexts.filter(c => c.id !== id);
         for (const p of this.perspectives) if (p.context === id) p.context = null;
+        this.edited();
     }
 
     /** An id from a name, not yet among `taken`. @private */
@@ -289,11 +846,16 @@ export class DataModel {
 
     toJSON() {
         return {
+            name: this.name,
             levels: Object.fromEntries(LEVELS.map(level => [level, this.level(level).toJSON()])),
             mappings: this.mappings.map(m => m.toJSON()),
             mappingLayout: { ...this.mappingLayout },
             noteLayout: Object.fromEntries(Object.entries(this.noteLayout).map(([level, at]) => [level, { ...at }])),
             perspectives: this.perspectives.map(p => p.toJSON()), contexts: this.contexts.map(c => c.toJSON()),
+            ...(this.dataTypes.length && { dataTypes: this.dataTypes.map(t => t.toJSON()) }),
+            ...(this.namingStandard && { namingStandard: this.namingStandard.toJSON() }),
+            ...(!this.classificationScheme.isDefault && { classificationScheme: this.classificationScheme.toJSON() }),
+            ...(this.scorecard && { scorecard: JSON.parse(JSON.stringify(this.scorecard)) }),
         };
     }
 }