@api-client/core 0.11.6 → 0.11.8

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

@@ -475,7 +475,6 @@ test.group('remove()', (group) => {
   })
 
   test('throws when removing an entity that is a target', ({ assert }) => {
-    // const e3 = m1.addEntity('e3')
     e2.addTargetAssociation(e1.key)
     assert.throws(
       () => e1.remove(),
@@ -483,6 +482,47 @@ test.group('remove()', (group) => {
       `Cannot remove entity ${e1.info.name} because it is used as a target in associations in entities: e2.`
     )
   })
+
+  test('force removes an entity that is a target', ({ assert }) => {
+    e2.addTargetAssociation(e1.key)
+    e1.remove({ force: true })
+    assert.deepEqual(m1.entities, [e2])
+    assert.deepEqual(root.definitions.entities, [e2])
+    assert.deepEqual(e2.associations, [], 'removes the association from the target entity')
+    assert.deepEqual(e2.fields, [], 'removes the association from the entity fields')
+    assert.deepEqual(root.definitions.associations, [], 'removes the association from the root definitions')
+  })
+
+  test('throws when removing an entity that is a parent', ({ assert }) => {
+    const e3 = m1.addEntity('e3')
+    e3.addParent(e1.key)
+    assert.throws(
+      () => e1.remove(),
+      RemoveEntityException as unknown as ErrorConstructor,
+      `Cannot remove entity ${e1.info.name} because it is a parent for the following entities: e3.`
+    )
+  })
+
+  test('force removes an entity that is a parent', ({ assert }) => {
+    const e3 = m1.addEntity('e3')
+    e3.addParent(e1.key)
+    e1.remove({ force: true })
+    assert.deepEqual(m1.entities, [e2, e3])
+    assert.deepEqual(root.definitions.entities, [e2, e3])
+    assert.deepEqual(e3.parents, [], 'removes the parent from the child entity')
+  })
+
+  test('force removes an entity that is a parent and a target', ({ assert }) => {
+    const e3 = m1.addEntity('e3')
+    e3.addParent(e1.key)
+    e2.addTargetAssociation(e1.key)
+    e1.remove({ force: true })
+    assert.deepEqual(m1.entities, [e2, e3])
+    assert.deepEqual(root.definitions.entities, [e2, e3])
+    assert.deepEqual(e3.parents, [], 'removes the parent from the child entity')
+    assert.deepEqual(e2.associations, [], 'removes the association from the target entity')
+    assert.deepEqual(root.definitions.associations, [], 'removes the association from the root definitions')
+  })
 })
 
 test.group('addTypedProperty()', (group) => {
@@ -1947,3 +1987,73 @@ test.group('moveField()', (group) => {
     assert.throws(() => e1.moveField(p1.key, 4), ValidationError as unknown as ErrorConstructor, 'Validation failure')
   })
 })
+
+test.group('DataEntity.isChildOf()', (group) => {
+  let root: DataNamespace
+  let n1: DataNamespace
+  let n2: DataNamespace
+  let m1: DataModel
+  let m2: DataModel
+  let e1: DataEntity
+  let e2: DataEntity
+  let e3: DataEntity
+
+  group.each.setup(() => {
+    root = new DataNamespace()
+    n1 = root.addNamespace('n1')
+    n2 = n1.addNamespace('n2')
+    m1 = root.addDataModel('m1')
+    m2 = n1.addDataModel('m2')
+    e1 = m1.addEntity('e1')
+    e2 = m2.addEntity('e2')
+    e3 = n2.addDataModel('m3').addEntity('e3')
+  })
+
+  test('returns false when called on an entity not in a data model', ({ assert }) => {
+    const e4 = new DataEntity(root)
+    const result = e4.isChildOf('some-key')
+    assert.isFalse(result)
+  })
+
+  test('returns false when called on self', ({ assert }) => {
+    const result = e2.isChildOf(e2.key)
+    assert.isFalse(result)
+  })
+
+  test('returns true when called on a direct parent', ({ assert }) => {
+    const result = e2.isChildOf(m2.key)
+    assert.isTrue(result)
+  })
+
+  test('returns true when called on a grandparent', ({ assert }) => {
+    const result = e3.isChildOf(root.key)
+    assert.isTrue(result)
+  })
+
+  test('returns false when called on a sibling', ({ assert }) => {
+    const e4 = m1.addEntity('e4')
+    const result = e1.isChildOf(e4.key)
+    assert.isFalse(result)
+  })
+
+  test('returns false when called on a child', ({ assert }) => {
+    const p1 = e2.addNamedProperty('p1')
+    const result = e2.isChildOf(p1.key)
+    assert.isFalse(result)
+  })
+
+  test('returns false when called on a non-existent namespace', ({ assert }) => {
+    const result = e2.isChildOf('non-existent-key')
+    assert.isFalse(result)
+  })
+
+  test('returns true when called on a grandparent', ({ assert }) => {
+    const result = e3.isChildOf(n1.key)
+    assert.isTrue(result)
+  })
+
+  test('returns true when called on a data model in the same namespace', ({ assert }) => {
+    const result = e1.isChildOf(m1.key)
+    assert.isTrue(result)
+  })
+})

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

@@ -339,3 +339,57 @@ test.group('adaptEntity()', (group) => {
     assert.throws(() => dm2.adaptEntity(e1, { index: 1 }), `The index 1 is not valid.`)
   })
 })
+
+test.group('isChildOf()', (group) => {
+  let root: DataNamespace
+  let n1: DataNamespace
+  let n2: DataNamespace
+  let m1: DataModel
+  let m2: DataModel
+  let m3: DataModel
+
+  group.each.setup(() => {
+    root = new DataNamespace()
+    n1 = root.addNamespace('n1')
+    n2 = n1.addNamespace('n2')
+    m1 = root.addDataModel('m1')
+    m2 = n1.addDataModel('m2')
+    m3 = n2.addDataModel('m3')
+  })
+
+  test('returns false when called on the root data model', ({ assert }) => {
+    const result = m1.isChildOf('some-key')
+    assert.isFalse(result)
+  })
+
+  test('returns true when called on a direct child', ({ assert }) => {
+    const result = m2.isChildOf(n1.key)
+    assert.isTrue(result)
+  })
+
+  test('returns true when called on a grandchild', ({ assert }) => {
+    const result = m3.isChildOf(root.key)
+    assert.isTrue(result)
+  })
+
+  test('returns false when called on a sibling', ({ assert }) => {
+    const m4 = root.addDataModel('m4')
+    const result = m1.isChildOf(m4.key)
+    assert.isFalse(result)
+  })
+
+  test('returns false when called on a parent', ({ assert }) => {
+    const result = n1.isChildOf(m2.key)
+    assert.isFalse(result)
+  })
+
+  test('returns false when called on a non-existent namespace', ({ assert }) => {
+    const result = m2.isChildOf('non-existent-key')
+    assert.isFalse(result)
+  })
+
+  test('returns false when called on self', ({ assert }) => {
+    const result = m2.isChildOf(m2.key)
+    assert.isFalse(result)
+  })
+})

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

@@ -1263,7 +1263,7 @@ test.group('adaptDataModel()', (group) => {
     assert.throws(() => n2.adaptDataModel(m1, { index: 1 }), `The index 1 is not valid.`)
   })
 
-  test('throws when adapting a data model from another namepsace', ({ assert }) => {
+  test('throws when adapting a data model from another namespace', ({ assert }) => {
     const otherRoot = new DataNamespace()
     const otherModel = new DataModel(otherRoot)
     assert.throws(
@@ -1272,3 +1272,48 @@ test.group('adaptDataModel()', (group) => {
     )
   })
 })
+
+test.group('isChildOf()', (group) => {
+  let root: DataNamespace
+  let n1: DataNamespace
+  let n2: DataNamespace
+  let n3: DataNamespace
+
+  group.each.setup(() => {
+    root = new DataNamespace()
+    n1 = root.addNamespace('n1')
+    n2 = n1.addNamespace('n2')
+    n3 = n2.addNamespace('n3')
+  })
+
+  test('returns false when called on the root namespace', ({ assert }) => {
+    const result = root.isChildOf('some-key')
+    assert.isFalse(result)
+  })
+
+  test('returns true when called on a direct child', ({ assert }) => {
+    const result = n1.isChildOf(root.key)
+    assert.isTrue(result)
+  })
+
+  test('returns true when called on a grandchild', ({ assert }) => {
+    const result = n3.isChildOf(root.key)
+    assert.isTrue(result)
+  })
+
+  test('returns false when called on a sibling', ({ assert }) => {
+    const n4 = root.addNamespace('n4')
+    const result = n1.isChildOf(n4.key)
+    assert.isFalse(result)
+  })
+
+  test('returns false when called on a parent', ({ assert }) => {
+    const result = root.isChildOf(n1.key)
+    assert.isFalse(result)
+  })
+
+  test('returns false when called on a non-existent namespace', ({ assert }) => {
+    const result = n1.isChildOf('non-existent-key')
+    assert.isFalse(result)
+  })
+})

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

@@ -815,3 +815,76 @@ test.group('readBinding()', () => {
     assert.isUndefined(binding)
   })
 })
+
+test.group('DataProperty.isChildOf()', (group) => {
+  let root: DataNamespace
+  let n1: DataNamespace
+  let n2: DataNamespace
+  let m1: DataModel
+  let m2: DataModel
+  let e1: DataEntity
+  let e2: DataEntity
+  let p1: DataProperty
+  let p2: DataProperty
+  let p3: DataProperty
+
+  group.each.setup(() => {
+    root = new DataNamespace()
+    n1 = root.addNamespace('n1')
+    n2 = n1.addNamespace('n2')
+    m1 = root.addDataModel('m1')
+    m2 = n1.addDataModel('m2')
+    e1 = m1.addEntity('e1')
+    e2 = m2.addEntity('e2')
+    p1 = e1.addNamedProperty('p1')
+    p2 = e2.addNamedProperty('p2')
+    p3 = n2.addDataModel('m3').addEntity('e3').addNamedProperty('p3')
+  })
+
+  test('returns false when called on a property not in an entity', ({ assert }) => {
+    const p4 = new DataProperty(root)
+    const result = p4.isChildOf('some-key')
+    assert.isFalse(result)
+  })
+
+  test('returns false when called on self', ({ assert }) => {
+    const result = p2.isChildOf(p2.key)
+    assert.isFalse(result)
+  })
+
+  test('returns true when called on a direct parent', ({ assert }) => {
+    const result = p2.isChildOf(e2.key)
+    assert.isTrue(result)
+  })
+
+  test('returns true when called on a grandparent', ({ assert }) => {
+    const result = p3.isChildOf(root.key)
+    assert.isTrue(result)
+  })
+
+  test('returns false when called on a sibling', ({ assert }) => {
+    const p4 = e1.addNamedProperty('p4')
+    const result = p1.isChildOf(p4.key)
+    assert.isFalse(result)
+  })
+
+  test('returns false when called on a child', ({ assert }) => {
+    const result = e2.isChildOf(p2.key)
+    assert.isFalse(result)
+  })
+
+  test('returns false when called on a non-existent namespace', ({ assert }) => {
+    const result = p2.isChildOf('non-existent-key')
+    assert.isFalse(result)
+  })
+
+  test('returns true when called on a grandparent', ({ assert }) => {
+    const result = p3.isChildOf(n1.key)
+    assert.isTrue(result)
+  })
+
+  test('returns true when called on a data model in the same namespace', ({ assert }) => {
+    const result = p1.isChildOf(m1.key)
+    assert.isTrue(result)
+  })
+})

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

@@ -0,0 +1,373 @@
+import { test } from '@japa/runner'
+import { ImpactAnalysis } from '../../../src/modeling/ImpactAnalysis.js'
+import {
+  DataNamespaceKind,
+  DataEntityKind,
+  DataModelKind,
+  DataPropertyKind,
+  DataAssociationKind,
+} from '../../../src/models/kinds.js'
+import { DataNamespace } from '../../../src/modeling/DataNamespace.js'
+import { DataEntity } from '../../../src/modeling/DataEntity.js'
+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) => {
+  let root: DataNamespace
+  let analyzer: ImpactAnalysis
+  let n1: DataNamespace
+  let n2: DataNamespace
+  let m1: DataModel
+  let m2: DataModel
+  let m3: DataModel
+  let e1: DataEntity
+  let e2: DataEntity
+  let e3: DataEntity
+  let e4: DataEntity
+  let p1: DataProperty
+  let a1: DataAssociation
+
+  group.each.setup(() => {
+    root = new DataNamespace()
+    analyzer = new ImpactAnalysis(root)
+    n1 = root.addNamespace('n1')
+    m1 = root.addDataModel('m1')
+    n2 = n1.addNamespace('n2')
+    m2 = n1.addDataModel('m2')
+    e1 = m1.addEntity('e1')
+    e2 = m2.addEntity('e2')
+    m3 = n2.addDataModel('m3')
+    e3 = m3.addEntity('e3')
+    p1 = e1.addNamedProperty('p1')
+    a1 = e1.addNamedAssociation('a1')
+    a1.addTarget(e2)
+    e2.addParent(e3.key)
+    e3.addParent(e1.key)
+    e4 = root.addDataModel('m4').addEntity('e4')
+    e4.addParent(e3.key)
+    // DataNamespace (root)
+    // ├── DataNamespace (n1)
+    // │   ├── DataModel (m2)
+    // │   │   └── DataEntity (e2)
+    // │   │       └── parent: DataEntity (e3)
+    // │   └── DataNamespace (n2)
+    // │       └── DataModel (m3)
+    // │           └── DataEntity (e3)
+    // │               └── parent: DataEntity (e1)
+    // ├── DataModel (m1)
+    // │   └── DataEntity (e1)
+    // │       ├── DataProperty (p1)
+    // │       └── DataAssociation (a1)
+    // │           └── target: DataEntity (e2)
+    // └── DataModel (m4)
+    //     └── DataEntity (e4)
+    //         └── parent: DataEntity (e3)
+  })
+
+  test('returns a report for deleting a namespace', ({ assert }) => {
+    const report = analyzer.deleteAnalysis(n1.key, DataNamespaceKind)
+    assert.equal(report.key, n1.key)
+    assert.equal(report.kind, DataNamespaceKind)
+    assert.isFalse(report.canProceed, 'operation should not be able to proceed')
+    // Affected items:
+    // - n1 (self)
+    // - m2 (child)
+    // - e2 (child), note, e3 parent is not included because it is included in the deletion.
+    // - n2 (child)
+    // - m3 (child)
+    // - e3 (child)
+    // - a1 (target of e2)
+    // - e4 (parent of e3)
+    assert.lengthOf(report.impact, 8, 'has all items')
+    const [n1r, n2r, m3r, e3r, e4r, m2r, e2r, a1r] = report.impact
+
+    assert.ok(n1r)
+    assert.equal(n1r.key, n1.key)
+    assert.equal(n1r.kind, DataNamespaceKind)
+    assert.equal(n1r.type, 'delete')
+    assert.equal(n1r.impact, `The n1 namespace will be deleted.`)
+    assert.isFalse(n1r.blocking)
+
+    assert.ok(n2r)
+    assert.equal(n2r.key, n2.key)
+    assert.equal(n2r.kind, DataNamespaceKind)
+    assert.equal(n2r.type, 'delete')
+    assert.equal(n2r.impact, `The n2 namespace will be deleted.`)
+    assert.isFalse(n2r.blocking)
+
+    assert.ok(m3r)
+    assert.equal(m3r.key, m3.key)
+    assert.equal(m3r.kind, DataModelKind)
+    assert.equal(m3r.type, 'delete')
+    assert.equal(m3r.impact, `The m3 data model will be deleted.`)
+    assert.isFalse(m3r.blocking)
+
+    assert.ok(e3r)
+    assert.equal(e3r.key, e3.key)
+    assert.equal(e3r.kind, DataEntityKind)
+    assert.equal(e3r.type, 'delete')
+    assert.equal(e3r.impact, `The e3 entity will be deleted.`)
+    assert.isFalse(e3r.blocking)
+
+    assert.ok(e4r)
+    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.isTrue(e4r.blocking)
+    assert.equal(e4r.relationship, 'child')
+
+    assert.ok(m2r)
+    assert.equal(m2r.key, m2.key)
+    assert.equal(m2r.kind, DataModelKind)
+    assert.equal(m2r.type, 'delete')
+    assert.equal(m2r.impact, `The m2 data model will be deleted.`)
+    assert.isFalse(m2r.blocking)
+
+    assert.ok(e2r)
+    assert.equal(e2r.key, e2.key)
+    assert.equal(e2r.kind, DataEntityKind)
+    assert.equal(e2r.type, 'delete')
+    assert.equal(e2r.impact, `The e2 entity will be deleted.`)
+    assert.isFalse(e2r.blocking)
+
+    assert.ok(a1r)
+    assert.equal(a1r.key, a1.key)
+    assert.equal(a1r.kind, DataAssociationKind)
+    assert.equal(a1r.type, 'delete')
+    assert.equal(a1r.impact, `The a1 association will be broken because it has a target to e2.`)
+    assert.equal(a1r.resolution, `The a1 association will be removed from e2.`)
+    assert.isTrue(a1r.blocking)
+  })
+
+  test('returns a report for deleting a data model', ({ assert }) => {
+    const report = analyzer.deleteAnalysis(m1.key, DataModelKind)
+    assert.equal(report.key, m1.key)
+    assert.equal(report.kind, DataModelKind)
+    assert.isFalse(report.canProceed, 'operation should not be able to proceed')
+
+    // Affected items:
+    // - m1 (self)
+    // - e1 (child)
+    // - p1 (child of e1)
+    // - a1 (child of e1)
+    // - e3 (parent of e4)
+    assert.lengthOf(report.impact, 5, 'has all items')
+    const [m1r, e1r, e3r, p1r, a1r] = report.impact
+
+    assert.ok(m1r)
+    assert.equal(m1r.key, m1.key)
+    assert.equal(m1r.kind, DataModelKind)
+    assert.equal(m1r.type, 'delete')
+    assert.equal(m1r.impact, `The m1 data model will be deleted.`)
+    assert.isFalse(m1r.blocking)
+
+    assert.ok(e1r)
+    assert.equal(e1r.key, e1.key)
+    assert.equal(e1r.kind, DataEntityKind)
+    assert.equal(e1r.type, 'delete')
+    assert.equal(e1r.impact, `The e1 entity will be deleted.`)
+    assert.isFalse(e1r.blocking)
+
+    assert.ok(p1r)
+    assert.equal(p1r.key, p1.key)
+    assert.equal(p1r.kind, DataPropertyKind)
+    assert.equal(p1r.type, 'delete')
+    assert.equal(p1r.impact, `The p1 property will be deleted.`)
+    assert.isFalse(p1r.blocking)
+
+    assert.ok(a1r)
+    assert.equal(a1r.key, a1.key)
+    assert.equal(a1r.kind, DataAssociationKind)
+    assert.equal(a1r.type, 'delete')
+    assert.equal(a1r.impact, `The a1 association will be deleted.`)
+    assert.isFalse(a1r.blocking)
+
+    assert.ok(e3r)
+    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.isTrue(e3r.blocking)
+    assert.equal(e3r.relationship, 'child')
+  })
+
+  test('returns a report for deleting an entity', ({ assert }) => {
+    const report = analyzer.deleteAnalysis(e1.key, DataEntityKind)
+    assert.equal(report.key, e1.key)
+    assert.equal(report.kind, DataEntityKind)
+    assert.isFalse(report.canProceed, 'operation should not be able to proceed')
+
+    // Affected items:
+    // - e1 (self)
+    // - e3 (parent)
+    // - p1 (child)
+    // - a1 (child)
+    assert.lengthOf(report.impact, 4, 'has all items')
+    const [e1r, e3r, p1r, a1r] = report.impact
+
+    assert.ok(e1r)
+    assert.equal(e1r.key, e1.key)
+    assert.equal(e1r.kind, DataEntityKind)
+    assert.equal(e1r.type, 'delete')
+    assert.equal(e1r.impact, `The e1 entity will be deleted.`)
+    assert.isFalse(e1r.blocking)
+
+    assert.ok(p1r)
+    assert.equal(p1r.key, p1.key)
+    assert.equal(p1r.kind, DataPropertyKind)
+    assert.equal(p1r.type, 'delete')
+    assert.equal(p1r.impact, `The p1 property will be deleted.`)
+    assert.isFalse(p1r.blocking)
+
+    assert.ok(a1r)
+    assert.equal(a1r.key, a1.key)
+    assert.equal(a1r.kind, DataAssociationKind)
+    assert.equal(a1r.type, 'delete')
+    assert.equal(a1r.impact, `The a1 association will be deleted.`)
+    assert.isFalse(a1r.blocking)
+
+    assert.ok(e3r)
+    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.isTrue(e3r.blocking)
+    assert.equal(e3r.relationship, 'child')
+  })
+
+  test('returns a report for deleting a property', ({ assert }) => {
+    p1.getWebBinding().hidden = true
+    const report = analyzer.deleteAnalysis(p1.key, DataPropertyKind)
+    assert.equal(report.key, p1.key)
+    assert.equal(report.kind, DataPropertyKind)
+    assert.isTrue(report.canProceed, 'operation should be able to proceed')
+
+    // Affected items:
+    // - p1 (self)
+    assert.lengthOf(report.impact, 1, 'has all items')
+    const [p1r] = report.impact
+
+    assert.ok(p1r)
+    assert.equal(p1r.key, p1.key)
+    assert.equal(p1r.kind, DataPropertyKind)
+    assert.equal(p1r.type, 'delete')
+    assert.equal(p1r.impact, `The p1 property will be deleted.`)
+    assert.isFalse(p1r.blocking)
+  })
+
+  test('returns a report for deleting an association', ({ assert }) => {
+    a1.getWebBinding().hidden = true
+    const report = analyzer.deleteAnalysis(a1.key, DataAssociationKind)
+    assert.equal(report.key, a1.key)
+    assert.equal(report.kind, DataAssociationKind)
+    assert.isTrue(report.canProceed, 'operation should be able to proceed')
+
+    // Affected items:
+    // - a1 (self)
+    assert.lengthOf(report.impact, 1, 'has all items')
+    const [a1r] = report.impact
+
+    assert.ok(a1r)
+    assert.equal(a1r.key, a1.key)
+    assert.equal(a1r.kind, DataAssociationKind)
+    assert.equal(a1r.type, 'delete')
+    assert.equal(a1r.impact, `The a1 association will be deleted.`)
+    assert.isFalse(a1r.blocking)
+  })
+
+  test('handles circular dependencies', ({ assert }) => {
+    const report = analyzer.deleteAnalysis(e3.key, DataEntityKind)
+    assert.equal(report.key, e3.key)
+    assert.equal(report.kind, DataEntityKind)
+    assert.isFalse(report.canProceed, 'operation should not be able to proceed')
+
+    // Affected items:
+    // - e3 (self)
+    // - e2 (target of a1)
+    // - e4 (child)
+    assert.lengthOf(report.impact, 3, 'has all items')
+    const [e3r, e2r, e4r] = report.impact
+
+    assert.ok(e3r)
+    assert.equal(e3r.key, e3.key)
+    assert.equal(e3r.kind, DataEntityKind)
+    assert.equal(e3r.type, 'delete')
+    assert.equal(e3r.impact, `The e3 entity will be deleted.`)
+    assert.isFalse(e3r.blocking)
+
+    assert.ok(e2r)
+    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.isTrue(e2r.blocking)
+    assert.equal(e2r.relationship, 'child')
+
+    assert.ok(e4r)
+    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.isTrue(e4r.blocking)
+    assert.equal(e4r.relationship, 'child')
+  })
+
+  test('deleteAnalysis() handles foreign namespaces', ({ assert }) => {
+    const f1 = new DataNamespace()
+    const fm1 = f1.addDataModel('fm1')
+    const fe1 = fm1.addEntity('fe1')
+    root.addForeign(f1)
+    a1.addTarget(fe1)
+
+    const report = analyzer.deleteAnalysis(e1.key, DataEntityKind)
+    // console.log(JSON.stringify(report.impact, null, 2))
+    assert.equal(report.key, e1.key)
+    assert.equal(report.kind, DataEntityKind)
+    assert.isFalse(report.canProceed, 'operation should not be able to proceed')
+
+    // Affected items:
+    // - e1 (self)
+    // - e3 (parent)
+    // - p1 (child)
+    // - a1 (child)
+    assert.lengthOf(report.impact, 4, 'has all items')
+    const [e1r, e3r, p1r, a1r] = report.impact
+
+    assert.ok(e1r)
+    assert.equal(e1r.key, e1.key)
+    assert.equal(e1r.kind, DataEntityKind)
+    assert.equal(e1r.type, 'delete')
+    assert.equal(e1r.impact, `The e1 entity will be deleted.`)
+    assert.isFalse(e1r.blocking)
+
+    assert.ok(p1r)
+    assert.equal(p1r.key, p1.key)
+    assert.equal(p1r.kind, DataPropertyKind)
+    assert.equal(p1r.type, 'delete')
+    assert.equal(p1r.impact, `The p1 property will be deleted.`)
+    assert.isFalse(p1r.blocking)
+
+    assert.ok(a1r)
+    assert.equal(a1r.key, a1.key)
+    assert.equal(a1r.kind, DataAssociationKind)
+    assert.equal(a1r.type, 'delete')
+    assert.equal(a1r.impact, `The a1 association will be deleted.`)
+    assert.isFalse(a1r.blocking)
+
+    assert.ok(e3r)
+    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.isTrue(e3r.blocking)
+    assert.equal(e3r.relationship, 'child')
+  })
+})