@dxos/edge-client 0.7.5-main.e9bb01b → 0.7.5-staging.2ff1350

package/src/edge-http-client.ts

@@ -21,6 +21,10 @@ import {
   type RecoverIdentityResponseBody,
   type UploadFunctionRequest,
   type UploadFunctionResponseBody,
+  type ObjectId,
+  type ExecuteWorkflowResponseBody,
+  type QueueQuery,
+  type QueryResult,
 } from '@dxos/protocols';
 
 import { type EdgeIdentity, handleAuthChallenge } from './edge-identity';
@@ -34,6 +38,7 @@ export class EdgeHttpClient {
   private readonly _baseUrl: string;
 
   private _edgeIdentity: EdgeIdentity | undefined;
+
   /**
    * Auth header is cached until receiving the next 401 from EDGE, at which point it gets refreshed.
    */
@@ -44,6 +49,10 @@ export class EdgeHttpClient {
     log('created', { url: this._baseUrl });
   }
 
+  get baseUrl() {
+    return this._baseUrl;
+  }
+
   setIdentity(identity: EdgeIdentity) {
     if (this._edgeIdentity?.identityKey !== identity.identityKey || this._edgeIdentity?.peerKey !== identity.peerKey) {
       this._edgeIdentity = identity;
@@ -89,6 +98,15 @@ export class EdgeHttpClient {
     return this._call('/identity/recover', { ...args, body, method: 'POST' });
   }
 
+  public async executeWorkflow(
+    spaceId: SpaceId,
+    graphId: ObjectId,
+    input: any,
+    args?: EdgeHttpGetArgs,
+  ): Promise<ExecuteWorkflowResponseBody> {
+    return this._call(`/workflows/${spaceId}/${graphId}`, { ...args, body: input, method: 'POST' });
+  }
+
   public async uploadFunction(
     pathParts: { spaceId: SpaceId; functionId?: string },
     body: UploadFunctionRequest,
@@ -98,12 +116,77 @@ export class EdgeHttpClient {
     return this._call(path, { ...args, body, method: 'PUT' });
   }
 
+  public async queryQueue(
+    subspaceTag: string,
+    spaceId: SpaceId,
+    query: QueueQuery,
+    args?: EdgeHttpGetArgs,
+  ): Promise<QueryResult> {
+    const { queueId } = query;
+    const queryParams = new URLSearchParams();
+    if (query.after != null) {
+      queryParams.set('after', query.after);
+    }
+    if (query.before != null) {
+      queryParams.set('before', query.before);
+    }
+    if (query.limit != null) {
+      queryParams.set('limit', query.limit.toString());
+    }
+    if (query.reverse != null) {
+      queryParams.set('reverse', query.reverse.toString());
+    }
+    if (query.objectIds != null) {
+      queryParams.set('objectIds', query.objectIds.join(','));
+    }
+    return this._call(`/spaces/${subspaceTag}/${spaceId}/queue/${queueId}/query?${queryParams.toString()}`, {
+      ...args,
+      method: 'GET',
+    });
+  }
+
+  public async insertIntoQueue(
+    subspaceTag: string,
+    spaceId: SpaceId,
+    queueId: ObjectId,
+    objects: unknown[],
+    args?: EdgeHttpGetArgs,
+  ): Promise<void> {
+    return this._call(`/spaces/${subspaceTag}/${spaceId}/queue/${queueId}`, {
+      ...args,
+      body: { objects },
+      method: 'POST',
+    });
+  }
+
+  async deleteFromQueue(
+    subspaceTag: string,
+    spaceId: SpaceId,
+    queueId: ObjectId,
+    objectIds: ObjectId[],
+    args?: EdgeHttpGetArgs,
+  ): Promise<void> {
+    return this._call(`/spaces/${subspaceTag}/${spaceId}/queue/${queueId}`, {
+      ...args,
+      query: { ids: objectIds.join(',') },
+      method: 'DELETE',
+    });
+  }
+
   private async _call<T>(path: string, args: EdgeHttpCallArgs): Promise<T> {
     const requestContext = args.context ?? new Context();
     const shouldRetry = createRetryHandler(args);
-    const url = `${this._baseUrl}${path.startsWith('/') ? path.slice(1) : path}`;
+    let url = `${this._baseUrl}${path.startsWith('/') ? path.slice(1) : path}`;
+
+    if (args.query) {
+      const queryParams = new URLSearchParams();
+      for (const [key, value] of Object.entries(args.query)) {
+        queryParams.set(key, value.toString());
+      }
+      url += `?${queryParams.toString()}`;
+    }
 
-    log.info('call', { method: args.method, path, request: args.body });
+    log('call', { method: args.method, path, request: args.body });
 
     let handledAuth = false;
     let authHeader = this._authHeader;
@@ -122,7 +205,7 @@ export class EdgeHttpClient {
             return body.data;
           }
 
-          log.info('unsuccessful edge response', { path, body });
+          log('unsuccessful edge response', { path, body });
 
           if (body.errorData?.type === 'auth_challenge' && typeof body.errorData?.challenge === 'string') {
             processingError = new EdgeAuthChallengeError(body.errorData.challenge, body.errorData);
@@ -141,7 +224,7 @@ export class EdgeHttpClient {
       }
 
       if (processingError.isRetryable && (await shouldRetry(requestContext, retryAfterHeaderValue))) {
-        log.info('retrying edge request', { path, processingError });
+        log('retrying edge request', { path, processingError });
       } else {
         throw processingError;
       }
@@ -208,6 +291,7 @@ type EdgeHttpCallArgs = {
   body?: any;
   context?: Context;
   retry?: RetryConfig;
+  query?: Record<string, string>;
 };
 
 const createRequest = (args: EdgeHttpCallArgs, authHeader: string | undefined): RequestInit => {

package/src/edge-ws-connection.ts

@@ -15,7 +15,8 @@ import { protocol } from './defs';
 import { type EdgeIdentity } from './edge-identity';
 import { toUint8Array } from './protocol';
 
-const SIGNAL_KEEPALIVE_INTERVAL = 5_000;
+const SIGNAL_KEEPALIVE_INTERVAL = 4_000;
+const SIGNAL_KEEPALIVE_TIMEOUT = 12_000;
 
 /**
  * 1MB websocket message limit: https://developers.cloudflare.com/durable-objects/platform/limits/
@@ -79,9 +80,9 @@ export class EdgeWsConnection extends Resource {
         log.verbose('connected after becoming inactive', { currentIdentity: this._identity });
       }
     };
-    this._ws.onclose = () => {
+    this._ws.onclose = (event) => {
       if (this.isOpen) {
-        log('disconnected while being open');
+        log.warn('disconnected while being open', { code: event.code, reason: event.reason });
         this._callbacks.onRestartRequired();
       }
     };
@@ -153,10 +154,11 @@ export class EdgeWsConnection extends Resource {
       this._inactivityTimeoutCtx,
       () => {
         if (this.isOpen) {
+          log.warn('restart due to inactivity timeout');
           this._callbacks.onRestartRequired();
         }
       },
-      2 * SIGNAL_KEEPALIVE_INTERVAL,
+      SIGNAL_KEEPALIVE_TIMEOUT,
     );
   }
 }

package/dist/types/src/persistent-lifecycle.d.ts

@@ -1,44 +0,0 @@
-import { Resource } from '@dxos/context';
-export type PersistentLifecycleParams<T> = {
-    /**
-     * Create connection.
-     * If promise resolves successfully, connection is considered established.
-     */
-    start: () => Promise<T | undefined>;
-    /**
-     * Reset connection to initial state.
-     */
-    stop: (state: T) => Promise<void>;
-    /**
-     * Called after successful start.
-     */
-    onRestart?: () => Promise<void>;
-    /**
-     * Maximum delay between restartion attempts.
-     * Default: 5000ms
-     */
-    maxRestartDelay?: number;
-};
-/**
- * Handles restarts (e.g. persists connection).
- * Restarts are scheduled with exponential backoff.
- */
-export declare class PersistentLifecycle<T> extends Resource {
-    private readonly _start;
-    private readonly _stop;
-    private readonly _onRestart?;
-    private readonly _maxRestartDelay;
-    private _currentContext;
-    private _restartTask?;
-    private _restartAfter;
-    constructor({ start, stop, onRestart, maxRestartDelay }: PersistentLifecycleParams<T>);
-    protected _open(): Promise<void>;
-    protected _close(): Promise<void>;
-    private _restart;
-    private _stopCurrentContext;
-    /**
-     * Scheduling restart should be done from outside.
-     */
-    scheduleRestart(): void;
-}
-//# sourceMappingURL=persistent-lifecycle.d.ts.map

package/dist/types/src/persistent-lifecycle.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"persistent-lifecycle.d.ts","sourceRoot":"","sources":["../../../src/persistent-lifecycle.ts"],"names":[],"mappings":"AAKA,OAAO,EAAqC,QAAQ,EAAE,MAAM,eAAe,CAAC;AAO5E,MAAM,MAAM,yBAAyB,CAAC,CAAC,IAAI;IACzC;;;OAGG;IACH,KAAK,EAAE,MAAM,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC;IAEpC;;OAEG;IACH,IAAI,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAElC;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAEhC;;;OAGG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B,CAAC;AAEF;;;GAGG;AACH,qBAAa,mBAAmB,CAAC,CAAC,CAAE,SAAQ,QAAQ;IAClD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA+B;IACtD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA8B;IACpD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAsB;IAClD,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAS;IAE1C,OAAO,CAAC,eAAe,CAA4B;IACnD,OAAO,CAAC,YAAY,CAAC,CAA2B;IAChD,OAAO,CAAC,aAAa,CAAK;gBAEd,EAAE,KAAK,EAAE,IAAI,EAAE,SAAS,EAAE,eAA2C,EAAE,EAAE,yBAAyB,CAAC,CAAC,CAAC;cASxF,KAAK;cAgBL,MAAM;YAMjB,QAAQ;YAkBR,mBAAmB;IAWjC;;OAEG;IAEH,eAAe;CAMhB"}

package/dist/types/src/persistent-lifecycle.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=persistent-lifecycle.test.d.ts.map

package/dist/types/src/persistent-lifecycle.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"persistent-lifecycle.test.d.ts","sourceRoot":"","sources":["../../../src/persistent-lifecycle.test.ts"],"names":[],"mappings":""}

package/src/persistent-lifecycle.test.ts

@@ -1,71 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import { describe, expect, test } from 'vitest';
-
-import { sleep, Trigger } from '@dxos/async';
-import { log } from '@dxos/log';
-import { openAndClose } from '@dxos/test-utils';
-
-import { PersistentLifecycle } from './persistent-lifecycle';
-
-describe('ConnectionState', () => {
-  test('first reconnect fires immediately', async () => {
-    const triggerCall = new Trigger<number>();
-    const persistentLifecycle = new PersistentLifecycle({
-      start: async () => {
-        triggerCall.wake(Date.now());
-      },
-      stop: async () => {},
-    });
-    await openAndClose(persistentLifecycle);
-
-    const triggerTimestamp = Date.now();
-    persistentLifecycle.scheduleRestart();
-    const timeToTrigger = (await triggerCall.wait({ timeout: 1000 })) - triggerTimestamp;
-    expect(timeToTrigger).to.be.lessThan(50);
-  });
-
-  test('second reconnect fires after 100ms', async () => {
-    let called = 0;
-    const triggerCall = new Trigger<number>();
-
-    const persistentLifecycle = new PersistentLifecycle({
-      start: async () => {
-        called += 1;
-        log.info('called', { called });
-        if (called < 3) {
-          throw new Error('TEST ERROR');
-        }
-        triggerCall.wake(Date.now());
-      },
-      stop: async () => {},
-    });
-
-    await openAndClose(persistentLifecycle);
-
-    const triggerTimestamp = Date.now();
-    await sleep(10);
-    const timeToTrigger = (await triggerCall.wait({ timeout: 1000 })) - triggerTimestamp;
-    expect(timeToTrigger).to.be.greaterThanOrEqual(100);
-  });
-
-  test('finish `restart` before close', async () => {
-    let restarted = false;
-    const persistentLifecycle = new PersistentLifecycle({
-      start: async () => await sleep(100),
-      stop: async () => {},
-      onRestart: async () => {
-        restarted = true;
-      },
-    });
-
-    await persistentLifecycle.open();
-
-    persistentLifecycle.scheduleRestart();
-    await sleep(10);
-    await persistentLifecycle.close();
-    expect(restarted).to.be.true;
-  });
-});

package/src/persistent-lifecycle.ts

@@ -1,121 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import { DeferredTask, sleep, synchronized } from '@dxos/async';
-import { cancelWithContext, LifecycleState, Resource } from '@dxos/context';
-import { warnAfterTimeout } from '@dxos/debug';
-import { log } from '@dxos/log';
-
-const INIT_RESTART_DELAY = 100;
-const DEFAULT_MAX_RESTART_DELAY = 5000;
-
-export type PersistentLifecycleParams<T> = {
-  /**
-   * Create connection.
-   * If promise resolves successfully, connection is considered established.
-   */
-  start: () => Promise<T | undefined>;
-
-  /**
-   * Reset connection to initial state.
-   */
-  stop: (state: T) => Promise<void>;
-
-  /**
-   * Called after successful start.
-   */
-  onRestart?: () => Promise<void>;
-
-  /**
-   * Maximum delay between restartion attempts.
-   * Default: 5000ms
-   */
-  maxRestartDelay?: number;
-};
-
-/**
- * Handles restarts (e.g. persists connection).
- * Restarts are scheduled with exponential backoff.
- */
-export class PersistentLifecycle<T> extends Resource {
-  private readonly _start: () => Promise<T | undefined>;
-  private readonly _stop: (state: T) => Promise<void>;
-  private readonly _onRestart?: () => Promise<void>;
-  private readonly _maxRestartDelay: number;
-
-  private _currentContext: T | undefined = undefined;
-  private _restartTask?: DeferredTask = undefined;
-  private _restartAfter = 0;
-
-  constructor({ start, stop, onRestart, maxRestartDelay = DEFAULT_MAX_RESTART_DELAY }: PersistentLifecycleParams<T>) {
-    super();
-    this._start = start;
-    this._stop = stop;
-    this._onRestart = onRestart;
-    this._maxRestartDelay = maxRestartDelay;
-  }
-
-  @synchronized
-  protected override async _open() {
-    this._restartTask = new DeferredTask(this._ctx, async () => {
-      try {
-        await this._restart();
-      } catch (err) {
-        log.warn('Restart failed', { err });
-        this._restartTask?.schedule();
-      }
-    });
-    this._currentContext = await this._start().catch((err) => {
-      log.warn('Start failed', { err });
-      this._restartTask?.schedule();
-      return undefined;
-    });
-  }
-
-  protected override async _close() {
-    await this._restartTask?.join();
-    await this._stopCurrentContext();
-    this._restartTask = undefined;
-  }
-
-  private async _restart() {
-    log(`restarting in ${this._restartAfter}ms`, { state: this._lifecycleState });
-    await this._stopCurrentContext();
-    if (this._lifecycleState !== LifecycleState.OPEN) {
-      return;
-    }
-    await cancelWithContext(this._ctx!, sleep(this._restartAfter));
-    this._restartAfter = Math.min(Math.max(this._restartAfter * 2, INIT_RESTART_DELAY), this._maxRestartDelay);
-
-    // May fail if the connection is not established.
-    await warnAfterTimeout(5_000, 'Connection establishment takes too long', async () => {
-      this._currentContext = await this._start();
-    });
-
-    this._restartAfter = 0;
-    await this._onRestart?.();
-  }
-
-  private async _stopCurrentContext() {
-    if (this._currentContext) {
-      try {
-        await this._stop(this._currentContext);
-      } catch (err) {
-        log.catch(err);
-      }
-      this._currentContext = undefined;
-    }
-  }
-
-  /**
-   * Scheduling restart should be done from outside.
-   */
-  @synchronized
-  scheduleRestart() {
-    if (this._lifecycleState !== LifecycleState.OPEN) {
-      return;
-    }
-    this._restartTask!.schedule();
-  }
-}