@api-client/core 0.14.8 → 0.14.10

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

@@ -42062,10 +42062,10 @@
 "@id": "#209"
 },
 {
-"@id": "#194"
+"@id": "#191"
 },
 {
-"@id": "#191"
+"@id": "#194"
 },
 {
 "@id": "#197"
@@ -42810,16 +42810,16 @@
 "@id": "#219"
 },
 {
-"@id": "#219"
+"@id": "#210"
 },
 {
-"@id": "#210"
+"@id": "#213"
 },
 {
 "@id": "#216"
 },
 {
-"@id": "#213"
+"@id": "#219"
 }
 ],
 "doc:root": false,
@@ -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": "countryCode: \"BE\"\ngraydonEnterpriseId: 1057155523\nregistrationId: \"0422319093\"\nvatNumber: \"BE0422319093\"\ngraydonCompanyId: \"0422319093\"\nisBranchOffice: false\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": [
 {
@@ -44232,7 +44232,7 @@
 "doc:ExternalDomainElement",
 "doc:DomainElement"
 ],
-"doc:raw": "type: 'GENERAL'\ncountryDialCode : '+32'\nareaCode : '21'\nsubscriberNumber: '12.87.00'\nformatted: '+32-(0)21 302099'\n",
+"doc:raw": "type: 'GENERAL'\ncountryDialCode : '+32'\nareaCode : '22'\nsubscriberNumber: '12.87.00'\nformatted: '+32-(0)22 000000'\n",
 "core:mediaType": "application/yaml",
 "sourcemaps:sources": [
 {
@@ -44253,7 +44253,7 @@
 "doc:ExternalDomainElement",
 "doc:DomainElement"
 ],
-"doc:raw": "type: \"GENERAL\"\nvalue: \"www.company.be\"\n",
+"doc:raw": "type: 'GENERAL'\ncountryDialCode : '+32'\nareaCode : '21'\nsubscriberNumber: '12.87.00'\nformatted: '+32-(0)21 302099'\n",
 "core:mediaType": "application/yaml",
 "sourcemaps:sources": [
 {
@@ -44295,7 +44295,7 @@
 "doc:ExternalDomainElement",
 "doc:DomainElement"
 ],
-"doc:raw": "type: 'GENERAL'\ncountryDialCode : '+32'\nareaCode : '22'\nsubscriberNumber: '12.87.00'\nformatted: '+32-(0)22 000000'\n",
+"doc:raw": "type: \"GENERAL\"\nvalue: \"www.company.be\"\n",
 "core:mediaType": "application/yaml",
 "sourcemaps:sources": [
 {
@@ -44756,12 +44756,12 @@
 {
 "@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)-(7,0)]"
+"sourcemaps:value": "[(1,0)-(10,0)]"
 },
 {
 "@id": "#199/source-map/lexical/element_0",
@@ -45121,7 +45121,7 @@
 {
 "@id": "#215/source-map/lexical/element_0",
 "sourcemaps:element": "amf://id#215",
-"sourcemaps:value": "[(1,0)-(3,0)]"
+"sourcemaps:value": "[(1,0)-(6,0)]"
 },
 {
 "@id": "#218/source-map/lexical/element_0",
@@ -45131,7 +45131,7 @@
 {
 "@id": "#221/source-map/lexical/element_0",
 "sourcemaps:element": "amf://id#221",
-"sourcemaps:value": "[(1,0)-(6,0)]"
+"sourcemaps:value": "[(1,0)-(3,0)]"
 },
 {
 "@id": "#338/source-map/synthesized-field/element_1",

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

package/src/modeling/DataDomain.ts

@@ -394,6 +394,33 @@ export class DataDomain extends DependentModel {
     }
   }
 
+  /**
+   * Lists all namespaces in the graph that are part of specified domain.
+   *
+   * @param namespace The foreign namespace to search in. When not found, it throws an error.
+   * @returns A generator that yields each `DomainNamespace`.
+   * @throws Error When the foreign domain is not found.
+   * @example
+   * ```typescript
+   * for (const ns of dataDomain.listForeignNamespaces('foreignDomainKey')) {
+   *   console.log(ns.key);
+   * }
+   * ```
+   */
+  *listForeignNamespaces(namespace: string): Generator<DomainNamespace> {
+    const foreignDomain = this.dependencies.get(namespace)
+    if (!foreignDomain) {
+      throw new Error(`Foreign domain ${namespace} not found`)
+    }
+    for (const node of foreignDomain.listNamespaces()) {
+      const key = `${namespace}:${node.key}`
+      const value = this.graph.node(key)
+      if (value) {
+        yield node
+      }
+    }
+  }
+
   /**
    * Checks if this data domain has any namespaces.
    *
@@ -661,8 +688,8 @@ export class DataDomain extends DependentModel {
    * @returns A generator that yields each `DomainModel`.
    * @example
    * ```typescript
-   * for (const ns of namespace.listModels()) {
-   *   console.log(ns.key);
+   * for (const model of namespace.listModels()) {
+   *   console.log(model.key);
    * }
    * ```
    */
@@ -679,6 +706,33 @@ export class DataDomain extends DependentModel {
     }
   }
 
+  /**
+   * Lists all models in the graph that are part of specified domain.
+   *
+   * @param namespace The foreign namespace to search in. When not found, it throws an error.
+   * @returns A generator that yields each `DomainModel`.
+   * @throws Error When the foreign domain is not found.
+   * @example
+   * ```typescript
+   * for (const model of dataDomain.listForeignModels('foreignDomainKey')) {
+   *   console.log(model.key);
+   * }
+   * ```
+   */
+  *listForeignModels(namespace: string): Generator<DomainModel> {
+    const foreignDomain = this.dependencies.get(namespace)
+    if (!foreignDomain) {
+      throw new Error(`Foreign domain ${namespace} not found`)
+    }
+    for (const node of foreignDomain.listModels()) {
+      const key = `${namespace}:${node.key}`
+      const value = this.graph.node(key)
+      if (value) {
+        yield node
+      }
+    }
+  }
+
   /**
    * Checks if this data domain has any direct models.
    *
@@ -893,10 +947,37 @@ export class DataDomain extends DependentModel {
     }
   }
 
+  /**
+   * Lists all entities in the graph that are part of specified domain.
+   *
+   * @param namespace The foreign namespace to search in. When not found, it throws an error.
+   * @returns A generator that yields each `DomainEntity`.
+   * @throws Error When the foreign domain is not found.
+   * @example
+   * ```typescript
+   * for (const model of dataDomain.listForeignEntities('foreignDomainKey')) {
+   *   console.log(model.key);
+   * }
+   * ```
+   */
+  *listForeignEntities(namespace: string): Generator<DomainEntity> {
+    const foreignDomain = this.dependencies.get(namespace)
+    if (!foreignDomain) {
+      throw new Error(`Foreign domain ${namespace} not found`)
+    }
+    for (const node of foreignDomain.listEntities()) {
+      const key = `${namespace}:${node.key}`
+      const value = this.graph.node(key)
+      if (value) {
+        yield node
+      }
+    }
+  }
+
   /**
    * Lists all entities in the graph that are not part of this domain.
    */
-  *listForeignEntities(): Generator<DomainEntity> {
+  *listAllForeignEntities(): Generator<DomainEntity> {
     for (const node of this.graph.nodes()) {
       const value = this.graph.node(node) as DomainGraphNodeType
       if (value.kind === DomainEntityKind && value.domain.key !== this.key) {

package/src/modeling/DomainElement.ts

@@ -39,6 +39,18 @@ export abstract class DomainElement implements DomainElementSchema {
     return this.#key
   }
 
+  #namespace: string
+
+  /**
+   * The key of the DataDomain this element belongs to.
+   * In a data domain that has foreign namespaces, this is the key of the namespace this element originally belongs to.
+   *
+   * It might be different from the `domain.key` if the element is a foreign object.
+   */
+  get namespace(): string {
+    return this.#namespace
+  }
+
   /**
    * @param root The root DataDomain instance.
    * @param key The unique key of the domain element.
@@ -46,5 +58,9 @@ export abstract class DomainElement implements DomainElementSchema {
   constructor(root: DataDomain, key: string) {
     this.root = root
     this.#key = key
+    // When dependencies are loaded, they all first belong to the root domain.
+    // When the foreign domain is merged, the object is transferred to the other domain,
+    // but the namespace is still the root domain key.
+    this.#namespace = root.key
   }
 }

package/src/modeling/validation/entity_validation.ts

@@ -225,7 +225,7 @@ export class EntityValidation {
         })
       }
     }
-    for (const other of this.domain.listForeignEntities()) {
+    for (const other of this.domain.listAllForeignEntities()) {
       if (other.info.name?.toLowerCase() === name && other.key !== entity.key) {
         const message = `The "${name}" entity name is already used in the foreign data domain.`
         const help = `The name must be unique. This includes references to other data domains.`

package/src/sdk/DataCatalogSdk.ts

@@ -288,7 +288,7 @@ export class DataCatalogSdk extends SdkBase {
   async listDependencies(
     dependencies?: ForeignDomainDependency[],
     request: SdkOptions = {}
-  ): Promise<ContextListResult<DataDomainSchema[]>> {
+  ): Promise<ContextListResult<DataDomainSchema>> {
     const { token } = request
     const url = this.sdk.getUrl(RouteBuilder.dataCatalogDependencies())
     const body = JSON.stringify({ items: dependencies })
@@ -308,7 +308,7 @@ export class DataCatalogSdk extends SdkBase {
     if (!result.body) {
       throw new Exception(`${E_PREFIX}${E_RESPONSE_NO_VALUE}`, { code: 'E_RESPONSE_NO_VALUE', status: result.status })
     }
-    let data: ContextListResult<DataDomainSchema[]>
+    let data: ContextListResult<DataDomainSchema>
     try {
       data = JSON.parse(result.body)
     } catch {

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')
+  })
+})