@api-client/core 0.6.15 → 0.6.18

package/src/models/data/DataEntity.ts

@@ -8,6 +8,7 @@ import { DataModel } from "./DataModel.js";
 import { INodeShape, IShapeUnion } from "../../amf/definitions/Shapes.js";
 import { AmfShapeGenerator } from "../../amf/AmfShapeGenerator.js";
 import { ApiSchemaGenerator } from "../../amf/ApiSchemaGenerator.js";
+import { IShapeRenderOptions } from "../../amf/shape/ShapeBase.js";
 
 export const Kind = 'Core#DataEntity';
 
@@ -465,63 +466,38 @@ export class DataEntity {
    * @yields The path containing keys of entities from this entity to the `toEntity` (inclusive) and all entities in between.
    */
   * associationPath(toEntity: string): Generator<string[]> {
-    const graph = this._associationGraph();
-    for (const path of this._associationPath(this.key, toEntity, graph)) {
+    const graph = this.root.associationGraph();
+    for (const path of this.root.associationPath(this.key, toEntity, graph)) {
       yield path;
     }
   }
 
   /**
-   * The actual implementation of the graph search.
+   * Returns a list of entities that are association with this entity through an association
+   * that the target property points to this entity.
    * 
-   * @param from The current from node
-   * @param to The target node
-   * @param g The graph
-   * @param path The current list of entity ids.
-   * @param visited The list of visited paths to avoid cycles
-   */
-  protected * _associationPath(from: string, to: string, g: Record<string, string[]>, path: string[] = [], visited: Set<string> = new Set()): Generator<string[]> {
-    if (from === to) {
-      yield path.concat(to);
-      return;
-    }
-    if (visited.has(from)) {
-      // it's a cycle
-      return;
-    }
-    if (g[from]) {
-      visited.add(from);
-      path.push(from);
-
-      for (const neighbor of g[from]) {
-        yield *this._associationPath(neighbor, to, g, path, visited);
-      }
-      
-      visited.delete(from);
-      path.pop();
-    }
-  }
-
-  /**
-   * @returns The graph of associations where keys are the source entities and the value is the list of all target entities.
+   * In other words, if entity `A` has association target with `B`, then asking `B` for related entities will
+   * result with `[A]`.
+   * 
+   * ```plain
+   * A -> B -> C
+   * D -> C
+   * 
+   * C => [B, D]
+   * B => [A, C]
+   * ```
    */
-  protected _associationGraph(): Record<string, string[]> {
-    const graph: Record<string, string[]> = {};
-    const { associations, entities } = this.root.definitions;
-    for (const assoc of associations) {
-      if (!assoc.targets.length) {
-        continue;
-      }
-      const srcEntity = entities.find(i => i.associations.some(a => a === assoc));
-      if (!srcEntity) {
-        continue;
-      }
-      if (!graph[srcEntity.key]) {
-        graph[srcEntity.key] = [];
+  getRelatedEntities(): DataEntity[] {
+    const { key, root } = this;
+    const result: DataEntity[] = [];
+    const inverse = root.definitions.associations.filter(i => i.targets.includes(key));
+    inverse.forEach((assoc) => {
+      const entity = root.definitions.entities.find(e => e.associations.includes(assoc));
+      if (entity) {
+        result.push(entity);
       }
-      graph[srcEntity.key].splice(0, 0, ...assoc.targets);
-    }
-    return graph;
+    });
+    return result;
   }
 
   /**
@@ -617,12 +593,13 @@ export class DataEntity {
   /**
    * Reads the schema of the Entity and generates an example for it.
    */
-  toExample(mime: string): string | number | boolean | null | undefined {
+  toExample(mime: string, opts: IShapeRenderOptions = {}): string | number | boolean | null | undefined {
     const shape = this.toApiShape();
     const generator = new ApiSchemaGenerator(mime, {
-      renderExamples: true,
-      renderMocked: true,
-      renderOptional: true,      
+      renderExamples: typeof opts.renderExamples === 'boolean' ? opts.renderExamples : true,
+      renderMocked: typeof opts.renderMocked === 'boolean' ? opts.renderMocked : true,
+      renderOptional: typeof opts.renderOptional === 'boolean' ? opts.renderOptional : true,
+      selectedUnions: opts.selectedUnions,
     });
     return generator.generate(shape);
   }
@@ -650,4 +627,30 @@ export class DataEntity {
     this.adapts = entity.key;
     return entity;
   }
+
+  hasClosedCycle(rootEntity: string, targetEntity: string): boolean {
+    if (targetEntity === this.key) {
+      // self association
+      return true;
+    }
+    const g = this.root.associationGraph();
+    const selfPaths: string[][] = [];
+    const targetPaths: string[][] = [];
+    for (const path of this.root.associationPath(rootEntity, this.key, g)) {
+      selfPaths.push(path);
+    }
+    for (const path of this.root.associationPath(targetEntity, this.key, g)) {
+      targetPaths.push(path);
+    }
+    const checker = (arr: string[], target: string[]): boolean => target.every(v => arr.includes(v));
+    for (const sp of selfPaths) {
+      for (const tp of targetPaths) {
+        const result = checker(sp, tp);
+        if (result) {
+          return result;
+        }
+      }
+    }
+    return false;
+  }
 }

package/src/models/data/DataNamespace.ts

@@ -534,4 +534,58 @@ export class DataNamespace extends DataNamespaceParent {
       model.remove();
     }
   }
+
+  /**
+   * @returns The graph of associations where keys are the source entities and the value is the list of all target entities.
+   */
+  associationGraph(): Record<string, string[]> {
+    const graph: Record<string, string[]> = {};
+    const { definitions } = this.root || this;
+    const { associations, entities } = definitions;
+    for (const assoc of associations) {
+      if (!assoc.targets.length) {
+        continue;
+      }
+      const srcEntity = entities.find(i => i.associations.some(a => a === assoc));
+      if (!srcEntity) {
+        continue;
+      }
+      if (!graph[srcEntity.key]) {
+        graph[srcEntity.key] = [];
+      }
+      graph[srcEntity.key].splice(0, 0, ...assoc.targets);
+    }
+    return graph;
+  }
+
+  /**
+   * Prints out all associations from one entity to another through all entities that may be in between.
+   * 
+   * @param from The key of the from entity
+   * @param to The key of the target entity
+   * @param g The graph generated with `associationGraph()`
+   * @param path The current list of entity ids. Do not set this, it is for the recursive processing of the graph.
+   * @param visited The list of visited paths to avoid cycles. Do not set this, it is for the recursive processing of the graph.
+   */
+  * associationPath(from: string, to: string, g: Record<string, string[]>, path: string[] = [], visited: Set<string> = new Set()): Generator<string[]> {
+    if (from === to) {
+      yield path.concat(to);
+      return;
+    }
+    if (visited.has(from)) {
+      // it's a cycle
+      return;
+    }
+    if (g[from]) {
+      visited.add(from);
+      path.push(from);
+
+      for (const neighbor of g[from]) {
+        yield *this.associationPath(neighbor, to, g, path, visited);
+      }
+      
+      visited.delete(from);
+      path.pop();
+    }
+  }
 }

package/build/src/models/data/DataAssociationSchema.d.ts

@@ -1,68 +0,0 @@
-export interface IDataAssociationSchema {
-    /**
-     * Whether the target entity should be embedded under the property name.
-     * When false, this association is just an information that one entity depend on another.
-     * When true, it changes the definition of the schema having this association to
-     * add the target schema properties inline with this property.
-     *
-     * **When true**
-     *
-     * ```javascript
-     * // generated schema for `address` association
-     * {
-     *  "name": "example value",
-     *  "address": {
-     *    "city": "example value",
-     *    ...
-     *  }
-     * }
-     * ```
-     *
-     * **When false**
-     *
-     * ```javascript
-     * // generated schema for `address` association
-     * {
-     *  "name": "example value",
-     *  "address": "the key of the referenced schema"
-     * }
-     * ```
-     */
-    embedded?: boolean;
-    /**
-     * Describes XML specific serialization.
-     */
-    xml?: {
-        /**
-         * The name of the attribute or a wrapped property to use when serializing the property.
-         *
-         * ```
-         * <Person fullName="John Doe"></Person>
-         * ```
-         */
-        name?: string;
-        /**
-         * When the property is an array (has the `multiple` set to true)
-         * then it tells that the list of values should be wrapped with a parent
-         * element:
-         *
-         * ```
-         * <Person>
-         *  <Person fullName="John Doe"></Person>
-         * </Person>
-         * ```
-         *
-         * Use this with the combination with `name` to describe the name of the wrapped
-         * element
-         *
-         * ```
-         * <people>
-         *  <Person fullName="John Doe"></Person>
-         * </people>
-         * ```
-         *
-         * Note, this is mutually exclusive with `attribute`.
-         */
-        wrapped?: boolean;
-    };
-}

package/build/src/models/data/DataAssociationSchema.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=DataAssociationSchema.js.map

package/build/src/models/data/DataAssociationSchema.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"DataAssociationSchema.js","sourceRoot":"","sources":["../../../../src/models/data/DataAssociationSchema.ts"],"names":[],"mappings":""}

package/src/models/data/DataAssociationSchema.ts

@@ -1,70 +0,0 @@
-export interface IDataAssociationSchema {
-  /**
-   * Whether the target entity should be embedded under the property name.
-   * When false, this association is just an information that one entity depend on another.
-   * When true, it changes the definition of the schema having this association to 
-   * add the target schema properties inline with this property.
-   * 
-   * **When true**
-   * 
-   * ```javascript
-   * // generated schema for `address` association
-   * {
-   *  "name": "example value",
-   *  "address": {
-   *    "city": "example value",
-   *    ...
-   *  }
-   * }
-   * ```
-   * 
-   * **When false**
-   * 
-   * ```javascript
-   * // generated schema for `address` association
-   * {
-   *  "name": "example value",
-   *  "address": "the key of the referenced schema"
-   * }
-   * ```
-   */
-  embedded?: boolean;
-
-  /**
-   * Describes XML specific serialization.
-   */
-  xml?: {
-    /**
-     * The name of the attribute or a wrapped property to use when serializing the property.
-     * 
-     * ```
-     * <Person fullName="John Doe"></Person>
-     * ```
-     */
-    name?: string;
-
-    /**
-     * When the property is an array (has the `multiple` set to true)
-     * then it tells that the list of values should be wrapped with a parent
-     * element:
-     * 
-     * ```
-     * <Person>
-     *  <Person fullName="John Doe"></Person>
-     * </Person>
-     * ```
-     * 
-     * Use this with the combination with `name` to describe the name of the wrapped
-     * element
-     * 
-     * ```
-     * <people>
-     *  <Person fullName="John Doe"></Person>
-     * </people>
-     * ```
-     * 
-     * Note, this is mutually exclusive with `attribute`.
-     */
-    wrapped?: boolean;
-  }
-}