@api-client/core 0.14.0 → 0.14.1

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

@@ -1,6 +1,7 @@
 import { test } from '@japa/runner'
 import { DataDomain } from '../../../src/modeling/DataDomain.js'
 import { DomainEntity } from '../../../src/modeling/DomainEntity.js'
+import { SemanticType } from '../../../src/modeling/Semantics.js'
 
 test.group('DataDomain.addEntity()', () => {
   test('addEntity adds an entity to the graph', ({ assert }) => {
@@ -70,7 +71,7 @@ test.group('DataDomain.addEntity()', () => {
     assert.throws(() => {
       // @ts-expect-error For testing purposes, we are passing undefined
       dataDomain.addEntity(undefined, { key: 'test-entity' })
-    }, `An entity expects a DataModel parent`)
+    }, `An entity expects a DomainModel parent`)
   })
 
   test('addEntity throws when adding the same entity twice', ({ assert }) => {
@@ -328,6 +329,133 @@ test.group('DataDomain.findEntity()', () => {
   })
 })
 
+test.group('DomainEntity.addSemantic()', () => {
+  test('adds a new semantic to the entity', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel({ key: 'test-model' })
+    const entity = dataDomain.addEntity(model.key, { key: 'test-entity' })
+    const semantic = { id: SemanticType.User }
+    entity.addSemantic(semantic)
+    assert.deepInclude(entity.semantics, semantic)
+  })
+
+  test('updates an existing semantic', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel({ key: 'test-model' })
+    const entity = dataDomain.addEntity(model.key, { key: 'test-entity' })
+    const semantic1 = { id: SemanticType.User, config: { value: 'old' } }
+    const semantic2 = { id: SemanticType.User, config: { value: 'new' } }
+    entity.addSemantic(semantic1)
+    entity.addSemantic(semantic2)
+    assert.lengthOf(entity.semantics, 1)
+    assert.deepInclude(entity.semantics, semantic2)
+  })
+
+  test('throws an error if the semantic is not an entity semantic', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel({ key: 'test-model' })
+    const entity = dataDomain.addEntity(model.key, { key: 'test-entity' })
+    const semantic = { id: SemanticType.CreatedTimestamp } // CreatedTimestamp is a Property semantic
+    assert.throws(() => {
+      entity.addSemantic(semantic)
+    }, `Invalid semantic type: ${SemanticType.CreatedTimestamp}. Expected an entity semantic.`)
+  })
+
+  test('notifies change when adding a new semantic', async ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel({ key: 'test-model' })
+    const entity = dataDomain.addEntity(model.key, { key: 'test-entity' })
+    const semantic = { id: SemanticType.User }
+    entity.addSemantic(semantic)
+    await assert.dispatches(dataDomain, 'change', { timeout: 20 })
+  })
+
+  test('notifies change when updating an existing semantic', async ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel({ key: 'test-model' })
+    const entity = dataDomain.addEntity(model.key, { key: 'test-entity' })
+    const semantic1 = { id: SemanticType.User, config: { value: 'old' } }
+    const semantic2 = { id: SemanticType.User, config: { value: 'new' } }
+    entity.addSemantic(semantic1)
+    // Clear the event queue before the second add
+    await new Promise((resolve) => setTimeout(resolve, 0))
+    entity.addSemantic(semantic2)
+    await assert.dispatches(dataDomain, 'change', { timeout: 20 })
+  })
+})
+
+test.group('DomainEntity.removeSemantic()', () => {
+  test('removes an existing semantic from the entity', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel({ key: 'test-model' })
+    const entity = dataDomain.addEntity(model.key, { key: 'test-entity' })
+    const semantic = { id: SemanticType.User }
+    entity.addSemantic(semantic)
+    assert.deepInclude(entity.semantics, semantic)
+    entity.removeSemantic(SemanticType.User)
+    assert.notDeepInclude(entity.semantics, semantic)
+    assert.lengthOf(entity.semantics, 0)
+  })
+
+  test('does nothing if the semantic to remove does not exist', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel({ key: 'test-model' })
+    const entity = dataDomain.addEntity(model.key, { key: 'test-entity' })
+    const semantic = { id: SemanticType.User }
+    entity.addSemantic(semantic)
+    const initialSemantics = [...entity.semantics]
+    entity.removeSemantic('non-existent-semantic-id' as SemanticType)
+    assert.deepEqual(entity.semantics, initialSemantics)
+  })
+
+  test('notifies change when a semantic is removed', async ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel({ key: 'test-model' })
+    const entity = dataDomain.addEntity(model.key, { key: 'test-entity' })
+    const semantic = { id: SemanticType.User }
+    entity.addSemantic(semantic)
+    // Clear the event queue before removal
+    await new Promise((resolve) => setTimeout(resolve, 0))
+    entity.removeSemantic(SemanticType.User)
+    await assert.dispatches(dataDomain, 'change', { timeout: 20 })
+  })
+
+  test('does not notify change if the semantic to remove does not exist', async ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel({ key: 'test-model' })
+    const entity = dataDomain.addEntity(model.key, { key: 'test-entity' })
+    // Clear the event queue before removal
+    await new Promise((resolve) => setTimeout(resolve, 0))
+    entity.removeSemantic('non-existent-semantic-id' as SemanticType)
+    await assert.notDispatches(dataDomain, 'change', { timeout: 20 })
+  })
+})
+
+test.group('DomainEntity.hasSemantic()', () => {
+  test('returns true if the entity has the specified semantic', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel({ key: 'test-model' })
+    const entity = dataDomain.addEntity(model.key, { key: 'test-entity' })
+    const semantic = { id: SemanticType.User }
+    entity.addSemantic(semantic)
+    assert.isTrue(entity.hasSemantic(SemanticType.User))
+  })
+
+  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))
+  })
+
+  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))
+  })
+})
+
 test.group('DataDomain.moveEntity()', () => {
   test('moves an entity from one model to another', ({ assert }) => {
     const dataDomain = new DataDomain()

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

@@ -67,7 +67,7 @@ test.group('DataDomain.addProperty()', () => {
     assert.throws(() => {
       // @ts-expect-error For testing purposes, we are passing undefined
       dataDomain.addProperty(undefined)
-    }, 'A property expects a DataEntity parent')
+    }, 'A property expects a DomainEntity parent')
   })
 
   test('addProperty throws when adding property to a foreign entity', ({ assert }) => {

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

@@ -7,6 +7,7 @@ import {
   AssociationBinding,
   DataDomain,
   DataFormat,
+  SemanticType,
 } from '../../../src/index.js'
 
 test.group('DomainAssociation.createSchema()', () => {
@@ -21,6 +22,7 @@ test.group('DomainAssociation.createSchema()', () => {
     assert.isUndefined(schema.required)
     assert.isUndefined(schema.bindings)
     assert.isUndefined(schema.targets)
+    assert.deepEqual(schema.semantics, [])
   })
 
   test('creates a schema with provided key', ({ assert }) => {
@@ -35,6 +37,12 @@ test.group('DomainAssociation.createSchema()', () => {
     assert.deepEqual(schema.info, Thing.fromJSON(info).toJSON())
   })
 
+  test('creates a schema with provided semantics', ({ assert }) => {
+    const semantics = [{ id: SemanticType.ResourceOwnerIdentifier }]
+    const schema = DomainAssociation.createSchema({ semantics })
+    assert.deepEqual(schema.semantics, semantics)
+  })
+
   test('creates a schema with provided schema', ({ assert }) => {
     const schemaDefinition: AmfShapes.IApiAssociationShape = { linked: false }
     const schema = DomainAssociation.createSchema({ schema: schemaDefinition })
@@ -71,6 +79,7 @@ test.group('DomainAssociation.createSchema()', () => {
     const required = true
     const bindings: AssociationBinding[] = [{ type: 'web', schema: { hidden: false } }]
     const targets = [{ key: 'target1', domain: 'domain1' }, { key: 'target2' }]
+    const semantics = [{ id: SemanticType.ResourceOwnerIdentifier }]
 
     const schema = DomainAssociation.createSchema({
       key,
@@ -80,6 +89,7 @@ test.group('DomainAssociation.createSchema()', () => {
       required,
       bindings,
       targets,
+      semantics,
     })
 
     assert.equal(schema.key, key)
@@ -89,6 +99,7 @@ test.group('DomainAssociation.createSchema()', () => {
     assert.equal(schema.required, required)
     assert.deepEqual(schema.bindings, bindings)
     assert.deepEqual(schema.targets, targets)
+    assert.deepEqual(schema.semantics, semantics)
   })
 
   test('creates a schema with cloned bindings', ({ assert }) => {
@@ -98,6 +109,13 @@ test.group('DomainAssociation.createSchema()', () => {
     assert.notStrictEqual(schema.bindings, bindings)
   })
 
+  test('creates a schema with cloned semantics', ({ assert }) => {
+    const semantics = [{ id: SemanticType.ResourceOwnerIdentifier }]
+    const schema = DomainAssociation.createSchema({ semantics })
+    assert.deepEqual(schema.semantics, semantics)
+    assert.notStrictEqual(schema.semantics, semantics)
+  })
+
   test('creates a schema with cloned targets', ({ assert }) => {
     const targets = [{ key: 'target1', domain: 'domain1' }, { key: 'target2' }]
     const schema = DomainAssociation.createSchema({ targets })
@@ -126,6 +144,7 @@ test.group('DomainAssociation.constructor()', () => {
     assert.isUndefined(association.required)
     assert.deepEqual(association.bindings, [])
     assert.deepEqual(association.targets, [])
+    assert.deepEqual(association.semantics, [])
   })
 
   test('creates an instance with provided key', ({ assert }) => {
@@ -136,6 +155,14 @@ test.group('DomainAssociation.constructor()', () => {
     assert.equal(association.key, key)
   })
 
+  test('creates an instance with provided semantics', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const parentKey = 'test-parent'
+    const semantics = [{ id: SemanticType.ResourceOwnerIdentifier }]
+    const association = new DomainAssociation(dataDomain, parentKey, { semantics })
+    assert.deepEqual(association.semantics, semantics)
+  })
+
   test('creates an instance with provided info', ({ assert }) => {
     const dataDomain = new DataDomain()
     const parentKey = 'test-parent'
@@ -192,6 +219,7 @@ test.group('DomainAssociation.constructor()', () => {
     const required = true
     const bindings: AssociationBinding[] = [{ type: 'web', schema: { hidden: false } }]
     const targets = [{ key: 'target1', domain: 'domain1' }, { key: 'target2' }]
+    const semantics = [{ id: SemanticType.ResourceOwnerIdentifier }]
 
     const association = new DomainAssociation(dataDomain, parentKey, {
       key,
@@ -201,6 +229,7 @@ test.group('DomainAssociation.constructor()', () => {
       required,
       bindings,
       targets,
+      semantics,
     })
 
     assert.equal(association.key, key)
@@ -210,6 +239,7 @@ test.group('DomainAssociation.constructor()', () => {
     assert.equal(association.required, required)
     assert.deepEqual(association.bindings, bindings)
     assert.deepEqual(association.targets, targets)
+    assert.deepEqual(association.semantics, semantics)
   })
 
   test('creates an instance with cloned bindings', ({ assert }) => {
@@ -221,6 +251,15 @@ test.group('DomainAssociation.constructor()', () => {
     assert.notStrictEqual(association.bindings, bindings)
   })
 
+  test('creates an instance with cloned semantics', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const parentKey = 'test-parent'
+    const semantics = [{ id: SemanticType.ResourceOwnerIdentifier }]
+    const association = new DomainAssociation(dataDomain, parentKey, { semantics })
+    assert.deepEqual(association.semantics, semantics)
+    assert.notStrictEqual(association.semantics, semantics)
+  })
+
   test('creates an instance with cloned targets', ({ assert }) => {
     const dataDomain = new DataDomain()
     const parentKey = 'test-parent'
@@ -254,6 +293,7 @@ test.group('DomainAssociation.toJSON()', () => {
     assert.isUndefined(json.required)
     assert.isUndefined(json.bindings)
     assert.isUndefined(json.targets)
+    assert.isUndefined(json.semantics)
   })
 
   test('returns a JSON representation with provided key', ({ assert }) => {
@@ -265,6 +305,15 @@ test.group('DomainAssociation.toJSON()', () => {
     assert.equal(json.key, key)
   })
 
+  test('returns a JSON representation with provided semantics', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const parentKey = 'test-parent'
+    const semantics = [{ id: SemanticType.ResourceOwnerIdentifier }]
+    const association = new DomainAssociation(dataDomain, parentKey, { semantics })
+    const json = association.toJSON()
+    assert.deepEqual(json.semantics, semantics)
+  })
+
   test('returns a JSON representation with provided info', ({ assert }) => {
     const dataDomain = new DataDomain()
     const parentKey = 'test-parent'
@@ -330,6 +379,7 @@ test.group('DomainAssociation.toJSON()', () => {
     const required = true
     const bindings: AssociationBinding[] = [{ type: 'web', schema: { hidden: false } }]
     const targets = [{ key: 'target1', domain: 'domain1' }, { key: 'target2' }]
+    const semantics = [{ id: SemanticType.ResourceOwnerIdentifier }]
 
     const association = new DomainAssociation(dataDomain, parentKey, {
       key,
@@ -339,6 +389,7 @@ test.group('DomainAssociation.toJSON()', () => {
       required,
       bindings,
       targets,
+      semantics,
     })
 
     const json = association.toJSON()
@@ -350,6 +401,7 @@ test.group('DomainAssociation.toJSON()', () => {
     assert.equal(json.required, required)
     assert.deepEqual(json.bindings, bindings)
     assert.deepEqual(json.targets, targets)
+    assert.deepEqual(json.semantics, semantics)
   })
 
   test('returns a JSON representation with cloned bindings', ({ assert }) => {
@@ -362,6 +414,16 @@ test.group('DomainAssociation.toJSON()', () => {
     assert.notStrictEqual(json.bindings, bindings)
   })
 
+  test('returns a JSON representation with cloned semantics when it is set after creation', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const parentKey = 'test-parent'
+    const association = new DomainAssociation(dataDomain, parentKey)
+    const semantics = [{ id: SemanticType.ResourceOwnerIdentifier }]
+    association.semantics = semantics
+    const json = association.toJSON()
+    assert.deepEqual(json.semantics, semantics)
+  })
+
   test('returns a JSON representation with cloned targets', ({ assert }) => {
     const dataDomain = new DataDomain()
     const parentKey = 'test-parent'
@@ -641,3 +703,118 @@ test.group('DomainAssociation.readBinding()', () => {
     assert.isUndefined(webBindings)
   })
 })
+
+test.group('DomainAssociation.addSemantic()', () => {
+  test('adds a new semantic to the association', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const association = new DomainAssociation(dataDomain, 'test-parent')
+    const semantic = { id: SemanticType.ResourceOwnerIdentifier }
+    association.addSemantic(semantic)
+    assert.deepInclude(association.semantics, semantic)
+  })
+
+  test('updates an existing semantic', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const association = new DomainAssociation(dataDomain, 'test-parent')
+    const semantic1 = { id: SemanticType.ResourceOwnerIdentifier, config: { value: 'old' } }
+    const semantic2 = { id: SemanticType.ResourceOwnerIdentifier, config: { value: 'new' } }
+    association.addSemantic(semantic1)
+    association.addSemantic(semantic2)
+    assert.lengthOf(association.semantics, 1)
+    assert.deepInclude(association.semantics, semantic2)
+  })
+
+  test('throws an error if the semantic is not an association semantic', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const association = new DomainAssociation(dataDomain, 'test-parent')
+    const semantic = { id: SemanticType.User } // User is an Entity semantic
+    assert.throws(() => {
+      association.addSemantic(semantic)
+    }, `Invalid semantic type: ${SemanticType.User}. Expected an association semantic.`)
+  })
+
+  test('notifies change when adding a new semantic', async ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const association = new DomainAssociation(dataDomain, 'test-parent')
+    const semantic = { id: SemanticType.ResourceOwnerIdentifier }
+    association.addSemantic(semantic)
+    await assert.dispatches(dataDomain, 'change', { timeout: 20 })
+  })
+
+  test('notifies change when updating an existing semantic', async ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const association = new DomainAssociation(dataDomain, 'test-parent')
+    const semantic1 = { id: SemanticType.ResourceOwnerIdentifier, config: { value: 'old' } }
+    const semantic2 = { id: SemanticType.ResourceOwnerIdentifier, config: { value: 'new' } }
+    association.addSemantic(semantic1)
+    // Clear the event queue before the second add
+    await new Promise((resolve) => setTimeout(resolve, 0))
+    association.addSemantic(semantic2)
+    await assert.dispatches(dataDomain, 'change', { timeout: 20 })
+  })
+})
+
+test.group('DomainAssociation.removeSemantic()', () => {
+  test('removes an existing semantic from the association', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const association = new DomainAssociation(dataDomain, 'test-parent')
+    const semantic = { id: SemanticType.ResourceOwnerIdentifier }
+    association.addSemantic(semantic)
+    assert.deepInclude(association.semantics, semantic)
+    association.removeSemantic(SemanticType.ResourceOwnerIdentifier)
+    assert.notDeepInclude(association.semantics, semantic)
+    assert.lengthOf(association.semantics, 0)
+  })
+
+  test('does nothing if the semantic to remove does not exist', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const association = new DomainAssociation(dataDomain, 'test-parent')
+    const semantic = { id: SemanticType.ResourceOwnerIdentifier }
+    association.addSemantic(semantic)
+    const initialSemantics = [...association.semantics]
+    association.removeSemantic('non-existent-semantic-id' as SemanticType)
+    assert.deepEqual(association.semantics, initialSemantics)
+  })
+
+  test('notifies change when a semantic is removed', async ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const association = new DomainAssociation(dataDomain, 'test-parent')
+    const semantic = { id: SemanticType.ResourceOwnerIdentifier }
+    association.addSemantic(semantic)
+    // Clear the event queue before removal
+    await new Promise((resolve) => setTimeout(resolve, 0))
+    association.removeSemantic(SemanticType.ResourceOwnerIdentifier)
+    await assert.dispatches(dataDomain, 'change', { timeout: 20 })
+  })
+
+  test('does not notify change if the semantic to remove does not exist', async ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const association = new DomainAssociation(dataDomain, 'test-parent')
+    // Clear the event queue before removal
+    await new Promise((resolve) => setTimeout(resolve, 0))
+    association.removeSemantic('non-existent-semantic-id' as SemanticType)
+    await assert.notDispatches(dataDomain, 'change', { timeout: 20 })
+  })
+})
+
+test.group('DomainAssociation.hasSemantic()', () => {
+  test('returns true if the association has the specified semantic', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const association = new DomainAssociation(dataDomain, 'test-parent')
+    const semantic = { id: SemanticType.ResourceOwnerIdentifier }
+    association.addSemantic(semantic)
+    assert.isTrue(association.hasSemantic(SemanticType.ResourceOwnerIdentifier))
+  })
+
+  test('returns false if the association does not have the specified semantic', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const association = new DomainAssociation(dataDomain, 'test-parent')
+    assert.isFalse(association.hasSemantic(SemanticType.ResourceOwnerIdentifier))
+  })
+
+  test('returns false for an empty semantics array', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const association = new DomainAssociation(dataDomain, 'test-parent')
+    assert.isFalse(association.hasSemantic(SemanticType.ResourceOwnerIdentifier))
+  })
+})

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

@@ -9,6 +9,7 @@ import {
   Thing,
 } from '../../../src/index.js'
 import type { EntityOrderedItem } from '../../../src/modeling/DomainEntity.js'
+import { SemanticType } from '../../../src/modeling/Semantics.js'
 
 test.group('DomainEntity.createSchema()', () => {
   test('creates a schema with default values', ({ assert }) => {
@@ -18,7 +19,7 @@ test.group('DomainEntity.createSchema()', () => {
     assert.isNotEmpty(schema.key)
     assert.deepInclude(schema.info, { name: 'New entity' })
     assert.isUndefined(schema.tags)
-    assert.isUndefined(schema.taxonomy)
+    assert.isUndefined(schema.semantics)
     assert.isUndefined(schema.fields)
     assert.isUndefined(schema.deprecated)
   })
@@ -28,7 +29,7 @@ test.group('DomainEntity.createSchema()', () => {
       key: 'test-entity',
       info: { name: 'Test Entity', description: 'A test entity' },
       tags: ['tag1', 'tag2'],
-      taxonomy: ['tax1', 'tax2'],
+      semantics: [{ id: SemanticType.User }],
       fields: [{ key: 'test-property', type: 'property' }],
       deprecated: true,
     })
@@ -36,7 +37,7 @@ test.group('DomainEntity.createSchema()', () => {
     assert.equal(schema.key, 'test-entity')
     assert.deepInclude(schema.info, { name: 'Test Entity', description: 'A test entity' })
     assert.deepEqual(schema.tags, ['tag1', 'tag2'])
-    assert.deepEqual(schema.taxonomy, ['tax1', 'tax2'])
+    assert.deepEqual(schema.semantics, [{ id: SemanticType.User }])
     assert.deepEqual(schema.fields, [{ key: 'test-property', type: 'property' }])
     assert.isTrue(schema.deprecated)
   })
@@ -72,15 +73,15 @@ test.group('DomainEntity.createSchema()', () => {
     assert.deepEqual(schema.tags, ['tag1', 'tag2'])
   })
 
-  test('creates a schema with taxonomy', ({ assert }) => {
+  test('creates a schema with semantics', ({ assert }) => {
     const schema = DomainEntity.createSchema({
-      taxonomy: ['tax1', 'tax2'],
+      semantics: [{ id: SemanticType.User }],
     })
     assert.equal(schema.kind, DomainEntityKind)
     assert.typeOf(schema.key, 'string')
     assert.isNotEmpty(schema.key)
     assert.deepInclude(schema.info, { name: 'New entity' })
-    assert.deepEqual(schema.taxonomy, ['tax1', 'tax2'])
+    assert.deepEqual(schema.semantics, [{ id: SemanticType.User }])
   })
 
   test('creates a schema with fields', ({ assert }) => {
@@ -134,10 +135,10 @@ test.group('DomainEntity.createSchema()', () => {
     assert.deepEqual(schema.tags, customTags)
   })
 
-  test('creates a schema with custom taxonomy', ({ assert }) => {
-    const customTaxonomy = ['custom-tax1', 'custom-tax2']
-    const schema = DomainEntity.createSchema({ taxonomy: customTaxonomy })
-    assert.deepEqual(schema.taxonomy, customTaxonomy)
+  test('creates a schema with custom semantics', ({ assert }) => {
+    const customSemantics = [{ id: SemanticType.User }]
+    const schema = DomainEntity.createSchema({ semantics: customSemantics })
+    assert.deepEqual(schema.semantics, customSemantics)
   })
 
   test('creates a schema with custom fields', ({ assert }) => {
@@ -165,7 +166,7 @@ test.group('DomainEntity.constructor()', () => {
     assert.instanceOf(entity.info, Thing)
     assert.equal(entity.info.name, 'New entity')
     assert.deepEqual(entity.tags, [])
-    assert.deepEqual(entity.taxonomy, [])
+    assert.deepEqual(entity.semantics, [])
     assert.deepEqual(entity.fields, [])
     assert.isUndefined(entity.deprecated)
   })
@@ -176,7 +177,7 @@ test.group('DomainEntity.constructor()', () => {
       key: 'test-entity',
       info: { name: 'Test Entity', description: 'A test entity' },
       tags: ['tag1', 'tag2'],
-      taxonomy: ['tax1', 'tax2'],
+      semantics: [{ id: SemanticType.User }],
       fields: [{ key: 'test-property', type: 'property' }],
       deprecated: true,
     })
@@ -186,7 +187,7 @@ test.group('DomainEntity.constructor()', () => {
     assert.equal(entity.info.name, 'Test Entity')
     assert.equal(entity.info.description, 'A test entity')
     assert.deepEqual(entity.tags, ['tag1', 'tag2'])
-    assert.deepEqual(entity.taxonomy, ['tax1', 'tax2'])
+    assert.deepEqual(entity.semantics, [{ id: SemanticType.User }])
     assert.deepEqual(entity.fields, [{ key: 'test-property', type: 'property' }])
     assert.isTrue(entity.deprecated)
   })
@@ -228,17 +229,17 @@ test.group('DomainEntity.constructor()', () => {
     assert.deepEqual(entity.tags, ['tag1', 'tag2'])
   })
 
-  test('creates a new DomainEntity with taxonomy', ({ assert }) => {
+  test('creates a new DomainEntity with semantics', ({ assert }) => {
     const dataDomain = new DataDomain()
     const entity = new DomainEntity(dataDomain, {
-      taxonomy: ['tax1', 'tax2'],
+      semantics: [{ id: SemanticType.User }],
     })
     assert.equal(entity.kind, DomainEntityKind)
     assert.typeOf(entity.key, 'string')
     assert.isNotEmpty(entity.key)
     assert.instanceOf(entity.info, Thing)
     assert.equal(entity.info.name, 'New entity')
-    assert.deepEqual(entity.taxonomy, ['tax1', 'tax2'])
+    assert.deepEqual(entity.semantics, [{ id: SemanticType.User }])
   })
 
   test('creates a new DomainEntity with fields', ({ assert }) => {
@@ -300,11 +301,11 @@ test.group('DomainEntity.constructor()', () => {
     assert.deepEqual(entity.tags, customTags)
   })
 
-  test('creates a new DomainEntity with custom taxonomy', ({ assert }) => {
+  test('creates a new DomainEntity with custom semantics', ({ assert }) => {
     const dataDomain = new DataDomain()
-    const customTaxonomy = ['custom-tax1', 'custom-tax2']
-    const entity = new DomainEntity(dataDomain, { taxonomy: customTaxonomy })
-    assert.deepEqual(entity.taxonomy, customTaxonomy)
+    const customSemantics = [{ id: SemanticType.User }]
+    const entity = new DomainEntity(dataDomain, { semantics: customSemantics })
+    assert.deepEqual(entity.semantics, customSemantics)
   })
 
   test('creates a new DomainEntity with custom fields', ({ assert }) => {
@@ -351,7 +352,7 @@ test.group('DomainEntity.toJSON()', () => {
     assert.equal(json.key, entity.key)
     assert.deepInclude(json.info, { name: 'New entity' })
     assert.isUndefined(json.tags)
-    assert.isUndefined(json.taxonomy)
+    assert.isUndefined(json.semantics)
     assert.isUndefined(json.fields)
     assert.isUndefined(json.deprecated)
   })
@@ -362,7 +363,7 @@ test.group('DomainEntity.toJSON()', () => {
       key: 'test-entity',
       info: { name: 'Test Entity', description: 'A test entity' },
       tags: ['tag1', 'tag2'],
-      taxonomy: ['tax1', 'tax2'],
+      semantics: [{ id: SemanticType.User }],
       fields: [{ key: 'test-property', type: 'property' }],
       deprecated: true,
     })
@@ -371,7 +372,7 @@ test.group('DomainEntity.toJSON()', () => {
     assert.equal(json.key, 'test-entity')
     assert.deepInclude(json.info, { name: 'Test Entity', description: 'A test entity' })
     assert.deepEqual(json.tags, ['tag1', 'tag2'])
-    assert.deepEqual(json.taxonomy, ['tax1', 'tax2'])
+    assert.deepEqual(json.semantics, [{ id: SemanticType.User }])
     assert.deepEqual(json.fields, [{ key: 'test-property', type: 'property' }])
     assert.isTrue(json.deprecated)
   })
@@ -455,15 +456,15 @@ test.group('DomainEntity.toJSON()', () => {
     assert.deepEqual(json.tags, ['tag1', 'tag2'])
   })
 
-  test('serializes the "taxonomy" property', ({ assert }) => {
+  test('serializes the "semantics" property', ({ assert }) => {
     const dataDomain = new DataDomain()
     const model = dataDomain.addModel()
     const entity = model.addEntity({
       key: 'test-entity',
-      taxonomy: ['tax1', 'tax2'],
+      semantics: [{ id: SemanticType.User }],
     })
     const json = entity.toJSON()
-    assert.deepEqual(json.taxonomy, ['tax1', 'tax2'])
+    assert.deepEqual(json.semantics, [{ id: SemanticType.User }])
   })
 })