@peter.prib/renderengine 0.2.7 → 0.2.11

package/src/workspace/parts/DataModelPart.js

@@ -7,12 +7,13 @@ import { ModelCheckDialog } from '../../charting/ModelCheckDialog.js';
 import { DataModelNotation } from '../../datamodel.js';
 import {
     DataModel, DataModelPerspective, DataModelContext, DataModelFileFormat, ServiceDomain, ServiceLandscape, BianLandscapeReader,
-    BianSemanticApiReader, DataType, EnumerationType, StructuredType,
+    BianSemanticApiReader, DataType, EnumerationType, StructuredType, NamingStandard, ClassificationScheme, ClassificationLens,
+    SqlDdlFileFormat, ModelScorecard,
 } from '../../charting/datamodel/index.js';
 import { pickFile } from '../../charting/toolbar/pickFile.js';
 import { ModelFile } from './ModelFile.js';
 import { EditorPart } from './EditorPart.js';
-import { downloadPng, downloadSvg } from '../../exportImage.js';
+import { downloadPng, downloadSvg, downloadBlob } from '../../exportImage.js';
 
 /**
  * DataModelPart — a data model (DataModel, drawn by dataModelDiagram) in a
@@ -96,7 +97,13 @@ export class DataModelPart extends ChartPart {
         this._adoptModel(model);
         this.perspectiveId = null;
         this.contextId = null;
-        if (this.mounted) this.render();
+        if (!this.mounted) return;
+        // Not rendered again (that would add a second toolbar and canvas): the toolbar
+        // shows the new model's choices, and it is drawn. What was on screen is the
+        // other model's, so where its boxes were is not kept into this one.
+        this._drawnLevel = null;
+        this._changed();
+        this._redraw();
     }
 
     /** A model opened from a file in a host's new tab (as EditorPart does). */
@@ -208,9 +215,131 @@ export class DataModelPart extends ChartPart {
             ...this.chartOptions,
             ...this.model.view({ perspective: this.perspectiveId, context: this.contextId, level: this.level }),
             ...(this.level === DataModel.LANDSCAPE && { onNodeDoubleClick: (node) => this.openServiceDomain(ServiceLandscape.serviceDomainOf(node.id)) }),
+            ...(this.editsLevel && this.editingOptions()),
+            ...(this.level === DataModel.MAPPING && this.lineageOptions()),
+        };
+    }
+
+    /**
+     * Show an entity's lineage: the mapping view, what it realises and what
+     * realises it (DataModel#lineage) as they are, the rest greyed.
+     */
+    showLineage(level, id) {
+        this.lineageFocus = { level, id };
+        this.setLevel(DataModel.MAPPING);
+    }
+
+    /**
+     * In the mapping view: an entity's lineage picked out (`lineageFocus`), and
+     * its menus to show another's or show all again.
+     */
+    lineageOptions() {
+        const view = {};
+        const focus = this.lineageFocus;
+        if (focus) {
+            const { up, down } = this.model.lineage(focus.level, focus.id);
+            const on = new Set([`${focus.level}:${focus.id}`, ...[...up, ...down].map(({ level, entity }) => `${level}:${entity.id}`)]);
+            const drawn = this.model.view({ perspective: this.perspectiveId, context: this.contextId, level: DataModel.MAPPING });
+            view.entities = drawn.entities.map(e => (on.has(e.id) ? e : { ...e, color: '#f3f4f6' }));
+            view.links = drawn.links.map(l => (on.has(l.source) && on.has(l.target) ? l : { ...l, color: '#e5e7eb' }));
+        }
+        const split = (nodeId) => { const i = String(nodeId).indexOf(':'); return [nodeId.slice(0, i), nodeId.slice(i + 1)]; };
+        return {
+            ...view,
+            contextMenuItems: [{ label: 'Show lineage', action: (node) => { const [level, id] = split(node.id); this.showLineage(level, id); } }],
+            canvasContextMenuItems: [{ label: 'Show all', action: () => { this.lineageFocus = null; this._redraw(); } }],
         };
     }
 
+    /** Whether what is shown is a level of the schema (so its entities and relationships can be edited here). */
+    get editsLevel() {
+        return !DataModel.otherView(this.level);
+    }
+
+    /**
+     * At a level of the schema: double-click an entity or a relationship to
+     * edit it; right-click one to edit or delete it, or the canvas for a new
+     * entity there or a new relationship. (These stand in for graphDiagram's
+     * own, which change only the drawing.)
+     */
+    editingOptions() {
+        const relationshipOf = (drawn) => this.model.relationshipIndex(this.level, drawn);
+        const isEntity = (node) => !!this.model.level(this.level).entity(node.id);
+        return {
+            onNodeDoubleClick: (node) => (isEntity(node) ? this.editEntity(node.id) : this.editRelationship(relationshipOf(node))),
+            onEdgeDoubleClick: (edge) => this.editRelationship(relationshipOf(edge)),
+            contextMenuItems: [
+                { label: 'Edit…', action: (node) => (isEntity(node) ? this.editEntity(node.id) : this.editRelationship(relationshipOf(node))) },
+                { label: 'Delete', action: (node) => (isEntity(node) ? this.removeEntity(node.id) : this.removeRelationship(relationshipOf(node))) },
+                { label: 'Show lineage', action: (node) => { if (isEntity(node)) this.showLineage(this.level, node.id); } },
+            ],
+            edgeContextMenuItems: [
+                { label: 'Edit relationship…', action: (edge) => this.editRelationship(relationshipOf(edge)) },
+                { label: 'Delete relationship', action: (edge) => this.removeRelationship(relationshipOf(edge)) },
+            ],
+            canvasContextMenuItems: [
+                { label: `New ${this.levelInfo.entityNoun.toLowerCase()} here…`, action: (subject, engine, point) => this.editEntity(null, point) },
+                { label: 'New relationship…', action: () => this.editRelationship(null) },
+            ],
+        };
+    }
+
+    /** The level shown, as DataModelNotation has it (its nouns, its dialogs' fields). */
+    get levelInfo() {
+        return DataModelNotation.level(this.level);
+    }
+
+    /**
+     * An entity's dialog at the level shown (none: a new one, placed at
+     * `point` or below the others): its level's fields (name, definition, and
+     * at the logical and physical levels its attributes as a table). Saved, it
+     * is one undo step.
+     */
+    editEntity(id, point = null) {
+        if (!this.editsLevel) return null;
+        const info = this.levelInfo;
+        const schema = this.model.level(this.level);
+        const entity = id ? schema.entity(id) : null;
+        if (id && !entity) return null;
+        const scheme = this.model.classificationScheme;
+        const context = { typeNames: this.model.dataTypes.map(t => t.name), sensitivities: scheme.levels.map(l => l.name), categories: scheme.categories };
+        const title = entity ? `${info.entityNoun}: ${entity.name}` : `New ${info.entityNoun.toLowerCase()}`;
+        return this._dialog(title, info.entityFields(entity, context), (values) => {
+            const spec = info.entitySpecFrom(values, entity);
+            if (!entity) Object.assign(spec, point ?? this._freeSpot(schema));
+            this.runModelEdit(this.model.saveEntityCommand(this.level, id, spec));
+        });
+    }
+
+    /** Where a new entity goes with no point given: below what is there. @private */
+    _freeSpot(schema) {
+        const ys = schema.entities.map(e => e.y).filter(Number.isFinite);
+        return { x: 160, y: (ys.length ? Math.max(...ys) : 0) + 160 };
+    }
+
+    removeEntity(id) {
+        if (!this.editsLevel || !this.model.level(this.level).entity(id)) return null;
+        return this.runModelEdit(this.model.removeEntityCommand(this.level, id));
+    }
+
+    /** A relationship's dialog at the level shown (`index` null or -1: a new one); saved, one undo step. */
+    editRelationship(index) {
+        if (!this.editsLevel) return null;
+        const info = this.levelInfo;
+        const schema = this.model.level(this.level);
+        const relationship = index == null || index < 0 ? null : schema.relationships[index];
+        if (!schema.entities.length) return null;
+        const title = relationship ? `Relationship: ${relationship.name || `${relationship.source} – ${relationship.target}`}` : 'New relationship';
+        return this._dialog(title, info.relationshipFields(schema.entities, relationship), (values) => {
+            this.runModelEdit(this.model.saveRelationshipCommand(this.level, relationship ? index : null, info.relationshipSpecFrom(values, relationship)));
+        }, ({ source, target }) => (source && target ? null : 'Choose both ends'));
+    }
+
+    removeRelationship(index) {
+        if (!this.editsLevel || index == null || index < 0) return null;
+        return this.runModelEdit(this.model.removeRelationshipCommand(this.level, index));
+    }
+
     /** See the model through a service domain (an id), at the logical level, where its business objects are. */
     openServiceDomain(id) {
         if (!this.model.perspective(id)) return;
@@ -260,8 +389,12 @@ export class DataModelPart extends ChartPart {
     /** Model ▸: make, change or remove a perspective or a context (the one chosen). */
     modelItems() {
         return [
+            { label: `New ${this.editsLevel ? this.levelInfo.entityNoun.toLowerCase() : 'entity'}…`, disabled: !this.editsLevel || undefined, action: () => this.editEntity(null) },
+            { label: 'New relationship…', disabled: !this.editsLevel || !this.model.level(this.level).entities.length || undefined, action: () => this.editRelationship(null) },
+            { separator: true },
             { label: 'New perspective…', action: () => this.editPerspective(null) },
             { label: 'New service domain…', action: () => this.editPerspective(null, ServiceDomain) },
+            { label: 'New classification lens…', action: () => this.editPerspective(null, ClassificationLens) },
             { label: 'Read service domains from a BIAN landscape…', action: () => this.readLandscape() },
             { label: 'Read a BIAN service domain (semantic API)…', action: () => this.readSemanticApi() },
             { label: 'Edit perspective…', disabled: !this.perspective || undefined, action: () => this.editPerspective(this.perspective) },
@@ -274,6 +407,9 @@ export class DataModelPart extends ChartPart {
             { label: 'Delete context', disabled: !this.context || undefined, action: () => this.removeContext(this.contextId) },
             { separator: true },
             { label: 'Check model…', action: () => this.checkModel() },
+            { label: 'Scorecard…', action: () => this.scoreModel() },
+            ...EditorPart.menuGroup('Naming standard', this.namingItems()),
+            { label: 'Classification scheme…', action: () => this.editClassificationScheme() },
         ];
     }
 
@@ -365,6 +501,51 @@ export class DataModelPart extends ChartPart {
         return command;
     }
 
+    /**
+     * The Data Model Scorecard (ModelScorecard): each category as the model
+     * measures it, a reviewer's score and note, its weight; the total in the
+     * title. Saved, the reviews and weights are kept (one undo step).
+     */
+    scoreModel() {
+        const card = this.model.scored();
+        const results = card.results();
+        const { score, coverage } = card.total(results);
+        const title = score == null ? 'Scorecard: nothing scored yet' : `Scorecard: ${score} of 100 (${coverage}% of the weight scored)`;
+        return this._dialog(title, card.fields(results), (values) => {
+            this.runModelEdit(this.model.scorecardCommand(ModelScorecard.specFrom(values)));
+        }, () => null);
+    }
+
+    /** The classification scheme's dialog (its sensitivity levels in order, its categories); saved, one undo step. */
+    editClassificationScheme() {
+        return this._dialog('Classification scheme', ClassificationScheme.fields(this.model.classificationScheme), (values) => {
+            this.runModelEdit(this.model.classificationSchemeCommand(ClassificationScheme.specFrom(values)));
+        }, (values) => (ClassificationScheme.specFrom(values).levels.length ? null : 'Give it at least one level'));
+    }
+
+    /** Model ▸ Naming standard ▸: edit it, start from the conventional one, or remove it (Check model… checks names against it). */
+    namingItems() {
+        const has = !!this.model.namingStandard;
+        return [
+            { label: has ? 'Edit…' : 'Set…', action: () => this.editNamingStandard() },
+            ...(has ? [] : [{ label: 'Use the conventional one', action: () => this.runModelEdit(this.model.namingStandardCommand(NamingStandard.CONVENTIONAL)) }]),
+            ...(has ? [{ label: 'Remove', action: () => this.runModelEdit(this.model.namingStandardCommand(null)) }] : []),
+        ];
+    }
+
+    /**
+     * The naming standard's dialog (NamingStandard.fields: a rule per level for
+     * entities and attributes); saved, one undo step. A standard that asks
+     * nothing is none.
+     */
+    editNamingStandard() {
+        return this._dialog('Naming standard', NamingStandard.fields(this.model.namingStandard), (values) => {
+            const spec = NamingStandard.specFrom(values);
+            const asks = Object.values(spec).some(kinds => Object.values(kinds).some(r => r.style || r.classWords.length || r.maxLength || Object.keys(r.abbreviations).length));
+            this.runModelEdit(this.model.namingStandardCommand(asks ? spec : null));
+        }, () => null);
+    }
+
     /** Model ▸ Data types ▸: a new one of each kind, then each to change or remove. */
     dataTypeItems() {
         const types = this.model.dataTypes;
@@ -454,12 +635,11 @@ export class DataModelPart extends ChartPart {
     }
 
     /** Open a form (a name is needed). @private */
-    _dialog(title, fields, apply) {
+    _dialog(title, fields, apply, validate = ({ name }) => ((name ?? '').trim() ? null : 'Give it a name')) {
         return new FormDialog({
             title, fields, submitLabel: 'Save', idPrefix: 'data-model-',
             document: this.container?.ownerDocument ?? globalThis.document,
-            validate: ({ name }) => ((name ?? '').trim() ? null : 'Give it a name'),
-            onApply: apply,
+            validate, onApply: apply,
         }).open();
     }
 
@@ -475,12 +655,23 @@ export class DataModelPart extends ChartPart {
         return [
             { label: 'Image (PNG)', action: () => downloadPng(this.canvasHost, { name }) },
             { label: 'Image (SVG)', action: () => downloadSvg(this.canvasHost, { name }) },
+            { separator: true },
+            { label: 'SQL DDL (physical level)', action: () => this.exportDdl() },
         ];
     }
 
+    /** The physical level as SQL DDL (SqlDdlFileFormat), downloaded as the model's name. Returns the file. */
+    exportDdl({ download = (file, fileName) => downloadBlob(new (this.document.defaultView ?? globalThis).Blob([file.data], { type: file.mimeType }), fileName) } = {}) {
+        const file = new SqlDdlFileFormat().export(this.model);
+        download(file, `${String(this.model.name || this.title || 'model').replace(/[^A-Za-z0-9._-]+/g, '-')}.sql`);
+        return file;
+    }
+
     /** Redraw now (a choice made), when there is somewhere to draw. @private */
     _redraw() {
         if (this.canvasHost) this._draw();
+        // Its toolbar shows what is drawn, however it was chosen (a finding, a lineage, a service domain opened).
+        this.menuBar?.refresh?.();
     }
 
     /**