@peter.prib/renderengine 0.2.6 → 0.2.7

package/src/charting/datamodel/DataModel.js

@@ -1,8 +1,19 @@
 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 { 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 +32,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 +44,45 @@ 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';
+
+    /** 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: '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 +100,17 @@ 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 {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 +120,10 @@ 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)));
     }
 
     /**
@@ -85,6 +148,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 +244,16 @@ export class DataModel {
         return [...ids];
     }
 
+    /** 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 +279,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) => {
@@ -164,31 +298,41 @@ export class DataModel {
             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 owners = level === 'logical' ? this.ownersOf(entity.id).map(o => o.name) : [];
+            const typed = this.typedAttributes(entity);
+            const iso = this.iso20022Of(entity);
             const details = {
                 ...entity.details,
+                ...(owners.length && { 'owned by': owners.join(', ') }),
+                ...(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) ?? {};
+            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);
+            }),
+            ...(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 +385,203 @@ export class DataModel {
 
     // ===== Perspectives and contexts of one's own =====
 
+    // ===== 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.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';
+    }
+
+    /** 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 +589,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 +611,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 +633,13 @@ 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()) }),
         };
     }
 }

package/src/charting/datamodel/DataModelChecker.js

@@ -0,0 +1,92 @@
+import { ModelChecker } from '../ModelChecker.js';
+import { BianNotation } from '../../bian.js';
+
+/**
+ * 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. Each finding names what it is about (`kind`: 'entity',
+ * '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];
+    }
+
+    /** 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`,
+            })));
+    }
+}