@api-client/core 0.14.1 → 0.14.3

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

@@ -0,0 +1,291 @@
+import { test } from '@japa/runner'
+import {
+  ApiModel,
+  ApiModelKind,
+  DataDomain,
+  type RolesBasedAccessControl,
+  type ApiModelSchema,
+  type ExposedEntity,
+} from '../../../src/index.js'
+
+test.group('ApiModel.createSchema()', () => {
+  test('creates a schema with default values', ({ assert }) => {
+    const schema = ApiModel.createSchema()
+    assert.equal(schema.kind, ApiModelKind)
+    assert.typeOf(schema.key, 'string')
+    assert.isNotEmpty(schema.key)
+    assert.deepInclude(schema.info, { name: 'Unnamed API' })
+    assert.deepEqual(schema.exposes, [])
+    assert.isUndefined(schema.userKey)
+    assert.isUndefined(schema.domain)
+    assert.isUndefined(schema.authentication)
+    assert.isUndefined(schema.authorization)
+    assert.isUndefined(schema.session)
+    assert.isUndefined(schema.accessRule)
+    assert.isUndefined(schema.rateLimiting)
+  })
+
+  test('creates a schema with provided values', ({ assert }) => {
+    const input: Partial<ApiModelSchema> = {
+      key: 'test-api',
+      info: { name: 'Test API', description: 'A test API' },
+      exposes: [{ key: 'entity1', actions: [] }],
+      userKey: 'user-entity',
+      domain: { key: 'domain1', version: '1.0.0' },
+      authentication: { strategy: 'UsernamePassword' },
+      authorization: { strategy: 'RBAC', roleKey: 'role' } as RolesBasedAccessControl,
+      session: { secret: 'secret', properties: ['email'] },
+      accessRule: [{ type: 'public' }],
+      rateLimiting: { rules: [] },
+    }
+    const schema = ApiModel.createSchema(input)
+
+    assert.equal(schema.kind, ApiModelKind)
+    assert.equal(schema.key, 'test-api')
+    assert.deepInclude(schema.info, { name: 'Test API', description: 'A test API' })
+    assert.deepEqual(schema.exposes, [{ key: 'entity1', actions: [] }])
+    assert.equal(schema.userKey, 'user-entity')
+    assert.deepEqual(schema.domain, { key: 'domain1', version: '1.0.0' })
+    assert.deepEqual(schema.authentication, { strategy: 'UsernamePassword' })
+    assert.deepEqual(schema.authorization, { strategy: 'RBAC', roleKey: 'role' })
+    assert.deepEqual(schema.session, { secret: 'secret', properties: ['email'] })
+    assert.deepEqual(schema.accessRule, [{ type: 'public' }])
+    assert.deepEqual(schema.rateLimiting, { rules: [] })
+  })
+
+  test('creates a schema with partial info', ({ assert }) => {
+    const schema = ApiModel.createSchema({ info: { name: 'Partial API' } })
+    assert.deepInclude(schema.info, { name: 'Partial API' })
+  })
+
+  test('creates a schema with empty info', ({ assert }) => {
+    const schema = ApiModel.createSchema({ info: {} })
+    assert.deepInclude(schema.info, { name: 'Unnamed API' })
+  })
+})
+
+test.group('ApiModel.constructor()', () => {
+  test('creates an instance with default values', ({ assert }) => {
+    const model = new ApiModel()
+    assert.equal(model.kind, ApiModelKind)
+    assert.typeOf(model.key, 'string')
+    assert.isNotEmpty(model.key)
+    assert.equal(model.info.name, 'Unnamed API')
+    assert.deepEqual(model.exposes, [])
+    assert.isUndefined(model.userKey)
+    assert.isUndefined(model.domain)
+    assert.isUndefined(model.authentication)
+    assert.isUndefined(model.authorization)
+    assert.isUndefined(model.session)
+    assert.isUndefined(model.accessRule)
+    assert.isUndefined(model.rateLimiting)
+    assert.isUndefined(model.dataDomain)
+  })
+
+  test('creates an instance with provided schema values', ({ assert }) => {
+    const schema: ApiModelSchema = {
+      kind: ApiModelKind,
+      key: 'test-api',
+      info: { name: 'Test API', description: 'A test API' },
+      exposes: [{ key: 'entity1', actions: [] }],
+      userKey: 'user-entity',
+      domain: { key: 'domain1', version: '1.0.0' },
+      authentication: { strategy: 'UsernamePassword' },
+      authorization: { strategy: 'RBAC', roleKey: 'role' } as RolesBasedAccessControl,
+      session: { secret: 'secret', properties: ['email'] },
+      accessRule: [{ type: 'public' }],
+      rateLimiting: { rules: [] },
+    }
+    const model = new ApiModel(schema)
+
+    assert.equal(model.key, 'test-api')
+    assert.equal(model.info.name, 'Test API')
+    assert.deepEqual(model.exposes, [{ key: 'entity1', actions: [] }])
+    assert.equal(model.userKey, 'user-entity')
+    assert.deepEqual(model.domain, { key: 'domain1', version: '1.0.0' })
+    assert.deepEqual(model.authentication, { strategy: 'UsernamePassword' })
+    assert.deepEqual(model.authorization, { strategy: 'RBAC', roleKey: 'role' })
+    assert.deepEqual(model.session, { secret: 'secret', properties: ['email'] })
+    assert.deepEqual(model.accessRule, [{ type: 'public' }])
+    assert.deepEqual(model.rateLimiting, { rules: [] })
+    assert.isUndefined(model.dataDomain)
+  })
+
+  test('creates an instance with a DataDomain', ({ assert }) => {
+    const domainSchema = DataDomain.createSchema({ key: 'my-domain' })
+    const model = new ApiModel({}, domainSchema)
+    assert.isDefined(model.dataDomain)
+    assert.instanceOf(model.dataDomain, DataDomain)
+    assert.equal(model.dataDomain!.key, 'my-domain')
+  })
+
+  test('notifies change when info is modified', async ({ assert }) => {
+    const model = new ApiModel()
+    let notified = false
+    model.addEventListener('change', () => {
+      notified = true
+    })
+    model.info.name = 'New Name'
+    await Promise.resolve() // Allow microtask to run
+    assert.isTrue(notified)
+  })
+})
+
+test.group('ApiModel.toJSON()', () => {
+  test('serializes default values', ({ assert }) => {
+    const model = new ApiModel()
+    const json = model.toJSON()
+
+    assert.equal(json.kind, ApiModelKind)
+    assert.equal(json.key, model.key)
+    assert.deepInclude(json.info, { name: 'Unnamed API' })
+    assert.deepEqual(json.exposes, [])
+    assert.isUndefined(json.userKey)
+    assert.isUndefined(json.domain)
+    assert.isUndefined(json.authentication)
+    assert.isUndefined(json.authorization)
+    assert.isUndefined(json.session)
+    assert.isUndefined(json.accessRule)
+    assert.isUndefined(json.rateLimiting)
+  })
+
+  test('serializes all provided values', ({ assert }) => {
+    const schema: ApiModelSchema = {
+      kind: ApiModelKind,
+      key: 'test-api',
+      info: { name: 'Test API', description: 'A test API' },
+      exposes: [{ key: 'entity1', actions: [] }],
+      userKey: 'user-entity',
+      domain: { key: 'domain1', version: '1.0.0' },
+      authentication: { strategy: 'UsernamePassword' },
+      authorization: { strategy: 'RBAC', roleKey: 'role' } as RolesBasedAccessControl,
+      session: { secret: 'secret', properties: ['email'] },
+      accessRule: [{ type: 'public' }],
+      rateLimiting: { rules: [] },
+    }
+    const model = new ApiModel(schema)
+    const json = model.toJSON()
+
+    assert.equal(json.key, 'test-api')
+    assert.deepInclude(json.info, { name: 'Test API', description: 'A test API' })
+    assert.deepEqual(json.exposes, [{ key: 'entity1', actions: [] }])
+    assert.equal(json.userKey, 'user-entity')
+    assert.deepEqual(json.domain, { key: 'domain1', version: '1.0.0' })
+    assert.deepEqual(json.authentication, { strategy: 'UsernamePassword' })
+    assert.deepEqual(json.authorization, { strategy: 'RBAC', roleKey: 'role' })
+    assert.deepEqual(json.session, { secret: 'secret', properties: ['email'] })
+    assert.deepEqual(json.accessRule, [{ type: 'public' }])
+    assert.deepEqual(json.rateLimiting, { rules: [] })
+  })
+})
+
+test.group('ApiModel.exposeEntity()', () => {
+  test('exposes a new entity', ({ assert }) => {
+    const model = new ApiModel()
+    const entityKey = 'new-entity'
+    const exposedEntity = model.exposeEntity(entityKey)
+
+    assert.isDefined(exposedEntity)
+    assert.equal(exposedEntity.key, entityKey)
+    assert.deepEqual(exposedEntity.actions, [])
+    assert.includeDeepMembers(model.exposes, [exposedEntity])
+  })
+
+  test('returns an existing entity if already exposed', ({ assert }) => {
+    const model = new ApiModel()
+    const entityKey = 'existing-entity'
+    const initialExposedEntity = model.exposeEntity(entityKey)
+    const retrievedExposedEntity = model.exposeEntity(entityKey)
+
+    assert.strictEqual(retrievedExposedEntity, initialExposedEntity)
+    assert.lengthOf(model.exposes, 1)
+  })
+
+  test('notifies change when a new entity is exposed', async ({ assert }) => {
+    const model = new ApiModel()
+    let notified = false
+    model.addEventListener('change', () => {
+      notified = true
+    })
+    model.exposeEntity('notify-entity')
+    await Promise.resolve() // Allow microtask to run
+    assert.isTrue(notified)
+  })
+
+  test('does not notify change if entity already exposed', async ({ assert }) => {
+    const model = new ApiModel()
+    model.exposeEntity('no-notify-entity') // First exposure
+    await Promise.resolve() // Allow microtask to run
+    let notified = false
+    model.addEventListener('change', () => {
+      notified = true
+    })
+    model.exposeEntity('no-notify-entity') // Second exposure
+    await Promise.resolve() // Allow microtask to run
+    assert.isFalse(notified)
+  })
+})
+
+test.group('ApiModel.removeEntity()', () => {
+  test('removes an existing entity', ({ assert }) => {
+    const model = new ApiModel()
+    const entityKey = 'entity-to-remove'
+    model.exposeEntity(entityKey)
+    assert.lengthOf(model.exposes, 1)
+
+    model.removeEntity(entityKey)
+    assert.lengthOf(model.exposes, 0)
+  })
+
+  test('does nothing if entity does not exist', ({ assert }) => {
+    const model = new ApiModel()
+    model.exposeEntity('existing-entity')
+    const initialExposes = [...model.exposes]
+
+    model.removeEntity('non-existing-entity')
+    assert.deepEqual(model.exposes, initialExposes)
+  })
+
+  test('notifies change when an entity is removed', async ({ assert }) => {
+    const model = new ApiModel()
+    const entityKey = 'notify-remove-entity'
+    model.exposeEntity(entityKey)
+
+    let notified = false
+    model.addEventListener('change', () => {
+      notified = true
+    })
+    model.removeEntity(entityKey)
+    await Promise.resolve() // Allow microtask to run
+    assert.isTrue(notified)
+  })
+
+  test('does not notify change if entity to remove does not exist', async ({ assert }) => {
+    const model = new ApiModel()
+    let notified = false
+    model.addEventListener('change', () => {
+      notified = true
+    })
+    model.removeEntity('no-notify-remove-entity')
+    await Promise.resolve() // Allow microtask to run
+    assert.isFalse(notified)
+  })
+})
+
+test.group('ApiModel.getExposedEntity()', () => {
+  test('returns an existing exposed entity', ({ assert }) => {
+    const model = new ApiModel()
+    const entityKey = 'get-entity'
+    const exposed: ExposedEntity = { key: entityKey, actions: [] }
+    model.exposes.push(exposed)
+
+    const retrievedEntity = model.getExposedEntity(entityKey)
+    assert.deepEqual(retrievedEntity, exposed)
+  })
+
+  test('returns undefined if entity is not exposed', ({ assert }) => {
+    const model = new ApiModel()
+    const retrievedEntity = model.getExposedEntity('non-exposed-entity')
+    assert.isUndefined(retrievedEntity)
+  })
+})

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

@@ -8,6 +8,7 @@ import {
   DataDomain,
   DataFormat,
   SemanticType,
+  type OnDeleteRule,
 } from '../../../src/index.js'
 
 test.group('DomainAssociation.createSchema()', () => {
@@ -23,6 +24,8 @@ test.group('DomainAssociation.createSchema()', () => {
     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 }) => {
@@ -43,6 +46,17 @@ test.group('DomainAssociation.createSchema()', () => {
     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 })
@@ -80,6 +94,8 @@ test.group('DomainAssociation.createSchema()', () => {
     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,
@@ -90,6 +106,8 @@ test.group('DomainAssociation.createSchema()', () => {
       bindings,
       targets,
       semantics,
+      onDelete,
+      readOnly,
     })
 
     assert.equal(schema.key, key)
@@ -100,6 +118,8 @@ test.group('DomainAssociation.createSchema()', () => {
     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 }) => {
@@ -145,6 +165,8 @@ test.group('DomainAssociation.constructor()', () => {
     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 }) => {
@@ -163,6 +185,22 @@ test.group('DomainAssociation.constructor()', () => {
     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'
@@ -220,6 +258,8 @@ test.group('DomainAssociation.constructor()', () => {
     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,
@@ -230,6 +270,8 @@ test.group('DomainAssociation.constructor()', () => {
       bindings,
       targets,
       semantics,
+      onDelete,
+      readOnly,
     })
 
     assert.equal(association.key, key)
@@ -240,6 +282,8 @@ test.group('DomainAssociation.constructor()', () => {
     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 }) => {
@@ -294,6 +338,8 @@ test.group('DomainAssociation.toJSON()', () => {
     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 }) => {
@@ -311,7 +357,25 @@ test.group('DomainAssociation.toJSON()', () => {
     const semantics = [{ id: SemanticType.ResourceOwnerIdentifier }]
     const association = new DomainAssociation(dataDomain, parentKey, { semantics })
     const json = association.toJSON()
-    assert.deepEqual(json.semantics, semantics)
+    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 }) => {
@@ -380,6 +444,8 @@ test.group('DomainAssociation.toJSON()', () => {
     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,
@@ -390,6 +456,8 @@ test.group('DomainAssociation.toJSON()', () => {
       bindings,
       targets,
       semantics,
+      onDelete,
+      readOnly,
     })
 
     const json = association.toJSON()
@@ -402,6 +470,8 @@ test.group('DomainAssociation.toJSON()', () => {
     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 }) => {
@@ -421,7 +491,27 @@ test.group('DomainAssociation.toJSON()', () => {
     const semantics = [{ id: SemanticType.ResourceOwnerIdentifier }]
     association.semantics = semantics
     const json = association.toJSON()
-    assert.deepEqual(json.semantics, semantics)
+    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 }) => {

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

@@ -17,7 +17,7 @@ test.group('DomainEntity.createSchema()', () => {
     assert.equal(schema.kind, DomainEntityKind)
     assert.typeOf(schema.key, 'string')
     assert.isNotEmpty(schema.key)
-    assert.deepInclude(schema.info, { name: 'New entity' })
+    assert.deepInclude(schema.info, { name: 'new_entity' })
     assert.isUndefined(schema.tags)
     assert.isUndefined(schema.semantics)
     assert.isUndefined(schema.fields)
@@ -59,7 +59,7 @@ test.group('DomainEntity.createSchema()', () => {
     assert.equal(schema.kind, DomainEntityKind)
     assert.typeOf(schema.key, 'string')
     assert.isNotEmpty(schema.key)
-    assert.deepInclude(schema.info, { name: 'New entity' })
+    assert.deepInclude(schema.info, { name: 'new_entity' })
   })
 
   test('creates a schema with tags', ({ assert }) => {
@@ -69,7 +69,7 @@ test.group('DomainEntity.createSchema()', () => {
     assert.equal(schema.kind, DomainEntityKind)
     assert.typeOf(schema.key, 'string')
     assert.isNotEmpty(schema.key)
-    assert.deepInclude(schema.info, { name: 'New entity' })
+    assert.deepInclude(schema.info, { name: 'new_entity' })
     assert.deepEqual(schema.tags, ['tag1', 'tag2'])
   })
 
@@ -80,7 +80,7 @@ test.group('DomainEntity.createSchema()', () => {
     assert.equal(schema.kind, DomainEntityKind)
     assert.typeOf(schema.key, 'string')
     assert.isNotEmpty(schema.key)
-    assert.deepInclude(schema.info, { name: 'New entity' })
+    assert.deepInclude(schema.info, { name: 'new_entity' })
     assert.deepEqual(schema.semantics, [{ id: SemanticType.User }])
   })
 
@@ -91,7 +91,7 @@ test.group('DomainEntity.createSchema()', () => {
     assert.equal(schema.kind, DomainEntityKind)
     assert.typeOf(schema.key, 'string')
     assert.isNotEmpty(schema.key)
-    assert.deepInclude(schema.info, { name: 'New entity' })
+    assert.deepInclude(schema.info, { name: 'new_entity' })
     assert.deepEqual(schema.fields, [{ key: 'test-property', type: 'property' }])
   })
 
@@ -102,7 +102,7 @@ test.group('DomainEntity.createSchema()', () => {
     assert.equal(schema.kind, DomainEntityKind)
     assert.typeOf(schema.key, 'string')
     assert.isNotEmpty(schema.key)
-    assert.deepInclude(schema.info, { name: 'New entity' })
+    assert.deepInclude(schema.info, { name: 'new_entity' })
     assert.isTrue(schema.deprecated)
   })
 
@@ -113,7 +113,7 @@ test.group('DomainEntity.createSchema()', () => {
     assert.equal(schema.kind, DomainEntityKind)
     assert.typeOf(schema.key, 'string')
     assert.isNotEmpty(schema.key)
-    assert.deepInclude(schema.info, { name: 'New entity' })
+    assert.deepInclude(schema.info, { name: 'new_entity' })
     assert.isFalse(schema.deprecated)
   })
 
@@ -164,7 +164,7 @@ test.group('DomainEntity.constructor()', () => {
     assert.typeOf(entity.key, 'string')
     assert.isNotEmpty(entity.key)
     assert.instanceOf(entity.info, Thing)
-    assert.equal(entity.info.name, 'New entity')
+    assert.equal(entity.info.name, 'new_entity')
     assert.deepEqual(entity.tags, [])
     assert.deepEqual(entity.semantics, [])
     assert.deepEqual(entity.fields, [])
@@ -213,7 +213,7 @@ test.group('DomainEntity.constructor()', () => {
     assert.typeOf(entity.key, 'string')
     assert.isNotEmpty(entity.key)
     assert.instanceOf(entity.info, Thing)
-    assert.equal(entity.info.name, 'New entity')
+    assert.equal(entity.info.name, 'new_entity')
   })
 
   test('creates a new DomainEntity with tags', ({ assert }) => {
@@ -225,7 +225,7 @@ test.group('DomainEntity.constructor()', () => {
     assert.typeOf(entity.key, 'string')
     assert.isNotEmpty(entity.key)
     assert.instanceOf(entity.info, Thing)
-    assert.equal(entity.info.name, 'New entity')
+    assert.equal(entity.info.name, 'new_entity')
     assert.deepEqual(entity.tags, ['tag1', 'tag2'])
   })
 
@@ -238,7 +238,7 @@ test.group('DomainEntity.constructor()', () => {
     assert.typeOf(entity.key, 'string')
     assert.isNotEmpty(entity.key)
     assert.instanceOf(entity.info, Thing)
-    assert.equal(entity.info.name, 'New entity')
+    assert.equal(entity.info.name, 'new_entity')
     assert.deepEqual(entity.semantics, [{ id: SemanticType.User }])
   })
 
@@ -251,7 +251,7 @@ test.group('DomainEntity.constructor()', () => {
     assert.typeOf(entity.key, 'string')
     assert.isNotEmpty(entity.key)
     assert.instanceOf(entity.info, Thing)
-    assert.equal(entity.info.name, 'New entity')
+    assert.equal(entity.info.name, 'new_entity')
     assert.deepEqual(entity.fields, [{ key: 'test-property', type: 'property' }])
   })
 
@@ -264,7 +264,7 @@ test.group('DomainEntity.constructor()', () => {
     assert.typeOf(entity.key, 'string')
     assert.isNotEmpty(entity.key)
     assert.instanceOf(entity.info, Thing)
-    assert.equal(entity.info.name, 'New entity')
+    assert.equal(entity.info.name, 'new_entity')
     assert.isTrue(entity.deprecated)
   })
 
@@ -277,7 +277,7 @@ test.group('DomainEntity.constructor()', () => {
     assert.typeOf(entity.key, 'string')
     assert.isNotEmpty(entity.key)
     assert.instanceOf(entity.info, Thing)
-    assert.equal(entity.info.name, 'New entity')
+    assert.equal(entity.info.name, 'new_entity')
     assert.isFalse(entity.deprecated)
   })
 
@@ -350,7 +350,7 @@ test.group('DomainEntity.toJSON()', () => {
     const json = entity.toJSON()
     assert.equal(json.kind, DomainEntityKind)
     assert.equal(json.key, entity.key)
-    assert.deepInclude(json.info, { name: 'New entity' })
+    assert.deepInclude(json.info, { name: 'new_entity' })
     assert.isUndefined(json.tags)
     assert.isUndefined(json.semantics)
     assert.isUndefined(json.fields)

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

@@ -99,22 +99,12 @@ test.group('constructor()', () => {
       ],
       lastModified: { byMe: false, time: 0, user: 'id', name: 'test' },
     }
-    const result = new DomainFile(JSON.stringify(schema))
+    const result = new DomainFile(schema)
     assert.equal(result.kind, DomainFileKind)
     assert.equal(result.info.name, 'hello')
     assert.equal(result.key, '123')
     assert.deepEqual(result.lastModified, schema.lastModified)
   })
-
-  test('throws when invalid schema', ({ assert }) => {
-    assert.throws(() => {
-      new DomainFile(
-        JSON.stringify({
-          name: 'a name',
-        })
-      )
-    })
-  })
 })
 
 test.group('toJSON()', () => {

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

@@ -9,7 +9,7 @@ test.group('DomainModel.addEntity()', () => {
     assert.instanceOf(entity, DomainEntity)
     assert.equal(entity.kind, DomainEntityKind)
     assert.equal(entity.key, 'test-entity')
-    assert.deepInclude(entity.info, { name: 'New entity' })
+    assert.deepInclude(entity.info, { name: 'new_entity' })
     assert.isTrue(dataDomain.graph.hasNode(entity.key))
     assert.equal(dataDomain.graph.parent(entity.key), model.key)
   })
@@ -22,7 +22,7 @@ test.group('DomainModel.addEntity()', () => {
     assert.equal(entity.kind, DomainEntityKind)
     assert.typeOf(entity.key, 'string')
     assert.isNotEmpty(entity.key)
-    assert.deepInclude(entity.info, { name: 'New entity' })
+    assert.deepInclude(entity.info, { name: 'new_entity' })
     assert.isTrue(dataDomain.graph.hasNode(entity.key))
     assert.equal(dataDomain.graph.parent(entity.key), model.key)
   })