@peter.prib/renderengine 0.2.7 → 0.2.11

package/src/charting/RowsField.js

@@ -0,0 +1,127 @@
+import { el } from '../workspace/dom.js';
+
+/**
+ * RowsField — the control a FormDialog shows for a `rows` field: a list of
+ * items edited as a table, a row each, its columns from the field
+ * (`columns: [{ key, label, type?: 'text'|'checkbox'|'select', choices?,
+ * suggestions?, placeholder?, width? }]`), each row movable up and down and
+ * removable, and **Add** for a new one (`addLabel`). It reads back as the rows
+ * in their order, each the item it was made from with what the columns say
+ * laid over it, so what a dialog does not show (an attribute's ISO 20022
+ * type, say) is kept: an empty text or an unticked box leaves its key out. A
+ * new row left empty is no row.
+ */
+export class RowsField {
+    /**
+     * @param {Object} field - The FormDialog field (`columns`, `value`: the items, `addLabel`)
+     * @param {Document} doc
+     * @param {string} [id] - The table's element id
+     */
+    constructor(field, doc, id = '') {
+        this.field = field;
+        this.doc = doc;
+        this.id = id;
+        /** Each row's element and how to read it, in display order. */
+        this.rows = [];
+    }
+
+    /** The control: the table, its rows, and Add. */
+    element() {
+        const { columns, value = [], addLabel = 'Add' } = this.field;
+        const lists = columns.filter(c => c.suggestions).map(c => ({
+            tag: 'datalist', attrs: { id: this._listId(c) }, children: c.suggestions.map(v => ({ tag: 'option', attrs: { value: v } })),
+        }));
+        this.root = el({
+            attrs: { id: this.id }, style: { display: 'flex', flexDirection: 'column', gap: '4px' },
+            children: [
+                {
+                    tag: 'table', style: { borderCollapse: 'collapse', fontSize: '12px' },
+                    children: [
+                        { tag: 'thead', children: [{ tag: 'tr', children: [...columns.map(c => ({ tag: 'th', text: c.label, style: { textAlign: 'left', fontWeight: 'normal', color: '#666', padding: '0 4px' } })), { tag: 'th' }] }] },
+                        { tag: 'tbody', ref: (n) => { this.body = n; } },
+                    ],
+                },
+                ...lists,
+                { tag: 'button', attrs: { type: 'button', 'data-action': 'add' }, text: `+ ${addLabel}`, style: { alignSelf: 'flex-start' }, on: { click: () => this.add() } },
+            ],
+        }, this.doc);
+        for (const item of value) this.add(item);
+        return this.root;
+    }
+
+    /** Add a row for an item (none: an empty one). Returns its element. */
+    add(item = null) {
+        const readers = [];
+        const cell = (c) => {
+            const current = item?.[c.key];
+            const width = c.width ?? (c.type === 'checkbox' ? '40px' : undefined);
+            let control;
+            if (c.type === 'checkbox') {
+                control = { tag: 'input', attrs: { type: 'checkbox', checked: !!current, 'data-key': c.key }, ref: (n) => { n.checked = !!current; readers.push([c, () => n.checked]); } };
+            } else if (c.type === 'select') {
+                const choices = c.choices.some(([v]) => v === String(current ?? '')) || current == null ? c.choices : [[String(current), String(current)], ...c.choices];
+                control = {
+                    // The value set as well as the option marked: a parent's ref runs after its children are in.
+                    tag: 'select', attrs: { 'data-key': c.key }, ref: (n) => { n.value = String(current ?? choices[0]?.[0] ?? ''); readers.push([c, () => n.value]); },
+                    children: choices.map(([v, text]) => ({ tag: 'option', attrs: { value: v, selected: v === String(current ?? '') }, text })),
+                };
+            } else {
+                control = {
+                    tag: 'input', attrs: { type: 'text', value: current == null ? '' : String(current), placeholder: c.placeholder, list: c.suggestions ? this._listId(c) : undefined, 'data-key': c.key },
+                    style: { width: '100%', boxSizing: 'border-box' }, ref: (n) => { n.value = current == null ? '' : String(current); readers.push([c, () => String(n.value ?? '').trim()]); },
+                };
+            }
+            return { tag: 'td', style: { padding: '1px 2px', ...(width && { width }) }, children: [control] };
+        };
+        const button = (text, title, action) => ({ tag: 'button', attrs: { type: 'button', title, 'data-action': action }, text, style: { padding: '0 4px' } });
+        let row;
+        const node = el({
+            tag: 'tr',
+            children: [
+                ...this.field.columns.map(cell),
+                {
+                    tag: 'td', style: { whiteSpace: 'nowrap' },
+                    children: [
+                        { ...button('↑', 'Move up', 'up'), on: { click: () => this.move(row, -1) } },
+                        { ...button('↓', 'Move down', 'down'), on: { click: () => this.move(row, 1) } },
+                        { ...button('✕', 'Remove', 'remove'), on: { click: () => this.remove(row) } },
+                    ],
+                },
+            ],
+        }, this.doc);
+        row = { node, item, readers };
+        this.rows.push(row);
+        this.body.appendChild(node);
+        return node;
+    }
+
+    /** Move a row up (-1) or down (1). */
+    move(row, by) {
+        const i = this.rows.indexOf(row), j = i + by;
+        if (i < 0 || j < 0 || j >= this.rows.length) return;
+        [this.rows[i], this.rows[j]] = [this.rows[j], this.rows[i]];
+        for (const r of this.rows) this.body.appendChild(r.node);
+    }
+
+    remove(row) {
+        this.rows = this.rows.filter(r => r !== row);
+        row.node.remove();
+    }
+
+    /** The rows as items, in order (see the class). */
+    read() {
+        return this.rows.map(({ item, readers }) => {
+            const out = { ...(item ?? {}) };
+            for (const [c, read] of readers) {
+                const v = read();
+                if (v === '' || v === false) delete out[c.key];
+                else out[c.key] = v;
+            }
+            return out;
+        }).filter((out, i) => this.rows[i].item || this.field.columns.some(c => out[c.key] !== undefined));
+    }
+
+    _listId(column) {
+        return `${this.id || 'rows'}-${column.key}-suggestions`;
+    }
+}

package/src/charting/datamodel/ClassificationLens.js

@@ -0,0 +1,33 @@
+import { DataModelPerspective } from './DataModelPerspective.js';
+import { ClassificationScheme } from './ClassificationScheme.js';
+
+/** How an entity with no classification is drawn through the lens. */
+const UNCLASSIFIED = '#f3f4f6';
+
+/**
+ * ClassificationLens — a perspective that colours what it shows by its
+ * classification (DMBOK2's data security): each entity in its sensitivity's
+ * colour (the model's ClassificationScheme), at its effective classification
+ * (the highest of its own and its attributes'), unclassified ones grey, and
+ * the classification on hover. It sees the concepts any perspective does.
+ */
+export class ClassificationLens extends DataModelPerspective {
+    static kind = 'classification';
+    static kindLabel = 'Classification lens';
+
+    decorate(entity, level, model) {
+        const scheme = model?.classificationScheme ?? new ClassificationScheme();
+        const effective = scheme.effective(entity);
+        return {
+            color: scheme.colorOf(effective.sensitivity) ?? UNCLASSIFIED,
+            details: { classification: ClassificationScheme.describe(effective) || 'unclassified' },
+        };
+    }
+
+    /** As a perspective's, its kind kept. */
+    static specFrom(values, model) {
+        return { ...DataModelPerspective.specFrom(values, model), kind: ClassificationLens.kind };
+    }
+}
+
+DataModelPerspective.register(ClassificationLens);

package/src/charting/datamodel/ClassificationScheme.js

@@ -0,0 +1,98 @@
+/** The colours sensitivity levels are drawn in, lowest first, when a scheme names none. */
+const LEVEL_COLORS = ['#dcfce7', '#e0f2fe', '#fef3c7', '#fecaca', '#e9d5ff', '#fed7aa'];
+
+/**
+ * ClassificationScheme — how a model's data is classified (DMBOK2's data
+ * security): sensitivity `levels` in order, lowest first, each with the colour
+ * a classification lens draws it in, and `categories` a piece of data may fall
+ * in (PII, PCI...). The default is the common four levels and categories; a
+ * model may keep its own.
+ *
+ * A classification, on an entity or an attribute, is its `sensitivity` (a
+ * level's name) and its `categories`; an entity's effective one is the highest
+ * of its own and its attributes', with all their categories.
+ */
+export class ClassificationScheme {
+    static DEFAULT = Object.freeze({
+        levels: [
+            { name: 'Public', color: LEVEL_COLORS[0] },
+            { name: 'Internal', color: LEVEL_COLORS[1] },
+            { name: 'Confidential', color: LEVEL_COLORS[2] },
+            { name: 'Restricted', color: LEVEL_COLORS[3] },
+        ],
+        categories: ['PII', 'PCI', 'PHI', 'Financial'],
+    });
+
+    /** @param {{levels?: Array<{name: string, color?: string}|string>, categories?: string[]}} [spec] */
+    constructor({ levels = ClassificationScheme.DEFAULT.levels, categories = ClassificationScheme.DEFAULT.categories } = {}) {
+        this.levels = levels.map((l, i) => {
+            const level = typeof l === 'string' ? { name: l } : l;
+            return { name: String(level.name), color: level.color || LEVEL_COLORS[i % LEVEL_COLORS.length] };
+        });
+        this.categories = [...categories].map(String);
+    }
+
+    /** A sensitivity's rank (0 the lowest), or -1 for none or one the scheme lacks. */
+    rank(sensitivity) {
+        return this.levels.findIndex(l => l.name.toLowerCase() === String(sensitivity ?? '').toLowerCase());
+    }
+
+    /** The colour a sensitivity is drawn in, or null. */
+    colorOf(sensitivity) {
+        return this.levels[this.rank(sensitivity)]?.color ?? null;
+    }
+
+    /** Categories as written ('PII, PCI' or a list) as a list. */
+    static categoriesOf(value) {
+        return (Array.isArray(value) ? value : String(value ?? '').split(/[,;]/)).map(c => String(c).trim()).filter(Boolean);
+    }
+
+    /**
+     * An entity's effective classification: the highest sensitivity of its own
+     * and its attributes', and all their categories.
+     * @returns {{sensitivity: string|null, categories: string[]}}
+     */
+    effective(entity) {
+        const parts = [entity, ...(entity?.attributes ?? [])];
+        let best = null;
+        for (const p of parts) if (this.rank(p?.sensitivity) > this.rank(best)) best = this.levels[this.rank(p.sensitivity)].name;
+        const categories = [...new Set(parts.flatMap(p => ClassificationScheme.categoriesOf(p?.categories)))];
+        return { sensitivity: best, categories };
+    }
+
+    /** A classification in words: 'Confidential (PII, PCI)', or '' for none. */
+    static describe({ sensitivity, categories = [] } = {}) {
+        if (!sensitivity && !categories.length) return '';
+        return [sensitivity || 'Unclassified', categories.length ? `(${categories.join(', ')})` : ''].filter(Boolean).join(' ');
+    }
+
+    toJSON() {
+        return { levels: this.levels.map(l => ({ ...l })), categories: [...this.categories] };
+    }
+
+    /** Whether it is the default (so a model need not keep it). */
+    get isDefault() {
+        return JSON.stringify(this.toJSON()) === JSON.stringify(new ClassificationScheme().toJSON());
+    }
+
+    /** Its dialog's fields: its levels a line each, lowest first (`name | colour`), its categories. */
+    static fields(scheme) {
+        return [
+            {
+                key: 'levels', label: 'Sensitivity levels', type: 'textarea', rows: 5,
+                value: scheme.levels.map(l => `${l.name} | ${l.color}`).join('\n'),
+                hint: 'Lowest first, one a line: name | colour',
+            },
+            { key: 'categories', label: 'Categories', type: 'text', value: scheme.categories.join(', '), placeholder: 'PII, PCI, PHI' },
+        ];
+    }
+
+    /** A scheme's spec from those fields. */
+    static specFrom(values) {
+        return {
+            levels: String(values.levels ?? '').split('\n').map(l => l.split('|').map(p => p.trim())).filter(([name]) => name)
+                .map(([name, color]) => ({ name, ...(color && { color }) })),
+            categories: ClassificationScheme.categoriesOf(values.categories),
+        };
+    }
+}

package/src/charting/datamodel/DataModel.js

@@ -10,6 +10,11 @@ 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,
@@ -50,6 +55,13 @@ export class DataModel {
     /** 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 };
@@ -71,6 +83,11 @@ export class DataModel {
             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,
@@ -101,6 +118,9 @@ export class DataModel {
      * @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
@@ -124,6 +144,24 @@ export class DataModel {
         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;
+        });
     }
 
     /**
@@ -244,6 +282,37 @@ 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));
@@ -297,13 +366,18 @@ 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 }),
@@ -312,7 +386,7 @@ export class DataModel {
                 ...(rules.length && { rules }),
             };
             const { attributes, ...rest } = entity;
-            const mark = lens?.decorate(entity, level) ?? {};
+            const mark = lens?.decorate(entity, level, this) ?? {};
             const allDetails = { ...details, ...mark.details };
             return {
                 ...rest,
@@ -329,7 +403,7 @@ export class DataModel {
         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) };
+                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);
@@ -385,6 +459,106 @@ 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. */
@@ -470,7 +644,7 @@ export class DataModel {
             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) },
+            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}` })));
@@ -487,6 +661,45 @@ export class DataModel {
         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');
@@ -640,6 +853,9 @@ export class DataModel {
             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)) }),
         };
     }
 }