@api-client/core 0.11.11 → 0.12.1

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

@@ -0,0 +1,305 @@
+import { test } from '@japa/runner'
+import { DataDomain, DomainPropertyKind, DomainProperty } from '../../../src/index.js'
+
+test.group('DomainEntity.addProperty()', () => {
+  test('adds a property to the entity', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+    const property = entity.addProperty({ key: 'test-property', type: 'string' })
+    assert.instanceOf(property, DomainProperty)
+    assert.equal(property.kind, DomainPropertyKind)
+    assert.equal(property.key, 'test-property')
+    assert.deepInclude(property.info, { name: 'New property' })
+    assert.isTrue(dataDomain.graph.hasNode(property.key))
+  })
+
+  test('adds a property with default values', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel({ key: 'test-model' })
+    const entity = model.addEntity({ key: 'test-entity' })
+    const property = entity.addProperty()
+    assert.instanceOf(property, DomainProperty)
+    assert.equal(property.kind, DomainPropertyKind)
+    assert.typeOf(property.key, 'string')
+    assert.isNotEmpty(property.key)
+    assert.deepInclude(property.info, { name: 'New property' })
+    assert.isTrue(dataDomain.graph.hasNode(property.key))
+  })
+
+  test('throws an error if a property with the same key already exists', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+    const p1 = entity.addProperty()
+    assert.throws(() => {
+      entity.addProperty({ key: p1.key, type: 'string' })
+    }, `Trying to add a property ${p1.key}, but it already exists`)
+  })
+
+  test('notifies change', async ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel({ key: 'test-model' })
+    const entity = model.addEntity({ key: 'test-entity' })
+    entity.addProperty({ key: 'test-property', type: 'string' })
+    await assert.dispatches(dataDomain, 'change', { timeout: 20 })
+  })
+
+  test('adds a property to the fields array', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel({ key: 'test-model' })
+    const entity = model.addEntity({ key: 'test-entity' })
+    const property = entity.addProperty({ key: 'test-property', type: 'string' })
+    assert.deepEqual(entity.fields, [{ key: property.key, type: 'property' }])
+  })
+
+  test('adds a property to the root graph', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel({ key: 'test-model' })
+    const entity = model.addEntity({ key: 'test-entity' })
+    const property = entity.addProperty({ key: 'test-property', type: 'string' })
+    assert.isTrue(dataDomain.graph.hasNode(property.key))
+  })
+
+  test('creates a graph edge', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel({ key: 'test-model' })
+    const entity = model.addEntity({ key: 'test-entity' })
+    const property = entity.addProperty({ key: 'test-property', type: 'string' })
+    assert.isTrue(dataDomain.graph.hasEdge(entity.key, property.key))
+    assert.deepEqual(dataDomain.graph.edge(entity.key, property.key), { type: 'property' })
+  })
+})
+
+test.group('DomainEntity.removeProperty()', () => {
+  test('removes a property from the entity', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+    const property = entity.addProperty({ key: 'test-property', type: 'string' })
+    entity.removeProperty(property.key)
+    assert.isFalse(dataDomain.graph.hasNode(property.key))
+    assert.deepEqual(entity.fields, [])
+  })
+
+  test('throws an error if the property does not exist', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+    assert.throws(() => {
+      entity.removeProperty('non-existent-property')
+    }, "Trying to remove the non-existent-property property, but it doesn't exist")
+  })
+
+  test('throws an error when the property belongs to another entity', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const m1 = dataDomain.addModel()
+    const e1 = m1.addEntity()
+    const e2 = m1.addEntity()
+    const p1 = e1.addProperty()
+    assert.throws(() => {
+      e2.removeProperty(p1.key)
+    }, `Trying to remove the ${p1.key} property, but it doesn't belong to this entity`)
+  })
+
+  test('notifies change', async ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+    const property = entity.addProperty({ key: 'test-property', type: 'string' })
+    entity.removeProperty(property.key)
+    await assert.dispatches(dataDomain, 'change', { timeout: 20 })
+  })
+
+  test('removes the property from the fields array', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+    const property = entity.addProperty({ key: 'test-property', type: 'string' })
+    entity.removeProperty(property.key)
+    assert.deepEqual(entity.fields, [])
+  })
+
+  test('removes the property from the root graph', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+    const property = entity.addProperty({ key: 'test-property', type: 'string' })
+    entity.removeProperty(property.key)
+    assert.isFalse(dataDomain.graph.hasNode(property.key))
+  })
+
+  test('removes the graph edge', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+    const property = entity.addProperty({ key: 'test-property', type: 'string' })
+    entity.removeProperty(property.key)
+    assert.isFalse(dataDomain.graph.hasEdge(entity.key, property.key))
+  })
+
+  test('removes only the specified property', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+    const property1 = entity.addProperty({ key: 'test-property1', type: 'string' })
+    const property2 = entity.addProperty({ key: 'test-property2', type: 'string' })
+    entity.removeProperty(property1.key)
+    assert.isFalse(dataDomain.graph.hasNode(property1.key))
+    assert.isTrue(dataDomain.graph.hasNode(property2.key))
+    assert.deepEqual(entity.fields, [{ key: property2.key, type: 'property' }])
+  })
+
+  test('does not remove other entities or models', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity1 = model.addEntity()
+    const entity2 = model.addEntity()
+    const property = entity1.addProperty({ key: 'test-property', type: 'string' })
+    entity1.removeProperty(property.key)
+    assert.isTrue(dataDomain.graph.hasNode(entity2.key))
+    assert.isTrue(dataDomain.graph.hasNode(model.key))
+  })
+
+  test('does not remove other properties', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+    const property1 = entity.addProperty({ key: 'test-property1', type: 'string' })
+    const property2 = entity.addProperty({ key: 'test-property2', type: 'string' })
+    entity.removeProperty(property1.key)
+    assert.isFalse(dataDomain.graph.hasNode(property1.key))
+    assert.isTrue(dataDomain.graph.hasNode(property2.key))
+  })
+})
+
+test.group('DomainEntity.listProperties()', () => {
+  test('lists all properties in the entity', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+    const property1 = entity.addProperty({ key: 'test-property1', type: 'string' })
+    const property2 = entity.addProperty({ key: 'test-property2', type: 'number' })
+    const properties = [...entity.listProperties()]
+    assert.lengthOf(properties, 2)
+    assert.deepInclude(properties, property1)
+    assert.deepInclude(properties, property2)
+  })
+
+  test('returns an empty array if there are no properties', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+    const properties = [...entity.listProperties()]
+    assert.lengthOf(properties, 0)
+  })
+
+  test('returns only properties', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+    const property1 = entity.addProperty({ key: 'test-property1', type: 'string' })
+    entity.addAssociation()
+    const properties = [...entity.listProperties()]
+    assert.lengthOf(properties, 1)
+    assert.deepInclude(properties, property1)
+  })
+
+  test('properties in the list are of type DomainProperty', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+    entity.addProperty({ key: 'test-property1', type: 'string' })
+    const properties = [...entity.listProperties()]
+    assert.instanceOf(properties[0], DomainProperty)
+  })
+
+  test('lists properties in the order they were added', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+    const property1 = entity.addProperty({ key: 'test-property1', type: 'string' })
+    const property2 = entity.addProperty({ key: 'test-property2', type: 'number' })
+    const properties = [...entity.listProperties()]
+    assert.deepEqual(properties, [property1, property2])
+  })
+
+  test('lists properties when there are no properties', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+    const properties = [...entity.listProperties()]
+    assert.deepEqual(properties, [])
+  })
+
+  test('lists properties when there are other domain elements', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+    const property1 = entity.addProperty({ key: 'test-property1', type: 'string' })
+    entity.addAssociation()
+    const properties = [...entity.listProperties()]
+    assert.deepEqual(properties, [property1])
+  })
+
+  test('lists properties when fields array is empty', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+    entity.fields = []
+    const properties = [...entity.listProperties()]
+    assert.deepEqual(properties, [])
+  })
+
+  test('lists properties when fields array contains only associations', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+    const association = entity.addAssociation()
+    entity.fields = [{ key: association.key, type: 'association' }]
+    const properties = [...entity.listProperties()]
+    assert.deepEqual(properties, [])
+  })
+})
+
+test.group('DomainEntity.hasProperties()', () => {
+  test('returns true if there are child properties', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+    entity.addProperty({ key: 'test-property', type: 'string' })
+    assert.isTrue(entity.hasProperties())
+  })
+
+  test('returns false if there are no child properties', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+    assert.isFalse(entity.hasProperties())
+  })
+
+  test('returns false if there are only other domain elements', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+    entity.addAssociation()
+    assert.isFalse(entity.hasProperties())
+  })
+
+  test('returns true if there are both properties and other domain elements', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+    entity.addProperty({ key: 'test-property', type: 'string' })
+    entity.addAssociation()
+    assert.isTrue(entity.hasProperties())
+  })
+
+  test('returns false if the entity has no fields', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const entity = model.addEntity()
+    entity.fields = []
+    assert.isFalse(entity.hasProperties())
+  })
+})

package/tests/unit/modeling/{data_file.spec.ts → domain_file.spec.ts}

@@ -1,58 +1,58 @@
 import { test } from '@japa/runner'
-import { DataNamespace, DataFile, IDataFile, ThingKind, DataFileKind } from '../../../src/index.js'
+import { DomainFile, IDomainFile, ThingKind, DomainFileKind, DataDomain } from '../../../src/index.js'
 
 const organization = 'test-organization'
 
-test.group('DataFile.fromDataNamespace()', () => {
+test.group('DomainFile.fromDataDomain()', () => {
   test('sets the kind', ({ assert }) => {
-    const p1 = DataNamespace.fromName('p1')
-    const result = DataFile.fromDataNamespace(p1, organization)
-    assert.equal(result.kind, DataFileKind)
+    const p1 = new DataDomain({ info: { name: 'p1' } })
+    const result = DomainFile.fromDataDomain(p1, organization)
+    assert.equal(result.kind, DomainFileKind)
   })
 
   test('sets the organization', ({ assert }) => {
-    const p1 = DataNamespace.fromName('p1')
-    const result = DataFile.fromDataNamespace(p1, organization)
+    const p1 = new DataDomain({ info: { name: 'p1' } })
+    const result = DomainFile.fromDataDomain(p1, organization)
     assert.equal(result.organization, organization)
   })
 
   test('sets the name', ({ assert }) => {
-    const p1 = DataNamespace.fromName('p1')
-    const result = DataFile.fromDataNamespace(p1, organization)
+    const p1 = new DataDomain({ info: { name: 'p1' } })
+    const result = DomainFile.fromDataDomain(p1, organization)
     assert.equal(result.info.name, 'p1')
   })
 
   test('sets the key', ({ assert }) => {
-    const p1 = DataNamespace.fromName('p1')
-    const result = DataFile.fromDataNamespace(p1, organization)
+    const p1 = new DataDomain({ info: { name: 'p1' } })
+    const result = DomainFile.fromDataDomain(p1, organization)
     assert.equal(result.key, p1.key)
   })
 
   test('sets the configured owner', ({ assert }) => {
-    const p1 = DataNamespace.fromName('p1')
-    const result = DataFile.fromDataNamespace(p1, organization, 'other')
+    const p1 = new DataDomain({ info: { name: 'p1' } })
+    const result = DomainFile.fromDataDomain(p1, organization, 'other')
     assert.equal(result.owner, 'other')
   })
 
   test('respects schema instead of instance', ({ assert }) => {
-    const p1 = DataNamespace.fromName('p1')
-    const result = DataFile.fromDataNamespace(p1.toJSON(), organization)
+    const p1 = new DataDomain({ info: { name: 'p1' } })
+    const result = DomainFile.fromDataDomain(p1.toJSON(), organization)
     assert.equal(result.info.name, 'p1')
   })
 })
 
 test.group('constructor()', () => {
   test('creates a default data file', ({ assert }) => {
-    const result = new DataFile()
-    assert.equal(result.kind, DataFileKind)
+    const result = new DomainFile()
+    assert.equal(result.kind, DomainFileKind)
     assert.isUndefined(result.owner)
     assert.typeOf(result.key, 'string')
     assert.typeOf(result.lastModified, 'object')
   })
 
   test('creates a data file from the schema values', ({ assert }) => {
-    const schema: IDataFile = {
-      kind: DataFileKind,
+    const schema: IDomainFile = {
+      kind: DomainFileKind,
       organization,
       info: {
         kind: ThingKind,
@@ -77,8 +77,8 @@ test.group('constructor()', () => {
       lastModified: { byMe: false, time: 0, user: 'id', name: 'test' },
       labels: ['l1'],
     }
-    const result = new DataFile(schema)
-    assert.equal(result.kind, DataFileKind)
+    const result = new DomainFile(schema)
+    assert.equal(result.kind, DomainFileKind)
     assert.equal(result.organization, organization)
     assert.equal(result.info.name, 'hello')
     assert.equal(result.owner, 'me')
@@ -91,8 +91,8 @@ test.group('constructor()', () => {
   })
 
   test('creates a data file from the JSON schema string', ({ assert }) => {
-    const schema: IDataFile = {
-      kind: DataFileKind,
+    const schema: IDomainFile = {
+      kind: DomainFileKind,
       organization,
       info: {
         kind: ThingKind,
@@ -116,8 +116,8 @@ test.group('constructor()', () => {
       ],
       lastModified: { byMe: false, time: 0, user: 'id', name: 'test' },
     }
-    const result = new DataFile(JSON.stringify(schema))
-    assert.equal(result.kind, DataFileKind)
+    const result = new DomainFile(JSON.stringify(schema))
+    assert.equal(result.kind, DomainFileKind)
     assert.equal(result.organization, organization)
     assert.equal(result.info.name, 'hello')
     assert.equal(result.owner, 'me')
@@ -127,7 +127,7 @@ test.group('constructor()', () => {
 
   test('throws when invalid schema', ({ assert }) => {
     assert.throws(() => {
-      new DataFile(
+      new DomainFile(
         JSON.stringify({
           name: 'a name',
         })
@@ -138,72 +138,16 @@ test.group('constructor()', () => {
 
 test.group('toJSON()', () => {
   test('serializes the kind', ({ assert }) => {
-    const file = new DataFile()
+    const file = new DomainFile()
     const result = file.toJSON()
-    assert.equal(result.kind, DataFileKind)
+    assert.equal(result.kind, DomainFileKind)
   })
 
   test('serializes the key', ({ assert }) => {
-    const file = new DataFile()
+    const file = new DomainFile()
     const result = file.toJSON()
     assert.equal(result.key, file.key)
   })
 
   // the "key" test tests whether the parent toJSON() is called.
 })
-
-test.group('DataFile.fromName()', () => {
-  test('sets the kind', ({ assert }) => {
-    const result = DataFile.fromName('name', organization)
-    assert.equal(result.kind, DataFileKind)
-  })
-
-  test('sets the organization', ({ assert }) => {
-    const result = DataFile.fromName('name', organization)
-    assert.equal(result.organization, organization)
-  })
-
-  test('sets the name', ({ assert }) => {
-    const result = DataFile.fromName('name', organization)
-    assert.equal(result.info.name, 'name')
-  })
-
-  test('sets the key', ({ assert }) => {
-    const result = DataFile.fromName('name', organization)
-    assert.typeOf(result.key, 'string')
-    assert.notEqual(result.key, '')
-  })
-
-  test('sets the owner', ({ assert }) => {
-    const result = DataFile.fromName('name', organization, 'other')
-    assert.equal(result.owner, 'other')
-  })
-})
-
-test.group('DataFile.fromName()', () => {
-  test('sets the kind', ({ assert }) => {
-    const result = DataFile.fromName('name', organization)
-    assert.equal(result.kind, DataFileKind)
-  })
-
-  test('sets the organization', ({ assert }) => {
-    const result = DataFile.fromName('name', organization)
-    assert.equal(result.organization, organization)
-  })
-
-  test('sets the name', ({ assert }) => {
-    const result = DataFile.fromName('name', organization)
-    assert.equal(result.info.name, 'name')
-  })
-
-  test('sets the key', ({ assert }) => {
-    const result = DataFile.fromName('name', organization)
-    assert.typeOf(result.key, 'string')
-    assert.notEqual(result.key, '')
-  })
-
-  test('sets the owner', ({ assert }) => {
-    const result = DataFile.fromName('name', organization, 'other')
-    assert.equal(result.owner, 'other')
-  })
-})