@api-client/core 0.18.10 → 0.18.12

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.10",
+  "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/src/modeling/DomainSerialization.ts

@@ -272,19 +272,25 @@ export function deserialize(root: DataDomain, json?: SerializedGraph, dependenci
     return g
   }
   if (Array.isArray(json.nodes)) {
+    // 1st pass - set up nodes
+    const parentInfo = new Map<string, string[]>()
     for (const entry of json.nodes) {
       g.setNode(entry.v, prepareNode(root, entry.value, json.edges))
       if (entry.parents) {
-        for (const parent of entry.parents) {
-          // In data domain graph, all nodes that can have parents can only have a single parent.
-          // It's the business logic of the library.
-          // Parent-child relationships:
-          // - Namespace -> Namespace
-          // - Namespace -> Model
-          // - Model -> Entity
-          // Entities and Association are associated with the parent entity through edges.
-          g.setParent(entry.v, parent)
-        }
+        parentInfo.set(entry.v, entry.parents)
+      }
+    }
+    // 2nd pass - set up parents
+    for (const [key, parents] of parentInfo) {
+      // In data domain graph, all nodes that can have parents can only have a single parent.
+      // It's the business logic of the library.
+      // Parent-child relationships:
+      // - Namespace -> Namespace
+      // - Namespace -> Model
+      // - Model -> Entity
+      // Entities and Association are associated with the parent entity through edges.
+      for (const parent of parents) {
+        g.setParent(key, parent)
       }
     }
   }

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

@@ -291,4 +291,104 @@ test.group('DataDomain Serialization and Deserialization', () => {
     assert.isTrue(restored.graph.hasEdge(e1.key, a1.key), 'has edge from e1 to a1')
     assert.isFalse(restored.graph.hasEdge(a1.key, `${fd.key}:${fe1.key}`), 'has no edge from a1 to fe1')
   }).tags(['@modeling', '@serialization'])
+
+  test('should serialize and deserialize parent-child relationships in the graph', ({ assert }) => {
+    const domain = new DataDomain()
+
+    // Create hierarchical structure: root > ns1 > ns2 > m1 > e1, e2 (e2 inherits from e1)
+    const ns1 = domain.addNamespace({ key: 'ns1' })
+    const ns2 = ns1.addNamespace({ key: 'ns2' })
+    const m1 = ns2.addModel({ key: 'm1' })
+    const m2 = domain.addModel({ key: 'm2' }) // root level model
+    const e1 = m1.addEntity({ key: 'e1' })
+    const e2 = m1.addEntity({ key: 'e2' })
+    const e3 = m2.addEntity({ key: 'e3' })
+
+    // Add entity inheritance relationships
+    e2.addParent(e1.key) // e2 inherits from e1
+    e3.addParent(e2.key) // e3 inherits from e2 (multi-level inheritance)
+
+    // Add properties and associations
+    const p1 = e1.addProperty({ type: 'string', key: 'p1' })
+    const p2 = e2.addProperty({ type: 'number', key: 'p2' })
+    const a1 = e1.addAssociation({ key: e3.key }, { key: 'a1' })
+
+    const serialized = domain.toJSON()
+    const restored = new DataDomain(serialized)
+
+    // Verify basic domain properties
+    assert.equal(restored.key, domain.key)
+    assert.equal(restored.kind, domain.kind)
+    assert.deepEqual(restored.info.toJSON(), domain.info.toJSON())
+
+    // Verify all nodes are restored
+    assert.equal([...restored.graph.nodes()].length, 10) // 2 ns + 2 models + 3 entities + 2 properties + 1 association
+
+    // Verify namespace hierarchy: ns1 (root) -> ns2 (child of ns1)
+    const rns1 = restored.findNamespace(ns1.key)
+    const rns2 = restored.findNamespace(ns2.key)
+    assert.isDefined(rns1)
+    assert.isDefined(rns2)
+    assert.isUndefined(restored.graph.parent(ns1.key), 'ns1 should be at root level')
+    assert.equal(restored.graph.parent(ns2.key), ns1.key, 'ns2 should be child of ns1')
+
+    // Verify model hierarchy: m1 (child of ns2), m2 (root level)
+    const rm1 = restored.findModel(m1.key)
+    const rm2 = restored.findModel(m2.key)
+    assert.isDefined(rm1)
+    assert.isDefined(rm2)
+    assert.equal(restored.graph.parent(m1.key), ns2.key, 'm1 should be child of ns2')
+    assert.isUndefined(restored.graph.parent(m2.key), 'm2 should be at root level')
+
+    // Verify entity hierarchy: e1, e2 (children of m1), e3 (child of m2)
+    const re1 = restored.findEntity(e1.key)
+    const re2 = restored.findEntity(e2.key)
+    const re3 = restored.findEntity(e3.key)
+    assert.isDefined(re1)
+    assert.isDefined(re2)
+    assert.isDefined(re3)
+    assert.equal(restored.graph.parent(e1.key), m1.key, 'e1 should be child of m1')
+    assert.equal(restored.graph.parent(e2.key), m1.key, 'e2 should be child of m1')
+    assert.equal(restored.graph.parent(e3.key), m2.key, 'e3 should be child of m2')
+
+    // Verify entity inheritance relationships (via edges, not parent-child)
+    assert.isTrue(restored.graph.hasEdge(e2.key, e1.key), 'e2 should inherit from e1')
+    assert.equal(restored.graph.edge(e2.key, e1.key)?.type, 'parent', 'inheritance edge should have type parent')
+    assert.isTrue(restored.graph.hasEdge(e3.key, e2.key), 'e3 should inherit from e2')
+    assert.equal(restored.graph.edge(e3.key, e2.key)?.type, 'parent', 'inheritance edge should have type parent')
+
+    // Verify entity inheritance works functionally
+    const restoredParentsE2 = [...re2!.listParents()]
+    const restoredParentsE3 = [...re3!.listParents()]
+    assert.equal(restoredParentsE2.length, 1, 'e2 should have 1 parent')
+    assert.equal(restoredParentsE2[0].key, e1.key, 'e2 parent should be e1')
+    assert.equal(restoredParentsE3.length, 1, 'e3 should have 1 parent')
+    assert.equal(restoredParentsE3[0].key, e2.key, 'e3 parent should be e2')
+
+    // Verify property hierarchy: p1 (child of e1), p2 (child of e2)
+    const rp1 = restored.findProperty(p1.key)
+    const rp2 = restored.findProperty(p2.key)
+    assert.isDefined(rp1)
+    assert.isDefined(rp2)
+    assert.isTrue(restored.graph.hasEdge(e1.key, p1.key), 'e1 should have edge to p1')
+    assert.equal(restored.graph.edge(e1.key, p1.key)?.type, 'property', 'property edge should have type property')
+    assert.isTrue(restored.graph.hasEdge(e2.key, p2.key), 'e2 should have edge to p2')
+    assert.equal(restored.graph.edge(e2.key, p2.key)?.type, 'property', 'property edge should have type property')
+
+    // Verify association hierarchy: a1 (child of e1) -> e3
+    const ra1 = restored.findAssociation(a1.key)
+    assert.isDefined(ra1)
+    assert.isTrue(restored.graph.hasEdge(e1.key, a1.key), 'e1 should have edge to a1')
+    assert.equal(
+      restored.graph.edge(e1.key, a1.key)?.type,
+      'association',
+      'association edge should have type association'
+    )
+    assert.isTrue(restored.graph.hasEdge(a1.key, e3.key), 'a1 should have edge to e3')
+    assert.equal(
+      restored.graph.edge(a1.key, e3.key)?.type,
+      'association',
+      'association target edge should have type association'
+    )
+  }).tags(['@modeling', '@serialization'])
 })

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