@api-client/core 0.11.11 → 0.12.1

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

@@ -0,0 +1,113 @@
+import { test } from '@japa/runner'
+import { DataDomain, DomainAssociation, DomainProperty } from '../../../src/index.js'
+
+test.group('DomainEntity.listFields()', () => {
+  test('lists all fields (properties and associations) of this entity', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+    const property1 = entity.addProperty()
+    const association1 = entity.addAssociation()
+    const fields = [...entity.listFields()]
+    assert.lengthOf(fields, 2)
+    assert.deepInclude(fields, property1)
+    assert.deepInclude(fields, association1)
+  })
+
+  test('returns an empty array if there are no fields', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+    const fields = [...entity.listFields()]
+    assert.lengthOf(fields, 0)
+  })
+
+  test('returns only properties and associations', ({ assert }) => {
+    const root = new DataDomain()
+    const m1 = root.addModel()
+    const e1 = m1.addEntity()
+    const e2 = m1.addEntity()
+    const p1 = e1.addProperty()
+    e1.addParent(e2.key)
+    const association1 = e1.addAssociation()
+
+    const fields = [...e1.listFields()]
+    assert.lengthOf(fields, 2)
+    assert.deepInclude(fields, p1)
+    assert.deepInclude(fields, association1)
+  })
+
+  test('fields in the list are of type DomainProperty or DomainAssociation', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+    entity.addProperty()
+    entity.addAssociation()
+    const fields = [...entity.listFields()]
+    assert.instanceOf(fields[0], DomainProperty)
+    assert.instanceOf(fields[1], DomainAssociation)
+  })
+
+  test('lists fields in the order they were added', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+    const property1 = entity.addProperty()
+    const association1 = entity.addAssociation()
+    const property2 = entity.addProperty({ key: 'property2' })
+    const association2 = entity.addAssociation()
+
+    const fields = [...entity.listFields()]
+    assert.deepEqual(fields, [property1, association1, property2, association2])
+  })
+
+  test('lists fields when there are no fields', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+    const fields = [...entity.listFields()]
+    assert.deepEqual(fields, [])
+  })
+
+  test('lists fields when fields array is empty', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+    entity.fields = []
+    const fields = [...entity.listFields()]
+    assert.deepEqual(fields, [])
+  })
+})
+
+test.group('DomainEntity.hasFields()', () => {
+  test('returns true if the entity has any fields (properties or associations)', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+    entity.addProperty()
+    assert.isTrue(entity.hasFields())
+  })
+
+  test('returns true if the entity has any associations', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+    entity.addAssociation()
+    assert.isTrue(entity.hasFields())
+  })
+
+  test('returns false if the entity has no fields', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+    assert.isFalse(entity.hasFields())
+  })
+
+  test('returns false if the entity has an empty fields array', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+    entity.fields = []
+    assert.isFalse(entity.hasFields())
+  })
+})

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

@@ -0,0 +1,20 @@
+import { test } from '@japa/runner'
+import { DataDomain } from '../../../src/index.js'
+
+test.group('DomainEntity.toApiShape()', () => {
+  test('returns an object', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+    const result = entity.toApiShape()
+    assert.typeOf(result, 'object')
+  })
+
+  test('returns an object with the correct kind', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+    const result = entity.toApiShape()
+    assert.equal(result.id, entity.key)
+  })
+})

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

@@ -0,0 +1,291 @@
+import { test } from '@japa/runner'
+import { DataDomain, DomainEntity } from '../../../src/index.js'
+
+test.group('DomainEntity.listParents()', () => {
+  test('lists all parent entities', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity1 = model.addEntity()
+    const entity2 = model.addEntity()
+    const entity3 = model.addEntity()
+    entity2.addParent(entity1.key)
+    entity2.addParent(entity3.key)
+    const parents = [...entity2.listParents()]
+    assert.lengthOf(parents, 2)
+    assert.deepInclude(parents, entity1)
+    assert.deepInclude(parents, entity3)
+  })
+
+  test('returns an empty array if there are no parents', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+    const parents = [...entity.listParents()]
+    assert.lengthOf(parents, 0)
+  })
+
+  test('returns only entities', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity1 = model.addEntity()
+    const entity2 = model.addEntity()
+    entity2.addParent(entity1.key)
+    entity2.addProperty({ key: 'test-property', type: 'string' })
+    const parents = [...entity2.listParents()]
+    assert.lengthOf(parents, 1)
+    assert.deepInclude(parents, entity1)
+  })
+
+  test('entities in the list are of type DomainEntity', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity1 = model.addEntity()
+    const entity2 = model.addEntity()
+    entity2.addParent(entity1.key)
+    const parents = [...entity2.listParents()]
+    assert.instanceOf(parents[0], DomainEntity)
+  })
+
+  test('lists parents when there are multiple levels of inheritance', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity1 = model.addEntity()
+    const entity2 = model.addEntity()
+    const entity3 = model.addEntity()
+    entity3.addParent(entity2.key)
+    entity2.addParent(entity1.key)
+    const parents = [...entity3.listParents()]
+    assert.deepEqual(parents, [entity2])
+  })
+})
+
+test.group('DomainEntity.addParent()', () => {
+  test('adds a parent to the entity', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity1 = model.addEntity({ key: 'entity1' })
+    const entity2 = model.addEntity({ key: 'entity2' })
+    entity2.addParent(entity1.key)
+    assert.isTrue(dataDomain.graph.hasEdge(entity2.key, entity1.key))
+    assert.deepEqual([...entity2.listParents()], [entity1])
+  })
+
+  test('throws an error if the parent does not exist', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+    assert.throws(() => {
+      entity.addParent('non-existent-entity')
+    }, 'Entity with key "non-existent-entity" not found')
+  })
+
+  test('throws an error if adding self as parent', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+    assert.throws(() => {
+      entity.addParent(entity.key)
+    }, 'Entity cannot be a parent of itself')
+  })
+
+  test('throws an error if circular dependency is detected', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity1 = model.addEntity({ key: 'entity1' })
+    const entity2 = model.addEntity({ key: 'entity2' })
+    entity1.addParent(entity2.key)
+    assert.throws(() => {
+      entity2.addParent(entity1.key)
+    }, 'Circular inheritance detected. Cannot add entity1 as a parent')
+  })
+
+  test('throws an error if circular dependency is detected - indirect', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity1 = model.addEntity({ key: 'entity1' })
+    const entity2 = model.addEntity({ key: 'entity2' })
+    const entity3 = model.addEntity({ key: 'entity3' })
+    entity1.addParent(entity2.key)
+    entity2.addParent(entity3.key)
+    assert.throws(() => {
+      entity3.addParent(entity1.key)
+    }, 'Circular inheritance detected. Cannot add entity1 as a parent')
+  })
+
+  test('throws an error if parent already exists', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity1 = model.addEntity({ key: 'entity1' })
+    const entity2 = model.addEntity({ key: 'entity2' })
+    entity2.addParent(entity1.key)
+    assert.throws(() => {
+      entity2.addParent(entity1.key)
+    }, 'Parent entity1 already exists')
+  })
+
+  test('notifies change', async ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity1 = model.addEntity({ key: 'entity1' })
+    const entity2 = model.addEntity({ key: 'entity2' })
+    entity2.addParent(entity1.key)
+    await assert.dispatches(dataDomain, 'change', { timeout: 20 })
+  })
+
+  test('creates a graph edge', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity1 = model.addEntity({ key: 'entity1' })
+    const entity2 = model.addEntity({ key: 'entity2' })
+    entity2.addParent(entity1.key)
+    assert.isTrue(dataDomain.graph.hasEdge(entity2.key, entity1.key))
+    assert.deepEqual(dataDomain.graph.edge(entity2.key, entity1.key), { type: 'parent' })
+  })
+})
+
+test.group('DomainEntity.removeParent()', () => {
+  test('removes a parent from the entity', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity1 = model.addEntity({ key: 'entity1' })
+    const entity2 = model.addEntity({ key: 'entity2' })
+    entity2.addParent(entity1.key)
+    entity2.removeParent(entity1.key)
+    assert.isFalse(dataDomain.graph.hasEdge(entity2.key, entity1.key))
+    assert.deepEqual([...entity2.listParents()], [])
+  })
+
+  test('throws an error if the parent does not exist', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+    assert.throws(() => {
+      entity.removeParent('non-existent-entity')
+    }, `Trying to remove a parent non-existent-entity from ${entity.key}, but it doesn't exist`)
+  })
+
+  test('notifies change', async ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity1 = model.addEntity({ key: 'entity1' })
+    const entity2 = model.addEntity({ key: 'entity2' })
+    entity2.addParent(entity1.key)
+    entity2.removeParent(entity1.key)
+    await assert.dispatches(dataDomain, 'change', { timeout: 20 })
+  })
+
+  test('removes the graph edge', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity1 = model.addEntity({ key: 'entity1' })
+    const entity2 = model.addEntity({ key: 'entity2' })
+    entity2.addParent(entity1.key)
+    entity2.removeParent(entity1.key)
+    assert.isFalse(dataDomain.graph.hasEdge(entity2.key, entity1.key))
+  })
+})
+
+test.group('DomainEntity.hasCircularParent()', () => {
+  test('returns false when no parents', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity1 = model.addEntity({ key: 'entity1' })
+    const entity2 = model.addEntity({ key: 'entity2' })
+    assert.isFalse(entity1.hasCircularParent(entity2.key))
+  })
+
+  test('returns true when direct circular dependency', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity1 = model.addEntity({ key: 'entity1' })
+    const entity2 = model.addEntity({ key: 'entity2' })
+    entity1.addParent(entity2.key)
+    assert.isTrue(entity2.hasCircularParent(entity1.key))
+  })
+
+  test('returns true when indirect circular dependency', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity1 = model.addEntity()
+    const entity2 = model.addEntity()
+    const entity3 = model.addEntity()
+    entity1.addParent(entity2.key)
+    entity2.addParent(entity3.key)
+    assert.isTrue(entity3.hasCircularParent(entity1.key))
+  })
+
+  test('returns true when indirect circular dependency - longer chain', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity1 = model.addEntity({ key: 'entity1' })
+    const entity2 = model.addEntity({ key: 'entity2' })
+    const entity3 = model.addEntity({ key: 'entity3' })
+    const entity4 = model.addEntity({ key: 'entity4' })
+    entity1.addParent(entity2.key)
+    entity2.addParent(entity3.key)
+    entity3.addParent(entity4.key)
+    assert.isTrue(entity4.hasCircularParent(entity1.key))
+  })
+
+  test('returns true when adding one of children as parent', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity1 = model.addEntity({ key: 'entity1' })
+    const entity2 = model.addEntity({ key: 'entity2' })
+    const entity3 = model.addEntity({ key: 'entity3' })
+    entity1.addParent(entity2.key)
+    entity2.addParent(entity3.key)
+    assert.isTrue(entity2.hasCircularParent(entity1.key))
+    assert.isTrue(entity3.hasCircularParent(entity1.key))
+  })
+
+  test('returns true when indirect circular dependency - multiple parents', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity1 = model.addEntity({ key: 'entity1' })
+    const entity2 = model.addEntity({ key: 'entity2' })
+    const entity3 = model.addEntity({ key: 'entity3' })
+    const entity4 = model.addEntity({ key: 'entity4' })
+    entity1.addParent(entity2.key)
+    entity1.addParent(entity3.key)
+    entity2.addParent(entity4.key)
+    assert.isTrue(entity4.hasCircularParent(entity1.key))
+  })
+
+  test('returns false when there is a parent, but not in the chain', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity1 = model.addEntity({ key: 'entity1' })
+    const entity2 = model.addEntity({ key: 'entity2' })
+    const entity3 = model.addEntity({ key: 'entity3' })
+    entity3.addParent(entity2.key)
+    assert.isFalse(entity1.hasCircularParent(entity3.key))
+  })
+})
+
+test.group('DomainEntity.hasParents()', () => {
+  test('returns true if the entity has parents', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity1 = model.addEntity({ key: 'entity1' })
+    const entity2 = model.addEntity({ key: 'entity2' })
+    entity2.addParent(entity1.key)
+    assert.isTrue(entity2.hasParents())
+  })
+
+  test('returns false if the entity has no parents', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+    assert.isFalse(entity.hasParents())
+  })
+
+  test('returns false if the entity has other edges but not parent', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity1 = model.addEntity({ key: 'entity1' })
+    const entity2 = model.addEntity({ key: 'entity2' })
+    dataDomain.graph.setEdge(entity2.key, entity1.key, { type: 'association' })
+    assert.isFalse(entity2.hasParents())
+  })
+})