@api-client/core 0.18.61 → 0.18.63

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

@@ -42810,9 +42810,6 @@
 "@id": "#219"
 },
 {
-"@id": "#219"
-},
-{
 "@id": "#210"
 },
 {
@@ -42820,6 +42817,9 @@
 },
 {
 "@id": "#216"
+},
+{
+"@id": "#219"
 }
 ],
 "doc:root": false,
@@ -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": "-\n  type: 'GENERAL'\n  value: 'info@company.be'\n-\n  type: 'IT_DEPT'\n  value: 'it-service@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": [
 {
@@ -44274,7 +44274,7 @@
 "doc:ExternalDomainElement",
 "doc:DomainElement"
 ],
-"doc:raw": "type: \"GENERAL\"\nvalue: \"www.company.be\"\n",
+"doc:raw": "-\n  type: 'GENERAL'\n  value: 'info@company.be'\n-\n  type: 'IT_DEPT'\n  value: 'it-service@company.be'\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": [
 {
@@ -45121,17 +45121,17 @@
 {
 "@id": "#215/source-map/lexical/element_0",
 "sourcemaps:element": "amf://id#215",
-"sourcemaps:value": "[(1,0)-(7,0)]"
+"sourcemaps:value": "[(1,0)-(6,0)]"
 },
 {
 "@id": "#218/source-map/lexical/element_0",
 "sourcemaps:element": "amf://id#218",
-"sourcemaps:value": "[(1,0)-(3,0)]"
+"sourcemaps:value": "[(1,0)-(7,0)]"
 },
 {
 "@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.18.61",
+  "version": "0.18.63",
   "license": "Apache-2.0",
   "exports": {
     "./browser.js": {
@@ -108,7 +108,7 @@
   "devDependencies": {
     "@commitlint/cli": "^20.1.0",
     "@commitlint/config-conventional": "^20.0.0",
-    "@eslint/js": "^9.20.0",
+    "@eslint/js": "^10.0.1",
     "@japa/api-client": "^3.0.3",
     "@japa/assert": "^4.0.1",
     "@japa/browser-client": "^2.1.1",
@@ -128,13 +128,13 @@
     "@web/dev-server-rollup": "^0.6.4",
     "@web/test-runner": "^0.20.0",
     "@web/test-runner-playwright": "^0.11.0",
-    "amf-client-js": "^5.9.1-3",
+    "amf-client-js": "^5.10.0-0",
     "c8": "^10.1.3",
     "chai-as-promised": "^8.0.2",
     "conventional-changelog": "^7.1.0",
     "conventional-changelog-conventionalcommits": "^9.1.0",
     "cors": "^2.8.5",
-    "eslint": "^9.20.1",
+    "eslint": "^10.0.1",
     "eslint-config-prettier": "^10.0.1",
     "eslint-plugin-no-only-tests": "^3.3.0",
     "eslint-plugin-prettier": "^5.2.3",

package/src/modeling/DataDomain.ts

@@ -9,7 +9,6 @@ import {
   DomainPropertyKind,
 } from '../models/kinds.js'
 import type {
-  AssociationAddOptions,
   DeserializationIssue,
   DeserializationMode,
   DomainGraphEdge,
@@ -22,7 +21,7 @@ import type {
 import { type DomainNamespaceSchema, DomainNamespace, type NamespaceOrderedItem } from './DomainNamespace.js'
 import { type DomainModelSchema, DomainModel } from './DomainModel.js'
 import { type DomainEntitySchema, DomainEntity } from './DomainEntity.js'
-import { DomainAssociation } from './DomainAssociation.js'
+import { DomainAssociation, DomainAssociationSchema } from './DomainAssociation.js'
 import { DomainProperty, DomainPropertySchema } from './DomainProperty.js'
 import { type IThing, Thing } from '../models/Thing.js'
 import { removeGraphNode } from './GraphUtils.js'
@@ -57,6 +56,7 @@ export interface DataDomainSchema extends DependentModelSchema {
  * -   **Root Container:** Holds all data elements within a domain.
  * -   **Graph-Based Structure:** Uses a graph to represent relationships between data elements.
  * -   **Namespace Management:** Supports creating and managing namespaces to organize data models.
+ *                               Namespaces are optional.
  * -   **Data Model Management:** Supports creating and managing data models to group entities.
  * -   **Entity Management:** Supports creating and managing entities, which define the structure of data.
  * -   **Property Management:** Supports creating and managing properties, which define the data elements
@@ -1084,17 +1084,17 @@ export class DataDomain extends DependentModel {
    * calls the `addAssociation` method on it.
    *
    * @param source The key of the source entity.
-   * @param init The association options.
+   * @param input The partial association schema.
    * @returns The created association.
    * @throws Error When the source entity does not exist.
    * @example
    * ```typescript
    * const addressAssociation = dataDomain.addAssociation(
-   *   'user', { key: 'address' }
+   *   'user-key', { targets: [{ key: 'address-key' }] }
    * );
    * ```
    */
-  addAssociation(source: string, init?: AssociationAddOptions): DomainAssociation {
+  addAssociation(source: string, input?: Partial<DomainAssociationSchema>): DomainAssociation {
     if (!this.graph.hasNode(source)) {
       throw new Error(`Source entity ${source} not found`)
     }
@@ -1105,7 +1105,7 @@ export class DataDomain extends DependentModel {
     if (entity.domain.key !== this.key) {
       throw new Error(`Cannot add an association to a foreign domain`)
     }
-    return entity.addAssociation(init)
+    return entity.addAssociation(input)
   }
 
   /**

package/src/modeling/DomainAssociation.ts

@@ -625,7 +625,7 @@ export class DomainAssociation extends DomainElement {
       copy.info = { name: newName }
     }
 
-    const result = parent.addAssociation({}, copy)
+    const result = parent.addAssociation(copy)
 
     // Copy the target entities
     for (const target of this.targets) {

package/src/modeling/DomainEntity.ts

@@ -8,7 +8,6 @@ import type { IShapeUnion } from '../amf/definitions/Shapes.js'
 import { DomainProperty, type DomainPropertySchema } from './DomainProperty.js'
 import { RemovePropertyException } from '../exceptions/remove_property_exception.js'
 import { DomainAssociation, DomainAssociationSchema } from './DomainAssociation.js'
-import type { AssociationAddOptions } from './types.js'
 import type { FileBreadcrumb } from '../models/store/File.js'
 import type { DomainModel } from './DomainModel.js'
 import type { DomainNamespace } from './DomainNamespace.js'
@@ -628,35 +627,54 @@ export class DomainEntity extends DomainElement {
   /**
    * Adds an association to this entity.
    *
-   * @param init The association options.
+   * Add rules:
+   * - If the target is specified, it has to exist in the graph.
+   * - The association targets can be local or foreign.
+   *
+   * Please note that you can't just add targets to the association schema.
+   * This function manipulates the graph to insert the required metadata.
+   *
    * @param input The partial association schema.
    * @returns The created `DomainAssociation` instance.
    * @throws Error When the target entity does not exist.
    * @example
    * ```typescript
-   * const association = entity.addAssociation({
-   *   key: 'address',
-   * });
+   * const association = entity.addAssociation({ info: { name: 'Address' }, targets: [{ key: 'address' }] });
    * ```
    */
-  addAssociation(init: AssociationAddOptions = {}, input?: Partial<DomainAssociationSchema>): DomainAssociation {
+  addAssociation(input: Partial<DomainAssociationSchema> = {}): DomainAssociation {
     const { graph } = this.root
-    if (init.domain && init.key) {
-      // target is foreign
-      const foreignKey = `${init.domain}:${init.key}`
-      if (!graph.hasNode(foreignKey)) {
-        throw new Error(`Foreign entity ${foreignKey} not found`)
-      }
-    } else if (init.key) {
-      if (!graph.hasNode(init.key)) {
-        throw new Error(`Target entity ${init.key} not found`)
+
+    // clean up any target information from the input
+    // so we won't break the graph and the app.
+    const inputCopy = { ...input }
+    const targets = inputCopy.targets
+    delete inputCopy.targets
+
+    const hasTargets = Array.isArray(targets) && targets.length
+    if (hasTargets) {
+      for (const target of targets) {
+        if (target.domain && target.key) {
+          // target is foreign
+          const foreignKey = `${target.domain}:${target.key}`
+          if (!graph.hasNode(foreignKey)) {
+            throw new Error(`Foreign entity ${foreignKey} not found`)
+          }
+        } else if (target.key) {
+          if (!graph.hasNode(target.key)) {
+            throw new Error(`Target entity ${target.key} not found`)
+          }
+        }
       }
     }
-    const item = new DomainAssociation(this.root, this.key, input)
+
+    const item = new DomainAssociation(this.root, this.key, inputCopy)
     graph.setNode(item.key, item)
     graph.setEdge(this.key, item.key, { type: 'association' })
-    if (init.key) {
-      item.addTarget(init.key, init.domain)
+    if (hasTargets) {
+      for (const target of targets) {
+        item.addTarget(target.key, target.domain)
+      }
     }
     this.fields.push({ type: 'association', key: item.key })
     this.root.notifyChange()

package/src/modeling/helpers/Intelisense.ts

@@ -325,13 +325,10 @@ export function addOwnerField(entity: DomainEntity, info: Partial<IThing> = {}):
   if (existing) {
     return existing
   }
-  const prop = entity.addAssociation(
-    {},
-    {
-      info: { name: 'owner', displayName: 'Owner', ...info },
-      required: true,
-    }
-  )
+  const prop = entity.addAssociation({
+    info: { name: 'owner', displayName: 'Owner', ...info },
+    required: true,
+  })
   prop.addSemantic({
     id: SemanticType.ResourceOwnerIdentifier,
   })
@@ -378,13 +375,10 @@ export function addUpdatedByField(entity: DomainEntity, info: Partial<IThing> =
   if (existing) {
     return existing
   }
-  const prop = entity.addAssociation(
-    {},
-    {
-      info: { name: 'updated_by', displayName: 'Updated By', ...info },
-      required: true,
-    }
-  )
+  const prop = entity.addAssociation({
+    info: { name: 'updated_by', displayName: 'Updated By', ...info },
+    required: true,
+  })
   prop.addSemantic({
     id: SemanticType.ResourceOwnerIdentifier,
   })

package/src/modeling/importers/JsonSchemaImporter.ts

@@ -455,7 +455,7 @@ export class JsonSchemaImporter {
     // Case 2: If any `$ref` was found, we treat it as an Association.
     if (analysis.refs.size > 0) {
       const sanitizedName = toDatabaseColumnName(propName, 'untitled_association')
-      const assoc = entity.addAssociation({}, { info: { name: sanitizedName } })
+      const assoc = entity.addAssociation({ info: { name: sanitizedName } })
       if (sanitizedName !== propName) {
         assoc.info.displayName = propName // Keep original name for display
       }

package/src/modeling/types.ts

@@ -33,21 +33,6 @@ export interface DataDomainRemoveOptions {
   force?: boolean
 }
 
-export interface AssociationAddOptions {
-  /**
-   * When set, it is the the association target's origin data domain.
-   * The key of the target data domain where this target entity is defined.
-   * Only used when `key` is specified.
-   */
-  domain?: string
-  /**
-   * The key of the association target, if known.
-   * If the target of the association is not specified, and the association has no other targets,
-   * the association is ignored in the namespace while processing.
-   */
-  key?: string
-}
-
 export interface DomainGraphEdge {
   /**
    * Indicates that the edge is to or from a foreign domain.

package/src/sdk/DataCatalogSdk.ts

@@ -388,9 +388,19 @@ export class DataCatalogSdk extends SdkBase {
     return data
   }
 
-  async checkPublicationStatus(domainId: string, request: SdkOptions = {}): Promise<DataCatalogStatus> {
+  /**
+   * Checks the publication status of a data domain.
+   * @param domainKey The key of the data domain to check.
+   * @param oid The optional ID of the organization. Optional for public domains.
+   * @param request The request options.
+   * @returns The publication status of the data domain.
+   */
+  async checkPublicationStatus(domainKey: string, oid?: string, request: SdkOptions = {}): Promise<DataCatalogStatus> {
     const { token } = request
-    const url = this.sdk.getUrl(RouteBuilder.dataCatalogStatus(domainId))
+    const url = this.sdk.getUrl(RouteBuilder.dataCatalogStatus(domainKey))
+    if (oid) {
+      url.searchParams.set('oid', oid)
+    }
     const result = await this.sdk.http.get(url.toString(), { token })
     this.inspectCommonStatusCodes(result)
     const E_PREFIX = 'Unable to check data domain publication status. '

package/tests/unit/modeling/amf/shape_generator.spec.ts

@@ -95,7 +95,7 @@ test.group('entity()', (group) => {
 
   test('adds associations to the properties', ({ assert }) => {
     e1.addProperty({ key: 'test', info: { name: 'test' } })
-    e1.addAssociation({}, { info: { name: 'test association' } })
+    e1.addAssociation({ info: { name: 'test association' } })
     const result = e1.toApiShape() as IApiNodeShape
 
     assert.lengthOf(result.properties, 2)
@@ -777,7 +777,7 @@ test.group('associationProperty()', (group) => {
     m1 = root.addModel({ key: 'm1' })
     e1 = m1.addEntity({ key: 'e1', info: { name: 'e1' } })
     e2 = m1.addEntity({ key: 'e2', info: { name: 'e2' } })
-    a1 = e1.addAssociation({ key: e2.key }, { key: 'a1', info: { name: 'a1' } })
+    a1 = e1.addAssociation({ targets: [{ key: e2.key }], key: 'a1', info: { name: 'a1' } })
     e1.addProperty({ key: 'p1', type: 'boolean', info: { name: 'p1' } })
     p2 = e2.addProperty({ key: 'p2', type: 'number', info: { name: 'p2' } })
   })
@@ -1048,7 +1048,7 @@ test.group('AI Generated tests', (group) => {
     m1 = root.addModel({ key: 'm1' })
     e1 = m1.addEntity({ key: 'e1', info: { name: 'e1' } })
     e2 = m1.addEntity({ key: 'e2', info: { name: 'e2' } })
-    a1 = e1.addAssociation({ key: e2.key }, { key: 'a1', info: { name: 'a1' } })
+    a1 = e1.addAssociation({ targets: [{ key: e2.key }], key: 'a1', info: { name: 'a1' } })
     p1 = e1.addProperty({ key: 'p1', info: { name: 'p1' } })
   })
 
@@ -1067,7 +1067,7 @@ test.group('AI Generated tests', (group) => {
     const e3 = m2.addEntity({ key: 'e3', info: { name: 'e3' } })
     fd1.info.version = '1.0.0'
     root.registerForeignDomain(fd1)
-    const a2 = e1.addAssociation({ key: e3.key, domain: fd1.key }, { key: 'a2', info: { name: 'a2' } })
+    const a2 = e1.addAssociation({ targets: [{ key: e3.key, domain: fd1.key }], key: 'a2', info: { name: 'a2' } })
     const result = e1.toApiShape() as IApiNodeShape
     assert.lengthOf(result.properties, 3)
     assert.isTrue(result.properties.some((prop) => prop.id === a2.key))

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

@@ -72,7 +72,7 @@ test.group('ApiModel.exposeEntity()', () => {
     const eA = dm.addEntity({ info: { name: 'A' } })
     const eB = dm.addEntity({ info: { name: 'B' } })
     // Add association from A to B
-    eA.addAssociation({ key: eB.key }, { info: { name: 'entityB' } })
+    eA.addAssociation({ info: { name: 'entityB' }, targets: [{ key: eB.key }] })
     const model = new ApiModel()
     model.attachDataDomain(domain)
     const exposedA = model.exposeEntity({ key: eA.key }, { followAssociations: true })
@@ -90,8 +90,8 @@ test.group('ApiModel.exposeEntity()', () => {
     const eA = dm.addEntity({ info: { name: 'A' } })
     const eB = dm.addEntity({ info: { name: 'B' } })
     // A -> B, B -> A
-    eA.addAssociation({ key: eB.key }, { info: { name: 'assocAB' } })
-    eB.addAssociation({ key: eA.key }, { info: { name: 'assocBA' } })
+    eA.addAssociation({ info: { name: 'assocAB' }, targets: [{ key: eB.key }] })
+    eB.addAssociation({ info: { name: 'assocBA' }, targets: [{ key: eA.key }] })
     const model = new ApiModel()
     model.attachDataDomain(domain)
     model.exposeEntity({ key: eA.key }, { followAssociations: true, maxDepth: 4 })
@@ -114,7 +114,7 @@ test.group('ApiModel.exposeEntity()', () => {
     const dm = domain.addModel()
     const eA = dm.addEntity({ info: { name: 'A' } })
     // A -> A (self-association)
-    eA.addAssociation({ key: eA.key }, { info: { name: 'assocAA' } })
+    eA.addAssociation({ info: { name: 'assocAA' }, targets: [{ key: eA.key }] })
     const model = new ApiModel()
     model.attachDataDomain(domain)
     model.exposeEntity({ key: eA.key }, { followAssociations: true })
@@ -132,8 +132,8 @@ test.group('ApiModel.exposeEntity()', () => {
     const eA = dm.addEntity({ info: { name: 'A' } })
     const eB = dm.addEntity({ info: { name: 'B' } })
     const eC = dm.addEntity({ info: { name: 'C' } })
-    eA.addAssociation({ key: eB.key }, { info: { name: 'toB' } })
-    eB.addAssociation({ key: eC.key }, { info: { name: 'toC' } })
+    eA.addAssociation({ info: { name: 'toB' }, targets: [{ key: eB.key }] })
+    eB.addAssociation({ info: { name: 'toC' }, targets: [{ key: eC.key }] })
     const model = new ApiModel()
     model.attachDataDomain(domain)
     model.exposeEntity({ key: eA.key }, { followAssociations: true })
@@ -152,8 +152,8 @@ test.group('ApiModel.exposeEntity()', () => {
     const eA = dm.addEntity({ info: { name: 'A' } })
     const eB = dm.addEntity({ info: { name: 'B' } })
     const eC = dm.addEntity({ info: { name: 'C' } })
-    eA.addAssociation({ key: eB.key }, { info: { name: 'toB' } })
-    eA.addAssociation({ key: eC.key }, { info: { name: 'toC' } })
+    eA.addAssociation({ info: { name: 'toB' }, targets: [{ key: eB.key }] })
+    eA.addAssociation({ info: { name: 'toC' }, targets: [{ key: eC.key }] })
     const model = new ApiModel()
     model.attachDataDomain(domain)
     model.exposeEntity({ key: eA.key }, { followAssociations: true })
@@ -173,9 +173,9 @@ test.group('ApiModel.exposeEntity()', () => {
     const eB = dm.addEntity({ info: { name: 'B' } })
     const eC = dm.addEntity({ info: { name: 'C' } })
     const eD = dm.addEntity({ info: { name: 'D' } })
-    eA.addAssociation({ key: eB.key }, { info: { name: 'toB' } })
-    eB.addAssociation({ key: eC.key }, { info: { name: 'toC' } })
-    eC.addAssociation({ key: eD.key }, { info: { name: 'toD' } })
+    eA.addAssociation({ info: { name: 'toB' }, targets: [{ key: eB.key }] })
+    eB.addAssociation({ info: { name: 'toC' }, targets: [{ key: eC.key }] })
+    eC.addAssociation({ info: { name: 'toD' }, targets: [{ key: eD.key }] })
     const model = new ApiModel()
     model.attachDataDomain(domain)
     model.exposeEntity({ key: eA.key }, { followAssociations: true, maxDepth: 2 })

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

@@ -23,7 +23,7 @@ test.group('ApiModel.removeEntity()', () => {
     const eA = dm.addEntity({ info: { name: 'A' } })
     const eB = dm.addEntity({ info: { name: 'B' } })
     // A -> B
-    eA.addAssociation({ key: eB.key }, { info: { name: 'toB' } })
+    eA.addAssociation({ info: { name: 'toB' }, targets: [{ key: eB.key }] })
     const model = new ApiModel()
     model.attachDataDomain(domain)
     const rootExposure = model.exposeEntity({ key: eA.key }, { followAssociations: true })

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

@@ -17,7 +17,7 @@ test.group('DataDomain.addAssociation()', () => {
     const model = dataDomain.addModel({ key: 'test-model' })
     const entity1 = dataDomain.addEntity(model.key, { key: 'entity1' })
     const entity2 = dataDomain.addEntity(model.key, { key: 'entity2' })
-    const association = dataDomain.addAssociation(entity1.key, { key: entity2.key })
+    const association = dataDomain.addAssociation(entity1.key, { targets: [{ key: entity2.key }] })
     assert.instanceOf(association, DomainAssociation)
     assert.isTrue(dataDomain.graph.hasNode(association.key))
   }).tags(['@modeling', '@associations', '@add'])
@@ -84,7 +84,7 @@ test.group('DataDomain.addAssociation()', () => {
 
     domain1.registerForeignDomain(domain2)
 
-    const association = domain1.addAssociation(e1.key, { key: 'entity2', domain: domain2.key })
+    const association = domain1.addAssociation(e1.key, { targets: [{ key: 'entity2', domain: domain2.key }] })
     assert.instanceOf(association, DomainAssociation)
     assert.isTrue(domain1.graph.hasNode(association.key))
   }).tags(['@modeling', '@associations', '@add'])
@@ -99,7 +99,7 @@ test.group('DataDomain.addAssociation()', () => {
     domain1.registerForeignDomain(domain2)
 
     assert.throws(() => {
-      domain1.addAssociation(e1.key, { key: 'non-existent-entity', domain: 'domain2' })
+      domain1.addAssociation(e1.key, { targets: [{ key: 'non-existent-entity', domain: 'domain2' }] })
     }, 'Foreign entity domain2:non-existent-entity not found')
   }).tags(['@modeling', '@associations', '@add'])
 })
@@ -159,7 +159,7 @@ test.group('DataDomain.removeAssociation()', () => {
     domain2.info.version = '1.0.0'
     domain1.registerForeignDomain(domain2)
 
-    const association = domain1.addAssociation(e1.key, { key: e2.key, domain: domain2.key })
+    const association = domain1.addAssociation(e1.key, { targets: [{ key: e2.key, domain: domain2.key }] })
     domain1.removeAssociation(association.key)
     assert.isFalse(domain1.graph.hasNode(association.key))
   }).tags(['@modeling', '@associations', '@remove'])
@@ -187,7 +187,7 @@ test.group('DataDomain.removeAssociation()', () => {
     const model = dataDomain.addModel()
     const entity1 = dataDomain.addEntity(model.key, { key: 'entity1' })
     const entity2 = dataDomain.addEntity(model.key, { key: 'entity2' })
-    const association = dataDomain.addAssociation(entity1.key, { key: entity2.key })
+    const association = dataDomain.addAssociation(entity1.key, { targets: [{ key: entity2.key }] })
     dataDomain.removeAssociation(association.key)
     assert.isTrue(dataDomain.graph.hasNode(entity1.key))
     assert.isTrue(dataDomain.graph.hasNode(entity2.key))
@@ -282,7 +282,7 @@ test.group('DataDomain.findAssociation()', () => {
     const e2 = domain2.addEntity(m2.key, { key: 'entity2' })
     domain2.info.version = '1.0.0'
     domain1.registerForeignDomain(domain2)
-    const association = domain1.addAssociation(e1.key, { key: e2.key, domain: domain2.key })
+    const association = domain1.addAssociation(e1.key, { targets: [{ key: e2.key, domain: domain2.key }] })
 
     const foundAssociation = domain1.findAssociation(association.key)
     assert.deepEqual(foundAssociation, association)

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

@@ -118,7 +118,7 @@ test.group('DataDomain.registerForeignDomain()', () => {
     const model = foreignDomain.addModel({ key: 'test-model' })
     const entity1 = foreignDomain.addEntity(model.key, { key: 'entity1' })
     const entity2 = foreignDomain.addEntity(model.key, { key: 'entity2' })
-    const association = entity1.addAssociation({ key: entity2.key })
+    const association = entity1.addAssociation({ targets: [{ key: entity2.key }] })
     foreignDomain.info.version = '1.0.0'
     dataDomain.registerForeignDomain(foreignDomain)
 
@@ -606,7 +606,7 @@ test.group('DataDomain.findAssociation()', () => {
     const m1 = fd.addModel()
     const e1 = m1.addEntity()
     const e2 = m1.addEntity()
-    const a1 = e1.addAssociation({ key: e2.key })
+    const a1 = e1.addAssociation({ targets: [{ key: e2.key }] })
     fd.info.version = '1.0.0'
     domain.registerForeignDomain(fd)
     const result = domain.findAssociation(a1.key, fd.key)

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

@@ -143,7 +143,7 @@ test.group('DataDomain.removeNamespace()', () => {
     const e1 = m1.addEntity({ key: 'entity1' })
     const e2 = m1.addEntity({ key: 'entity2' })
     const p1 = e1.addProperty({ key: 'property1' })
-    const a1 = e1.addAssociation({ key: e2.key })
+    const a1 = e1.addAssociation({ targets: [{ key: e2.key }] })
     d1.removeNamespace(ns1.key)
     assert.isFalse(d1.graph.hasNode(ns1.key))
     assert.isFalse(d1.graph.hasNode(ns2.key))