@api-client/core 0.11.4 → 0.11.7

package/src/amf/definitions/Shapes.ts

@@ -68,7 +68,7 @@ export interface IApiAssociationShape {
    * - anyOf - To validate against `anyOf`, the given data must be valid against
    *   any (one or more) of the given sub-schemas. When generation a schema, it takes first union schema.
    * - oneOf - To validate against `oneOf`, the given data must be valid against
-   *   exactly one of the given sub-schemas. It behaves the same as `oneOf` when generating a schema
+   *   exactly one of the given sub-schemas. It behaves the same as `anyOf` when generating a schema
    * - not - The `not` keyword declares that an instance validates if it doesn’t
    *   validate against the given sub-schema. It has no use when generating a schema.
    *

package/src/modeling/DataAssociation.ts

@@ -358,9 +358,9 @@ export class DataAssociation {
    */
   remove(): void {
     const { root } = this
-    const entity = root.definitions.entities.find((i) => i.associations.some((j) => j === this))
+    const entity = root.definitions.entities.find((i) => i.associations.some((j) => j.key === this.key))
     if (entity) {
-      const assocIndex = entity.associations.findIndex((i) => i === this)
+      const assocIndex = entity.associations.findIndex((i) => i.key === this.key)
       entity.associations.splice(assocIndex, 1)
     }
     const defIndex = this.root.definitions.associations.findIndex((i) => i.key === this.key)
@@ -402,6 +402,19 @@ export class DataAssociation {
         namespace = typed.root.key
       }
     }
+    if (this.targets.some((i) => i.key === key)) {
+      const message = `Target ${key} already exists.`
+      throw new ValidationError(
+        [
+          {
+            field: 'targets',
+            message,
+            rule: 'unique',
+          },
+        ],
+        { message }
+      )
+    }
     if (namespace && namespace !== this.root.key) {
       const foreignNamespace = this.root.foreign.find((ns) => ns.key === namespace)
       if (!foreignNamespace) {
@@ -450,15 +463,22 @@ export class DataAssociation {
     return serializer.associationProperty(this)
   }
 
+  /**
+   * @deprecated Use the `getParentInstance()` method instead.
+   */
+  getParent(): DataEntity {
+    return this.getParentInstance()
+  }
+
   /**
    * Retrieves the parent entity of this association.
    *
    * @returns The `DataEntity` instance that contains this association.
    */
-  getParent(): DataEntity {
+  getParentInstance(): DataEntity {
     // this is forced as an association is only created when an entity is created
     // so it has to be defined.
-    return this.root.definitions.entities.find((i) => i.associations.includes(this)) as DataEntity
+    return this.root.definitions.entities.find((i) => i.associations.some((a) => a.key === this.key)) as DataEntity
   }
 
   /**
@@ -473,9 +493,9 @@ export class DataAssociation {
   }
 
   /**
-   * Checks whether the passed value is one of the supported data proprty attributes.
+   * Checks whether the passed value is one of the supported data property attributes.
    * @param value The value to test
-   * @returns True when the passed value is one of the supported data proprty attributes.
+   * @returns True when the passed value is one of the supported data property attributes.
    */
   static isValidAttribute(value: unknown): value is DataAttributeAttribute {
     if (typeof value !== 'string') {

package/src/modeling/DataEntity.ts

@@ -585,7 +585,7 @@ export class DataEntity {
     )
     if (associationsToEntity.length > 0) {
       const entitiesNames = associationsToEntity.reduce<string[]>((acc, association) => {
-        const entity = root.definitions.entities.find((e) => e.associations.includes(association))
+        const entity = root.definitions.entities.find((e) => e.associations.some((a) => a.key === association.key))
         if (entity) {
           acc.push(entity.info.name as string)
         }
@@ -605,18 +605,26 @@ export class DataEntity {
       root.definitions.entities.splice(index, 1)
     }
     // remove from the parent
-    const model = this.getParent()
+    const model = this.getParentInstance()
     if (model) {
-      const entityIndex = model.entities.findIndex((e) => e === this)
+      const entityIndex = model.entities.findIndex((e) => e.key === this.key)
       model.entities.splice(entityIndex, 1)
     }
   }
 
   /**
-   * Returns a parent data model where this entity exist.
+   * @deprecated Use the `getParentInstance()` method instead.
    */
+  // This method name collides with the `getParents()` method.
   getParent(): DataModel | undefined {
-    return this.root.definitions.models.find((m) => m.entities.some((e) => e === this))
+    return this.getParentInstance()
+  }
+
+  /**
+   * Returns a parent data model where this entity exist.
+   */
+  getParentInstance(): DataModel | undefined {
+    return this.root.definitions.models.find((m) => m.entities.some((e) => e.key === this.key))
   }
 
   /**
@@ -677,7 +685,7 @@ export class DataEntity {
           {
             field: 'parents',
             message,
-            rule: 'exists',
+            rule: 'unique',
           },
         ],
         { message }
@@ -687,6 +695,33 @@ export class DataEntity {
     return this
   }
 
+  /**
+   * Removes a parent reference from this entity.
+   * It keeps the parent as is.
+   *
+   * @param key The key of the parent entity to remove.
+   * @throws ValidationError when the parent is not found.
+   * @returns Self for chaining.
+   */
+  removeParent(key: string): this {
+    const index = this.parents.findIndex((i) => i === key)
+    if (index < 0) {
+      const message = `Parent ${key} not found.`
+      throw new ValidationError(
+        [
+          {
+            field: 'parents',
+            message,
+            rule: 'not-found',
+          },
+        ],
+        { message }
+      )
+    }
+    this.parents.splice(index, 1)
+    return this
+  }
+
   /**
    * Checks if the entity has a circular parent relationship when attempting to add a new parent.
    * @param key The key of the parent being added.
@@ -808,21 +843,21 @@ export class DataEntity {
       name: this.info.name || 'Unnamed entity',
       kind: DataEntityKind,
     })
-    const model = this.getParent()
+    const model = this.getParentInstance()
     if (model) {
       result.push({
         key: model.key,
         kind: model.kind,
         name: model.info.name || 'Unnamed data model',
       })
-      let parent = model.getParent()
+      let parent = model.getParentInstance()
       while (parent && parent !== this.root) {
         result.push({
           key: parent.key,
           kind: parent.kind,
           name: parent.info.name || 'Unnamed namespace',
         })
-        parent = parent.getParent()
+        parent = parent.getParentInstance()
       }
     }
     result.push({

package/src/modeling/DataModel.ts

@@ -135,7 +135,7 @@ export class DataModel {
     entities.forEach((e) => e.remove())
 
     // remove self from the parent
-    const parent = this.getParent()
+    const parent = this.getParentInstance()
     if (parent) {
       const itemIndex = parent.items.findIndex((i) => i.key === key)
       if (itemIndex >= 0) {
@@ -169,17 +169,15 @@ export class DataModel {
     if (entity.root !== this.root) {
       throw new Error(`The entity ${entity.key} is not in the same namespace as this data model.`)
     }
-    if (entity.getParent() === this) {
-      throw new Error(`The entity ${entity.key} is already adapted by this data model.`)
-    }
-    const parent = entity.getParent()
+    const parent = entity.getParentInstance()
     if (!parent) {
       throw new Error(`The entity ${entity.key} has no parent.`)
     }
-    const index = parent.entities.findIndex((i) => i.key === entity.key)
-    if (index < 0) {
-      throw new Error(`The entity ${entity.key} is not in the parent data model.`)
+    if (parent.key === this.key) {
+      throw new Error(`The entity ${entity.key} is already adapted by this data model.`)
     }
+    // it has a parent (above check) so it has the index.
+    const index = parent.entities.findIndex((i) => i.key === entity.key)
     parent.entities.splice(index, 1)
     if (opts.index !== undefined) {
       this.entities.splice(opts.index, 0, entity)
@@ -209,9 +207,16 @@ export class DataModel {
   }
 
   /**
-   * Returns the parent namespace where this data model exist.
+   * @deprecated Use the `getParentInstance()` method instead.
    */
   getParent(): DataNamespace | undefined {
+    return this.getParentInstance()
+  }
+
+  /**
+   * Returns the parent namespace where this data model exist.
+   */
+  getParentInstance(): DataNamespace | undefined {
     if (this.root.items.some((e) => e.key === this.key)) {
       return this.root
     }
@@ -228,14 +233,14 @@ export class DataModel {
       name: this.info.name || 'Unnamed data model',
       kind: DataModelKind,
     })
-    let parent = this.getParent()
+    let parent = this.getParentInstance()
     while (parent && parent !== this.root) {
       result.push({
         key: parent.key,
         kind: parent.kind,
         name: parent.info.name || 'Unnamed namespace',
       })
-      parent = parent.getParent()
+      parent = parent.getParentInstance()
     }
     result.push({
       key: this.root.key,

package/src/modeling/DataNamespace.ts

@@ -127,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)
@@ -523,7 +530,7 @@ export class DataNamespace extends DataNamespaceParent {
     if (ns.root !== this.root) {
       throw new Error(`The namespace ${ns.key} is not in the same namespace as this data namespace.`)
     }
-    if (ns.getParent() === this) {
+    if (ns.getParentInstance() === this) {
       throw new Error(`The namespace ${ns.key} is already adapted by this data namespace.`)
     }
     // Check for circular dependency
@@ -532,16 +539,49 @@ export class DataNamespace extends DataNamespaceParent {
       if (current === ns) {
         throw new Error(`Unable to adapt namespace ${ns.key} under itself or one of its children.`)
       }
-      current = current.getParent()
+      current = current.getParentInstance()
     }
-    const parent = ns.getParent() || this.root
+    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)
-    if (index < 0) {
-      throw new Error(`The namespace ${ns.key} is not in the parent data namespace.`)
+    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)

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)
   })
 })

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

@@ -1033,7 +1033,7 @@ test.group('getRoot()', (group) => {
   })
 })
 
-test.group('getParent()', (group) => {
+test.group('getParentInstance()', (group) => {
   let root: DataNamespace
   let n1: DataNamespace
   let n2: DataNamespace
@@ -1045,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)
   })
 })
@@ -1203,3 +1203,72 @@ test.group('adaptNamespace() - Circular Dependency', (group) => {
     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.`
+    )
+  })
+})

package/tsconfig.browser.json

@@ -28,5 +28,6 @@
     "resolveJsonModule": true,
     "skipLibCheck": true
   },
-  "include": ["src/**/*", "test/**/*"]
+  "include": ["src/**/*", "test/**/*"],
+  "exclude": ["node_modules", "build", "coverage", ".tmp", ".wireit", "amf-models", "bin", "data", "docs", "scripts"],
 }