@api-client/core 0.6.17 → 0.6.20

package/src/events/models/ClientCertificateEvents.ts

@@ -6,11 +6,11 @@ export class ClientCertificateEvents {
   /**
    * Dispatches an event handled by the data store to read the client certificate.
    *
-   * @param target A node on which to dispatch the event.
    * @param id The id of the client certificate
+   * @param target A node on which to dispatch the event.
    * @returns Promise resolved to a client certificate model.
    */
-  static async read(target: EventTarget, id: string): Promise<HttpCertificate | undefined> {
+  static async read(id: string, target: EventTarget = window): Promise<HttpCertificate | undefined> {
     const e = new ContextReadEvent<HttpCertificate>(ModelEventTypes.ClientCertificate.read, id);
     target.dispatchEvent(e);
     return e.detail.result;
@@ -19,11 +19,11 @@ export class ClientCertificateEvents {
   /**
    * Dispatches an event to list the client certificates data.
    *
-   * @param target A node on which to dispatch the event.
    * @param opts Query options.
+   * @param target A node on which to dispatch the event.
    * @returns The list result.
    */
-  static async list(target: EventTarget, opts?: ContextListOptions): Promise<ContextListResult<HttpCertificate> | undefined> {
+  static async list(opts?: ContextListOptions, target: EventTarget = window): Promise<ContextListResult<HttpCertificate> | undefined> {
     const e = new ContextListEvent<HttpCertificate>(ModelEventTypes.ClientCertificate.list, opts);
     target.dispatchEvent(e);
     return e.detail.result;
@@ -32,11 +32,11 @@ export class ClientCertificateEvents {
   /**
    * Dispatches an event handled by the data store to delete a client certificate
    *
-   * @param target A node on which to dispatch the event.
    * @param id The id of the project to delete.
+   * @param target A node on which to dispatch the event.
    * @returns Promise resolved to a new revision after delete.
    */
-  static async delete(target: EventTarget, id: string): Promise<ContextDeleteRecord | undefined> {
+  static async delete(id: string, target: EventTarget = window): Promise<ContextDeleteRecord | undefined> {
     const e = new ContextDeleteEvent(ModelEventTypes.ClientCertificate.delete, id, undefined);
     target.dispatchEvent(e);
     return e.detail.result;
@@ -45,11 +45,11 @@ export class ClientCertificateEvents {
   /**
    * Dispatches an event handled by the data store to insert a new client certificate.
    *
-   * @param target A node on which to dispatch the event.
    * @param item The certificate object.
+   * @param target A node on which to dispatch the event.
    * @returns Promise resolved to the change record
    */
-  static async insert(target: EventTarget, item: ICertificateCreateOptions): Promise<ContextChangeRecord<HttpCertificate> | undefined> {
+  static async insert(item: ICertificateCreateOptions, target: EventTarget = window): Promise<ContextChangeRecord<HttpCertificate> | undefined> {
     const e = new ContextUpdateEvent<ICertificateCreateOptions, HttpCertificate>(ModelEventTypes.ClientCertificate.insert, { item, });
     target.dispatchEvent(e);
     return e.detail.result;
@@ -67,7 +67,7 @@ class StateEvents {
    * @param target A node on which to dispatch the event.
    * @param record Change record
    */
-  static update(target: EventTarget, record: ContextChangeRecord<HttpCertificate>): void {
+  static update(record: ContextChangeRecord<HttpCertificate>, target: EventTarget = window): void {
     const e = new ContextStateUpdateEvent<HttpCertificate>(ModelEventTypes.ClientCertificate.State.update, record);
     target.dispatchEvent(e);
   }
@@ -75,10 +75,10 @@ class StateEvents {
   /**
    * Dispatches an event after a client certificate was deleted
    *
-   * @param target A node on which to dispatch the event.
    * @param record The context store delete record
+   * @param target A node on which to dispatch the event.
    */
-  static delete(target: EventTarget, record: ContextDeleteRecord): void {
+  static delete(record: ContextDeleteRecord, target: EventTarget = window): void {
     const e = new ContextStateDeleteEvent(ModelEventTypes.ClientCertificate.State.delete, record);
     target.dispatchEvent(e);
   }

package/src/events/process/ProcessEvents.ts

@@ -21,11 +21,11 @@ export class ProcessEvents {
    * in the background. The side effect of the event is the UI showing a process
    * indicator.
    * 
-   * @param target A node on which to dispatch the event.
    * @param pid The id of the process. The same id has to be passed to the stop event.
    * @param message Optional message rendered in the UI.
+   * @param target A node on which to dispatch the event.
    */
-  static loadingStart(target: EventTarget, pid: string, message: string): void {
+  static loadingStart(pid: string, message: string, target: EventTarget = window): void {
     const detail: IProcessStartDetail = { pid, message };
     const e = new CustomEvent(ProcessEventTypes.loadingStart, {
       cancelable: true,
@@ -40,10 +40,10 @@ export class ProcessEvents {
    * An event to be dispatched when the application has finished a long running process
    * in the background.
    * 
-   * @param target A node on which to dispatch the event.
    * @param pid The id of the process. The same id has to be passed to the stop event.
+   * @param target A node on which to dispatch the event.
    */
-  static loadingStop(target: EventTarget, pid: string): void {
+  static loadingStop(pid: string, target: EventTarget = window): void {
     const detail: IProcessStopDetail = { pid };
     const e = new CustomEvent(ProcessEventTypes.loadingStop, {
       cancelable: true,
@@ -58,12 +58,12 @@ export class ProcessEvents {
    * An event to be dispatched when the application has finished a long running process
    * in the background with an error.
    * 
-   * @param target A node on which to dispatch the event.
    * @param pid The id of the process used to start it.
    * @param message The message to be rendered to the user.
    * @param error The error object caused the event. Optional.
+   * @param target A node on which to dispatch the event.
    */
-  static loadingError(target: EventTarget, pid: string, message: string, error?: Error): void {
+  static loadingError(pid: string, message: string, error?: Error, target: EventTarget = window): void {
     const detail: IProcessErrorDetail = { pid, message, error };
     const e = new CustomEvent(ProcessEventTypes.loadingError, {
       cancelable: true,

package/src/events/reporting/ReportingEvents.ts

@@ -10,12 +10,12 @@ export class ReportingEvents {
   /**
    * Dispatches the general error event for UI logging purposes.
    * 
-   * @param target A node on which to dispatch the event
    * @param description The error description
    * @param error Optional original error object that has caused this event
    * @param component Optional component name.
+   * @param target A node on which to dispatch the event
    */
-  static error(target: EventTarget, description: string, error?: Error, component?: string): void {
+  static error(description: string, error?: Error, component?: string, target: EventTarget = window): void {
     const detail: IReportingErrorDetail = { error, description, component };
     const e = new CustomEvent(ReportingEventTypes.error, {
       bubbles: true,

package/src/events/telemetry/TelemetryEvents.ts

@@ -48,7 +48,7 @@ export class TelemetryEvents {
    * @param screenName The screen name
    * @param info Analytics base configuration
    */
-  static view(target: EventTarget, screenName: string, info: ITelemetryDetail = {}): void {
+  static view(screenName: string, target: EventTarget = window, info: ITelemetryDetail = {}): void {
     const detail: ITelemetryScreenViewDetail = {
       ...info, screenName,
     };
@@ -66,7 +66,7 @@ export class TelemetryEvents {
    * @param target A node on which to dispatch the event
    * @param detail The event configuration
    */
-  static event(target: EventTarget, detail: ITelemetryEventDetail): void {
+  static event(detail: ITelemetryEventDetail, target: EventTarget = window): void {
     const e = new CustomEvent(TelemetryEventTypes.event, {
       bubbles: true,
       composed: true,
@@ -83,7 +83,7 @@ export class TelemetryEvents {
    * @param fatal Whether the exception was fatal to the application
    * @param info Analytics base configuration
    */
-  static exception(target: EventTarget, description: string, fatal?: boolean, info: ITelemetryDetail = {}): void {
+  static exception(description: string, fatal?: boolean, target: EventTarget = window, info: ITelemetryDetail = {}): void {
     const detail: ITelemetryExceptionDetail = { ...info, description, fatal };
     const e = new CustomEvent(TelemetryEventTypes.exception, {
       bubbles: true,
@@ -102,7 +102,7 @@ export class TelemetryEvents {
    * @param url The share url
    * @param info Analytics base configuration
    */
-  static social(target: EventTarget, network: string, action: string, url: string, info: ITelemetryDetail = {}): void {
+  static social(network: string, action: string, url: string, target: EventTarget = window, info: ITelemetryDetail = {}): void {
     const detail: ITelemetrySocialDetail = { ...info, network, action, target: url };
     const e = new CustomEvent(TelemetryEventTypes.social, {
       bubbles: true,
@@ -122,7 +122,7 @@ export class TelemetryEvents {
    * @param label The timing label
    * @param info Analytics base configuration
    */
-  static timing(target: EventTarget, category: string, variable: string, value: number, label?: string, info: ITelemetryDetail = {}): void {
+  static timing(category: string, variable: string, value: number, label?: string, target: EventTarget = window, info: ITelemetryDetail = {}): void {
     const detail: ITelemetryTimingDetail = { ...info, category, variable, value, label };
     const e = new CustomEvent(TelemetryEventTypes.timing, {
       bubbles: true,
@@ -145,7 +145,7 @@ class StateEvents {
    * 
    * @param target The node on which to dispatch the event.
    */
-  static set(target: EventTarget): void {
+  static set(target: EventTarget = window): void {
     const e = new Event(TelemetryEventTypes.State.set, {
       composed: true,
       cancelable: true,

package/src/events/transport/TransportEvents.ts

@@ -39,7 +39,7 @@ export const TransportEvent = Object.freeze({
      * @param config Optional request configuration.
      * @returns The execution log or `undefined` when the event was not handled.
      */
-    send: async (target: EventTarget, request: IHttpRequest, authorization?: IRequestAuthorization[], config?: IRequestBaseConfig): Promise<IRequestLog | undefined> => {
+    send: async (request: IHttpRequest, authorization?: IRequestAuthorization[], config?: IRequestBaseConfig, target: EventTarget = window): Promise<IRequestLog | undefined> => {
       const e = new ContextEvent<ICoreRequestDetail, IRequestLog>(TransportEventTypes.Core.send, {
         request,
         authorization,
@@ -62,7 +62,7 @@ export const TransportEvent = Object.freeze({
      * @param init Optional request init options compatible with the Fetch API.
      * @returns Compatible with the Fetch API Response object or `undefined` when the event was not handled.
      */
-    send: async (target: EventTarget, request: IHttpRequest, init?: RequestInit): Promise<Response | undefined> => {
+    send: async (request: IHttpRequest, init?: RequestInit, target: EventTarget = window): Promise<Response | undefined> => {
       const e = new ContextEvent<IHttpRequestDetail, Response>(TransportEventTypes.Http.send, {
         request,
         init,
@@ -82,7 +82,7 @@ export const TransportEvent = Object.freeze({
      * @param opts The project execution options.
      * @returns 
      */
-    send: async (target: EventTarget, project: HttpProject | string, opts: IProjectRunnerOptions): Promise<IProjectExecutionLog | undefined> => {
+    send: async (project: HttpProject | string, opts: IProjectRunnerOptions, target: EventTarget = window): Promise<IProjectExecutionLog | undefined> => {
       const e = new ContextEvent<IProjectRequestDetail, IProjectExecutionLog>(TransportEventTypes.Project.send, {
         project,
         opts,

package/src/models/data/DataAssociation.ts

@@ -383,4 +383,13 @@ export class DataAssociation {
     this.adapts = association.key;
     return association;
   }
+
+  /**
+   * @returns The definition of the parent entity of this association.
+   */
+  getParent(): DataEntity {
+    // this is forced as an association is only created when an entity is created
+    // so it has to be defined.
+    return this.root.definitions.entities.find(i => i.associations.includes(this)) as DataEntity;
+  }
 }

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';
 
@@ -483,20 +484,19 @@ export class DataEntity {
    * D -> C
    * 
    * C => [B, D]
+   * B => [A, C]
    * ```
    */
   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);
       }
     });
-
     return result;
   }
 
@@ -593,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);
   }
@@ -627,29 +628,27 @@ export class DataEntity {
     return entity;
   }
 
-  /**
-   * Checks whether the `target` creates a cycle in the graph (whether this creates a recursive association).
-   * @param target 
-   */
-  hasForwardCycle(target: string, g = this.root.associationGraph(), key = this.key): boolean {
-    if (target === key) {
-      return true;
-    }
-    const neighbors: string[] = [];
-    Object.keys(g).forEach(prop => {
-      if (g[prop].includes(key)) {
-        neighbors.push(prop);
-      }
-    });
-    if (neighbors.includes(target)) {
+  hasClosedCycle(rootEntity: string, targetEntity: string): boolean {
+    if (targetEntity === this.key) {
+      // self association
       return true;
     }
-    for (const neighbor of neighbors) {
-      if (neighbor === key) {
-        return true;
-      }
-      if (this.hasForwardCycle(target, g, neighbor)) {
-        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/runtime/actions/runnable/DeleteCookieRunnable.ts

@@ -19,7 +19,7 @@ export class DeleteCookieRunnable extends ActionRunnable {
     if (!url) {
       return;
     }
-    Events.Cookie.deleteUrl(this.eventTarget, url, config.name);
+    Events.Cookie.deleteUrl(url, config.name, this.eventTarget);
   }
 
   async request(request: IHttpRequest): Promise<void> {
@@ -34,6 +34,6 @@ export class DeleteCookieRunnable extends ActionRunnable {
     if (!url) {
       return;
     }
-    Events.Cookie.deleteUrl(this.eventTarget, url, config.name);
+    Events.Cookie.deleteUrl(url, config.name, this.eventTarget);
   } 
 }

package/src/runtime/actions/runnable/SetCookieRunnable.ts

@@ -68,7 +68,7 @@ export class SetCookieRunnable extends ActionRunnable {
     if (typeof config.secure === 'boolean') {
       cookie.secure = config.secure;
     }
-    Events.Cookie.update(this.eventTarget, cookie);
+    Events.Cookie.update(cookie, this.eventTarget);
   }
 
   async response(log: IRequestLog): Promise<void> {

package/src/runtime/actions/runnable/SetVariableRunnable.ts

@@ -29,7 +29,7 @@ export class SetVariableRunnable extends ActionRunnable {
 
   async setVariable(config: ISetVariableAction, value: string): Promise<void> {
     const { name } = config;
-    Events.Environment.set(this.eventTarget, name, value);
+    Events.Environment.set(name, value, this.eventTarget);
   }
 
   async response(log: IRequestLog): Promise<void> {

package/src/runtime/modules/RequestCookies.ts

@@ -19,7 +19,7 @@ import { Cookie } from '../../lib/cookies/Cookie.js';
  * @returns A promise that resolves to header value string.
  */
 async function getCookiesHeaderValue(eventsTarget: EventTarget, url: string): Promise<string> {
-  const cookies = await CookieEvents.listUrl(eventsTarget, url);
+  const cookies = await CookieEvents.listUrl(url, eventsTarget);
   if (!cookies || !cookies.length) {
     return '';
   }
@@ -141,6 +141,6 @@ export async function processResponseCookies(log: IRequestLog, context: Executio
   const typedResponse = log.response as IResponse;
   const result = extract(typedResponse, log.request.url, log.redirects);
   if (result.cookies.length) {
-    await CookieEvents.updateBulk(context.eventsTarget, result.cookies.map(c => HttpCookie.fromCookieParser(c).toJSON()));
+    await CookieEvents.updateBulk(result.cookies.map(c => HttpCookie.fromCookieParser(c).toJSON()), context.eventsTarget);
   }
 }

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;
-  }
-}