@api-client/core 0.17.0 → 0.17.1

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

@@ -10,7 +10,7 @@ test.group('DataDomain.addAssociation()', () => {
     const association = dataDomain.addAssociation(entity.key)
     assert.instanceOf(association, DomainAssociation)
     assert.isTrue(dataDomain.graph.hasNode(association.key))
-  })
+  }).tags(['@modeling', '@associations', '@add'])
 
   test('addAssociation adds an association to an entity with a target', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -20,14 +20,14 @@ test.group('DataDomain.addAssociation()', () => {
     const association = dataDomain.addAssociation(entity1.key, { key: entity2.key })
     assert.instanceOf(association, DomainAssociation)
     assert.isTrue(dataDomain.graph.hasNode(association.key))
-  })
+  }).tags(['@modeling', '@associations', '@add'])
 
   test('addAssociation throws an error if source entity does not exist', ({ assert }) => {
     const dataDomain = new DataDomain()
     assert.throws(() => {
       dataDomain.addAssociation('non-existent-entity')
     }, 'Source entity non-existent-entity not found')
-  })
+  }).tags(['@modeling', '@associations', '@add'])
 
   test('addAssociation adds an association with default values', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -38,7 +38,7 @@ test.group('DataDomain.addAssociation()', () => {
     assert.isTrue(dataDomain.graph.hasNode(association.key))
     assert.typeOf(association.key, 'string')
     assert.equal(association.info.name, 'new_association')
-  })
+  }).tags(['@modeling', '@associations', '@add'])
 
   test('addAssociation notifies change', async ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -46,7 +46,7 @@ test.group('DataDomain.addAssociation()', () => {
     const entity = dataDomain.addEntity(model.key, { key: 'test-entity' })
     dataDomain.addAssociation(entity.key)
     await assert.dispatches(dataDomain, 'change', { timeout: 20 })
-  })
+  }).tags(['@modeling', '@associations', '@add'])
 
   test('addAssociation adds an association to an entity - checks parent-child relationship', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -54,7 +54,7 @@ test.group('DataDomain.addAssociation()', () => {
     const entity = dataDomain.addEntity(model.key, { key: 'test-entity' })
     const association = dataDomain.addAssociation(entity.key)
     assert.isTrue(dataDomain.graph.hasEdge(entity.key, association.key))
-  })
+  }).tags(['@modeling', '@associations', '@add'])
 
   test('addAssociation adds an association to an entity - checks items list', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -62,7 +62,7 @@ test.group('DataDomain.addAssociation()', () => {
     const entity = dataDomain.addEntity(model.key, { key: 'test-entity' })
     const association = dataDomain.addAssociation(entity.key)
     assert.deepInclude([...entity.listAssociations()], association)
-  })
+  }).tags(['@modeling', '@associations', '@add'])
 
   test('addAssociation throws an error if no source is provided', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -70,7 +70,7 @@ test.group('DataDomain.addAssociation()', () => {
       // @ts-expect-error For testing purposes, we are passing undefined
       dataDomain.addAssociation(undefined)
     }, 'Source entity undefined not found')
-  })
+  }).tags(['@modeling', '@associations', '@add'])
 
   test('addAssociation adds an association to a foreign entity', ({ assert }) => {
     const domain1 = new DataDomain()
@@ -87,7 +87,7 @@ test.group('DataDomain.addAssociation()', () => {
     const association = domain1.addAssociation(e1.key, { key: 'entity2', domain: domain2.key })
     assert.instanceOf(association, DomainAssociation)
     assert.isTrue(domain1.graph.hasNode(association.key))
-  })
+  }).tags(['@modeling', '@associations', '@add'])
 
   test('addAssociation throws an error if foreign entity does not exist', ({ assert }) => {
     const domain1 = new DataDomain()
@@ -101,7 +101,7 @@ test.group('DataDomain.addAssociation()', () => {
     assert.throws(() => {
       domain1.addAssociation(e1.key, { key: 'non-existent-entity', domain: 'domain2' })
     }, 'Foreign entity domain2:non-existent-entity not found')
-  })
+  }).tags(['@modeling', '@associations', '@add'])
 })
 
 test.group('DataDomain.removeAssociation()', () => {
@@ -112,14 +112,14 @@ test.group('DataDomain.removeAssociation()', () => {
     const association = dataDomain.addAssociation(entity.key)
     dataDomain.removeAssociation(association.key)
     assert.isFalse(dataDomain.graph.hasNode(association.key))
-  })
+  }).tags(['@modeling', '@associations', '@remove'])
 
   test('throws an error if the association does not exist', ({ assert }) => {
     const dataDomain = new DataDomain()
     assert.throws(() => {
       dataDomain.removeAssociation('non-existent-association')
     }, 'Association non-existent-association does not exist')
-  })
+  }).tags(['@modeling', '@associations', '@remove'])
 
   test('removes the association from the parent entity', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -128,7 +128,7 @@ test.group('DataDomain.removeAssociation()', () => {
     const association = dataDomain.addAssociation(entity.key)
     dataDomain.removeAssociation(association.key)
     assert.isFalse(entity.hasAssociations())
-  })
+  }).tags(['@modeling', '@associations', '@remove'])
 
   test('throws an error when the parent entity is not found', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -137,7 +137,7 @@ test.group('DataDomain.removeAssociation()', () => {
     assert.throws(() => {
       dataDomain.removeAssociation(association.key)
     }, `Parent entity not found for association ${association.key}`)
-  })
+  }).tags(['@modeling', '@associations', '@remove'])
 
   test('notifies change', async ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -146,7 +146,7 @@ test.group('DataDomain.removeAssociation()', () => {
     const association = dataDomain.addAssociation(entity.key)
     dataDomain.removeAssociation(association.key)
     await assert.dispatches(dataDomain, 'change', { timeout: 20 })
-  })
+  }).tags(['@modeling', '@associations', '@remove'])
 
   test('removes an association to a foreign entity', ({ assert }) => {
     const domain1 = new DataDomain()
@@ -162,7 +162,7 @@ test.group('DataDomain.removeAssociation()', () => {
     const association = domain1.addAssociation(e1.key, { key: e2.key, domain: domain2.key })
     domain1.removeAssociation(association.key)
     assert.isFalse(domain1.graph.hasNode(association.key))
-  })
+  }).tags(['@modeling', '@associations', '@remove'])
 
   test('throws an error if the association is not of type DomainAssociation', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -171,7 +171,7 @@ test.group('DataDomain.removeAssociation()', () => {
     assert.throws(() => {
       dataDomain.removeAssociation(model.key)
     }, 'Association test-model not found')
-  })
+  }).tags(['@modeling', '@associations', '@remove'])
 
   test('removes the association from the fields list', ({ assert }) => {
     const dataDomain = new DataDomain()
@@ -180,7 +180,18 @@ test.group('DataDomain.removeAssociation()', () => {
     const association = dataDomain.addAssociation(entity.key)
     dataDomain.removeAssociation(association.key)
     assert.deepEqual([...entity.listFields()], [])
-  })
+  }).tags(['@modeling', '@associations', '@remove'])
+
+  test('keeps both source and target entities in the graph after removing an association', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity1 = dataDomain.addEntity(model.key, { key: 'entity1' })
+    const entity2 = dataDomain.addEntity(model.key, { key: 'entity2' })
+    const association = dataDomain.addAssociation(entity1.key, { key: entity2.key })
+    dataDomain.removeAssociation(association.key)
+    assert.isTrue(dataDomain.graph.hasNode(entity1.key))
+    assert.isTrue(dataDomain.graph.hasNode(entity2.key))
+  }).tags(['@modeling', '@associations', '@remove'])
 })
 
 test.group('DataDomain.findAssociation()', () => {
@@ -191,75 +202,75 @@ test.group('DataDomain.findAssociation()', () => {
     const association = dataDomain.addAssociation(entity.key)
     const foundAssociation = dataDomain.findAssociation(association.key)
     assert.deepEqual(foundAssociation, association)
-  })
+  }).tags(['@modeling', '@associations', '@find'])
 
   test('returns undefined if association does not exist', ({ assert }) => {
     const dataDomain = new DataDomain()
     const foundAssociation = dataDomain.findAssociation('non-existent-association')
     assert.isUndefined(foundAssociation)
-  })
+  }).tags(['@modeling', '@associations', '@find'])
 
   test('returns undefined if key is not an association', ({ assert }) => {
     const dataDomain = new DataDomain()
     const model = dataDomain.addModel({ key: 'test-model' })
     const foundAssociation = dataDomain.findAssociation(model.key)
     assert.isUndefined(foundAssociation)
-  })
+  }).tags(['@modeling', '@associations', '@find'])
 
   test('returns undefined if key is undefined', ({ assert }) => {
     const dataDomain = new DataDomain()
     // @ts-expect-error For testing purposes
     const foundAssociation = dataDomain.findAssociation(undefined)
     assert.isUndefined(foundAssociation)
-  })
+  }).tags(['@modeling', '@associations', '@find'])
 
   test('returns undefined if key is null', ({ assert }) => {
     const dataDomain = new DataDomain()
     // @ts-expect-error For testing purposes
     const foundAssociation = dataDomain.findAssociation(null)
     assert.isUndefined(foundAssociation)
-  })
+  }).tags(['@modeling', '@associations', '@find'])
 
   test('returns undefined if key is an empty string', ({ assert }) => {
     const dataDomain = new DataDomain()
     const foundAssociation = dataDomain.findAssociation('')
     assert.isUndefined(foundAssociation)
-  })
+  }).tags(['@modeling', '@associations', '@find'])
 
   test('returns undefined if key is a number', ({ assert }) => {
     const dataDomain = new DataDomain()
     // @ts-expect-error For testing purposes
     const foundAssociation = dataDomain.findAssociation(123)
     assert.isUndefined(foundAssociation)
-  })
+  }).tags(['@modeling', '@associations', '@find'])
 
   test('returns undefined if key is a boolean', ({ assert }) => {
     const dataDomain = new DataDomain()
     // @ts-expect-error For testing purposes
     const foundAssociation = dataDomain.findAssociation(true)
     assert.isUndefined(foundAssociation)
-  })
+  }).tags(['@modeling', '@associations', '@find'])
 
   test('returns undefined if key is an object', ({ assert }) => {
     const dataDomain = new DataDomain()
     // @ts-expect-error For testing purposes
     const foundAssociation = dataDomain.findAssociation({})
     assert.isUndefined(foundAssociation)
-  })
+  }).tags(['@modeling', '@associations', '@find'])
 
   test('returns undefined if key is an array', ({ assert }) => {
     const dataDomain = new DataDomain()
     // @ts-expect-error For testing purposes
     const foundAssociation = dataDomain.findAssociation([])
     assert.isUndefined(foundAssociation)
-  })
+  }).tags(['@modeling', '@associations', '@find'])
 
   test('returns undefined if key is a function', ({ assert }) => {
     const dataDomain = new DataDomain()
     // @ts-expect-error For testing purposes
     const foundAssociation = dataDomain.findAssociation(() => {})
     assert.isUndefined(foundAssociation)
-  })
+  }).tags(['@modeling', '@associations', '@find'])
 
   test('finds an association to a foreign domain', ({ assert }) => {
     const domain1 = new DataDomain()
@@ -275,5 +286,5 @@ test.group('DataDomain.findAssociation()', () => {
 
     const foundAssociation = domain1.findAssociation(association.key)
     assert.deepEqual(foundAssociation, association)
-  })
+  }).tags(['@modeling', '@associations', '@find'])
 })

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

@@ -2,7 +2,11 @@ import { test } from '@japa/runner'
 import { DataDomain, DataFormat } from '../../../src/index.js'
 import { SemanticType } from '../../../src/modeling/Semantics.js'
 
-test.group('DataDomain change observers', () => {
+test.group('DataDomain change observers', (g) => {
+  g.tests.forEach((test) => {
+    test.tags(['@modeling', '@domain', '@change_observers'])
+  })
+
   test('does not notifies a change when initializing a domain', async ({ assert }) => {
     const domain = new DataDomain()
     await assert.notDispatches(domain, 'change', { timeout: 1 })
@@ -33,7 +37,11 @@ test.group('DataDomain change observers', () => {
   })
 })
 
-test.group('DomainNamespace change observers', () => {
+test.group('DomainNamespace change observers', (g) => {
+  g.tests.forEach((test) => {
+    test.tags(['@modeling', '@namespace', '@change_observers'])
+  })
+
   test('notifies a change when changing info.name', async ({ assert, sleep }) => {
     const domain = new DataDomain()
     const n1 = domain.addNamespace()
@@ -128,7 +136,11 @@ test.group('DomainNamespace change observers', () => {
   })
 })
 
-test.group('DomainModel change observers', () => {
+test.group('DomainModel change observers', (g) => {
+  g.tests.forEach((test) => {
+    test.tags(['@modeling', '@model', '@change_observers'])
+  })
+
   test('notifies a change when changing info.name', async ({ assert, sleep }) => {
     const domain = new DataDomain()
     const n1 = domain.addNamespace()
@@ -205,7 +217,11 @@ test.group('DomainModel change observers', () => {
   })
 })
 
-test.group('DomainEntity change observers', () => {
+test.group('DomainEntity change observers', (g) => {
+  g.tests.forEach((test) => {
+    test.tags(['@modeling', '@entity', '@change_observers'])
+  })
+
   test('notifies a change when changing info.name', async ({ assert, sleep }) => {
     const domain = new DataDomain()
     const n1 = domain.addNamespace()
@@ -364,7 +380,11 @@ test.group('DomainEntity change observers', () => {
   })
 })
 
-test.group('DomainProperty change observers', () => {
+test.group('DomainProperty change observers', (g) => {
+  g.tests.forEach((test) => {
+    test.tags(['@modeling', '@property', '@change_observers'])
+  })
+
   test('notifies a change when changing info.name', async ({ assert, sleep }) => {
     const domain = new DataDomain()
     const n1 = domain.addNamespace()
@@ -566,7 +586,11 @@ test.group('DomainProperty change observers', () => {
   })
 })
 
-test.group('DomainAssociation change observers', () => {
+test.group('DomainAssociation change observers', (g) => {
+  g.tests.forEach((test) => {
+    test.tags(['@modeling', '@association', '@change_observers'])
+  })
+
   test('notifies a change when changing info.name', async ({ assert, sleep }) => {
     const domain = new DataDomain()
     const n1 = domain.addNamespace()