@api-client/core 0.18.30 → 0.18.32

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.30",
+  "version": "0.18.32",
   "license": "Apache-2.0",
   "exports": {
     "./browser.js": {

package/src/modeling/ApiModel.ts

@@ -1,12 +1,12 @@
 import { nanoid } from '../nanoid.js'
-import { ApiModelKind, DataDomainKind } from '../models/kinds.js'
+import { ApiModelKind, DataDomainKind, ExposedEntityKind } from '../models/kinds.js'
 import { type IThing, Thing } from '../models/Thing.js'
 import type {
   AccessRule,
   AssociationTarget,
   AuthenticationConfiguration,
   AuthorizationConfiguration,
-  ExposedEntity,
+  ExposedEntitySchema,
   RateLimitingConfiguration,
   RolesBasedAccessControl,
   SessionConfiguration,
@@ -18,6 +18,7 @@ import { DependentModel, type DependentModelSchema, type DomainDependency } from
 import { observed, toRaw } from '../decorators/observed.js'
 import pluralize from '@jarrodek/pluralize'
 import { createDomainKey } from './helpers/keying.js'
+import { ExposedEntity } from './ExposedEntity.js'
 
 /**
  * Contact information for the exposed API.
@@ -95,7 +96,7 @@ export interface ApiModelSchema extends DependentModelSchema {
    * The specific subset of Data Entities to be exposed by this API.
    * These are the entities that are included in the data domain schema.
    */
-  exposes: ExposedEntity[]
+  exposes: ExposedEntitySchema[]
 
   /**
    * Optional array of access rules that define the access control policies
@@ -294,7 +295,7 @@ export class ApiModel extends DependentModel {
       this.session = structuredClone(init.session)
     }
     if (Array.isArray(init.exposes)) {
-      this.exposes = structuredClone(init.exposes)
+      this.exposes = init.exposes.map((e) => new ExposedEntity(this, e))
     } else {
       this.exposes = []
     }
@@ -324,7 +325,7 @@ export class ApiModel extends DependentModel {
       kind: this.kind,
       key: this.key,
       info: this.info.toJSON(),
-      exposes: structuredClone(this.exposes),
+      exposes: this.exposes.map((e) => e.toJSON()),
     }
     if (this.user) {
       result.user = { ...this.user }
@@ -401,17 +402,24 @@ export class ApiModel extends DependentModel {
       throw new Error(`Entity not found in domain: ${entity.key}`)
     }
     const name = domainEntity.info.name || ''
-    const newEntity: ExposedEntity = {
+    const segment = pluralize(name.toLocaleLowerCase())
+    const relativeCollectionPath = `/${segment}`
+    const relativeResourcePath = `/${segment}/{id}`
+    const newEntity: ExposedEntitySchema = {
+      kind: ExposedEntityKind,
       key: nanoid(),
       entity: { ...entity },
       actions: [],
       isRoot: true,
-      path: pluralize(name.toLocaleLowerCase()),
+      relativeCollectionPath,
+      relativeResourcePath,
+      hasCollection: true,
     }
     if (options) {
       newEntity.exposeOptions = { ...options }
     }
-    this.exposes.push(newEntity)
+    const created = new ExposedEntity(this, newEntity)
+    this.exposes.push(created)
 
     // Follow associations if requested
     if (options?.followAssociations) {
@@ -420,7 +428,7 @@ export class ApiModel extends DependentModel {
       }
     }
     this.notifyChange()
-    return newEntity
+    return created
   }
 
   /**
@@ -430,7 +438,7 @@ export class ApiModel extends DependentModel {
    * @param parentExposure The root exposure to follow associations from
    * @param options The expose options containing follow configuration
    */
-  private followEntityAssociations(parentExposure: ExposedEntity, options: ExposeOptions): void {
+  private followEntityAssociations(parentExposure: ExposedEntitySchema, options: ExposeOptions): void {
     const domain = this.domain
     if (!domain) {
       return
@@ -479,13 +487,20 @@ export class ApiModel extends DependentModel {
           if (!targetDomainEntity) continue
 
           const name = association.info.name || ''
+          const segment = pluralize(name.toLocaleLowerCase())
+          const isCollection = association.multiple !== false
+          const relativeCollectionPath = isCollection ? `/${segment}` : undefined
+          const relativeResourcePath = isCollection ? `/${segment}/{id}` : `/${segment}`
           // Create nested exposure
-          const nestedExposure: ExposedEntity = {
+          const nestedExposure: ExposedEntitySchema = {
+            kind: ExposedEntityKind,
             key: nanoid(),
             entity: { ...target },
             actions: [],
             isRoot: false,
-            path: pluralize(name.toLocaleLowerCase()),
+            relativeCollectionPath,
+            relativeResourcePath,
+            hasCollection: isCollection,
             parent: {
               key: parentKey,
               association: {
@@ -496,7 +511,7 @@ export class ApiModel extends DependentModel {
             },
           }
 
-          this.exposes.push(nestedExposure)
+          this.exposes.push(new ExposedEntity(this, nestedExposure))
           if (depth + 1 >= maxDepth) {
             nestedExposure.truncated = true
           } else {

package/src/modeling/ExposedEntity.ts

@@ -0,0 +1,344 @@
+import { ExposedEntityKind } from '../models/kinds.js'
+import { nanoid } from '../nanoid.js'
+import type { ApiModel } from './ApiModel.js'
+import { ensureLeadingSlash, joinPaths } from './helpers/endpointHelpers.js'
+import type {
+  AccessRule,
+  ApiAction,
+  AssociationTarget,
+  ExposeOptions,
+  ExposeParentRef,
+  RateLimitingConfiguration,
+  ExposedEntitySchema,
+} from './types.js'
+
+/**
+ * A class that specializes in representing an exposed Data Entity within an API Model.
+ *
+ * @fires change - Emitted when the exposed entity has changed.
+ */
+export class ExposedEntity extends EventTarget {
+  /**
+   * The exposed entity kind recognizable by the ecosystem.
+   */
+  kind: typeof ExposedEntityKind
+
+  /**
+   * The unique key of the exposed entity.
+   * This is a stable identifier that does not change across versions.
+   */
+  key: string
+
+  /**
+   * A pointer to a Data Entity from the Data Domain.
+   */
+  entity: AssociationTarget
+
+  /**
+   * Indicates whether this exposure has a collection endpoint.
+   * A collection endpoint is optional for nested exposures where the association is 1:1
+   * and the schema is embedded directly under the parent resource.
+   */
+  hasCollection: boolean
+
+  /**
+   * Relative path to the collection endpoint for this exposure.
+   * Starts with '/'. Not set for 1:1 nested exposures where collection does not exist.
+   */
+  relativeCollectionPath?: string
+
+  /**
+   * Relative path to the resource endpoint for this exposure.
+   * Starts with '/'. For 1:1 nested exposures the resource path typically does not include an id segment.
+   */
+  relativeResourcePath: string
+
+  /**
+   * Whether this exposure is a root exposure (top-level collection).
+   * If this is set then the `parent` reference must be populated.
+   */
+  isRoot?: boolean
+
+  /**
+   * Parent reference when this exposure was created via following an association.
+   */
+  parent?: ExposeParentRef
+
+  /**
+   * Expose-time config used to create this exposure (persisted for auditing/UI).
+   * This is only populated for the root exposure. All children exposures inherit this config.
+   */
+  exposeOptions?: ExposeOptions
+
+  /**
+   * The list of enabled API actions for this exposure (List/Read/Create/etc.)
+   */
+  actions: ApiAction[]
+
+  /**
+   * Optional array of access rules that define the access control policies for this exposure.
+   */
+  accessRule?: AccessRule[]
+
+  /**
+   * Optional configuration for rate limiting for this exposure.
+   */
+  rateLimiting?: RateLimitingConfiguration
+
+  /**
+   * When true, generation for this exposure hit configured limits
+   */
+  truncated?: boolean
+
+  /**
+   * When the notifying flag is set to true,
+   * the domain is pending a notification.
+   * No other notifications will be sent until
+   * the current notification is sent.
+   */
+  #notifying = false
+  /**
+   * A reference to the parent API Model instance.
+   */
+  api: ApiModel
+
+  static createSchema(input: Partial<ExposedEntitySchema> = {}): ExposedEntitySchema {
+    const {
+      key = nanoid(),
+      entity = { key: '' },
+      relativeCollectionPath,
+      relativeResourcePath = '/',
+      hasCollection = true,
+      isRoot,
+      parent,
+      exposeOptions,
+      actions = [],
+      accessRule,
+      rateLimiting,
+      truncated,
+    } = input
+    const result: ExposedEntitySchema = {
+      kind: ExposedEntityKind,
+      key,
+      entity: { ...entity },
+      hasCollection,
+      relativeResourcePath,
+      actions: actions.map((a) => ({ ...a })),
+    }
+    if (relativeCollectionPath !== undefined) {
+      result.relativeCollectionPath = relativeCollectionPath
+    }
+    if (isRoot !== undefined) {
+      result.isRoot = isRoot
+    }
+    if (parent !== undefined) {
+      result.parent = { ...parent }
+    }
+    if (exposeOptions !== undefined) {
+      result.exposeOptions = { ...exposeOptions }
+    }
+    if (accessRule !== undefined) {
+      result.accessRule = accessRule.map((ar) => ({ ...ar }))
+    }
+    if (rateLimiting !== undefined) {
+      result.rateLimiting = { ...rateLimiting }
+    }
+    if (truncated !== undefined) {
+      result.truncated = truncated
+    }
+    return result
+  }
+
+  constructor(model: ApiModel, state?: Partial<ExposedEntitySchema>) {
+    super()
+    this.api = model
+    const init = ExposedEntity.createSchema(state)
+    this.kind = init.kind
+    this.key = init.key
+    this.entity = init.entity
+    this.hasCollection = init.hasCollection
+    this.relativeCollectionPath = init.relativeCollectionPath
+    this.relativeResourcePath = init.relativeResourcePath
+    this.isRoot = init.isRoot
+    this.parent = init.parent
+    this.exposeOptions = init.exposeOptions
+    this.actions = init.actions
+    this.accessRule = init.accessRule
+    this.rateLimiting = init.rateLimiting
+    this.truncated = init.truncated
+  }
+
+  notifyChange() {
+    if (this.#notifying) {
+      return
+    }
+    this.#notifying = true
+    queueMicrotask(() => {
+      this.#notifying = false
+      const event = new Event('change')
+      this.dispatchEvent(event)
+    })
+  }
+
+  toJSON(): ExposedEntitySchema {
+    const result: ExposedEntitySchema = {
+      kind: this.kind,
+      key: this.key,
+      entity: { ...this.entity },
+      relativeResourcePath: this.relativeResourcePath,
+      actions: this.actions.map((a) => ({ ...a })),
+      hasCollection: this.hasCollection,
+    }
+    if (this.relativeCollectionPath !== undefined) {
+      result.relativeCollectionPath = this.relativeCollectionPath
+    }
+    if (this.isRoot !== undefined) {
+      result.isRoot = this.isRoot
+    }
+    if (this.parent !== undefined) {
+      result.parent = { ...this.parent }
+    }
+    if (this.exposeOptions !== undefined) {
+      result.exposeOptions = { ...this.exposeOptions }
+    }
+    if (this.accessRule !== undefined) {
+      result.accessRule = this.accessRule.map((ar) => ({ ...ar }))
+    }
+    if (this.rateLimiting !== undefined) {
+      result.rateLimiting = { ...this.rateLimiting }
+    }
+    if (this.truncated !== undefined) {
+      result.truncated = this.truncated
+    }
+    return result
+  }
+
+  /**
+   * Sets a new relative collection path for this exposed entity.
+   *
+   * It:
+   * - updates the relativeCollectionPath property
+   * - updates the absoluteCollectionPath property accordingly
+   * - updates the relativeResourcePath and absoluteResourcePath accordingly.
+   * @param path The new path to set.
+   */
+  setRelativeCollectionPath(path: string) {
+    if (!this.hasCollection) {
+      throw new Error(`Cannot set collection path on an exposure that does not have a collection`)
+    }
+    const cleaned = ensureLeadingSlash(path)
+    // Ensure exactly one non-empty segment
+    const segments = cleaned.split('/').filter(Boolean)
+    if (segments.length !== 1) {
+      throw new Error(`Collection path must contain exactly one segment. Received: "${path}"`)
+    }
+    const normalizedCollection = `/${segments[0]}`
+    // Preserve current parameter name if present, otherwise default to {id}
+    let param = '{id}'
+    if (this.relativeResourcePath) {
+      const curSegments = this.relativeResourcePath.split('/').filter(Boolean)
+      const maybeParam = curSegments[1]
+      if (maybeParam && /^\{[A-Za-z_][A-Za-z0-9_]*\}$/.test(maybeParam)) {
+        param = maybeParam
+      }
+    }
+    const nextResource = `${normalizedCollection}/${param}`
+    const changed = this.relativeCollectionPath !== normalizedCollection || this.relativeResourcePath !== nextResource
+    this.relativeCollectionPath = normalizedCollection
+    this.relativeResourcePath = nextResource
+    if (changed) this.notifyChange()
+  }
+
+  /**
+   * Sets a new relative resource path for this exposed entity.
+   *
+   * Rules:
+   * - Must start with '/'.
+   * - If this exposure has a collection, the path must be exactly the collection path plus a single
+   *   parameter segment (e.g. `/products/{productId}`) and only the parameter name may vary.
+   * - If this exposure does NOT have a collection, the path can be any two segments (e.g. `/profile/{id}` or `/a/b`).
+   */
+  setRelativeResourcePath(path: string) {
+    const cleaned = ensureLeadingSlash(path)
+    const segments = cleaned.split('/').filter(Boolean)
+
+    if (this.hasCollection) {
+      if (!this.relativeCollectionPath) {
+        throw new Error('Cannot set resource path: missing collection path for this exposure')
+      }
+      const colSegments = this.relativeCollectionPath.split('/').filter(Boolean)
+      if (colSegments.length !== 1) {
+        throw new Error(`Invalid stored collection path "${this.relativeCollectionPath}"`)
+      }
+      if (segments.length !== 2) {
+        throw new Error(`Resource path must be exactly two segments (collection + parameter). Received: "${cleaned}"`)
+      }
+      const [s1, s2] = segments
+      if (s1 !== colSegments[0]) {
+        throw new Error(`Resource path must start with the collection segment "${colSegments[0]}". Received: "${s1}"`)
+      }
+      // s2 must be a parameter segment {name}
+      if (!/^\{[A-Za-z_][A-Za-z0-9_]*\}$/.test(s2)) {
+        throw new Error(`The second segment must be a parameter in braces, e.g. {id}. Received: "${s2}"`)
+      }
+      if (this.relativeResourcePath !== cleaned) {
+        this.relativeResourcePath = `/${s1}/${s2}`
+        this.notifyChange()
+      }
+      return
+    }
+
+    // No collection: allow any two segments
+    if (segments.length !== 2) {
+      throw new Error(
+        `Resource path must contain exactly two segments when no collection is present. Received: "${cleaned}"`
+      )
+    }
+    if (this.relativeResourcePath !== cleaned) {
+      this.relativeResourcePath = `/${segments[0]}/${segments[1]}`
+      this.notifyChange()
+    }
+  }
+
+  /**
+   * Computes the absolute path for this exposure's resource endpoint by
+   * walking up the exposure tree using `parent.key` until reaching a root exposure.
+   * The absolute path is composed by concatenating each ancestor's resource path
+   * with this exposure's relative resource path.
+   */
+  getAbsoluteResourcePath(): string {
+    let absolute = ensureLeadingSlash(this.relativeResourcePath)
+    // Traverse parents, always joining with the parent's resource path
+    let parentKey = this.parent?.key
+    while (parentKey) {
+      const parent = this.api.exposes.find((e) => e.key === parentKey)
+      if (!parent) break
+      const parentResource = ensureLeadingSlash(parent.relativeResourcePath)
+      absolute = joinPaths(parentResource, absolute)
+      parentKey = parent.parent?.key
+    }
+    return absolute
+  }
+
+  /**
+   * Computes the absolute path for this exposure's collection endpoint (if any)
+   * by walking up the exposure tree using `parent.key` until reaching a root exposure.
+   * The absolute path is composed by concatenating each ancestor's resource path
+   * with this exposure's relative collection path.
+   * Returns undefined if this exposure has no collection.
+   */
+  getAbsoluteCollectionPath(): string | undefined {
+    if (!this.hasCollection || !this.relativeCollectionPath) return undefined
+    let absolute = ensureLeadingSlash(this.relativeCollectionPath)
+    // Traverse parents, always joining with the parent's resource path
+    let parentKey = this.parent?.key
+    while (parentKey) {
+      const parent = this.api.exposes.find((e) => e.key === parentKey)
+      if (!parent) break
+      const parentResource = ensureLeadingSlash(parent.relativeResourcePath)
+      absolute = joinPaths(parentResource, absolute)
+      parentKey = parent.parent?.key
+    }
+    return absolute
+  }
+}

package/src/modeling/helpers/endpointHelpers.ts

@@ -3,3 +3,25 @@ export function paramNameFor(entityKeyLocal: string): string {
   const key = parts[parts.length - 1]
   return `${key}Id`
 }
+
+/**
+ * Ensures the path starts with a single leading slash and has no trailing slash (except root '/')
+ * @param path The path fragment to normalize
+ */
+export function ensureLeadingSlash(path: string): string {
+  const trimmed = path.trim()
+  const withSlash = trimmed.startsWith('/') ? trimmed : `/${trimmed}`
+  if (withSlash === '/') return '/'
+  return withSlash.replace(/\/+$/, '')
+}
+
+/**
+ * Joins two absolute-like fragments ensuring single slashes between segments
+ * @param left The left path fragment
+ * @param right The right path fragment
+ */
+export function joinPaths(left: string, right: string): string {
+  const l = left.endsWith('/') ? left.slice(0, -1) : left
+  const r = right.startsWith('/') ? right : `/${right}`
+  return `${l}${r}`
+}

package/src/modeling/types.ts

@@ -12,6 +12,7 @@ import type {
   DomainPropertyKind,
   DomainAssociationKind,
   DataDomainKind,
+  ExposedEntityKind,
 } from '../models/kinds.js'
 import type { DataDomain } from './DataDomain.js'
 
@@ -426,7 +427,8 @@ export interface UsernamePasswordConfiguration extends AuthenticationConfigurati
 /**
  * Represents a Data Entity from the Data Domain that the API will expose and operate upon.
  */
-export interface ExposedEntity {
+export interface ExposedEntitySchema {
+  kind: typeof ExposedEntityKind
   /**
    * The unique identifier for this exposure instance.
    * In the exposure model, we need to uniquely identify each exposure instance, because
@@ -449,9 +451,22 @@ export interface ExposedEntity {
    */
   entity: AssociationTarget
   /**
-   * The path segment for this exposure.
+   * Indicates whether this exposure has a collection endpoint.
+   * A collection endpoint is optional for nested exposures where the association is 1:1
+   * and the schema is embedded directly under the parent resource.
    */
-  path: string
+  hasCollection: boolean
+  /**
+   * Relative path to the collection endpoint for this exposure.
+   * Starts with '/'. Not set for 1:1 nested exposures where collection does not exist.
+   */
+  relativeCollectionPath?: string
+
+  /**
+   * Relative path to the resource endpoint for this exposure.
+   * Starts with '/'. For 1:1 nested exposures the resource path typically does not include an id segment.
+   */
+  relativeResourcePath: string
 
   /**
    * Whether this exposure is a root exposure (top-level collection).

package/src/models/kinds.ts

@@ -21,5 +21,6 @@ export const DataCatalogVersionKind = 'Core#DataCatalogVersion'
 export const OrganizationKind = 'Core#Organization'
 export const InvitationKind = 'Core#Invitation'
 export const ApiModelKind = 'Core#ApiModel'
+export const ExposedEntityKind = 'Core#ExposedEntity'
 export const ApiFileKind = 'Core#ApiFile'
 export const GroupKind = 'Core#Group'

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

@@ -5,9 +5,11 @@ import {
   DataDomain,
   type RolesBasedAccessControl,
   type ApiModelSchema,
-  type ExposedEntity,
+  type ExposedEntitySchema,
   type ApiContact,
   type ApiLicense,
+  ExposedEntityKind,
+  ExposedEntity,
 } from '../../../src/index.js'
 
 test.group('ApiModel.createSchema()', () => {
@@ -34,7 +36,16 @@ test.group('ApiModel.createSchema()', () => {
     const input: Partial<ApiModelSchema> = {
       key: 'test-api',
       info: { name: 'Test API', description: 'A test API' },
-      exposes: [{ key: 'entity1', actions: [], path: '', entity: { key: 'entity1' } }],
+      exposes: [
+        {
+          key: 'entity1',
+          actions: [],
+          hasCollection: true,
+          kind: ExposedEntityKind,
+          relativeResourcePath: '/',
+          entity: { key: 'entity1' },
+        },
+      ],
       user: { key: 'user-entity' },
       dependencyList: [{ key: 'domain1', version: '1.0.0' }],
       authentication: { strategy: 'UsernamePassword' },
@@ -51,7 +62,8 @@ test.group('ApiModel.createSchema()', () => {
     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: [], path: '', entity: { key: 'entity1' } }])
+    assert.lengthOf(schema.exposes, 1, 'should have one exposed entity')
+    assert.equal(schema.exposes[0].key, 'entity1', 'exposed entity should have correct key')
     assert.deepEqual(schema.user, { key: 'user-entity' })
     assert.deepEqual(schema.dependencyList, [{ key: 'domain1', version: '1.0.0' }])
     assert.deepEqual(schema.authentication, { strategy: 'UsernamePassword' })
@@ -100,7 +112,16 @@ test.group('ApiModel.constructor()', () => {
       kind: ApiModelKind,
       key: 'test-api',
       info: { name: 'Test API', description: 'A test API' },
-      exposes: [{ key: 'entity1', actions: [], path: '', entity: { key: 'entity1' } }],
+      exposes: [
+        {
+          key: 'entity1',
+          actions: [],
+          relativeResourcePath: '/',
+          entity: { key: 'entity1' },
+          hasCollection: true,
+          kind: ExposedEntityKind,
+        },
+      ],
       user: { key: 'user-entity' },
       dependencyList: [{ key: 'domain1', version: '1.0.0' }],
       authentication: { strategy: 'UsernamePassword' },
@@ -116,7 +137,8 @@ test.group('ApiModel.constructor()', () => {
 
     assert.equal(model.key, 'test-api')
     assert.equal(model.info.name, 'Test API')
-    assert.deepEqual(model.exposes, [{ key: 'entity1', actions: [], path: '', entity: { key: 'entity1' } }])
+    assert.lengthOf(model.exposes, 1, 'should have one exposed entity')
+    assert.equal(model.exposes[0].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' })
@@ -179,7 +201,16 @@ test.group('ApiModel.toJSON()', () => {
       kind: ApiModelKind,
       key: 'test-api',
       info: { name: 'Test API', description: 'A test API' },
-      exposes: [{ key: 'entity1', actions: [], path: '', entity: { key: 'entity1' } }],
+      exposes: [
+        {
+          key: 'entity1',
+          actions: [],
+          relativeResourcePath: '/',
+          entity: { key: 'entity1' },
+          hasCollection: true,
+          kind: ExposedEntityKind,
+        },
+      ],
       user: { key: 'user-entity' },
       dependencyList: [{ key: 'domain1', version: '1.0.0' }],
       authentication: { strategy: 'UsernamePassword' },
@@ -196,7 +227,8 @@ test.group('ApiModel.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: [], path: '', entity: { key: 'entity1' } }])
+    assert.lengthOf(json.exposes, 1, 'should have one exposed entity')
+    assert.equal(json.exposes[0].key, 'entity1', 'exposed entity should have correct key')
     assert.deepEqual(json.user, { key: 'user-entity' })
     assert.deepEqual(json.dependencyList, [{ key: 'domain1', version: '1.0.0' }])
     assert.deepEqual(json.authentication, { strategy: 'UsernamePassword' })
@@ -214,11 +246,18 @@ 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: [], path: '', entity: { key: entityKey } }
-    model.exposes.push(exposed)
+    const exposed: ExposedEntitySchema = {
+      key: entityKey,
+      actions: [],
+      hasCollection: true,
+      kind: ExposedEntityKind,
+      relativeResourcePath: '/',
+      entity: { key: entityKey },
+    }
+    model.exposes.push(new ExposedEntity(model, exposed))
 
     const retrievedEntity = model.getExposedEntity({ key: entityKey })
-    assert.deepEqual(retrievedEntity, exposed)
+    assert.deepEqual(retrievedEntity?.toJSON(), exposed)
   }).tags(['@modeling', '@api'])
 
   test('returns undefined if entity is not exposed', ({ assert }) => {

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

@@ -81,7 +81,7 @@ test.group('ApiModel.exposeEntity()', () => {
     const nestedB = model.exposes.find((e) => !e.isRoot && e.entity.key === eB.key)
     assert.isDefined(nestedB)
     assert.deepEqual(nestedB?.parent?.key, exposedA.key)
-    assert.strictEqual(nestedB?.path, 'entitybs')
+    assert.strictEqual(nestedB?.relativeCollectionPath, '/entitybs')
   })
 
   test('does not infinitely expose circular associations', ({ assert }) => {