@api-client/core 0.14.6 → 0.14.8

package/src/models/store/Backend.ts

@@ -1,180 +1,4 @@
 import type { PatchInfo } from '../../patch/types.js'
-import { type IPatchRevision } from '../../events/BaseEvents.js'
-import { type IHttpHistory, Kind as HttpHistoryKind } from '../HttpHistory.js'
-import { Kind as ProjectExecutionKind } from '../ProjectExecution.js'
-import type { IFile } from './File.js'
-import type { IPermission } from './Permission.js'
-import type { IRevision } from './Revision.js'
-/**
- * @deprecated
- */
-export enum BackendCommandType {
-  observe,
-  unobserve,
-}
-/**
- * @deprecated
- */
-export const BackendCommandKind = 'Core#BackendCommand'
-/**
- * @deprecated
- */
-export interface IBackendCommand {
-  kind: typeof BackendCommandKind
-  cmd: BackendCommandType
-}
-/**
- * @deprecated
- */
-export interface IBackendObserveCommand extends IBackendCommand {
-  path: string // includes query parameters
-}
-/**
- * @deprecated
- */
-export interface BroadcastEvent {
-  type: 'event'
-  operation: string
-  kind: string
-  key: string
-  path: string
-  organization: string // empty string for `/organizations`
-}
-/**
- * @deprecated
- */
-export interface BackendErrorEvent {
-  type: 'error'
-  cause: string
-  time: number
-}
-/**
- * @deprecated
- */
-export interface ClearedBroadcastEvent {
-  type: 'event'
-  operation: 'cleared'
-  name: string
-  organization: string
-  path: string
-}
-/**
- * @deprecated
- */
-export interface BroadcastFileData {
-  parent?: string
-}
-/**
- * @deprecated
- */
-export interface BroadcastCreatedEvent extends BroadcastEvent {
-  operation: 'created'
-  data: unknown
-  // path: string; -> /files, /certificates, /history, /project/executions, /organizations, /trash
-}
-/**
- * @deprecated
- */
-export interface FileCreatedBroadcastEvent extends BroadcastCreatedEvent, BroadcastFileData {}
-/**
- * @deprecated
- */
-export interface FileMetaCreatedBroadcastEvent extends FileCreatedBroadcastEvent {
-  data: IFile
-  alt: 'meta'
-}
-/**
- * @deprecated
- */
-export interface FileMediaCreatedBroadcastEvent extends FileCreatedBroadcastEvent {
-  alt: 'media'
-}
-/**
- * @deprecated
- */
-export interface HistoryCreatedBroadcastEvent extends BroadcastCreatedEvent {
-  project: string
-  request: string
-  app: string
-  kind: typeof HttpHistoryKind
-  data: IHttpHistory
-}
-/**
- * @deprecated
- */
-export interface FileRevisionCreatedBroadcastEvent extends BroadcastCreatedEvent, BroadcastFileData {
-  parent: string
-  data: IRevision
-}
-/**
- * @deprecated
- */
-export interface ProjectExecutionCreatedBroadcastEvent extends BroadcastCreatedEvent {
-  project: string
-  kind: typeof ProjectExecutionKind
-}
-/**
- * @deprecated
- */
-export interface BroadcastPatchEvent extends BroadcastEvent {
-  operation: 'patch'
-  data: IPatchRevision
-  // path: string; -> /files, /organizations
-}
-/**
- * @deprecated
- */
-export interface FilePatchBroadcastEvent extends BroadcastPatchEvent, BroadcastFileData {}
-
-/**
- * @deprecated
- */
-export interface AccessBroadcastEvent extends BroadcastEvent {
-  operation: 'access-granted' | 'access-removed'
-  data?: IPermission
-  // path: string; -> /files, /organizations, /organizations
-}
-
-/**
- * @deprecated
- */
-export interface FileAccessBroadcastEvent extends AccessBroadcastEvent {
-  parent?: string
-}
-
-/**
- * @deprecated
- */
-export interface DeletedBroadcastEvent extends BroadcastEvent {
-  operation: 'deleted'
-  // path: string; -> /files, /certificates, /history, /project/executions, /organizations, /trash
-}
-
-/**
- * @deprecated
- */
-export interface FileDeletedBroadcastEvent extends DeletedBroadcastEvent, BroadcastFileData {
-  /**
-   * The key of the created trash entry for the deleted object.
-   * This is **always** populated when the file alt is `meta`.
-   */
-  trash?: string
-}
-
-/**
- * @deprecated
- */
-export interface ProjectExecutionDeleteBroadcastEvent extends DeletedBroadcastEvent {
-  project: string
-}
-
-/**
- * @deprecated
- */
-export interface HistoryDeletedBroadcastEvent extends DeletedBroadcastEvent {
-  project: string
-  request: string
-}
 
 export interface ServerEvent {
   kind: string

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

@@ -17,7 +17,7 @@ test.group('ApiModel.createSchema()', () => {
     assert.deepInclude(schema.info, { name: 'Unnamed API' })
     assert.deepEqual(schema.exposes, [])
     assert.isUndefined(schema.userKey)
-    assert.isUndefined(schema.domain)
+    assert.isUndefined(schema.dependencyList)
     assert.isUndefined(schema.authentication)
     assert.isUndefined(schema.authorization)
     assert.isUndefined(schema.session)
@@ -31,7 +31,7 @@ test.group('ApiModel.createSchema()', () => {
       info: { name: 'Test API', description: 'A test API' },
       exposes: [{ key: 'entity1', actions: [] }],
       userKey: 'user-entity',
-      domain: { key: 'domain1', version: '1.0.0' },
+      dependencyList: [{ key: 'domain1', version: '1.0.0' }],
       authentication: { strategy: 'UsernamePassword' },
       authorization: { strategy: 'RBAC', roleKey: 'role' } as RolesBasedAccessControl,
       session: { secret: 'secret', properties: ['email'] },
@@ -45,7 +45,7 @@ test.group('ApiModel.createSchema()', () => {
     assert.deepInclude(schema.info, { name: 'Test API', description: 'A test API' })
     assert.deepEqual(schema.exposes, [{ key: 'entity1', actions: [] }])
     assert.equal(schema.userKey, 'user-entity')
-    assert.deepEqual(schema.domain, { key: 'domain1', version: '1.0.0' })
+    assert.deepEqual(schema.dependencyList, [{ key: 'domain1', version: '1.0.0' }])
     assert.deepEqual(schema.authentication, { strategy: 'UsernamePassword' })
     assert.deepEqual(schema.authorization, { strategy: 'RBAC', roleKey: 'role' })
     assert.deepEqual(schema.session, { secret: 'secret', properties: ['email'] })
@@ -73,13 +73,12 @@ test.group('ApiModel.constructor()', () => {
     assert.equal(model.info.name, 'Unnamed API')
     assert.deepEqual(model.exposes, [])
     assert.isUndefined(model.userKey)
-    assert.isUndefined(model.domain)
     assert.isUndefined(model.authentication)
     assert.isUndefined(model.authorization)
     assert.isUndefined(model.session)
     assert.isUndefined(model.accessRule)
     assert.isUndefined(model.rateLimiting)
-    assert.isUndefined(model.dataDomain)
+    assert.deepEqual(model.dependencyList, [])
   })
 
   test('creates an instance with provided schema values', ({ assert }) => {
@@ -89,7 +88,7 @@ test.group('ApiModel.constructor()', () => {
       info: { name: 'Test API', description: 'A test API' },
       exposes: [{ key: 'entity1', actions: [] }],
       userKey: 'user-entity',
-      domain: { key: 'domain1', version: '1.0.0' },
+      dependencyList: [{ key: 'domain1', version: '1.0.0' }],
       authentication: { strategy: 'UsernamePassword' },
       authorization: { strategy: 'RBAC', roleKey: 'role' } as RolesBasedAccessControl,
       session: { secret: 'secret', properties: ['email'] },
@@ -102,21 +101,24 @@ test.group('ApiModel.constructor()', () => {
     assert.equal(model.info.name, 'Test API')
     assert.deepEqual(model.exposes, [{ key: 'entity1', actions: [] }])
     assert.equal(model.userKey, 'user-entity')
-    assert.deepEqual(model.domain, { key: 'domain1', version: '1.0.0' })
+    assert.deepEqual(model.dependencyList, [{ key: 'domain1', version: '1.0.0' }])
     assert.deepEqual(model.authentication, { strategy: 'UsernamePassword' })
     assert.deepEqual(model.authorization, { strategy: 'RBAC', roleKey: 'role' })
     assert.deepEqual(model.session, { secret: 'secret', properties: ['email'] })
     assert.deepEqual(model.accessRule, [{ type: 'public' }])
     assert.deepEqual(model.rateLimiting, { rules: [] })
-    assert.isUndefined(model.dataDomain)
   })
 
   test('creates an instance with a DataDomain', ({ assert }) => {
     const domainSchema = DataDomain.createSchema({ key: 'my-domain' })
-    const model = new ApiModel({}, domainSchema)
-    assert.isDefined(model.dataDomain)
-    assert.instanceOf(model.dataDomain, DataDomain)
-    assert.equal(model.dataDomain!.key, 'my-domain')
+    domainSchema.info.version = '1.0.0'
+    const model = new ApiModel(
+      { dependencyList: [{ version: domainSchema.info.version, key: domainSchema.key }] },
+      domainSchema
+    )
+    assert.isDefined(model.domain)
+    assert.instanceOf(model.domain, DataDomain)
+    assert.equal(model.domain!.key, 'my-domain')
   })
 
   test('notifies change when info is modified', async ({ assert }) => {
@@ -141,7 +143,7 @@ test.group('ApiModel.toJSON()', () => {
     assert.deepInclude(json.info, { name: 'Unnamed API' })
     assert.deepEqual(json.exposes, [])
     assert.isUndefined(json.userKey)
-    assert.isUndefined(json.domain)
+    assert.isUndefined(json.dependencyList)
     assert.isUndefined(json.authentication)
     assert.isUndefined(json.authorization)
     assert.isUndefined(json.session)
@@ -156,7 +158,7 @@ test.group('ApiModel.toJSON()', () => {
       info: { name: 'Test API', description: 'A test API' },
       exposes: [{ key: 'entity1', actions: [] }],
       userKey: 'user-entity',
-      domain: { key: 'domain1', version: '1.0.0' },
+      dependencyList: [{ key: 'domain1', version: '1.0.0' }],
       authentication: { strategy: 'UsernamePassword' },
       authorization: { strategy: 'RBAC', roleKey: 'role' } as RolesBasedAccessControl,
       session: { secret: 'secret', properties: ['email'] },
@@ -170,7 +172,7 @@ test.group('ApiModel.toJSON()', () => {
     assert.deepInclude(json.info, { name: 'Test API', description: 'A test API' })
     assert.deepEqual(json.exposes, [{ key: 'entity1', actions: [] }])
     assert.equal(json.userKey, 'user-entity')
-    assert.deepEqual(json.domain, { key: 'domain1', version: '1.0.0' })
+    assert.deepEqual(json.dependencyList, [{ key: 'domain1', version: '1.0.0' }])
     assert.deepEqual(json.authentication, { strategy: 'UsernamePassword' })
     assert.deepEqual(json.authorization, { strategy: 'RBAC', roleKey: 'role' })
     assert.deepEqual(json.session, { secret: 'secret', properties: ['email'] })

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

@@ -142,7 +142,66 @@ test.group('DataDomain.registerForeignDomain()', () => {
   })
 })
 
-test.group('DataDomain.findForeignEntity()', () => {
+test.group('DataDomain.findNamespace()', () => {
+  test('finds a foreign namespace by its key and domain key', ({ assert }) => {
+    const domain = new DataDomain()
+    const fd = new DataDomain()
+    const ns = fd.addNamespace({ key: 'test-namespace' })
+    fd.info.version = '1.0.0'
+    domain.registerForeignDomain(fd)
+    const result = domain.findNamespace('test-namespace', fd.key)
+    assert.deepEqual(result, ns)
+  })
+
+  test('returns undefined when namespace not found', ({ assert }) => {
+    const domain = new DataDomain()
+    const fd = new DataDomain()
+    fd.info.version = '1.0.0'
+    domain.registerForeignDomain(fd)
+    const result = domain.findNamespace('other-namespace', fd.key)
+    assert.isUndefined(result)
+  })
+
+  test("throws when namespace's namespace not found", ({ assert }) => {
+    const domain = new DataDomain()
+    domain.addNamespace({ key: 'test-namespace' })
+    assert.throws(() => {
+      domain.findNamespace('test-namespace', 'non-existent-domain')
+    }, `Foreign domain non-existent-domain not found`)
+  })
+})
+
+test.group('DataDomain.findModel()', () => {
+  test('finds a foreign model by its key and domain key', ({ assert }) => {
+    const domain = new DataDomain()
+    const fd = new DataDomain()
+    const ns = fd.addNamespace({ key: 'test-namespace' })
+    const model = ns.addModel({ key: 'test-model' })
+    fd.info.version = '1.0.0'
+    domain.registerForeignDomain(fd)
+    const result = domain.findModel('test-model', fd.key)
+    assert.deepEqual(result, model)
+  })
+
+  test('returns undefined when model not found', ({ assert }) => {
+    const domain = new DataDomain()
+    const fd = new DataDomain()
+    fd.info.version = '1.0.0'
+    domain.registerForeignDomain(fd)
+    const result = domain.findModel('other-model', fd.key)
+    assert.isUndefined(result)
+  })
+
+  test("throws when model's namespace not found", ({ assert }) => {
+    const domain = new DataDomain()
+    domain.addNamespace({ key: 'test-namespace' })
+    assert.throws(() => {
+      domain.findModel('test-model', 'non-existent-domain')
+    }, `Foreign domain non-existent-domain not found`)
+  })
+})
+
+test.group('DataDomain.findEntity()', () => {
   test('finds a foreign entity by its key and domain key', ({ assert }) => {
     const dataDomain = new DataDomain()
     const foreignDomain = new DataDomain()
@@ -150,14 +209,16 @@ test.group('DataDomain.findForeignEntity()', () => {
     const entity = foreignDomain.addEntity(model.key, { key: 'test-entity' })
     foreignDomain.info.version = '1.0.0'
     dataDomain.registerForeignDomain(foreignDomain)
-    const foundEntity = dataDomain.findForeignEntity('test-entity', foreignDomain.key)
+    const foundEntity = dataDomain.findEntity('test-entity', foreignDomain.key)
     assert.deepEqual(foundEntity, entity)
   })
 
-  test('returns undefined if the foreign domain does not exist', ({ assert }) => {
+  test('throws when the foreign domain does not exist', ({ assert }) => {
     const dataDomain = new DataDomain()
-    const foundEntity = dataDomain.findForeignEntity('test-entity', 'non-existent-domain')
-    assert.isUndefined(foundEntity)
+    assert.throws(
+      () => dataDomain.findEntity('test-entity', 'non-existent-domain'),
+      `Foreign domain non-existent-domain not found`
+    )
   })
 
   test('returns undefined if the entity does not exist in the foreign domain', ({ assert }) => {
@@ -165,7 +226,7 @@ test.group('DataDomain.findForeignEntity()', () => {
     const foreignDomain = new DataDomain()
     foreignDomain.info.version = '1.0.0'
     dataDomain.registerForeignDomain(foreignDomain)
-    const foundEntity = dataDomain.findForeignEntity('non-existent-entity', foreignDomain.key)
+    const foundEntity = dataDomain.findEntity('non-existent-entity', foreignDomain.key)
     assert.isUndefined(foundEntity)
   })
 
@@ -175,7 +236,7 @@ test.group('DataDomain.findForeignEntity()', () => {
     const model = foreignDomain.addModel({ key: 'test-model' })
     foreignDomain.info.version = '1.0.0'
     dataDomain.registerForeignDomain(foreignDomain)
-    const foundEntity = dataDomain.findForeignEntity(model.key, foreignDomain.key)
+    const foundEntity = dataDomain.findEntity(model.key, foreignDomain.key)
     assert.isUndefined(foundEntity)
   })
 
@@ -185,7 +246,7 @@ test.group('DataDomain.findForeignEntity()', () => {
     foreignDomain.info.version = '1.0.0'
     dataDomain.registerForeignDomain(foreignDomain)
     // @ts-expect-error For testing purposes
-    const foundEntity = dataDomain.findForeignEntity(undefined, foreignDomain.key)
+    const foundEntity = dataDomain.findEntity(undefined, foreignDomain.key)
     assert.isUndefined(foundEntity)
   })
 
@@ -195,7 +256,7 @@ test.group('DataDomain.findForeignEntity()', () => {
     foreignDomain.info.version = '1.0.0'
     dataDomain.registerForeignDomain(foreignDomain)
     // @ts-expect-error For testing purposes
-    const foundEntity = dataDomain.findForeignEntity(null, foreignDomain.key)
+    const foundEntity = dataDomain.findEntity(null, foreignDomain.key)
     assert.isUndefined(foundEntity)
   })
 
@@ -204,7 +265,7 @@ test.group('DataDomain.findForeignEntity()', () => {
     const foreignDomain = new DataDomain()
     foreignDomain.info.version = '1.0.0'
     dataDomain.registerForeignDomain(foreignDomain)
-    const foundEntity = dataDomain.findForeignEntity('', foreignDomain.key)
+    const foundEntity = dataDomain.findEntity('', foreignDomain.key)
     assert.isUndefined(foundEntity)
   })
 
@@ -214,7 +275,7 @@ test.group('DataDomain.findForeignEntity()', () => {
     foreignDomain.info.version = '1.0.0'
     dataDomain.registerForeignDomain(foreignDomain)
     // @ts-expect-error For testing purposes
-    const foundEntity = dataDomain.findForeignEntity(123, foreignDomain.key)
+    const foundEntity = dataDomain.findEntity(123, foreignDomain.key)
     assert.isUndefined(foundEntity)
   })
 
@@ -224,7 +285,7 @@ test.group('DataDomain.findForeignEntity()', () => {
     foreignDomain.info.version = '1.0.0'
     dataDomain.registerForeignDomain(foreignDomain)
     // @ts-expect-error For testing purposes
-    const foundEntity = dataDomain.findForeignEntity(true, foreignDomain.key)
+    const foundEntity = dataDomain.findEntity(true, foreignDomain.key)
     assert.isUndefined(foundEntity)
   })
 
@@ -234,7 +295,7 @@ test.group('DataDomain.findForeignEntity()', () => {
     foreignDomain.info.version = '1.0.0'
     dataDomain.registerForeignDomain(foreignDomain)
     // @ts-expect-error For testing purposes
-    const foundEntity = dataDomain.findForeignEntity({}, foreignDomain.key)
+    const foundEntity = dataDomain.findEntity({}, foreignDomain.key)
     assert.isUndefined(foundEntity)
   })
 
@@ -244,7 +305,7 @@ test.group('DataDomain.findForeignEntity()', () => {
     foreignDomain.info.version = '1.0.0'
     dataDomain.registerForeignDomain(foreignDomain)
     // @ts-expect-error For testing purposes
-    const foundEntity = dataDomain.findForeignEntity([], foreignDomain.key)
+    const foundEntity = dataDomain.findEntity([], foreignDomain.key)
     assert.isUndefined(foundEntity)
   })
 
@@ -254,7 +315,7 @@ test.group('DataDomain.findForeignEntity()', () => {
     foreignDomain.info.version = '1.0.0'
     dataDomain.registerForeignDomain(foreignDomain)
     // @ts-expect-error For testing purposes
-    const foundEntity = dataDomain.findForeignEntity(() => {}, foreignDomain.key)
+    const foundEntity = dataDomain.findEntity(() => {}, foreignDomain.key)
     assert.isUndefined(foundEntity)
   })
 
@@ -265,8 +326,7 @@ test.group('DataDomain.findForeignEntity()', () => {
     const model = foreignDomain.addModel({ key: 'test-model' })
     const entity = foreignDomain.addEntity(model.key, { key: 'test-entity' })
     dataDomain.registerForeignDomain(foreignDomain)
-    // @ts-expect-error For testing purposes
-    const foundEntity = dataDomain.findForeignEntity(entity.key, undefined)
+    const foundEntity = dataDomain.findEntity(entity.key, undefined)
     assert.isUndefined(foundEntity)
   })
 
@@ -278,7 +338,7 @@ test.group('DataDomain.findForeignEntity()', () => {
     const entity = foreignDomain.addEntity(model.key, { key: 'test-entity' })
     dataDomain.registerForeignDomain(foreignDomain)
     // @ts-expect-error For testing purposes
-    const foundEntity = dataDomain.findForeignEntity(entity.key, null)
+    const foundEntity = dataDomain.findEntity(entity.key, null)
     assert.isUndefined(foundEntity)
   })
 
@@ -289,67 +349,140 @@ test.group('DataDomain.findForeignEntity()', () => {
     const model = foreignDomain.addModel({ key: 'test-model' })
     const entity = foreignDomain.addEntity(model.key, { key: 'test-entity' })
     dataDomain.registerForeignDomain(foreignDomain)
-    const foundEntity = dataDomain.findForeignEntity(entity.key, '')
+    const foundEntity = dataDomain.findEntity(entity.key, '')
     assert.isUndefined(foundEntity)
   })
 
-  test('returns undefined if domainKey is a number', ({ assert }) => {
+  test('throws when domainKey is a number', ({ assert }) => {
     const dataDomain = new DataDomain()
     const foreignDomain = new DataDomain()
     foreignDomain.info.version = '1.0.0'
     const model = foreignDomain.addModel({ key: 'test-model' })
     const entity = foreignDomain.addEntity(model.key, { key: 'test-entity' })
     dataDomain.registerForeignDomain(foreignDomain)
-    // @ts-expect-error For testing purposes
-    const foundEntity = dataDomain.findForeignEntity(entity.key, 123)
-    assert.isUndefined(foundEntity)
+    assert.throws(
+      // @ts-expect-error For testing purposes
+      () => dataDomain.findEntity(entity.key, 123),
+      `Invalid namespace key. Expected a string, got number`
+    )
   })
 
-  test('returns undefined if domainKey is a boolean', ({ assert }) => {
+  test('throws when domainKey is a boolean', ({ assert }) => {
     const dataDomain = new DataDomain()
     const foreignDomain = new DataDomain()
     foreignDomain.info.version = '1.0.0'
     const model = foreignDomain.addModel({ key: 'test-model' })
     const entity = foreignDomain.addEntity(model.key, { key: 'test-entity' })
     dataDomain.registerForeignDomain(foreignDomain)
-    // @ts-expect-error For testing purposes
-    const foundEntity = dataDomain.findForeignEntity(entity.key, true)
-    assert.isUndefined(foundEntity)
+    assert.throws(
+      // @ts-expect-error For testing purposes
+      () => dataDomain.findEntity(entity.key, true),
+      `Invalid namespace key. Expected a string, got boolean`
+    )
   })
 
-  test('returns undefined if domainKey is an object', ({ assert }) => {
+  test('throws when domainKey is an object', ({ assert }) => {
     const dataDomain = new DataDomain()
     const foreignDomain = new DataDomain()
     foreignDomain.info.version = '1.0.0'
     const model = foreignDomain.addModel({ key: 'test-model' })
     const entity = foreignDomain.addEntity(model.key, { key: 'test-entity' })
     dataDomain.registerForeignDomain(foreignDomain)
-    // @ts-expect-error For testing purposes
-    const foundEntity = dataDomain.findForeignEntity(entity.key, {})
-    assert.isUndefined(foundEntity)
+    assert.throws(
+      // @ts-expect-error For testing purposes
+      () => dataDomain.findEntity(entity.key, {}),
+      `Invalid namespace key. Expected a string, got object`
+    )
   })
 
-  test('returns undefined if domainKey is an array', ({ assert }) => {
+  test('throws when domainKey is an array', ({ assert }) => {
     const dataDomain = new DataDomain()
     const foreignDomain = new DataDomain()
     foreignDomain.info.version = '1.0.0'
     const model = foreignDomain.addModel({ key: 'test-model' })
     const entity = foreignDomain.addEntity(model.key, { key: 'test-entity' })
     dataDomain.registerForeignDomain(foreignDomain)
-    // @ts-expect-error For testing purposes
-    const foundEntity = dataDomain.findForeignEntity(entity.key, [])
-    assert.isUndefined(foundEntity)
+    assert.throws(
+      // @ts-expect-error For testing purposes
+      () => dataDomain.findEntity(entity.key, []),
+      `Invalid namespace key. Expected a string, got object`
+    )
   })
 
-  test('returns undefined if domainKey is a function', ({ assert }) => {
+  test('throws when domainKey is a function', ({ assert }) => {
     const dataDomain = new DataDomain()
     const foreignDomain = new DataDomain()
     foreignDomain.info.version = '1.0.0'
     const model = foreignDomain.addModel({ key: 'test-model' })
     const entity = foreignDomain.addEntity(model.key, { key: 'test-entity' })
     dataDomain.registerForeignDomain(foreignDomain)
-    // @ts-expect-error For testing purposes
-    const foundEntity = dataDomain.findForeignEntity(entity.key, () => {})
-    assert.isUndefined(foundEntity)
+    assert.throws(
+      // @ts-expect-error For testing purposes
+      () => dataDomain.findEntity(entity.key, () => {}),
+      `Invalid namespace key. Expected a string, got function`
+    )
+  })
+})
+
+test.group('DataDomain.findAssociation()', () => {
+  test('finds a foreign association by its key and domain key', ({ assert }) => {
+    const domain = new DataDomain()
+    const fd = new DataDomain()
+    const m1 = fd.addModel()
+    const e1 = m1.addEntity()
+    const e2 = m1.addEntity()
+    const a1 = e1.addAssociation({ key: e2.key })
+    fd.info.version = '1.0.0'
+    domain.registerForeignDomain(fd)
+    const result = domain.findAssociation(a1.key, fd.key)
+    assert.deepEqual(result, a1)
+  })
+
+  test('returns undefined when association not found', ({ assert }) => {
+    const domain = new DataDomain()
+    const fd = new DataDomain()
+    fd.info.version = '1.0.0'
+    domain.registerForeignDomain(fd)
+    const result = domain.findAssociation('other-association', fd.key)
+    assert.isUndefined(result)
+  })
+
+  test("throws when association's namespace not found", ({ assert }) => {
+    const domain = new DataDomain()
+    domain.addNamespace({ key: 'test-namespace' })
+    assert.throws(() => {
+      domain.findAssociation('test-association', 'non-existent-domain')
+    }, `Foreign domain non-existent-domain not found`)
+  })
+})
+
+test.group('DataDomain.findProperty()', () => {
+  test('finds a foreign property by its key and domain key', ({ assert }) => {
+    const domain = new DataDomain()
+    const fd = new DataDomain()
+    const m1 = fd.addModel()
+    const e1 = m1.addEntity()
+    const p1 = e1.addProperty()
+    fd.info.version = '1.0.0'
+    domain.registerForeignDomain(fd)
+    const result = domain.findProperty(p1.key, fd.key)
+    assert.deepEqual(result, p1)
+  })
+
+  test('returns undefined when property not found', ({ assert }) => {
+    const domain = new DataDomain()
+    const fd = new DataDomain()
+    fd.info.version = '1.0.0'
+    domain.registerForeignDomain(fd)
+    const result = domain.findProperty('other-property', fd.key)
+    assert.isUndefined(result)
+  })
+
+  test("throws when property's namespace not found", ({ assert }) => {
+    const domain = new DataDomain()
+    domain.addNamespace({ key: 'test-namespace' })
+    assert.throws(() => {
+      domain.findProperty('test-property', 'non-existent-domain')
+    }, `Foreign domain non-existent-domain not found`)
   })
 })