@api-client/core 0.18.48 → 0.18.49

package/data/models/example-generator-api.json

@@ -42062,9 +42062,6 @@
 "@id": "#209"
 },
 {
-"@id": "#206"
-},
-{
 "@id": "#191"
 },
 {
@@ -42080,6 +42077,9 @@
 "@id": "#203"
 },
 {
+"@id": "#206"
+},
+{
 "@id": "#209"
 }
 ],
@@ -43436,7 +43436,7 @@
 "doc:ExternalDomainElement",
 "doc:DomainElement"
 ],
-"doc:raw": "addressType: 'REGISTERED-OFFICE-ADDRESS'\nstreetName: 'UITBREIDINGSTRAAT'\nhouseNumber: '84'\nhouseNumberAddition: '/1'\npostalCode: '2600'\ncity: 'BERCHEM (ANTWERPEN)'\ncountry: 'Belgium'\ncountryCode: 'BE'\nfullFormatedAddress: \"UITBREIDINGSTRAAT 84 /1, 2600 BERCHEM (ANTWERPEN), BELIUM\"\n",
+"doc:raw": "countryCode: \"BE\"\ngraydonEnterpriseId: 1057155523\nregistrationId: \"0422319093\"\nvatNumber: \"BE0422319093\"\ngraydonCompanyId: \"0422319093\"\nisBranchOffice: false\n",
 "core:mediaType": "application/yaml",
 "sourcemaps:sources": [
 {
@@ -43457,7 +43457,7 @@
 "doc:ExternalDomainElement",
 "doc:DomainElement"
 ],
-"doc:raw": "code: '5'\ndescription: 'Limited company'\n",
+"doc:raw": "addressType: 'REGISTERED-OFFICE-ADDRESS'\nstreetName: 'UITBREIDINGSTRAAT'\nhouseNumber: '84'\nhouseNumberAddition: '/1'\npostalCode: '2600'\ncity: 'BERCHEM (ANTWERPEN)'\ncountry: 'Belgium'\ncountryCode: 'BE'\nfullFormatedAddress: \"UITBREIDINGSTRAAT 84 /1, 2600 BERCHEM (ANTWERPEN), BELIUM\"\n",
 "core:mediaType": "application/yaml",
 "sourcemaps:sources": [
 {
@@ -43478,7 +43478,7 @@
 "doc:ExternalDomainElement",
 "doc:DomainElement"
 ],
-"doc:raw": "class: '3'\ndescription: '150 - 300'\nnumberOfFte: 5500\nnumberOfEmployees: 5232\n",
+"doc:raw": "code: '5'\ndescription: 'Limited company'\n",
 "core:mediaType": "application/yaml",
 "sourcemaps:sources": [
 {
@@ -43499,7 +43499,7 @@
 "doc:ExternalDomainElement",
 "doc:DomainElement"
 ],
-"doc:raw": "code: 'J'\ndescription: 'Information and communication'\n",
+"doc:raw": "class: '3'\ndescription: '150 - 300'\nnumberOfFte: 5500\nnumberOfEmployees: 5232\n",
 "core:mediaType": "application/yaml",
 "sourcemaps:sources": [
 {
@@ -43520,7 +43520,7 @@
 "doc:ExternalDomainElement",
 "doc:DomainElement"
 ],
-"doc:raw": "code: '7487'\ndescription: 'Financial and insurance activities'\ntype: \"PRIMARY\"\nclassificationCode: 'BE_NACEBEL2008'\nactivityGroupCode: 'ABCDE'\n",
+"doc:raw": "code: 'J'\ndescription: 'Information and communication'\n",
 "core:mediaType": "application/yaml",
 "sourcemaps:sources": [
 {
@@ -43541,7 +43541,7 @@
 "doc:ExternalDomainElement",
 "doc:DomainElement"
 ],
-"doc:raw": "countryCode: \"BE\"\ngraydonEnterpriseId: 1057155523\nregistrationId: \"0422319093\"\nvatNumber: \"BE0422319093\"\ngraydonCompanyId: \"0422319093\"\nisBranchOffice: false\n",
+"doc:raw": "code: '7487'\ndescription: 'Financial and insurance activities'\ntype: \"PRIMARY\"\nclassificationCode: 'BE_NACEBEL2008'\nactivityGroupCode: 'ABCDE'\n",
 "core:mediaType": "application/yaml",
 "sourcemaps:sources": [
 {
@@ -44756,32 +44756,32 @@
 {
 "@id": "#193/source-map/lexical/element_0",
 "sourcemaps:element": "amf://id#193",
-"sourcemaps:value": "[(1,0)-(10,0)]"
+"sourcemaps:value": "[(1,0)-(7,0)]"
 },
 {
 "@id": "#196/source-map/lexical/element_0",
 "sourcemaps:element": "amf://id#196",
-"sourcemaps:value": "[(1,0)-(3,0)]"
+"sourcemaps:value": "[(1,0)-(10,0)]"
 },
 {
 "@id": "#199/source-map/lexical/element_0",
 "sourcemaps:element": "amf://id#199",
-"sourcemaps:value": "[(1,0)-(5,0)]"
+"sourcemaps:value": "[(1,0)-(3,0)]"
 },
 {
 "@id": "#202/source-map/lexical/element_0",
 "sourcemaps:element": "amf://id#202",
-"sourcemaps:value": "[(1,0)-(3,0)]"
+"sourcemaps:value": "[(1,0)-(5,0)]"
 },
 {
 "@id": "#205/source-map/lexical/element_0",
 "sourcemaps:element": "amf://id#205",
-"sourcemaps:value": "[(1,0)-(6,0)]"
+"sourcemaps:value": "[(1,0)-(3,0)]"
 },
 {
 "@id": "#208/source-map/lexical/element_0",
 "sourcemaps:element": "amf://id#208",
-"sourcemaps:value": "[(1,0)-(7,0)]"
+"sourcemaps:value": "[(1,0)-(6,0)]"
 },
 {
 "@id": "#223/source-map/lexical/element_0",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@api-client/core",
   "description": "The API Client's core client library. Works in NodeJS and in a ES enabled browser.",
-  "version": "0.18.48",
+  "version": "0.18.49",
   "license": "Apache-2.0",
   "exports": {
     "./browser.js": {
@@ -99,7 +99,7 @@
     "chalk": "^5.4.1",
     "console-table-printer": "^2.11.2",
     "dompurify": "^3.2.6",
-    "jsdom": "^27.0.0",
+    "jsdom": "^28.0.0",
     "nanoid": "^5.1.5",
     "tslog": "^4.9.3",
     "ws": "^8.12.0",

package/src/modeling/ApiModel.ts

@@ -280,6 +280,16 @@ export class ApiModel extends DependentModel {
     } else if (domain) {
       throw new Error(`Invalid domain provided. Expected a DataDomain instance or schema.`)
     }
+    // Note that since we're using the `DependentModel` class, but the API Model can have only one dependency,
+    // we keep the reference to the data domain under the `dependencyList` property.
+    // It is all handled by the parent class `DependentModel`. This way we simplify the dependency management (loading)
+    // process when the API model is loaded from the API.
+    if (domain) {
+      if (!domain.info.version) {
+        throw new Error(`Domain ${domain.key} must have a version.`)
+      }
+      init.dependencyList = [{ key: domain.key, version: domain.info.version }]
+    }
     super(init.dependencyList, instances)
     this.kind = init.kind
     this.key = init.key
@@ -380,6 +390,12 @@ export class ApiModel extends DependentModel {
   /**
    * Exposes a new entity in the API model.
    * If the entity already exists, it returns the existing one.
+   *
+   * The logic regarding exposing an entity:
+   * - If the entity is already exposed as a root entity, it returns the existing one.
+   * - If the entity has an association, we expose that entity as a nested entity (by setting the parent property).
+   * - If the associated entity is already exposed as a root entity, we do not follow the association.
+   *
    * @param entity The entity key and domain to expose.
    * @returns The exposed entity.
    */
@@ -403,8 +419,18 @@ export class ApiModel extends DependentModel {
     }
     const name = domainEntity.info.name || ''
     const segment = pluralize(name.toLocaleLowerCase())
-    const relativeCollectionPath = `/${segment}`
-    const relativeResourcePath = `/${segment}/{id}`
+    let relativeCollectionPath = `/${segment}`
+    let relativeResourcePath = `/${segment}/{id}`
+
+    // Check for root path collision and resolve by appending a number
+    let counter = 1
+    const originalCollectionPath = relativeCollectionPath
+    while (this.exposes.some((e) => e.isRoot && e.collectionPath === relativeCollectionPath)) {
+      relativeCollectionPath = `${originalCollectionPath}-${counter}`
+      relativeResourcePath = `${relativeCollectionPath}/{id}`
+      counter++
+    }
+
     const newEntity: ExposedEntitySchema = {
       kind: ExposedEntityKind,
       key: nanoid(),
@@ -444,12 +470,7 @@ export class ApiModel extends DependentModel {
       return
     }
     const maxDepth = options.maxDepth ?? 6
-    const visited = new Set<string>()
-    // Add parent entity's key to the visited set so we won't skip it when traversing
-    // associations.
-    visited.add(createDomainKey(parentExposure.entity))
-
-    const follow = (currentEntity: AssociationTarget, parentKey: string, depth: number) => {
+    const follow = (currentEntity: AssociationTarget, parentKey: string, depth: number, currentPath: string[]) => {
       // Find the domain entity
       const domainEntity = domain.findEntity(currentEntity.key, currentEntity.domain)
       if (!domainEntity) return
@@ -462,24 +483,45 @@ export class ApiModel extends DependentModel {
             continue
           }
 
-          // Create unique identifier for circular detection
-          const visitKey = createDomainKey(target)
-          if (visited.has(visitKey)) {
-            continue // Skip circular references
+          const targetKeys = createDomainKey(target)
+          // Circular dependency check: if this entity is already in our *current* traversal path
+          if (currentPath.includes(targetKeys)) {
+            continue
           }
-          visited.add(visitKey)
-
-          // Check if this nested exposure already exists
-          const existingNested = this.exposes.find(
-            (e) =>
-              !e.isRoot &&
-              e.entity.key === target.key &&
-              e.entity.domain === target.domain &&
-              e.parent?.key === parentKey
-          )
-
-          if (existingNested) {
-            continue // Already exposed under this parent
+
+          // Check if this entity is ALREADY exposed anywhere in the model
+          const existingExposure = this.getExposedEntity(target)
+
+          if (existingExposure) {
+            // If it's already exposed and NOT root (i.e., it's currently a nested child of someone else),
+            // promote it to ROOT to avoid duplicating it or deeply nesting it in multiple places.
+            if (!existingExposure.isRoot) {
+              // 1. Calculate new root paths (handling collisions)
+              const targetDomEntity = domain.findEntity(target.key, target.domain)
+              if (targetDomEntity) {
+                const name = targetDomEntity.info.name || ''
+                const segment = pluralize(name.toLocaleLowerCase())
+                let relativeCollectionPath = `/${segment}`
+                let relativeResourcePath = `/${segment}/{id}`
+
+                let counter = 1
+                const originalCollectionPath = relativeCollectionPath
+                while (this.exposes.some((e) => e.isRoot && e.collectionPath === relativeCollectionPath)) {
+                  relativeCollectionPath = `${originalCollectionPath}-${counter}`
+                  relativeResourcePath = `${relativeCollectionPath}/{id}`
+                  counter++
+                }
+
+                // 2. Update properties to make it root
+                existingExposure.isRoot = true
+                existingExposure.parent = undefined
+                existingExposure.collectionPath = relativeCollectionPath
+                existingExposure.resourcePath = relativeResourcePath
+                existingExposure.hasCollection = true
+              }
+            }
+            // Whether it was already root or we just promoted it, we stop following here.
+            continue
           }
 
           // Find the target domain entity for path generation
@@ -516,27 +558,30 @@ export class ApiModel extends DependentModel {
             nestedExposure.truncated = true
           } else {
             // Recursively follow associations
-            follow(target, nestedExposure.key, depth + 1)
+            follow(target, nestedExposure.key, depth + 1, [...currentPath, targetKeys])
           }
         }
       }
     }
 
     // Start following from the root exposure
-    follow(parentExposure.entity, parentExposure.key, 0)
+    // Initial path contains the root entity itself
+    const rootKey = createDomainKey(parentExposure.entity)
+    follow(parentExposure.entity, parentExposure.key, 0, [rootKey])
   }
 
   /**
    * Removes an exposed entity from the API model.
-   * @param entity The entity to remove.
+   * This also removes any nested exposed entities that are children of the removed entity.
+   *
+   * @param key The key of the exposed entity to remove.
    */
-  removeEntity(entity: AssociationTarget): void {
-    const current = this.exposes.find((e) => e.entity.key === entity.key && e.entity.domain === entity.domain)
-    if (!current) {
-      return
+  removeExposedEntity(key: string): void {
+    const index = this.exposes.findIndex((e) => e.key === key)
+    if (index < 0) {
+      throw new Error(`Exposed entity with key "${key}" not found.`)
     }
-    this.removeWithChildren(current.key)
-    this.notifyChange()
+    this.removeWithChildren(key)
   }
 
   private removeWithChildren(key: string): void {
@@ -573,11 +618,11 @@ export class ApiModel extends DependentModel {
   }
 
   /**
-   * Clears the API model for a new entity change.
+   * Clears the API model for a new data domain change.
    * This method resets the dependencies, exposes, user,
    * authentication, authorization, and session properties.
    */
-  cleanForEntityChange(): void {
+  cleanForDomainChange(): void {
     this.dependencies.clear()
     this.dependencyList = []
     this.exposes = []
@@ -606,7 +651,7 @@ export class ApiModel extends DependentModel {
     if (!domain.info.version) {
       throw new Error(`Cannot attach DataDomain without a version. Please set the version in the domain info.`)
     }
-    this.cleanForEntityChange()
+    this.cleanForDomainChange()
     this.dependencies.set(domain.key, domain)
     this.dependencyList = [{ key: domain.key, version: domain.info.version }]
     this.notifyChange()

package/src/modeling/ExposedEntity.ts

@@ -16,6 +16,15 @@ import type {
 /**
  * A class that specializes in representing an exposed Data Entity within an API Model.
  *
+ * ## Design Note
+ * This class enforces strict path constraints (e.g., single-segment collection paths like `/users`,
+ * two-segment resource paths like `/users/{id}`).
+ * This is an intentional design choice to support a UI paradigm for non-technical users, ensuring that
+ * path segments are configured individually at each level of the exposure hierarchy.
+ *
+ * Flexibility is achieved by chaining exposed entities (parent/child relationships), where the final
+ * absolute path is composed of all ancestral paths. See `getAbsoluteResourcePath()` and `getAbsoluteCollectionPath()`.
+ *
  * @fires change - Emitted when the exposed entity has changed.
  */
 export class ExposedEntity extends EventTarget {
@@ -250,6 +259,17 @@ export class ExposedEntity extends EventTarget {
       throw new Error(`Collection path must contain exactly one segment. Received: "${path}"`)
     }
     const normalizedCollection = `/${segments[0]}`
+
+    // Check for collision if this is a root entity
+    if (this.isRoot) {
+      const collision = this.api.exposes.find(
+        (e) => e.isRoot && e.key !== this.key && e.collectionPath === normalizedCollection
+      )
+      if (collision) {
+        throw new Error(`Collection path "${normalizedCollection}" is already in use by another root entity.`)
+      }
+    }
+
     // Preserve current parameter name if present, otherwise default to {id}
     let param = '{id}'
     if (this.resourcePath) {
@@ -309,6 +329,14 @@ export class ExposedEntity extends EventTarget {
         `Resource path must contain exactly two segments when no collection is present. Received: "${cleaned}"`
       )
     }
+    // Check for collision if this is a root entity (singleton case)
+    if (this.isRoot) {
+      const collision = this.api.exposes.find((e) => e.isRoot && e.key !== this.key && e.resourcePath === cleaned)
+      if (collision) {
+        throw new Error(`Resource path "${cleaned}" is already in use by another root entity.`)
+      }
+    }
+
     if (this.resourcePath !== cleaned) {
       this.resourcePath = `/${segments[0]}/${segments[1]}`
     }

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

@@ -163,6 +163,26 @@ test.group('ApiModel.constructor()', () => {
     assert.equal(model.domain!.key, 'my-domain')
   }).tags(['@modeling', '@api', '@creation'])
 
+  test('initializes domain dependency correctly when passed to constructor', ({ assert }) => {
+    const domain = new DataDomain()
+    domain.info.version = '1.0.0'
+
+    const model = new ApiModel({}, domain)
+
+    assert.isDefined(model.domain)
+    assert.equal(model.domain?.key, domain.key)
+    assert.lengthOf(model.dependencyList, 1)
+    assert.equal(model.dependencyList[0].key, domain.key)
+    assert.equal(model.dependencyList[0].version, '1.0.0')
+  }).tags(['@modeling', '@api', '@creation'])
+
+  test('throws if passed domain has no version', ({ assert }) => {
+    const domain = new DataDomain()
+    // No version set
+
+    assert.throws(() => new ApiModel({}, domain), /must have a version/)
+  }).tags(['@modeling', '@api', '@creation'])
+
   test('notifies change when info is modified', async ({ assert }) => {
     const model = new ApiModel()
     let notified = false

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

@@ -186,4 +186,29 @@ test.group('ApiModel.exposeEntity()', () => {
     assert.isDefined(nestedC)
     assert.isUndefined(nestedD)
   })
+  test('resolves root path collision by appending a number', ({ assert }) => {
+    const domain = new DataDomain()
+    domain.info.version = '1.0.0'
+    const dm = domain.addModel()
+    // Two entities that will generate the same plural path "/items"
+    const e1 = dm.addEntity({ info: { name: 'Item' } })
+    const e2 = dm.addEntity({ info: { name: 'Item' } }) // Same name
+
+    const model = new ApiModel()
+    model.attachDataDomain(domain)
+
+    // Expose first entity -> /items
+    const exp1 = model.exposeEntity({ key: e1.key })
+    assert.equal(exp1.collectionPath, '/items')
+
+    // Expose second entity -> should resolve collision to /items-1
+    const exp2 = model.exposeEntity({ key: e2.key })
+    assert.equal(exp2.collectionPath, '/items-1')
+    assert.equal(exp2.resourcePath, '/items-1/{id}')
+
+    // Expose third entity -> /items-2
+    const e3 = dm.addEntity({ info: { name: 'Item' } })
+    const exp3 = model.exposeEntity({ key: e3.key })
+    assert.equal(exp3.collectionPath, '/items-2')
+  }).tags(['@modeling', '@api'])
 })

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

@@ -9,10 +9,10 @@ test.group('ApiModel.removeEntity()', () => {
     const e1 = dm.addEntity()
     const model = new ApiModel()
     model.attachDataDomain(domain)
-    model.exposeEntity({ key: e1.key })
+    const exposure = model.exposeEntity({ key: e1.key })
     assert.lengthOf(model.exposes, 1)
 
-    model.removeEntity({ key: e1.key })
+    model.removeExposedEntity(exposure.key)
     assert.lengthOf(model.exposes, 0)
   }).tags(['@modeling', '@api'])
 
@@ -26,18 +26,18 @@ test.group('ApiModel.removeEntity()', () => {
     eA.addAssociation({ key: eB.key }, { info: { name: 'toB' } })
     const model = new ApiModel()
     model.attachDataDomain(domain)
-    model.exposeEntity({ key: eA.key }, { followAssociations: true })
+    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)
     assert.isDefined(nestedB)
     assert.isAbove(model.exposes.length, 1)
 
-    // Remove root entity A and expect children to be removed as well
-    model.removeEntity({ key: eA.key })
+    // Remove root exposure for A and expect children to be removed as well
+    model.removeExposedEntity(rootExposure.key)
     assert.lengthOf(model.exposes, 0)
   }).tags(['@modeling', '@api'])
 
-  test('does nothing if entity does not exist', ({ assert }) => {
+  test('throws error if entity does not exist', ({ assert }) => {
     const domain = new DataDomain()
     domain.info.version = '1.0.0'
     const dm = domain.addModel()
@@ -46,7 +46,10 @@ test.group('ApiModel.removeEntity()', () => {
     model.attachDataDomain(domain)
     model.exposeEntity({ key: e1.key })
 
-    model.removeEntity({ key: 'non-existing-entity' })
+    assert.throws(
+      () => model.removeExposedEntity('non-existing-key'),
+      'Exposed entity with key "non-existing-key" not found.'
+    )
     assert.lengthOf(model.exposes, 1, 'exposes count should remain unchanged')
   }).tags(['@modeling', '@api'])
 
@@ -57,13 +60,13 @@ test.group('ApiModel.removeEntity()', () => {
     const e1 = dm.addEntity()
     const model = new ApiModel()
     model.attachDataDomain(domain)
-    model.exposeEntity({ key: e1.key })
+    const exposure = model.exposeEntity({ key: e1.key })
 
     let notified = false
     model.addEventListener('change', () => {
       notified = true
     })
-    model.removeEntity({ key: e1.key })
+    model.removeExposedEntity(exposure.key)
     await Promise.resolve() // Allow microtask to run
     assert.isTrue(notified)
   }).tags(['@modeling', '@api'])
@@ -74,7 +77,11 @@ test.group('ApiModel.removeEntity()', () => {
     model.addEventListener('change', () => {
       notified = true
     })
-    model.removeEntity({ key: 'no-notify-remove-entity' })
+    try {
+      model.removeExposedEntity('no-notify-remove-entity')
+    } catch {
+      // ignore error
+    }
     await Promise.resolve() // Allow microtask to run
     assert.isFalse(notified)
   }).tags(['@modeling', '@api'])

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

@@ -0,0 +1,107 @@
+import { test } from '@japa/runner'
+import { ApiModel, DataDomain } from '../../../src/index.js'
+
+test.group('ExposedEntity Path Setter Validation', () => {
+  test('throws when setting collection path that collides with another root entity', ({ assert }) => {
+    const domain = new DataDomain()
+    domain.info.version = '1.0.0'
+    const dm = domain.addModel()
+    const e1 = dm.addEntity({ info: { name: 'A' } })
+    const e2 = dm.addEntity({ info: { name: 'B' } })
+
+    const model = new ApiModel()
+    model.attachDataDomain(domain)
+
+    model.exposeEntity({ key: e1.key }) // /as
+    const exp2 = model.exposeEntity({ key: e2.key }) // /bs
+
+    // Try to rename exp2's collection path to /as (collision)
+    assert.throws(
+      () => exp2.setCollectionPath('/as'),
+      'Collection path "/as" is already in use by another root entity.'
+    )
+  })
+
+  test('throws when setting resource path that collides with another root entity (singleton)', ({ assert }) => {
+    const domain = new DataDomain()
+    domain.info.version = '1.0.0'
+    const dm = domain.addModel()
+    const e1 = dm.addEntity({ info: { name: 'A' } })
+    const e2 = dm.addEntity({ info: { name: 'B' } }) // Collection-less
+
+    const model = new ApiModel()
+    model.attachDataDomain(domain)
+
+    const exp1 = model.exposeEntity({ key: e1.key }) // /as, /as/{id}
+    // Manually force a collision for testing resource path (singleton vs singleton or singleton vs resource)
+    // Let's make exp2 a singleton
+    const exp2 = model.exposeEntity({ key: e2.key })
+    // Remove collection from exp2 so we can set arbitrary resource path
+    // Note: implementation of setResourcePath for collection-less allows any 2 segments
+    // We need to simulate the state where hasCollection is false
+    exp2.hasCollection = false
+
+    // Set exp1 resource path to something specific
+    exp1.hasCollection = false
+    exp1.setResourcePath('/shared/path')
+
+    // Try to set exp2 resource path to same
+    assert.throws(
+      () => exp2.setResourcePath('/shared/path'),
+      'Resource path "/shared/path" is already in use by another root entity.'
+    )
+  })
+
+  test('allows setting non-colliding paths for root entity', ({ assert }) => {
+    const domain = new DataDomain()
+    domain.info.version = '1.0.0'
+    const dm = domain.addModel()
+    const e1 = dm.addEntity({ info: { name: 'A' } })
+
+    const model = new ApiModel()
+    model.attachDataDomain(domain)
+
+    const exp1 = model.exposeEntity({ key: e1.key }) // /as
+
+    exp1.setCollectionPath('/new-path')
+    assert.equal(exp1.collectionPath, '/new-path')
+
+    exp1.hasCollection = false // allow arbitrary resource path
+    exp1.setResourcePath('/custom/resource')
+    assert.equal(exp1.resourcePath, '/custom/resource')
+  })
+
+  test('does not validate collision for non-root entities', ({ assert }) => {
+    const domain = new DataDomain()
+    domain.info.version = '1.0.0'
+    const dm = domain.addModel()
+    const eA = dm.addEntity({ info: { name: 'A' } })
+    const eB = dm.addEntity({ info: { name: 'B' } })
+    eA.addAssociation({ key: eB.key }, { info: { name: 'toB' } })
+
+    const model = new ApiModel()
+    model.attachDataDomain(domain)
+
+    // expose A -> B
+    const rootExp = model.exposeEntity({ key: eA.key }, { followAssociations: true })
+    const nestedExp = model.exposes.find((e) => !e.isRoot)
+
+    assert.isDefined(nestedExp)
+    // Assuming root entity has collection path /as
+    assert.equal(rootExp.collectionPath, '/as')
+
+    // Try to set nested entity's collection path to /as
+    // Since it's not root, it should NOT check for collision with rootExp
+    // (In reality this path is technically valid relative to parent, but here we just check that
+    // it doesn't throw the specific root collision error)
+
+    // setCollectionPath logic for non-root:
+    // It doesn't check checks.
+
+    try {
+      nestedExp?.setCollectionPath('/as')
+    } catch (e) {
+      assert.notInclude((e as Error).message, 'already in use by another root entity')
+    }
+  })
+})