@api-client/core 0.11.10 → 0.12.0

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

@@ -0,0 +1,264 @@
+import { test } from '@japa/runner'
+import { DataDomain } from '../../../src/modeling/DataDomain.js'
+import { DomainProperty } from '../../../src/modeling/DomainProperty.js'
+
+test.group('DataDomain.addProperty()', () => {
+  test('addProperty adds a property to an entity', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel({ key: 'test-model' })
+    const entity = dataDomain.addEntity(model.key, { key: 'test-entity' })
+    const property = dataDomain.addProperty(entity.key, { key: 'test-property' })
+    assert.instanceOf(property, DomainProperty)
+    assert.isTrue(dataDomain.graph.hasNode(property.key))
+  })
+
+  test('addProperty adds a property with default values', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel({ key: 'test-model' })
+    const entity = dataDomain.addEntity(model.key, { key: 'test-entity' })
+    const property = dataDomain.addProperty(entity.key)
+    assert.instanceOf(property, DomainProperty)
+    assert.isTrue(dataDomain.graph.hasNode(property.key))
+    assert.equal(property.info.name, 'New property')
+    assert.equal(property.type, 'string')
+  })
+
+  test('addProperty throws an error if parent entity does not exist', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    assert.throws(() => {
+      dataDomain.addProperty('non-existent-entity', { key: 'test-property' })
+    }, 'Parent entity non-existent-entity does not exist')
+  })
+
+  test('addProperty throws an error if parent is not an entity', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    assert.throws(() => {
+      dataDomain.addProperty(model.key)
+    }, `Parent entity ${model.key} not found`)
+  })
+
+  test('addProperty notifies change', async ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = dataDomain.addEntity(model.key)
+    dataDomain.addProperty(entity.key)
+    await assert.dispatches(dataDomain, 'change', { timeout: 20 })
+  })
+
+  test('addProperty adds a property to a parent entity - checks parent-child relationship', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = dataDomain.addEntity(model.key)
+    const property = dataDomain.addProperty(entity.key)
+    assert.isTrue(dataDomain.graph.hasEdge(entity.key, property.key))
+  })
+
+  test('addProperty adds a property to a parent entity - checks items list', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = dataDomain.addEntity(model.key)
+    const property = dataDomain.addProperty(entity.key)
+    assert.deepInclude([...entity.listProperties()], property)
+  })
+
+  test('addProperty throws an error if no parent is provided', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    assert.throws(() => {
+      // @ts-expect-error For testing purposes, we are passing undefined
+      dataDomain.addProperty(undefined)
+    }, 'A property expects a DataEntity parent')
+  })
+
+  test('addProperty throws when adding property to a foreign entity', ({ assert }) => {
+    const domain1 = new DataDomain()
+    const m1 = domain1.addModel({ key: 'model1' })
+    domain1.addEntity(m1.key, { key: 'entity1' })
+
+    const domain2 = new DataDomain()
+    const m2 = domain2.addModel({ key: 'model2' })
+    const e2 = domain2.addEntity(m2.key, { key: 'entity2' })
+
+    domain2.info.version = '1.0.0'
+    domain1.registerForeignDomain(domain2)
+
+    assert.throws(() => {
+      domain1.addProperty(`${domain2.key}:${e2.key}`)
+    }, 'Cannot add a property to a foreign domain')
+  })
+})
+
+test.group('DataDomain.removeProperty()', () => {
+  test('removes a property from the graph', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = dataDomain.addEntity(model.key)
+    const property = dataDomain.addProperty(entity.key)
+    dataDomain.removeProperty(property.key)
+    assert.isFalse(dataDomain.graph.hasNode(property.key))
+  })
+
+  test('throws an error if the property does not exist', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    assert.throws(() => {
+      dataDomain.removeProperty('non-existent-property')
+    }, 'Property non-existent-property does not exist')
+  })
+
+  test('removes the property from the parent entity', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = dataDomain.addEntity(model.key)
+    const property = dataDomain.addProperty(entity.key)
+    dataDomain.removeProperty(property.key)
+    assert.isUndefined(entity.listProperties().next().value)
+  })
+
+  test('throws an error when the parent entity is not found', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const property = new DomainProperty(dataDomain, 'non-existent-entity')
+    dataDomain.graph.setNode(property.key, property)
+    assert.throws(() => {
+      dataDomain.removeProperty(property.key)
+    }, `Parent entity not found for property ${property.key}`)
+  })
+
+  test('notifies change', async ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = dataDomain.addEntity(model.key)
+    const property = dataDomain.addProperty(entity.key)
+    dataDomain.removeProperty(property.key)
+    await assert.dispatches(dataDomain, 'change', { timeout: 20 })
+  })
+
+  test('throws an error if the property is not of type DomainProperty', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    dataDomain.graph.setNode(model.key, model)
+    assert.throws(() => {
+      dataDomain.removeProperty(model.key)
+    }, `Property ${model.key} not found`)
+  })
+
+  test('throws an error if trying to remove a property from a foreign domain', ({ assert }) => {
+    const domain1 = new DataDomain()
+    const m1 = domain1.addModel()
+    domain1.addEntity(m1.key)
+
+    const domain2 = new DataDomain()
+    const m2 = domain2.addModel()
+    const e2 = domain2.addEntity(m2.key)
+    const property = domain2.addProperty(e2.key)
+
+    domain2.info.version = '1.0.0'
+    domain1.registerForeignDomain(domain2)
+    assert.throws(() => {
+      domain1.removeProperty(`${domain2.key}:${property.key}`)
+    }, 'Cannot remove a property from a foreign domain')
+  })
+
+  test('removes the property from the fields list', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = dataDomain.addEntity(model.key)
+    const property = dataDomain.addProperty(entity.key)
+    dataDomain.removeProperty(property.key)
+    assert.deepEqual([...entity.listFields()], [])
+  })
+})
+
+test.group('DataDomain.findProperty()', () => {
+  test('finds a property by its key', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = dataDomain.addEntity(model.key)
+    const property = dataDomain.addProperty(entity.key)
+    const foundProperty = dataDomain.findProperty(property.key)
+    assert.deepEqual(foundProperty, property)
+  })
+
+  test('returns undefined if property does not exist', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const foundProperty = dataDomain.findProperty('non-existent-property')
+    assert.isUndefined(foundProperty)
+  })
+
+  test('returns undefined if key is not a property', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const foundProperty = dataDomain.findProperty(model.key)
+    assert.isUndefined(foundProperty)
+  })
+
+  test('returns undefined if key is undefined', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    // @ts-expect-error For testing purposes
+    const foundProperty = dataDomain.findProperty(undefined)
+    assert.isUndefined(foundProperty)
+  })
+
+  test('returns undefined if key is null', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    // @ts-expect-error For testing purposes
+    const foundProperty = dataDomain.findProperty(null)
+    assert.isUndefined(foundProperty)
+  })
+
+  test('returns undefined if key is an empty string', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const foundProperty = dataDomain.findProperty('')
+    assert.isUndefined(foundProperty)
+  })
+
+  test('returns undefined if key is a number', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    // @ts-expect-error For testing purposes
+    const foundProperty = dataDomain.findProperty(123)
+    assert.isUndefined(foundProperty)
+  })
+
+  test('returns undefined if key is a boolean', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    // @ts-expect-error For testing purposes
+    const foundProperty = dataDomain.findProperty(true)
+    assert.isUndefined(foundProperty)
+  })
+
+  test('returns undefined if key is an object', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    // @ts-expect-error For testing purposes
+    const foundProperty = dataDomain.findProperty({})
+    assert.isUndefined(foundProperty)
+  })
+
+  test('returns undefined if key is an array', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    // @ts-expect-error For testing purposes
+    const foundProperty = dataDomain.findProperty([])
+    assert.isUndefined(foundProperty)
+  })
+
+  test('returns undefined if key is a function', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    // @ts-expect-error For testing purposes
+    const foundProperty = dataDomain.findProperty(() => {})
+    assert.isUndefined(foundProperty)
+  })
+
+  test('finds a property in a foreign domain', ({ assert }) => {
+    const domain1 = new DataDomain()
+    const m1 = domain1.addModel({ key: 'model1' })
+    domain1.addEntity(m1.key, { key: 'entity1' })
+
+    const domain2 = new DataDomain()
+    const m2 = domain2.addModel({ key: 'model2' })
+    const e2 = domain2.addEntity(m2.key, { key: 'entity2' })
+    const property = domain2.addProperty(e2.key, { key: 'test-property' })
+    domain2.info.version = '1.0.0'
+    domain1.registerForeignDomain(domain2)
+
+    const foundProperty = domain1.findProperty(`${domain2.key}:${property.key}`)
+    assert.deepEqual(foundProperty, property)
+  })
+})

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

@@ -0,0 +1,294 @@
+import { test } from '@japa/runner'
+import {
+  DomainAssociationKind,
+  DataDomain,
+  DomainEntityKind,
+  DomainModelKind,
+  DomainNamespaceKind,
+  DomainPropertyKind,
+} from '../../../src/index.js'
+
+test.group('DataDomain Serialization and Deserialization', () => {
+  test('should serialize and deserialize an empty DataDomain', ({ assert }) => {
+    const domain = new DataDomain()
+    const serialized = domain.toJSON()
+    const restored = new DataDomain(serialized)
+
+    assert.equal(restored.key, domain.key)
+    assert.equal(restored.kind, domain.kind)
+    assert.deepEqual(restored.info.toJSON(), domain.info.toJSON())
+    assert.equal([...restored.graph.nodes()].length, 0)
+    assert.equal([...restored.graph.edges()].length, 0)
+  })
+
+  test('should serialize and deserialize a DataDomain with namespaces', ({ assert }) => {
+    const domain = new DataDomain()
+    const ns1 = domain.addNamespace()
+    const ns2 = ns1.addNamespace()
+
+    const serialized = domain.toJSON()
+    const restored = new DataDomain(serialized)
+
+    assert.equal(restored.key, domain.key)
+    assert.equal(restored.kind, domain.kind)
+    assert.deepEqual(restored.info.toJSON(), domain.info.toJSON())
+    assert.equal([...restored.graph.nodes()].length, 2)
+    assert.equal([...restored.graph.edges()].length, 0)
+
+    const rn1 = restored.findNamespace(ns1.key)
+    assert.isDefined(rn1)
+    assert.equal(rn1!.key, ns1.key)
+    assert.equal(rn1!.kind, DomainNamespaceKind)
+
+    const rn2 = restored.findNamespace(ns2.key)
+    assert.isDefined(rn2)
+    assert.equal(rn2!.key, ns2.key)
+    assert.equal(rn2!.kind, DomainNamespaceKind)
+    assert.equal(restored.graph.parent(ns2.key), ns1.key)
+  })
+
+  test('should serialize and deserialize a DataDomain with models', ({ assert }) => {
+    const domain = new DataDomain()
+    const m1 = domain.addModel()
+    const m2 = domain.addModel()
+
+    const serialized = domain.toJSON()
+    const restored = new DataDomain(serialized)
+
+    assert.equal(restored.key, domain.key)
+    assert.equal(restored.kind, domain.kind)
+    assert.deepEqual(restored.info.toJSON(), domain.info.toJSON())
+    assert.equal([...restored.graph.nodes()].length, 2)
+    assert.equal([...restored.graph.edges()].length, 0)
+
+    const rm1 = restored.findModel(m1.key)
+    assert.isDefined(rm1)
+    assert.equal(rm1!.key, m1.key)
+    assert.equal(rm1!.kind, DomainModelKind)
+
+    const rm2 = restored.findModel(m2.key)
+    assert.isDefined(rm2)
+    assert.equal(rm2!.key, m2.key)
+    assert.equal(rm2!.kind, DomainModelKind)
+  })
+
+  test('should serialize and deserialize a DataDomain with entities', ({ assert }) => {
+    const domain = new DataDomain()
+    const m1 = domain.addModel()
+    const e1 = m1.addEntity()
+    const e2 = m1.addEntity()
+    e2.addParent(e1.key)
+
+    const serialized = domain.toJSON()
+    const restored = new DataDomain(serialized)
+
+    assert.equal(restored.key, domain.key)
+    assert.equal(restored.kind, domain.kind)
+    assert.deepEqual(restored.info.toJSON(), domain.info.toJSON())
+    assert.equal([...restored.graph.nodes()].length, 3)
+    assert.equal([...restored.graph.edges()].length, 1)
+
+    const re1 = restored.findEntity(e1.key)
+    assert.isDefined(re1)
+    assert.equal(re1!.key, e1.key)
+    assert.equal(re1!.kind, DomainEntityKind)
+
+    const re2 = restored.findEntity(e2.key)
+    assert.isDefined(re2)
+    assert.equal(re2!.key, e2.key)
+    assert.equal(re2!.kind, DomainEntityKind)
+    assert.equal([...re2!.listParents()][0].key, e1.key)
+  })
+
+  test('should serialize and deserialize a DataDomain with properties', ({ assert }) => {
+    const domain = new DataDomain()
+    const m1 = domain.addModel()
+    const e1 = m1.addEntity()
+    const p1 = e1.addProperty({ type: 'string' })
+    const p2 = e1.addProperty({ type: 'number' })
+
+    const serialized = domain.toJSON()
+    const restored = new DataDomain(serialized)
+
+    assert.equal(restored.key, domain.key)
+    assert.equal(restored.kind, domain.kind)
+    assert.deepEqual(restored.info.toJSON(), domain.info.toJSON())
+    assert.equal([...restored.graph.nodes()].length, 4)
+    assert.equal([...restored.graph.edges()].length, 2)
+
+    const rp1 = restored.findProperty(p1.key)
+    assert.isDefined(rp1)
+    assert.equal(rp1!.key, p1.key)
+    assert.equal(rp1!.kind, DomainPropertyKind)
+
+    const rp2 = restored.findProperty(p2.key)
+    assert.isDefined(rp2)
+    assert.equal(rp2!.key, p2.key)
+    assert.equal(rp2!.kind, DomainPropertyKind)
+
+    const re1 = restored.findEntity(e1.key)
+    assert.isDefined(re1)
+    const props = [...re1!.listProperties()]
+    assert.equal(props.length, 2)
+    assert.equal(props[0].key, p1.key)
+    assert.equal(props[1].key, p2.key)
+  })
+
+  test('should serialize and deserialize a DataDomain with associations', ({ assert }) => {
+    const domain = new DataDomain()
+    const m1 = domain.addModel()
+    const e1 = m1.addEntity()
+    const e2 = m1.addEntity()
+    const a1 = e1.addAssociation({ key: e2.key })
+
+    const serialized = domain.toJSON()
+    const restored = new DataDomain(serialized)
+
+    assert.equal(restored.key, domain.key)
+    assert.equal(restored.kind, domain.kind)
+    assert.deepEqual(restored.info.toJSON(), domain.info.toJSON())
+    assert.equal([...restored.graph.nodes()].length, 4)
+    assert.equal([...restored.graph.edges()].length, 2)
+
+    const ra1 = restored.findAssociation(a1.key)
+    assert.isDefined(ra1)
+    assert.equal(ra1!.key, a1.key)
+    assert.equal(ra1!.kind, DomainAssociationKind)
+    assert.equal([...ra1!.listTargets()][0].key, e2.key)
+  })
+
+  test('should serialize and deserialize a complex DataDomain', ({ assert }) => {
+    const domain = new DataDomain()
+    const ns1 = domain.addNamespace()
+    const ns2 = ns1.addNamespace()
+    const m1 = ns1.addModel()
+    const m2 = ns2.addModel()
+    const e1 = m1.addEntity()
+    const e2 = m2.addEntity()
+    e2.addParent(e1.key)
+    const p1 = e1.addProperty({ type: 'string' })
+    const p2 = e2.addProperty({ type: 'number' })
+    const a1 = e1.addAssociation({ key: e2.key })
+
+    const serialized = domain.toJSON()
+    const restored = new DataDomain(serialized)
+
+    assert.equal(restored.key, domain.key)
+    assert.equal(restored.kind, domain.kind)
+    assert.deepEqual(restored.info.toJSON(), domain.info.toJSON())
+    assert.equal([...restored.graph.nodes()].length, 9)
+    assert.equal([...restored.graph.edges()].length, 5)
+
+    const rn1 = restored.findNamespace(ns1.key)
+    assert.isDefined(rn1)
+    assert.equal(rn1!.key, ns1.key)
+    assert.equal(rn1!.kind, DomainNamespaceKind)
+    assert.equal([...rn1!.listNamespaces()][0].key, ns2.key)
+    assert.equal([...rn1!.listModels()][0].key, m1.key)
+
+    const rn2 = restored.findNamespace(ns2.key)
+    assert.isDefined(rn2)
+    assert.equal(rn2!.key, ns2.key)
+    assert.equal(rn2!.kind, DomainNamespaceKind)
+    assert.equal(restored.graph.parent(ns2.key), ns1.key)
+    assert.deepEqual([...rn2!.listNamespaces()], [])
+    assert.equal([...rn2!.listModels()][0].key, m2.key)
+
+    const rm1 = restored.findModel(m1.key)
+    assert.isDefined(rm1)
+    assert.equal(rm1!.key, m1.key)
+    assert.equal(rm1!.kind, DomainModelKind)
+    assert.equal(restored.graph.parent(m1.key), ns1.key)
+
+    const rm2 = restored.findModel(m2.key)
+    assert.isDefined(rm2)
+    assert.equal(rm2!.key, m2.key)
+    assert.equal(rm2!.kind, DomainModelKind)
+    assert.equal(restored.graph.parent(m2.key), ns2.key)
+
+    const re1 = restored.findEntity(e1.key)
+    assert.isDefined(re1)
+    assert.equal(re1!.key, e1.key)
+    assert.equal(re1!.kind, DomainEntityKind)
+    assert.equal(restored.graph.parent(e1.key), m1.key)
+    assert.equal([...re1!.listProperties()][0].key, p1.key)
+
+    const re2 = restored.findEntity(e2.key)
+    assert.isDefined(re2)
+    assert.equal(re2!.key, e2.key)
+    assert.equal(re2!.kind, DomainEntityKind)
+    assert.equal(restored.graph.parent(e2.key), m2.key)
+    assert.equal([...re2!.listParents()][0].key, e1.key)
+    assert.equal([...re2!.listProperties()][0].key, p2.key)
+
+    const rp1 = restored.findProperty(p1.key)
+    assert.isDefined(rp1)
+    assert.equal(rp1!.key, p1.key)
+    assert.equal(rp1!.kind, DomainPropertyKind)
+
+    const rp2 = restored.findProperty(p2.key)
+    assert.isDefined(rp2)
+    assert.equal(rp2!.key, p2.key)
+    assert.equal(rp2!.kind, DomainPropertyKind)
+
+    const ra1 = restored.findAssociation(a1.key)
+    assert.isDefined(ra1)
+    assert.equal(ra1!.key, a1.key)
+    assert.equal(ra1!.kind, DomainAssociationKind)
+    assert.equal([...ra1!.listTargets()][0].key, e2.key)
+  })
+
+  test('should serialize and deserialize a DataDomain with foreign dependencies', ({ assert }) => {
+    const fd = new DataDomain()
+    const fm1 = fd.addModel({ key: 'fm1' })
+    const fe1 = fm1.addEntity({ key: 'fe1' })
+    fe1.addProperty({ type: 'string', key: 'fp1' })
+    fd.info.version = '1.0.0'
+
+    const domain = new DataDomain()
+    domain.registerForeignDomain(fd)
+    const m1 = domain.addModel({ key: 'm1' })
+    const e1 = m1.addEntity({ key: 'e1' })
+    const a1 = e1.addAssociation({ key: fe1.key, domain: fd.key }, { key: 'a1' })
+    const serialized = domain.toJSON()
+    const restored = new DataDomain(serialized, [fd])
+
+    assert.equal(restored.key, domain.key)
+    assert.equal(restored.kind, domain.kind)
+    assert.deepEqual(restored.info.toJSON(), domain.info.toJSON())
+    assert.equal([...restored.graph.nodes()].length, 6)
+    assert.equal([...restored.graph.edges()].length, 3)
+    const rfe1 = restored.findForeignEntity(fe1.key, fd.key)
+    assert.isDefined(rfe1)
+    assert.equal(rfe1!.key, fe1.key)
+    assert.equal(rfe1!.kind, DomainEntityKind)
+    // Associations look like: Entity -> (edge) -> Association -> (edge) -> ForeignEntity
+    assert.isTrue(restored.graph.hasEdge(e1.key, a1.key), 'has edge from e1 to a1')
+    assert.isTrue(restored.graph.hasEdge(a1.key, `${fd.key}:${fe1.key}`), 'has edge from a1 to fe1')
+  })
+
+  test('should serialize and deserialize a DataDomain with missing foreign dependencies', ({ assert }) => {
+    const fd = new DataDomain()
+    fd.info.version = '1.0.0'
+    const fm1 = fd.addModel()
+    const fe1 = fm1.addEntity()
+    fd.addProperty(fe1.key, { type: 'string' })
+
+    const domain = new DataDomain()
+    domain.registerForeignDomain(fd)
+    const m1 = domain.addModel()
+    const e1 = m1.addEntity()
+    const a1 = e1.addAssociation({ key: fe1.key, domain: fd.key })
+
+    const serialized = domain.toJSON()
+    const restored = new DataDomain(serialized)
+
+    assert.equal(restored.key, domain.key)
+    assert.equal(restored.kind, domain.kind)
+    assert.deepEqual(restored.info.toJSON(), domain.info.toJSON())
+    assert.equal([...restored.graph.nodes()].length, 3)
+    assert.equal([...restored.graph.edges()].length, 1)
+    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')
+  })
+})