@api-client/core 0.20.5 → 0.20.7

package/src/modeling/helpers/endpointHelpers.ts

@@ -1,7 +1,54 @@
-export function paramNameFor(entityKeyLocal: string): string {
-  const parts = entityKeyLocal.split(':')
-  const key = parts[parts.length - 1]
-  return `${key}Id`
+import { Exception } from '../../exceptions/exception.js'
+
+/**
+ * Generates a semantic parameter name for an entity.
+ * It converts snake_case, kebab-case, or PascalCase to camelCase and appends 'Id'.
+ * @param entityName The entity name (e.g. from entity.info.name)
+ */
+export function paramNameFor(entityName: string): string {
+  if (!entityName) {
+    throw new Exception('Cannot generate parameter name from an empty string.', {
+      code: 'E_INVALID_PARAM_NAME',
+      help: 'The entity name used for path parameter generation is empty.',
+    })
+  }
+
+  // Add a space between lowercase and uppercase letters to handle camelCase/PascalCase
+  let withSpaces = entityName.replace(/([a-z])([A-Z])/g, '$1 $2')
+  // Also split consecutive uppercase letters if followed by a lowercase (e.g. XMLHttp -> XML Http)
+  withSpaces = withSpaces.replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2')
+
+  // Replace all non-alphanumeric characters with spaces
+  const cleanStr = withSpaces.replace(/[^a-zA-Z0-9]/g, ' ')
+
+  // Split by spaces and filter out empty strings
+  const words = cleanStr.split(/\s+/).filter(Boolean)
+
+  if (words.length === 0) {
+    throw new Exception(`Cannot generate a valid parameter name from "${entityName}".`, {
+      code: 'E_INVALID_PARAM_NAME',
+      help: 'The entity name must contain alphanumeric characters to generate a path parameter.',
+    })
+  }
+
+  // CamelCase: lower first word, Capitalize subsequent words
+  const camelCased = words
+    .map((word, index) => {
+      const lower = word.toLowerCase()
+      if (index === 0) {
+        return lower
+      }
+      return lower.charAt(0).toUpperCase() + lower.slice(1)
+    })
+    .join('')
+
+  // Ensure it starts with a letter or underscore
+  let param = camelCased
+  if (/^[0-9]/.test(param)) {
+    param = '_' + param
+  }
+
+  return `${param}Id`
 }
 
 /**

package/src/modeling/types.ts

@@ -974,3 +974,19 @@ export interface AssociationSchema {
    */
   unionType?: 'allOf' | 'anyOf' | 'oneOf' | 'not'
 }
+
+/**
+ * Options used when initializing a DataDomain.
+ */
+export interface DataDomainOptions {
+  /**
+   * The mode used during deserialization to control error tolerance.
+   * 'strict' throws errors on invalid references. 'lenient' collects them.
+   */
+  mode?: DeserializationMode
+  /**
+   * Whether the DataDomain is in read-only mode, which makes it immutable
+   * and enables internal caching optimizations.
+   */
+  readOnly?: boolean
+}

package/src/modeling/validation/api_model_rules.ts

@@ -581,6 +581,25 @@ export function validateExposedEntity(exposure: ExposedEntity, apiModel: ApiMode
     }
   }
 
+  // Branch Path Parameter Collision
+  const absoluteResourcePath = exposure.getAbsoluteResourcePath()
+  if (absoluteResourcePath) {
+    const params = [...absoluteResourcePath.matchAll(/\{([^}]+)\}/g)].map((m) => m[1])
+    const uniqueParams = new Set(params)
+    if (uniqueParams.size !== params.length) {
+      const duplicates = params.filter((item, index) => params.indexOf(item) !== index)
+      const duplicateParam = duplicates[0]
+      issues.push({
+        code: createCode('EXPOSURE', 'DUPLICATE_PATH_PARAMETER'),
+        message: `[${entityName}]: The path parameter "{${duplicateParam}}" is duplicated in the resource path hierarchy.`,
+        suggestion:
+          'Change the parameter name in either this resource or its ancestor to ensure unique parameter names.',
+        severity: 'error',
+        context: { ...context, property: 'resourcePath' },
+      })
+    }
+  }
+
   // Minimum Actions
   if (!exposure.actions || exposure.actions.length === 0) {
     issues.push({

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

@@ -34,6 +34,20 @@ test.group('RuntimeApiModel', () => {
     assert.deepEqual(runtimeModel.toJSON().routingMap, schema.routingMap)
   }).tags(['@modeling', '@runtime'])
 
+  test('throws error if routingMap is missing', ({ assert }) => {
+    const domain = new DataDomain({ info: { version: '1.0.0' } })
+    const schema = {
+      key: 'api-1',
+      info: { name: 'Test API' },
+      // routingMap is intentionally missing
+    }
+
+    assert.throws(
+      () => new RuntimeApiModel(schema as any, domain.toJSON()),
+      'The runtime API model must have a routing map.'
+    )
+  }).tags(['@modeling', '@runtime'])
+
   test('resolves path with matchit', ({ assert }) => {
     const domain = new DataDomain({ info: { version: '1.0.0' } })
     const model = domain.addModel({ info: { name: 'Test Model' } })
@@ -179,6 +193,97 @@ test.group('RuntimeApiModel', () => {
     assert.equal(runtimeModel.sessionProperties.get(prop2.key)?.key, prop2.key)
   }).tags(['@modeling', '@runtime'])
 
+  test('precomputes semanticPropertiesCache correctly', ({ assert }) => {
+    const domain = new DataDomain({ info: { version: '1.0.0' } })
+    const modelNode = domain.addModel({ key: 'users' })
+    const userEntity = modelNode.addEntity({ info: { name: 'User' } })
+    const prop1 = userEntity.addProperty({ info: { name: 'Prop1' }, semantics: [{ id: SemanticType.Password }] })
+    const prop2 = userEntity.addProperty({ info: { name: 'Prop2' }, semantics: [{ id: SemanticType.Username }] })
+    const prop3 = userEntity.addProperty({ info: { name: 'Prop3' } })
+
+    const schema = {
+      key: 'api-1',
+      info: { name: 'Test API' },
+      exposes: [
+        {
+          key: 'expose-1',
+          entity: { key: userEntity.key, domain: domain.key },
+          actions: [],
+        },
+      ],
+      routingMap: {},
+    }
+
+    const runtimeModel = new RuntimeApiModel(schema as any, domain.toJSON())
+
+    assert.equal(runtimeModel.semanticPropertiesCache.size, 1)
+
+    // Convert keys iterator to array to find the matched entity reference
+    const cachedEntities = Array.from(runtimeModel.semanticPropertiesCache.keys())
+    assert.equal(cachedEntities.length, 1)
+    assert.equal(cachedEntities[0].key, userEntity.key)
+
+    const cachedProps = runtimeModel.semanticPropertiesCache.get(cachedEntities[0])
+    assert.isDefined(cachedProps)
+    assert.equal(cachedProps?.length, 2)
+    assert.equal(cachedProps?.[0].key, prop1.key)
+    assert.equal(cachedProps?.[1].key, prop2.key)
+  }).tags(['@modeling', '@runtime'])
+
+  test('precomputes semanticAssociationsCache correctly', ({ assert }) => {
+    const domain = new DataDomain({ info: { version: '1.0.0' } })
+    const modelNode = domain.addModel({ key: 'users' })
+    const userEntity = modelNode.addEntity({ info: { name: 'User' } })
+
+    const assoc1 = userEntity.addAssociation({ info: { name: 'Assoc1' }, targets: [] })
+    assoc1.semantics = [{ id: SemanticType.Tags }]
+
+    const assoc2 = userEntity.addAssociation({ info: { name: 'Assoc2' }, targets: [] })
+    assoc2.semantics = [{ id: SemanticType.Categories }]
+
+    const assoc3 = userEntity.addAssociation({ info: { name: 'Assoc3' }, targets: [] })
+
+    const schema = {
+      key: 'api-1',
+      info: { name: 'Test API' },
+      exposes: [
+        {
+          key: 'expose-1',
+          entity: { key: userEntity.key, domain: domain.key },
+          actions: [],
+        },
+      ],
+      routingMap: {},
+    }
+
+    const runtimeModel = new RuntimeApiModel(schema as any, domain.toJSON())
+
+    assert.equal(runtimeModel.semanticAssociationsCache.size, 1)
+
+    // Convert keys iterator to array to find the matched entity reference
+    const cachedEntities = Array.from(runtimeModel.semanticAssociationsCache.keys())
+    assert.equal(cachedEntities.length, 1)
+    assert.equal(cachedEntities[0].key, userEntity.key)
+
+    const cachedAssocs = runtimeModel.semanticAssociationsCache.get(cachedEntities[0])
+    assert.isDefined(cachedAssocs)
+    assert.equal(cachedAssocs?.length, 2)
+    assert.equal(cachedAssocs?.[0].key, assoc1.key)
+    assert.equal(cachedAssocs?.[1].key, assoc2.key)
+
+    // Test getAssociationsBySemantic
+    const tagsAssocs = runtimeModel.getAssociationsBySemantic(cachedEntities[0], SemanticType.Tags)
+    assert.lengthOf(tagsAssocs, 1)
+    assert.equal(tagsAssocs[0].key, assoc1.key)
+
+    const categoriesAssocs = runtimeModel.getAssociationsBySemantic(cachedEntities[0], SemanticType.Categories)
+    assert.lengthOf(categoriesAssocs, 1)
+    assert.equal(categoriesAssocs[0].key, assoc2.key)
+
+    const emptyAssocs = runtimeModel.getAssociationsBySemantic(cachedEntities[0], SemanticType.ResourceOwnerIdentifier)
+    assert.lengthOf(emptyAssocs, 0)
+  }).tags(['@modeling', '@runtime', '@semantic'])
+
   test('throws exception if session property is missing from domain', ({ assert }) => {
     const domain = new DataDomain({ info: { version: '1.0.0' } })
     const modelNode = domain.addModel({ key: 'users' })
@@ -220,7 +325,7 @@ test.group('RuntimeApiModel', () => {
       { key: 'api-1', accessRule: [{ type: 'allowAuthenticated', mandatory: true }] },
       domain
     )
-    const runtimeModel = new RuntimeApiModel(baseModel.toJSON() as any, domain.toJSON())
+    const runtimeModel = new RuntimeApiModel({ ...baseModel.toJSON(), routingMap: {} } as any, domain.toJSON())
 
     const mockAction = {
       exposure: { accessRule: [], parent: undefined },
@@ -236,7 +341,7 @@ test.group('RuntimeApiModel', () => {
   test('getEffectiveRules - defaults to preFetch phase if none specified', async ({ assert }) => {
     const domain = new DataDomain({ info: { version: '1.0.0' } })
     const baseModel = new ApiModel({ key: 'api-1' }, domain)
-    const runtimeModel = new RuntimeApiModel(baseModel.toJSON() as any, domain.toJSON())
+    const runtimeModel = new RuntimeApiModel({ ...baseModel.toJSON(), routingMap: {} } as any, domain.toJSON())
 
     const mockAction = {
       exposure: {
@@ -254,7 +359,7 @@ test.group('RuntimeApiModel', () => {
   test('getEffectiveRules - orders from most specific to most general', async ({ assert }) => {
     const domain = new DataDomain({ info: { version: '1.0.0' } })
     const baseModel = new ApiModel({ accessRule: [{ type: 'allowAuthenticated' }] }, domain)
-    const runtimeModel = new RuntimeApiModel(baseModel.toJSON() as any, domain.toJSON())
+    const runtimeModel = new RuntimeApiModel({ ...baseModel.toJSON(), routingMap: {} } as any, domain.toJSON())
 
     const mockAction = {
       exposure: {

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

@@ -575,3 +575,59 @@ test.group('DataDomain.moveEntity()', () => {
     assert.isTrue(dataDomain.graph.hasNode(assoc.key))
   }).tags(['@modeling', '@entity', '@move'])
 })
+
+test.group('DomainEntity.listAllSemantics()', () => {
+  test('returns semantics from entity and its parents', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const parentEntity = model.addEntity({ key: 'parent' })
+    const childEntity = model.addEntity({ key: 'child' })
+
+    parentEntity.addSemantic({ id: SemanticType.User })
+    childEntity.addSemantic({ id: SemanticType.Address })
+
+    childEntity.addParent(parentEntity.key)
+
+    const inherited = childEntity.listAllSemantics()
+    assert.lengthOf(inherited, 2)
+    const semanticIds = inherited.map((s) => s.id).sort()
+    assert.deepEqual(semanticIds, [SemanticType.Address, SemanticType.User].sort())
+  }).tags(['@modeling', '@entity', '@semantic'])
+
+  test('overrides parent semantics with the same id', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const parentEntity = model.addEntity({ key: 'parent' })
+    const childEntity = model.addEntity({ key: 'child' })
+
+    parentEntity.addSemantic({ id: SemanticType.User, config: { value: 'parent-val' } })
+    childEntity.addSemantic({ id: SemanticType.User, config: { value: 'child-val' } })
+
+    childEntity.addParent(parentEntity.key)
+
+    const inherited = childEntity.listAllSemantics()
+    assert.lengthOf(inherited, 1)
+    assert.deepEqual(inherited[0].config, { value: 'child-val' })
+  }).tags(['@modeling', '@entity', '@semantic'])
+
+  test('uses cached inherited semantics when domain is readOnly', ({ assert }) => {
+    const dataDomain = new DataDomain(undefined, [], { readOnly: true })
+    const model = dataDomain.addModel()
+    const parentEntity = model.addEntity({ key: 'parent' })
+    const childEntity = model.addEntity({ key: 'child' })
+
+    parentEntity.addSemantic({ id: SemanticType.User })
+
+    childEntity.addParent(parentEntity.key)
+
+    const inherited1 = childEntity.listAllSemantics()
+    assert.lengthOf(inherited1, 1)
+
+    // Add another semantic bypassing normal immutable logic for test purposes
+    parentEntity.addSemantic({ id: SemanticType.Address })
+
+    const inherited2 = childEntity.listAllSemantics()
+    // Should still be length 1 due to the cache
+    assert.lengthOf(inherited2, 1)
+  }).tags(['@modeling', '@entity', '@semantic', '@readonly'])
+})

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

@@ -583,7 +583,7 @@ test.group('DataDomain Lenient Mode Deserialization', () => {
     }
 
     // Should not throw in lenient mode
-    const restored = new DataDomain(corruptedSerialized, [], 'lenient')
+    const restored = new DataDomain(corruptedSerialized, [], { mode: 'lenient' })
 
     // Should have issues recorded
     assert.isAbove(restored.issues.length, 0)
@@ -611,7 +611,7 @@ test.group('DataDomain Lenient Mode Deserialization', () => {
     }
 
     // Should not throw in lenient mode
-    const restored = new DataDomain(corruptedSerialized, [], 'lenient')
+    const restored = new DataDomain(corruptedSerialized, [], { mode: 'lenient' })
 
     // Should have issues recorded
     assert.isAbove(restored.issues.length, 0)
@@ -641,7 +641,7 @@ test.group('DataDomain Lenient Mode Deserialization', () => {
     }
 
     // Should not throw in lenient mode
-    const restored = new DataDomain(corruptedSerialized, [], 'lenient')
+    const restored = new DataDomain(corruptedSerialized, [], { mode: 'lenient' })
 
     // Should have issues recorded
     assert.isAbove(restored.issues.length, 0)
@@ -680,7 +680,7 @@ test.group('DataDomain Lenient Mode Deserialization', () => {
     }
 
     // Should not throw in lenient mode
-    const restored = new DataDomain(corruptedSerialized, [], 'lenient')
+    const restored = new DataDomain(corruptedSerialized, [], { mode: 'lenient' })
 
     // Should have issues recorded about missing parent node
     assert.isAbove(restored.issues.length, 0)
@@ -706,7 +706,7 @@ test.group('DataDomain Lenient Mode Deserialization', () => {
     const serialized = domain.toJSON()
 
     // Deserialize without providing the foreign dependency
-    const restored = new DataDomain(serialized, [], 'lenient')
+    const restored = new DataDomain(serialized, [], { mode: 'lenient' })
 
     // Should have issues recorded about missing dependency
     assert.isAbove(restored.issues.length, 0)
@@ -742,7 +742,7 @@ test.group('DataDomain Lenient Mode Deserialization', () => {
     }
 
     // Should not throw in lenient mode
-    const restored = new DataDomain(corruptedSerialized, [], 'lenient')
+    const restored = new DataDomain(corruptedSerialized, [], { mode: 'lenient' })
 
     // Should have issues recorded
     assert.isAbove(restored.issues.length, 0)
@@ -797,7 +797,7 @@ test.group('DataDomain Lenient Mode Deserialization', () => {
     }
 
     // Should not throw in lenient mode
-    const restored = new DataDomain(corruptedSerialized, [], 'lenient')
+    const restored = new DataDomain(corruptedSerialized, [], { mode: 'lenient' })
 
     // Should have multiple issues recorded
     assert.isAtLeast(restored.issues.length, 3)
@@ -823,7 +823,7 @@ test.group('DataDomain Lenient Mode Deserialization', () => {
     e1.addProperty({ type: 'string' })
 
     const serialized = domain.toJSON()
-    const restored = new DataDomain(serialized, [], 'strict')
+    const restored = new DataDomain(serialized, [], { mode: 'strict' })
 
     // Should have no issues in strict mode for valid data
     assert.equal(restored.issues.length, 0)
@@ -855,11 +855,11 @@ test.group('DataDomain Lenient Mode Deserialization', () => {
 
     // Should throw in strict mode
     assert.throws(() => {
-      new DataDomain(corruptedSerialized, [], 'strict')
+      new DataDomain(corruptedSerialized, [], { mode: 'strict' })
     })
 
     // Should not throw in lenient mode
-    const restored = new DataDomain(corruptedSerialized, [], 'lenient')
+    const restored = new DataDomain(corruptedSerialized, [], { mode: 'lenient' })
     assert.isAbove(restored.issues.length, 0)
   }).tags(['@modeling', '@serialization', '@lenient', '@strict'])
 
@@ -879,7 +879,7 @@ test.group('DataDomain Lenient Mode Deserialization', () => {
       )
     }
 
-    const restored = new DataDomain(corruptedSerialized, [], 'lenient')
+    const restored = new DataDomain(corruptedSerialized, [], { mode: 'lenient' })
 
     // Should have detailed issue information
     assert.isAbove(restored.issues.length, 0)

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

@@ -328,3 +328,66 @@ test.group('DomainEntity.hasAssociations()', () => {
     assert.isFalse(entity.hasAssociations())
   })
 })
+
+test.group('DomainEntity.withInheritedAssociations()', () => {
+  test('returns associations from entity and its parents', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const parentEntity = model.addEntity({ key: 'parent' })
+    const childEntity = model.addEntity({ key: 'child' })
+
+    const parentAssoc = parentEntity.addAssociation()
+    parentAssoc.info.name = 'parentAssoc'
+
+    const childAssoc = childEntity.addAssociation()
+    childAssoc.info.name = 'childAssoc'
+
+    childEntity.addParent(parentEntity.key)
+
+    const inherited = Array.from(childEntity.withInheritedAssociations())
+    assert.lengthOf(inherited, 2)
+    assert.deepEqual(inherited.map((a) => a.info.name).sort(), ['childAssoc', 'parentAssoc'])
+  })
+
+  test('overrides parent association with the same name', ({ assert }) => {
+    const dataDomain = new DataDomain()
+    const model = dataDomain.addModel()
+    const parentEntity = model.addEntity({ key: 'parent' })
+    const childEntity = model.addEntity({ key: 'child' })
+
+    const parentAssoc = parentEntity.addAssociation()
+    parentAssoc.info.name = 'assoc'
+
+    const childAssoc = childEntity.addAssociation()
+    childAssoc.info.name = 'assoc'
+
+    childEntity.addParent(parentEntity.key)
+
+    const inherited = Array.from(childEntity.withInheritedAssociations())
+    assert.lengthOf(inherited, 1)
+    assert.equal(inherited[0].key, childAssoc.key)
+  })
+
+  test('uses cached inherited associations when domain is readOnly', ({ assert }) => {
+    const dataDomain = new DataDomain(undefined, [], { readOnly: true })
+    const model = dataDomain.addModel()
+    const parentEntity = model.addEntity({ key: 'parent' })
+    const childEntity = model.addEntity({ key: 'child' })
+
+    const parentAssoc = parentEntity.addAssociation()
+    parentAssoc.info.name = 'parentAssoc'
+
+    childEntity.addParent(parentEntity.key)
+
+    const inherited1 = Array.from(childEntity.withInheritedAssociations())
+    assert.lengthOf(inherited1, 1)
+
+    // Add another association bypassing normal immutability rules for test
+    const anotherAssoc = parentEntity.addAssociation()
+    anotherAssoc.info.name = 'anotherAssoc'
+
+    const inherited2 = Array.from(childEntity.withInheritedAssociations())
+    // Should still be length 1 because of the readOnly cache
+    assert.lengthOf(inherited2, 1)
+  })
+})

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

@@ -18,6 +18,41 @@ test.group('ExposedEntity', () => {
     assert.equal(ex.resourcePath, '/products/{customId}')
   }).tags(['@modeling', '@exposed-entity'])
 
+  test('setCollectionPath throws if semantic param cannot be generated', ({ assert }) => {
+    const model = new ApiModel()
+    const ex = new ExposedEntity(model, {
+      entity: { key: 'missing' },
+      hasCollection: true,
+      collectionPath: '/items',
+      resourcePath: '/', // Forces param generation
+    })
+
+    assert.throws(() => ex.setCollectionPath('products'), 'Cannot generate a semantic parameter name')
+  }).tags(['@modeling', '@exposed-entity'])
+
+  test('setCollectionPath generates semantic param from domain entity', ({ assert }) => {
+    const domain = new DataDomain()
+    domain.info.version = '1.0.0'
+    const dm = domain.addModel()
+    const entity = domain.addEntity(dm.key)
+    entity.info.name = 'user_post'
+
+    const model = new ApiModel()
+    model.attachDataDomain(domain)
+
+    const ex = new ExposedEntity(model, {
+      entity: { key: entity.key },
+      hasCollection: true,
+      collectionPath: '/items',
+      resourcePath: '/', // Forces param generation
+    })
+
+    ex.setCollectionPath('user-posts')
+
+    assert.equal(ex.collectionPath, '/user-posts')
+    assert.equal(ex.resourcePath, '/user-posts/{userPostId}')
+  }).tags(['@modeling', '@exposed-entity'])
+
   test('setResourcePath with collection allows only parameter name change', ({ assert }) => {
     const model = new ApiModel()
     const ex = new ExposedEntity(model, {
@@ -104,6 +139,66 @@ test.group('ExposedEntity', () => {
     assert.equal(grandEx.getAbsoluteResourcePath(), '/users/{userId}/posts/{postId}/details')
   }).tags(['@modeling', '@exposed-entity'])
 
+  test('rejects branch collision when modifying collection path', ({ assert }) => {
+    const model = new ApiModel()
+    const rootSchema: Partial<ExposedEntitySchema> = {
+      key: 'root',
+      entity: { key: 'user' },
+      hasCollection: true,
+      collectionPath: '/users',
+      resourcePath: '/users/{userId}',
+      isRoot: true,
+    }
+    const childSchema: Partial<ExposedEntitySchema> = {
+      key: 'child',
+      entity: { key: 'post' },
+      hasCollection: true,
+      collectionPath: '/posts',
+      resourcePath: '/posts/{postId}',
+      parent: { key: 'root', association: { key: 'toPosts' } },
+    }
+
+    const rootEx = new ExposedEntity(model, rootSchema)
+    const childEx = new ExposedEntity(model, childSchema)
+    model.exposes = new Map([
+      [rootEx.key, rootEx],
+      [childEx.key, childEx],
+    ])
+
+    // Modifying child's collection path to reuse 'userId'
+    assert.throws(() => childEx.setResourcePath('/posts/{userId}'), 'Duplicate path parameter "{userId}" detected')
+  }).tags(['@modeling', '@exposed-entity', '@collision'])
+
+  test('rejects branch collision from descendant when modifying ancestor resource path', ({ assert }) => {
+    const model = new ApiModel()
+    const rootSchema: Partial<ExposedEntitySchema> = {
+      key: 'root',
+      entity: { key: 'user' },
+      hasCollection: true,
+      collectionPath: '/users',
+      resourcePath: '/users/{userId}',
+      isRoot: true,
+    }
+    const childSchema: Partial<ExposedEntitySchema> = {
+      key: 'child',
+      entity: { key: 'post' },
+      hasCollection: true,
+      collectionPath: '/posts',
+      resourcePath: '/posts/{postId}',
+      parent: { key: 'root', association: { key: 'toPosts' } },
+    }
+
+    const rootEx = new ExposedEntity(model, rootSchema)
+    const childEx = new ExposedEntity(model, childSchema)
+    model.exposes = new Map([
+      [rootEx.key, rootEx],
+      [childEx.key, childEx],
+    ])
+
+    // Modifying root's resource path to 'postId' which collides with child
+    assert.throws(() => rootEx.setResourcePath('/users/{postId}'), 'Duplicate path parameter "{postId}" detected')
+  }).tags(['@modeling', '@exposed-entity', '@collision'])
+
   test('ApiModel notifies when nested ExposedEntity collection path changes', async ({ assert }) => {
     const model = new ApiModel({
       exposes: [