@api-client/core 0.11.7 → 0.11.8

package/src/modeling/DataEntity.ts

@@ -16,9 +16,16 @@ import { RemoveAssociationException } from '../exceptions/remove_association_exc
 import { ValidationError, type FieldValidationMessage } from '../exceptions/validation_error.js'
 import { RemoveEntityException } from '../exceptions/remove_entity_exception.js'
 import { ForeignAssociationException } from '../exceptions/foreign_association_exception.js'
+import type { DataDomainRemoveOptions } from './types.js'
 
 interface OrderedItem {
+  /**
+   * The type of the ordered item.
+   */
   type: 'property' | 'association'
+  /**
+   * The key of the ordered item.
+   */
   key: string
 }
 
@@ -556,6 +563,7 @@ export class DataEntity {
 
   /**
    * Computes a list of entities that are associated with the current entity.
+   * This is the association-out (out-edge) direction.
    */
   getComputedAssociations(): DataEntity[] {
     const { associations } = this
@@ -577,23 +585,43 @@ export class DataEntity {
   /**
    * Removes self from the namespace with all properties and attributes.
    */
-  remove(): void {
+  remove(opts: DataDomainRemoveOptions = {}): void {
     const { key, properties, associations, root } = this
     // check if some entity has reference to this entity as a target
-    const associationsToEntity = this.root.definitions.associations.filter((a) =>
-      a.targets.some((t) => t.key === this.key)
-    )
-    if (associationsToEntity.length > 0) {
-      const entitiesNames = associationsToEntity.reduce<string[]>((acc, association) => {
+    const toEdges = this.root.definitions.associations.filter((a) => a.targets.some((t) => t.key === this.key))
+    if (toEdges.length > 0) {
+      const result = toEdges.reduce<{ entity: DataEntity; association: DataAssociation }[]>((acc, association) => {
         const entity = root.definitions.entities.find((e) => e.associations.some((a) => a.key === association.key))
         if (entity) {
-          acc.push(entity.info.name as string)
+          acc.push({ entity, association })
         }
         return acc
       }, [])
-      throw new RemoveEntityException(
-        `Cannot remove entity ${this.info.name} because it is used as a target in associations in entities: ${entitiesNames.join(', ')}.`
-      )
+      if (opts.force) {
+        // remove the association from the entity
+        result.forEach(({ entity: item, association }) => {
+          item.removeAssociation(association.key)
+        })
+      } else {
+        const entitiesNames = result.map(({ entity }) => entity.info.renderLabel || entity.key)
+        throw new RemoveEntityException(
+          `Cannot remove entity ${this.info.renderLabel} because it is used as a target in associations in entities: ${entitiesNames.join(', ')}.`
+        )
+      }
+    }
+
+    const children = this.getComputedChildren()
+    if (children.length > 0) {
+      if (opts.force) {
+        children.forEach((child) => {
+          child.parents = child.parents.filter((i) => i !== this.key)
+        })
+      } else {
+        const childrenNames = children.map((i) => i.info.renderLabel || i.key)
+        throw new RemoveEntityException(
+          `Cannot remove entity ${this.info.renderLabel} because it is a parent for the following entities: ${childrenNames.join(', ')}.`
+        )
+      }
     }
 
     // remove own stuff
@@ -962,4 +990,25 @@ export class DataEntity {
     }
     return false
   }
+
+  /**
+   * Checks whether the entity is a child of the given namespace or data model.
+   * The relationship doesn't have to be direct, as long as the entity is in the hierarchy it will return true.
+   *
+   * @param key The key of the parent to check.
+   * @returns True if this entity is a child of the given namespace or data model.
+   */
+  isChildOf(key: string): boolean {
+    if (this.key === key) {
+      return false
+    }
+    const parent = this.getParentInstance()
+    if (!parent) {
+      return false
+    }
+    if (parent.key === key) {
+      return true
+    }
+    return parent.isChildOf(key)
+  }
 }

package/src/modeling/DataModel.ts

@@ -4,6 +4,7 @@ import { DataEntity, IDataEntity } from './DataEntity.js'
 import type { DataItemAdaptingOptions, DataNamespace } from './DataNamespace.js'
 import { FileBreadcrumb } from '../models/store/File.js'
 import { DataModelKind } from '../models/kinds.js'
+import type { DataDomainRemoveOptions } from './types.js'
 
 /**
  * Data model creates a logical structure around data entities.
@@ -129,10 +130,10 @@ export class DataModel {
   /**
    * Removes self from the namespace with all entities.
    */
-  remove(): void {
+  remove(opts?: DataDomainRemoveOptions): void {
     const { key, entities, root } = this
     // remove children
-    entities.forEach((e) => e.remove())
+    entities.forEach((e) => e.remove(opts))
 
     // remove self from the parent
     const parent = this.getParentInstance()
@@ -249,4 +250,25 @@ export class DataModel {
     })
     return result.reverse()
   }
+
+  /**
+   * Checks whether the data model is a child of the given namespace.
+   * The relationship doesn't have to be direct, as long as the data model is in the hierarchy it will return true.
+   *
+   * @param key The key of the parent namespace to check.
+   * @returns True if this data model is a child of the given namespace.
+   */
+  isChildOf(key: string): boolean {
+    if (this.key === key) {
+      return false
+    }
+    const parent = this.getParentInstance()
+    if (!parent) {
+      return false
+    }
+    if (parent.key === key) {
+      return true
+    }
+    return parent.isChildOf(key)
+  }
 }

package/src/modeling/DataNamespace.ts

@@ -6,6 +6,7 @@ import { IDataModel, DataModel } from './DataModel.js'
 import { IDataProperty, DataProperty } from './DataProperty.js'
 import { DataNamespaceKind, DataModelKind } from '../models/kinds.js'
 import v4 from '../lib/uuid.js'
+import type { DataDomainRemoveOptions } from './types.js'
 
 type ItemKind = typeof DataNamespaceKind | typeof DataModelKind
 
@@ -60,7 +61,10 @@ interface ForeignNamespace {
   version: string
 }
 
-interface IDataNamespaceParent {
+/**
+ * Data namespace is a logical description of the hierarchy in the data.
+ */
+export interface IDataNamespace {
   kind: typeof DataNamespaceKind
   /**
    * The key of the namespace.
@@ -74,12 +78,6 @@ interface IDataNamespaceParent {
    * The data namespace description.
    */
   info: IThing
-}
-
-/**
- * Data namespace is a logical description of the hierarchy in the data.
- */
-export interface IDataNamespace extends IDataNamespaceParent {
   /**
    * The list of definitions used in the namespace.
    */
@@ -101,132 +99,6 @@ export interface IDataItem {
   key: string
 }
 
-class DataNamespaceParent {
-  kind = DataNamespaceKind
-
-  key = ''
-
-  /**
-   * The ordered list of items in this namespace.
-   */
-  items: DataItem[] = []
-
-  /**
-   * The description of the data namespace.
-   */
-  info: Thing = Thing.fromName('')
-
-  /**
-   * When a namespace is a sub-namespace this is the reference to the
-   * root namespace with all definitions.
-   */
-  root?: DataNamespace
-
-  constructor(root?: DataNamespace) {
-    this.root = root
-  }
-
-  /**
-   * @deprecated Use the `getParentInstance()` method instead.
-   */
-  getParent(): DataNamespace | undefined {
-    return this.getParentInstance()
-  }
-
-  /**
-   * @returns The parent namespace of this namespace. It returns `undefined` when this is the root namespace.
-   */
-  getParentInstance(): DataNamespace | undefined {
-    const { root, key } = this
-    if (root) {
-      const result = (root as DataNamespace).findParent(key)
-      if (result === this.root) {
-        return undefined
-      }
-      return result
-    }
-    // we are the root namespace.
-    return undefined
-  }
-
-  /**
-   * Adds a data namespace to the structure.
-   * @param init The name of the namespace to add, namespace's schema, or instance.
-   */
-  addNamespace(init: string | IDataNamespace | DataNamespace): DataNamespace {
-    return (this.root as DataNamespace).addNamespace(init, this.key)
-  }
-
-  /**
-   * Lists namespaces that are in this namespace items.
-   */
-  listNamespaces(): DataNamespace[] {
-    const result: DataNamespace[] = []
-    const { items } = this
-    const root = this.getRoot()
-    const { namespaces } = root.definitions
-    items.forEach((i) => {
-      if (i.kind !== DataNamespaceKind) {
-        return
-      }
-      const def = namespaces.find((j) => j.key === i.key)
-      if (def) {
-        result.push(def)
-      }
-    })
-    return result
-  }
-
-  /**
-   * Lists namespaces that are in this namespace items.
-   */
-  listDataModels(): DataModel[] {
-    const result: DataModel[] = []
-    const { items } = this
-    const root = this.getRoot()
-    const { models } = root.definitions
-    items.forEach((i) => {
-      if (i.kind !== DataModelKind) {
-        return
-      }
-      const def = models.find((j) => j.key === i.key)
-      if (def) {
-        result.push(def)
-      }
-    })
-    return result
-  }
-
-  /**
-   * @returns The root of the namespaces tree. It might be the same object.
-   */
-  getRoot(): DataNamespace {
-    if (this.root) {
-      return this.root
-    }
-    return this as unknown as DataNamespace
-  }
-
-  /**
-   * Removes self from the parent namespace with all data models.
-   * This does noting for the root namespace.
-   */
-  remove(): void {
-    const { root } = this
-    if (!root) {
-      throw new Error(`Unable to remove the root namespace this way.`)
-    }
-    const models = this.listDataModels()
-    const children = this.listNamespaces()
-    models.forEach((m) => m.remove())
-    children.forEach((c) => c.remove())
-    const index = root.definitions.namespaces.findIndex((i) => i.key === this.key)
-    if (index >= 0) {
-      root.definitions.namespaces.splice(index, 1)
-    }
-  }
-}
-
 export class DataItem implements IDataItem {
   kind: ItemKind = DataModelKind
 
@@ -310,7 +182,29 @@ export class DataItem implements IDataItem {
 /**
  * Data namespace is a logical description of the hierarchy in the data.
  */
-export class DataNamespace extends DataNamespaceParent {
+export class DataNamespace {
+  kind = DataNamespaceKind
+
+  key = ''
+
+  /**
+   * The ordered list of items in this namespace.
+   */
+  items: DataItem[] = []
+
+  /**
+   * The description of the data namespace.
+   */
+  info: Thing = Thing.fromName('')
+
+  /**
+   * When a namespace is a sub-namespace this is the reference to the
+   * root namespace with all definitions.
+   */
+  root?: DataNamespace
+  /**
+   * The list of definitions used in the namespace.
+   */
   definitions: DataDefinitions
 
   /**
@@ -334,6 +228,9 @@ export class DataNamespace extends DataNamespaceParent {
     return ns
   }
 
+  /**
+   * @deprecated
+   */
   static definitions(): DataDefinitions {
     return {
       models: [],
@@ -346,8 +243,15 @@ export class DataNamespace extends DataNamespaceParent {
   }
 
   constructor(input?: string | IDataNamespace, root?: DataNamespace) {
-    super(root)
-    this.definitions = DataNamespace.definitions()
+    this.root = root
+    this.definitions = {
+      models: [],
+      associations: [],
+      entities: [],
+      properties: [],
+      namespaces: [],
+      tags: [],
+    }
 
     let init: IDataNamespace
     if (typeof input === 'string') {
@@ -449,6 +353,94 @@ export class DataNamespace extends DataNamespaceParent {
     return result
   }
 
+  /**
+   * @deprecated Use the `getParentInstance()` method instead.
+   */
+  getParent(): DataNamespace | undefined {
+    return this.getParentInstance()
+  }
+
+  /**
+   * @returns The parent namespace of this namespace. It returns `undefined` when this is the root namespace.
+   */
+  getParentInstance(): DataNamespace | undefined {
+    const { root, key } = this
+    if (root) {
+      return root.findParent(key)
+    }
+    // we are the root namespace.
+    return undefined
+  }
+
+  /**
+   * Lists namespaces that are in this namespace items.
+   */
+  listNamespaces(): DataNamespace[] {
+    const result: DataNamespace[] = []
+    const { items } = this
+    const root = this.getRoot()
+    const { namespaces } = root.definitions
+    items.forEach((i) => {
+      if (i.kind !== DataNamespaceKind) {
+        return
+      }
+      const def = namespaces.find((j) => j.key === i.key)
+      if (def) {
+        result.push(def)
+      }
+    })
+    return result
+  }
+
+  /**
+   * Lists namespaces that are in this namespace items.
+   */
+  listDataModels(): DataModel[] {
+    const result: DataModel[] = []
+    const { items } = this
+    const root = this.getRoot()
+    const { models } = root.definitions
+    items.forEach((i) => {
+      if (i.kind !== DataModelKind) {
+        return
+      }
+      const def = models.find((j) => j.key === i.key)
+      if (def) {
+        result.push(def)
+      }
+    })
+    return result
+  }
+
+  /**
+   * @returns The root of the namespaces tree. It might be the same object.
+   */
+  getRoot(): DataNamespace {
+    if (this.root) {
+      return this.root
+    }
+    return this as unknown as DataNamespace
+  }
+
+  /**
+   * Removes self from the parent namespace with all data models.
+   * This does noting for the root namespace.
+   */
+  remove(opts?: DataDomainRemoveOptions): void {
+    const { root } = this
+    if (!root) {
+      throw new Error(`Unable to remove the root namespace this way.`)
+    }
+    const models = this.listDataModels()
+    const children = this.listNamespaces()
+    models.forEach((m) => m.remove(opts))
+    children.forEach((c) => c.remove(opts))
+    const index = root.definitions.namespaces.findIndex((i) => i.key === this.key)
+    if (index >= 0) {
+      root.definitions.namespaces.splice(index, 1)
+    }
+  }
+
   /**
    * Checks if this is the root namespace.
    * @returns True if this is the root namespace.
@@ -480,7 +472,7 @@ export class DataNamespace extends DataNamespaceParent {
    * @param init The name of the namespace to add, namespace's schema, or instance.
    * @param parent The optional key of the parent namespace to add the new namespace to.
    */
-  override addNamespace(init: string | IDataNamespace | DataNamespace, parent?: string): DataNamespace {
+  addNamespace(init: string | IDataNamespace | DataNamespace, parent?: string): DataNamespace {
     let root: DataNamespace
     if (parent) {
       const rootCandidate = this.findParent(parent)
@@ -860,4 +852,25 @@ export class DataNamespace extends DataNamespaceParent {
   hasForeignNamespace(key: string): boolean {
     return this.foreign.some((i) => i.key === key)
   }
+
+  /**
+   * Checks whether the namespace is a child of the given namespace.
+   * The relationship doesn't have to be direct, as long as the namespace is in the hierarchy it will return true.
+   *
+   * @param key The key of the parent namespace to check.
+   * @returns True if this namespace is a child of the given namespace.
+   */
+  isChildOf(key: string): boolean {
+    if (this.key === key) {
+      return false
+    }
+    const parent = this.getParentInstance()
+    if (!parent) {
+      return false
+    }
+    if (parent.key === key) {
+      return true
+    }
+    return parent.isChildOf(key)
+  }
 }

package/src/modeling/DataProperty.ts

@@ -18,6 +18,7 @@ import {
   type NumberFormat,
   NumberFormats,
 } from './DataFormat.js'
+import type { DataEntity } from './DataEntity.js'
 
 /**
  * Describes the default value set on a property schema.
@@ -88,7 +89,7 @@ export interface DataPropertySchema {
    * Examples:
    * - if `1` then every integer is allowed
    * - if `2` than every even number is allowed
-   * - if `0.5` than every number difidable by `0.5` is allowed
+   * - if `0.5` than every number dividable by `0.5` is allowed
    */
   multipleOf?: number
   /**
@@ -524,9 +525,9 @@ export class DataProperty {
   }
 
   /**
-   * Checks whether the passed value is one of the supported data proprty attributes.
+   * Checks whether the passed value is one of the supported data property attributes.
    * @param value The value to test
-   * @returns True when the passed value is one of the supported data proprty attributes.
+   * @returns True when the passed value is one of the supported data property attributes.
    */
   static isValidAttribute(value: unknown): value is DataPropertyAttribute {
     if (typeof value !== 'string') {
@@ -591,4 +592,32 @@ export class DataProperty {
     const item = this.bindings.find((i) => i.type === type) as PropertyBinding
     return item?.schema
   }
+
+  /**
+   * Returns a parent data entity where this data property exist.
+   */
+  getParentInstance(): DataEntity | undefined {
+    return this.root.definitions.entities.find((e) => e.properties.some((e) => e.key === this.key))
+  }
+
+  /**
+   * Checks whether the property is a child of the given namespace, data model, or an entity.
+   * The relationship doesn't have to be direct, as long as the property is in the hierarchy it will return true.
+   *
+   * @param key The key of the parent to check.
+   * @returns True if this data property is a child of the given namespace, data model, or an entity
+   */
+  isChildOf(key: string): boolean {
+    if (this.key === key) {
+      return false
+    }
+    const parent = this.getParentInstance()
+    if (!parent) {
+      return false
+    }
+    if (parent.key === key) {
+      return true
+    }
+    return parent.isChildOf(key)
+  }
 }