@api-client/core 0.14.0 → 0.14.2

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

@@ -7,6 +7,8 @@ import {
   AssociationBinding,
   DataDomain,
   DataFormat,
+  SemanticType,
+  type OnDeleteRule,
 } from '../../../src/index.js'
 
 test.group('DomainAssociation.createSchema()', () => {
@@ -21,6 +23,9 @@ test.group('DomainAssociation.createSchema()', () => {
     assert.isUndefined(schema.required)
     assert.isUndefined(schema.bindings)
     assert.isUndefined(schema.targets)
+    assert.deepEqual(schema.semantics, [])
+    assert.isUndefined(schema.onDelete)
+    assert.isUndefined(schema.readOnly)
   })
 
   test('creates a schema with provided key', ({ assert }) => {
@@ -35,6 +40,23 @@ 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 onDelete rule', ({ assert }) => {
+    const onDelete: OnDeleteRule = 'cascade'
+    const schema = DomainAssociation.createSchema({ onDelete })
+    assert.equal(schema.onDelete, onDelete)
+  })
+
+  test('creates a schema with provided readOnly rule', ({ assert }) => {
+    const schema = DomainAssociation.createSchema({ readOnly: true })
+    assert.isTrue(schema.readOnly)
+  })
+
   test('creates a schema with provided schema', ({ assert }) => {
     const schemaDefinition: AmfShapes.IApiAssociationShape = { linked: false }
     const schema = DomainAssociation.createSchema({ schema: schemaDefinition })
@@ -71,6 +93,9 @@ 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 readOnly = true
+    const onDelete: OnDeleteRule = 'restrict'
 
     const schema = DomainAssociation.createSchema({
       key,
@@ -80,6 +105,9 @@ test.group('DomainAssociation.createSchema()', () => {
       required,
       bindings,
       targets,
+      semantics,
+      onDelete,
+      readOnly,
     })
 
     assert.equal(schema.key, key)
@@ -89,6 +117,9 @@ test.group('DomainAssociation.createSchema()', () => {
     assert.equal(schema.required, required)
     assert.deepEqual(schema.bindings, bindings)
     assert.deepEqual(schema.targets, targets)
+    assert.deepEqual(schema.semantics, semantics)
+    assert.equal(schema.onDelete, onDelete)
+    assert.isTrue(schema.readOnly)
   })
 
   test('creates a schema with cloned bindings', ({ assert }) => {
@@ -98,6 +129,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 +164,9 @@ test.group('DomainAssociation.constructor()', () => {
     assert.isUndefined(association.required)
     assert.deepEqual(association.bindings, [])
     assert.deepEqual(association.targets, [])
+    assert.deepEqual(association.semantics, [])
+    assert.isUndefined(association.onDelete)
+    assert.isUndefined(association.readOnly)
   })
 
   test('creates an instance with provided key', ({ assert }) => {
@@ -136,6 +177,30 @@ 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 onDelete rule', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const parentKey = 'test-parent'
+    const onDelete: OnDeleteRule = 'setNull'
+    const association = new DomainAssociation(dataDomain, parentKey, { onDelete })
+    assert.equal(association.onDelete, onDelete)
+  })
+
+  test('creates an instance with provided readOnly rule', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const parentKey = 'test-parent'
+    const readOnly = true
+    const association = new DomainAssociation(dataDomain, parentKey, { readOnly })
+    assert.isTrue(association.readOnly)
+  })
+
   test('creates an instance with provided info', ({ assert }) => {
     const dataDomain = new DataDomain()
     const parentKey = 'test-parent'
@@ -192,6 +257,9 @@ 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 readOnly = false
+    const onDelete: OnDeleteRule = 'cascade'
 
     const association = new DomainAssociation(dataDomain, parentKey, {
       key,
@@ -201,6 +269,9 @@ test.group('DomainAssociation.constructor()', () => {
       required,
       bindings,
       targets,
+      semantics,
+      onDelete,
+      readOnly,
     })
 
     assert.equal(association.key, key)
@@ -210,6 +281,9 @@ test.group('DomainAssociation.constructor()', () => {
     assert.equal(association.required, required)
     assert.deepEqual(association.bindings, bindings)
     assert.deepEqual(association.targets, targets)
+    assert.deepEqual(association.semantics, semantics)
+    assert.equal(association.onDelete, onDelete)
+    assert.isFalse(association.readOnly)
   })
 
   test('creates an instance with cloned bindings', ({ assert }) => {
@@ -221,6 +295,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 +337,9 @@ test.group('DomainAssociation.toJSON()', () => {
     assert.isUndefined(json.required)
     assert.isUndefined(json.bindings)
     assert.isUndefined(json.targets)
+    assert.isUndefined(json.semantics)
+    assert.isUndefined(json.onDelete)
+    assert.isUndefined(json.readOnly)
   })
 
   test('returns a JSON representation with provided key', ({ assert }) => {
@@ -265,6 +351,33 @@ 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, 'Semantics are serialized')
+  })
+
+  test('returns a JSON representation with provided onDelete rule', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const parentKey = 'test-parent'
+    const onDelete: OnDeleteRule = 'cascade'
+    const association = new DomainAssociation(dataDomain, parentKey, { onDelete })
+    const json = association.toJSON()
+    assert.equal(json.onDelete, onDelete, 'onDelete is serialized')
+  })
+
+  test('returns a JSON representation with provided readOnly rule', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const parentKey = 'test-parent'
+    const readOnly = true
+    const association = new DomainAssociation(dataDomain, parentKey, { readOnly })
+    const json = association.toJSON()
+    assert.isTrue(json.readOnly, 'readOnly is serialized when true')
+  })
+
   test('returns a JSON representation with provided info', ({ assert }) => {
     const dataDomain = new DataDomain()
     const parentKey = 'test-parent'
@@ -330,6 +443,9 @@ 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 readOnly = true
+    const onDelete: OnDeleteRule = 'restrict'
 
     const association = new DomainAssociation(dataDomain, parentKey, {
       key,
@@ -339,6 +455,9 @@ test.group('DomainAssociation.toJSON()', () => {
       required,
       bindings,
       targets,
+      semantics,
+      onDelete,
+      readOnly,
     })
 
     const json = association.toJSON()
@@ -350,6 +469,9 @@ test.group('DomainAssociation.toJSON()', () => {
     assert.equal(json.required, required)
     assert.deepEqual(json.bindings, bindings)
     assert.deepEqual(json.targets, targets)
+    assert.deepEqual(json.semantics, semantics)
+    assert.equal(json.onDelete, onDelete)
+    assert.isTrue(json.readOnly)
   })
 
   test('returns a JSON representation with cloned bindings', ({ assert }) => {
@@ -362,6 +484,36 @@ 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, 'Semantics are serialized after creation')
+  })
+
+  test('returns a JSON representation with onDelete rule when it is set after creation', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const parentKey = 'test-parent'
+    const association = new DomainAssociation(dataDomain, parentKey)
+    const onDelete: OnDeleteRule = 'setNull'
+    association.onDelete = onDelete
+    const json = association.toJSON()
+    assert.equal(json.onDelete, onDelete, 'onDelete is serialized after creation')
+  })
+
+  test('returns a JSON representation with readOnly rule when it is set after creation', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const parentKey = 'test-parent'
+    const association = new DomainAssociation(dataDomain, parentKey)
+    const readOnly = true
+    association.readOnly = readOnly
+    const json = association.toJSON()
+    assert.isTrue(json.readOnly, 'readOnly is serialized after creation when true')
+  })
+
   test('returns a JSON representation with cloned targets', ({ assert }) => {
     const dataDomain = new DataDomain()
     const parentKey = 'test-parent'
@@ -641,3 +793,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 }])
   })
 })
 

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

@@ -9,7 +9,7 @@ const dateRe = /^[0-9]{4}-[0-9]{2}-[0-9]{2}$/
 const timeRe = /^[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}$/
 const mime = 'application/json'
 
-test.group('JSON DataEntity Generator: string', (group) => {
+test.group('JSON DomainEntity Generator: string', (group) => {
   let e1: DomainEntity
 
   group.each.setup(() => {
@@ -140,7 +140,7 @@ test.group('JSON DataEntity Generator: string', (group) => {
   })
 })
 
-test.group('JSON DataEntity Generator: number', (group) => {
+test.group('JSON DomainEntity Generator: number', (group) => {
   let e1: DomainEntity
 
   group.each.setup(() => {
@@ -289,7 +289,7 @@ test.group('JSON DataEntity Generator: number', (group) => {
   })
 })
 
-test.group('JSON DataEntity Generator: int64 format', (group) => {
+test.group('JSON DomainEntity Generator: int64 format', (group) => {
   let e1: DomainEntity
   let p1: DomainProperty
 
@@ -416,7 +416,7 @@ test.group('JSON DataEntity Generator: int64 format', (group) => {
   })
 })
 
-test.group('JSON DataEntity Generator: date', (group) => {
+test.group('JSON DomainEntity Generator: date', (group) => {
   let e1: DomainEntity
 
   group.each.setup(() => {
@@ -492,7 +492,7 @@ test.group('JSON DataEntity Generator: date', (group) => {
   })
 })
 
-test.group('JSON DataEntity Generator: datetime', (group) => {
+test.group('JSON DomainEntity Generator: datetime', (group) => {
   let e1: DomainEntity
 
   group.each.setup(() => {
@@ -557,7 +557,7 @@ test.group('JSON DataEntity Generator: datetime', (group) => {
   })
 })
 
-test.group('JSON DataEntity Generator: time', (group) => {
+test.group('JSON DomainEntity Generator: time', (group) => {
   let e1: DomainEntity
 
   group.each.setup(() => {
@@ -633,7 +633,7 @@ test.group('JSON DataEntity Generator: time', (group) => {
   })
 })
 
-test.group('JSON DataEntity Generator: boolean', (group) => {
+test.group('JSON DomainEntity Generator: boolean', (group) => {
   let e1: DomainEntity
 
   group.each.setup(() => {
@@ -662,7 +662,7 @@ test.group('JSON DataEntity Generator: boolean', (group) => {
   })
 })
 
-// test.group('JSON DataEntity Generator: nil', (group) => {
+// test.group('JSON DomainEntity Generator: nil', (group) => {
 //   let e1: DomainEntity
 
 //   group.each.setup(() => {
@@ -691,7 +691,7 @@ test.group('JSON DataEntity Generator: boolean', (group) => {
 //   })
 // })
 
-test.group('JSON DataEntity Generator: binary', (group) => {
+test.group('JSON DomainEntity Generator: binary', (group) => {
   let e1: DomainEntity
 
   group.each.setup(() => {
@@ -715,7 +715,7 @@ test.group('JSON DataEntity Generator: binary', (group) => {
   })
 })
 
-test.group('JSON DataEntity Generator: associations', (group) => {
+test.group('JSON DomainEntity Generator: associations', (group) => {
   let n1: DataDomain
   let d1: DomainModel
   let e1: DomainEntity
@@ -906,7 +906,7 @@ test.group('JSON DataEntity Generator: associations', (group) => {
   })
 })
 
-test.group('JSON DataEntity Generator: parents', (group) => {
+test.group('JSON DomainEntity Generator: parents', (group) => {
   let d1: DomainModel
   let e1: DomainEntity
   let e2: DomainEntity