@api-client/core 0.14.10 → 0.15.0

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

@@ -42065,10 +42065,10 @@
 "@id": "#191"
 },
 {
-"@id": "#194"
+"@id": "#197"
 },
 {
-"@id": "#197"
+"@id": "#194"
 },
 {
 "@id": "#200"
@@ -43457,7 +43457,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": "code: '5'\ndescription: 'Limited company'\n",
 "core:mediaType": "application/yaml",
 "sourcemaps:sources": [
 {
@@ -43478,7 +43478,7 @@
 "doc:ExternalDomainElement",
 "doc:DomainElement"
 ],
-"doc:raw": "code: '5'\ndescription: 'Limited company'\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": [
 {
@@ -44761,12 +44761,12 @@
 {
 "@id": "#196/source-map/lexical/element_0",
 "sourcemaps:element": "amf://id#196",
-"sourcemaps:value": "[(1,0)-(10,0)]"
+"sourcemaps:value": "[(1,0)-(3,0)]"
 },
 {
 "@id": "#199/source-map/lexical/element_0",
 "sourcemaps:element": "amf://id#199",
-"sourcemaps:value": "[(1,0)-(3,0)]"
+"sourcemaps:value": "[(1,0)-(10,0)]"
 },
 {
 "@id": "#202/source-map/lexical/element_0",

package/noop.ts

@@ -0,0 +1,3 @@
+// Dummy file to satisfy @web/dev-server-rollup plugin requirements
+// This file is used as a placeholder input for rollup configuration
+export default {}

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.10",
+  "version": "0.15.0",
   "license": "Apache-2.0",
   "exports": {
     "./browser.js": {
@@ -106,6 +106,7 @@
     "@japa/browser-client": "^2.1.1",
     "@japa/expect-type": "^2.0.3",
     "@japa/runner": "^4.2.0",
+    "@pawel-up/semver": "^0.1.4",
     "@rollup/plugin-typescript": "^12.1.2",
     "@types/cors": "^2.8.12",
     "@types/express-ntlm": "^2.3.3",
@@ -119,6 +120,7 @@
     "@web/test-runner-playwright": "^0.11.0",
     "amf-client-js": "^5.7.0",
     "c8": "^10.1.3",
+    "conventional-changelog-cli": "^5.0.0",
     "cors": "^2.8.5",
     "eslint": "^9.20.1",
     "eslint-config-prettier": "^10.0.1",
@@ -133,7 +135,6 @@
     "lint-staged": "^16.0.0",
     "nock": "^14.0.1",
     "oauth2-mock-server": "^8.0.0",
-    "playwright": "^1.50.1",
     "prettier": "^3.5.1",
     "sinon": "^21.0.0",
     "ts-lit-plugin": "^2.0.2",
@@ -146,7 +147,7 @@
     "build:browser": "wireit",
     "build:ts": "wireit",
     "build:node": "wireit",
-    "build": "npm run build:ts && npm run lint && npm run copy:assets",
+    "build": "npm run build:ts && npm run copy:assets",
     "prepare": "husky && npm run fixes && npm run build:ts && npm run build:api-models",
     "fixes": "node scripts/fix-rollup-plugin.js",
     "tsc": "wireit",
@@ -165,7 +166,11 @@
     "lint:prettier": "wireit",
     "format": "npm run format:prettier && npm run format:prettier",
     "format:prettier": "wireit",
-    "format:eslint": "wireit"
+    "format:eslint": "wireit",
+    "release": "node scripts/release.js",
+    "release:patch": "node scripts/release.js patch",
+    "release:minor": "node scripts/release.js minor",
+    "release:major": "node scripts/release.js major"
   },
   "wireit": {
     "test": {

package/src/events/authorization/AuthorizationEvents.ts

@@ -66,7 +66,7 @@ class OidcEvents {
    * @param target A node on which to dispatch the event.
    * @returns Promise resolved when the token is removed
    */
-  static async removeToken(config: ITokenRemoveOptions, target: EventTarget = window): Promise<void> {
+  static async removeTokens(config: ITokenRemoveOptions, target: EventTarget = window): Promise<void> {
     const e = new ContextEvent<ITokenRemoveOptions, void>(AuthorizationEventTypes.Oidc.removeTokens, config)
     target.dispatchEvent(e)
     return e.detail.result

package/src/events/cookies/CookieEvents.ts

@@ -38,7 +38,7 @@ export class CookieEvents {
    * @param target The target on which to dispatch the event
    * @returns The list of project index objects.
    */
-  static async listAll(target: EventTarget): Promise<IHttpCookie[] | undefined> {
+  static async listAll(target: EventTarget = window): Promise<IHttpCookie[] | undefined> {
     const detail: ContextEventDetailWithResult<IHttpCookie[]> = {}
     const e = new CustomEvent(CookieEventTypes.listAll, {
       bubbles: true,

package/src/modeling/DomainImpactAnalysis.ts

@@ -4,96 +4,9 @@ import {
   DomainModelKind,
   DomainPropertyKind,
   DomainAssociationKind,
-  DataDomainKind,
 } from '../models/kinds.js'
 import type { DataDomain } from './DataDomain.js'
-import { AssociationValidation } from './validation/association_validation.js'
-import { EntityValidation } from './validation/entity_validation.js'
-import { PropertyValidation } from './validation/property_validation.js'
-
-export type DomainImpactKinds =
-  | typeof DomainNamespaceKind
-  | typeof DomainEntityKind
-  | typeof DomainModelKind
-  | typeof DomainPropertyKind
-  | typeof DomainAssociationKind
-  | typeof DataDomainKind
-
-/**
- * The impact analysis report
- */
-export interface DomainImpactReport {
-  /**
-   * The key of the impacted data object.
-   * This is the key of the object that is being changed.
-   */
-  key: string
-  /**
-   * The kind of the impacted data object.
-   * This is the kind of the object that is being changed.
-   */
-  kind: DomainImpactKinds
-  /**
-   * The list of impacted data objects.
-   */
-  impact: DomainImpactItem[]
-  /**
-   * Whether it is possible to proceed with the change.
-   * If the change is not possible, the reason will be in the impact list.
-   */
-  canProceed: boolean
-}
-
-export interface DomainImpactItem {
-  /**
-   * The key of the impacted data object.
-   */
-  key: string
-  /**
-   * The kind of the impacted data object.
-   */
-  kind: string
-  /**
-   * The type of the impact.
-   *
-   * - `delete` - The data object would be deleted.
-   */
-  type: 'delete' | 'publish'
-  /**
-   * The impact description.
-   * Explains what will happen to the impacted data object.
-   * This is a human-readable description of the impact.
-   * It should be clear and concise.
-   */
-  impact: string
-  /**
-   * The severity of the impact.
-   *
-   * - `info` - The impact is informational.
-   * - `warning` - The impact can potentially cause problems but is not a blocker.
-   * - `error` - The impact is a blocker and needs to be resolved before proceeding.
-   */
-  severity: 'info' | 'warning' | 'error'
-  /**
-   * Whether the impact is blocking the operation.
-   * If true, the operation cannot proceed.
-   * @deprecated Use `severity` instead.
-   */
-  blocking: boolean
-  /**
-   * The type of the relationship between two impacted objects.
-   */
-  relationship?: 'child'
-  /**
-   * The resolution of the conflict if the change will be forced.
-   */
-  resolution?: string
-  /**
-   * The optional parent of the impacted data object.
-   * For example, if the impacted item is a property, this will be the entity it belongs to.
-   */
-  parent?: string
-}
+import { DomainImpactItem, DomainImpactKinds, DomainImpactReport } from './types.js'
 
 /**
  * # DomainImpactAnalysis
@@ -116,13 +29,13 @@ export interface DomainImpactItem {
  *     -   `kind`: The kind of the impacted object.
  *     -   `type`: The type of impact (currently only `delete`).
  *     -   `impact`: A human-readable description of the impact.
- *     -   `blocking`: Whether this impact prevents the deletion from proceeding.
  *     -   `relationship`: The type of relationship between the deleted object and the impacted object (e.g., `child`).
  *     -   `resolution`: A description of how the impact will be resolved if the deletion is forced.
+ *     -   `severity`: The severity of the impact, which can be `info`, `warning`, or `error`.
  *
  * -   **Blocking Impacts:** Some impacts are considered "blocking," meaning they prevent the deletion from proceeding
  *     without manual intervention. For example, deleting an entity that is a parent to other entities is
- *     a blocking impact.
+ *     a blocking impact. Blocking impacts are indicated by the `severity` property set to `error`.
  *
  * -   **Non-Blocking Impacts:** Some impacts are informational and do not prevent the deletion. For example, deleting a
  *     property is not a blocking impact.
@@ -154,7 +67,7 @@ export interface DomainImpactItem {
  * 3.  **Interpreting the Report:** Examine the `DomainImpactReport` to understand the consequences of the deletion.
  *     -   Check `report.canProceed` to see if the deletion is safe.
  *     -   Iterate through `report.impact` to understand each consequence.
- *     -   Pay special attention to `impact.blocking` to identify impacts that require manual resolution.
+ *     -   Pay special attention to `impact.severity` to identify impacts that require manual resolution.
  *
  *     ```typescript
  *     if (report.canProceed) {
@@ -163,7 +76,7 @@ export interface DomainImpactItem {
  *       console.warn('Deletion cannot proceed due to the following impacts:');
  *       report.impact.forEach((item) => {
  *         console.warn(`- ${item.impact}`);
- *         if (item.blocking) {
+ *         if (item.severity === 'error') {
  *           console.warn(`  - This impact is blocking.`);
  *           if (item.resolution) {
  *             console.warn(`  - Resolution: ${item.resolution}`);
@@ -215,7 +128,7 @@ export interface DomainImpactItem {
  *       "kind": "DomainEntityKind",
  *       "type": "delete",
  *       "impact": "The entity with key Product will be deleted.",
- *       "blocking": false
+ *       "severity": "warning"
  *     },
  *     {
  *       "key": "SpecialProduct",
@@ -223,7 +136,7 @@ export interface DomainImpactItem {
  *       "type": "delete",
  *       "impact": "The SpecialProduct entity will become an orphan because it is a child of Product.",
  *       "resolution": "The \"Product\" entity will be removed as the parent of the \"SpecialProduct\" entity.",
- *       "blocking": true,
+ *       "severity": "error",
  *       "relationship": "child"
  *     },
  *     {
@@ -232,14 +145,14 @@ export interface DomainImpactItem {
  *       "type": "delete",
  *       "impact": "The association with key category will be broken because it has a target to Product.",
  *       "resolution": "The association with key category will be removed from Product.",
- *       "blocking": true
+ *       "severity": "error"
  *     },
  *     {
  *       "key": "name",
  *       "kind": "DomainPropertyKind",
  *       "type": "delete",
  *       "impact": "The property with key name will be deleted.",
- *       "blocking": false
+ *       "severity": "info"
  *     }
  *   ],
  *   "canProceed": false
@@ -267,27 +180,6 @@ export interface DomainImpactItem {
  *     - `DomainAssociationKind`
  *     - `DataDomainKind`
  *
- * ### `DomainImpactReport`
- *
- * -   **Description:** The structure of the impact analysis report.
- * -   **Properties:**
- *     -   `key` (`string`): The key of the object being deleted.
- *     -   `kind` (`DomainImpactKinds`): The kind of the object being deleted.
- *     -   `impact` (`DomainImpactItem[]`): The list of impacts.
- *     -   `canProceed` (`boolean`): Whether the deletion can proceed.
- *
- * ### `DomainImpactItem`
- *
- * -   **Description:** The structure of an individual impact item.
- * -   **Properties:**
- *     -   `key` (`string`): The key of the impacted object.
- *     -   `kind` (`string`): The kind of the impacted object.
- *     -   `type` (`'delete'`): The type of impact.
- *     -   `impact` (`string`): The impact description.
- *     -   `blocking` (`boolean`): Whether the impact is blocking.
- *     -   `relationship` (`'child'`, optional): The relationship type.
- *     -   `resolution` (`string`, optional): The resolution description.
- *
  * ## Error Handling
  *
  * The `DomainImpactAnalysis` class does not throw errors. Instead, it uses the `DomainImpactReport` to communicate
@@ -297,7 +189,7 @@ export interface DomainImpactItem {
  *
  * - **Always Analyze Before Deleting:** Before deleting any data domain element, always use `DomainImpactAnalysis`
  *   to understand the consequences.
- * - **Handle Blocking Impacts:** Pay close attention to `blocking` impacts and implement appropriate
+ * - **Handle Blocking Impacts:** Pay close attention to `severity = "error"` impacts and implement appropriate
  *   logic to handle them.
  * - **Inform the User:** If a deletion cannot proceed, inform the user about the blocking impacts and provide
  *   guidance on how to resolve them.
@@ -311,17 +203,10 @@ export interface DomainImpactItem {
  * about data deletion and prevent unintended consequences.
  */
 export class DomainImpactAnalysis {
-  private report: DomainImpactReport
   private root: DataDomain
 
   constructor(root: DataDomain) {
     this.root = root
-    this.report = {
-      key: '',
-      kind: DataDomainKind,
-      impact: [],
-      canProceed: false,
-    }
   }
 
   /**
@@ -331,14 +216,15 @@ export class DomainImpactAnalysis {
    * @returns The delete impact analysis report.
    */
   deleteAnalysis(key: string, kind: DomainImpactKinds): DomainImpactReport {
-    this.report = {
+    const report: DomainImpactReport = {
       key,
       kind,
       impact: [],
       canProceed: true,
     }
-    this.createDeleteImpact(key, kind, key)
-    return this.report
+    this.createDeleteImpact(key, kind, key, report.impact)
+    report.canProceed = this.computeCanProceed(report.impact)
+    return report
   }
 
   /**
@@ -347,161 +233,100 @@ export class DomainImpactAnalysis {
    * @returns The delete impact analysis report.
    */
   removeForeignNamespaceAnalysis(key: string): DomainImpactReport {
-    this.report = {
+    const report: DomainImpactReport = {
       key,
       kind: DomainNamespaceKind,
       impact: [],
       canProceed: true,
     }
-    this.createRemoveForeignNamespaceImpact(key)
-    return this.report
+    this.createRemoveForeignNamespaceImpact(key, report.impact)
+    report.canProceed = this.computeCanProceed(report.impact)
+    return report
   }
 
   /**
-   * Analyzes the data domain for publishing. Essentially, it performs a validation of the data domain
-   * and returns a report of the impact.
-   * @returns The publish impact analysis report.
+   * Computes whether the deletion can proceed based on the impact report.
+   * @param impact The list of impacts from the analysis.
+   * @returns `true` if the deletion can proceed, `false` otherwise.
    */
-  publishAnalysis(): DomainImpactReport {
-    this.report = {
-      key: '',
-      kind: DataDomainKind,
-      impact: [],
-      canProceed: true,
-    }
-    const entityValidator = new EntityValidation(this.root)
-    const propertyValidator = new PropertyValidation(this.root)
-    const associationValidator = new AssociationValidation(this.root)
-    for (const entity of this.root.listEntities()) {
-      if (entity.domain.key !== this.root.key) {
-        // we don't need to validate foreign entities
-        continue
-      }
-      const report = entityValidator.validate(entity)
-      for (const item of report) {
-        const blocking = item.severity === 'error'
-        this.report.canProceed = this.report.canProceed && !blocking
-        this.report.impact.push({
-          key: item.key,
-          kind: item.kind,
-          type: 'publish',
-          impact: item.message,
-          blocking,
-          resolution: item.help,
-          severity: item.severity,
-          parent: item.parent,
-        })
-      }
-      for (const property of entity.properties) {
-        const report = propertyValidator.validate(property)
-        for (const item of report) {
-          const blocking = item.severity === 'error'
-          this.report.canProceed = this.report.canProceed && !blocking
-          this.report.impact.push({
-            key: item.key,
-            kind: item.kind,
-            type: 'publish',
-            impact: item.message,
-            blocking,
-            resolution: item.help,
-            severity: item.severity,
-            parent: item.parent,
-          })
-        }
-      }
-      for (const association of entity.associations) {
-        const report = associationValidator.validate(association)
-        for (const item of report) {
-          const blocking = item.severity === 'error'
-          this.report.canProceed = this.report.canProceed && !blocking
-          this.report.impact.push({
-            key: item.key,
-            kind: item.kind,
-            type: 'publish',
-            impact: item.message,
-            blocking,
-            resolution: item.help,
-            severity: item.severity,
-            parent: item.parent,
-          })
-        }
-      }
-    }
-    return this.report
+  protected computeCanProceed(impact: DomainImpactItem[]): boolean {
+    return !impact.some((item) => item.severity === 'error')
   }
 
-  protected createDeleteImpact(key: string, kind: DomainImpactKinds, rootKey: string): void {
+  protected createDeleteImpact(
+    key: string,
+    kind: DomainImpactKinds,
+    rootKey: string,
+    impact: DomainImpactItem[]
+  ): void {
     switch (kind) {
       case DomainNamespaceKind:
-        this.deleteNamespaceAnalysis(key, rootKey)
+        this.deleteNamespaceAnalysis(key, rootKey, impact)
         break
       case DomainModelKind:
-        this.deleteModelAnalysis(key, rootKey)
+        this.deleteModelAnalysis(key, rootKey, impact)
         break
       case DomainEntityKind:
-        this.deleteEntityAnalysis(key, rootKey)
+        this.deleteEntityAnalysis(key, rootKey, impact)
         break
       case DomainPropertyKind:
-        this.deletePropertyAnalysis(key)
+        this.deletePropertyAnalysis(key, impact)
         break
       case DomainAssociationKind:
-        this.deleteAssociationAnalysis(key)
+        this.deleteAssociationAnalysis(key, impact)
         break
       default:
       // ignore unknown kinds
     }
   }
 
-  protected deleteNamespaceAnalysis(key: string, rootKey: string): void {
+  protected deleteNamespaceAnalysis(key: string, rootKey: string, impact: DomainImpactItem[]): void {
     const ns = this.root.findNamespace(key)
     if (!ns) {
       return
     }
-    this.report.impact.push({
+    impact.push({
       key: ns.key,
       kind: ns.kind,
       type: 'delete',
       impact: `The ${ns.info.getLabel()} ${this.kindToLabel(DomainNamespaceKind)} will be deleted.`,
-      blocking: false,
       severity: 'info',
     })
     for (const child of ns.listNamespaces()) {
-      this.deleteNamespaceAnalysis(child.key, rootKey)
+      this.deleteNamespaceAnalysis(child.key, rootKey, impact)
     }
     for (const child of ns.listModels()) {
-      this.deleteModelAnalysis(child.key, rootKey)
+      this.deleteModelAnalysis(child.key, rootKey, impact)
     }
   }
 
-  protected deleteModelAnalysis(key: string, rootKey: string): void {
+  protected deleteModelAnalysis(key: string, rootKey: string, impact: DomainImpactItem[]): void {
     const model = this.root.findModel(key)
     if (!model) {
       return
     }
-    this.report.impact.push({
+    impact.push({
       key: model.key,
       kind: model.kind,
       type: 'delete',
       impact: `The ${model.info.getLabel()} ${this.kindToLabel(DomainModelKind)} will be deleted.`,
-      blocking: false,
       severity: 'info',
     })
     for (const child of model.listEntities()) {
-      this.deleteEntityAnalysis(child.key, rootKey)
+      this.deleteEntityAnalysis(child.key, rootKey, impact)
     }
   }
 
-  protected deleteEntityAnalysis(key: string, rootKey: string): void {
+  protected deleteEntityAnalysis(key: string, rootKey: string, impact: DomainImpactItem[]): void {
     const entity = this.root.findEntity(key)
     if (!entity) {
       return
     }
-    this.report.impact.push({
+    impact.push({
       key: entity.key,
       kind: entity.kind,
       type: 'delete',
       impact: `The ${entity.info.getLabel()} ${this.kindToLabel(DomainEntityKind)} will be deleted.`,
-      blocking: false,
       severity: 'info',
     })
 
@@ -521,17 +346,15 @@ export class DomainImpactAnalysis {
       }
       const pLabel = entity.info.getLabel()
       const cLabel = childEntity.info.getLabel()
-      this.report.impact.push({
+      impact.push({
         key: childEntity.key,
         kind: childEntity.kind,
         type: 'delete',
         impact: `The "${cLabel}" ${this.kindToLabel(DomainEntityKind)} will become an orphan because it is a child of the "${pLabel}" entity.`,
         resolution: `The "${pLabel}" entity will be removed as the parent of the "${cLabel}" entity.`,
-        blocking: false,
         relationship: 'child',
         severity: 'error',
       })
-      this.report.canProceed = false
     }
     // We need to know whether there's another entity that has an association to this entity.
     for (const edgeInfo of this.root.graph.inEdges(entity.key)) {
@@ -554,51 +377,47 @@ export class DomainImpactAnalysis {
 
       const aLabel = association.info.getLabel()
       const eLabel = entity.info.getLabel()
-      this.report.impact.push({
+      impact.push({
         key: association.key,
         kind: association.kind,
         type: 'delete',
         impact: `The ${aLabel} ${this.kindToLabel(DomainAssociationKind)} will be broken because it has a target to ${eLabel}.`,
         resolution: `The ${aLabel} ${this.kindToLabel(DomainAssociationKind)} will be removed from ${eLabel}.`,
-        blocking: true,
         severity: 'error',
       })
-      this.report.canProceed = false
     }
     for (const child of entity.listProperties()) {
-      this.deletePropertyAnalysis(child.key)
+      this.deletePropertyAnalysis(child.key, impact)
     }
     for (const child of entity.listAssociations()) {
-      this.deleteAssociationAnalysis(child.key)
+      this.deleteAssociationAnalysis(child.key, impact)
     }
   }
 
-  protected deletePropertyAnalysis(key: string): void {
+  protected deletePropertyAnalysis(key: string, impact: DomainImpactItem[]): void {
     const property = this.root.findProperty(key)
     if (!property) {
       return
     }
-    this.report.impact.push({
+    impact.push({
       key: property.key,
       kind: property.kind,
       type: 'delete',
       impact: `The ${property.info.getLabel()} ${this.kindToLabel(DomainPropertyKind)} will be deleted.`,
-      blocking: false,
       severity: 'info',
     })
   }
 
-  protected deleteAssociationAnalysis(key: string): void {
+  protected deleteAssociationAnalysis(key: string, impact: DomainImpactItem[]): void {
     const association = this.root.findAssociation(key)
     if (!association) {
       return
     }
-    this.report.impact.push({
+    impact.push({
       key: association.key,
       kind: association.kind,
       type: 'delete',
       impact: `The ${association.info.getLabel()} ${this.kindToLabel(DomainAssociationKind)} will be deleted.`,
-      blocking: false,
       severity: 'info',
     })
   }
@@ -620,7 +439,7 @@ export class DomainImpactAnalysis {
     }
   }
 
-  protected createRemoveForeignNamespaceImpact(key: string): void {
+  protected createRemoveForeignNamespaceImpact(key: string, impact: DomainImpactItem[]): void {
     const foreignNamespace = this.root.dependencies.get(key)
     if (!foreignNamespace) {
       return
@@ -640,17 +459,15 @@ export class DomainImpactAnalysis {
           }
           const eLabel = entity.info.getLabel()
           const pLabel = parentEntity.info.getLabel()
-          this.report.impact.push({
+          impact.push({
             key: entity.key,
             kind: entity.kind,
             type: 'delete',
             impact: `The "${eLabel}" ${this.kindToLabel(DomainEntityKind)} will become an orphan because its parent "${pLabel}" is in the foreign namespace "${foreignNamespace.key}".`,
             resolution: `The "${pLabel}" entity will be removed as the parent of the "${eLabel}" entity.`,
-            blocking: true,
             relationship: 'child',
             severity: 'error',
           })
-          this.report.canProceed = false
         } else if (edge.type === 'association') {
           const association = this.root.findAssociation(info.w)
           if (!association) {
@@ -666,16 +483,14 @@ export class DomainImpactAnalysis {
               const aLabel = association.info.getLabel()
               const eLabel = entity.info.getLabel()
               const tLabel = targetEntity.info.getLabel()
-              this.report.impact.push({
+              impact.push({
                 key: association.key,
                 kind: association.kind,
                 type: 'delete',
                 impact: `The "${aLabel}" ${this.kindToLabel(DomainAssociationKind)} from "${eLabel}" will be broken because it targets "${tLabel}" in the foreign namespace "${foreignNamespace.key}".`,
                 resolution: `The "${aLabel}" ${this.kindToLabel(DomainAssociationKind)} will be removed from "${eLabel}".`,
-                blocking: true,
                 severity: 'error',
               })
-              this.report.canProceed = false
             }
           }
         }