@api-client/core 0.17.0 → 0.17.2

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

@@ -10,7 +10,7 @@ test.group('DataDomain.addEntity()', () => {
     const entity = dataDomain.addEntity(model.key, { key: 'test-entity' })
     assert.instanceOf(entity, DomainEntity)
     assert.isTrue(dataDomain.graph.hasNode(entity.key))
-  })
+  }).tags(['@modeling', '@entity', '@add'])
 
   test('addEntity adds an entity to the graph with a parent', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -19,14 +19,14 @@ test.group('DataDomain.addEntity()', () => {
     assert.instanceOf(entity, DomainEntity)
     assert.isTrue(dataDomain.graph.hasNode(entity.key))
     assert.equal(dataDomain.graph.parent(entity.key), model.key)
-  })
+  }).tags(['@modeling', '@entity', '@add'])
 
   test('addEntity throws an error if parent model does not exist', ({ assert }) => {
     const dataDomain = new DataDomain()
     assert.throws(() => {
       dataDomain.addEntity('non-existent-parent', { key: 'test-entity' })
     }, 'The parent non-existent-parent does not exist')
-  })
+  }).tags(['@modeling', '@entity', '@add'])
 
   test('addEntity throws an error if parent is not a model', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -34,7 +34,7 @@ test.group('DataDomain.addEntity()', () => {
     assert.throws(() => {
       dataDomain.addEntity(namespace.key, { key: 'test-entity' })
     }, `Parent model ${namespace.key} is not a valid model`)
-  })
+  }).tags(['@modeling', '@entity', '@add'])
 
   test('addEntity adds an entity with default values', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -43,28 +43,28 @@ test.group('DataDomain.addEntity()', () => {
     assert.instanceOf(entity, DomainEntity)
     assert.isTrue(dataDomain.graph.hasNode(entity.key))
     assert.equal(dataDomain.graph.parent(entity.key), model.key)
-  })
+  }).tags(['@modeling', '@entity', '@add'])
 
   test('addEntity notifies change', async ({ assert }) => {
     const dataDomain = new DataDomain()
     const model = dataDomain.addModel({ key: 'test-model' })
     dataDomain.addEntity(model.key, { key: 'test-entity' })
     await assert.dispatches(dataDomain, 'change', { timeout: 20 })
-  })
+  }).tags(['@modeling', '@entity', '@add'])
 
   test('addEntity adds an entity to a parent model - checks parent-child relationship', ({ assert }) => {
     const dataDomain = new DataDomain()
     const parentModel = dataDomain.addModel({ key: 'parent-model' })
     const entity = dataDomain.addEntity(parentModel.key, { key: 'test-entity' })
     assert.isTrue(dataDomain.graph.hasParent(entity.key, parentModel.key))
-  })
+  }).tags(['@modeling', '@entity', '@add'])
 
   test('addEntity adds an entity to a parent model - checks items list', ({ assert }) => {
     const dataDomain = new DataDomain()
     const parentModel = dataDomain.addModel({ key: 'parent-model' })
     const entity = dataDomain.addEntity(parentModel.key, { key: 'test-entity' })
     assert.deepInclude([...parentModel!.listEntities()], entity)
-  })
+  }).tags(['@modeling', '@entity', '@add'])
 
   test('addEntity throws an error if no parent is provided', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -72,7 +72,7 @@ test.group('DataDomain.addEntity()', () => {
       // @ts-expect-error For testing purposes, we are passing undefined
       dataDomain.addEntity(undefined, { key: 'test-entity' })
     }, `An entity expects a DomainModel parent`)
-  })
+  }).tags(['@modeling', '@entity', '@add'])
 
   test('addEntity throws when adding the same entity twice', ({ assert }) => {
     const root = new DataDomain()
@@ -81,7 +81,7 @@ test.group('DataDomain.addEntity()', () => {
     assert.throws(() => {
       root.addEntity(m1.key, { key: 'test-entity' })
     }, `Entity with key test-entity already exists`)
-  })
+  }).tags(['@modeling', '@entity', '@add'])
 })
 
 test.group('DataDomain.removeEntity()', () => {
@@ -90,14 +90,14 @@ test.group('DataDomain.removeEntity()', () => {
     const entity = dataDomain.addModel({ key: 'test-model' }).addEntity({ key: 'test-entity' })
     dataDomain.removeEntity(entity.key)
     assert.isFalse(dataDomain.graph.hasNode(entity.key))
-  })
+  }).tags(['@modeling', '@entity', '@remove'])
 
   test('removeEntity throws an error if entity does not exist', ({ assert }) => {
     const dataDomain = new DataDomain()
     assert.throws(() => {
       dataDomain.removeEntity('non-existent-entity')
     }, 'Entity non-existent-entity does not exist')
-  })
+  }).tags(['@modeling', '@entity', '@remove'])
 
   test('removeEntity notifies change', async ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -105,7 +105,7 @@ test.group('DataDomain.removeEntity()', () => {
     const entity = dataDomain.addEntity(model.key, { key: 'test-entity' })
     dataDomain.removeEntity(entity.key)
     await assert.dispatches(dataDomain, 'change', { timeout: 20 })
-  })
+  }).tags(['@modeling', '@entity', '@remove'])
 
   test('removeEntity removes an entity from a parent model', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -114,7 +114,7 @@ test.group('DataDomain.removeEntity()', () => {
     dataDomain.removeEntity(entity.key)
     assert.isFalse(dataDomain.graph.hasNode(entity.key))
     assert.equal(dataDomain.graph.parent(entity.key), undefined)
-  })
+  }).tags(['@modeling', '@entity', '@remove'])
 
   test('removeEntity removes an entity with properties', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -124,7 +124,7 @@ test.group('DataDomain.removeEntity()', () => {
     dataDomain.removeEntity(entity.key)
     assert.isFalse(dataDomain.graph.hasNode(entity.key))
     assert.isFalse(dataDomain.graph.hasNode(property.key))
-  })
+  }).tags(['@modeling', '@entity', '@remove'])
 
   test('removeEntity removes an entity from a parent model - checks parent-child relationship', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -132,7 +132,7 @@ test.group('DataDomain.removeEntity()', () => {
     const entity = dataDomain.addEntity(parentModel.key, { key: 'test-entity' })
     dataDomain.removeEntity(entity.key)
     assert.isFalse(dataDomain.graph.hasParent(entity.key, parentModel.key))
-  })
+  }).tags(['@modeling', '@entity', '@remove'])
 
   test('removeEntity removes an entity from a parent model - checks items list', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -140,7 +140,7 @@ test.group('DataDomain.removeEntity()', () => {
     const entity = dataDomain.addEntity(parentModel.key, { key: 'test-entity' })
     dataDomain.removeEntity(entity.key)
     assert.notDeepInclude([...parentModel!.listEntities()], entity)
-  })
+  }).tags(['@modeling', '@entity', '@remove'])
 
   test('removeEntity throws an error if key is not an entity', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -148,7 +148,7 @@ test.group('DataDomain.removeEntity()', () => {
     assert.throws(() => {
       dataDomain.removeEntity(model.key)
     }, `Parent model not found for entity ${model.key}`)
-  })
+  }).tags(['@modeling', '@entity', '@remove'])
 })
 
 test.group('DataDomain.listEntities()', () => {
@@ -161,14 +161,14 @@ test.group('DataDomain.listEntities()', () => {
     assert.lengthOf(entities, 2)
     assert.deepInclude(entities, entity1)
     assert.deepInclude(entities, entity2)
-  })
+  }).tags(['@modeling', '@entity', '@list'])
 
   test('returns an empty array if there are no entities for a given parent model', ({ assert }) => {
     const dataDomain = new DataDomain()
     const model = dataDomain.addModel({ key: 'test-model' })
     const entities = [...dataDomain.listEntities(model.key)]
     assert.lengthOf(entities, 0)
-  })
+  }).tags(['@modeling', '@entity', '@list'])
 
   test('returns only entities for a given parent model', ({ assert }) => {
     const root = new DataDomain()
@@ -180,7 +180,7 @@ test.group('DataDomain.listEntities()', () => {
     const entities = [...root.listEntities(m1.key)]
     assert.lengthOf(entities, 1)
     assert.deepInclude(entities, e1)
-  })
+  }).tags(['@modeling', '@entity', '@list'])
 
   test('entities in the list are of type DomainEntity', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -188,14 +188,14 @@ test.group('DataDomain.listEntities()', () => {
     dataDomain.addEntity(model.key, { key: 'entity1' })
     const entities = [...dataDomain.listEntities(model.key)]
     assert.instanceOf(entities[0], DomainEntity)
-  })
+  }).tags(['@modeling', '@entity', '@list'])
 
   test('lists entities when there are no entities', ({ assert }) => {
     const dataDomain = new DataDomain()
     const model = dataDomain.addModel({ key: 'test-model' })
     const entities = [...dataDomain.listEntities(model.key)]
     assert.deepEqual(entities, [])
-  })
+  }).tags(['@modeling', '@entity', '@list'])
 
   test('lists entities when there are other domain elements', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -204,20 +204,20 @@ test.group('DataDomain.listEntities()', () => {
     dataDomain.addNamespace({ key: 'ns1' })
     const entities = [...dataDomain.listEntities(model.key)]
     assert.deepEqual(entities, [entity1])
-  })
+  }).tags(['@modeling', '@entity', '@list'])
 
   test('returns an empty array if the parent model does not exist', ({ assert }) => {
     const dataDomain = new DataDomain()
     const entities = [...dataDomain.listEntities('non-existent-model')]
     assert.deepEqual(entities, [])
-  })
+  }).tags(['@modeling', '@entity', '@list'])
 
   test('returns an empty array if the parent is not a model', ({ assert }) => {
     const dataDomain = new DataDomain()
     const namespace = dataDomain.addNamespace({ key: 'test-ns' })
     const entities = [...dataDomain.listEntities(namespace.key)]
     assert.deepEqual(entities, [])
-  })
+  }).tags(['@modeling', '@entity', '@list'])
 
   test('lists entities from a foreign domain', ({ assert }) => {
     const domain1 = new DataDomain()
@@ -233,7 +233,7 @@ test.group('DataDomain.listEntities()', () => {
     const children = [...domain1.listEntities(m1.key)]
     assert.lengthOf(children, 1)
     assert.deepInclude(children, e1)
-  })
+  }).tags(['@modeling', '@entity', '@list'])
 })
 
 test.group('DataDomain.findEntity()', () => {
@@ -243,75 +243,75 @@ test.group('DataDomain.findEntity()', () => {
     const entity = dataDomain.addEntity(model.key, { key: 'test-entity' })
     const foundEntity = dataDomain.findEntity('test-entity')
     assert.deepEqual(foundEntity, entity)
-  })
+  }).tags(['@modeling', '@entity', '@find'])
 
   test('returns undefined if entity does not exist', ({ assert }) => {
     const dataDomain = new DataDomain()
     const foundEntity = dataDomain.findEntity('non-existent-entity')
     assert.isUndefined(foundEntity)
-  })
+  }).tags(['@modeling', '@entity', '@find'])
 
   test('returns undefined if key is not an entity', ({ assert }) => {
     const dataDomain = new DataDomain()
     const model = dataDomain.addModel({ key: 'test-model' })
     const foundEntity = dataDomain.findEntity(model.key)
     assert.isUndefined(foundEntity)
-  })
+  }).tags(['@modeling', '@entity', '@find'])
 
   test('returns undefined if key is undefined', ({ assert }) => {
     const dataDomain = new DataDomain()
     // @ts-expect-error For testing purposes
     const foundEntity = dataDomain.findEntity(undefined)
     assert.isUndefined(foundEntity)
-  })
+  }).tags(['@modeling', '@entity', '@find'])
 
   test('returns undefined if key is null', ({ assert }) => {
     const dataDomain = new DataDomain()
     // @ts-expect-error For testing purposes
     const foundEntity = dataDomain.findEntity(null)
     assert.isUndefined(foundEntity)
-  })
+  }).tags(['@modeling', '@entity', '@find'])
 
   test('returns undefined if key is an empty string', ({ assert }) => {
     const dataDomain = new DataDomain()
     const foundEntity = dataDomain.findEntity('')
     assert.isUndefined(foundEntity)
-  })
+  }).tags(['@modeling', '@entity', '@find'])
 
   test('returns undefined if key is a number', ({ assert }) => {
     const dataDomain = new DataDomain()
     // @ts-expect-error For testing purposes
     const foundEntity = dataDomain.findEntity(123)
     assert.isUndefined(foundEntity)
-  })
+  }).tags(['@modeling', '@entity', '@find'])
 
   test('returns undefined if key is a boolean', ({ assert }) => {
     const dataDomain = new DataDomain()
     // @ts-expect-error For testing purposes
     const foundEntity = dataDomain.findEntity(true)
     assert.isUndefined(foundEntity)
-  })
+  }).tags(['@modeling', '@entity', '@find'])
 
   test('returns undefined if key is an object', ({ assert }) => {
     const dataDomain = new DataDomain()
     // @ts-expect-error For testing purposes
     const foundEntity = dataDomain.findEntity({})
     assert.isUndefined(foundEntity)
-  })
+  }).tags(['@modeling', '@entity', '@find'])
 
   test('returns undefined if key is an array', ({ assert }) => {
     const dataDomain = new DataDomain()
     // @ts-expect-error For testing purposes
     const foundEntity = dataDomain.findEntity([])
     assert.isUndefined(foundEntity)
-  })
+  }).tags(['@modeling', '@entity', '@find'])
 
   test('returns undefined if key is a function', ({ assert }) => {
     const dataDomain = new DataDomain()
     // @ts-expect-error For testing purposes
     const foundEntity = dataDomain.findEntity(() => {})
     assert.isUndefined(foundEntity)
-  })
+  }).tags(['@modeling', '@entity', '@find'])
 
   test('finds an entity in a foreign domain', ({ assert }) => {
     const domain1 = new DataDomain()
@@ -326,7 +326,7 @@ test.group('DataDomain.findEntity()', () => {
 
     const foundEntity = domain1.findEntity('entity1')
     assert.deepEqual(foundEntity, e1)
-  })
+  }).tags(['@modeling', '@entity', '@find'])
 })
 
 test.group('DomainEntity.addSemantic()', () => {
@@ -337,7 +337,7 @@ test.group('DomainEntity.addSemantic()', () => {
     const semantic = { id: SemanticType.User }
     entity.addSemantic(semantic)
     assert.deepInclude(entity.semantics, semantic)
-  })
+  }).tags(['@modeling', '@entity', '@add', '@semantic'])
 
   test('updates an existing semantic', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -349,7 +349,7 @@ test.group('DomainEntity.addSemantic()', () => {
     entity.addSemantic(semantic2)
     assert.lengthOf(entity.semantics, 1)
     assert.deepInclude(entity.semantics, semantic2)
-  })
+  }).tags(['@modeling', '@entity', '@add', '@semantic'])
 
   test('throws an error if the semantic is not an entity semantic', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -359,7 +359,7 @@ test.group('DomainEntity.addSemantic()', () => {
     assert.throws(() => {
       entity.addSemantic(semantic)
     }, `Invalid semantic type: ${SemanticType.CreatedTimestamp}. Expected an entity semantic.`)
-  })
+  }).tags(['@modeling', '@entity', '@add', '@semantic'])
 
   test('notifies change when adding a new semantic', async ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -368,7 +368,7 @@ test.group('DomainEntity.addSemantic()', () => {
     const semantic = { id: SemanticType.User }
     entity.addSemantic(semantic)
     await assert.dispatches(dataDomain, 'change', { timeout: 20 })
-  })
+  }).tags(['@modeling', '@entity', '@add', '@semantic'])
 
   test('notifies change when updating an existing semantic', async ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -381,7 +381,7 @@ test.group('DomainEntity.addSemantic()', () => {
     await new Promise((resolve) => setTimeout(resolve, 0))
     entity.addSemantic(semantic2)
     await assert.dispatches(dataDomain, 'change', { timeout: 20 })
-  })
+  }).tags(['@modeling', '@entity', '@add', '@semantic'])
 })
 
 test.group('DomainEntity.removeSemantic()', () => {
@@ -395,7 +395,7 @@ test.group('DomainEntity.removeSemantic()', () => {
     entity.removeSemantic(SemanticType.User)
     assert.notDeepInclude(entity.semantics, semantic)
     assert.lengthOf(entity.semantics, 0)
-  })
+  }).tags(['@modeling', '@entity', '@remove', '@semantic'])
 
   test('does nothing if the semantic to remove does not exist', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -406,7 +406,7 @@ test.group('DomainEntity.removeSemantic()', () => {
     const initialSemantics = [...entity.semantics]
     entity.removeSemantic('non-existent-semantic-id' as SemanticType)
     assert.deepEqual(entity.semantics, initialSemantics)
-  })
+  }).tags(['@modeling', '@entity', '@remove', '@semantic'])
 
   test('notifies change when a semantic is removed', async ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -418,7 +418,7 @@ test.group('DomainEntity.removeSemantic()', () => {
     await new Promise((resolve) => setTimeout(resolve, 0))
     entity.removeSemantic(SemanticType.User)
     await assert.dispatches(dataDomain, 'change', { timeout: 20 })
-  })
+  }).tags(['@modeling', '@entity', '@remove', '@semantic'])
 
   test('does not notify change if the semantic to remove does not exist', async ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -428,7 +428,7 @@ test.group('DomainEntity.removeSemantic()', () => {
     await new Promise((resolve) => setTimeout(resolve, 0))
     entity.removeSemantic('non-existent-semantic-id' as SemanticType)
     await assert.notDispatches(dataDomain, 'change', { timeout: 20 })
-  })
+  }).tags(['@modeling', '@entity', '@remove', '@semantic'])
 })
 
 test.group('DomainEntity.hasSemantic()', () => {
@@ -439,21 +439,21 @@ test.group('DomainEntity.hasSemantic()', () => {
     const semantic = { id: SemanticType.User }
     entity.addSemantic(semantic)
     assert.isTrue(entity.hasSemantic(SemanticType.User))
-  })
+  }).tags(['@modeling', '@entity', '@has', '@semantic'])
 
   test('returns false if the entity does not have the specified semantic', ({ assert }) => {
     const dataDomain = new DataDomain()
     const model = dataDomain.addModel({ key: 'test-model' })
     const entity = dataDomain.addEntity(model.key, { key: 'test-entity' })
     assert.isFalse(entity.hasSemantic(SemanticType.User))
-  })
+  }).tags(['@modeling', '@entity', '@has', '@semantic'])
 
   test('returns false for an empty semantics array', ({ assert }) => {
     const dataDomain = new DataDomain()
     const model = dataDomain.addModel({ key: 'test-model' })
     const entity = dataDomain.addEntity(model.key, { key: 'test-entity' })
     assert.isFalse(entity.hasSemantic(SemanticType.User))
-  })
+  }).tags(['@modeling', '@entity', '@has', '@semantic'])
 })
 
 test.group('DataDomain.moveEntity()', () => {
@@ -466,7 +466,7 @@ test.group('DataDomain.moveEntity()', () => {
     assert.equal(dataDomain.graph.parent(entity.key), model2.key)
     assert.deepEqual(model1.fields, [])
     assert.deepEqual(model2.fields, [{ key: entity.key, type: 'entity' }])
-  })
+  }).tags(['@modeling', '@entity', '@move'])
 
   test('throws an error if the entity does not exist', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -475,7 +475,7 @@ test.group('DataDomain.moveEntity()', () => {
     assert.throws(() => {
       dataDomain.moveEntity('non-existent-entity', model1.key, model2.key)
     }, 'Entity non-existent-entity does not exist')
-  })
+  }).tags(['@modeling', '@entity', '@move'])
 
   test('throws an error if the source model does not exist', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -484,7 +484,7 @@ test.group('DataDomain.moveEntity()', () => {
     assert.throws(() => {
       dataDomain.moveEntity(entity.key, 'non-existent-model', model2.key)
     }, 'Source model non-existent-model does not exist')
-  })
+  }).tags(['@modeling', '@entity', '@move'])
 
   test('throws an error if the target model does not exist', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -493,7 +493,7 @@ test.group('DataDomain.moveEntity()', () => {
     assert.throws(() => {
       dataDomain.moveEntity(entity.key, model1.key, 'non-existent-model')
     }, 'Target model non-existent-model does not exist')
-  })
+  }).tags(['@modeling', '@entity', '@move'])
 
   test('throws an error if the entity is not in the same domain', ({ assert }) => {
     const dataDomain1 = new DataDomain()
@@ -508,7 +508,7 @@ test.group('DataDomain.moveEntity()', () => {
     assert.throws(() => {
       dataDomain2.moveEntity(`${dataDomain1.key}:${entity.key}`, `${dataDomain1.key}:${model1.key}`, model2.key)
     }, 'Cannot move an entity from a foreign domain')
-  })
+  }).tags(['@modeling', '@entity', '@move'])
 
   test('throws an error if the target model is not in the same domain', ({ assert }) => {
     const dataDomain1 = new DataDomain()
@@ -523,7 +523,7 @@ test.group('DataDomain.moveEntity()', () => {
     assert.throws(() => {
       dataDomain1.moveEntity(entity.key, model1.key, `${dataDomain2.key}:${model2.key}`)
     }, 'Cannot move an entity to a foreign domain')
-  })
+  }).tags(['@modeling', '@entity', '@move'])
 
   test('throws an error if the source and target models are the same', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -532,7 +532,7 @@ test.group('DataDomain.moveEntity()', () => {
     assert.throws(() => {
       dataDomain.moveEntity(entity.key, model1.key, model1.key)
     }, 'Cannot move an entity to the same model')
-  })
+  }).tags(['@modeling', '@entity', '@move'])
 
   test('throws an error if the target is not a model', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -542,7 +542,7 @@ test.group('DataDomain.moveEntity()', () => {
     assert.throws(() => {
       dataDomain.moveEntity(entity.key, model1.key, namespace.key)
     }, 'Entity or models not found in the graph')
-  })
+  }).tags(['@modeling', '@entity', '@move'])
 
   test('notifies change', async ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -551,7 +551,7 @@ test.group('DataDomain.moveEntity()', () => {
     const entity = model1.addEntity({ key: 'entity1' })
     dataDomain.moveEntity(entity.key, model1.key, model2.key)
     await assert.dispatches(dataDomain, 'change', { timeout: 20 })
-  })
+  }).tags(['@modeling', '@entity', '@move'])
 
   test('moves an entity with properties', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -562,7 +562,7 @@ test.group('DataDomain.moveEntity()', () => {
     dataDomain.moveEntity(entity.key, model1.key, model2.key)
     assert.equal(dataDomain.graph.parent(entity.key), model2.key)
     assert.isTrue(dataDomain.graph.hasNode('test-property'))
-  })
+  }).tags(['@modeling', '@entity', '@move'])
 
   test('moves an entity with associations', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -573,5 +573,5 @@ test.group('DataDomain.moveEntity()', () => {
     dataDomain.moveEntity(entity.key, model1.key, model2.key)
     assert.equal(dataDomain.graph.parent(entity.key), model2.key)
     assert.isTrue(dataDomain.graph.hasNode(assoc.key))
-  })
+  }).tags(['@modeling', '@entity', '@move'])
 })