@api-client/core 0.6.16 → 0.6.19

package/src/events/cookies/CookieEvents.ts

@@ -48,7 +48,7 @@ export class CookieEvents {
    * @param domain The cookie domain
    * @returns The list of project index objects.
    */
-  static async listDomain(target: EventTarget, domain: string): Promise<IHttpCookie[] | undefined> {
+  static async listDomain(domain: string, target: EventTarget = window): Promise<IHttpCookie[] | undefined> {
     const detail: ICookieDomainListDetail = { domain };
     const e = new ContextEvent<ICookieDomainListDetail, IHttpCookie[]>(CookieEventTypes.listDomain, detail);
     target.dispatchEvent(e);
@@ -60,7 +60,7 @@ export class CookieEvents {
    * @param url The cookie URL
    * @returns The list of project index objects.
    */
-  static async listUrl(target: EventTarget, url: string): Promise<IHttpCookie[] | undefined> {
+  static async listUrl(url: string, target: EventTarget = window): Promise<IHttpCookie[] | undefined> {
     const detail: ICookieUrlListDetail = { url };
     const e = new ContextEvent<ICookieUrlListDetail, IHttpCookie[]>(CookieEventTypes.listUrl, detail);
     target.dispatchEvent(e);
@@ -73,7 +73,7 @@ export class CookieEvents {
    * @param target The target on which to dispatch the event
    * @param cookies The list of cookies to remove
    */
-  static async delete(target: EventTarget, cookies: IHttpCookie[]): Promise<void> {
+  static async delete(cookies: IHttpCookie[], target: EventTarget = window): Promise<void> {
     const detail: ICookieItemsDetail = { cookies };
     const e = new ContextEvent<ICookieItemsDetail, void>(CookieEventTypes.delete, detail);
     target.dispatchEvent(e);
@@ -87,7 +87,7 @@ export class CookieEvents {
    * @param url The url associated with the cookie. Depending on the session mechanism the URL or the domain and the path is used.
    * @param name The name of the cookie to remove. When not set all cookies are removed for the given URL.
    */
-  static async deleteUrl(target: EventTarget, url: string, name?: string): Promise<void> {
+  static async deleteUrl(url: string, name?: string, target: EventTarget = window): Promise<void> {
     const detail: ICookieDeleteUrlDetail = { url, name };
     const e = new ContextEvent<ICookieDeleteUrlDetail, void>(CookieEventTypes.deleteUrl, detail);
     target.dispatchEvent(e);
@@ -101,7 +101,7 @@ export class CookieEvents {
    * @param cookie A cookie to update
    * @returns The change record of the updated cookie.
    */
-  static async update(target: EventTarget, cookie: IHttpCookie): Promise<ContextChangeRecord<IHttpCookie> | undefined> {
+  static async update(cookie: IHttpCookie, target: EventTarget = window): Promise<ContextChangeRecord<IHttpCookie> | undefined> {
     const e = new ContextUpdateEvent(CookieEventTypes.update, { item: cookie });
     target.dispatchEvent(e);
     return e.detail.result;
@@ -114,7 +114,7 @@ export class CookieEvents {
    * @param cookies A list of cookies to update
    * @returns The change record of the updated cookie.
    */
-  static async updateBulk(target: EventTarget, cookies: IHttpCookie[]): Promise<void> {
+  static async updateBulk(cookies: IHttpCookie[], target: EventTarget = window): Promise<void> {
     const detail: ICookieItemsDetail = { cookies };
     const e = new ContextEvent<ICookieItemsDetail, void>(CookieEventTypes.updateBulk, detail);
     target.dispatchEvent(e);
@@ -135,7 +135,7 @@ class StateEvents {
    * @param target The target on which to dispatch the event
    * @param cookie The schema of the removed cookie
    */
-  static delete(target: EventTarget, cookie: IHttpCookie): void {
+  static delete(cookie: IHttpCookie, target: EventTarget = window): void {
     const e = new CustomEvent<ICookieDetail>(CookieEventTypes.State.delete, {
       bubbles: true,
       composed: true,
@@ -150,7 +150,7 @@ class StateEvents {
    * @param target The target on which to dispatch the event
    * @param record The change record.
    */
-  static update(target: EventTarget, record: ContextChangeRecord<IHttpCookie>): void {
+  static update(record: ContextChangeRecord<IHttpCookie>, target: EventTarget = window): void {
     const e = new ContextStateUpdateEvent<IHttpCookie>(CookieEventTypes.State.update, record);
     target.dispatchEvent(e);
   }

package/src/events/encryption/EncryptionEvents.ts

@@ -20,13 +20,13 @@ export class EncryptionEvents {
   /**
    * Dispatches an event handled by the encryption module to encrypt the data
    *
-   * @param target A node on which to dispatch the event.
    * @param data The data to encrypt
    * @param passphrase The passphrase to use in 2-way data encryption
    * @param method Encryption method to use
+   * @param target A node on which to dispatch the event.
    * @returns Promise resolved to the encryption result
    */
-  static async encrypt(target: EventTarget, data: any, passphrase: string, method: string): Promise<string | undefined> {
+  static async encrypt(data: any, passphrase: string, method: string, target: EventTarget = window): Promise<string | undefined> {
     const config: IEncryptionEventDetail = { data, passphrase, method };
     const e = new ContextEvent<IEncryptionEventDetail, string>(EncryptionEventTypes.encrypt, config);
     target.dispatchEvent(e);
@@ -36,13 +36,13 @@ export class EncryptionEvents {
   /**
    * Dispatches an event handled by the encryption module to decrypt the data
    *
-   * @param target A node on which to dispatch the event.
    * @param data The data to decrypt
    * @param passphrase The passphrase to use to decrypt the data
    * @param method Method used to encrypt the data
+   * @param target A node on which to dispatch the event.
    * @returns Promise resolved to the decrypted result
    */
-  static async decrypt(target: EventTarget, data: any, passphrase: string, method: string): Promise<string | undefined> {
+  static async decrypt(data: any, passphrase: string, method: string, target: EventTarget = window): Promise<string | undefined> {
     const config: IEncryptionEventDetail = { data, passphrase, method };
     const e = new ContextEvent<IEncryptionEventDetail, string>(EncryptionEventTypes.decrypt, config);
     target.dispatchEvent(e);

package/src/events/environment/EnvironmentEvents.ts

@@ -10,12 +10,12 @@ export class EnvironmentEvents {
   /**
    * An event dispatched to set a variable in the current environment.
    * 
-   * @param target A node on which to dispatch the event.
    * @param name Variable name
    * @param value Variable value
+   * @param target A node on which to dispatch the event.
    * @returns Nothing. The promise resolves when the variable is set.
    */
-  static async set(target: EventTarget, name: string, value: string): Promise<void> {
+  static async set(name: string, value: string, target: EventTarget = window): Promise<void> {
     const detail: ISetVariableDetail = { name, value };
     const e = new ContextEvent<ISetVariableDetail, void>(EnvironmentEventTypes.set, detail);
     target.dispatchEvent(e);

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';
 
@@ -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/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);
   }
 }