@api-client/core 0.11.3 → 0.11.6

package/src/modeling/DataNamespace.ts

@@ -9,6 +9,13 @@ import v4 from '../lib/uuid.js'
 
 type ItemKind = typeof DataNamespaceKind | typeof DataModelKind
 
+export interface DataItemAdaptingOptions {
+  /**
+   * The index at which to adapt the item.
+   */
+  index?: number
+}
+
 interface IDataDefinitions {
   models?: IDataModel[]
   entities?: IDataEntity[]
@@ -120,9 +127,16 @@ class DataNamespaceParent {
   }
 
   /**
-   * @returns The parent namespace of this namespace. It returns `undefined` when this is the root namespace.
+   * @deprecated Use the `getParentInstance()` method instead.
    */
   getParent(): DataNamespace | undefined {
+    return this.getParentInstance()
+  }
+
+  /**
+   * @returns The parent namespace of this namespace. It returns `undefined` when this is the root namespace.
+   */
+  getParentInstance(): DataNamespace | undefined {
     const { root, key } = this
     if (root) {
       const result = (root as DataNamespace).findParent(key)
@@ -494,6 +508,88 @@ export class DataNamespace extends DataNamespaceParent {
     return definition
   }
 
+  /**
+   * Adapts an existing namespace to this namespace.
+   * This will remove the namespace from the parent namespace and add it to this one.
+   *
+   * @param ns The namespace to adapt.
+   * @param opts Adapting options.
+   */
+  adaptNamespace(ns: DataNamespace, opts: DataItemAdaptingOptions = {}): void {
+    if (opts.index !== undefined) {
+      if (opts.index < 0) {
+        throw new Error(`The index ${opts.index} cannot be below 0.`)
+      }
+      if (opts.index >= this.items.length) {
+        throw new Error(`The index ${opts.index} is not valid.`)
+      }
+    }
+    if (ns === this) {
+      throw new Error(`Unable to adapt a namespace that is self.`)
+    }
+    if (ns.root !== this.root) {
+      throw new Error(`The namespace ${ns.key} is not in the same namespace as this data namespace.`)
+    }
+    if (ns.getParentInstance() === this) {
+      throw new Error(`The namespace ${ns.key} is already adapted by this data namespace.`)
+    }
+    // Check for circular dependency
+    let current: DataNamespace | undefined = this
+    while (current) {
+      if (current === ns) {
+        throw new Error(`Unable to adapt namespace ${ns.key} under itself or one of its children.`)
+      }
+      current = current.getParentInstance()
+    }
+    const parent = ns.getParentInstance() || this.root
+    if (!parent) {
+      throw new Error(`The namespace ${ns.key} has no parent.`)
+    }
+    // it has a parent (above check) so it has the index.
+    const index = parent.items.findIndex((i) => i.key === ns.key)
+    const [item] = parent.items.splice(index, 1)
+    if (opts.index !== undefined) {
+      this.items.splice(opts.index, 0, item)
+    } else {
+      this.items.push(item)
+    }
+  }
+
+  /**
+   * Adapts an existing data model to this namespace.
+   * This will remove the data model from the parent namespace and add it to this one.
+   * @param model The data model to adapt.
+   * @param opts The adapting options.
+   */
+  adaptDataModel(model: DataModel, opts: DataItemAdaptingOptions = {}): void {
+    if (opts.index !== undefined) {
+      if (opts.index < 0) {
+        throw new Error(`The index ${opts.index} cannot be below 0.`)
+      }
+      if (opts.index >= this.items.length) {
+        throw new Error(`The index ${opts.index} is not valid.`)
+      }
+    }
+    if (model.root !== this.root) {
+      throw new Error(`The data model ${model.key} is not in the same namespace as this data namespace.`)
+    }
+    const parent = model.getParentInstance()
+    if (!parent) {
+      throw new Error(`The data model ${model.key} has no parent.`)
+    }
+    if (parent === this) {
+      throw new Error(`The data model ${model.key} is already adapted by this data namespace.`)
+    }
+    // it has a parent (above check) so it has the index.
+    const index = parent.items.findIndex((i) => i.key === model.key)
+    const [item] = parent.items.splice(index, 1)
+    if (opts.index !== undefined) {
+      this.items.splice(opts.index, 0, item)
+    } else {
+      this.items.push(item)
+    }
+  }
+
   /**
    * Finds a namespace in the definitions.
    * @param key The key of the namespace to find.

package/src/modeling/DataProperty.ts

@@ -445,9 +445,9 @@ export class DataProperty {
    */
   remove(): void {
     const { root } = this
-    const entity = root.definitions.entities.find((i) => i.properties.some((j) => j === this))
+    const entity = root.definitions.entities.find((i) => i.properties.some((j) => j.key === this.key))
     if (entity) {
-      const assocIndex = entity.properties.findIndex((i) => i === this)
+      const assocIndex = entity.properties.findIndex((i) => i.key === this.key)
       entity.properties.splice(assocIndex, 1)
     }
     const defIndex = this.root.definitions.properties.findIndex((i) => i.key === this.key)

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

@@ -510,7 +510,7 @@ test.group('toApiShape()', (g) => {
   })
 })
 
-test.group('getParent()', (g) => {
+test.group('getParentInstance()', (g) => {
   let root: DataNamespace
   let m1: DataModel
   let e1: DataEntity
@@ -525,7 +525,7 @@ test.group('getParent()', (g) => {
 
   test('returns the reference to the parent entity', ({ assert }) => {
     const a1 = e1.addTargetAssociation(e2.key)
-    const result = a1.getParent()
+    const result = a1.getParentInstance()
     assert.deepEqual(result, e1)
   })
 })

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

@@ -1616,7 +1616,7 @@ test.group('addParent()', (group) => {
   })
 })
 
-test.group('DataEntity - getParent()', (group) => {
+test.group('getParentInstance()', (group) => {
   let root: DataNamespace
   let model: DataModel
   let entity1: DataEntity
@@ -1628,12 +1628,12 @@ test.group('DataEntity - getParent()', (group) => {
   })
 
   test('returns undefined when the entity is not in a model', ({ assert }) => {
-    const result = new DataEntity(root).getParent()
+    const result = new DataEntity(root).getParentInstance()
     assert.isUndefined(result)
   })
 
   test('returns the parent data model', ({ assert }) => {
-    const result = entity1.getParent()
+    const result = entity1.getParentInstance()
     assert.instanceOf(result, DataModel)
   })
 })

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

@@ -227,7 +227,7 @@ test.group('addEntity()', (group) => {
   })
 })
 
-test.group('getParent()', (group) => {
+test.group('getParentInstance()', (group) => {
   let root: DataNamespace
 
   group.each.setup(() => {
@@ -236,14 +236,14 @@ test.group('getParent()', (group) => {
 
   test('returns the parent as root', ({ assert }) => {
     const m1 = root.addDataModel('m1')
-    const result = m1.getParent()
+    const result = m1.getParentInstance()
     assert.isTrue(result === root)
   })
 
   test('returns the parent is as sub-namespace', ({ assert }) => {
     const n1 = root.addNamespace('n1')
     const m1 = n1.addDataModel('m1')
-    const result = m1.getParent()
+    const result = m1.getParentInstance()
     assert.isTrue(result === n1)
   })
 })
@@ -285,3 +285,57 @@ test.group('breadcrumbs()', (group) => {
     assert.equal(result[3].key, m1.key, 'has self last')
   })
 })
+
+test.group('adaptEntity()', (group) => {
+  let root: DataNamespace
+  let dm1: DataModel
+  let dm2: DataModel
+  let e1: DataEntity
+  let e2: DataEntity
+
+  group.each.setup(() => {
+    root = new DataNamespace()
+    dm1 = root.addNamespace('dm1').addDataModel('Data Model 1')
+    dm2 = root.addNamespace('dm2').addDataModel('Data Model 2')
+    e1 = dm1.addEntity('Entity 1')
+    e2 = dm1.addEntity('Entity 2')
+  })
+
+  test('moves an entity to a new data model', ({ assert }) => {
+    dm2.adaptEntity(e1)
+    assert.deepEqual(dm1.entities, [e2], 'removes from the old data model')
+    assert.deepEqual(dm2.entities, [e1], 'adds to the new data model')
+    assert.deepEqual(root.definitions.entities, [e1, e2], 'keeps the entity in the root definitions')
+  })
+
+  test('moves an entity to a new index', ({ assert }) => {
+    const e3 = dm2.addEntity('Entity 3')
+    dm2.adaptEntity(e1, { index: 0 })
+    assert.deepEqual(dm1.entities, [e2], 'removes from the old data model')
+    assert.deepEqual(dm2.entities, [e1, e3], 'adds to the new data model')
+    assert.deepEqual(root.definitions.entities, [e1, e2, e3], 'keeps the entity in the root definitions')
+  })
+
+  test('throws when adapting an entity from another root', ({ assert }) => {
+    const otherRoot = new DataNamespace()
+    const otherDm = otherRoot.addNamespace('other').addDataModel('Other Data Model')
+    const otherEntity = otherDm.addEntity('Other Entity')
+    assert.throws(
+      () => dm1.adaptEntity(otherEntity),
+      `The entity ${otherEntity.key} is not in the same namespace as this data model.`
+    )
+  })
+
+  test('throws when adapting an entity that is already adapted', ({ assert }) => {
+    dm2.adaptEntity(e1)
+    assert.throws(() => dm2.adaptEntity(e1), `The entity ${e1.key} is already adapted by this data model.`)
+  })
+
+  test('throws when index is out of range (minimum)', ({ assert }) => {
+    assert.throws(() => dm2.adaptEntity(e1, { index: -1 }), `The index -1 cannot be below 0.`)
+  })
+
+  test('throws when index is out of range (maximum)', ({ assert }) => {
+    assert.throws(() => dm2.adaptEntity(e1, { index: 1 }), `The index 1 is not valid.`)
+  })
+})

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

@@ -1,5 +1,13 @@
 import { test } from '@japa/runner'
-import { DataEntity, DataModel, DataNamespace, DataNamespaceKind, IDataNamespace, Thing } from '../../../src/index.js'
+import {
+  DataEntity,
+  DataItem,
+  DataModel,
+  DataNamespace,
+  DataNamespaceKind,
+  IDataNamespace,
+  Thing,
+} from '../../../src/index.js'
 
 test.group('constructor() defaults', () => {
   test('sets the kind', ({ assert }) => {
@@ -1025,7 +1033,7 @@ test.group('getRoot()', (group) => {
   })
 })
 
-test.group('getParent()', (group) => {
+test.group('getParentInstance()', (group) => {
   let root: DataNamespace
   let n1: DataNamespace
   let n2: DataNamespace
@@ -1037,12 +1045,12 @@ test.group('getParent()', (group) => {
   })
 
   test('returns undefined when called on the root namespace', ({ assert }) => {
-    const result = root.getParent()
+    const result = root.getParentInstance()
     assert.isUndefined(result)
   })
 
   test('returns the parent namespace when called on a sub-namespace', ({ assert }) => {
-    const result = n2.getParent()
+    const result = n2.getParentInstance()
     assert.deepEqual(result, n1)
   })
 })
@@ -1066,3 +1074,201 @@ test.group('isRoot()', (group) => {
     assert.isFalse(result)
   })
 })
+
+test.group('adaptNamespace()', (group) => {
+  let root: DataNamespace
+  let n1: DataNamespace
+  let n2: DataNamespace
+
+  group.each.setup(() => {
+    root = new DataNamespace()
+    n1 = root.addNamespace('n1')
+    n2 = root.addNamespace('n2')
+  })
+
+  test('moves a namespace to a new parent', ({ assert }) => {
+    const n3 = n1.addNamespace('n3')
+    n2.adaptNamespace(n3)
+    assert.deepEqual(n1.items, [], 'removes from the old parent')
+    const item = DataItem.dataNamespace(root, n3.key)
+    assert.deepEqual(n2.items, [item], 'adds to the new parent')
+    assert.deepEqual(root.definitions.namespaces, [n1, n2, n3], 'keeps the namespace in the root definitions')
+  })
+
+  test('moves a namespace to a new index', ({ assert }) => {
+    const n3 = n1.addNamespace('n3')
+    const n4 = n1.addNamespace('n4')
+    const n5 = n2.addNamespace('n5')
+    n2.adaptNamespace(n3, { index: 0 })
+    const item3 = DataItem.dataNamespace(root, n3.key)
+    const item4 = DataItem.dataNamespace(root, n4.key)
+    const item5 = DataItem.dataNamespace(root, n5.key)
+    assert.deepEqual(n1.items, [item4], 'removes from the old parent')
+    assert.deepEqual(n2.items, [item3, item5], 'adds to the new parent')
+    assert.deepEqual(root.definitions.namespaces, [n1, n2, n3, n4, n5], 'keeps the namespace in the root definitions')
+  })
+
+  test('throws when adapting self', ({ assert }) => {
+    assert.throws(() => n1.adaptNamespace(n1), 'Unable to adapt a namespace that is self.')
+  })
+
+  test('throws when adapting a namespace from another root', ({ assert }) => {
+    const otherRoot = new DataNamespace()
+    const otherNs = otherRoot.addNamespace('other')
+    assert.throws(
+      () => n1.adaptNamespace(otherNs),
+      `The namespace ${otherNs.key} is not in the same namespace as this data namespace.`
+    )
+  })
+
+  test('throws when adapting a namespace that is already adapted', ({ assert }) => {
+    const n3 = n1.addNamespace('n3')
+    n2.adaptNamespace(n3)
+    assert.throws(() => n2.adaptNamespace(n3), `The namespace ${n3.key} is already adapted by this data namespace.`)
+  })
+
+  test('throws when index is out of range (minimum)', ({ assert }) => {
+    assert.throws(() => n1.adaptNamespace(n2, { index: -1 }), `The index -1 cannot be below 0.`)
+  })
+
+  test('throws when index is out of range (maximum)', ({ assert }) => {
+    assert.throws(() => n1.adaptNamespace(n2, { index: 1 }), `The index 1 is not valid.`)
+  })
+})
+
+test.group('adaptNamespace() - Circular Dependency', (group) => {
+  let root: DataNamespace
+  let n1: DataNamespace
+  let n2: DataNamespace
+  let n3: DataNamespace
+  let n4: DataNamespace
+
+  // Root
+  // ├── n1
+  // │   ├── n3
+  // │   │   └── n4
+  // └── n2
+
+  group.each.setup(() => {
+    root = new DataNamespace()
+    n1 = root.addNamespace('n1')
+    n2 = root.addNamespace('n2')
+    n3 = n1.addNamespace('n3')
+    n4 = n3.addNamespace('n4')
+  })
+
+  test('throws when adapting a namespace under itself', ({ assert }) => {
+    assert.throws(() => n1.adaptNamespace(n1), 'Unable to adapt a namespace that is self.')
+  })
+
+  test('throws when adapting a namespace under its child', ({ assert }) => {
+    assert.throws(
+      () => n3.adaptNamespace(n1),
+      `Unable to adapt namespace ${n1.key} under itself or one of its children.`
+    )
+  })
+
+  test('throws when adapting a namespace under its grandchild', ({ assert }) => {
+    assert.throws(
+      () => n4.adaptNamespace(n1),
+      `Unable to adapt namespace ${n1.key} under itself or one of its children.`
+    )
+  })
+
+  test('does not throw when adapting a namespace under its sibling', ({ assert }) => {
+    const n5 = n1.addNamespace('n5')
+    assert.doesNotThrow(() => n2.adaptNamespace(n5))
+  })
+
+  test("does not throw when adapting a namespace under its sibling's child", ({ assert }) => {
+    const n5 = n1.addNamespace('n5')
+    const n6 = n5.addNamespace('n6')
+    assert.doesNotThrow(() => n2.adaptNamespace(n6))
+  })
+
+  test("does not throw when adapting a namespace under its sibling's parent", ({ assert }) => {
+    const n5 = n1.addNamespace('n5')
+    // Root (before)
+    // ├── n1
+    // │   ├── n3
+    // │   │   └── n4
+    // │   └── n5
+    // └── n2
+    // Root (after)
+    // └── n1
+    //     ├── n3
+    //     │   └── n4
+    //     └── n5
+    //         └── n2
+    assert.doesNotThrow(() => n5.adaptNamespace(n2))
+  })
+})
+
+test.group('adaptDataModel()', (group) => {
+  let root: DataNamespace
+  let n1: DataNamespace
+  let n2: DataNamespace
+  let m1: DataModel
+  let m2: DataModel
+
+  group.each.setup(() => {
+    root = new DataNamespace()
+    n1 = root.addNamespace('n1')
+    n2 = root.addNamespace('n2')
+    m1 = n1.addDataModel('m1')
+    m2 = n1.addDataModel('m2')
+    m1.addEntity('e1')
+  })
+
+  test('moves a data model to a new parent', ({ assert }) => {
+    n2.adaptDataModel(m1)
+    const item1 = DataItem.dataModel(root, m1.key)
+    const item2 = DataItem.dataModel(root, m2.key)
+    assert.deepEqual(n1.items, [item2], 'removes from the old parent')
+    assert.deepEqual(n2.items, [item1], 'adds to the new parent')
+    assert.deepEqual(root.definitions.models, [m1, m2], 'keeps the data model in the root definitions')
+  })
+
+  test('moves a data model to a new index', ({ assert }) => {
+    const m3 = n2.addDataModel('m3')
+    n2.adaptDataModel(m1, { index: 0 })
+    const item1 = DataItem.dataModel(root, m1.key)
+    const item2 = DataItem.dataModel(root, m2.key)
+    const item3 = DataItem.dataModel(root, m3.key)
+    assert.deepEqual(n1.items, [item2], 'removes from the old parent')
+    assert.deepEqual(n2.items, [item1, item3], 'adds to the new parent')
+    assert.deepEqual(root.definitions.models, [m1, m2, m3], 'keeps the data model in the root definitions')
+  })
+
+  test('throws when adapting a data model from another root', ({ assert }) => {
+    const otherRoot = new DataNamespace()
+    const otherNs = otherRoot.addNamespace('other')
+    const otherModel = otherNs.addDataModel('Other Data Model')
+    assert.throws(
+      () => n1.adaptDataModel(otherModel),
+      `The data model ${otherModel.key} is not in the same namespace as this data namespace.`
+    )
+  })
+
+  test('throws when adapting a data model that is already adapted', ({ assert }) => {
+    n2.adaptDataModel(m1)
+    assert.throws(() => n2.adaptDataModel(m1), `The data model ${m1.key} is already adapted by this data namespace.`)
+  })
+
+  test('throws when index is out of range (minimum)', ({ assert }) => {
+    assert.throws(() => n2.adaptDataModel(m1, { index: -1 }), `The index -1 cannot be below 0.`)
+  })
+
+  test('throws when index is out of range (maximum)', ({ assert }) => {
+    assert.throws(() => n2.adaptDataModel(m1, { index: 1 }), `The index 1 is not valid.`)
+  })
+
+  test('throws when adapting a data model from another namepsace', ({ assert }) => {
+    const otherRoot = new DataNamespace()
+    const otherModel = new DataModel(otherRoot)
+    assert.throws(
+      () => n1.adaptDataModel(otherModel),
+      `The data model ${otherModel.key} is not in the same namespace as this data namespace.`
+    )
+  })
+})