document-drive 1.0.0-websockets.1 → 1.0.1

package/src/server/listener/transmitter/switchboard-push.ts

@@ -1,65 +1,82 @@
-import stringify from 'json-stringify-deterministic';
-import { gql, requestGraphql } from '../../../utils/graphql';
+import stringify from "json-stringify-deterministic";
+import { gql, requestGraphql } from "../../../utils/graphql";
+import { logger } from "../../../utils/logger";
 import {
-    BaseDocumentDriveServer,
-    Listener,
-    ListenerRevision,
-    StrandUpdate
-} from '../../types';
-import { ITransmitter } from './types';
-import { logger } from '../../../utils/logger';
+  IBaseDocumentDriveServer,
+  Listener,
+  ListenerRevision,
+  StrandUpdate,
+} from "../../types";
+import { ITransmitter, StrandUpdateSource } from "./types";
 
 export class SwitchboardPushTransmitter implements ITransmitter {
-    private drive: BaseDocumentDriveServer;
-    private listener: Listener;
-    private targetURL: string;
+  private drive: IBaseDocumentDriveServer;
+  private listener: Listener;
+  private targetURL: string;
 
-    constructor(listener: Listener, drive: BaseDocumentDriveServer) {
-        this.listener = listener;
-        this.drive = drive;
-        this.targetURL = listener.callInfo!.data!;
-    }
+  constructor(listener: Listener, drive: IBaseDocumentDriveServer) {
+    this.listener = listener;
+    this.drive = drive;
+    this.targetURL = listener.callInfo!.data!;
+  }
 
-    async transmit(strands: StrandUpdate[]): Promise<ListenerRevision[]> {
-        // Send Graphql mutation to switchboard
-        try {
-            const { pushUpdates } = await requestGraphql<{
-                pushUpdates: ListenerRevision[];
-            }>(
-                this.targetURL,
-                gql`
-                    mutation pushUpdates($strands: [InputStrandUpdate!]) {
-                        pushUpdates(strands: $strands) {
-                            driveId
-                            documentId
-                            scope
-                            branch
-                            status
-                            revision
-                            error
-                        }
-                    }
-                `,
-                {
-                    strands: strands.map(strand => ({
-                        ...strand,
-                        operations: strand.operations.map(op => ({
-                            ...op,
-                            input: stringify(op.input)
-                        }))
-                    }))
-                }
-            );
+  async transmit(
+    strands: StrandUpdate[],
+    source: StrandUpdateSource,
+  ): Promise<ListenerRevision[]> {
+    if (
+      source.type === "trigger" &&
+      source.trigger.data?.url === this.targetURL
+    ) {
+      return strands.map((strand) => ({
+        driveId: strand.driveId,
+        documentId: strand.documentId,
+        scope: strand.scope,
+        branch: strand.branch,
+        status: "SUCCESS",
+        revision: strand.operations.at(-1)?.index ?? -1,
+      }));
+    }
 
-            if (!pushUpdates) {
-                throw new Error("Couldn't update listener revision");
+    // Send Graphql mutation to switchboard
+    try {
+      const { pushUpdates } = await requestGraphql<{
+        pushUpdates: ListenerRevision[];
+      }>(
+        this.targetURL,
+        gql`
+          mutation pushUpdates($strands: [InputStrandUpdate!]) {
+            pushUpdates(strands: $strands) {
+              driveId
+              documentId
+              scope
+              branch
+              status
+              revision
+              error
             }
+          }
+        `,
+        {
+          strands: strands.map((strand) => ({
+            ...strand,
+            operations: strand.operations.map((op) => ({
+              ...op,
+              input: stringify(op.input),
+            })),
+          })),
+        },
+      );
+
+      if (!pushUpdates) {
+        throw new Error("Couldn't update listener revision");
+      }
 
-            return pushUpdates;
-        } catch (e) {
-            logger.error(e);
-            throw e;
-        }
-        return [];
+      return pushUpdates;
+    } catch (e) {
+      logger.error(e);
+      throw e;
     }
+    return [];
+  }
 }

package/src/server/listener/transmitter/types.ts

@@ -1,33 +1,27 @@
 import {
-    PullResponderTriggerData,
-    SubscriptionTriggerData,
-    Trigger
-} from 'document-model-libs/document-drive';
-import { ListenerRevision, StrandUpdate } from '../..';
+  PullResponderTriggerData,
+  Trigger,
+} from "document-model-libs/document-drive";
+import { ListenerRevision, StrandUpdate } from "../..";
 
-export interface ITransmitter {
-    transmit(strands: StrandUpdate[]): Promise<ListenerRevision[]>;
-    disconnect?(): Promise<void>;
-}
+export type StrandUpdateSource =
+  | {
+      type: "local";
+    }
+  | { type: "trigger"; trigger: Trigger };
 
-export interface ITriggerTransmitter extends ITransmitter {
-    processAcknowledge(
-        driveId: string,
-        listenerId: string,
-        revisions: ListenerRevision[]
-    ): Promise<boolean>
+export interface ITransmitter {
+  transmit?(
+    strands: StrandUpdate[],
+    source: StrandUpdateSource,
+  ): Promise<ListenerRevision[]>;
+  disconnect?(): Promise<void>;
 }
-
 export interface InternalTransmitterService extends ITransmitter {
-    getName(): string;
+  getName(): string;
 }
 
-export type PullResponderTrigger = Omit<Trigger, 'data' | 'type'> & {
-    data: PullResponderTriggerData;
-    type: 'PullResponder';
-};
-
-export type SubscriptionTrigger = Omit<Trigger, 'data' | 'type'> & {
-    data: SubscriptionTriggerData;
-    type: 'Subscription';
+export type PullResponderTrigger = Omit<Trigger, "data" | "type"> & {
+  data: PullResponderTriggerData;
+  type: "PullResponder";
 };