@api-client/core 0.19.9 → 0.19.11

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

@@ -13,7 +13,7 @@ import {
 } from '../../../src/index.js'
 import { AllowPublicAccessRule } from '../../../src/modeling/rules/AllowPublic.js'
 import { RateLimitingConfiguration } from '../../../src/modeling/rules/RateLimitingConfiguration.js'
-import { Action } from '../../../src/modeling/index.js'
+import { ReadActionSchema } from '../../../src/modeling/index.js'
 
 test.group('ApiModel.createSchema()', () => {
   test('creates a schema with default values', ({ assert }) => {
@@ -97,7 +97,7 @@ test.group('ApiModel.constructor()', () => {
     assert.typeOf(model.key, 'string')
     assert.isNotEmpty(model.key)
     assert.equal(model.info.name, 'Unnamed API')
-    assert.deepEqual(model.exposes, [])
+    assert.equal(model.exposes.size, 0)
     assert.isUndefined(model.user)
     assert.isUndefined(model.authentication)
     assert.isUndefined(model.authorization)
@@ -140,8 +140,8 @@ test.group('ApiModel.constructor()', () => {
 
     assert.equal(model.key, 'test-api')
     assert.equal(model.info.name, 'Test API')
-    assert.lengthOf(model.exposes, 1, 'should have one exposed entity')
-    assert.equal(model.exposes[0].key, 'entity1', 'exposed entity should have correct key')
+    assert.equal(model.exposes.size, 1, 'should have one exposed entity')
+    assert.equal(Array.from(model.exposes.values())[0]!.entity.key, 'entity1', 'exposed entity should have correct key')
     assert.deepEqual(model.user, { key: 'user-entity' })
     assert.deepEqual(model.dependencyList, [{ key: 'domain1', version: '1.0.0' }])
     assert.deepEqual(model.authentication, { strategy: 'UsernamePassword' })
@@ -216,7 +216,7 @@ test.group('ApiModel.constructor()', () => {
       notified = true
     })
 
-    model.exposes[0].actions[0].kind = 'write'
+    Array.from(model.exposes.values())[0]!.actions[0]!.kind = 'write'
     await Promise.resolve()
     assert.isTrue(notified)
   }).tags(['@modeling', '@api', '@observed'])
@@ -290,20 +290,22 @@ test.group('ApiModel.toJSON()', () => {
 
   test('actions are immutable', ({ assert }) => {
     const model = new ApiModel()
-    const action = new Action({ kind: 'read' })
+    const action: ReadActionSchema = {
+      kind: 'read',
+    }
     const entityKey = 'get-entity'
     const exposed: ExposedEntitySchema = {
       key: entityKey,
-      actions: [action.toJSON()],
+      actions: [action],
       hasCollection: true,
       kind: ExposedEntityKind,
       resourcePath: '/',
       entity: { key: entityKey },
     }
-    model.exposes.push(new ExposedEntity(model, exposed))
+    model.exposes.set(exposed.key, new ExposedEntity(model, exposed))
     const json = model.toJSON()
-    json.exposes[0].actions[0].kind = 'write'
-    assert.equal(model.exposes[0].actions[0].kind, 'read')
+    json.exposes![0]!.actions![0]!.kind = 'write'
+    assert.equal(Array.from(model.exposes.values())[0]!.actions[0]!.kind, 'read')
   }).tags(['@modeling', '@api', '@serialization'])
 })
 
@@ -319,15 +321,190 @@ test.group('ApiModel.getExposedEntity()', () => {
       resourcePath: '/',
       entity: { key: entityKey },
     }
-    model.exposes.push(new ExposedEntity(model, exposed))
+    model.exposes.set(exposed.key, new ExposedEntity(model, exposed))
 
-    const retrievedEntity = model.getExposedEntity({ key: entityKey })
+    const retrievedEntity = model.exposes.get(entityKey)
     assert.deepEqual(retrievedEntity?.toJSON(), exposed)
   }).tags(['@modeling', '@api'])
 
   test('returns undefined if entity is not exposed', ({ assert }) => {
     const model = new ApiModel()
-    const retrievedEntity = model.getExposedEntity({ key: 'non-exposed-entity' })
+    const retrievedEntity = model.exposes.get('non-exposed-entity')
     assert.isUndefined(retrievedEntity)
   }).tags(['@modeling', '@api'])
 })
+
+test.group('ApiModel.findResourcePathCollision()', () => {
+  test('returns the entity if resource path collides', ({ assert }) => {
+    const model = new ApiModel()
+    model.exposes.set(
+      'ent1',
+      new ExposedEntity(model, {
+        key: 'ent1',
+        kind: ExposedEntityKind,
+        resourcePath: '/test',
+        isRoot: true,
+        hasCollection: false,
+        actions: [],
+        entity: { key: 'domain1' },
+      })
+    )
+
+    const collision = model.findResourcePathCollision('/test')
+    assert.isDefined(collision)
+    assert.equal(collision?.key, 'ent1')
+  }).tags(['@modeling', '@api'])
+
+  test('returns undefined if no collision', ({ assert }) => {
+    const model = new ApiModel()
+    model.exposes.set(
+      'ent1',
+      new ExposedEntity(model, {
+        key: 'ent1',
+        kind: ExposedEntityKind,
+        resourcePath: '/test',
+        isRoot: true,
+        hasCollection: false,
+        actions: [],
+        entity: { key: 'domain1' },
+      })
+    )
+
+    assert.isUndefined(model.findResourcePathCollision('/other'))
+  }).tags(['@modeling', '@api'])
+
+  test('ignores the entity with the ignore key', ({ assert }) => {
+    const model = new ApiModel()
+    model.exposes.set(
+      'ent1',
+      new ExposedEntity(model, {
+        key: 'ent1',
+        kind: ExposedEntityKind,
+        resourcePath: '/test',
+        isRoot: true,
+        hasCollection: false,
+        actions: [],
+        entity: { key: 'domain1' },
+      })
+    )
+
+    assert.isUndefined(model.findResourcePathCollision('/test', 'ent1'))
+  }).tags(['@modeling', '@api'])
+
+  test('ignores non-root entities', ({ assert }) => {
+    const model = new ApiModel()
+    model.exposes.set(
+      'ent1',
+      new ExposedEntity(model, {
+        key: 'ent1',
+        kind: ExposedEntityKind,
+        resourcePath: '/test',
+        isRoot: false,
+        hasCollection: false,
+        actions: [],
+        entity: { key: 'domain1' },
+      })
+    )
+
+    assert.isUndefined(model.findResourcePathCollision('/test'))
+  }).tags(['@modeling', '@api'])
+})
+
+test.group('ApiModel.findCollectionPathCollision()', () => {
+  test('returns the entity if collection path collides', ({ assert }) => {
+    const model = new ApiModel()
+    model.exposes.set(
+      'ent1',
+      new ExposedEntity(model, {
+        key: 'ent1',
+        kind: ExposedEntityKind,
+        collectionPath: '/tests',
+        resourcePath: '/tests/{id}',
+        isRoot: true,
+        hasCollection: true,
+        actions: [],
+        entity: { key: 'domain1' },
+      })
+    )
+
+    const collision = model.findCollectionPathCollision('/tests')
+    assert.isDefined(collision)
+    assert.equal(collision?.key, 'ent1')
+  }).tags(['@modeling', '@api'])
+
+  test('returns undefined if no collision', ({ assert }) => {
+    const model = new ApiModel()
+    model.exposes.set(
+      'ent1',
+      new ExposedEntity(model, {
+        key: 'ent1',
+        kind: ExposedEntityKind,
+        collectionPath: '/tests',
+        resourcePath: '/tests/{id}',
+        isRoot: true,
+        hasCollection: true,
+        actions: [],
+        entity: { key: 'domain1' },
+      })
+    )
+
+    assert.isUndefined(model.findCollectionPathCollision('/other'))
+  }).tags(['@modeling', '@api'])
+
+  test('ignores the entity with the ignore key', ({ assert }) => {
+    const model = new ApiModel()
+    model.exposes.set(
+      'ent1',
+      new ExposedEntity(model, {
+        key: 'ent1',
+        kind: ExposedEntityKind,
+        collectionPath: '/tests',
+        resourcePath: '/tests/{id}',
+        isRoot: true,
+        hasCollection: true,
+        actions: [],
+        entity: { key: 'domain1' },
+      })
+    )
+
+    assert.isUndefined(model.findCollectionPathCollision('/tests', 'ent1'))
+  }).tags(['@modeling', '@api'])
+
+  test('ignores non-root entities', ({ assert }) => {
+    const model = new ApiModel()
+    model.exposes.set(
+      'ent1',
+      new ExposedEntity(model, {
+        key: 'ent1',
+        kind: ExposedEntityKind,
+        collectionPath: '/tests',
+        resourcePath: '/tests/{id}',
+        isRoot: false,
+        hasCollection: true,
+        actions: [],
+        entity: { key: 'domain1' },
+      })
+    )
+
+    assert.isUndefined(model.findCollectionPathCollision('/tests'))
+  }).tags(['@modeling', '@api'])
+
+  test('ignores entities without collections', ({ assert }) => {
+    const model = new ApiModel()
+    model.exposes.set(
+      'ent1',
+      new ExposedEntity(model, {
+        key: 'ent1',
+        kind: ExposedEntityKind,
+        resourcePath: '/tests',
+        collectionPath: '/tests',
+        isRoot: true,
+        hasCollection: false,
+        actions: [],
+        entity: { key: 'domain1' },
+      })
+    )
+
+    assert.isUndefined(model.findCollectionPathCollision('/tests'))
+  }).tags(['@modeling', '@api'])
+})

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

@@ -1,5 +1,23 @@
 import { test } from '@japa/runner'
-import { ApiModel, DataDomain } from '../../../src/index.js'
+import { ApiModel, DataDomain, type ExposedEntity } from '../../../src/index.js'
+
+function findRootExposedEntity(model: ApiModel, entityKey: string) {
+  for (const e of model.exposes.values()) {
+    if (e.isRoot && e.entity.key === entityKey) {
+      return e
+    }
+  }
+  return undefined
+}
+
+function findNonRootExposedEntity(model: ApiModel, entityKey: string) {
+  for (const e of model.exposes.values()) {
+    if (!e.isRoot && e.entity.key === entityKey) {
+      return e
+    }
+  }
+  return undefined
+}
 
 test.group('ApiModel.exposeEntity()', () => {
   test('exposes a new entity', ({ assert }) => {
@@ -28,7 +46,7 @@ test.group('ApiModel.exposeEntity()', () => {
     const retrievedExposedEntity = model.exposeEntity({ key: e1.key })
 
     assert.deepEqual(retrievedExposedEntity.toJSON(), initialExposedEntity.toJSON())
-    assert.lengthOf(model.exposes, 1)
+    assert.equal(model.exposes.size, 1)
   }).tags(['@modeling', '@api'])
 
   test('notifies change when a new entity is exposed', async ({ assert }) => {
@@ -77,7 +95,7 @@ test.group('ApiModel.exposeEntity()', () => {
     model.attachDataDomain(domain)
     const exposedA = model.exposeEntity({ key: eA.key }, { followAssociations: true })
     // Find nested exposure for B
-    const nestedB = model.exposes.find((e) => !e.isRoot && e.entity.key === eB.key)
+    const nestedB = findNonRootExposedEntity(model, eB.key)
     assert.isDefined(nestedB)
     assert.deepEqual(nestedB?.parent?.key, exposedA.key)
     assert.strictEqual(nestedB?.collectionPath, '/entitybs')
@@ -96,15 +114,21 @@ test.group('ApiModel.exposeEntity()', () => {
     model.attachDataDomain(domain)
     model.exposeEntity({ key: eA.key }, { followAssociations: true, maxDepth: 4 })
 
-    assert.lengthOf(model.exposes, 2, 'has only 2 exposures')
+    assert.equal(model.exposes.size, 2, 'has only 2 exposures')
     // Should expose A (root), B (nested under A), but not infinitely nest
-    const exposedA = model.exposes.find((e) => e.isRoot && e.entity.key === eA.key)
-    const nestedB = model.exposes.find((e) => !e.isRoot && e.entity.key === eB.key)
+    const exposedA = findRootExposedEntity(model, eA.key)
+    const nestedB = findNonRootExposedEntity(model, eB.key)
     // There should be only one nested exposure for B under A
     assert.isDefined(exposedA)
     assert.isDefined(nestedB)
     // There should NOT be a nested exposure for A under B
-    const circularA = model.exposes.find((e) => !e.isRoot && e.entity.key === eA.key && e.parent?.key === nestedB?.key)
+    let circularA: ExposedEntity | undefined
+    for (const e of model.exposes.values()) {
+      if (!e.isRoot && e.entity.key === eA.key && e.parent?.key === nestedB?.key) {
+        circularA = e
+        break
+      }
+    }
     assert.isUndefined(circularA)
   })
 
@@ -119,8 +143,8 @@ test.group('ApiModel.exposeEntity()', () => {
     model.attachDataDomain(domain)
     model.exposeEntity({ key: eA.key }, { followAssociations: true })
     // Should only expose A as root, not as nested
-    const exposedA = model.exposes.find((e) => e.isRoot && e.entity.key === eA.key)
-    const nestedA = model.exposes.find((e) => !e.isRoot && e.entity.key === eA.key)
+    const exposedA = findRootExposedEntity(model, eA.key)
+    const nestedA = findNonRootExposedEntity(model, eA.key)
     assert.isDefined(exposedA)
     assert.isUndefined(nestedA)
   })
@@ -137,11 +161,11 @@ test.group('ApiModel.exposeEntity()', () => {
     const model = new ApiModel()
     model.attachDataDomain(domain)
     model.exposeEntity({ key: eA.key }, { followAssociations: true })
-    const nestedB = model.exposes.find((e) => !e.isRoot && e.entity.key === eB.key)
-    const nestedC = model.exposes.find((e) => !e.isRoot && e.entity.key === eC.key)
+    const nestedB = findNonRootExposedEntity(model, eB.key)
+    const nestedC = findNonRootExposedEntity(model, eC.key)
     assert.isDefined(nestedB)
     assert.isDefined(nestedC)
-    assert.deepEqual(nestedB?.parent?.key, model.exposes.find((e) => e.isRoot && e.entity.key === eA.key)?.key)
+    assert.deepEqual(nestedB?.parent?.key, findRootExposedEntity(model, eA.key)?.key)
     assert.deepEqual(nestedC?.parent?.key, nestedB?.key)
   })
 
@@ -157,12 +181,12 @@ test.group('ApiModel.exposeEntity()', () => {
     const model = new ApiModel()
     model.attachDataDomain(domain)
     model.exposeEntity({ key: eA.key }, { followAssociations: true })
-    const nestedB = model.exposes.find((e) => !e.isRoot && e.entity.key === eB.key)
-    const nestedC = model.exposes.find((e) => !e.isRoot && e.entity.key === eC.key)
+    const nestedB = findNonRootExposedEntity(model, eB.key)
+    const nestedC = findNonRootExposedEntity(model, eC.key)
     assert.isDefined(nestedB)
     assert.isDefined(nestedC)
-    assert.deepEqual(nestedB?.parent?.key, model.exposes.find((e) => e.isRoot && e.entity.key === eA.key)?.key)
-    assert.deepEqual(nestedC?.parent?.key, model.exposes.find((e) => e.isRoot && e.entity.key === eA.key)?.key)
+    assert.deepEqual(nestedB?.parent?.key, findRootExposedEntity(model, eA.key)?.key)
+    assert.deepEqual(nestedC?.parent?.key, findRootExposedEntity(model, eA.key)?.key)
   })
 
   test('respects maxDepth option (A -> B -> C -> D, maxDepth=2)', ({ assert }) => {
@@ -179,9 +203,9 @@ test.group('ApiModel.exposeEntity()', () => {
     const model = new ApiModel()
     model.attachDataDomain(domain)
     model.exposeEntity({ key: eA.key }, { followAssociations: true, maxDepth: 2 })
-    const nestedB = model.exposes.find((e) => !e.isRoot && e.entity.key === eB.key)
-    const nestedC = model.exposes.find((e) => !e.isRoot && e.entity.key === eC.key)
-    const nestedD = model.exposes.find((e) => !e.isRoot && e.entity.key === eD.key)
+    const nestedB = findNonRootExposedEntity(model, eB.key)
+    const nestedC = findNonRootExposedEntity(model, eC.key)
+    const nestedD = findNonRootExposedEntity(model, eD.key)
     assert.isDefined(nestedB)
     assert.isDefined(nestedC)
     assert.isUndefined(nestedD)

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

@@ -10,10 +10,10 @@ test.group('ApiModel.removeEntity()', () => {
     const model = new ApiModel()
     model.attachDataDomain(domain)
     const exposure = model.exposeEntity({ key: e1.key })
-    assert.lengthOf(model.exposes, 1)
+    assert.equal(model.exposes.size, 1)
 
     model.removeExposedEntity(exposure.key)
-    assert.lengthOf(model.exposes, 0)
+    assert.equal(model.exposes.size, 0)
   }).tags(['@modeling', '@api'])
 
   test('removes an entity and its nested children', ({ assert }) => {
@@ -28,13 +28,13 @@ test.group('ApiModel.removeEntity()', () => {
     model.attachDataDomain(domain)
     const rootExposure = model.exposeEntity({ key: eA.key }, { followAssociations: true })
     // Ensure nested exposure for B was created
-    const nestedB = model.exposes.find((e) => !e.isRoot && e.entity.key === eB.key)
+    const nestedB = Array.from(model.exposes.values()).find((e) => !e.isRoot && e.entity.key === eB.key)
     assert.isDefined(nestedB)
-    assert.isAbove(model.exposes.length, 1)
+    assert.isAbove(model.exposes.size, 1)
 
     // Remove root exposure for A and expect children to be removed as well
     model.removeExposedEntity(rootExposure.key)
-    assert.lengthOf(model.exposes, 0)
+    assert.equal(model.exposes.size, 0)
   }).tags(['@modeling', '@api'])
 
   test('throws error if entity does not exist', ({ assert }) => {
@@ -50,7 +50,7 @@ test.group('ApiModel.removeEntity()', () => {
       () => model.removeExposedEntity('non-existing-key'),
       'Exposed entity with key "non-existing-key" not found.'
     )
-    assert.lengthOf(model.exposes, 1, 'exposes count should remain unchanged')
+    assert.equal(model.exposes.size, 1, 'exposes count should remain unchanged')
   }).tags(['@modeling', '@api'])
 
   test('notifies change when an entity is removed', async ({ assert }) => {

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

@@ -1,7 +1,6 @@
 import { test } from '@japa/runner'
 import {
   DomainAssociation,
-  AmfShapes,
   DomainAssociationKind,
   Thing,
   AssociationBinding,
@@ -10,6 +9,7 @@ import {
   SemanticType,
   type OnDeleteRule,
 } from '../../../src/index.js'
+import { Shapes } from '@api-client/amf-core'
 
 test.group('DomainAssociation.createSchema()', () => {
   test('creates a valid schema with default values', ({ assert }) => {
@@ -58,7 +58,7 @@ test.group('DomainAssociation.createSchema()', () => {
   })
 
   test('creates a schema with provided schema', ({ assert }) => {
-    const schemaDefinition: AmfShapes.IApiAssociationShape = { linked: false }
+    const schemaDefinition: Shapes.IApiAssociationShape = { linked: false }
     const schema = DomainAssociation.createSchema({ schema: schemaDefinition })
     assert.deepEqual(schema.schema, schemaDefinition)
   })
@@ -88,7 +88,7 @@ test.group('DomainAssociation.createSchema()', () => {
   test('creates a schema with all properties', ({ assert }) => {
     const key = 'test-key'
     const info = { name: 'Test Association', description: 'Test description' }
-    const schemaDefinition: AmfShapes.IApiAssociationShape = { linked: false }
+    const schemaDefinition: Shapes.IApiAssociationShape = { linked: false }
     const multiple = true
     const required = true
     const bindings: AssociationBinding[] = [{ type: 'web', schema: { hidden: false } }]
@@ -144,7 +144,7 @@ test.group('DomainAssociation.createSchema()', () => {
   })
 
   test('creates a schema with cloned schema', ({ assert }) => {
-    const schemaDefinition: AmfShapes.IApiAssociationShape = { linked: false }
+    const schemaDefinition: Shapes.IApiAssociationShape = { linked: false }
     const schema = DomainAssociation.createSchema({ schema: schemaDefinition })
     assert.deepEqual(schema.schema, schemaDefinition)
     assert.notStrictEqual(schema.schema, schemaDefinition)
@@ -212,7 +212,7 @@ test.group('DomainAssociation.constructor()', () => {
   test('creates an instance with provided schema', ({ assert }) => {
     const dataDomain = new DataDomain()
     const parentKey = 'test-parent'
-    const schemaDefinition: AmfShapes.IApiAssociationShape = { linked: false }
+    const schemaDefinition: Shapes.IApiAssociationShape = { linked: false }
     const association = new DomainAssociation(dataDomain, parentKey, { schema: schemaDefinition })
     assert.deepEqual(association.schema, schemaDefinition)
   })
@@ -252,7 +252,7 @@ test.group('DomainAssociation.constructor()', () => {
     const parentKey = 'test-parent'
     const key = 'test-key'
     const info = { name: 'Test Association', description: 'Test description' }
-    const schemaDefinition: AmfShapes.IApiAssociationShape = { linked: false }
+    const schemaDefinition: Shapes.IApiAssociationShape = { linked: false }
     const multiple = true
     const required = true
     const bindings: AssociationBinding[] = [{ type: 'web', schema: { hidden: false } }]
@@ -316,7 +316,7 @@ test.group('DomainAssociation.constructor()', () => {
   test('creates an instance with cloned schema', ({ assert }) => {
     const dataDomain = new DataDomain()
     const parentKey = 'test-parent'
-    const schemaDefinition: AmfShapes.IApiAssociationShape = { linked: false }
+    const schemaDefinition: Shapes.IApiAssociationShape = { linked: false }
     const association = new DomainAssociation(dataDomain, parentKey, { schema: schemaDefinition })
     assert.deepEqual(association.schema, schemaDefinition)
     assert.notStrictEqual(association.schema, schemaDefinition)
@@ -390,7 +390,7 @@ test.group('DomainAssociation.toJSON()', () => {
   test('returns a JSON representation with provided schema', ({ assert }) => {
     const dataDomain = new DataDomain()
     const parentKey = 'test-parent'
-    const schemaDefinition: AmfShapes.IApiAssociationShape = { linked: false }
+    const schemaDefinition: Shapes.IApiAssociationShape = { linked: false }
     const association = new DomainAssociation(dataDomain, parentKey, { schema: schemaDefinition })
     const json = association.toJSON()
     assert.deepEqual(json.schema, schemaDefinition)
@@ -438,7 +438,7 @@ test.group('DomainAssociation.toJSON()', () => {
     const parentKey = 'test-parent'
     const key = 'test-key'
     const info = { name: 'Test Association', description: 'Test description' }
-    const schemaDefinition: AmfShapes.IApiAssociationShape = { linked: false }
+    const schemaDefinition: Shapes.IApiAssociationShape = { linked: false }
     const multiple = true
     const required = true
     const bindings: AssociationBinding[] = [{ type: 'web', schema: { hidden: false } }]
@@ -527,7 +527,7 @@ test.group('DomainAssociation.toJSON()', () => {
   test('returns a JSON representation with cloned schema', ({ assert }) => {
     const dataDomain = new DataDomain()
     const parentKey = 'test-parent'
-    const schemaDefinition: AmfShapes.IApiAssociationShape = { linked: false }
+    const schemaDefinition: Shapes.IApiAssociationShape = { linked: false }
     const association = new DomainAssociation(dataDomain, parentKey, { schema: schemaDefinition })
     const json = association.toJSON()
     assert.deepEqual(json.schema, schemaDefinition)
@@ -538,7 +538,7 @@ test.group('DomainAssociation.toJSON()', () => {
     const dataDomain = new DataDomain()
     const parentKey = 'test-parent'
     const association = new DomainAssociation(dataDomain, parentKey)
-    const schemaDefinition: AmfShapes.IApiAssociationShape = { linked: false }
+    const schemaDefinition: Shapes.IApiAssociationShape = { linked: false }
     association.schema = schemaDefinition
     const json = association.toJSON()
     assert.deepEqual(json.schema, schemaDefinition)
@@ -672,7 +672,7 @@ test.group('DomainAssociation.ensureSchema()', () => {
 
   test('returns the existing schema object if it exists', ({ assert }) => {
     const dataDomain = new DataDomain()
-    const schemaDefinition: AmfShapes.IApiAssociationShape = { linked: false }
+    const schemaDefinition: Shapes.IApiAssociationShape = { linked: false }
     const association = new DomainAssociation(dataDomain, 'test-parent', { schema: schemaDefinition })
     const originalSchema = association.schema
     const schema = association.ensureSchema()
@@ -682,7 +682,7 @@ test.group('DomainAssociation.ensureSchema()', () => {
 
   test('does not modify the existing schema object', ({ assert }) => {
     const dataDomain = new DataDomain()
-    const schemaDefinition: AmfShapes.IApiAssociationShape = { linked: false }
+    const schemaDefinition: Shapes.IApiAssociationShape = { linked: false }
     const association = new DomainAssociation(dataDomain, 'test-parent', { schema: schemaDefinition })
     const originalSchema = association.schema
     association.ensureSchema()