document-drive 1.0.0-alpha.77 → 1.0.0-alpha.78

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "document-drive",
-    "version": "1.0.0-alpha.77",
+    "version": "1.0.0-alpha.78",
     "license": "AGPL-3.0-only",
     "type": "module",
     "module": "./src/index.ts",

package/src/queue/types.ts

@@ -1,12 +1,12 @@
 import { Action, Operation } from "document-model/document";
-import { IOperationResult } from "../server";
+import { AddOperationOptions, IOperationResult } from "../server";
 import type { Unsubscribe } from "nanoevents";
 
 export interface BaseJob {
     driveId: string;
     documentId?: string
     actions?: Action[]
-    forceSync?: boolean
+    options?: AddOperationOptions;    
 }
 
 export interface OperationJob extends BaseJob {

package/src/server/index.ts

@@ -60,9 +60,11 @@ import {
     InternalTransmitter,
     IReceiver,
     ITransmitter,
-    PullResponderTransmitter
+    PullResponderTransmitter,
+    StrandUpdateSource
 } from './listener/transmitter';
 import {
+    AddOperationOptions,
     BaseDocumentDriveServer,
     DriveEvents,
     GetDocumentOptions,
@@ -138,7 +140,7 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
         }
     }
 
-    private async saveStrand(strand: StrandUpdate) {
+    private async saveStrand(strand: StrandUpdate, source: StrandUpdateSource) {
         const operations: Operation[] = strand.operations.map(op => ({
             ...op,
             scope: strand.scope,
@@ -149,13 +151,13 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
             ? this.queueDriveOperations(
                   strand.driveId,
                   operations as Operation<DocumentDriveAction | BaseAction>[],
-                  false
+                  { source }
               )
             : this.queueOperations(
                   strand.driveId,
                   strand.documentId,
                   operations,
-                  false
+                  { source }
               ));
 
         if (result.status === 'ERROR') {
@@ -283,30 +285,30 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
             driveId,
             documentId,
             operations,
-            forceSync
+            options
         }: OperationJob) => {
             return documentId
-                ? this.addOperations(driveId, documentId, operations, forceSync)
+                ? this.addOperations(driveId, documentId, operations, options)
                 : this.addDriveOperations(
                       driveId,
                       operations as Operation<
                           DocumentDriveAction | BaseAction
                       >[],
-                      forceSync
+                      options
                   );
         },
         processActionJob: async ({
             driveId,
             documentId,
             actions,
-            forceSync
+            options
         }: ActionJob) => {
             return documentId
-                ? this.addActions(driveId, documentId, actions, forceSync)
+                ? this.addActions(driveId, documentId, actions, options)
                 : this.addDriveActions(
                       driveId,
                       actions as Operation<DocumentDriveAction | BaseAction>[],
-                      forceSync
+                      options
                   );
         },
         processJob: async (job: Job) => {
@@ -335,12 +337,16 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
             errors.push(error);
         });
 
-        // if network connect comes online then
-        // triggers the listeners update
+        // if network connect comes back online
+        // then triggers the listeners update
         if (typeof window !== 'undefined') {
             window.addEventListener('online', () => {
                 this.listenerStateManager
-                    .triggerUpdate(false, this.handleListenerError.bind(this))
+                    .triggerUpdate(
+                        false,
+                        { type: 'local' },
+                        this.handleListenerError.bind(this)
+                    )
                     .catch(error => {
                         logger.error(
                             'Non handled error updating listeners',
@@ -1072,9 +1078,9 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
         drive: string,
         id: string,
         operation: Operation,
-        forceSync = true
+        options?: AddOperationOptions
     ): Promise<IOperationResult> {
-        return this.addOperations(drive, id, [operation], forceSync);
+        return this.addOperations(drive, id, [operation], options);
     }
 
     private async _addOperations(
@@ -1110,9 +1116,9 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
         drive: string,
         id: string,
         operation: Operation,
-        forceSync = true
+        options?: AddOperationOptions
     ): Promise<IOperationResult> {
-        return this.queueOperations(drive, id, [operation], forceSync);
+        return this.queueOperations(drive, id, [operation], options);
     }
 
     private async resultIfExistingOperations(
@@ -1153,7 +1159,7 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
         drive: string,
         id: string,
         operations: Operation[],
-        forceSync = true
+        options?: AddOperationOptions
     ) {
         // if operations are already stored then returns cached document
         const result = await this.resultIfExistingOperations(
@@ -1162,7 +1168,6 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
             operations
         );
         if (result) {
-            console.log('Duplicated operations!');
             return result;
         }
         try {
@@ -1170,7 +1175,7 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
                 driveId: drive,
                 documentId: id,
                 operations,
-                forceSync
+                options
             });
 
             return new Promise<IOperationResult>((resolve, reject) => {
@@ -1205,23 +1210,23 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
         drive: string,
         id: string,
         action: Action,
-        forceSync?: boolean | undefined
+        options?: AddOperationOptions
     ): Promise<IOperationResult> {
-        return this.queueActions(drive, id, [action], forceSync);
+        return this.queueActions(drive, id, [action], options);
     }
 
     async queueActions(
         drive: string,
         id: string,
         actions: Action[],
-        forceSync?: boolean | undefined
+        options?: AddOperationOptions
     ): Promise<IOperationResult> {
         try {
             const jobId = await this.queueManager.addJob({
                 driveId: drive,
                 documentId: id,
                 actions,
-                forceSync
+                options
             });
 
             return new Promise<IOperationResult>((resolve, reject) => {
@@ -1255,20 +1260,20 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
     async queueDriveAction(
         drive: string,
         action: DocumentDriveAction | BaseAction,
-        forceSync?: boolean | undefined
+        options?: AddOperationOptions
     ): Promise<IOperationResult<DocumentDriveDocument>> {
-        return this.queueDriveActions(drive, [action], forceSync);
+        return this.queueDriveActions(drive, [action], options);
     }
 
     async queueDriveActions(
         drive: string,
         actions: (DocumentDriveAction | BaseAction)[],
-        forceSync?: boolean | undefined
+        options?: AddOperationOptions
     ): Promise<IOperationResult<DocumentDriveDocument>> {
         const jobId = await this.queueManager.addJob({
             driveId: drive,
             actions,
-            forceSync
+            options
         });
         return new Promise<IOperationResult<DocumentDriveDocument>>(
             (resolve, reject) => {
@@ -1302,7 +1307,7 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
         drive: string,
         id: string,
         operations: Operation[],
-        forceSync = true
+        options?: AddOperationOptions
     ) {
         // if operations are already stored then returns the result
         const result = await this.resultIfExistingOperations(
@@ -1365,11 +1370,32 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
                 scopes,
                 branches
             );
+
+            // checks if any of the provided operations where reshufled
+            const newOp = operationsApplied.find(
+                appliedOp =>
+                    !operations.find(
+                        o =>
+                            o.id === appliedOp.id &&
+                            o.index === appliedOp.index &&
+                            o.skip === appliedOp.skip &&
+                            o.hash === appliedOp.hash
+                    )
+            );
+
+            // if there are no new operations then reuses the provided source
+            // otherwise sets it to local so listeners know that there were
+            // new changes originating from this document drive server
+            const source: StrandUpdateSource = newOp
+                ? { type: 'local' }
+                : options?.source ?? { type: 'local' };
+
             // update listener cache
             this.listenerStateManager
                 .updateSynchronizationRevisions(
                     drive,
                     syncUnits,
+                    source,
                     () => {
                         this.updateSyncStatus(drive, 'SYNCING');
 
@@ -1378,7 +1404,7 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
                         }
                     },
                     this.handleListenerError.bind(this),
-                    forceSync
+                    options?.forceSync ?? source.type === 'local'
                 )
                 .then(updates => {
                     updates.length && this.updateSyncStatus(drive, 'SUCCESS');
@@ -1439,9 +1465,9 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
     addDriveOperation(
         drive: string,
         operation: Operation<DocumentDriveAction | BaseAction>,
-        forceSync = true
+        options?: AddOperationOptions
     ) {
-        return this.addDriveOperations(drive, [operation], forceSync);
+        return this.addDriveOperations(drive, [operation], options);
     }
 
     async clearStorage() {
@@ -1482,9 +1508,9 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
     queueDriveOperation(
         drive: string,
         operation: Operation<DocumentDriveAction | BaseAction>,
-        forceSync = true
+        options?: AddOperationOptions
     ): Promise<IOperationResult<DocumentDriveDocument>> {
-        return this.queueDriveOperations(drive, [operation], forceSync);
+        return this.queueDriveOperations(drive, [operation], options);
     }
 
     private async resultIfExistingDriveOperations(
@@ -1523,7 +1549,7 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
     async queueDriveOperations(
         drive: string,
         operations: Operation<DocumentDriveAction | BaseAction>[],
-        forceSync = true
+        options?: AddOperationOptions
     ): Promise<IOperationResult<DocumentDriveDocument>> {
         // if operations are already stored then returns cached document
         const result = await this.resultIfExistingDriveOperations(
@@ -1537,7 +1563,7 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
         const jobId = await this.queueManager.addJob({
             driveId: drive,
             operations,
-            forceSync
+            options
         });
         return new Promise<IOperationResult<DocumentDriveDocument>>(
             (resolve, reject) => {
@@ -1570,7 +1596,7 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
     async addDriveOperations(
         drive: string,
         operations: Operation<DocumentDriveAction | BaseAction>[],
-        forceSync = true
+        options?: AddOperationOptions
     ) {
         let document: DocumentDriveDocument | undefined;
         const operationsApplied: Operation<DocumentDriveAction | BaseAction>[] =
@@ -1646,7 +1672,27 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
                 .filter(op => op.scope === 'global')
                 .slice()
                 .pop();
+
             if (lastOperation) {
+                // checks if any of the provided operations where reshufled
+                const newOp = operationsApplied.find(
+                    appliedOp =>
+                        !operations.find(
+                            o =>
+                                o.id === appliedOp.id &&
+                                o.index === appliedOp.index &&
+                                o.skip === appliedOp.skip &&
+                                o.hash === appliedOp.hash
+                        )
+                );
+
+                // if there are no new operations then reuses the provided source
+                // otherwise sets it to local so listeners know that there were
+                // new changes originating from this document drive server
+                const source: StrandUpdateSource = newOp
+                    ? { type: 'local' }
+                    : options?.source ?? { type: 'local' };
+
                 this.listenerStateManager
                     .updateSynchronizationRevisions(
                         drive,
@@ -1662,6 +1708,7 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
                                 revision: lastOperation.index
                             }
                         ],
+                        source,
                         () => {
                             this.updateSyncStatus(drive, 'SYNCING');
 
@@ -1673,7 +1720,7 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
                             }
                         },
                         this.handleListenerError.bind(this),
-                        forceSync
+                        options?.forceSync ?? source.type === 'local'
                     )
                     .then(updates => {
                         if (updates.length) {
@@ -1768,41 +1815,41 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
         drive: string,
         id: string,
         action: Action,
-        forceSync = true
+        options?: AddOperationOptions
     ): Promise<IOperationResult> {
-        return this.addActions(drive, id, [action], forceSync);
+        return this.addActions(drive, id, [action], options);
     }
 
     async addActions(
         drive: string,
         id: string,
         actions: Action[],
-        forceSync = true
+        options?: AddOperationOptions
     ): Promise<IOperationResult> {
         const document = await this.getDocument(drive, id);
         const operations = this._buildOperations(document, actions);
-        return this.addOperations(drive, id, operations, forceSync);
+        return this.addOperations(drive, id, operations, options);
     }
 
     async addDriveAction(
         drive: string,
         action: DocumentDriveAction | BaseAction,
-        forceSync = true
+        options?: AddOperationOptions
     ): Promise<IOperationResult<DocumentDriveDocument>> {
-        return this.addDriveActions(drive, [action], forceSync);
+        return this.addDriveActions(drive, [action], options);
     }
 
     async addDriveActions(
         drive: string,
         actions: (DocumentDriveAction | BaseAction)[],
-        forceSync = true
+        options?: AddOperationOptions
     ): Promise<IOperationResult<DocumentDriveDocument>> {
         const document = await this.getDrive(drive);
         const operations = this._buildOperations(document, actions);
         const result = await this.addDriveOperations(
             drive,
             operations,
-            forceSync
+            options
         );
         return result;
     }

package/src/server/listener/manager.ts

@@ -3,6 +3,7 @@ import {
     ListenerFilter
 } from 'document-model-libs/document-drive';
 import { OperationScope } from 'document-model/document';
+import { logger } from '../../utils/logger';
 import { OperationError } from '../error';
 import {
     BaseListenerManager,
@@ -17,8 +18,7 @@ import {
 import { PullResponderTransmitter } from './transmitter';
 import { InternalTransmitter } from './transmitter/internal';
 import { SwitchboardPushTransmitter } from './transmitter/switchboard-push';
-import { ITransmitter } from './transmitter/types';
-import { logger } from '../../utils/logger';
+import { ITransmitter, StrandUpdateSource } from './transmitter/types';
 
 function debounce<T extends unknown[], R>(
     func: (...args: T) => Promise<R>,
@@ -118,7 +118,10 @@ export class ListenerManager extends BaseListenerManager {
         return Promise.resolve(driveMap.delete(listenerId));
     }
 
-    async removeSyncUnits(driveId: string, syncUnits: Pick<SynchronizationUnit, "syncId">[]) {
+    async removeSyncUnits(
+        driveId: string,
+        syncUnits: Pick<SynchronizationUnit, 'syncId'>[]
+    ) {
         const listeners = this.listenerState.get(driveId);
         if (!listeners) {
             return;
@@ -134,6 +137,7 @@ export class ListenerManager extends BaseListenerManager {
     async updateSynchronizationRevisions(
         driveId: string,
         syncUnits: SynchronizationUnit[],
+        source: StrandUpdateSource,
         willUpdate?: (listeners: Listener[]) => void,
         onError?: (
             error: Error,
@@ -175,7 +179,7 @@ export class ListenerManager extends BaseListenerManager {
 
         if (outdatedListeners.length) {
             willUpdate?.(outdatedListeners);
-            return this.triggerUpdate(forceSync, onError);
+            return this.triggerUpdate(forceSync, source, onError);
         }
         return [];
     }
@@ -214,6 +218,7 @@ export class ListenerManager extends BaseListenerManager {
     );
 
     private async _triggerUpdate(
+        source: StrandUpdateSource,
         onError?: (
             error: Error,
             driveId: string,
@@ -246,7 +251,8 @@ export class ListenerManager extends BaseListenerManager {
 
                     const opData: OperationUpdate[] = [];
                     try {
-                        const data = await this.drive.getOperationData( // TODO - join queries, DEAL WITH INVALID SYNC ID ERROR
+                        const data = await this.drive.getOperationData(
+                            // TODO - join queries, DEAL WITH INVALID SYNC ID ERROR
                             driveId,
                             syncUnit.syncId,
                             {
@@ -282,8 +288,10 @@ export class ListenerManager extends BaseListenerManager {
 
                 // TODO update listeners in parallel, blocking for listeners with block=true
                 try {
-                    const listenerRevisions =
-                        await transmitter?.transmit(strandUpdates);
+                    const listenerRevisions = await transmitter?.transmit(
+                        strandUpdates,
+                        source
+                    );
 
                     listener.pendingTimeout = '0';
                     listener.listenerStatus = 'PENDING';
@@ -420,7 +428,9 @@ export class ListenerManager extends BaseListenerManager {
         this.listenerState.delete(driveId);
         const transmitters = this.transmitters[driveId];
         if (transmitters) {
-            await Promise.all(Object.values(transmitters).map(t => t.disconnect?.()));
+            await Promise.all(
+                Object.values(transmitters).map(t => t.disconnect?.())
+            );
         }
     }
 
@@ -456,7 +466,8 @@ export class ListenerManager extends BaseListenerManager {
 
             const { documentId, driveId, scope, branch } = syncUnit;
             try {
-                const operations = await this.drive.getOperationData( // DEAL WITH INVALID SYNC ID ERROR
+                const operations = await this.drive.getOperationData(
+                    // DEAL WITH INVALID SYNC ID ERROR
                     driveId,
                     syncUnit.syncId,
                     {

package/src/server/listener/transmitter/pull-responder.ts

@@ -16,7 +16,11 @@ import {
     StrandUpdate
 } from '../../types';
 import { ListenerManager } from '../manager';
-import { ITransmitter, PullResponderTrigger } from './types';
+import {
+    ITransmitter,
+    PullResponderTrigger,
+    StrandUpdateSource
+} from './types';
 
 export type OperationUpdateGraphQL = Omit<OperationUpdate, 'input'> & {
     input: string;
@@ -215,7 +219,10 @@ export class PullResponderTransmitter implements IPullResponderTransmitter {
     private static async executePull(
         driveId: string,
         trigger: PullResponderTrigger,
-        onStrandUpdate: (strand: StrandUpdate) => Promise<IOperationResult>,
+        onStrandUpdate: (
+            strand: StrandUpdate,
+            source: StrandUpdateSource
+        ) => Promise<IOperationResult>,
         onError: (error: Error) => void,
         onRevisions?: (revisions: ListenerRevisionWithError[]) => void,
         onAcknowledge?: (success: boolean) => void
@@ -246,7 +253,10 @@ export class PullResponderTransmitter implements IPullResponderTransmitter {
 
                 let error: Error | undefined = undefined;
                 try {
-                    const result = await onStrandUpdate(strand);
+                    const result = await onStrandUpdate(strand, {
+                        type: 'trigger',
+                        trigger
+                    });
                     if (result.error) {
                         throw result.error;
                     }
@@ -291,7 +301,10 @@ export class PullResponderTransmitter implements IPullResponderTransmitter {
     static setupPull(
         driveId: string,
         trigger: PullResponderTrigger,
-        onStrandUpdate: (strand: StrandUpdate) => Promise<IOperationResult>,
+        onStrandUpdate: (
+            strand: StrandUpdate,
+            source: StrandUpdateSource
+        ) => Promise<IOperationResult>,
         onError: (error: Error) => void,
         onRevisions?: (revisions: ListenerRevisionWithError[]) => void,
         onAcknowledge?: (success: boolean) => void

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

@@ -1,13 +1,13 @@
 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';
+import { ITransmitter, StrandUpdateSource } from './types';
 
 export class SwitchboardPushTransmitter implements ITransmitter {
     private drive: BaseDocumentDriveServer;
@@ -20,7 +20,24 @@ export class SwitchboardPushTransmitter implements ITransmitter {
         this.targetURL = listener.callInfo!.data!;
     }
 
-    async transmit(strands: StrandUpdate[]): Promise<ListenerRevision[]> {
+    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
+            }));
+        }
+
         // Send Graphql mutation to switchboard
         try {
             const { pushUpdates } = await requestGraphql<{

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

@@ -4,11 +4,19 @@ import {
 } from 'document-model-libs/document-drive';
 import { ListenerRevision, StrandUpdate } from '../..';
 
+export type StrandUpdateSource =
+    | {
+          type: 'local';
+      }
+    | { type: 'trigger'; trigger: Trigger };
+
 export interface ITransmitter {
-    transmit(strands: StrandUpdate[]): Promise<ListenerRevision[]>;
+    transmit(
+        strands: StrandUpdate[],
+        source: StrandUpdateSource
+    ): Promise<ListenerRevision[]>;
     disconnect?(): Promise<void>;
 }
-
 export interface InternalTransmitterService extends ITransmitter {
     getName(): string;
 }

package/src/server/types.ts

@@ -20,7 +20,7 @@ import type {
 } from 'document-model/document';
 import { Unsubscribe } from 'nanoevents';
 import { OperationError } from './error';
-import { ITransmitter } from './listener/transmitter/types';
+import { ITransmitter, StrandUpdateSource } from './listener/transmitter/types';
 
 export type DriveInput = State<
     Omit<DocumentDriveState, '__typename' | 'id' | 'nodes'> & { id?: string },
@@ -59,7 +59,10 @@ export type SynchronizationUnit = {
     revision: number;
 };
 
-export type SynchronizationUnitQuery = Omit<SynchronizationUnit, "revision" | "lastUpdated">;
+export type SynchronizationUnitQuery = Omit<
+    SynchronizationUnit,
+    'revision' | 'lastUpdated'
+>;
 
 export type Listener = {
     driveId: string;
@@ -149,6 +152,11 @@ export type GetDocumentOptions = ReducerOptions & {
     checkHashes?: boolean;
 };
 
+export type AddOperationOptions = {
+    forceSync?: boolean;
+    source: StrandUpdateSource;
+};
+
 export abstract class BaseDocumentDriveServer {
     /** Public methods **/
     abstract getDrives(): Promise<string[]>;
@@ -163,9 +171,7 @@ export abstract class BaseDocumentDriveServer {
         options?: GetDocumentOptions
     ): Promise<DocumentDriveDocument>;
 
-    abstract getDriveBySlug(
-        slug: string,
-    ): Promise<DocumentDriveDocument>;
+    abstract getDriveBySlug(slug: string): Promise<DocumentDriveDocument>;
 
     abstract getDocuments(drive: string): Promise<string[]>;
     abstract getDocument(
@@ -178,100 +184,101 @@ export abstract class BaseDocumentDriveServer {
         drive: string,
         id: string,
         operation: Operation,
-        forceSync?: boolean
+        options?: AddOperationOptions
     ): Promise<IOperationResult>;
 
     abstract addOperations(
         drive: string,
         id: string,
         operations: Operation[],
-        forceSync?: boolean
+        options?: AddOperationOptions
     ): Promise<IOperationResult>;
 
     abstract queueOperation(
         drive: string,
         id: string,
         operation: Operation,
-        forceSync?: boolean
+        options?: AddOperationOptions
     ): Promise<IOperationResult>;
 
     abstract queueOperations(
         drive: string,
         id: string,
         operations: Operation[],
-        forceSync?: boolean
+        options?: AddOperationOptions
     ): Promise<IOperationResult>;
 
     abstract queueAction(
         drive: string,
         id: string,
         action: Action,
-        forceSync?: boolean
+        options?: AddOperationOptions
     ): Promise<IOperationResult>;
 
     abstract queueActions(
         drive: string,
         id: string,
         actions: Action[],
-        forceSync?: boolean
+        options?: AddOperationOptions
     ): Promise<IOperationResult>;
 
     abstract addDriveOperation(
         drive: string,
         operation: Operation<DocumentDriveAction | BaseAction>,
-        forceSync?: boolean
+        options?: AddOperationOptions
     ): Promise<IOperationResult<DocumentDriveDocument>>;
     abstract addDriveOperations(
         drive: string,
         operations: Operation<DocumentDriveAction | BaseAction>[],
-        forceSync?: boolean
+        options?: AddOperationOptions
     ): Promise<IOperationResult<DocumentDriveDocument>>;
 
     abstract queueDriveOperation(
         drive: string,
         operation: Operation<DocumentDriveAction | BaseAction>,
-        forceSync?: boolean
+        options?: AddOperationOptions
     ): Promise<IOperationResult<DocumentDriveDocument>>;
+
     abstract queueDriveOperations(
         drive: string,
         operations: Operation<DocumentDriveAction | BaseAction>[],
-        forceSync?: boolean
+        options?: AddOperationOptions
     ): Promise<IOperationResult<DocumentDriveDocument>>;
 
     abstract queueDriveAction(
         drive: string,
         action: DocumentDriveAction | BaseAction,
-        forceSync?: boolean
+        options?: AddOperationOptions
     ): Promise<IOperationResult<DocumentDriveDocument>>;
 
     abstract queueDriveActions(
         drive: string,
         actions: Array<DocumentDriveAction | BaseAction>,
-        forceSync?: boolean
+        options?: AddOperationOptions
     ): Promise<IOperationResult<DocumentDriveDocument>>;
 
     abstract addAction(
         drive: string,
         id: string,
         action: Action,
-        forceSync?: boolean
+        options?: AddOperationOptions
     ): Promise<IOperationResult>;
     abstract addActions(
         drive: string,
         id: string,
         actions: Action[],
-        forceSync?: boolean
+        options?: AddOperationOptions
     ): Promise<IOperationResult>;
 
     abstract addDriveAction(
         drive: string,
         action: DocumentDriveAction | BaseAction,
-        forceSync?: boolean
+        options?: AddOperationOptions
     ): Promise<IOperationResult<DocumentDriveDocument>>;
     abstract addDriveActions(
         drive: string,
         actions: (DocumentDriveAction | BaseAction)[],
-        forceSync?: boolean
+        options?: AddOperationOptions
     ): Promise<IOperationResult<DocumentDriveDocument>>;
 
     abstract getSyncStatus(drive: string): SyncStatus;
@@ -351,7 +358,7 @@ export abstract class BaseListenerManager {
     }
 
     abstract initDrive(drive: DocumentDriveDocument): Promise<void>;
-    abstract removeDrive(driveId: DocumentDriveState["id"]): Promise<void>;
+    abstract removeDrive(driveId: DocumentDriveState['id']): Promise<void>;
 
     abstract addListener(listener: Listener): Promise<ITransmitter>;
     abstract removeListener(
@@ -376,6 +383,7 @@ export abstract class BaseListenerManager {
     abstract updateSynchronizationRevisions(
         driveId: string,
         syncUnits: SynchronizationUnit[],
+        source: StrandUpdateSource,
         willUpdate?: (listeners: Listener[]) => void,
         onError?: (
             error: Error,