@api-client/core 0.14.2 → 0.14.3

package/src/models/store/File.ts

@@ -181,6 +181,45 @@ export class StoredFile {
     this[shortcutTargetSymbol] = value
   }
 
+  /**
+   * Creates a file schema object with the given properties.
+   * The `key` is generated if not set.
+   *
+   * @param input The input to create the file schema.
+   * @returns The file schema object.
+   */
+  static createSchema(input: Partial<IStoredFile> = {}): IStoredFile {
+    const { key = nanoid(), kind, iconColor, shortcutTarget } = input
+    const result: IStoredFile = {
+      key,
+      kind: kind || '',
+      info: Thing.fromJSON(input.info, { name: 'Unnamed file' }).toJSON(),
+    }
+    if (iconColor) {
+      result.iconColor = iconColor
+    }
+    if (shortcutTarget) {
+      result.isShortcut = true
+      result.shortcutTarget = shortcutTarget
+    }
+    return result
+  }
+
+  constructor(state: IStoredFile) {
+    this.kind = state.kind
+    this.key = state.key
+    this.info = new Thing(state.info)
+    if (state.iconColor) {
+      this.iconColor = state.iconColor
+    }
+    if (state.shortcutTarget) {
+      this.shortcutTarget = state.shortcutTarget
+    }
+  }
+
+  /**
+   * @deprecated Use `createSchema()` and setup values in the constructor instead.
+   */
   new(init: IStoredFile): this {
     const { key = nanoid(), info, kind, iconColor, shortcutTarget } = init
     this.key = key
@@ -409,6 +448,64 @@ export class File extends StoredFile {
     return this[permissionsSymbol]
   }
 
+  static override createSchema(input: Partial<IFile> = {}): IFile {
+    const result = StoredFile.createSchema(input) as IFile
+    if (Array.isArray(input.parents)) {
+      result.parents = [...input.parents]
+    } else {
+      result.parents = []
+    }
+    if (Array.isArray(input.permissionIds)) {
+      result.permissionIds = [...input.permissionIds]
+    } else {
+      result.permissionIds = []
+    }
+    if (Array.isArray(input.permissions)) {
+      result.permissions = input.permissions.map((i) => ({ ...i }))
+    } else {
+      result.permissions = []
+    }
+    if (input.capabilities) {
+      result.capabilities = { ...input.capabilities }
+    }
+    if (input.lastModified) {
+      result.lastModified = { ...input.lastModified }
+    } else {
+      result.lastModified = { user: '', time: 0, byMe: false }
+    }
+    if (typeof input.deleted === 'boolean') {
+      result.deleted = input.deleted
+      result.deletedInfo = input.deletedInfo ? { ...input.deletedInfo } : undefined
+    }
+    if (Array.isArray(input.labels)) {
+      result.labels = [...input.labels]
+    }
+    if (typeof input.shortcutTarget === 'string') {
+      result.shortcutTarget = input.shortcutTarget
+    }
+    return result
+  }
+
+  constructor(state?: Partial<IFile>) {
+    const init = File.createSchema(state)
+    super(init)
+    this[parentsSymbol] = [...init.parents]
+    this[permissionIdsSymbol] = [...init.permissionIds]
+    this[permissionsSymbol] = init.permissions.map((i) => ({ ...i }))
+    this[capabilitiesSymbol] = init.capabilities ? { ...init.capabilities } : undefined
+    this[lastModifiedSymbol] = Object.freeze({ ...init.lastModified })
+    if (typeof init.deleted === 'boolean') {
+      this[deletedSymbol] = init.deleted
+      this[deletedInfoSymbol] = init.deletedInfo ? Object.freeze({ ...init.deletedInfo }) : undefined
+    }
+    if (Array.isArray(init.labels)) {
+      this.labels = [...init.labels]
+    }
+  }
+
+  /**
+   * @deprecated Use `createSchema()` and setup values in the constructor instead.
+   */
   override new(init: IFile): this {
     super.new(init)
     const { permissions = [], parents = [], permissionIds = [], deleted, deletedInfo, lastModified, labels } = init
@@ -453,20 +550,10 @@ export class File extends StoredFile {
 
   /**
    * @param name The name to set.
-   * @param owner The user id that is the owner of the file.
+   * @param kind The kind of the file to create.
    */
-  static fromName(name: string, kind = ''): File {
-    const key = nanoid()
-    const definition = new File()
-    definition.new({
-      key,
-      kind,
-      info: Thing.fromName(name).toJSON(),
-      parents: [],
-      permissionIds: [],
-      permissions: [],
-      lastModified: { user: '', time: 0, byMe: false },
-    })
+  static fromName(name: string, kind: string): File {
+    const definition = new File({ kind, info: { name } })
     return definition
   }
 

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_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)
   })

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

@@ -14,17 +14,14 @@ import {
 
 test.group('Semantics', () => {
   test('SemanticType enum should have correct values', ({ assert }) => {
-    assert.equal(SemanticType.User, 'https://apinow.app/semantics/entities/#User')
-    assert.equal(SemanticType.CreatedTimestamp, 'https://apinow.app/semantics/properties/#CreatedTimestamp')
-    assert.equal(SemanticType.UpdatedTimestamp, 'https://apinow.app/semantics/properties/#UpdatedTimestamp')
-    assert.equal(SemanticType.DeletedTimestamp, 'https://apinow.app/semantics/properties/#DeletedTimestamp')
-    assert.equal(SemanticType.DeletedFlag, 'https://apinow.app/semantics/properties/#DeletedFlag')
-    assert.equal(SemanticType.PublicUniqueName, 'https://apinow.app/semantics/properties/#PublicUniqueName')
-    assert.equal(SemanticType.UserRole, 'https://apinow.app/semantics/entities/#UserRole')
-    assert.equal(
-      SemanticType.ResourceOwnerIdentifier,
-      'https://apinow.app/semantics/associations/#ResourceOwnerIdentifier'
-    )
+    assert.equal(SemanticType.User, 'Semantic#User')
+    assert.equal(SemanticType.CreatedTimestamp, 'Semantic#CreatedTimestamp')
+    assert.equal(SemanticType.UpdatedTimestamp, 'Semantic#UpdatedTimestamp')
+    assert.equal(SemanticType.DeletedTimestamp, 'Semantic#DeletedTimestamp')
+    assert.equal(SemanticType.DeletedFlag, 'Semantic#DeletedFlag')
+    assert.equal(SemanticType.PublicUniqueName, 'Semantic#PublicUniqueName')
+    assert.equal(SemanticType.UserRole, 'Semantic#UserRole')
+    assert.equal(SemanticType.ResourceOwnerIdentifier, 'Semantic#ResourceOwnerIdentifier')
   })
 
   test('SemanticScope enum should have correct values', ({ assert }) => {

package/tests/unit/models/File/constructor.spec.ts

@@ -5,8 +5,9 @@ test.group('File.constructor()', () => {
   test('creates a default File', ({ assert }) => {
     const result = new File()
     assert.equal(result.kind, '')
-    assert.equal(result.key, '')
-    assert.deepEqual(result.info.toJSON(), { kind: ThingKind, name: '' })
+    assert.isString(result.key, 'has the key')
+    assert.isNotEmpty(result.key, 'key is not empty')
+    assert.deepEqual(result.info.toJSON(), { kind: ThingKind, name: 'Unnamed file' })
     assert.deepEqual(result.parents, [])
     assert.deepEqual(result.permissionIds, [])
     assert.isFalse(result.deleted, 'deleted')

package/tests/unit/models/File/shortcutTo.spec.ts

@@ -46,7 +46,7 @@ test.group('File.shortcutTo()', () => {
   })
 
   test('creates a shortcut from a name with fromName()', ({ assert }) => {
-    const file = File.fromName('test-file')
+    const file = File.fromName('test-file', 'shortcut')
     const targetId = 'target-file-id'
     file.shortcutTo(targetId)
     assert.equal(file.shortcutTarget, targetId)