@api-client/core 0.18.11 → 0.18.12

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

@@ -42071,10 +42071,10 @@
 "@id": "#197"
 },
 {
-"@id": "#203"
+"@id": "#200"
 },
 {
-"@id": "#200"
+"@id": "#203"
 },
 {
 "@id": "#206"
@@ -42810,16 +42810,16 @@
 "@id": "#219"
 },
 {
-"@id": "#216"
+"@id": "#210"
 },
 {
-"@id": "#219"
+"@id": "#213"
 },
 {
-"@id": "#210"
+"@id": "#216"
 },
 {
-"@id": "#213"
+"@id": "#219"
 }
 ],
 "doc:root": false,
@@ -43499,7 +43499,7 @@
 "doc:ExternalDomainElement",
 "doc:DomainElement"
 ],
-"doc:raw": "code: 'J'\ndescription: 'Information and communication'\n",
+"doc:raw": "class: '3'\ndescription: '150 - 300'\nnumberOfFte: 5500\nnumberOfEmployees: 5232\n",
 "core:mediaType": "application/yaml",
 "sourcemaps:sources": [
 {
@@ -43520,7 +43520,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": [
 {
@@ -44232,7 +44232,7 @@
 "doc:ExternalDomainElement",
 "doc:DomainElement"
 ],
-"doc:raw": "-\n  type: 'GENERAL'\n  value: 'info@company.be'\n-\n  type: 'IT_DEPT'\n  value: 'it-service@company.be'\n",
+"doc:raw": "type: 'GENERAL'\ncountryDialCode : '+32'\nareaCode : '22'\nsubscriberNumber: '12.87.00'\nformatted: '+32-(0)22 000000'\n",
 "core:mediaType": "application/yaml",
 "sourcemaps:sources": [
 {
@@ -44253,7 +44253,7 @@
 "doc:ExternalDomainElement",
 "doc:DomainElement"
 ],
-"doc:raw": "type: \"GENERAL\"\nvalue: \"www.company.be\"\n",
+"doc:raw": "type: 'GENERAL'\ncountryDialCode : '+32'\nareaCode : '21'\nsubscriberNumber: '12.87.00'\nformatted: '+32-(0)21 302099'\n",
 "core:mediaType": "application/yaml",
 "sourcemaps:sources": [
 {
@@ -44274,7 +44274,7 @@
 "doc:ExternalDomainElement",
 "doc:DomainElement"
 ],
-"doc:raw": "type: 'GENERAL'\ncountryDialCode : '+32'\nareaCode : '22'\nsubscriberNumber: '12.87.00'\nformatted: '+32-(0)22 000000'\n",
+"doc:raw": "-\n  type: 'GENERAL'\n  value: 'info@company.be'\n-\n  type: 'IT_DEPT'\n  value: 'it-service@company.be'\n",
 "core:mediaType": "application/yaml",
 "sourcemaps:sources": [
 {
@@ -44295,7 +44295,7 @@
 "doc:ExternalDomainElement",
 "doc:DomainElement"
 ],
-"doc:raw": "type: 'GENERAL'\ncountryDialCode : '+32'\nareaCode : '21'\nsubscriberNumber: '12.87.00'\nformatted: '+32-(0)21 302099'\n",
+"doc:raw": "type: \"GENERAL\"\nvalue: \"www.company.be\"\n",
 "core:mediaType": "application/yaml",
 "sourcemaps:sources": [
 {
@@ -44771,12 +44771,12 @@
 {
 "@id": "#202/source-map/lexical/element_0",
 "sourcemaps:element": "amf://id#202",
-"sourcemaps:value": "[(1,0)-(3,0)]"
+"sourcemaps:value": "[(1,0)-(5,0)]"
 },
 {
 "@id": "#205/source-map/lexical/element_0",
 "sourcemaps:element": "amf://id#205",
-"sourcemaps:value": "[(1,0)-(5,0)]"
+"sourcemaps:value": "[(1,0)-(3,0)]"
 },
 {
 "@id": "#208/source-map/lexical/element_0",
@@ -45116,22 +45116,22 @@
 {
 "@id": "#212/source-map/lexical/element_0",
 "sourcemaps:element": "amf://id#212",
-"sourcemaps:value": "[(1,0)-(7,0)]"
+"sourcemaps:value": "[(1,0)-(6,0)]"
 },
 {
 "@id": "#215/source-map/lexical/element_0",
 "sourcemaps:element": "amf://id#215",
-"sourcemaps:value": "[(1,0)-(3,0)]"
+"sourcemaps:value": "[(1,0)-(6,0)]"
 },
 {
 "@id": "#218/source-map/lexical/element_0",
 "sourcemaps:element": "amf://id#218",
-"sourcemaps:value": "[(1,0)-(6,0)]"
+"sourcemaps:value": "[(1,0)-(7,0)]"
 },
 {
 "@id": "#221/source-map/lexical/element_0",
 "sourcemaps:element": "amf://id#221",
-"sourcemaps:value": "[(1,0)-(6,0)]"
+"sourcemaps:value": "[(1,0)-(3,0)]"
 },
 {
 "@id": "#338/source-map/synthesized-field/element_1",

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.18.11",
+  "version": "0.18.12",
   "license": "Apache-2.0",
   "exports": {
     "./browser.js": {

package/src/modeling/DomainModel.ts

@@ -271,11 +271,18 @@ export class DomainModel extends DomainElement {
       throw new AttachException(`Trying to attach the ${key} entity, but it is already a child of this model`)
     }
     parent.detachEntity(key)
-    this.fields.push({
-      type: 'entity',
-      key: key,
-    })
+    if (!this.fields.some((item) => item.key === key)) {
+      this.fields.push({
+        type: 'entity',
+        key: key,
+      })
+    }
     this.root.graph.setParent(key, this.key)
+    // verify that the entity is moved to the current model
+    const graphParent = this.root.graph.parent(key)
+    if (graphParent !== this.key) {
+      throw new AttachException(`Trying to attach the ${key} entity, but it is not a child of this model`)
+    }
     this.root.notifyChange()
     return this
   }

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

@@ -1,5 +1,5 @@
 import { test } from '@japa/runner'
-import { DataDomain, DomainEntity, DomainEntityKind } from '../../../src/index.js'
+import { DataDomain, DomainEntity, DomainEntityKind, DomainModel } from '../../../src/index.js'
 
 test.group('DomainModel.addEntity()', () => {
   test('adds an entity to the model', ({ assert }) => {
@@ -406,3 +406,308 @@ test.group('DomainModel.hasEntities()', () => {
     assert.isFalse(model.hasEntities())
   })
 })
+
+test.group('DomainModel.attachEntity() - Race Condition Tests', () => {
+  test('simulate multiple entities moved to same target simultaneously', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const sourceModel1 = dataDomain.addModel({ key: 'source1' })
+    const sourceModel2 = dataDomain.addModel({ key: 'source2' })
+    const targetModel = dataDomain.addModel({ key: 'target' })
+
+    const entity1 = sourceModel1.addEntity({ key: 'entity1' })
+    const entity2 = sourceModel2.addEntity({ key: 'entity2' })
+
+    // Move multiple entities to the same target
+    targetModel.attachEntity(entity1.key)
+    targetModel.attachEntity(entity2.key)
+
+    // Verify no duplication in fields array
+    const entityFields = targetModel.fields.filter((f) => f.type === 'entity')
+    const entityKeys = entityFields.map((f) => f.key)
+    const uniqueKeys = [...new Set(entityKeys)]
+    assert.equal(entityFields.length, uniqueKeys.length, 'No duplicate entities in fields array')
+    assert.lengthOf(entityFields, 2, 'Should have exactly 2 entities')
+    assert.include(entityKeys, entity1.key, 'Should contain entity1')
+    assert.include(entityKeys, entity2.key, 'Should contain entity2')
+
+    // Verify graph consistency
+    assert.equal(dataDomain.graph.parent(entity1.key), targetModel.key, 'Entity1 parent should be target model')
+    assert.equal(dataDomain.graph.parent(entity2.key), targetModel.key, 'Entity2 parent should be target model')
+
+    // Verify entities removed from source models
+    assert.lengthOf(sourceModel1.fields, 0, 'Source1 should have no entities')
+    assert.lengthOf(sourceModel2.fields, 0, 'Source2 should have no entities')
+  })
+
+  test('simulate entity moved between models multiple times rapidly', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model1 = dataDomain.addModel({ key: 'model1' })
+    const model2 = dataDomain.addModel({ key: 'model2' })
+    const model3 = dataDomain.addModel({ key: 'model3' })
+
+    const entity = model1.addEntity({ key: 'entity' })
+
+    // Simulate rapid moves
+    model2.attachEntity(entity.key)
+    model3.attachEntity(entity.key)
+    model1.attachEntity(entity.key)
+    model2.attachEntity(entity.key)
+
+    // Final state verification
+    assert.lengthOf(model2.fields, 1, 'Model2 should have 1 entity')
+    assert.lengthOf(model1.fields, 0, 'Model1 should have no entities')
+    assert.lengthOf(model3.fields, 0, 'Model3 should have no entities')
+    assert.equal(dataDomain.graph.parent(entity.key), model2.key, 'Entity parent should be model2')
+  })
+
+  test('simulate concurrent attachment of same entity to different targets', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const sourceModel = dataDomain.addModel({ key: 'source' })
+    const targetModel1 = dataDomain.addModel({ key: 'target1' })
+    const targetModel2 = dataDomain.addModel({ key: 'target2' })
+
+    const entity = sourceModel.addEntity({ key: 'entity' })
+
+    // First move should succeed
+    targetModel1.attachEntity(entity.key)
+    assert.equal(dataDomain.graph.parent(entity.key), targetModel1.key, 'Entity should be in target1')
+    assert.lengthOf(targetModel1.fields, 1, 'Target1 should have the entity')
+    assert.lengthOf(sourceModel.fields, 0, 'Source should be empty')
+
+    // Second move should move from target1 to target2
+    targetModel2.attachEntity(entity.key)
+    assert.equal(dataDomain.graph.parent(entity.key), targetModel2.key, 'Entity should be in target2')
+    assert.lengthOf(targetModel2.fields, 1, 'Target2 should have the entity')
+    assert.lengthOf(targetModel1.fields, 0, 'Target1 should be empty')
+    assert.lengthOf(sourceModel.fields, 0, 'Source should still be empty')
+  })
+
+  test('verify entity is not duplicated when moved from model with multiple entities', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const sourceModel = dataDomain.addModel({ key: 'source' })
+    const targetModel = dataDomain.addModel({ key: 'target' })
+
+    const entity1 = sourceModel.addEntity({ key: 'entity1' })
+    const entity2 = sourceModel.addEntity({ key: 'entity2' })
+    const entity3 = sourceModel.addEntity({ key: 'entity3' })
+
+    // Move middle entity
+    targetModel.attachEntity(entity2.key)
+
+    // Verify source model has 2 entities remaining
+    assert.lengthOf(sourceModel.fields, 2, 'Source should have 2 entities remaining')
+    const sourceKeys = sourceModel.fields.map((f) => f.key)
+    assert.include(sourceKeys, entity1.key, 'Should contain entity1')
+    assert.include(sourceKeys, entity3.key, 'Should contain entity3')
+    assert.notInclude(sourceKeys, entity2.key, 'Should not contain moved entity2')
+
+    // Verify target model has 1 entity
+    assert.lengthOf(targetModel.fields, 1, 'Target should have 1 entity')
+    assert.equal(targetModel.fields[0].key, entity2.key, 'Target should have entity2')
+
+    // Verify graph consistency
+    assert.equal(dataDomain.graph.parent(entity1.key), sourceModel.key, 'Entity1 parent should be source')
+    assert.equal(dataDomain.graph.parent(entity2.key), targetModel.key, 'Entity2 parent should be target')
+    assert.equal(dataDomain.graph.parent(entity3.key), sourceModel.key, 'Entity3 parent should be source')
+  })
+
+  test('verify field consistency when moving entities with properties', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const sourceModel = dataDomain.addModel({ key: 'source' })
+    const targetModel = dataDomain.addModel({ key: 'target' })
+
+    const entity = sourceModel.addEntity({ key: 'entity' })
+    entity.addProperty({ key: 'prop1', type: 'string' })
+    entity.addProperty({ key: 'prop2', type: 'number' })
+
+    // Verify initial state
+    assert.lengthOf(entity.fields, 2, 'Entity should have 2 properties')
+
+    // Move entity
+    targetModel.attachEntity(entity.key)
+
+    // Verify entity fields are preserved
+    assert.lengthOf(entity.fields, 2, 'Entity should still have 2 properties after move')
+    assert.equal(dataDomain.graph.parent(entity.key), targetModel.key, 'Entity parent should be target')
+
+    // Verify model fields
+    assert.lengthOf(sourceModel.fields, 0, 'Source model should be empty')
+    assert.lengthOf(targetModel.fields, 1, 'Target model should have 1 entity')
+  })
+
+  test('stress test - multiple entities moved in sequence to verify no field array corruption', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const sourceModels = []
+    const targetModel = dataDomain.addModel({ key: 'target' })
+    const entities = []
+
+    // Create 10 source models with 1 entity each
+    for (let i = 0; i < 10; i++) {
+      const sourceModel = dataDomain.addModel({ key: `source${i}` })
+      sourceModels.push(sourceModel)
+      const entity = sourceModel.addEntity({ key: `entity${i}` })
+      entities.push(entity)
+    }
+
+    // Move all entities to target model
+    for (const entity of entities) {
+      targetModel.attachEntity(entity.key)
+    }
+
+    // Verify target model state
+    assert.lengthOf(targetModel.fields, 10, 'Target should have 10 entities')
+    const targetKeys = targetModel.fields.map((f) => f.key).sort()
+    const expectedKeys = entities.map((e) => e.key).sort()
+    assert.deepEqual(targetKeys, expectedKeys, 'Target should have all expected entities')
+
+    // Verify no duplicates
+    const uniqueKeys = [...new Set(targetKeys)]
+    assert.equal(targetKeys.length, uniqueKeys.length, 'No duplicate keys in target')
+
+    // Verify source models are empty
+    for (const sourceModel of sourceModels) {
+      assert.lengthOf(sourceModel.fields, 0, `Source model ${sourceModel.key} should be empty`)
+    }
+
+    // Verify graph consistency
+    for (const entity of entities) {
+      assert.equal(dataDomain.graph.parent(entity.key), targetModel.key, `Entity ${entity.key} parent should be target`)
+    }
+  })
+
+  test('verify detach-attach sequence atomicity', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model1 = dataDomain.addModel({ key: 'model1' })
+    const model2 = dataDomain.addModel({ key: 'model2' })
+
+    const entity = model1.addEntity({ key: 'entity' })
+
+    // Spy on the detachEntity method to verify it's called
+    let detachCalled = false
+    const originalDetach = model1.detachEntity
+    model1.detachEntity = function (key: string) {
+      detachCalled = true
+      return originalDetach.call(this, key)
+    }
+
+    model2.attachEntity(entity.key)
+
+    // Verify detach was called during attach
+    assert.isTrue(detachCalled, 'detachEntity should have been called on the source model')
+
+    // Verify final state
+    assert.lengthOf(model1.fields, 0, 'Model1 should be empty')
+    assert.lengthOf(model2.fields, 1, 'Model2 should have the entity')
+    assert.equal(dataDomain.graph.parent(entity.key), model2.key, 'Graph parent should be model2')
+  })
+
+  test('verify graph parent is updated before fields array check', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model1 = dataDomain.addModel({ key: 'model1' })
+    const model2 = dataDomain.addModel({ key: 'model2' })
+
+    const entity = model1.addEntity({ key: 'entity' })
+
+    // Override setParent to track when it's called
+    const parentSetCalls: { nodeKey: string; parentKey?: string; timestamp: number }[] = []
+    const originalSetParent = dataDomain.graph.setParent
+    dataDomain.graph.setParent = function (nodeKey: string, parentKey?: string) {
+      parentSetCalls.push({ nodeKey, parentKey, timestamp: Date.now() })
+      return originalSetParent.call(this, nodeKey, parentKey)
+    }
+
+    // Override fields.push to track when it's called
+    const fieldsPushCalls: { items: unknown[]; timestamp: number }[] = []
+    const originalPush = model2.fields.push
+    model2.fields.push = function (...items) {
+      fieldsPushCalls.push({ items: [...items], timestamp: Date.now() })
+      return originalPush.call(this, ...items)
+    }
+
+    model2.attachEntity(entity.key)
+
+    // Verify the sequence - setParent should be called twice (detach + attach)
+    assert.lengthOf(parentSetCalls, 2, 'setParent should be called twice (detach + attach)')
+    assert.lengthOf(fieldsPushCalls, 1, 'fields.push should be called once')
+
+    // First call should clear the parent (detach)
+    assert.equal(parentSetCalls[0].nodeKey, entity.key, 'First call should be for entity key')
+    assert.isUndefined(parentSetCalls[0].parentKey, 'First call should clear parent')
+
+    // Second call should set the new parent (attach)
+    assert.equal(parentSetCalls[1].parentKey, model2.key, 'Second call should set parent to model2')
+    assert.equal(parentSetCalls[1].nodeKey, entity.key, 'Second call should be for entity key')
+  })
+
+  test('detect inconsistent graph parent - entity in fields but wrong graph parent', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const sourceModel = dataDomain.addModel({ key: 'source' })
+    const targetModel = dataDomain.addModel({ key: 'target' })
+
+    const entity = sourceModel.addEntity({ key: 'entity' })
+
+    // Simulate race condition where graph parent is not updated during attach
+    const originalSetParent = dataDomain.graph.setParent
+    let setParentCallCount = 0
+    dataDomain.graph.setParent = function (nodeKey: string, parentKey?: string) {
+      setParentCallCount++
+      // Skip the second setParent call (the attach operation)
+      if (setParentCallCount === 2) {
+        return this // Don't actually set the parent
+      }
+      return originalSetParent.call(this, nodeKey, parentKey)
+    }
+
+    assert.throws(() => {
+      targetModel.attachEntity(entity.key)
+    })
+
+    // Restore original method
+    dataDomain.graph.setParent = originalSetParent
+  })
+
+  test('verify consistency during rapid sequential moves', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const models: DomainModel[] = []
+
+    // Create multiple models
+    for (let i = 0; i < 5; i++) {
+      models.push(dataDomain.addModel({ key: `model${i}` }))
+    }
+
+    const entity = models[0].addEntity({ key: 'entity' })
+
+    // Perform rapid moves between models
+    for (let iteration = 0; iteration < 20; iteration++) {
+      const targetIndex = (iteration + 1) % models.length
+      models[targetIndex].attachEntity(entity.key)
+
+      // Verify consistency after each move
+      let entityCount = 0
+      let modelWithEntity = null
+
+      for (const model of models) {
+        const hasEntity = model.fields.some((f) => f.type === 'entity' && f.key === entity.key)
+        if (hasEntity) {
+          entityCount++
+          modelWithEntity = model
+        }
+      }
+
+      // Entity should exist in exactly one model
+      assert.equal(
+        entityCount,
+        1,
+        `Iteration ${iteration}: Entity should exist in exactly one model, found in ${entityCount} models`
+      )
+
+      // Graph parent should match the model that has the entity
+      const graphParent = dataDomain.graph.parent(entity.key)
+      assert.equal(
+        graphParent,
+        modelWithEntity?.key,
+        `Iteration ${iteration}: Graph parent should match model with entity`
+      )
+    }
+  })
+})