@api-client/core 0.14.9 → 0.15.0

package/tests/unit/events/telemetry.spec.ts

@@ -0,0 +1,224 @@
+import { test } from '@japa/runner'
+import sinon from 'sinon'
+import { EventTypes } from '../../../src/events/EventTypes.js'
+import { Events } from '../../../src/events/Events.js'
+import { ensureUnique } from './EventsTestHelpers.js'
+import './events_polyfills.js'
+
+test.group('Events > Telemetry > EventTypes.Telemetry', () => {
+  test('has the namespace', ({ assert }) => {
+    assert.typeOf(EventTypes.Telemetry, 'object')
+  })
+
+  test('has "{prop}" property')
+    .with([
+      { prop: 'view', value: 'telemetryscreenview' },
+      { prop: 'event', value: 'telemetryevent' },
+      { prop: 'exception', value: 'telemetryexception' },
+      { prop: 'social', value: 'telemetrysocial' },
+      { prop: 'timing', value: 'telemetrytiming' },
+    ])
+    .run(({ assert }, { prop, value }) => {
+      // @ts-expect-error Used in testing
+      assert.equal(EventTypes.Telemetry[prop], value)
+    })
+
+  test('has unique events for the namespace', () => {
+    ensureUnique('EventTypes.Telemetry', EventTypes.Telemetry)
+  })
+})
+
+test.group('Events > Telemetry > Events.Telemetry > view()', () => {
+  const screenName = 'test-screen'
+
+  test('dispatches the event', async ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Telemetry.view, spy)
+    Events.Telemetry.view(screenName)
+    globalThis.removeEventListener(EventTypes.Telemetry.view, spy)
+    assert.isTrue(spy.calledOnce)
+  })
+
+  test('the event has screen name on the detail', async ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Telemetry.view, spy)
+    Events.Telemetry.view(screenName)
+    globalThis.removeEventListener(EventTypes.Telemetry.view, spy)
+    const e = spy.args[0][0] as CustomEvent
+    assert.equal(e.detail.screenName, screenName)
+  })
+
+  test('the event has the custom configuration', async ({ assert }) => {
+    const spy = sinon.spy()
+    const custom = {
+      customMetrics: [{ index: 1, value: 1 }],
+      customDimensions: [{ index: 1, value: 'test' }],
+    }
+    globalThis.addEventListener(EventTypes.Telemetry.view, spy)
+    Events.Telemetry.view(screenName, undefined, custom)
+    globalThis.removeEventListener(EventTypes.Telemetry.view, spy)
+    const e = spy.args[0][0] as CustomEvent
+    assert.deepEqual(e.detail.customMetrics, custom.customMetrics, 'has customMetrics')
+    assert.deepEqual(e.detail.customDimensions, custom.customDimensions, 'has customDimensions')
+  })
+})
+
+test.group('Events > Telemetry > Events.Telemetry > event()', () => {
+  const init = {
+    category: 'e-cat',
+    action: 'e-act',
+    label: 'e-label',
+    value: 1,
+  }
+
+  test('dispatches the event', async ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Telemetry.event, spy)
+    Events.Telemetry.event(init)
+    globalThis.removeEventListener(EventTypes.Telemetry.event, spy)
+    assert.isTrue(spy.calledOnce)
+  })
+
+  test('the event has the detail object', async ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Telemetry.event, spy)
+    Events.Telemetry.event(init)
+    globalThis.removeEventListener(EventTypes.Telemetry.event, spy)
+    const e = spy.args[0][0] as CustomEvent
+    assert.deepEqual(e.detail, init)
+  })
+})
+
+test.group('Events > Telemetry > Events.Telemetry > exception()', () => {
+  const description = 'event-exception'
+  const fatal = true
+
+  test('dispatches the event', async ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Telemetry.exception, spy)
+    Events.Telemetry.exception(description)
+    globalThis.removeEventListener(EventTypes.Telemetry.exception, spy)
+    assert.isTrue(spy.calledOnce)
+  })
+
+  test('the event has the description', async ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Telemetry.exception, spy)
+    Events.Telemetry.exception(description)
+    globalThis.removeEventListener(EventTypes.Telemetry.exception, spy)
+    const e = spy.args[0][0] as CustomEvent
+    assert.equal(e.detail.description, description)
+  })
+
+  test('the event has the fatal', async ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Telemetry.exception, spy)
+    Events.Telemetry.exception(description, fatal)
+    globalThis.removeEventListener(EventTypes.Telemetry.exception, spy)
+    const e = spy.args[0][0] as CustomEvent
+    assert.equal(e.detail.fatal, fatal)
+  })
+
+  test('the event has custom configuration', async ({ assert }) => {
+    const spy = sinon.spy()
+    const custom = {
+      customMetrics: [{ index: 1, value: 1 }],
+      customDimensions: [{ index: 1, value: 'test' }],
+    }
+    globalThis.addEventListener(EventTypes.Telemetry.exception, spy)
+    Events.Telemetry.exception(description, fatal, undefined, custom)
+    globalThis.removeEventListener(EventTypes.Telemetry.exception, spy)
+    const e = spy.args[0][0] as CustomEvent
+    assert.deepEqual(e.detail.customMetrics, custom.customMetrics, 'has customMetrics')
+    assert.deepEqual(e.detail.customDimensions, custom.customDimensions, 'has customDimensions')
+  })
+})
+
+test.group('Events > Telemetry > Events.Telemetry > social()', () => {
+  const init = {
+    network: 'e-network',
+    action: 'e-action',
+    target: 'e-target',
+  }
+
+  test('dispatches the event', async ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Telemetry.social, spy)
+    Events.Telemetry.social(init.network, init.action, init.target)
+    globalThis.removeEventListener(EventTypes.Telemetry.social, spy)
+    assert.isTrue(spy.calledOnce)
+  })
+
+  test('the event has the detail object', async ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Telemetry.social, spy)
+    Events.Telemetry.social(init.network, init.action, init.target)
+    globalThis.removeEventListener(EventTypes.Telemetry.social, spy)
+    const e = spy.args[0][0] as CustomEvent
+    assert.deepEqual(e.detail, init)
+  })
+
+  test('the event has custom configuration', async ({ assert }) => {
+    const spy = sinon.spy()
+    const custom = {
+      customMetrics: [{ index: 1, value: 1 }],
+      customDimensions: [{ index: 1, value: 'test' }],
+    }
+    globalThis.addEventListener(EventTypes.Telemetry.social, spy)
+    Events.Telemetry.social(init.network, init.action, init.target, undefined, custom)
+    globalThis.removeEventListener(EventTypes.Telemetry.social, spy)
+    const e = spy.args[0][0] as CustomEvent
+    assert.deepEqual(e.detail.customMetrics, custom.customMetrics, 'has customMetrics')
+    assert.deepEqual(e.detail.customDimensions, custom.customDimensions, 'has customDimensions')
+  })
+})
+
+test.group('Events > Telemetry > Events.Telemetry > timing()', () => {
+  const init = {
+    category: 'e-category',
+    variable: 'e-variable',
+    value: 100,
+    label: 'e-label',
+  }
+
+  test('dispatches the event', async ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Telemetry.timing, spy)
+    Events.Telemetry.timing(init.category, init.variable, init.value, init.label)
+    globalThis.removeEventListener(EventTypes.Telemetry.timing, spy)
+    assert.isTrue(spy.calledOnce)
+  })
+
+  test('the event has the detail object', async ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Telemetry.timing, spy)
+    Events.Telemetry.timing(init.category, init.variable, init.value, init.label)
+    globalThis.removeEventListener(EventTypes.Telemetry.timing, spy)
+    const e = spy.args[0][0] as CustomEvent
+    assert.deepEqual(e.detail, init)
+  })
+
+  test('the event has custom configuration', async ({ assert }) => {
+    const spy = sinon.spy()
+    const custom = {
+      customMetrics: [{ index: 1, value: 1 }],
+      customDimensions: [{ index: 1, value: 'test' }],
+    }
+    globalThis.addEventListener(EventTypes.Telemetry.timing, spy)
+    Events.Telemetry.timing(init.category, init.variable, init.value, init.label, undefined, custom)
+    globalThis.removeEventListener(EventTypes.Telemetry.timing, spy)
+    const e = spy.args[0][0] as CustomEvent
+    assert.deepEqual(e.detail.customMetrics, custom.customMetrics, 'has customMetrics')
+    assert.deepEqual(e.detail.customDimensions, custom.customDimensions, 'has customDimensions')
+  })
+})
+
+test.group('Events > Telemetry > Events.Telemetry > State', () => {
+  test('set()', async ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Telemetry.State.set, spy)
+    Events.Telemetry.State.set()
+    globalThis.removeEventListener(EventTypes.Telemetry.State.set, spy)
+    assert.isTrue(spy.calledOnce)
+  })
+})

package/tests/unit/events/transport.spec.ts

@@ -0,0 +1,139 @@
+import { test } from '@japa/runner'
+import sinon from 'sinon'
+import { EventTypes } from '../../../src/events/EventTypes.js'
+import { Events } from '../../../src/events/Events.js'
+import { ensureUnique } from './EventsTestHelpers.js'
+import { IHttpRequest, HttpRequest, Kind as HttpRequestKind } from '../../../src/models/HttpRequest.js'
+import { Kind as HttpProjectKind } from '../../../src/models/HttpProject.js'
+import { IHttpRequestDetail } from '../../../src/events/transport/TransportEvents.js'
+import { IRequestProxyInit } from '../../../src/proxy/RequestProxy.js'
+import { ContextEventDetailWithResult } from '../../../src/events/BaseEvents.js'
+import { IHttpProjectProxyInit, IHttpProjectStoreProxyInit } from '../../../src/proxy/HttpProjectProxy.js'
+import './events_polyfills.js'
+
+test.group('Events > Transport > EventTypes.Transport.Core', () => {
+  test('has "{prop}" property')
+    .with([
+      ['request', 'transportcorerequest'],
+      ['httpProject', 'transportcorehttpproject'],
+    ])
+    .run(({ assert }, [prop, value]) => {
+      // @ts-expect-error Used in testing
+      assert.equal(EventTypes.Transport.Core[prop], value)
+    })
+
+  test('has unique events for the namespace', () => {
+    ensureUnique('EventTypes.Transport.Core', EventTypes.Transport.Core)
+  })
+})
+
+test.group('Events > Transport > EventTypes.Transport.Http', () => {
+  test('has "{prop}" property')
+    .with([['send', 'httptransportsend']])
+    .run(({ assert }, [prop, value]) => {
+      // @ts-expect-error Used in testing
+      assert.equal(EventTypes.Transport.Http[prop], value)
+    })
+
+  test('has unique events for the namespace', () => {
+    ensureUnique('EventTypes.Transport.Http', EventTypes.Transport.Http)
+  })
+})
+
+test.group('Events > Transport > EventTypes.Transport.Ws', () => {
+  test('has "{prop}" property')
+    .with([
+      ['connect', 'wstransportconnect'],
+      ['disconnect', 'wstransportdisconnect'],
+      ['send', 'wstransportsend'],
+    ])
+    .run(({ assert }, [prop, value]) => {
+      // @ts-expect-error Used in testing
+      assert.equal(EventTypes.Transport.Ws[prop], value)
+    })
+
+  test('has unique events for the namespace', () => {
+    ensureUnique('EventTypes.Transport.Ws', EventTypes.Transport.Ws)
+  })
+})
+
+test.group('Events > Transport > Events.Transport.Core > request()', () => {
+  const init: IRequestProxyInit = {
+    kind: HttpRequestKind,
+    request: new HttpRequest().toJSON(),
+  }
+
+  test('dispatches the event', async ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Transport.Core.request, spy)
+    await Events.Transport.Core.request(init)
+    globalThis.removeEventListener(EventTypes.Transport.Core.request, spy)
+    assert.isTrue(spy.calledOnce)
+  })
+
+  test('has the detail object', async ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Transport.Core.request, spy)
+    await Events.Transport.Core.request(init)
+    globalThis.removeEventListener(EventTypes.Transport.Core.request, spy)
+    const e = spy.args[0][0] as CustomEvent<ContextEventDetailWithResult<IRequestProxyInit>>
+    assert.deepEqual(e.detail, { ...init, result: undefined })
+  })
+})
+
+test.group('Events > Transport > Events.Transport.Core > httpProject()', () => {
+  const init: IHttpProjectStoreProxyInit = {
+    kind: HttpProjectKind,
+    pid: 'test-id',
+    options: { parallel: true },
+    organization: 'test-organization',
+  }
+
+  test('dispatches the event', async ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Transport.Core.httpProject, spy)
+    await Events.Transport.Core.httpProject(init)
+    globalThis.removeEventListener(EventTypes.Transport.Core.httpProject, spy)
+    assert.isTrue(spy.calledOnce)
+  })
+
+  test('has the detail object', async ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Transport.Core.httpProject, spy)
+    await Events.Transport.Core.httpProject(init)
+    globalThis.removeEventListener(EventTypes.Transport.Core.httpProject, spy)
+    const e = spy.args[0][0] as CustomEvent<ContextEventDetailWithResult<IHttpProjectProxyInit>>
+    assert.deepEqual(e.detail, { ...init, result: undefined })
+  })
+})
+
+test.group('Events > Transport > Events.Transport.Http > send()', () => {
+  const request: IHttpRequest = new HttpRequest().toJSON()
+  const init: RequestInit = { method: 'POST' }
+
+  test('dispatches the event', async ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Transport.Http.send, spy)
+    await Events.Transport.Http.send(request)
+    globalThis.removeEventListener(EventTypes.Transport.Http.send, spy)
+    assert.isTrue(spy.calledOnce)
+  })
+
+  test('has the request on the detail', async ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Transport.Http.send, spy)
+    await Events.Transport.Http.send(request)
+    globalThis.removeEventListener(EventTypes.Transport.Http.send, spy)
+    const e = spy.args[0][0] as CustomEvent<IHttpRequestDetail>
+    assert.equal(e.detail.request, request)
+  })
+
+  test('has the optional init on the detail', async ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Transport.Http.send, spy)
+    await Events.Transport.Http.send(request, init)
+    globalThis.removeEventListener(EventTypes.Transport.Http.send, spy)
+    const e = spy.args[0][0] as CustomEvent<IHttpRequestDetail>
+    assert.deepEqual(e.detail.init, init)
+  })
+})

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

@@ -1,5 +1,6 @@
 import { test } from '@japa/runner'
 import { DataDomain } from '../../../src/modeling/DataDomain.js'
+import type { DomainEntity } from '../../../src/modeling/DomainEntity.js'
 
 test.group('DataDomain.registerForeignDomain()', () => {
   test('registers a foreign domain', ({ assert }) => {
@@ -424,6 +425,180 @@ test.group('DataDomain.findEntity()', () => {
   })
 })
 
+test.group('DataDomain.listForeignNamespaces()', () => {
+  test('lists all namespaces from a registered foreign domain', ({ assert }) => {
+    const localDomain = new DataDomain()
+    const foreignDomain = new DataDomain({ key: 'foreignKey' })
+    foreignDomain.info.version = '1.0.0'
+
+    const ns1Foreign = foreignDomain.addNamespace({ key: 'ns1' })
+    const ns2Foreign = foreignDomain.addNamespace({ key: 'ns2' })
+
+    localDomain.registerForeignDomain(foreignDomain)
+
+    const namespaces = [...localDomain.listForeignNamespaces(foreignDomain.key)]
+    assert.lengthOf(namespaces, 2)
+    assert.deepInclude(namespaces, ns1Foreign)
+    assert.deepInclude(namespaces, ns2Foreign)
+  })
+
+  test('returns an empty generator if the foreign domain has no namespaces', ({ assert }) => {
+    const localDomain = new DataDomain()
+    const foreignDomain = new DataDomain({ key: 'foreignKey' })
+    foreignDomain.info.version = '1.0.0'
+    localDomain.registerForeignDomain(foreignDomain)
+
+    const namespaces = [...localDomain.listForeignNamespaces(foreignDomain.key)]
+    assert.lengthOf(namespaces, 0)
+  })
+
+  test('returns an empty generator if foreign namespaces are not in the local graph', ({ assert }) => {
+    const localDomain = new DataDomain()
+    const foreignDomain = new DataDomain({ key: 'foreignKey' })
+    foreignDomain.info.version = '1.0.0'
+    foreignDomain.addNamespace({ key: 'ns1' })
+    localDomain.registerForeignDomain(foreignDomain)
+
+    // Simulate that the foreign namespaces are not in the local graph
+    localDomain.graph.removeNode(`${foreignDomain.key}:ns1`)
+
+    const namespacesAfterRemoval = [...localDomain.listForeignNamespaces(foreignDomain.key)]
+    assert.lengthOf(namespacesAfterRemoval, 0)
+  })
+
+  test('throws an error if the foreign domain key is not registered', ({ assert }) => {
+    const localDomain = new DataDomain()
+    assert.throws(
+      () => [...localDomain.listForeignNamespaces('nonExistentKey')],
+      'Foreign domain nonExistentKey not found'
+    )
+  })
+})
+
+test.group('DataDomain.listForeignModels()', () => {
+  test('lists all models from a registered foreign domain', ({ assert }) => {
+    const localDomain = new DataDomain()
+    const foreignDomain = new DataDomain({ key: 'foreignKey' })
+    foreignDomain.info.version = '1.0.0'
+
+    const model1Foreign = foreignDomain.addModel({ key: 'model1' })
+    const model2Foreign = foreignDomain.addModel({ key: 'model2' })
+
+    localDomain.registerForeignDomain(foreignDomain)
+
+    // Ensure the foreign nodes are in the local graph (simulating mergeGraph)
+    localDomain.graph.setNode(`${foreignDomain.key}:${model1Foreign.key}`, model1Foreign)
+    localDomain.graph.setNode(`${foreignDomain.key}:${model2Foreign.key}`, model2Foreign)
+
+    const models = [...localDomain.listForeignModels(foreignDomain.key)]
+    assert.lengthOf(models, 2)
+    assert.deepInclude(models, model1Foreign)
+    assert.deepInclude(models, model2Foreign)
+  })
+
+  test('returns an empty generator if the foreign domain has no models', ({ assert }) => {
+    const localDomain = new DataDomain()
+    const foreignDomain = new DataDomain({ key: 'foreignKey' })
+    foreignDomain.info.version = '1.0.0'
+    localDomain.registerForeignDomain(foreignDomain)
+
+    const models = [...localDomain.listForeignModels(foreignDomain.key)]
+    assert.lengthOf(models, 0)
+  })
+
+  test('returns an empty generator if foreign models are not in the local graph', ({ assert }) => {
+    const localDomain = new DataDomain()
+    const foreignDomain = new DataDomain({ key: 'foreignKey' })
+    foreignDomain.info.version = '1.0.0'
+    foreignDomain.addModel({ key: 'model1' })
+    localDomain.registerForeignDomain(foreignDomain)
+
+    // Simulate that the foreign models are not in the local graph
+    localDomain.graph.removeNode(`${foreignDomain.key}:model1`)
+
+    const modelsAfterRemoval = [...localDomain.listForeignModels(foreignDomain.key)]
+    assert.lengthOf(modelsAfterRemoval, 0)
+  })
+
+  test('throws an error if the foreign domain key is not registered', ({ assert }) => {
+    const localDomain = new DataDomain()
+    assert.throws(() => [...localDomain.listForeignModels('nonExistentKey')], 'Foreign domain nonExistentKey not found')
+  })
+})
+
+test.group('DataDomain.listForeignEntities()', () => {
+  test('lists all entities from a registered foreign domain', ({ assert }) => {
+    const localDomain = new DataDomain()
+    const foreignDomain = new DataDomain({ key: 'foreignKey' })
+    foreignDomain.info.version = '1.0.0'
+
+    const modelForeign = foreignDomain.addModel({ key: 'modelF' })
+    const entity1Foreign = foreignDomain.addEntity(modelForeign.key, { key: 'entity1' })
+    const entity2Foreign = foreignDomain.addEntity(modelForeign.key, { key: 'entity2' })
+
+    localDomain.registerForeignDomain(foreignDomain)
+
+    // Ensure the foreign nodes are in the local graph (simulating mergeGraph)
+    localDomain.graph.setNode(`${foreignDomain.key}:${entity1Foreign.key}`, entity1Foreign)
+    localDomain.graph.setNode(`${foreignDomain.key}:${entity2Foreign.key}`, entity2Foreign)
+
+    const entities = [...localDomain.listForeignEntities(foreignDomain.key)]
+    assert.lengthOf(entities, 2)
+    assert.deepInclude(entities, entity1Foreign)
+    assert.deepInclude(entities, entity2Foreign)
+  })
+
+  test('returns an empty generator if the foreign domain has no entities', ({ assert }) => {
+    const localDomain = new DataDomain()
+    const foreignDomain = new DataDomain({ key: 'foreignKey' })
+    foreignDomain.info.version = '1.0.0'
+    localDomain.registerForeignDomain(foreignDomain)
+
+    const entities = [...localDomain.listForeignEntities(foreignDomain.key)]
+    assert.lengthOf(entities, 0)
+  })
+
+  test('returns an empty generator if foreign entities are not in the local graph', ({ assert }) => {
+    const localDomain = new DataDomain()
+    const foreignDomain = new DataDomain({ key: 'foreignKey' })
+    foreignDomain.info.version = '1.0.0'
+    const modelForeign = foreignDomain.addModel({ key: 'modelF' })
+    foreignDomain.addEntity(modelForeign.key, { key: 'entity1' })
+    localDomain.registerForeignDomain(foreignDomain)
+
+    // Simulate that the foreign entities are not in the local graph
+    localDomain.graph.removeNode(`${foreignDomain.key}:entity1`)
+
+    const entitiesAfterRemoval = [...localDomain.listForeignEntities(foreignDomain.key)]
+    assert.lengthOf(entitiesAfterRemoval, 0)
+  })
+
+  test('throws an error if the foreign domain key is not registered', ({ assert }) => {
+    const localDomain = new DataDomain()
+    assert.throws(
+      () => [...localDomain.listForeignEntities('nonExistentKey')],
+      'Foreign domain nonExistentKey not found'
+    )
+  })
+
+  test('lists entities from a foreign domain even if local domain has entities', ({ assert }) => {
+    const localDomain = new DataDomain()
+    const modelLocal = localDomain.addModel({ key: 'modelL' })
+    localDomain.addEntity(modelLocal.key, { key: 'entityL' })
+
+    const foreignDomain = new DataDomain({ key: 'foreignKey' })
+    foreignDomain.info.version = '1.0.0'
+    const modelForeign = foreignDomain.addModel({ key: 'modelF' })
+    const entityForeign = foreignDomain.addEntity(modelForeign.key, { key: 'entityF' })
+    localDomain.registerForeignDomain(foreignDomain)
+
+    const entities = [...localDomain.listForeignEntities(foreignDomain.key)]
+    assert.lengthOf(entities, 1)
+    assert.deepInclude(entities, entityForeign)
+    assert.notDeepInclude(entities, localDomain.findEntity('entityL') as DomainEntity)
+  })
+})
+
 test.group('DataDomain.findAssociation()', () => {
   test('finds a foreign association by its key and domain key', ({ assert }) => {
     const domain = new DataDomain()
@@ -486,3 +661,72 @@ test.group('DataDomain.findProperty()', () => {
     }, `Foreign domain non-existent-domain not found`)
   })
 })
+
+test.group('DataDomain foreign elements namespace property', () => {
+  test('DomainNamespace retains its original namespace key after foreign registration', ({ assert }) => {
+    const localDomain = new DataDomain({ key: 'localKey' })
+    const foreignDomain = new DataDomain({ key: 'foreignKey' })
+    foreignDomain.addNamespace({ key: 'nsInForeign' })
+    foreignDomain.info.version = '1.0.0'
+    localDomain.registerForeignDomain(foreignDomain)
+
+    const retrievedNs = localDomain.findNamespace('nsInForeign', 'foreignKey')
+    assert.ok(retrievedNs, 'Foreign namespace should be found in local domain')
+    assert.equal(retrievedNs!.namespace, 'foreignKey', 'Namespace property should point to foreign domain key')
+    assert.equal(retrievedNs!.domain.key, 'foreignKey', 'Domain property should point to local domain key')
+  })
+
+  test('DomainModel retains its original namespace key after foreign registration', ({ assert }) => {
+    const localDomain = new DataDomain({ key: 'localKey' })
+    const foreignDomain = new DataDomain({ key: 'foreignKey' })
+    foreignDomain.info.version = '1.0.0'
+
+    foreignDomain.addModel({ key: 'modelInForeign' })
+    localDomain.registerForeignDomain(foreignDomain)
+
+    const retrievedModel = localDomain.findModel('modelInForeign', 'foreignKey')
+    assert.ok(retrievedModel, 'Foreign model should be found in local domain')
+    assert.equal(retrievedModel!.namespace, 'foreignKey', 'Namespace property should point to foreign domain key')
+    assert.equal(retrievedModel!.domain.key, 'foreignKey', 'Domain property should point to local domain key')
+  })
+
+  test('DomainEntity retains its original namespace key after foreign registration', ({ assert }) => {
+    const localDomain = new DataDomain({ key: 'localKey' })
+    const foreignDomain = new DataDomain({ key: 'foreignKey' })
+    foreignDomain.info.version = '1.0.0'
+
+    const parentForeignModel = foreignDomain.addModel({ key: 'parentModelInForeign' })
+    foreignDomain.addEntity(parentForeignModel.key, { key: 'entityInForeign' })
+    localDomain.registerForeignDomain(foreignDomain)
+
+    const retrievedEntity = localDomain.findEntity('entityInForeign', 'foreignKey')
+    assert.ok(retrievedEntity, 'Foreign entity should be found in local domain')
+    assert.equal(retrievedEntity!.namespace, 'foreignKey', 'Namespace property should point to foreign domain key')
+    assert.equal(retrievedEntity!.domain.key, 'foreignKey', 'Domain property should point to local domain key')
+  })
+
+  test('DomainProperty retains its original namespace key after foreign registration', ({ assert }) => {
+    const localDomain = new DataDomain({ key: 'localKey' })
+    const foreignDomain = new DataDomain({ key: 'foreignKey' })
+    foreignDomain.info.version = '1.0.0'
+
+    const parentForeignModel = foreignDomain.addModel({ key: 'parentModelInForeign' })
+    const parentForeignEntity = foreignDomain.addEntity(parentForeignModel.key, { key: 'parentEntityInForeign' })
+    foreignDomain.addProperty(parentForeignEntity.key, { key: 'propertyInForeign' })
+    localDomain.registerForeignDomain(foreignDomain)
+
+    const retrievedProperty = localDomain.findProperty('propertyInForeign', 'foreignKey')
+    assert.ok(retrievedProperty, 'Foreign property should be found in local domain')
+    assert.equal(retrievedProperty!.namespace, 'foreignKey', 'Namespace property should point to foreign domain key')
+    assert.equal(retrievedProperty!.domain.key, 'foreignKey', 'Domain property should point to local domain key')
+  })
+
+  test('DomainElement.namespace is the key of the domain it was created in', ({ assert }) => {
+    const domain = new DataDomain({ key: 'originalDomainKey' })
+    const model = domain.addModel({ key: 'myModel' })
+    const entity = model.addEntity({ key: 'myEntity' })
+
+    assert.equal(model.namespace, 'originalDomainKey')
+    assert.equal(entity.namespace, 'originalDomainKey')
+  })
+})