@api-client/core 0.11.8 → 0.11.10

package/data/models/example-generator-api.json

@@ -41722,6 +41722,9 @@
 "@id": "#209"
 },
 {
+"@id": "#206"
+},
+{
 "@id": "#191"
 },
 {
@@ -41737,9 +41740,6 @@
 "@id": "#203"
 },
 {
-"@id": "#206"
-},
-{
 "@id": "#209"
 }
 ],
@@ -43096,7 +43096,7 @@
 "doc:ExternalDomainElement",
 "doc:DomainElement"
 ],
-"doc:raw": "countryCode: \"BE\"\ngraydonEnterpriseId: 1057155523\nregistrationId: \"0422319093\"\nvatNumber: \"BE0422319093\"\ngraydonCompanyId: \"0422319093\"\nisBranchOffice: false\n",
+"doc:raw": "addressType: 'REGISTERED-OFFICE-ADDRESS'\nstreetName: 'UITBREIDINGSTRAAT'\nhouseNumber: '84'\nhouseNumberAddition: '/1'\npostalCode: '2600'\ncity: 'BERCHEM (ANTWERPEN)'\ncountry: 'Belgium'\ncountryCode: 'BE'\nfullFormatedAddress: \"UITBREIDINGSTRAAT 84 /1, 2600 BERCHEM (ANTWERPEN), BELIUM\"\n",
 "core:mediaType": "application/yaml",
 "sourcemaps:sources": [
 {
@@ -43117,7 +43117,7 @@
 "doc:ExternalDomainElement",
 "doc:DomainElement"
 ],
-"doc:raw": "addressType: 'REGISTERED-OFFICE-ADDRESS'\nstreetName: 'UITBREIDINGSTRAAT'\nhouseNumber: '84'\nhouseNumberAddition: '/1'\npostalCode: '2600'\ncity: 'BERCHEM (ANTWERPEN)'\ncountry: 'Belgium'\ncountryCode: 'BE'\nfullFormatedAddress: \"UITBREIDINGSTRAAT 84 /1, 2600 BERCHEM (ANTWERPEN), BELIUM\"\n",
+"doc:raw": "code: '5'\ndescription: 'Limited company'\n",
 "core:mediaType": "application/yaml",
 "sourcemaps:sources": [
 {
@@ -43138,7 +43138,7 @@
 "doc:ExternalDomainElement",
 "doc:DomainElement"
 ],
-"doc:raw": "code: '5'\ndescription: 'Limited company'\n",
+"doc:raw": "class: '3'\ndescription: '150 - 300'\nnumberOfFte: 5500\nnumberOfEmployees: 5232\n",
 "core:mediaType": "application/yaml",
 "sourcemaps:sources": [
 {
@@ -43159,7 +43159,7 @@
 "doc:ExternalDomainElement",
 "doc:DomainElement"
 ],
-"doc:raw": "class: '3'\ndescription: '150 - 300'\nnumberOfFte: 5500\nnumberOfEmployees: 5232\n",
+"doc:raw": "code: 'J'\ndescription: 'Information and communication'\n",
 "core:mediaType": "application/yaml",
 "sourcemaps:sources": [
 {
@@ -43180,7 +43180,7 @@
 "doc:ExternalDomainElement",
 "doc:DomainElement"
 ],
-"doc:raw": "code: 'J'\ndescription: 'Information and communication'\n",
+"doc:raw": "code: '7487'\ndescription: 'Financial and insurance activities'\ntype: \"PRIMARY\"\nclassificationCode: 'BE_NACEBEL2008'\nactivityGroupCode: 'ABCDE'\n",
 "core:mediaType": "application/yaml",
 "sourcemaps:sources": [
 {
@@ -43201,7 +43201,7 @@
 "doc:ExternalDomainElement",
 "doc:DomainElement"
 ],
-"doc:raw": "code: '7487'\ndescription: 'Financial and insurance activities'\ntype: \"PRIMARY\"\nclassificationCode: 'BE_NACEBEL2008'\nactivityGroupCode: 'ABCDE'\n",
+"doc:raw": "countryCode: \"BE\"\ngraydonEnterpriseId: 1057155523\nregistrationId: \"0422319093\"\nvatNumber: \"BE0422319093\"\ngraydonCompanyId: \"0422319093\"\nisBranchOffice: false\n",
 "core:mediaType": "application/yaml",
 "sourcemaps:sources": [
 {
@@ -44416,32 +44416,32 @@
 {
 "@id": "#193/source-map/lexical/element_0",
 "sourcemaps:element": "amf://id#193",
-"sourcemaps:value": "[(1,0)-(7,0)]"
+"sourcemaps:value": "[(1,0)-(10,0)]"
 },
 {
 "@id": "#196/source-map/lexical/element_0",
 "sourcemaps:element": "amf://id#196",
-"sourcemaps:value": "[(1,0)-(10,0)]"
+"sourcemaps:value": "[(1,0)-(3,0)]"
 },
 {
 "@id": "#199/source-map/lexical/element_0",
 "sourcemaps:element": "amf://id#199",
-"sourcemaps:value": "[(1,0)-(3,0)]"
+"sourcemaps:value": "[(1,0)-(5,0)]"
 },
 {
 "@id": "#202/source-map/lexical/element_0",
 "sourcemaps:element": "amf://id#202",
-"sourcemaps:value": "[(1,0)-(5,0)]"
+"sourcemaps:value": "[(1,0)-(3,0)]"
 },
 {
 "@id": "#205/source-map/lexical/element_0",
 "sourcemaps:element": "amf://id#205",
-"sourcemaps:value": "[(1,0)-(3,0)]"
+"sourcemaps:value": "[(1,0)-(6,0)]"
 },
 {
 "@id": "#208/source-map/lexical/element_0",
 "sourcemaps:element": "amf://id#208",
-"sourcemaps:value": "[(1,0)-(6,0)]"
+"sourcemaps:value": "[(1,0)-(7,0)]"
 },
 {
 "@id": "#223/source-map/lexical/element_0",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@api-client/core",
   "description": "The API Client's core client library. Works in NodeJS and in a ES enabled browser.",
-  "version": "0.11.8",
+  "version": "0.11.10",
   "license": "Apache-2.0",
   "exports": {
     "./browser.js": {

package/src/modeling/DataEntity.ts

@@ -535,7 +535,7 @@ export class DataEntity {
   /**
    * Reads the list of parents for the entity, inside the root namespace. The computed list contains the list of all
    * parents in the inheritance chain in no particular order.
-   * @param recursive Whether to include parent parents as well.
+   * @param recursive Whether to include parent's parents as well.
    */
   getComputedParents(recursive?: boolean): DataEntity[] {
     const { entities } = this.root.definitions

package/src/modeling/DataNamespace.ts

@@ -4,7 +4,13 @@ import { IDataAssociation, DataAssociation, AssociationTarget } from './DataAsso
 import { IDataEntity, DataEntity } from './DataEntity.js'
 import { IDataModel, DataModel } from './DataModel.js'
 import { IDataProperty, DataProperty } from './DataProperty.js'
-import { DataNamespaceKind, DataModelKind } from '../models/kinds.js'
+import {
+  DataNamespaceKind,
+  DataModelKind,
+  DataEntityKind,
+  DataPropertyKind,
+  DataAssociationKind,
+} from '../models/kinds.js'
 import v4 from '../lib/uuid.js'
 import type { DataDomainRemoveOptions } from './types.js'
 
@@ -475,7 +481,7 @@ export class DataNamespace {
   addNamespace(init: string | IDataNamespace | DataNamespace, parent?: string): DataNamespace {
     let root: DataNamespace
     if (parent) {
-      const rootCandidate = this.findParent(parent)
+      const rootCandidate = this.findNamespace(parent)
       if (!rootCandidate) {
         throw new Error(`Unable to find the parent namespace ${parent}`)
       }
@@ -596,7 +602,7 @@ export class DataNamespace {
    * Finds a namespace and calls the `remove()` on it.
    * @param key The key of the namespace to find.
    */
-  removeNamespace(key: string): void {
+  removeNamespace(key: string, opts?: DataDomainRemoveOptions): void {
     const root = this.root || this
     if (root.key === key) {
       throw new Error(`Unable to remove the root namespace this way.`)
@@ -604,7 +610,7 @@ export class DataNamespace {
     const { definitions } = root
     const ns = definitions.namespaces.find((i) => i.key === key)
     if (ns) {
-      ns.remove()
+      ns.remove(opts)
     }
   }
 
@@ -651,15 +657,44 @@ export class DataNamespace {
     return definitions.models.find((i) => i.key === key)
   }
 
+  /**
+   * A convenience function to remove an object from the namespace.
+   * @param key The key of the object to remove.
+   * @param kind The kind of the object to remove.
+   * @param opts The options for the removal.
+   * @throws Error when the kind is not known.
+   */
+  removeObject(key: string, kind: string, opts?: DataDomainRemoveOptions): void {
+    switch (kind) {
+      case DataNamespaceKind:
+        this.findNamespace(key)?.remove(opts)
+        break
+      case DataModelKind:
+        this.findDataModel(key)?.remove(opts)
+        break
+      case DataEntityKind:
+        this.findEntity(key)?.remove(opts)
+        break
+      case DataPropertyKind:
+        this.findProperty(key)?.remove()
+        break
+      case DataAssociationKind:
+        this.findAssociation(key)?.remove()
+        break
+      default:
+        throw new Error(`Unknown kind ${kind} for the object ${key}.`)
+    }
+  }
+
   /**
    * Finds a data model and calls the `remove()` on it.
    * @param key The key of the data model to find.
    */
-  removeDataModel(key: string): void {
+  removeDataModel(key: string, opts?: DataDomainRemoveOptions): void {
     const { definitions } = this.root || this
     const model = definitions.models.find((i) => i.key === key)
     if (model) {
-      model.remove()
+      model.remove(opts)
     }
   }
 

package/src/modeling/{ImpactAnalysis.ts → DomainImpactAnalysis.ts}

@@ -7,7 +7,7 @@ import {
 } from '../models/kinds.js'
 import type { DataNamespace } from './DataNamespace.js'
 
-export type ImpactKinds =
+export type DomainImpactKinds =
   | typeof DataNamespaceKind
   | typeof DataEntityKind
   | typeof DataModelKind
@@ -17,7 +17,7 @@ export type ImpactKinds =
 /**
  * The impact analysis report
  */
-interface ImpactReport {
+export interface DomainImpactReport {
   /**
    * The key of the impacted data object.
    * This is the key of the object that is being changed.
@@ -27,11 +27,11 @@ interface ImpactReport {
    * The kind of the impacted data object.
    * This is the kind of the object that is being changed.
    */
-  kind: ImpactKinds
+  kind: DomainImpactKinds
   /**
    * The list of impacted data objects.
    */
-  impact: ImpactItem[]
+  impact: DomainImpactItem[]
   /**
    * Whether it is possible to proceed with the change.
    * If the change is not possible, the reason will be in the impact list.
@@ -39,7 +39,7 @@ interface ImpactReport {
   canProceed: boolean
 }
 
-interface ImpactItem {
+export interface DomainImpactItem {
   /**
    * The key of the impacted data object.
    */
@@ -74,17 +74,17 @@ interface ImpactItem {
 }
 
 /**
- * # ImpactAnalysis
+ * # DomainImpactAnalysis
  *
- * The `ImpactAnalysis` class is a powerful tool for analyzing the consequences of deleting data domain objects
+ * The `DomainImpactAnalysis` class is a powerful tool for analyzing the consequences of deleting data domain objects
  * within a `DataNamespace`.
  * It helps developers understand the ripple effects of removing a namespace, data model, entity, property,
  * or association, ensuring data integrity and preventing unintended side effects.
  *
  * ## Core Concepts
  *
- * -   **Impact Report:** The central output of the `ImpactAnalysis` class is an `ImpactReport`. This report details the
- *     potential consequences of a deletion operation, including:
+ * -   **Impact Report:** The central output of the `DomainImpactAnalysis` class is an `DomainImpactReport`.
+ *     This report details the potential consequences of a deletion operation, including:
  *     -   The object being deleted (`key`, `kind`).
  *     -   A list of `ImpactItem` objects, each describing a specific consequence.
  *     -   Whether the deletion can proceed safely (`canProceed`).
@@ -107,15 +107,15 @@ interface ImpactItem {
  *
  * ## Usage
  *
- * 1.  **Instantiation:** Create an instance of `ImpactAnalysis`, passing the root `DataNamespace` as an argument.
+ * 1.  **Instantiation:** Create an instance of `DomainImpactAnalysis`, passing the root `DataNamespace` as an argument.
  *
  *     ```typescript
- *     import { DataNamespace } from './DataNamespace'; // Assuming DataNamespace is in the same directory
- *     import { ImpactAnalysis } from './ImpactAnalysis'; // Assuming ImpactAnalysis is in the same directory
+ *     import { DataNamespace } from './DataNamespace';
+ *     import { DomainImpactAnalysis } from './DomainImpactAnalysis';
  *
  *     const rootNamespace = new DataNamespace();
  *     // ... add some data to the namespace
- *     const analyzer = new ImpactAnalysis(rootNamespace);
+ *     const analyzer = new DomainImpactAnalysis(rootNamespace);
  *     ```
  *
  * 2.  **Performing Analysis:** Use the `deleteAnalysis()` method to generate an `ImpactReport` for a specific deletion.
@@ -153,7 +153,7 @@ interface ImpactItem {
  *
  * ## Supported Deletion Scenarios
  *
- * The `ImpactAnalysis` class supports analyzing the deletion of the following data domain object types:
+ * The `DomainImpactAnalysis` class supports analyzing the deletion of the following data domain object types:
  *
  * -   **Namespaces (`DataNamespaceKind`):** Deleting a namespace also impacts all its child namespaces,
  *     data models, entities, properties, and associations.
@@ -176,7 +176,7 @@ interface ImpactItem {
  *             - Property: `name`
  *         - Entity: `SpecialProduct` (parent: `Product`)
  *
- * If you attempt to delete the `Product` entity, the `ImpactAnalysis` will generate a report similar to this:
+ * If you attempt to delete the `Product` entity, the `DomainImpactAnalysis` will generate a report similar to this:
  *
  * ```json
  * {
@@ -195,7 +195,7 @@ interface ImpactItem {
  *       "kind": "DataEntityKind",
  *       "type": "delete",
  *       "impact": "The SpecialProduct entity will become an orphan because it is a child of Product.",
- *       "resolution": "The Product will be removed as the parent parent of SpecialProduct.",
+ *       "resolution": "The "Product" entity will be removed as the parent of the "SpecialProduct" entity.",
  *       "blocking": true,
  *       "relationship": "child"
  *     },
@@ -262,12 +262,12 @@ interface ImpactItem {
  *
  * ## Error Handling
  *
- * The `ImpactAnalysis` class does not throw errors. Instead, it uses the `ImpactReport` to communicate
+ * The `DomainImpactAnalysis` class does not throw errors. Instead, it uses the `ImpactReport` to communicate
  * the results of the analysis, including any blocking impacts.
  *
  * ## Best Practices
  *
- * - **Always Analyze Before Deleting:** Before deleting any data domain object, always use `ImpactAnalysis`
+ * - **Always Analyze Before Deleting:** Before deleting any data domain object, always use `DomainImpactAnalysis`
  *   to understand the consequences.
  * - **Handle Blocking Impacts:** Pay close attention to `blocking` impacts and implement appropriate
  *   logic to handle them.
@@ -278,12 +278,12 @@ interface ImpactItem {
  *
  * ## Conclusion
  *
- * The `ImpactAnalysis` class is an essential tool for maintaining data integrity when working with complex
+ * The `DomainImpactAnalysis` class is an essential tool for maintaining data integrity when working with complex
  * data domain models. By providing detailed impact reports, it empowers developers to make informed decisions
  * about data deletion and prevent unintended consequences.
  */
-export class ImpactAnalysis {
-  private report: ImpactReport
+export class DomainImpactAnalysis {
+  private report: DomainImpactReport
   private root: DataNamespace
 
   constructor(root: DataNamespace) {
@@ -302,7 +302,7 @@ export class ImpactAnalysis {
    * @param kind The kind of the impacted data object.
    * @returns The delete impact analysis report.
    */
-  deleteAnalysis(key: string, kind: ImpactKinds): ImpactReport {
+  deleteAnalysis(key: string, kind: DomainImpactKinds): DomainImpactReport {
     this.report = {
       key,
       kind,
@@ -320,7 +320,7 @@ export class ImpactAnalysis {
     return this.report
   }
 
-  protected createDeleteImpact(key: string, kind: ImpactKinds, rootKey: string): ImpactItem[] {
+  protected createDeleteImpact(key: string, kind: DomainImpactKinds, rootKey: string): DomainImpactItem[] {
     switch (kind) {
       case DataNamespaceKind:
         return this.deleteNamespaceAnalysis(key, rootKey)
@@ -337,8 +337,8 @@ export class ImpactAnalysis {
     }
   }
 
-  protected deleteNamespaceAnalysis(key: string, rootKey: string): ImpactItem[] {
-    const result: ImpactItem[] = []
+  protected deleteNamespaceAnalysis(key: string, rootKey: string): DomainImpactItem[] {
+    const result: DomainImpactItem[] = []
     const ns = this.root.findNamespace(key)
     if (!ns) {
       return result
@@ -363,8 +363,8 @@ export class ImpactAnalysis {
     return result
   }
 
-  protected deleteDataModelAnalysis(key: string, rootKey: string): ImpactItem[] {
-    const result: ImpactItem[] = []
+  protected deleteDataModelAnalysis(key: string, rootKey: string): DomainImpactItem[] {
+    const result: DomainImpactItem[] = []
     const model = this.root.findDataModel(key)
     if (!model) {
       return result
@@ -383,8 +383,8 @@ export class ImpactAnalysis {
     return result
   }
 
-  protected deleteEntityAnalysis(key: string, rootKey: string): ImpactItem[] {
-    const result: ImpactItem[] = []
+  protected deleteEntityAnalysis(key: string, rootKey: string): DomainImpactItem[] {
+    const result: DomainImpactItem[] = []
     const entity = this.root.findEntity(key)
     if (!entity) {
       return result
@@ -415,12 +415,14 @@ export class ImpactAnalysis {
     })
     if (children.length) {
       children.forEach((child) => {
+        const pLabel = entity.info.renderLabel
+        const cLabel = child.info.renderLabel
         result.push({
           key: child.key,
           kind: child.kind,
           type: 'delete',
-          impact: `The ${child.info.renderLabel} ${this.kindToLabel(DataEntityKind)} will become an orphan because it is a child of ${entity.info.renderLabel}.`,
-          resolution: `The ${entity.info.renderLabel} will be removed as the parent parent of ${child.info.renderLabel}.`,
+          impact: `The "${cLabel}" ${this.kindToLabel(DataEntityKind)} will become an orphan because it is a child of the "${pLabel}" entity.`,
+          resolution: `The "${pLabel}" entity will be removed as the parent of the "${cLabel}" entity.`,
           blocking: true,
           relationship: 'child',
         })
@@ -468,8 +470,8 @@ export class ImpactAnalysis {
     return result
   }
 
-  protected deletePropertyAnalysis(key: string): ImpactItem[] {
-    const result: ImpactItem[] = []
+  protected deletePropertyAnalysis(key: string): DomainImpactItem[] {
+    const result: DomainImpactItem[] = []
     const property = this.root.findProperty(key)
     if (!property) {
       return result
@@ -484,8 +486,8 @@ export class ImpactAnalysis {
     return result
   }
 
-  protected deleteAssociationAnalysis(key: string): ImpactItem[] {
-    const result: ImpactItem[] = []
+  protected deleteAssociationAnalysis(key: string): DomainImpactItem[] {
+    const result: DomainImpactItem[] = []
     const association = this.root.findAssociation(key)
     if (!association) {
       return result
@@ -500,7 +502,7 @@ export class ImpactAnalysis {
     return result
   }
 
-  protected kindToLabel(kind: ImpactKinds): string {
+  protected kindToLabel(kind: DomainImpactKinds): string {
     switch (kind) {
       case DataNamespaceKind:
         return 'namespace'

package/src/modeling/types.ts

@@ -6,7 +6,7 @@ export interface DataDomainRemoveOptions {
    * For example, when removing an entity that is a parent to another entity, it will
    * removed itself as a parent from the child entity.
    *
-   * Note, this option should only be used when the ImpactAnalysis has been performed
+   * Note, this option should only be used when the DomainImpactAnalysis has been performed
    * and the user was informed of the impact.
    */
   force?: boolean

package/tests/unit/modeling/impact_analysis.spec.ts

@@ -1,5 +1,5 @@
 import { test } from '@japa/runner'
-import { ImpactAnalysis } from '../../../src/modeling/ImpactAnalysis.js'
+import { DomainImpactAnalysis } from '../../../src/modeling/DomainImpactAnalysis.js'
 import {
   DataNamespaceKind,
   DataEntityKind,
@@ -13,9 +13,9 @@ import { DataModel } from '../../../src/modeling/DataModel.js'
 import { DataProperty } from '../../../src/modeling/DataProperty.js'
 import { DataAssociation } from '../../../src/modeling/DataAssociation.js'
 
-test.group('ImpactAnalysis', (group) => {
+test.group('DomainImpactAnalysis', (group) => {
   let root: DataNamespace
-  let analyzer: ImpactAnalysis
+  let analyzer: DomainImpactAnalysis
   let n1: DataNamespace
   let n2: DataNamespace
   let m1: DataModel
@@ -30,7 +30,7 @@ test.group('ImpactAnalysis', (group) => {
 
   group.each.setup(() => {
     root = new DataNamespace()
-    analyzer = new ImpactAnalysis(root)
+    analyzer = new DomainImpactAnalysis(root)
     n1 = root.addNamespace('n1')
     m1 = root.addDataModel('m1')
     n2 = n1.addNamespace('n2')
@@ -114,8 +114,8 @@ test.group('ImpactAnalysis', (group) => {
     assert.equal(e4r.key, e4.key)
     assert.equal(e4r.kind, DataEntityKind)
     assert.equal(e4r.type, 'delete')
-    assert.equal(e4r.impact, `The e4 entity will become an orphan because it is a child of e3.`)
-    assert.equal(e4r.resolution, `The e3 will be removed as the parent parent of e4.`)
+    assert.equal(e4r.impact, `The "e4" entity will become an orphan because it is a child of the "e3" entity.`)
+    assert.equal(e4r.resolution, `The "e3" entity will be removed as the parent of the "e4" entity.`)
     assert.isTrue(e4r.blocking)
     assert.equal(e4r.relationship, 'child')
 
@@ -189,8 +189,8 @@ test.group('ImpactAnalysis', (group) => {
     assert.equal(e3r.key, e3.key)
     assert.equal(e3r.kind, DataEntityKind)
     assert.equal(e3r.type, 'delete')
-    assert.equal(e3r.impact, `The e3 entity will become an orphan because it is a child of e1.`)
-    assert.equal(e3r.resolution, `The e1 will be removed as the parent parent of e3.`)
+    assert.equal(e3r.impact, `The "e3" entity will become an orphan because it is a child of the "e1" entity.`)
+    assert.equal(e3r.resolution, `The "e1" entity will be removed as the parent of the "e3" entity.`)
     assert.isTrue(e3r.blocking)
     assert.equal(e3r.relationship, 'child')
   })
@@ -234,8 +234,8 @@ test.group('ImpactAnalysis', (group) => {
     assert.equal(e3r.key, e3.key)
     assert.equal(e3r.kind, DataEntityKind)
     assert.equal(e3r.type, 'delete')
-    assert.equal(e3r.impact, `The e3 entity will become an orphan because it is a child of e1.`)
-    assert.equal(e3r.resolution, `The e1 will be removed as the parent parent of e3.`)
+    assert.equal(e3r.impact, `The "e3" entity will become an orphan because it is a child of the "e1" entity.`)
+    assert.equal(e3r.resolution, `The "e1" entity will be removed as the parent of the "e3" entity.`)
     assert.isTrue(e3r.blocking)
     assert.equal(e3r.relationship, 'child')
   })
@@ -304,8 +304,8 @@ test.group('ImpactAnalysis', (group) => {
     assert.equal(e2r.key, e2.key)
     assert.equal(e2r.kind, DataEntityKind)
     assert.equal(e2r.type, 'delete')
-    assert.equal(e2r.impact, `The e2 entity will become an orphan because it is a child of e3.`)
-    assert.equal(e2r.resolution, `The e3 will be removed as the parent parent of e2.`)
+    assert.equal(e2r.impact, `The "e2" entity will become an orphan because it is a child of the "e3" entity.`)
+    assert.equal(e2r.resolution, `The "e3" entity will be removed as the parent of the "e2" entity.`)
     assert.isTrue(e2r.blocking)
     assert.equal(e2r.relationship, 'child')
 
@@ -313,8 +313,8 @@ test.group('ImpactAnalysis', (group) => {
     assert.equal(e4r.key, e4.key)
     assert.equal(e4r.kind, DataEntityKind)
     assert.equal(e4r.type, 'delete')
-    assert.equal(e4r.impact, `The e4 entity will become an orphan because it is a child of e3.`)
-    assert.equal(e4r.resolution, `The e3 will be removed as the parent parent of e4.`)
+    assert.equal(e4r.impact, `The "e4" entity will become an orphan because it is a child of the "e3" entity.`)
+    assert.equal(e4r.resolution, `The "e3" entity will be removed as the parent of the "e4" entity.`)
     assert.isTrue(e4r.blocking)
     assert.equal(e4r.relationship, 'child')
   })
@@ -365,8 +365,8 @@ test.group('ImpactAnalysis', (group) => {
     assert.equal(e3r.key, e3.key)
     assert.equal(e3r.kind, DataEntityKind)
     assert.equal(e3r.type, 'delete')
-    assert.equal(e3r.impact, `The e3 entity will become an orphan because it is a child of e1.`)
-    assert.equal(e3r.resolution, `The e1 will be removed as the parent parent of e3.`)
+    assert.equal(e3r.impact, `The "e3" entity will become an orphan because it is a child of the "e1" entity.`)
+    assert.equal(e3r.resolution, `The "e1" entity will be removed as the parent of the "e3" entity.`)
     assert.isTrue(e3r.blocking)
     assert.equal(e3r.relationship, 'child')
   })

package/build/src/modeling/ImpactAnalysis.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ImpactAnalysis.d.ts","sourceRoot":"","sources":["../../../src/modeling/ImpactAnalysis.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iBAAiB,EACjB,cAAc,EACd,aAAa,EACb,gBAAgB,EAChB,mBAAmB,EACpB,MAAM,oBAAoB,CAAA;AAC3B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AAEvD,MAAM,MAAM,WAAW,GACnB,OAAO,iBAAiB,GACxB,OAAO,cAAc,GACrB,OAAO,aAAa,GACpB,OAAO,gBAAgB,GACvB,OAAO,mBAAmB,CAAA;AAE9B;;GAEG;AACH,UAAU,YAAY;IACpB;;;OAGG;IACH,GAAG,EAAE,MAAM,CAAA;IACX;;;OAGG;IACH,IAAI,EAAE,WAAW,CAAA;IACjB;;OAEG;IACH,MAAM,EAAE,UAAU,EAAE,CAAA;IACpB;;;OAGG;IACH,UAAU,EAAE,OAAO,CAAA;CACpB;AAED,UAAU,UAAU;IAClB;;OAEG;IACH,GAAG,EAAE,MAAM,CAAA;IACX;;OAEG;IACH,IAAI,EAAE,MAAM,CAAA;IACZ;;;;OAIG;IACH,IAAI,EAAE,QAAQ,CAAA;IACd;;OAEG;IACH,MAAM,EAAE,MAAM,CAAA;IACd;;;OAGG;IACH,QAAQ,EAAE,OAAO,CAAA;IACjB;;OAEG;IACH,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB;;OAEG;IACH,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgNG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,MAAM,CAAc;IAC5B,OAAO,CAAC,IAAI,CAAe;gBAEf,IAAI,EAAE,aAAa;IAU/B;;;;;OAKG;IACH,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,GAAG,YAAY;IAkB5D,SAAS,CAAC,kBAAkB,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,GAAG,UAAU,EAAE;IAiB3F,SAAS,CAAC,uBAAuB,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,UAAU,EAAE;IA0B7E,SAAS,CAAC,uBAAuB,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,UAAU,EAAE;IAoB7E,SAAS,CAAC,oBAAoB,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,UAAU,EAAE;IAqF1E,SAAS,CAAC,sBAAsB,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,EAAE;IAgB3D,SAAS,CAAC,yBAAyB,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,EAAE;IAgB9D,SAAS,CAAC,WAAW,CAAC,IAAI,EAAE,WAAW,GAAG,MAAM;CAgBjD"}

package/build/src/modeling/ImpactAnalysis.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ImpactAnalysis.js","sourceRoot":"","sources":["../../../src/modeling/ImpactAnalysis.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  DataNamespaceKind,\n  DataEntityKind,\n  DataModelKind,\n  DataPropertyKind,\n  DataAssociationKind,\n} from '../models/kinds.js'\nimport type { DataNamespace } from './DataNamespace.js'\n\nexport type ImpactKinds =\n  | typeof DataNamespaceKind\n  | typeof DataEntityKind\n  | typeof DataModelKind\n  | typeof DataPropertyKind\n  | typeof DataAssociationKind\n\n/**\n * The impact analysis report\n */\ninterface ImpactReport {\n  /**\n   * The key of the impacted data object.\n   * This is the key of the object that is being changed.\n   */\n  key: string\n  /**\n   * The kind of the impacted data object.\n   * This is the kind of the object that is being changed.\n   */\n  kind: ImpactKinds\n  /**\n   * The list of impacted data objects.\n   */\n  impact: ImpactItem[]\n  /**\n   * Whether it is possible to proceed with the change.\n   * If the change is not possible, the reason will be in the impact list.\n   */\n  canProceed: boolean\n}\n\ninterface ImpactItem {\n  /**\n   * The key of the impacted data object.\n   */\n  key: string\n  /**\n   * The kind of the impacted data object.\n   */\n  kind: string\n  /**\n   * The type of the impact.\n   *\n   * - `delete` - The data object would be deleted.\n   */\n  type: 'delete'\n  /**\n   * The impact description.\n   */\n  impact: string\n  /**\n   * Whether the impact is blocking the operation.\n   * If true, the operation cannot proceed.\n   */\n  blocking: boolean\n  /**\n   * The type of the relationship between two impacted objects.\n   */\n  relationship?: 'child'\n  /**\n   * The resolution of the conflict if the change will be forced.\n   */\n  resolution?: string\n}\n\n/**\n * # ImpactAnalysis\n *\n * The `ImpactAnalysis` class is a powerful tool for analyzing the consequences of deleting data domain objects\n * within a `DataNamespace`.\n * It helps developers understand the ripple effects of removing a namespace, data model, entity, property,\n * or association, ensuring data integrity and preventing unintended side effects.\n *\n * ## Core Concepts\n *\n * -   **Impact Report:** The central output of the `ImpactAnalysis` class is an `ImpactReport`. This report details the\n *     potential consequences of a deletion operation, including:\n *     -   The object being deleted (`key`, `kind`).\n *     -   A list of `ImpactItem` objects, each describing a specific consequence.\n *     -   Whether the deletion can proceed safely (`canProceed`).\n *\n * -   **ImpactItem:** Each `ImpactItem` describes a specific consequence of the deletion. Key properties include:\n *     -   `key`: The key of the impacted object.\n *     -   `kind`: The kind of the impacted object.\n *     -   `type`: The type of impact (currently only `delete`).\n *     -   `impact`: A human-readable description of the impact.\n *     -   `blocking`: Whether this impact prevents the deletion from proceeding.\n *     -   `relationship`: The type of relationship between the deleted object and the impacted object (e.g., `child`).\n *     -   `resolution`: A description of how the impact will be resolved if the deletion is forced.\n *\n * -   **Blocking Impacts:** Some impacts are considered \"blocking,\" meaning they prevent the deletion from proceeding\n *     without manual intervention. For example, deleting an entity that is a parent to other entities is\n *     a blocking impact.\n *\n * -   **Non-Blocking Impacts:** Some impacts are informational and do not prevent the deletion. For example, deleting a\n *     property is not a blocking impact.\n *\n * ## Usage\n *\n * 1.  **Instantiation:** Create an instance of `ImpactAnalysis`, passing the root `DataNamespace` as an argument.\n *\n *     ```typescript\n *     import { DataNamespace } from './DataNamespace'; // Assuming DataNamespace is in the same directory\n *     import { ImpactAnalysis } from './ImpactAnalysis'; // Assuming ImpactAnalysis is in the same directory\n *\n *     const rootNamespace = new DataNamespace();\n *     // ... add some data to the namespace\n *     const analyzer = new ImpactAnalysis(rootNamespace);\n *     ```\n *\n * 2.  **Performing Analysis:** Use the `deleteAnalysis()` method to generate an `ImpactReport` for a specific deletion.\n *     Provide the `key` and `kind` of the object to be deleted.\n *\n *     ```typescript\n *     import { DataEntityKind } from '../models/kinds.js';\n *     // ...\n *     const entityKey = 'some-entity-key';\n *     const report = analyzer.deleteAnalysis(entityKey, DataEntityKind);\n *     ```\n *\n * 3.  **Interpreting the Report:** Examine the `ImpactReport` to understand the consequences of the deletion.\n *     -   Check `report.canProceed` to see if the deletion is safe.\n *     -   Iterate through `report.impact` to understand each consequence.\n *     -   Pay special attention to `impact.blocking` to identify impacts that require manual resolution.\n *\n *     ```typescript\n *     if (report.canProceed) {\n *       // Proceed with deletion\n *     } else {\n *       console.warn('Deletion cannot proceed due to the following impacts:');\n *       report.impact.forEach((item) => {\n *         console.warn(`- ${item.impact}`);\n *         if (item.blocking) {\n *           console.warn(`  - This impact is blocking.`);\n *           if (item.resolution) {\n *             console.warn(`  - Resolution: ${item.resolution}`);\n *           }\n *         }\n *       });\n *       // Handle blocking impacts (e.g., prompt the user, modify the data, etc.)\n *     }\n *     ```\n *\n * ## Supported Deletion Scenarios\n *\n * The `ImpactAnalysis` class supports analyzing the deletion of the following data domain object types:\n *\n * -   **Namespaces (`DataNamespaceKind`):** Deleting a namespace also impacts all its child namespaces,\n *     data models, entities, properties, and associations.\n * -   **Data Models (`DataModelKind`):** Deleting a data model impacts all its entities, properties, and associations.\n * -   **Entities (`DataEntityKind`):** Deleting an entity impacts its properties, associations, and any other\n *     entities that have it as a parent or target in an association.\n * -   **Properties (`DataPropertyKind`):** Deleting a property impacts the entity it belongs to.\n * -   **Associations (`DataAssociationKind`):** Deleting an association impacts the entity it belongs to.\n *\n * ## Example: Deleting an Entity\n *\n * Consider the following scenario:\n *\n * -   Namespace: `MyNamespace`\n *     -   Data Model: `ProductModel`\n *         -   Entity: `Product`\n *             -   Property: `name`\n *             -   Association: `category` (targets `Category` entity)\n *         -   Entity: `Category`\n *             - Property: `name`\n *         - Entity: `SpecialProduct` (parent: `Product`)\n *\n * If you attempt to delete the `Product` entity, the `ImpactAnalysis` will generate a report similar to this:\n *\n * ```json\n * {\n *   \"key\": \"Product\",\n *   \"kind\": \"DataEntityKind\",\n *   \"impact\": [\n *     {\n *       \"key\": \"Product\",\n *       \"kind\": \"DataEntityKind\",\n *       \"type\": \"delete\",\n *       \"impact\": \"The entity with key Product will be deleted.\",\n *       \"blocking\": false\n *     },\n *     {\n *       \"key\": \"SpecialProduct\",\n *       \"kind\": \"DataEntityKind\",\n *       \"type\": \"delete\",\n *       \"impact\": \"The SpecialProduct entity will become an orphan because it is a child of Product.\",\n *       \"resolution\": \"The Product will be removed as the parent parent of SpecialProduct.\",\n *       \"blocking\": true,\n *       \"relationship\": \"child\"\n *     },\n *     {\n *       \"key\": \"category\",\n *       \"kind\": \"DataAssociationKind\",\n *       \"type\": \"delete\",\n *       \"impact\": \"The association with key category will be broken because it has a target to Product.\",\n *       \"resolution\": \"The association with key category will be removed from Product.\",\n *       \"blocking\": true\n *     },\n *     {\n *       \"key\": \"name\",\n *       \"kind\": \"DataPropertyKind\",\n *       \"type\": \"delete\",\n *       \"impact\": \"The property with key name will be deleted.\",\n *       \"blocking\": false\n *     }\n *   ],\n *   \"canProceed\": false\n * }\n * ```\n *\n * This report indicates that:\n *\n * -   The `Product` entity will be deleted.\n * -   The `SpecialProduct` entity will become an orphan (blocking).\n * -   The `category` association will be broken (blocking).\n * -   The `name` property will be deleted.\n * -   The deletion cannot proceed without addressing the blocking impacts.\n *\n * ## Types\n *\n * ### `ImpactKinds`\n *\n * -   **Description:** A type alias for the kinds of data domain objects that can be analyzed.\n * -   **Values:**\n *     -   `DataNamespaceKind`\n *     -   `DataEntityKind`\n *     -   `DataModelKind`\n *     -   `DataPropertyKind`\n *     -   `DataAssociationKind`\n *\n * ### `ImpactReport`\n *\n * -   **Description:** The structure of the impact analysis report.\n * -   **Properties:**\n *     -   `key` (`string`): The key of the object being deleted.\n *     -   `kind` (`ImpactKinds`): The kind of the object being deleted.\n *     -   `impact` (`ImpactItem[]`): The list of impacts.\n *     -   `canProceed` (`boolean`): Whether the deletion can proceed.\n *\n * ### `ImpactItem`\n *\n * -   **Description:** The structure of an individual impact item.\n * -   **Properties:**\n *     -   `key` (`string`): The key of the impacted object.\n *     -   `kind` (`string`): The kind of the impacted object.\n *     -   `type` (`'delete'`): The type of impact.\n *     -   `impact` (`string`): The impact description.\n *     -   `blocking` (`boolean`): Whether the impact is blocking.\n *     -   `relationship` (`'child'`, optional): The relationship type.\n *     -   `resolution` (`string`, optional): The resolution description.\n *\n * ## Error Handling\n *\n * The `ImpactAnalysis` class does not throw errors. Instead, it uses the `ImpactReport` to communicate\n * the results of the analysis, including any blocking impacts.\n *\n * ## Best Practices\n *\n * - **Always Analyze Before Deleting:** Before deleting any data domain object, always use `ImpactAnalysis`\n *   to understand the consequences.\n * - **Handle Blocking Impacts:** Pay close attention to `blocking` impacts and implement appropriate\n *   logic to handle them.\n * - **Inform the User:** If a deletion cannot proceed, inform the user about the blocking impacts and provide\n *   guidance on how to resolve them.\n * - **Consider Forced Deletion:** In some cases, you may want to allow users to force a deletion even if there are\n *   blocking impacts. In such cases, you should clearly communicate the risks to the user.\n *\n * ## Conclusion\n *\n * The `ImpactAnalysis` class is an essential tool for maintaining data integrity when working with complex\n * data domain models. By providing detailed impact reports, it empowers developers to make informed decisions\n * about data deletion and prevent unintended consequences.\n */\nexport class ImpactAnalysis {\n  private report: ImpactReport\n  private root: DataNamespace\n\n  constructor(root: DataNamespace) {\n    this.root = root\n    this.report = {\n      key: '',\n      kind: DataNamespaceKind,\n      impact: [],\n      canProceed: false,\n    }\n  }\n\n  /**\n   * Generates a report of how the data domain will be impacted by the deletion of a data domain object.\n   * @param key The key of the impacted data domain object.\n   * @param kind The kind of the impacted data object.\n   * @returns The delete impact analysis report.\n   */\n  deleteAnalysis(key: string, kind: ImpactKinds): ImpactReport {\n    this.report = {\n      key,\n      kind,\n      impact: [],\n      canProceed: true,\n    }\n    this.report.impact = this.createDeleteImpact(key, kind, key)\n    // this.report.impact.unshift({\n    //   key,\n    //   kind,\n    //   type: 'delete',\n    //   impact: `The ${this.kindToLabel(kind)} with key ${key} will be deleted.`,\n    //   blocking: false,\n    // })\n    return this.report\n  }\n\n  protected createDeleteImpact(key: string, kind: ImpactKinds, rootKey: string): ImpactItem[] {\n    switch (kind) {\n      case DataNamespaceKind:\n        return this.deleteNamespaceAnalysis(key, rootKey)\n      case DataModelKind:\n        return this.deleteDataModelAnalysis(key, rootKey)\n      case DataEntityKind:\n        return this.deleteEntityAnalysis(key, rootKey)\n      case DataPropertyKind:\n        return this.deletePropertyAnalysis(key)\n      case DataAssociationKind:\n        return this.deleteAssociationAnalysis(key)\n      default:\n        return []\n    }\n  }\n\n  protected deleteNamespaceAnalysis(key: string, rootKey: string): ImpactItem[] {\n    const result: ImpactItem[] = []\n    const ns = this.root.findNamespace(key)\n    if (!ns) {\n      return result\n    }\n    result.push({\n      key: ns.key,\n      kind: ns.kind,\n      type: 'delete',\n      impact: `The ${ns.info.renderLabel} ${this.kindToLabel(DataNamespaceKind)} will be deleted.`,\n      blocking: false,\n    })\n    const namespaces = ns.listNamespaces()\n    namespaces.forEach((child) => {\n      const items = this.deleteNamespaceAnalysis(child.key, rootKey)\n      result.push(...items)\n    })\n    const models = ns.listDataModels()\n    models.forEach((child) => {\n      const items = this.deleteDataModelAnalysis(child.key, rootKey)\n      result.push(...items)\n    })\n    return result\n  }\n\n  protected deleteDataModelAnalysis(key: string, rootKey: string): ImpactItem[] {\n    const result: ImpactItem[] = []\n    const model = this.root.findDataModel(key)\n    if (!model) {\n      return result\n    }\n    result.push({\n      key: model.key,\n      kind: model.kind,\n      type: 'delete',\n      impact: `The ${model.info.renderLabel} ${this.kindToLabel(DataModelKind)} will be deleted.`,\n      blocking: false,\n    })\n    model.entities.forEach((child) => {\n      const items = this.deleteEntityAnalysis(child.key, rootKey)\n      result.push(...items)\n    })\n    return result\n  }\n\n  protected deleteEntityAnalysis(key: string, rootKey: string): ImpactItem[] {\n    const result: ImpactItem[] = []\n    const entity = this.root.findEntity(key)\n    if (!entity) {\n      return result\n    }\n    result.push({\n      key: entity.key,\n      kind: entity.kind,\n      type: 'delete',\n      impact: `The ${entity.info.renderLabel} ${this.kindToLabel(DataEntityKind)} will be deleted.`,\n      blocking: false,\n    })\n    // We need to know whether the entity is a parent of another entity\n    const children = this.root.definitions.entities.filter((domainEntity) => {\n      if (domainEntity.key === entity.key) {\n        // ignore self\n        return false\n      }\n      if (!domainEntity.parents.includes(entity.key)) {\n        // no relationship\n        return false\n      }\n      if (domainEntity.isChildOf(rootKey)) {\n        // No need to include this parent as it itself is being deleted\n        return false\n      }\n      // the entity has a parent-child relationship to the deleted entity.\n      return true\n    })\n    if (children.length) {\n      children.forEach((child) => {\n        result.push({\n          key: child.key,\n          kind: child.kind,\n          type: 'delete',\n          impact: `The ${child.info.renderLabel} ${this.kindToLabel(DataEntityKind)} will become an orphan because it is a child of ${entity.info.renderLabel}.`,\n          resolution: `The ${entity.info.renderLabel} will be removed as the parent parent of ${child.info.renderLabel}.`,\n          blocking: true,\n          relationship: 'child',\n        })\n      })\n      this.report.canProceed = false\n    }\n    // We need to know whether there's another entity that has an association to this entity.\n    const inAssociations = this.root.definitions.associations.filter((association) => {\n      return association.targets.some((item) => {\n        if (item.key === entity.key) {\n          const related = association.getParentInstance()\n          if (!related) {\n            return false\n          }\n          if (related.isChildOf(rootKey)) {\n            // No need to include this association as the related entity itself is being deleted\n            return false\n          }\n          return true\n        }\n        return false\n      })\n    })\n    if (inAssociations.length) {\n      inAssociations.forEach((association) => {\n        result.push({\n          key: association.key,\n          kind: association.kind,\n          type: 'delete',\n          impact: `The ${association.info.renderLabel} ${this.kindToLabel(DataAssociationKind)} will be broken because it has a target to ${entity.info.renderLabel}.`,\n          resolution: `The ${association.info.renderLabel} ${this.kindToLabel(DataAssociationKind)} will be removed from ${entity.info.renderLabel}.`,\n          blocking: true,\n        })\n      })\n      this.report.canProceed = false\n    }\n    entity.properties.forEach((child) => {\n      const items = this.deletePropertyAnalysis(child.key)\n      result.push(...items)\n    })\n    entity.associations.forEach((child) => {\n      const items = this.deleteAssociationAnalysis(child.key)\n      result.push(...items)\n    })\n    return result\n  }\n\n  protected deletePropertyAnalysis(key: string): ImpactItem[] {\n    const result: ImpactItem[] = []\n    const property = this.root.findProperty(key)\n    if (!property) {\n      return result\n    }\n    result.push({\n      key: property.key,\n      kind: property.kind,\n      type: 'delete',\n      impact: `The ${property.info.renderLabel} ${this.kindToLabel(DataPropertyKind)} will be deleted.`,\n      blocking: false,\n    })\n    return result\n  }\n\n  protected deleteAssociationAnalysis(key: string): ImpactItem[] {\n    const result: ImpactItem[] = []\n    const association = this.root.findAssociation(key)\n    if (!association) {\n      return result\n    }\n    result.push({\n      key: association.key,\n      kind: association.kind,\n      type: 'delete',\n      impact: `The ${association.info.renderLabel} ${this.kindToLabel(DataAssociationKind)} will be deleted.`,\n      blocking: false,\n    })\n    return result\n  }\n\n  protected kindToLabel(kind: ImpactKinds): string {\n    switch (kind) {\n      case DataNamespaceKind:\n        return 'namespace'\n      case DataEntityKind:\n        return 'entity'\n      case DataModelKind:\n        return 'data model'\n      case DataPropertyKind:\n        return 'property'\n      case DataAssociationKind:\n        return 'association'\n      default:\n        return 'unknown'\n    }\n  }\n}\n"]}