document-drive 1.0.0-websockets → 1.0.0

package/src/server/index.ts

@@ -1,1941 +1,2316 @@
 import {
-    actions,
-    AddListenerInput,
-    DocumentDriveAction,
-    DocumentDriveDocument,
-    DocumentDriveState,
-    FileNode,
-    isFileNode,
-    ListenerFilter,
-    RemoveListenerInput,
-    Trigger,
-    utils
-} from 'document-model-libs/document-drive';
+  actions,
+  AddListenerInput,
+  DocumentDriveAction,
+  DocumentDriveDocument,
+  DocumentDriveState,
+  FileNode,
+  isFileNode,
+  ListenerFilter,
+  RemoveListenerInput,
+  Trigger,
+  utils,
+} from "document-model-libs/document-drive";
 import {
-    Action,
-    BaseAction,
-    utils as baseUtils,
-    Document,
-    DocumentHeader,
-    DocumentModel,
-    utils as DocumentUtils,
-    Operation,
-    OperationScope
-} from 'document-model/document';
-import { createNanoEvents, Unsubscribe } from 'nanoevents';
-import { ICache } from '../cache';
-import InMemoryCache from '../cache/memory';
-import { BaseQueueManager } from '../queue/base';
+  Action,
+  BaseAction,
+  utils as baseUtils,
+  Document,
+  DocumentHeader,
+  DocumentModel,
+  utils as DocumentUtils,
+  Operation,
+  OperationScope,
+} from "document-model/document";
+import { ClientError } from "graphql-request";
+import { createNanoEvents, Unsubscribe } from "nanoevents";
+import { ICache } from "../cache";
+import InMemoryCache from "../cache/memory";
+import { BaseQueueManager } from "../queue/base";
 import {
-    ActionJob,
-    IQueueManager,
-    isActionJob,
-    isOperationJob,
-    Job,
-    OperationJob
-} from '../queue/types';
-import { MemoryStorage } from '../storage/memory';
+  ActionJob,
+  IQueueManager,
+  isActionJob,
+  isOperationJob,
+  Job,
+  OperationJob,
+} from "../queue/types";
+import { ReadModeServer } from "../read-mode";
+import { MemoryStorage } from "../storage/memory";
 import type {
-    DocumentDriveStorage,
-    DocumentStorage,
-    IDriveStorage
-} from '../storage/types';
-import { generateUUID, isBefore, isDocumentDrive } from '../utils';
+  DocumentDriveStorage,
+  DocumentStorage,
+  IDriveStorage,
+} from "../storage/types";
 import {
-    attachBranch,
-    garbageCollect,
-    groupOperationsByScope,
-    merge,
-    precedes,
-    removeExistingOperations,
-    reshuffleByTimestamp,
-    sortOperations
-} from '../utils/document-helpers';
-import { requestPublicDrive } from '../utils/graphql';
-import { logger } from '../utils/logger';
-import { ConflictOperationError, OperationError } from './error';
-import { ListenerManager } from './listener/manager';
+  generateUUID,
+  isBefore,
+  isDocumentDrive,
+  RunAsap,
+  runAsapAsync,
+} from "../utils";
+import { DefaultDrivesManager } from "../utils/default-drives-manager";
 import {
-    CancelPullLoop,
-    InternalTransmitter,
-    IReceiver,
-    ITransmitter,
-    PullResponderTransmitter,
-    SubscriptionTransmitter
-} from './listener/transmitter';
+  attachBranch,
+  garbageCollect,
+  groupOperationsByScope,
+  merge,
+  precedes,
+  removeExistingOperations,
+  reshuffleByTimestamp,
+  sortOperations,
+} from "../utils/document-helpers";
+import { requestPublicDrive } from "../utils/graphql";
+import { logger } from "../utils/logger";
 import {
-    BaseDocumentDriveServer,
-    DriveEvents,
-    GetDocumentOptions,
-    IOperationResult,
-    ListenerState,
-    RemoteDriveOptions,
-    StrandUpdate,
-    SynchronizationUnitQuery,
-    SyncStatus,
-    type CreateDocumentInput,
-    type DriveInput,
-    type OperationUpdate,
-    type SignalResult,
-    type SynchronizationUnit
-} from './types';
-import { filterOperationsByRevision } from './utils';
-
-export * from './listener';
-export type * from './types';
+  ConflictOperationError,
+  DriveAlreadyExistsError,
+  OperationError,
+  SynchronizationUnitNotFoundError,
+} from "./error";
+import { ListenerManager } from "./listener/manager";
+import {
+  CancelPullLoop,
+  InternalTransmitter,
+  IReceiver,
+  ITransmitter,
+  PullResponderTransmitter,
+  StrandUpdateSource,
+} from "./listener/transmitter";
+import {
+  AbstractDocumentDriveServer,
+  AddOperationOptions,
+  DefaultListenerManagerOptions,
+  DocumentDriveServerOptions,
+  DriveEvents,
+  GetDocumentOptions,
+  GetStrandsOptions,
+  IBaseDocumentDriveServer,
+  IOperationResult,
+  ListenerState,
+  RemoteDriveAccessLevel,
+  RemoteDriveOptions,
+  StrandUpdate,
+  SynchronizationUnitQuery,
+  SyncStatus,
+  SyncUnitStatusObject,
+  type CreateDocumentInput,
+  type DriveInput,
+  type OperationUpdate,
+  type SignalResult,
+  type SynchronizationUnit,
+} from "./types";
+import { filterOperationsByRevision } from "./utils";
+
+export * from "./listener";
+export type * from "./types";
+
+export * from "../read-mode";
 
 export const PULL_DRIVE_INTERVAL = 5000;
 
-export class DocumentDriveServer extends BaseDocumentDriveServer {
-    private emitter = createNanoEvents<DriveEvents>();
-    private cache: ICache;
-    private documentModels: DocumentModel[];
-    private storage: IDriveStorage;
-    private listenerStateManager: ListenerManager;
-    private triggerMap = new Map<
-        DocumentDriveState['id'],
-        Map<Trigger['id'], CancelPullLoop>
-    >();
-    private syncStatus = new Map<string, SyncStatus>();
-
-    private queueManager: IQueueManager;
-
-    constructor(
-        documentModels: DocumentModel[],
-        storage: IDriveStorage = new MemoryStorage(),
-        cache: ICache = new InMemoryCache(),
-        queueManager: IQueueManager = new BaseQueueManager()
-    ) {
-        super();
-        this.listenerStateManager = new ListenerManager(this);
-        this.documentModels = documentModels;
-        this.storage = storage;
-        this.cache = cache;
-        this.queueManager = queueManager;
-
-        this.storage.setStorageDelegate?.({
-            getCachedOperations: async (drive, id) => {
-                try {
-                    const document = await this.cache.getDocument(drive, id);
-                    return document?.operations;
-                } catch (error) {
-                    logger.error(error);
-                    return undefined;
-                }
-            }
-        });
-    }
+export class BaseDocumentDriveServer
+  extends AbstractDocumentDriveServer
+  implements IBaseDocumentDriveServer
+{
+  private emitter = createNanoEvents<DriveEvents>();
+  private cache: ICache;
+  private documentModels: DocumentModel[];
+  private storage: IDriveStorage;
+  private listenerStateManager: ListenerManager;
+  private triggerMap = new Map<
+    DocumentDriveState["id"],
+    Map<Trigger["id"], CancelPullLoop>
+  >();
+  private syncStatus = new Map<string, SyncUnitStatusObject>();
+
+  private queueManager: IQueueManager;
+  private initializePromise: Promise<Error[] | null>;
+
+  private defaultDrivesManager: DefaultDrivesManager;
+
+  protected options: Required<DocumentDriveServerOptions>;
+
+  constructor(
+    documentModels: DocumentModel[],
+    storage: IDriveStorage = new MemoryStorage(),
+    cache: ICache = new InMemoryCache(),
+    queueManager: IQueueManager = new BaseQueueManager(),
+    options?: DocumentDriveServerOptions,
+  ) {
+    super();
+    this.options = {
+      ...options,
+      defaultDrives: {
+        ...options?.defaultDrives,
+      },
+      listenerManager: {
+        ...DefaultListenerManagerOptions,
+        ...options?.listenerManager,
+      },
+      taskQueueMethod:
+        options?.taskQueueMethod === undefined
+          ? RunAsap.runAsap
+          : options.taskQueueMethod,
+    };
 
-    private updateSyncStatus(
-        driveId: string,
-        status: SyncStatus | null,
-        error?: Error
-    ) {
-        if (status === null) {
-            this.syncStatus.delete(driveId);
-        } else if (this.syncStatus.get(driveId) !== status) {
-            this.syncStatus.set(driveId, status);
-            this.emit('syncStatus', driveId, status, error);
+    this.listenerStateManager = new ListenerManager(
+      this,
+      undefined,
+      options?.listenerManager,
+    );
+    this.documentModels = documentModels;
+    this.storage = storage;
+    this.cache = cache;
+    this.queueManager = queueManager;
+    this.defaultDrivesManager = new DefaultDrivesManager(
+      this,
+      this.defaultDrivesManagerDelegate,
+      options,
+    );
+
+    this.storage.setStorageDelegate?.({
+      getCachedOperations: async (drive, id) => {
+        try {
+          const document = await this.cache.getDocument(drive, id);
+          return document?.operations;
+        } catch (error) {
+          logger.error(error);
+          return undefined;
         }
-    }
+      },
+    });
+
+    this.initializePromise = this._initialize();
+  }
+
+  setDocumentModels(models: DocumentModel[]): void {
+    this.documentModels = [...models];
+    this.emit("documentModels", [...models]);
+  }
+
+  initializeDefaultRemoteDrives() {
+    return this.defaultDrivesManager.initializeDefaultRemoteDrives();
+  }
+
+  getDefaultRemoteDrives() {
+    return this.defaultDrivesManager.getDefaultRemoteDrives();
+  }
+
+  setDefaultDriveAccessLevel(url: string, level: RemoteDriveAccessLevel) {
+    return this.defaultDrivesManager.setDefaultDriveAccessLevel(url, level);
+  }
+
+  setAllDefaultDrivesAccessLevel(level: RemoteDriveAccessLevel) {
+    return this.defaultDrivesManager.setAllDefaultDrivesAccessLevel(level);
+  }
+
+  private getOperationSource(source: StrandUpdateSource) {
+    return source.type === "local" ? "push" : "pull";
+  }
+
+  private getCombinedSyncUnitStatus(
+    syncUnitStatus: SyncUnitStatusObject,
+  ): SyncStatus {
+    if (!syncUnitStatus.pull && !syncUnitStatus.push) return "INITIAL_SYNC";
+    if (syncUnitStatus.pull === "INITIAL_SYNC") return "INITIAL_SYNC";
+    if (syncUnitStatus.push === "INITIAL_SYNC")
+      return syncUnitStatus.pull || "INITIAL_SYNC";
+
+    const order: Array<SyncStatus> = [
+      "ERROR",
+      "MISSING",
+      "CONFLICT",
+      "SYNCING",
+      "SUCCESS",
+    ];
+    const sortedStatus = Object.values(syncUnitStatus).sort(
+      (a, b) => order.indexOf(a) - order.indexOf(b),
+    );
+
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    return sortedStatus[0]!;
+  }
+
+  private initSyncStatus(
+    syncUnitId: string,
+    status: Partial<SyncUnitStatusObject>,
+  ) {
+    const defaultSyncUnitStatus: SyncUnitStatusObject = Object.entries(
+      status,
+    ).reduce((acc, [key, _status]) => {
+      return {
+        ...acc,
+        [key]: _status !== "SYNCING" ? _status : "INITIAL_SYNC",
+      };
+    }, {});
+
+    this.syncStatus.set(syncUnitId, defaultSyncUnitStatus);
+    this.emit(
+      "syncStatus",
+      syncUnitId,
+      this.getCombinedSyncUnitStatus(defaultSyncUnitStatus),
+      undefined,
+      defaultSyncUnitStatus,
+    );
+  }
+
+  private async initializeDriveSyncStatus(
+    driveId: string,
+    drive: DocumentDriveDocument,
+  ) {
+    const syncUnits = await this.getSynchronizationUnitsIds(driveId);
+    const syncStatus: SyncUnitStatusObject = {
+      pull: drive.state.local.triggers.length > 0 ? "INITIAL_SYNC" : undefined,
+      push: drive.state.local.listeners.length > 0 ? "SUCCESS" : undefined,
+    };
 
-    private async saveStrand(strand: StrandUpdate) {
-        const operations: Operation[] = strand.operations.map(op => ({
-            ...op,
-            scope: strand.scope,
-            branch: strand.branch
-        }));
+    if (!syncStatus.pull && !syncStatus.push) return;
 
-        const result = await (!strand.documentId
-            ? this.queueDriveOperations(
-                  strand.driveId,
-                  operations as Operation<DocumentDriveAction | BaseAction>[],
-                  false
-              )
-            : this.queueOperations(
-                  strand.driveId,
-                  strand.documentId,
-                  operations,
-                  false
-              ));
-
-        if (result.status === 'ERROR') {
-            this.updateSyncStatus(strand.driveId, result.status, result.error);
-        } else {
-            this.emit('strandUpdate', strand);
-        }
-        return result;
-    }
+    const syncUnitsIds = [driveId, ...syncUnits.map((s) => s.syncId)];
 
-    private handleListenerError(
-        error: Error,
-        driveId: string,
-        listener: ListenerState
-    ) {
-        logger.error(
-            `Listener ${listener.listener.label ?? listener.listener.listenerId} error:`,
-            error
-        );
-        this.updateSyncStatus(
-            driveId,
-            error instanceof OperationError ? error.status : 'ERROR',
-            error
-        );
+    for (const syncUnitId of syncUnitsIds) {
+      this.initSyncStatus(syncUnitId, syncStatus);
     }
-
-    private shouldSyncRemoteDrive(drive: DocumentDriveDocument) {
-        return (
-            drive.state.local.availableOffline &&
-            drive.state.local.triggers.length > 0
-        );
+  }
+
+  private updateSyncUnitStatus(
+    syncUnitId: string,
+    status: Partial<SyncUnitStatusObject> | null,
+    error?: Error,
+  ) {
+    if (status === null) {
+      this.syncStatus.delete(syncUnitId);
+      return;
     }
 
-    private async startSyncRemoteDrive(driveId: string) {
-        const drive = await this.getDrive(driveId);
-        let driveTriggers = this.triggerMap.get(driveId);
+    const syncUnitStatus = this.syncStatus.get(syncUnitId);
 
-        const syncUnits = await this.getSynchronizationUnitsIds(driveId);
-
-        for (const trigger of drive.state.local.triggers) {
-            if (driveTriggers?.get(trigger.id)) {
-                continue;
-            }
+    if (!syncUnitStatus) {
+      this.initSyncStatus(syncUnitId, status);
+      return;
+    }
 
-            if (!driveTriggers) {
-                driveTriggers = new Map();
-            }
+    const shouldUpdateStatus = Object.entries(status).some(
+      ([key, _status]) =>
+        syncUnitStatus[key as keyof SyncUnitStatusObject] !== _status,
+    );
 
-            this.updateSyncStatus(driveId, 'SYNCING');
+    if (shouldUpdateStatus) {
+      const newstatus = Object.entries(status).reduce((acc, [key, _status]) => {
+        return {
+          ...acc,
+          // do not replace initial_syncing if it has not finished yet
+          [key]:
+            acc[key as keyof SyncUnitStatusObject] === "INITIAL_SYNC" &&
+            _status === "SYNCING"
+              ? "INITIAL_SYNC"
+              : _status,
+        };
+      }, syncUnitStatus);
 
-            for (const syncUnit of syncUnits) {
-                this.updateSyncStatus(syncUnit.syncId, 'SYNCING');
-            }
+      const previousCombinedStatus =
+        this.getCombinedSyncUnitStatus(syncUnitStatus);
+      const newCombinedStatus = this.getCombinedSyncUnitStatus(newstatus);
 
-            let cancelTrigger: (() => void) | undefined = undefined;
-            if (PullResponderTransmitter.isPullResponderTrigger(trigger)) {
-                cancelTrigger = PullResponderTransmitter.setupPull(
-                    driveId,
-                    trigger,
-                    this.saveStrand.bind(this),
-                    error => {
-                        this.updateSyncStatus(
-                            driveId,
-                            error instanceof OperationError
-                                ? error.status
-                                : 'ERROR',
-                            error
-                        );
-                    },
-                    revisions => {
-                        const errorRevision = revisions.filter(
-                            r => r.status !== 'SUCCESS'
-                        );
-                        if (errorRevision.length < 1) {
-                            this.updateSyncStatus(driveId, 'SUCCESS');
-                        }
-
-                        for (const syncUnit of syncUnits) {
-                            const fileErrorRevision = errorRevision.find(
-                                r => r.documentId === syncUnit.documentId
-                            );
-
-                            if (fileErrorRevision) {
-                                this.updateSyncStatus(
-                                    syncUnit.syncId,
-                                    fileErrorRevision.status,
-                                    fileErrorRevision.error
-                                );
-                            } else {
-                                this.updateSyncStatus(
-                                    syncUnit.syncId,
-                                    'SUCCESS'
-                                );
-                            }
-                        }
-                    }
-                );
-            } else if (SubscriptionTransmitter.isTrigger(trigger)) {
-                cancelTrigger = SubscriptionTransmitter.setup(
-                    driveId,
-                    trigger,
-                    this.saveStrand.bind(this),
-                    error => {
-                        this.updateSyncStatus(
-                            driveId,
-                            error instanceof OperationError
-                                ? error.status
-                                : 'ERROR',
-                            error
-                        );
-                    },
-                    revisions => {
-                        const errorRevision = revisions.find(
-                            r => r.status !== 'SUCCESS'
-                        );
-                        if (!errorRevision) {
-                            this.updateSyncStatus(driveId, 'SUCCESS');
-                        }
-                    }
-                );
-            }
+      this.syncStatus.set(syncUnitId, newstatus);
 
-            if (cancelTrigger) {
-                driveTriggers.set(trigger.id, cancelTrigger);
-                this.triggerMap.set(driveId, driveTriggers);
-            }
-        }
+      if (previousCombinedStatus !== newCombinedStatus) {
+        this.emit(
+          "syncStatus",
+          syncUnitId,
+          this.getCombinedSyncUnitStatus(newstatus),
+          error,
+          newstatus,
+        );
+      }
     }
+  }
+
+  private async saveStrand(strand: StrandUpdate, source: StrandUpdateSource) {
+    const operations: Operation[] = strand.operations.map((op) => ({
+      ...op,
+      scope: strand.scope,
+      branch: strand.branch,
+    }));
+
+    const result = await (!strand.documentId
+      ? this.queueDriveOperations(
+          strand.driveId,
+          operations as Operation<DocumentDriveAction | BaseAction>[],
+          { source },
+        )
+      : this.queueOperations(strand.driveId, strand.documentId, operations, {
+          source,
+        }));
 
-    private async stopSyncRemoteDrive(driveId: string) {
-        const syncUnits = await this.getSynchronizationUnitsIds(driveId);
-        const fileNodes = syncUnits
-            .filter(syncUnit => syncUnit.documentId !== '')
-            .map(syncUnit => syncUnit.documentId);
+    if (result.status === "ERROR") {
+      const syncUnits =
+        strand.documentId !== ""
+          ? (
+              await this.getSynchronizationUnitsIds(
+                strand.driveId,
+                [strand.documentId],
+                [strand.scope],
+                [strand.branch],
+              )
+            ).map((s) => s.syncId)
+          : [strand.driveId];
 
-        const triggers = this.triggerMap.get(driveId);
-        triggers?.forEach(cancel => cancel());
-        this.updateSyncStatus(driveId, null);
+      const operationSource = this.getOperationSource(source);
 
-        for (const fileNode of fileNodes) {
-            this.updateSyncStatus(fileNode, null);
-        }
-        return this.triggerMap.delete(driveId);
+      for (const syncUnit of syncUnits) {
+        this.updateSyncUnitStatus(
+          syncUnit,
+          { [operationSource]: result.status },
+          result.error,
+        );
+      }
     }
+    this.emit("strandUpdate", strand);
+    return result;
+  }
+
+  private handleListenerError(
+    error: Error,
+    driveId: string,
+    listener: ListenerState,
+  ) {
+    logger.error(
+      `Listener ${listener.listener.label ?? listener.listener.listenerId} error:`,
+      error,
+    );
+
+    const status = error instanceof OperationError ? error.status : "ERROR";
+
+    this.updateSyncUnitStatus(driveId, { push: status }, error);
+  }
+
+  private shouldSyncRemoteDrive(drive: DocumentDriveDocument) {
+    return (
+      drive.state.local.availableOffline &&
+      drive.state.local.triggers.length > 0
+    );
+  }
+
+  private async startSyncRemoteDrive(driveId: string) {
+    const drive = await this.getDrive(driveId);
+    let driveTriggers = this.triggerMap.get(driveId);
+
+    const syncUnits = await this.getSynchronizationUnitsIds(
+      driveId,
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      drive,
+    );
+
+    for (const trigger of drive.state.local.triggers) {
+      if (driveTriggers?.get(trigger.id)) {
+        continue;
+      }
+
+      if (!driveTriggers) {
+        driveTriggers = new Map();
+      }
+
+      this.updateSyncUnitStatus(driveId, { pull: "SYNCING" });
+
+      for (const syncUnit of syncUnits) {
+        this.updateSyncUnitStatus(syncUnit.syncId, { pull: "SYNCING" });
+      }
+
+      if (PullResponderTransmitter.isPullResponderTrigger(trigger)) {
+        let firstPull = true;
+        const cancelPullLoop = PullResponderTransmitter.setupPull(
+          driveId,
+          trigger,
+          this.saveStrand.bind(this),
+          (error) => {
+            const statusError =
+              error instanceof OperationError ? error.status : "ERROR";
+
+            this.updateSyncUnitStatus(driveId, { pull: statusError }, error);
+
+            if (error instanceof ClientError) {
+              this.emit(
+                "clientStrandsError",
+                driveId,
+                trigger,
+                error.response.status,
+                error.message,
+              );
+            }
+          },
+          (revisions) => {
+            const errorRevision = revisions.filter(
+              (r) => r.status !== "SUCCESS",
+            );
 
-    private queueDelegate = {
-        checkDocumentExists: (
-            driveId: string,
-            documentId: string
-        ): Promise<boolean> =>
-            this.storage.checkDocumentExists(driveId, documentId),
-        processOperationJob: async ({
-            driveId,
-            documentId,
-            operations,
-            forceSync
-        }: OperationJob) => {
-            return documentId
-                ? this.addOperations(driveId, documentId, operations, forceSync)
-                : this.addDriveOperations(
-                      driveId,
-                      operations as Operation<
-                          DocumentDriveAction | BaseAction
-                      >[],
-                      forceSync
-                  );
-        },
-        processActionJob: async ({
-            driveId,
-            documentId,
-            actions,
-            forceSync
-        }: ActionJob) => {
-            return documentId
-                ? this.addActions(driveId, documentId, actions, forceSync)
-                : this.addDriveActions(
-                      driveId,
-                      actions as Operation<DocumentDriveAction | BaseAction>[],
-                      forceSync
-                  );
-        },
-        processJob: async (job: Job) => {
-            if (isOperationJob(job)) {
-                return this.queueDelegate.processOperationJob(job);
-            } else if (isActionJob(job)) {
-                return this.queueDelegate.processActionJob(job);
-            } else {
-                throw new Error('Unknown job type', job);
+            if (errorRevision.length < 1) {
+              this.updateSyncUnitStatus(driveId, {
+                pull: "SUCCESS",
+              });
             }
-        }
-    };
 
-    async initialize() {
-        const errors: Error[] = [];
-        const drives = await this.getDrives();
-        for (const drive of drives) {
-            await this._initializeDrive(drive).catch(error => {
-                logger.error(`Error initializing drive ${drive}`, error);
-                errors.push(error as Error);
-            });
-        }
+            const documentIdsFromRevision = revisions
+              .filter((rev) => rev.documentId !== "")
+              .map((rev) => rev.documentId);
 
-        await this.queueManager.init(this.queueDelegate, error => {
-            logger.error(`Error initializing queue manager`, error);
-            errors.push(error);
-        });
+            this.getSynchronizationUnitsIds(driveId, documentIdsFromRevision)
+              .then((revSyncUnits) => {
+                for (const syncUnit of revSyncUnits) {
+                  const fileErrorRevision = errorRevision.find(
+                    (r) => r.documentId === syncUnit.documentId,
+                  );
 
-        // if network connect comes online then
-        // triggers the listeners update
-        if (typeof window !== 'undefined') {
-            window.addEventListener('online', () => {
-                this.listenerStateManager
-                    .triggerUpdate(false, this.handleListenerError.bind(this))
-                    .catch(error => {
-                        logger.error(
-                            'Non handled error updating listeners',
-                            error
-                        );
+                  if (fileErrorRevision) {
+                    this.updateSyncUnitStatus(
+                      syncUnit.syncId,
+                      { pull: fileErrorRevision.status },
+                      fileErrorRevision.error,
+                    );
+                  } else {
+                    this.updateSyncUnitStatus(syncUnit.syncId, {
+                      pull: "SUCCESS",
                     });
-            });
-        }
-
-        return errors.length === 0 ? null : errors;
-    }
-
-    private async _initializeDrive(driveId: string) {
-        const drive = await this.getDrive(driveId);
-
-        if (this.shouldSyncRemoteDrive(drive)) {
-            await this.startSyncRemoteDrive(driveId);
-        }
-
-        await this.listenerStateManager.initDrive(drive);
-    }
-
-    public async getSynchronizationUnits(
-        driveId: string,
-        documentId?: string[],
-        scope?: string[],
-        branch?: string[],
-        documentType?: string[]
-    ) {
-        const drive = await this.getDrive(driveId);
-
-        const synchronizationUnitsQuery = await this.getSynchronizationUnitsIds(
-            driveId,
-            documentId,
-            scope,
-            branch,
-            documentType,
-            drive
-        );
-        const revisions = await this.storage.getSynchronizationUnitsRevision(
-            synchronizationUnitsQuery
-        );
-
-        const synchronizationUnits: SynchronizationUnit[] =
-            synchronizationUnitsQuery.map(s => ({
-                ...s,
-                lastUpdated: drive.created,
-                revision: -1
-            }));
-        for (const revision of revisions) {
-            const syncUnit = synchronizationUnits.find(
-                s =>
-                    revision.driveId === s.driveId &&
-                    revision.documentId === s.documentId &&
-                    revision.scope === s.scope &&
-                    revision.branch === s.branch
-            );
-            if (syncUnit) {
-                syncUnit.revision = revision.revision;
-                syncUnit.lastUpdated = revision.lastUpdated;
-            }
-        }
-        return synchronizationUnits;
-    }
-
-    public async getSynchronizationUnitsIds(
-        driveId: string,
-        documentId?: string[],
-        scope?: string[],
-        branch?: string[],
-        documentType?: string[],
-        loadedDrive?: DocumentDriveDocument
-    ): Promise<SynchronizationUnitQuery[]> {
-        const drive = loadedDrive ?? (await this.getDrive(driveId));
-        const nodes = drive.state.global.nodes.filter(
-            node =>
-                isFileNode(node) &&
-                (!documentId?.length ||
-                    documentId.includes(node.id) ||
-                    documentId.includes('*')) &&
-                (!documentType?.length ||
-                    documentType.includes(node.documentType) ||
-                    documentType.includes('*'))
-        ) as Pick<FileNode, 'id' | 'documentType' | 'synchronizationUnits'>[];
-
-        // checks if document drive synchronization unit should be added
-        if (
-            (!documentId ||
-                documentId.includes('*') ||
-                documentId.includes('')) &&
-            (!documentType?.length ||
-                documentType.includes('powerhouse/document-drive') ||
-                documentType.includes('*'))
-        ) {
-            nodes.unshift({
-                id: '',
-                documentType: 'powerhouse/document-drive',
-                synchronizationUnits: [
-                    {
-                        syncId: '0',
-                        scope: 'global',
-                        branch: 'main'
+                  }
+                }
+              })
+              .catch(console.error);
+
+            // if it is the first pull and returns empty
+            // then updates corresponding push transmitter
+            if (firstPull) {
+              firstPull = false;
+              const pushListener = drive.state.local.listeners.find(
+                (listener) => trigger.data.url === listener.callInfo?.data,
+              );
+              if (pushListener) {
+                this.getSynchronizationUnitsRevision(driveId, syncUnits)
+                  .then((syncUnitRevisions) => {
+                    for (const revision of syncUnitRevisions) {
+                      this.listenerStateManager
+                        .updateListenerRevision(
+                          pushListener.listenerId,
+                          driveId,
+                          revision.syncId,
+                          revision.revision,
+                        )
+                        .catch(logger.error);
                     }
-                ]
-            });
-        }
-
-        const synchronizationUnitsQuery: Omit<
-            SynchronizationUnit,
-            'revision' | 'lastUpdated'
-        >[] = [];
-        for (const node of nodes) {
-            const nodeUnits =
-                scope?.length || branch?.length
-                    ? node.synchronizationUnits.filter(
-                          unit =>
-                              (!scope?.length ||
-                                  scope.includes(unit.scope) ||
-                                  scope.includes('*')) &&
-                              (!branch?.length ||
-                                  branch.includes(unit.branch) ||
-                                  branch.includes('*'))
-                      )
-                    : node.synchronizationUnits;
-            if (!nodeUnits.length) {
-                continue;
+                  })
+                  .catch(logger.error);
+              }
             }
-            synchronizationUnitsQuery.push(
-                ...nodeUnits.map(n => ({
-                    driveId,
-                    documentId: node.id,
-                    syncId: n.syncId,
-                    documentType: node.documentType,
-                    scope: n.scope,
-                    branch: n.branch
-                }))
-            );
-        }
-        return synchronizationUnitsQuery;
-    }
-
-    public async getSynchronizationUnitIdInfo(
-        driveId: string,
-        syncId: string
-    ): Promise<SynchronizationUnitQuery | undefined> {
-        const drive = await this.getDrive(driveId);
-        const node = drive.state.global.nodes.find(
-            node =>
-                isFileNode(node) &&
-                node.synchronizationUnits.find(unit => unit.syncId === syncId)
+          },
         );
+        driveTriggers.set(trigger.id, cancelPullLoop);
+        this.triggerMap.set(driveId, driveTriggers);
+      }
+    }
+  }
 
-        if (!node || !isFileNode(node)) {
-            return undefined;
-        }
+  private async stopSyncRemoteDrive(driveId: string) {
+    const syncUnits = await this.getSynchronizationUnitsIds(driveId);
+    const filesNodeSyncId = syncUnits
+      .filter((syncUnit) => syncUnit.documentId !== "")
+      .map((syncUnit) => syncUnit.syncId);
 
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        const syncUnit = node.synchronizationUnits.find(
-            unit => unit.syncId === syncId
-        );
-        if (!syncUnit) {
-            return undefined;
-        }
+    const triggers = this.triggerMap.get(driveId);
+    triggers?.forEach((cancel) => cancel());
+    this.updateSyncUnitStatus(driveId, null);
 
-        return {
-            syncId,
-            scope: syncUnit.scope,
-            branch: syncUnit.branch,
-            driveId,
-            documentId: node.id,
-            documentType: node.documentType
-        };
+    for (const fileNodeSyncId of filesNodeSyncId) {
+      this.updateSyncUnitStatus(fileNodeSyncId, null);
     }
-
-    public async getSynchronizationUnit(
-        driveId: string,
-        syncId: string
-    ): Promise<SynchronizationUnit | undefined> {
-        const syncUnit = await this.getSynchronizationUnitIdInfo(
+    return this.triggerMap.delete(driveId);
+  }
+
+  private defaultDrivesManagerDelegate = {
+    detachDrive: this.detachDrive.bind(this),
+    emit: (...args: Parameters<DriveEvents["defaultRemoteDrive"]>) =>
+      this.emit("defaultRemoteDrive", ...args),
+  };
+
+  private queueDelegate = {
+    checkDocumentExists: (
+      driveId: string,
+      documentId: string,
+    ): Promise<boolean> =>
+      this.storage.checkDocumentExists(driveId, documentId),
+    processOperationJob: async ({
+      driveId,
+      documentId,
+      operations,
+      options,
+    }: OperationJob) => {
+      return documentId
+        ? this.addOperations(driveId, documentId, operations, options)
+        : this.addDriveOperations(
             driveId,
-            syncId
-        );
-
-        if (!syncUnit) {
-            return undefined;
-        }
-
-        const { scope, branch, documentId, documentType } = syncUnit;
-
-        // TODO: REPLACE WITH GET DOCUMENT OPERATIONS
-        const document = await this.getDocument(driveId, documentId);
-        const operations = document.operations[scope as OperationScope] ?? [];
-        const lastOperation = operations[operations.length - 1];
-
-        return {
-            syncId,
-            scope,
-            branch,
+            operations as Operation<DocumentDriveAction | BaseAction>[],
+            options,
+          );
+    },
+    processActionJob: async ({
+      driveId,
+      documentId,
+      actions,
+      options,
+    }: ActionJob) => {
+      return documentId
+        ? this.addActions(driveId, documentId, actions, options)
+        : this.addDriveActions(
             driveId,
-            documentId,
-            documentType,
-            lastUpdated: lastOperation?.timestamp ?? document.lastModified,
-            revision: lastOperation?.index ?? 0
-        };
+            actions as Operation<DocumentDriveAction | BaseAction>[],
+            options,
+          );
+    },
+    processJob: async (job: Job) => {
+      if (isOperationJob(job)) {
+        return this.queueDelegate.processOperationJob(job);
+      } else if (isActionJob(job)) {
+        return this.queueDelegate.processActionJob(job);
+      } else {
+        throw new Error("Unknown job type", job);
+      }
+    },
+  };
+
+  initialize() {
+    return this.initializePromise;
+  }
+
+  private async _initialize() {
+    await this.queueManager.init(this.queueDelegate, (error) => {
+      logger.error(`Error initializing queue manager`, error);
+      errors.push(error);
+    });
+
+    try {
+      await this.defaultDrivesManager.removeOldremoteDrives();
+    } catch (error) {
+      logger.error(error);
     }
 
-    async getOperationData(
-        driveId: string,
-        syncId: string,
-        filter: {
-            since?: string | undefined;
-            fromRevision?: number | undefined;
-        }
-    ): Promise<OperationUpdate[]> {
-        const syncUnit =
-            syncId === '0'
-                ? { documentId: '', scope: 'global' }
-                : await this.getSynchronizationUnitIdInfo(driveId, syncId);
-
-        if (!syncUnit) {
-            throw new Error(`Invalid Sync Id ${syncId} in drive ${driveId}`);
-        }
-
-        const document =
-            syncId === '0'
-                ? await this.getDrive(driveId)
-                : await this.getDocument(driveId, syncUnit.documentId); // TODO replace with getDocumentOperations
-
-        const operations =
-            document.operations[syncUnit.scope as OperationScope] ?? []; // TODO filter by branch also
-        const filteredOperations = operations.filter(
-            operation =>
-                Object.keys(filter).length === 0 ||
-                ((filter.since === undefined ||
-                    isBefore(filter.since, operation.timestamp)) &&
-                    (filter.fromRevision === undefined ||
-                        operation.index > filter.fromRevision))
-        );
-
-        return filteredOperations.map(operation => ({
-            hash: operation.hash,
-            index: operation.index,
-            timestamp: operation.timestamp,
-            type: operation.type,
-            input: operation.input as object,
-            skip: operation.skip,
-            context: operation.context,
-            id: operation.id
-        }));
+    const errors: Error[] = [];
+    const drives = await this.getDrives();
+    for (const drive of drives) {
+      await this._initializeDrive(drive).catch((error) => {
+        logger.error(`Error initializing drive ${drive}`, error);
+        errors.push(error as Error);
+      });
     }
 
-    private _getDocumentModel(documentType: string) {
-        const documentModel = this.documentModels.find(
-            model => model.documentModel.id === documentType
-        );
-        if (!documentModel) {
-            throw new Error(`Document type ${documentType} not supported`);
-        }
-        return documentModel;
+    if (this.options.defaultDrives.loadOnInit !== false) {
+      await this.defaultDrivesManager.initializeDefaultRemoteDrives();
     }
 
-    async addDrive(drive: DriveInput): Promise<DocumentDriveDocument> {
-        const id = drive.global.id || generateUUID();
-        if (!id) {
-            throw new Error('Invalid Drive Id');
-        }
-
-        const drives = await this.storage.getDrives();
-        if (drives.includes(id)) {
-            throw new Error('Drive already exists');
-        }
-
-        const document = utils.createDocument({
-            state: drive
-        });
-
-        await this.storage.createDrive(id, document);
+    // if network connect comes back online
+    // then triggers the listeners update
+    if (typeof window !== "undefined") {
+      window.addEventListener("online", () => {
+        this.listenerStateManager
+          .triggerUpdate(
+            false,
+            { type: "local" },
+            this.handleListenerError.bind(this),
+          )
+          .catch((error) => {
+            logger.error("Non handled error updating listeners", error);
+          });
+      });
+    }
 
-        if (drive.global.slug) {
-            await this.cache.deleteDocument('drives-slug', drive.global.slug);
-        }
+    return errors.length === 0 ? null : errors;
+  }
 
-        await this._initializeDrive(id);
+  private async _initializeDrive(driveId: string) {
+    const drive = await this.getDrive(driveId);
+    await this.initializeDriveSyncStatus(driveId, drive);
 
-        return document;
+    if (this.shouldSyncRemoteDrive(drive)) {
+      await this.startSyncRemoteDrive(driveId);
     }
 
-    async addRemoteDrive(
-        url: string,
-        options: RemoteDriveOptions
-    ): Promise<DocumentDriveDocument> {
-        const { id, name, slug, icon } = await requestPublicDrive(url);
-        const {
-            pullFilter,
-            pullInterval,
-            availableOffline,
-            sharingType,
-            listeners,
-            triggers
-        } = options;
-
-        const trigger = await SubscriptionTransmitter.createTrigger(id, url, {
-            pullFilter
-        });
-
-        return await this.addDrive({
-            global: {
-                id: id,
-                name,
-                slug,
-                icon: icon ?? null
-            },
-            local: {
-                triggers: [...triggers, trigger],
-                listeners: listeners,
-                availableOffline,
-                sharingType
-            }
-        });
+    await this.listenerStateManager.initDrive(drive);
+  }
+
+  public async getSynchronizationUnits(
+    driveId: string,
+    documentId?: string[],
+    scope?: string[],
+    branch?: string[],
+    documentType?: string[],
+    loadedDrive?: DocumentDriveDocument,
+  ) {
+    const drive = loadedDrive || (await this.getDrive(driveId));
+
+    const synchronizationUnitsQuery = await this.getSynchronizationUnitsIds(
+      driveId,
+      documentId,
+      scope,
+      branch,
+      documentType,
+      drive,
+    );
+    return this.getSynchronizationUnitsRevision(
+      driveId,
+      synchronizationUnitsQuery,
+      drive,
+    );
+  }
+
+  public async getSynchronizationUnitsRevision(
+    driveId: string,
+    syncUnitsQuery: SynchronizationUnitQuery[],
+    loadedDrive?: DocumentDriveDocument,
+  ): Promise<SynchronizationUnit[]> {
+    const drive = loadedDrive || (await this.getDrive(driveId));
+
+    const revisions =
+      await this.storage.getSynchronizationUnitsRevision(syncUnitsQuery);
+
+    const synchronizationUnits: SynchronizationUnit[] = syncUnitsQuery.map(
+      (s) => ({
+        ...s,
+        lastUpdated: drive.created,
+        revision: -1,
+      }),
+    );
+    for (const revision of revisions) {
+      const syncUnit = synchronizationUnits.find(
+        (s) =>
+          revision.driveId === s.driveId &&
+          revision.documentId === s.documentId &&
+          revision.scope === s.scope &&
+          revision.branch === s.branch,
+      );
+      if (syncUnit) {
+        syncUnit.revision = revision.revision;
+        syncUnit.lastUpdated = revision.lastUpdated;
+      }
     }
-
-    async deleteDrive(id: string) {
-        const result = await Promise.allSettled([
-            this.stopSyncRemoteDrive(id),
-            this.listenerStateManager.removeDrive(id),
-            this.cache.deleteDocument('drives', id),
-            this.storage.deleteDrive(id)
-        ]);
-
-        result.forEach(r => {
-            if (r.status === 'rejected') {
-                throw r.reason;
-            }
-        });
+    return synchronizationUnits;
+  }
+
+  public async getSynchronizationUnitsIds(
+    driveId: string,
+    documentId?: string[],
+    scope?: string[],
+    branch?: string[],
+    documentType?: string[],
+    loadedDrive?: DocumentDriveDocument,
+  ): Promise<SynchronizationUnitQuery[]> {
+    const drive = loadedDrive ?? (await this.getDrive(driveId));
+    const nodes = drive.state.global.nodes.filter(
+      (node) =>
+        isFileNode(node) &&
+        (!documentId?.length ||
+          documentId.includes(node.id) ||
+          documentId.includes("*")) &&
+        (!documentType?.length ||
+          documentType.includes(node.documentType) ||
+          documentType.includes("*")),
+    ) as Pick<FileNode, "id" | "documentType" | "synchronizationUnits">[];
+
+    // checks if document drive synchronization unit should be added
+    if (
+      (!documentId || documentId.includes("*") || documentId.includes("")) &&
+      (!documentType?.length ||
+        documentType.includes("powerhouse/document-drive") ||
+        documentType.includes("*"))
+    ) {
+      nodes.unshift({
+        id: "",
+        documentType: "powerhouse/document-drive",
+        synchronizationUnits: [
+          {
+            syncId: "0",
+            scope: "global",
+            branch: "main",
+          },
+        ],
+      });
     }
 
-    getDrives() {
-        return this.storage.getDrives();
+    const synchronizationUnitsQuery: Omit<
+      SynchronizationUnit,
+      "revision" | "lastUpdated"
+    >[] = [];
+    for (const node of nodes) {
+      const nodeUnits =
+        scope?.length || branch?.length
+          ? node.synchronizationUnits.filter(
+              (unit) =>
+                (!scope?.length ||
+                  scope.includes(unit.scope) ||
+                  scope.includes("*")) &&
+                (!branch?.length ||
+                  branch.includes(unit.branch) ||
+                  branch.includes("*")),
+            )
+          : node.synchronizationUnits;
+      if (!nodeUnits.length) {
+        continue;
+      }
+      synchronizationUnitsQuery.push(
+        ...nodeUnits.map((n) => ({
+          driveId,
+          documentId: node.id,
+          syncId: n.syncId,
+          documentType: node.documentType,
+          scope: n.scope,
+          branch: n.branch,
+        })),
+      );
     }
-
-    async getDrive(drive: string, options?: GetDocumentOptions) {
-        try {
-            const document = await this.cache.getDocument('drives', drive); // TODO support GetDocumentOptions
-            if (document && isDocumentDrive(document)) {
-                return document;
-            }
-        } catch (e) {
-            logger.error('Error getting drive from cache', e);
-        }
-        const driveStorage = await this.storage.getDrive(drive);
-        const document = this._buildDocument(driveStorage, options);
-        if (!isDocumentDrive(document)) {
-            throw new Error(
-                `Document with id ${drive} is not a Document Drive`
-            );
-        } else {
-            this.cache
-                .setDocument('drives', drive, document)
-                .catch(logger.error);
-            return document;
-        }
+    return synchronizationUnitsQuery;
+  }
+
+  public async getSynchronizationUnitIdInfo(
+    driveId: string,
+    syncId: string,
+    loadedDrive?: DocumentDriveDocument,
+  ): Promise<SynchronizationUnitQuery | undefined> {
+    const drive = loadedDrive || (await this.getDrive(driveId));
+    const node = drive.state.global.nodes.find(
+      (node) =>
+        isFileNode(node) &&
+        node.synchronizationUnits.find((unit) => unit.syncId === syncId),
+    );
+
+    if (!node || !isFileNode(node)) {
+      return undefined;
     }
 
-    async getDriveBySlug(slug: string, options?: GetDocumentOptions) {
-        try {
-            const document = await this.cache.getDocument('drives-slug', slug);
-            if (document && isDocumentDrive(document)) {
-                return document;
-            }
-        } catch (e) {
-            logger.error('Error getting drive from cache', e);
-        }
-
-        const driveStorage = await this.storage.getDriveBySlug(slug);
-        const document = this._buildDocument(driveStorage, options);
-        if (!isDocumentDrive(document)) {
-            throw new Error(
-                `Document with slug ${slug} is not a Document Drive`
-            );
-        } else {
-            this.cache
-                .setDocument('drives-slug', slug, document)
-                .catch(logger.error);
-            return document;
-        }
+    const syncUnit = node.synchronizationUnits.find(
+      (unit) => unit.syncId === syncId,
+    );
+    if (!syncUnit) {
+      return undefined;
     }
 
-    async getDocument(drive: string, id: string, options?: GetDocumentOptions) {
-        try {
-            const document = await this.cache.getDocument(drive, id); // TODO support GetDocumentOptions
-            if (document) {
-                return document;
-            }
-        } catch (e) {
-            logger.error('Error getting document from cache', e);
-        }
-        const documentStorage = await this.storage.getDocument(drive, id);
-        const document = this._buildDocument(documentStorage, options);
-
-        this.cache.setDocument(drive, id, document).catch(logger.error);
-        return document;
+    return {
+      syncId,
+      scope: syncUnit.scope,
+      branch: syncUnit.branch,
+      driveId,
+      documentId: node.id,
+      documentType: node.documentType,
+    };
+  }
+
+  public async getSynchronizationUnit(
+    driveId: string,
+    syncId: string,
+    loadedDrive?: DocumentDriveDocument,
+  ): Promise<SynchronizationUnit | undefined> {
+    const syncUnit = await this.getSynchronizationUnitIdInfo(
+      driveId,
+      syncId,
+      loadedDrive,
+    );
+
+    if (!syncUnit) {
+      return undefined;
     }
 
-    getDocuments(drive: string) {
-        return this.storage.getDocuments(drive);
+    const { scope, branch, documentId, documentType } = syncUnit;
+
+    // TODO: REPLACE WITH GET DOCUMENT OPERATIONS
+    const document = await this.getDocument(driveId, documentId);
+    const operations = document.operations[scope as OperationScope] ?? [];
+    const lastOperation = operations[operations.length - 1];
+
+    return {
+      syncId,
+      scope,
+      branch,
+      driveId,
+      documentId,
+      documentType,
+      lastUpdated: lastOperation?.timestamp ?? document.lastModified,
+      revision: lastOperation?.index ?? 0,
+    };
+  }
+
+  async getOperationData(
+    driveId: string,
+    syncId: string,
+    filter: GetStrandsOptions,
+    loadedDrive?: DocumentDriveDocument,
+  ): Promise<OperationUpdate[]> {
+    const syncUnit =
+      syncId === "0"
+        ? { documentId: "", scope: "global" }
+        : await this.getSynchronizationUnitIdInfo(driveId, syncId, loadedDrive);
+
+    if (!syncUnit) {
+      throw new Error(`Invalid Sync Id ${syncId} in drive ${driveId}`);
     }
 
-    protected async createDocument(
-        driveId: string,
-        input: CreateDocumentInput
-    ) {
-        // if a document was provided then checks if it's valid
-        let state = undefined;
-        if (input.document) {
-            if (input.documentType !== input.document.documentType) {
-                throw new Error(
-                    `Provided document is not ${input.documentType}`
-                );
-            }
-            const doc = this._buildDocument(input.document);
-            state = doc.state;
-        }
-
-        // if no document was provided then create a new one
-        const document =
-            input.document ??
-            this._getDocumentModel(input.documentType).utils.createDocument();
-
-        // stores document information
-        const documentStorage: DocumentStorage = {
-            name: document.name,
-            revision: document.revision,
-            documentType: document.documentType,
-            created: document.created,
-            lastModified: document.lastModified,
-            operations: { global: [], local: [] },
-            initialState: document.initialState,
-            clipboard: [],
-            state: state ?? document.state
-        };
-        await this.storage.createDocument(driveId, input.id, documentStorage);
-
-        // if the document contains operations then
-        // stores the operations in the storage
-        const operations = Object.values(document.operations).flat();
-        if (operations.length) {
-            if (isDocumentDrive(document)) {
-                await this.storage.addDriveOperations(
-                    driveId,
-                    operations as Operation<DocumentDriveAction>[],
-                    document
-                );
-            } else {
-                await this.storage.addDocumentOperations(
-                    driveId,
-                    input.id,
-                    operations,
-                    document
-                );
-            }
-        }
-
-        return document;
+    const document =
+      syncId === "0"
+        ? loadedDrive || (await this.getDrive(driveId))
+        : await this.getDocument(driveId, syncUnit.documentId); // TODO replace with getDocumentOperations
+
+    const operations =
+      document.operations[syncUnit.scope as OperationScope] ?? []; // TODO filter by branch also
+
+    const filteredOperations = operations.filter(
+      (operation) =>
+        Object.keys(filter).length === 0 ||
+        ((filter.since === undefined ||
+          isBefore(filter.since, operation.timestamp)) &&
+          (filter.fromRevision === undefined ||
+            operation.index > filter.fromRevision)),
+    );
+
+    const limitedOperations = filter.limit
+      ? filteredOperations.slice(0, filter.limit)
+      : filteredOperations;
+
+    return limitedOperations.map((operation) => ({
+      hash: operation.hash,
+      index: operation.index,
+      timestamp: operation.timestamp,
+      type: operation.type,
+      input: operation.input as object,
+      skip: operation.skip,
+      context: operation.context,
+      id: operation.id,
+    }));
+  }
+
+  protected getDocumentModel(documentType: string) {
+    const documentModel = this.documentModels.find(
+      (model) => model.documentModel.id === documentType,
+    );
+    if (!documentModel) {
+      throw new Error(`Document type ${documentType} not supported`);
     }
+    return documentModel;
+  }
 
-    async deleteDocument(driveId: string, id: string) {
-        try {
-            const syncUnits = await this.getSynchronizationUnitsIds(driveId, [
-                id
-            ]);
-            await this.listenerStateManager.removeSyncUnits(driveId, syncUnits);
-        } catch (error) {
-            logger.warn('Error deleting document', error);
-        }
-        await this.cache.deleteDocument(driveId, id);
-        return this.storage.deleteDocument(driveId, id);
+  async addDrive(drive: DriveInput): Promise<DocumentDriveDocument> {
+    const id = drive.global.id || generateUUID();
+    if (!id) {
+      throw new Error("Invalid Drive Id");
     }
 
-    async _processOperations<T extends Document, A extends Action>(
-        drive: string,
-        documentId: string | undefined,
-        storageDocument: DocumentStorage<T>,
-        operations: Operation<A | BaseAction>[]
-    ) {
-        const operationsApplied: Operation<A | BaseAction>[] = [];
-        const signals: SignalResult[] = [];
-        let document: T = this._buildDocument(storageDocument);
-
-        let error: OperationError | undefined; // TODO: replace with an array of errors/consistency issues
-        const operationsByScope = groupOperationsByScope(operations);
-
-        for (const scope of Object.keys(operationsByScope)) {
-            const storageDocumentOperations =
-                storageDocument.operations[scope as OperationScope];
-
-            // TODO two equal operations done by two clients will be considered the same, ie: { type: "INCREMENT" }
-            const branch = removeExistingOperations(
-                operationsByScope[scope as OperationScope] || [],
-                storageDocumentOperations
-            );
-
-            // No operations to apply
-            if (branch.length < 1) {
-                continue;
-            }
-
-            const trunk = garbageCollect(
-                sortOperations(storageDocumentOperations)
-            );
-
-            const [invertedTrunk, tail] = attachBranch(trunk, branch);
-
-            const newHistory =
-                tail.length < 1
-                    ? invertedTrunk
-                    : merge(trunk, invertedTrunk, reshuffleByTimestamp);
-
-            const newOperations = newHistory.filter(
-                op => trunk.length < 1 || precedes(trunk[trunk.length - 1]!, op)
-            );
-
-            for (const nextOperation of newOperations) {
-                let skipHashValidation = false;
-
-                // when dealing with a merge (tail.length > 0) we have to skip hash validation
-                // for the operations that were re-indexed (previous hash becomes invalid due the new position in the history)
-                if (tail.length > 0) {
-                    const sourceOperation = operations.find(
-                        op => op.hash === nextOperation.hash
-                    );
-
-                    skipHashValidation =
-                        !sourceOperation ||
-                        sourceOperation.index !== nextOperation.index ||
-                        sourceOperation.skip !== nextOperation.skip;
-                }
-
-                try {
-                    const appliedResult = await this._performOperation(
-                        drive,
-                        documentId,
-                        document,
-                        nextOperation,
-                        skipHashValidation
-                    );
-                    document = appliedResult.document;
-                    signals.push(...appliedResult.signals);
-                    operationsApplied.push(...appliedResult.operation);
-                } catch (e) {
-                    error =
-                        e instanceof OperationError
-                            ? e
-                            : new OperationError(
-                                  'ERROR',
-                                  nextOperation,
-                                  (e as Error).message,
-                                  (e as Error).cause
-                              );
-
-                    // TODO: don't break on errors...
-                    break;
-                }
-            }
-        }
-
-        return {
-            document,
-            operationsApplied,
-            signals,
-            error
-        } as const;
+    const drives = await this.storage.getDrives();
+    if (drives.includes(id)) {
+      throw new DriveAlreadyExistsError(id);
     }
 
-    private _buildDocument<T extends Document>(
-        documentStorage: DocumentStorage<T>,
-        options?: GetDocumentOptions
-    ): T {
-        if (
-            documentStorage.state &&
-            (!options || options.checkHashes === false)
-        ) {
-            return documentStorage as T;
-        }
+    const document = utils.createDocument({
+      state: drive,
+    });
 
-        const documentModel = this._getDocumentModel(
-            documentStorage.documentType
-        );
+    await this.storage.createDrive(id, document);
 
-        const revisionOperations =
-            options?.revisions !== undefined
-                ? filterOperationsByRevision(
-                      documentStorage.operations,
-                      options.revisions
-                  )
-                : documentStorage.operations;
-        const operations =
-            baseUtils.documentHelpers.garbageCollectDocumentOperations(
-                revisionOperations
-            );
-
-        return baseUtils.replayDocument(
-            documentStorage.initialState,
-            operations,
-            documentModel.reducer,
-            undefined,
-            documentStorage,
-            undefined,
-            {
-                ...options,
-                checkHashes: options?.checkHashes ?? true,
-                reuseOperationResultingState: options?.checkHashes ?? true
-            }
-        ) as T;
+    if (drive.global.slug) {
+      await this.cache.deleteDocument("drives-slug", drive.global.slug);
     }
 
-    private async _performOperation<T extends Document>(
-        drive: string,
-        id: string | undefined,
-        document: T,
-        operation: Operation,
-        skipHashValidation = false
-    ) {
-        const documentModel = this._getDocumentModel(document.documentType);
-
-        const signalResults: SignalResult[] = [];
-        let newDocument = document;
-
-        const scope = operation.scope;
-        const documentOperations =
-            DocumentUtils.documentHelpers.garbageCollectDocumentOperations({
-                ...document.operations,
-                [scope]: DocumentUtils.documentHelpers.skipHeaderOperations(
-                    document.operations[scope],
-                    operation
-                )
-            });
-
-        const lastRemainingOperation = documentOperations[scope].at(-1);
-        // if the latest operation doesn't have a resulting state then tries
-        // to retrieve it from the db to avoid rerunning all the operations
-        if (lastRemainingOperation && !lastRemainingOperation.resultingState) {
-            lastRemainingOperation.resultingState = await (id
-                ? this.storage.getOperationResultingState?.(
-                      drive,
-                      id,
-                      lastRemainingOperation.index,
-                      lastRemainingOperation.scope,
-                      'main'
-                  )
-                : this.storage.getDriveOperationResultingState?.(
-                      drive,
-                      lastRemainingOperation.index,
-                      lastRemainingOperation.scope,
-                      'main'
-                  ));
-        }
-
-        const operationSignals: (() => Promise<SignalResult>)[] = [];
-        newDocument = documentModel.reducer(
-            newDocument,
-            operation,
-            signal => {
-                let handler: (() => Promise<unknown>) | undefined = undefined;
-                switch (signal.type) {
-                    case 'CREATE_CHILD_DOCUMENT':
-                        handler = () =>
-                            this.createDocument(drive, signal.input);
-                        break;
-                    case 'DELETE_CHILD_DOCUMENT':
-                        handler = () =>
-                            this.deleteDocument(drive, signal.input.id);
-                        break;
-                    case 'COPY_CHILD_DOCUMENT':
-                        handler = () =>
-                            this.getDocument(drive, signal.input.id).then(
-                                documentToCopy =>
-                                    this.createDocument(drive, {
-                                        id: signal.input.newId,
-                                        documentType:
-                                            documentToCopy.documentType,
-                                        document: documentToCopy,
-                                        synchronizationUnits:
-                                            signal.input.synchronizationUnits
-                                    })
-                            );
-                        break;
-                }
-                if (handler) {
-                    operationSignals.push(() =>
-                        handler().then(result => ({ signal, result }))
-                    );
-                }
-            },
-            { skip: operation.skip, reuseOperationResultingState: true }
-        ) as T;
-
-        const appliedOperation = newDocument.operations[operation.scope].filter(
-            op => op.index == operation.index && op.skip == operation.skip
-        );
-
-        if (appliedOperation.length < 1) {
-            throw new OperationError(
-                'ERROR',
-                operation,
-                `Operation with index ${operation.index}:${operation.skip || 0} was not applied.`
-            );
-        } else if (
-            appliedOperation[0]!.hash !== operation.hash &&
-            !skipHashValidation
-        ) {
-            throw new ConflictOperationError(operation, appliedOperation[0]!);
-        }
-
-        for (const signalHandler of operationSignals) {
-            const result = await signalHandler();
-            signalResults.push(result);
-        }
-
-        return {
-            document: newDocument,
-            signals: signalResults,
-            operation: appliedOperation
-        };
+    await this._initializeDrive(id);
+
+    return document;
+  }
+
+  async addRemoteDrive(
+    url: string,
+    options: RemoteDriveOptions,
+  ): Promise<DocumentDriveDocument> {
+    const { id, name, slug, icon } =
+      options.expectedDriveInfo || (await requestPublicDrive(url));
+
+    const {
+      pullFilter,
+      pullInterval,
+      availableOffline,
+      sharingType,
+      listeners,
+      triggers,
+    } = options;
+
+    const pullTrigger =
+      await PullResponderTransmitter.createPullResponderTrigger(id, url, {
+        pullFilter,
+        pullInterval,
+      });
+
+    return await this.addDrive({
+      global: {
+        id: id,
+        name,
+        slug,
+        icon: icon ?? null,
+      },
+      local: {
+        triggers: [...triggers, pullTrigger],
+        listeners: listeners,
+        availableOffline,
+        sharingType,
+      },
+    });
+  }
+
+  public async registerPullResponderTrigger(
+    id: string,
+    url: string,
+    options: Pick<RemoteDriveOptions, "pullFilter" | "pullInterval">,
+  ) {
+    const pullTrigger =
+      await PullResponderTransmitter.createPullResponderTrigger(
+        id,
+        url,
+        options,
+      );
+
+    return pullTrigger;
+  }
+
+  async deleteDrive(id: string) {
+    const result = await Promise.allSettled([
+      this.stopSyncRemoteDrive(id),
+      this.listenerStateManager.removeDrive(id),
+      this.cache.deleteDocument("drives", id),
+      this.storage.deleteDrive(id),
+    ]);
+
+    result.forEach((r) => {
+      if (r.status === "rejected") {
+        throw r.reason;
+      }
+    });
+  }
+
+  getDrives() {
+    return this.storage.getDrives();
+  }
+
+  async getDrive(drive: string, options?: GetDocumentOptions) {
+    try {
+      const document = await this.cache.getDocument("drives", drive); // TODO support GetDocumentOptions
+      if (document && isDocumentDrive(document)) {
+        return document;
+      }
+    } catch (e) {
+      logger.error("Error getting drive from cache", e);
+    }
+    const driveStorage = await this.storage.getDrive(drive);
+    const document = this._buildDocument(driveStorage, options);
+    if (!isDocumentDrive(document)) {
+      throw new Error(`Document with id ${drive} is not a Document Drive`);
+    } else {
+      this.cache.setDocument("drives", drive, document).catch(logger.error);
+      return document;
     }
+  }
 
-    addOperation(
-        drive: string,
-        id: string,
-        operation: Operation,
-        forceSync = true
-    ): Promise<IOperationResult> {
-        return this.addOperations(drive, id, [operation], forceSync);
+  async getDriveBySlug(slug: string, options?: GetDocumentOptions) {
+    try {
+      const document = await this.cache.getDocument("drives-slug", slug);
+      if (document && isDocumentDrive(document)) {
+        return document;
+      }
+    } catch (e) {
+      logger.error("Error getting drive from cache", e);
     }
 
-    private async _addOperations(
-        drive: string,
-        id: string,
-        callback: (document: DocumentStorage) => Promise<{
-            operations: Operation[];
-            header: DocumentHeader;
-        }>
-    ) {
-        if (!this.storage.addDocumentOperationsWithTransaction) {
-            const documentStorage = await this.storage.getDocument(drive, id);
-            const result = await callback(documentStorage);
-            // saves the applied operations to storage
-            if (result.operations.length > 0) {
-                await this.storage.addDocumentOperations(
-                    drive,
-                    id,
-                    result.operations,
-                    result.header
-                );
-            }
-        } else {
-            await this.storage.addDocumentOperationsWithTransaction(
-                drive,
-                id,
-                callback
-            );
-        }
+    const driveStorage = await this.storage.getDriveBySlug(slug);
+    const document = this._buildDocument(driveStorage, options);
+    if (!isDocumentDrive(document)) {
+      throw new Error(`Document with slug ${slug} is not a Document Drive`);
+    } else {
+      this.cache.setDocument("drives-slug", slug, document).catch(logger.error);
+      return document;
     }
+  }
 
-    queueOperation(
-        drive: string,
-        id: string,
-        operation: Operation,
-        forceSync = true
-    ): Promise<IOperationResult> {
-        return this.queueOperations(drive, id, [operation], forceSync);
+  async getDocument(drive: string, id: string, options?: GetDocumentOptions) {
+    try {
+      const document = await this.cache.getDocument(drive, id); // TODO support GetDocumentOptions
+      if (document) {
+        return document;
+      }
+    } catch (e) {
+      logger.error("Error getting document from cache", e);
+    }
+    const documentStorage = await this.storage.getDocument(drive, id);
+    const document = this._buildDocument(documentStorage, options);
+
+    this.cache.setDocument(drive, id, document).catch(logger.error);
+    return document;
+  }
+
+  getDocuments(drive: string) {
+    return this.storage.getDocuments(drive);
+  }
+
+  protected async createDocument(driveId: string, input: CreateDocumentInput) {
+    // if a document was provided then checks if it's valid
+    let state = undefined;
+    if (input.document) {
+      if (input.documentType !== input.document.documentType) {
+        throw new Error(`Provided document is not ${input.documentType}`);
+      }
+      const doc = this._buildDocument(input.document);
+      state = doc.state;
     }
 
-    private async resultIfExistingOperations(
-        drive: string,
-        id: string,
-        operations: Operation[]
-    ): Promise<IOperationResult | undefined> {
-        try {
-            const document = await this.getDocument(drive, id);
-            const newOperation = operations.find(
-                op =>
-                    !op.id ||
-                    !document.operations[op.scope].find(
-                        existingOp =>
-                            existingOp.id === op.id &&
-                            existingOp.index === op.index &&
-                            existingOp.type === op.type &&
-                            existingOp.hash === op.hash
-                    )
-            );
-            if (!newOperation) {
-                return {
-                    status: 'SUCCESS',
-                    document,
-                    operations,
-                    signals: []
-                };
-            } else {
-                return undefined;
-            }
-        } catch (error) {
-            console.error(error); // TODO error
-            return undefined;
-        }
+    // if no document was provided then create a new one
+    const document =
+      input.document ??
+      this.getDocumentModel(input.documentType).utils.createDocument();
+
+    // stores document information
+    const documentStorage: DocumentStorage = {
+      name: document.name,
+      revision: document.revision,
+      documentType: document.documentType,
+      created: document.created,
+      lastModified: document.lastModified,
+      operations: { global: [], local: [] },
+      initialState: document.initialState,
+      clipboard: [],
+      state: state ?? document.state,
+    };
+    await this.storage.createDocument(driveId, input.id, documentStorage);
+
+    // set initial state for new syncUnits
+    for (const syncUnit of input.synchronizationUnits) {
+      this.initSyncStatus(syncUnit.syncId, {
+        pull: this.triggerMap.get(driveId) ? "INITIAL_SYNC" : undefined,
+        push: this.listenerStateManager.driveHasListeners(driveId)
+          ? "SUCCESS"
+          : undefined,
+      });
     }
 
-    async queueOperations(
-        drive: string,
-        id: string,
-        operations: Operation[],
-        forceSync = true
-    ) {
-        // if operations are already stored then returns cached document
-        const result = await this.resultIfExistingOperations(
-            drive,
-            id,
-            operations
+    // if the document contains operations then
+    // stores the operations in the storage
+    const operations = Object.values(document.operations).flat();
+    if (operations.length) {
+      if (isDocumentDrive(document)) {
+        await this.storage.addDriveOperations(
+          driveId,
+          operations as Operation<DocumentDriveAction>[],
+          document,
         );
-        if (result) {
-            console.log('Duplicated operations!');
-            return result;
-        }
-        try {
-            const jobId = await this.queueManager.addJob({
-                driveId: drive,
-                documentId: id,
-                operations,
-                forceSync
-            });
-
-            return new Promise<IOperationResult>((resolve, reject) => {
-                const unsubscribe = this.queueManager.on(
-                    'jobCompleted',
-                    (job, result) => {
-                        if (job.jobId === jobId) {
-                            unsubscribe();
-                            unsubscribeError();
-                            resolve(result);
-                        }
-                    }
-                );
-                const unsubscribeError = this.queueManager.on(
-                    'jobFailed',
-                    (job, error) => {
-                        if (job.jobId === jobId) {
-                            unsubscribe();
-                            unsubscribeError();
-                            reject(error);
-                        }
-                    }
-                );
-            });
-        } catch (error) {
-            logger.error('Error adding job', error);
-            throw error;
-        }
+      } else {
+        await this.storage.addDocumentOperations(
+          driveId,
+          input.id,
+          operations,
+          document,
+        );
+      }
     }
 
-    async queueAction(
-        drive: string,
-        id: string,
-        action: Action,
-        forceSync?: boolean | undefined
-    ): Promise<IOperationResult> {
-        return this.queueActions(drive, id, [action], forceSync);
+    return document;
+  }
+
+  async deleteDocument(driveId: string, id: string) {
+    try {
+      const syncUnits = await this.getSynchronizationUnitsIds(driveId, [id]);
+
+      // remove document sync units status when a document is deleted
+      for (const syncUnit of syncUnits) {
+        this.updateSyncUnitStatus(syncUnit.syncId, null);
+      }
+      await this.listenerStateManager.removeSyncUnits(driveId, syncUnits);
+    } catch (error) {
+      logger.warn("Error deleting document", error);
     }
+    await this.cache.deleteDocument(driveId, id);
+    return this.storage.deleteDocument(driveId, id);
+  }
+
+  async _processOperations<T extends Document, A extends Action>(
+    drive: string,
+    documentId: string | undefined,
+    documentStorage: DocumentStorage<T>,
+    operations: Operation<A | BaseAction>[],
+  ) {
+    const operationsApplied: Operation<A | BaseAction>[] = [];
+    const signals: SignalResult[] = [];
+
+    const documentStorageWithState = await this._addDocumentResultingStage(
+      documentStorage,
+      drive,
+      documentId,
+    );
+
+    let document: T = this._buildDocument(documentStorageWithState);
+    let error: OperationError | undefined; // TODO: replace with an array of errors/consistency issues
+    const operationsByScope = groupOperationsByScope(operations);
+
+    for (const scope of Object.keys(operationsByScope)) {
+      const storageDocumentOperations =
+        documentStorage.operations[scope as OperationScope];
+
+      // TODO two equal operations done by two clients will be considered the same, ie: { type: "INCREMENT" }
+      const branch = removeExistingOperations(
+        operationsByScope[scope as OperationScope] || [],
+        storageDocumentOperations,
+      );
+
+      // No operations to apply
+      if (branch.length < 1) {
+        continue;
+      }
+
+      const trunk = garbageCollect(sortOperations(storageDocumentOperations));
+
+      const [invertedTrunk, tail] = attachBranch(trunk, branch);
+
+      const newHistory =
+        tail.length < 1
+          ? invertedTrunk
+          : merge(trunk, invertedTrunk, reshuffleByTimestamp);
+
+      const newOperations = newHistory.filter(
+        (op) => trunk.length < 1 || precedes(trunk[trunk.length - 1]!, op),
+      );
+
+      for (const nextOperation of newOperations) {
+        let skipHashValidation = false;
+
+        // when dealing with a merge (tail.length > 0) we have to skip hash validation
+        // for the operations that were re-indexed (previous hash becomes invalid due the new position in the history)
+        if (tail.length > 0) {
+          const sourceOperation = operations.find(
+            (op) => op.hash === nextOperation.hash,
+          );
+
+          skipHashValidation =
+            !sourceOperation ||
+            sourceOperation.index !== nextOperation.index ||
+            sourceOperation.skip !== nextOperation.skip;
+        }
 
-    async queueActions(
-        drive: string,
-        id: string,
-        actions: Action[],
-        forceSync?: boolean | undefined
-    ): Promise<IOperationResult> {
         try {
-            const jobId = await this.queueManager.addJob({
-                driveId: drive,
-                documentId: id,
-                actions,
-                forceSync
-            });
-
-            return new Promise<IOperationResult>((resolve, reject) => {
-                const unsubscribe = this.queueManager.on(
-                    'jobCompleted',
-                    (job, result) => {
-                        if (job.jobId === jobId) {
-                            unsubscribe();
-                            unsubscribeError();
-                            resolve(result);
-                        }
-                    }
-                );
-                const unsubscribeError = this.queueManager.on(
-                    'jobFailed',
-                    (job, error) => {
-                        if (job.jobId === jobId) {
-                            unsubscribe();
-                            unsubscribeError();
-                            reject(error);
-                        }
-                    }
+          // runs operation on next available tick, to avoid blocking the main thread
+          const taskQueueMethod = this.options.taskQueueMethod;
+          const task = () =>
+            this._performOperation(
+              drive,
+              documentId,
+              document,
+              nextOperation,
+              skipHashValidation,
+            );
+          const appliedResult = await (taskQueueMethod
+            ? runAsapAsync(task, taskQueueMethod)
+            : task());
+          document = appliedResult.document;
+          signals.push(...appliedResult.signals);
+          operationsApplied.push(appliedResult.operation);
+
+          // TODO what to do if one of the applied operations has an error?
+        } catch (e) {
+          error =
+            e instanceof OperationError
+              ? e
+              : new OperationError(
+                  "ERROR",
+                  nextOperation,
+                  (e as Error).message,
+                  (e as Error).cause,
                 );
-            });
-        } catch (error) {
-            logger.error('Error adding job', error);
-            throw error;
+
+          // TODO: don't break on errors...
+          break;
         }
+      }
     }
 
-    async queueDriveAction(
-        drive: string,
-        action: DocumentDriveAction | BaseAction,
-        forceSync?: boolean | undefined
-    ): Promise<IOperationResult<DocumentDriveDocument>> {
-        return this.queueDriveActions(drive, [action], forceSync);
+    return {
+      document,
+      operationsApplied,
+      signals,
+      error,
+    } as const;
+  }
+
+  private async _addDocumentResultingStage<T extends Document>(
+    document: DocumentStorage<T>,
+    drive: string,
+    documentId?: string,
+    options?: GetDocumentOptions,
+  ): Promise<DocumentStorage<T>> {
+    // apply skip header operations to all scopes
+    const operations =
+      options?.revisions !== undefined
+        ? filterOperationsByRevision(document.operations, options.revisions)
+        : document.operations;
+    const documentOperations =
+      DocumentUtils.documentHelpers.garbageCollectDocumentOperations(
+        operations,
+      );
+
+    for (const scope of Object.keys(documentOperations)) {
+      const lastRemainingOperation =
+        documentOperations[scope as OperationScope].at(-1);
+      // if the latest operation doesn't have a resulting state then tries
+      // to retrieve it from the db to avoid rerunning all the operations
+      if (lastRemainingOperation && !lastRemainingOperation.resultingState) {
+        lastRemainingOperation.resultingState = await (documentId
+          ? this.storage.getOperationResultingState?.(
+              drive,
+              documentId,
+              lastRemainingOperation.index,
+              lastRemainingOperation.scope,
+              "main",
+            )
+          : this.storage.getDriveOperationResultingState?.(
+              drive,
+              lastRemainingOperation.index,
+              lastRemainingOperation.scope,
+              "main",
+            ));
+      }
     }
 
-    async queueDriveActions(
-        drive: string,
-        actions: (DocumentDriveAction | BaseAction)[],
-        forceSync?: boolean | undefined
-    ): Promise<IOperationResult<DocumentDriveDocument>> {
-        const jobId = await this.queueManager.addJob({
-            driveId: drive,
-            actions,
-            forceSync
-        });
-        return new Promise<IOperationResult<DocumentDriveDocument>>(
-            (resolve, reject) => {
-                const unsubscribe = this.queueManager.on(
-                    'jobCompleted',
-                    (job, result) => {
-                        if (job.jobId === jobId) {
-                            unsubscribe();
-                            unsubscribeError();
-                            resolve(
-                                result as IOperationResult<DocumentDriveDocument>
-                            );
-                        }
-                    }
-                );
-                const unsubscribeError = this.queueManager.on(
-                    'jobFailed',
-                    (job, error) => {
-                        if (job.jobId === jobId) {
-                            unsubscribe();
-                            unsubscribeError();
-                            reject(error);
-                        }
-                    }
-                );
-            }
-        );
+    return {
+      ...document,
+      operations: documentOperations,
+    };
+  }
+
+  private _buildDocument<T extends Document>(
+    documentStorage: DocumentStorage<T>,
+    options?: GetDocumentOptions,
+  ): T {
+    if (documentStorage.state && (!options || options.checkHashes === false)) {
+      return documentStorage as T;
     }
 
-    async addOperations(
-        drive: string,
-        id: string,
-        operations: Operation[],
-        forceSync = true
-    ) {
-        // if operations are already stored then returns the result
-        const result = await this.resultIfExistingOperations(
+    const documentModel = this.getDocumentModel(documentStorage.documentType);
+
+    const revisionOperations =
+      options?.revisions !== undefined
+        ? filterOperationsByRevision(
+            documentStorage.operations,
+            options.revisions,
+          )
+        : documentStorage.operations;
+    const operations =
+      baseUtils.documentHelpers.garbageCollectDocumentOperations(
+        revisionOperations,
+      );
+
+    return baseUtils.replayDocument(
+      documentStorage.initialState,
+      operations,
+      documentModel.reducer,
+      undefined,
+      documentStorage,
+      undefined,
+      {
+        ...options,
+        checkHashes: options?.checkHashes ?? true,
+        reuseOperationResultingState: options?.checkHashes ?? true,
+      },
+    ) as T;
+  }
+
+  private async _performOperation<T extends Document>(
+    drive: string,
+    id: string | undefined,
+    document: T,
+    operation: Operation,
+    skipHashValidation = false,
+  ) {
+    const documentModel = this.getDocumentModel(document.documentType);
+
+    const signalResults: SignalResult[] = [];
+    let newDocument = document;
+
+    const scope = operation.scope;
+    const documentOperations =
+      DocumentUtils.documentHelpers.garbageCollectDocumentOperations({
+        ...document.operations,
+        [scope]: DocumentUtils.documentHelpers.skipHeaderOperations(
+          document.operations[scope],
+          operation,
+        ),
+      });
+
+    const lastRemainingOperation = documentOperations[scope].at(-1);
+    // if the latest operation doesn't have a resulting state then tries
+    // to retrieve it from the db to avoid rerunning all the operations
+    if (lastRemainingOperation && !lastRemainingOperation.resultingState) {
+      lastRemainingOperation.resultingState = await (id
+        ? this.storage.getOperationResultingState?.(
             drive,
             id,
-            operations
-        );
-        if (result) {
-            return result;
-        }
-        let document: Document | undefined;
-        const operationsApplied: Operation[] = [];
-        const signals: SignalResult[] = [];
-        let error: Error | undefined;
-
-        try {
-            await this._addOperations(drive, id, async documentStorage => {
-                const result = await this._processOperations(
-                    drive,
-                    id,
-                    documentStorage,
-                    operations
-                );
-
-                if (!result.document) {
-                    logger.error('Invalid document');
-                    throw result.error ?? new Error('Invalid document');
-                }
-
-                document = result.document;
-                error = result.error;
-                signals.push(...result.signals);
-                operationsApplied.push(...result.operationsApplied);
-
-                return {
-                    operations: result.operationsApplied,
-                    header: result.document,
-                    newState: document.state
-                };
-            });
-
-            if (document) {
-                this.cache.setDocument(drive, id, document).catch(logger.error);
-            }
-
-            // gets all the different scopes and branches combinations from the operations
-            const { scopes, branches } = operationsApplied.reduce(
-                (acc, operation) => {
-                    if (!acc.scopes.includes(operation.scope)) {
-                        acc.scopes.push(operation.scope);
-                    }
-                    return acc;
-                },
-                { scopes: [] as string[], branches: ['main'] }
-            );
-
-            const syncUnits = await this.getSynchronizationUnits(
-                drive,
-                [id],
-                scopes,
-                branches
-            );
-            // update listener cache
-            this.listenerStateManager
-                .updateSynchronizationRevisions(
-                    drive,
-                    syncUnits,
-                    () => {
-                        this.updateSyncStatus(drive, 'SYNCING');
-
-                        for (const syncUnit of syncUnits) {
-                            this.updateSyncStatus(syncUnit.syncId, 'SYNCING');
-                        }
-                    },
-                    this.handleListenerError.bind(this),
-                    forceSync
-                )
-                .then(updates => {
-                    updates.length && this.updateSyncStatus(drive, 'SUCCESS');
-
-                    for (const syncUnit of syncUnits) {
-                        this.updateSyncStatus(syncUnit.syncId, 'SUCCESS');
-                    }
-                })
-                .catch(error => {
-                    logger.error(
-                        'Non handled error updating sync revision',
-                        error
-                    );
-                    this.updateSyncStatus(drive, 'ERROR', error as Error);
-
-                    for (const syncUnit of syncUnits) {
-                        this.updateSyncStatus(
-                            syncUnit.syncId,
-                            'ERROR',
-                            error as Error
-                        );
-                    }
-                });
-
-            // after applying all the valid operations,throws
-            // an error if there was an invalid operation
-            if (error) {
-                throw error;
-            }
+            lastRemainingOperation.index,
+            lastRemainingOperation.scope,
+            "main",
+          )
+        : this.storage.getDriveOperationResultingState?.(
+            drive,
+            lastRemainingOperation.index,
+            lastRemainingOperation.scope,
+            "main",
+          ));
+    }
 
-            return {
-                status: 'SUCCESS',
-                document,
-                operations: operationsApplied,
-                signals
-            } satisfies IOperationResult;
-        } catch (error) {
-            const operationError =
-                error instanceof OperationError
-                    ? error
-                    : new OperationError(
-                          'ERROR',
-                          undefined,
-                          (error as Error).message,
-                          (error as Error).cause
-                      );
-
-            return {
-                status: operationError.status,
-                error: operationError,
-                document,
-                operations: operationsApplied,
-                signals
-            } satisfies IOperationResult;
+    const operationSignals: (() => Promise<SignalResult>)[] = [];
+    newDocument = documentModel.reducer(
+      newDocument,
+      operation,
+      (signal) => {
+        let handler: (() => Promise<unknown>) | undefined = undefined;
+        switch (signal.type) {
+          case "CREATE_CHILD_DOCUMENT":
+            handler = () => this.createDocument(drive, signal.input);
+            break;
+          case "DELETE_CHILD_DOCUMENT":
+            handler = () => this.deleteDocument(drive, signal.input.id);
+            break;
+          case "COPY_CHILD_DOCUMENT":
+            handler = () =>
+              this.getDocument(drive, signal.input.id).then((documentToCopy) =>
+                this.createDocument(drive, {
+                  id: signal.input.newId,
+                  documentType: documentToCopy.documentType,
+                  document: documentToCopy,
+                  synchronizationUnits: signal.input.synchronizationUnits,
+                }),
+              );
+            break;
         }
+        if (handler) {
+          operationSignals.push(() =>
+            handler().then((result) => ({ signal, result })),
+          );
+        }
+      },
+      { skip: operation.skip, reuseOperationResultingState: true },
+    ) as T;
+
+    const appliedOperations = newDocument.operations[operation.scope].filter(
+      (op) => op.index == operation.index && op.skip == operation.skip,
+    );
+    const appliedOperation = appliedOperations.at(0);
+
+    if (!appliedOperation) {
+      throw new OperationError(
+        "ERROR",
+        operation,
+        `Operation with index ${operation.index}:${operation.skip} was not applied.`,
+      );
     }
-
-    addDriveOperation(
-        drive: string,
-        operation: Operation<DocumentDriveAction | BaseAction>,
-        forceSync = true
+    if (
+      !appliedOperation.error &&
+      appliedOperation.hash !== operation.hash &&
+      !skipHashValidation
     ) {
-        return this.addDriveOperations(drive, [operation], forceSync);
+      throw new ConflictOperationError(operation, appliedOperation);
     }
 
-    async clearStorage() {
-        for (const drive of await this.getDrives()) {
-            await this.deleteDrive(drive);
-        }
-
-        await this.storage.clearStorage?.();
+    for (const signalHandler of operationSignals) {
+      const result = await signalHandler();
+      signalResults.push(result);
     }
 
-    private async _addDriveOperations(
-        drive: string,
-        callback: (document: DocumentDriveStorage) => Promise<{
-            operations: Operation<DocumentDriveAction | BaseAction>[];
-            header: DocumentHeader;
-        }>
-    ) {
-        if (!this.storage.addDriveOperationsWithTransaction) {
-            const documentStorage = await this.storage.getDrive(drive);
-            const result = await callback(documentStorage);
-            // saves the applied operations to storage
-            if (result.operations.length > 0) {
-                await this.storage.addDriveOperations(
-                    drive,
-                    result.operations,
-                    result.header
-                );
-            }
-            return result;
-        } else {
-            return this.storage.addDriveOperationsWithTransaction(
-                drive,
-                callback
-            );
-        }
+    return {
+      document: newDocument,
+      signals: signalResults,
+      operation: appliedOperation,
+    };
+  }
+
+  addOperation(
+    drive: string,
+    id: string,
+    operation: Operation,
+    options?: AddOperationOptions,
+  ): Promise<IOperationResult> {
+    return this.addOperations(drive, id, [operation], options);
+  }
+
+  private async _addOperations(
+    drive: string,
+    id: string,
+    callback: (document: DocumentStorage) => Promise<{
+      operations: Operation[];
+      header: DocumentHeader;
+    }>,
+  ) {
+    if (!this.storage.addDocumentOperationsWithTransaction) {
+      const documentStorage = await this.storage.getDocument(drive, id);
+      const result = await callback(documentStorage);
+      // saves the applied operations to storage
+      if (result.operations.length > 0) {
+        await this.storage.addDocumentOperations(
+          drive,
+          id,
+          result.operations,
+          result.header,
+        );
+      }
+    } else {
+      await this.storage.addDocumentOperationsWithTransaction(
+        drive,
+        id,
+        callback,
+      );
     }
-
-    queueDriveOperation(
-        drive: string,
-        operation: Operation<DocumentDriveAction | BaseAction>,
-        forceSync = true
-    ): Promise<IOperationResult<DocumentDriveDocument>> {
-        return this.queueDriveOperations(drive, [operation], forceSync);
+  }
+
+  queueOperation(
+    drive: string,
+    id: string,
+    operation: Operation,
+    options?: AddOperationOptions,
+  ): Promise<IOperationResult> {
+    return this.queueOperations(drive, id, [operation], options);
+  }
+
+  private async resultIfExistingOperations(
+    drive: string,
+    id: string,
+    operations: Operation[],
+  ): Promise<IOperationResult | undefined> {
+    try {
+      const document = await this.getDocument(drive, id);
+      const newOperation = operations.find(
+        (op) =>
+          !op.id ||
+          !document.operations[op.scope].find(
+            (existingOp) =>
+              existingOp.id === op.id &&
+              existingOp.index === op.index &&
+              existingOp.type === op.type &&
+              existingOp.hash === op.hash,
+          ),
+      );
+      if (!newOperation) {
+        return {
+          status: "SUCCESS",
+          document,
+          operations,
+          signals: [],
+        };
+      } else {
+        return undefined;
+      }
+    } catch (error) {
+      if (
+        !(error as Error).message.includes(`Document with id ${id} not found`)
+      ) {
+        console.error(error);
+      }
+      return undefined;
     }
-
-    private async resultIfExistingDriveOperations(
-        driveId: string,
-        operations: Operation<DocumentDriveAction | BaseAction>[]
-    ): Promise<IOperationResult<DocumentDriveDocument> | undefined> {
-        try {
-            const drive = await this.getDrive(driveId);
-            const newOperation = operations.find(
-                op =>
-                    !op.id ||
-                    !drive.operations[op.scope].find(
-                        existingOp =>
-                            existingOp.id === op.id &&
-                            existingOp.index === op.index &&
-                            existingOp.type === op.type &&
-                            existingOp.hash === op.hash
-                    )
-            );
-            if (!newOperation) {
-                return {
-                    status: 'SUCCESS',
-                    document: drive,
-                    operations: operations,
-                    signals: []
-                } as IOperationResult<DocumentDriveDocument>;
-            } else {
-                return undefined;
+  }
+
+  async queueOperations(
+    drive: string,
+    id: string,
+    operations: Operation[],
+    options?: AddOperationOptions,
+  ) {
+    // if operations are already stored then returns cached document
+    const result = await this.resultIfExistingOperations(drive, id, operations);
+    if (result) {
+      return result;
+    }
+    try {
+      const jobId = await this.queueManager.addJob({
+        driveId: drive,
+        documentId: id,
+        operations,
+        options,
+      });
+
+      return new Promise<IOperationResult>((resolve, reject) => {
+        const unsubscribe = this.queueManager.on(
+          "jobCompleted",
+          (job, result) => {
+            if (job.jobId === jobId) {
+              unsubscribe();
+              unsubscribeError();
+              resolve(result);
             }
-        } catch (error) {
-            console.error(error); // TODO error
-            return undefined;
-        }
+          },
+        );
+        const unsubscribeError = this.queueManager.on(
+          "jobFailed",
+          (job, error) => {
+            if (job.jobId === jobId) {
+              unsubscribe();
+              unsubscribeError();
+              reject(error);
+            }
+          },
+        );
+      });
+    } catch (error) {
+      logger.error("Error adding job", error);
+      throw error;
     }
-
-    async queueDriveOperations(
-        drive: string,
-        operations: Operation<DocumentDriveAction | BaseAction>[],
-        forceSync = true
-    ): Promise<IOperationResult<DocumentDriveDocument>> {
-        // if operations are already stored then returns cached document
-        const result = await this.resultIfExistingDriveOperations(
-            drive,
-            operations
+  }
+
+  async queueAction(
+    drive: string,
+    id: string,
+    action: Action,
+    options?: AddOperationOptions,
+  ): Promise<IOperationResult> {
+    return this.queueActions(drive, id, [action], options);
+  }
+
+  async queueActions(
+    drive: string,
+    id: string,
+    actions: Action[],
+    options?: AddOperationOptions,
+  ): Promise<IOperationResult> {
+    try {
+      const jobId = await this.queueManager.addJob({
+        driveId: drive,
+        documentId: id,
+        actions,
+        options,
+      });
+
+      return new Promise<IOperationResult>((resolve, reject) => {
+        const unsubscribe = this.queueManager.on(
+          "jobCompleted",
+          (job, result) => {
+            if (job.jobId === jobId) {
+              unsubscribe();
+              unsubscribeError();
+              resolve(result);
+            }
+          },
         );
-        if (result) {
-            return result;
-        }
-
-        const jobId = await this.queueManager.addJob({
-            driveId: drive,
-            operations,
-            forceSync
-        });
-        return new Promise<IOperationResult<DocumentDriveDocument>>(
-            (resolve, reject) => {
-                const unsubscribe = this.queueManager.on(
-                    'jobCompleted',
-                    (job, result) => {
-                        if (job.jobId === jobId) {
-                            unsubscribe();
-                            unsubscribeError();
-                            resolve(
-                                result as IOperationResult<DocumentDriveDocument>
-                            );
-                        }
-                    }
-                );
-                const unsubscribeError = this.queueManager.on(
-                    'jobFailed',
-                    (job, error) => {
-                        if (job.jobId === jobId) {
-                            unsubscribe();
-                            unsubscribeError();
-                            reject(error);
-                        }
-                    }
-                );
+        const unsubscribeError = this.queueManager.on(
+          "jobFailed",
+          (job, error) => {
+            if (job.jobId === jobId) {
+              unsubscribe();
+              unsubscribeError();
+              reject(error);
             }
+          },
         );
+      });
+    } catch (error) {
+      logger.error("Error adding job", error);
+      throw error;
     }
-
-    async addDriveOperations(
-        drive: string,
-        operations: Operation<DocumentDriveAction | BaseAction>[],
-        forceSync = true
-    ) {
-        let document: DocumentDriveDocument | undefined;
-        const operationsApplied: Operation<DocumentDriveAction | BaseAction>[] =
-            [];
-        const signals: SignalResult[] = [];
-        let error: Error | undefined;
-
-        // if operations are already stored then returns cached drive
-        const result = await this.resultIfExistingDriveOperations(
-            drive,
-            operations
+  }
+
+  async queueDriveAction(
+    drive: string,
+    action: DocumentDriveAction | BaseAction,
+    options?: AddOperationOptions,
+  ): Promise<IOperationResult<DocumentDriveDocument>> {
+    return this.queueDriveActions(drive, [action], options);
+  }
+
+  async queueDriveActions(
+    drive: string,
+    actions: (DocumentDriveAction | BaseAction)[],
+    options?: AddOperationOptions,
+  ): Promise<IOperationResult<DocumentDriveDocument>> {
+    try {
+      const jobId = await this.queueManager.addJob({
+        driveId: drive,
+        actions,
+        options,
+      });
+      return new Promise<IOperationResult<DocumentDriveDocument>>(
+        (resolve, reject) => {
+          const unsubscribe = this.queueManager.on(
+            "jobCompleted",
+            (job, result) => {
+              if (job.jobId === jobId) {
+                unsubscribe();
+                unsubscribeError();
+                resolve(result as IOperationResult<DocumentDriveDocument>);
+              }
+            },
+          );
+          const unsubscribeError = this.queueManager.on(
+            "jobFailed",
+            (job, error) => {
+              if (job.jobId === jobId) {
+                unsubscribe();
+                unsubscribeError();
+                reject(error);
+              }
+            },
+          );
+        },
+      );
+    } catch (error) {
+      logger.error("Error adding drive job", error);
+      throw error;
+    }
+  }
+
+  async addOperations(
+    drive: string,
+    id: string,
+    operations: Operation[],
+    options?: AddOperationOptions,
+  ) {
+    // if operations are already stored then returns the result
+    const result = await this.resultIfExistingOperations(drive, id, operations);
+    if (result) {
+      return result;
+    }
+    let document: Document | undefined;
+    const operationsApplied: Operation[] = [];
+    const signals: SignalResult[] = [];
+    let error: Error | undefined;
+
+    try {
+      await this._addOperations(drive, id, async (documentStorage) => {
+        const result = await this._processOperations(
+          drive,
+          id,
+          documentStorage,
+          operations,
         );
-        if (result) {
-            return result;
-        }
 
-        const prevSyncUnits = await this.getSynchronizationUnitsIds(drive);
+        if (!result.document) {
+          logger.error("Invalid document");
+          throw result.error ?? new Error("Invalid document");
+        }
 
-        try {
-            await this._addDriveOperations(drive, async documentStorage => {
-                const result = await this._processOperations<
-                    DocumentDriveDocument,
-                    DocumentDriveAction
-                >(drive, undefined, documentStorage, operations.slice());
-
-                document = result.document;
-                operationsApplied.push(...result.operationsApplied);
-                signals.push(...result.signals);
-                error = result.error;
-
-                return {
-                    operations: result.operationsApplied,
-                    header: result.document
-                };
-            });
+        document = result.document;
+        error = result.error;
+        signals.push(...result.signals);
+        operationsApplied.push(...result.operationsApplied);
 
-            if (!document || !isDocumentDrive(document)) {
-                throw error ?? new Error('Invalid Document Drive document');
-            }
+        return {
+          operations: result.operationsApplied,
+          header: result.document,
+          newState: document.state,
+        };
+      });
 
-            this.cache
-                .setDocument('drives', drive, document)
-                .catch(logger.error);
+      if (document) {
+        this.cache.setDocument(drive, id, document).catch(logger.error);
+      }
+
+      // gets all the different scopes and branches combinations from the operations
+      const { scopes, branches } = operationsApplied.reduce(
+        (acc, operation) => {
+          if (!acc.scopes.includes(operation.scope)) {
+            acc.scopes.push(operation.scope);
+          }
+          return acc;
+        },
+        { scopes: [] as string[], branches: ["main"] },
+      );
+
+      const syncUnits = await this.getSynchronizationUnits(
+        drive,
+        [id],
+        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
+
+      const operationSource = this.getOperationSource(source);
+
+      this.listenerStateManager
+        .updateSynchronizationRevisions(
+          drive,
+          syncUnits,
+          source,
+          () => {
+            this.updateSyncUnitStatus(drive, {
+              [operationSource]: "SYNCING",
+            });
 
-            for (const operation of operationsApplied) {
-                switch (operation.type) {
-                    case 'ADD_LISTENER': {
-                        await this.addListener(drive, operation);
-                        break;
-                    }
-                    case 'REMOVE_LISTENER': {
-                        await this.removeListener(drive, operation);
-                        break;
-                    }
-                }
+            for (const syncUnit of syncUnits) {
+              this.updateSyncUnitStatus(syncUnit.syncId, {
+                [operationSource]: "SYNCING",
+              });
             }
+          },
+          this.handleListenerError.bind(this),
+          options?.forceSync ?? source.type === "local",
+        )
+        .then((updates) => {
+          if (updates.length) {
+            this.updateSyncUnitStatus(drive, {
+              [operationSource]: "SUCCESS",
+            });
+          }
 
-            const syncUnits = await this.getSynchronizationUnitsIds(drive);
-
-            const prevSyncUnitsIds = prevSyncUnits.map(unit => unit.syncId);
-            const syncUnitsIds = syncUnits.map(unit => unit.syncId);
-
-            const newSyncUnits = syncUnitsIds.filter(
-                syncUnitId => !prevSyncUnitsIds.includes(syncUnitId)
+          for (const syncUnit of syncUnits) {
+            this.updateSyncUnitStatus(syncUnit.syncId, {
+              [operationSource]: "SUCCESS",
+            });
+          }
+        })
+        .catch((error) => {
+          logger.error("Non handled error updating sync revision", error);
+          this.updateSyncUnitStatus(
+            drive,
+            {
+              [operationSource]: "ERROR",
+            },
+            error as Error,
+          );
+
+          for (const syncUnit of syncUnits) {
+            this.updateSyncUnitStatus(
+              syncUnit.syncId,
+              {
+                [operationSource]: "ERROR",
+              },
+              error as Error,
             );
+          }
+        });
 
-            const removedSyncUnits = prevSyncUnitsIds.filter(
-                syncUnitId => !syncUnitsIds.includes(syncUnitId)
+      // after applying all the valid operations,throws
+      // an error if there was an invalid operation
+      if (error) {
+        throw error;
+      }
+
+      return {
+        status: "SUCCESS",
+        document,
+        operations: operationsApplied,
+        signals,
+      } satisfies IOperationResult;
+    } catch (error) {
+      const operationError =
+        error instanceof OperationError
+          ? error
+          : new OperationError(
+              "ERROR",
+              undefined,
+              (error as Error).message,
+              (error as Error).cause,
             );
 
-            // update listener cache
-            const lastOperation = operationsApplied
-                .filter(op => op.scope === 'global')
-                .slice()
-                .pop();
-            if (lastOperation) {
-                this.listenerStateManager
-                    .updateSynchronizationRevisions(
-                        drive,
-                        [
-                            {
-                                syncId: '0',
-                                driveId: drive,
-                                documentId: '',
-                                scope: 'global',
-                                branch: 'main',
-                                documentType: 'powerhouse/document-drive',
-                                lastUpdated: lastOperation.timestamp,
-                                revision: lastOperation.index
-                            }
-                        ],
-                        () => {
-                            this.updateSyncStatus(drive, 'SYNCING');
-
-                            for (const syncUnitId of [
-                                ...newSyncUnits,
-                                ...removedSyncUnits
-                            ]) {
-                                this.updateSyncStatus(syncUnitId, 'SYNCING');
-                            }
-                        },
-                        this.handleListenerError.bind(this),
-                        forceSync
-                    )
-                    .then(updates => {
-                        if (updates.length) {
-                            this.updateSyncStatus(drive, 'SUCCESS');
-
-                            for (const syncUnitId of newSyncUnits) {
-                                this.updateSyncStatus(syncUnitId, 'SUCCESS');
-                            }
-
-                            for (const syncUnitId of removedSyncUnits) {
-                                this.updateSyncStatus(syncUnitId, null);
-                            }
-                        }
-                    })
-                    .catch(error => {
-                        logger.error(
-                            'Non handled error updating sync revision',
-                            error
-                        );
-                        this.updateSyncStatus(drive, 'ERROR', error as Error);
-
-                        for (const syncUnitId of [
-                            ...newSyncUnits,
-                            ...removedSyncUnits
-                        ]) {
-                            this.updateSyncStatus(
-                                syncUnitId,
-                                'ERROR',
-                                error as Error
-                            );
-                        }
-                    });
-            }
-
-            if (this.shouldSyncRemoteDrive(document)) {
-                this.startSyncRemoteDrive(document.state.global.id);
-            } else {
-                this.stopSyncRemoteDrive(document.state.global.id);
-            }
-
-            // after applying all the valid operations,throws
-            // an error if there was an invalid operation
-            if (error) {
-                throw error;
-            }
-
-            return {
-                status: 'SUCCESS',
-                document,
-                operations: operationsApplied,
-                signals
-            } satisfies IOperationResult;
-        } catch (error) {
-            const operationError =
-                error instanceof OperationError
-                    ? error
-                    : new OperationError(
-                          'ERROR',
-                          undefined,
-                          (error as Error).message,
-                          (error as Error).cause
-                      );
-
-            return {
-                status: operationError.status,
-                error: operationError,
-                document,
-                operations: operationsApplied,
-                signals
-            } satisfies IOperationResult;
-        }
+      return {
+        status: operationError.status,
+        error: operationError,
+        document,
+        operations: operationsApplied,
+        signals,
+      } satisfies IOperationResult;
     }
-
-    private _buildOperations<T extends Action>(
-        document: Document,
-        actions: (T | BaseAction)[]
-    ): Operation<T | BaseAction>[] {
-        const operations: Operation<T | BaseAction>[] = [];
-        const { reducer } = this._getDocumentModel(document.documentType);
-        for (const action of actions) {
-            document = reducer(document, action);
-            const operation = document.operations[action.scope].slice().pop();
-            if (!operation) {
-                throw new Error('Error creating operations');
-            }
-            operations.push(operation);
-        }
-        return operations;
+  }
+
+  addDriveOperation(
+    drive: string,
+    operation: Operation<DocumentDriveAction | BaseAction>,
+    options?: AddOperationOptions,
+  ) {
+    return this.addDriveOperations(drive, [operation], options);
+  }
+
+  async clearStorage() {
+    for (const drive of await this.getDrives()) {
+      await this.deleteDrive(drive);
     }
 
-    async addAction(
-        drive: string,
-        id: string,
-        action: Action,
-        forceSync = true
-    ): Promise<IOperationResult> {
-        return this.addActions(drive, id, [action], forceSync);
+    await this.storage.clearStorage?.();
+  }
+
+  private async _addDriveOperations(
+    drive: string,
+    callback: (document: DocumentDriveStorage) => Promise<{
+      operations: Operation<DocumentDriveAction | BaseAction>[];
+      header: DocumentHeader;
+    }>,
+  ) {
+    if (!this.storage.addDriveOperationsWithTransaction) {
+      const documentStorage = await this.storage.getDrive(drive);
+      const result = await callback(documentStorage);
+      // saves the applied operations to storage
+      if (result.operations.length > 0) {
+        await this.storage.addDriveOperations(
+          drive,
+          result.operations,
+          result.header,
+        );
+      }
+      return result;
+    } else {
+      return this.storage.addDriveOperationsWithTransaction(drive, callback);
     }
-
-    async addActions(
-        drive: string,
-        id: string,
-        actions: Action[],
-        forceSync = true
-    ): Promise<IOperationResult> {
-        const document = await this.getDocument(drive, id);
-        const operations = this._buildOperations(document, actions);
-        return this.addOperations(drive, id, operations, forceSync);
+  }
+
+  queueDriveOperation(
+    drive: string,
+    operation: Operation<DocumentDriveAction | BaseAction>,
+    options?: AddOperationOptions,
+  ): Promise<IOperationResult<DocumentDriveDocument>> {
+    return this.queueDriveOperations(drive, [operation], options);
+  }
+
+  private async resultIfExistingDriveOperations(
+    driveId: string,
+    operations: Operation<DocumentDriveAction | BaseAction>[],
+  ): Promise<IOperationResult<DocumentDriveDocument> | undefined> {
+    try {
+      const drive = await this.getDrive(driveId);
+      const newOperation = operations.find(
+        (op) =>
+          !op.id ||
+          !drive.operations[op.scope].find(
+            (existingOp) =>
+              existingOp.id === op.id &&
+              existingOp.index === op.index &&
+              existingOp.type === op.type &&
+              existingOp.hash === op.hash,
+          ),
+      );
+      if (!newOperation) {
+        return {
+          status: "SUCCESS",
+          document: drive,
+          operations: operations,
+          signals: [],
+        } as IOperationResult<DocumentDriveDocument>;
+      } else {
+        return undefined;
+      }
+    } catch (error) {
+      console.error(error); // TODO error
+      return undefined;
     }
-
-    async addDriveAction(
-        drive: string,
-        action: DocumentDriveAction | BaseAction,
-        forceSync = true
-    ): Promise<IOperationResult<DocumentDriveDocument>> {
-        return this.addDriveActions(drive, [action], forceSync);
+  }
+
+  async queueDriveOperations(
+    drive: string,
+    operations: Operation<DocumentDriveAction | BaseAction>[],
+    options?: AddOperationOptions,
+  ): Promise<IOperationResult<DocumentDriveDocument>> {
+    // if operations are already stored then returns cached document
+    const result = await this.resultIfExistingDriveOperations(
+      drive,
+      operations,
+    );
+    if (result) {
+      return result;
     }
-
-    async addDriveActions(
-        drive: string,
-        actions: (DocumentDriveAction | BaseAction)[],
-        forceSync = true
-    ): Promise<IOperationResult<DocumentDriveDocument>> {
-        const document = await this.getDrive(drive);
-        const operations = this._buildOperations(document, actions);
-        const result = await this.addDriveOperations(
-            drive,
-            operations,
-            forceSync
-        );
-        return result;
+    try {
+      const jobId = await this.queueManager.addJob({
+        driveId: drive,
+        operations,
+        options,
+      });
+      return new Promise<IOperationResult<DocumentDriveDocument>>(
+        (resolve, reject) => {
+          const unsubscribe = this.queueManager.on(
+            "jobCompleted",
+            (job, result) => {
+              if (job.jobId === jobId) {
+                unsubscribe();
+                unsubscribeError();
+                resolve(result as IOperationResult<DocumentDriveDocument>);
+              }
+            },
+          );
+          const unsubscribeError = this.queueManager.on(
+            "jobFailed",
+            (job, error) => {
+              if (job.jobId === jobId) {
+                unsubscribe();
+                unsubscribeError();
+                reject(error);
+              }
+            },
+          );
+        },
+      );
+    } catch (error) {
+      logger.error("Error adding drive job", error);
+      throw error;
+    }
+  }
+
+  async addDriveOperations(
+    drive: string,
+    operations: Operation<DocumentDriveAction | BaseAction>[],
+    options?: AddOperationOptions,
+  ) {
+    let document: DocumentDriveDocument | undefined;
+    const operationsApplied: Operation<DocumentDriveAction | BaseAction>[] = [];
+    const signals: SignalResult[] = [];
+    let error: Error | undefined;
+
+    // if operations are already stored then returns cached drive
+    const result = await this.resultIfExistingDriveOperations(
+      drive,
+      operations,
+    );
+    if (result) {
+      return result;
     }
 
-    async addInternalListener(
-        driveId: string,
-        receiver: IReceiver,
-        options: {
-            listenerId: string;
-            label: string;
-            block: boolean;
-            filter: ListenerFilter;
-        }
-    ) {
-        const listener: AddListenerInput['listener'] = {
-            callInfo: {
-                data: '',
-                name: 'Interal',
-                transmitterType: 'Internal'
-            },
-            system: true,
-            ...options
+    try {
+      await this._addDriveOperations(drive, async (documentStorage) => {
+        const result = await this._processOperations<
+          DocumentDriveDocument,
+          DocumentDriveAction
+        >(drive, undefined, documentStorage, operations.slice());
+        document = result.document;
+        operationsApplied.push(...result.operationsApplied);
+        signals.push(...result.signals);
+        error = result.error;
+
+        return {
+          operations: result.operationsApplied,
+          header: result.document,
         };
-        await this.addDriveAction(driveId, actions.addListener({ listener }));
-        const transmitter = await this.getTransmitter(
-            driveId,
-            options.listenerId
-        );
-        if (!transmitter) {
-            logger.error('Internal listener not found');
-            throw new Error('Internal listener not found');
-        }
-        if (!(transmitter instanceof InternalTransmitter)) {
-            logger.error('Listener is not an internal transmitter');
-            throw new Error('Listener is not an internal transmitter');
+      });
+
+      if (!document || !isDocumentDrive(document)) {
+        throw error ?? new Error("Invalid Document Drive document");
+      }
+
+      this.cache.setDocument("drives", drive, document).catch(logger.error);
+
+      for (const operation of operationsApplied) {
+        switch (operation.type) {
+          case "ADD_LISTENER": {
+            await this.addListener(drive, operation);
+            break;
+          }
+          case "REMOVE_LISTENER": {
+            await this.removeListener(drive, operation);
+            break;
+          }
         }
+      }
+
+      // update listener cache
+      const lastOperation = operationsApplied
+        .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,
+            ),
+        );
 
-        transmitter.setReceiver(receiver);
-        return transmitter;
-    }
+        // 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" });
 
-    private async addListener(
-        driveId: string,
-        operation: Operation<Action<'ADD_LISTENER', AddListenerInput>>
-    ) {
-        const { listener } = operation.input;
-        await this.listenerStateManager.addListener({
-            ...listener,
-            driveId,
-            label: listener.label ?? '',
-            system: listener.system ?? false,
-            filter: {
-                branch: listener.filter.branch ?? [],
-                documentId: listener.filter.documentId ?? [],
-                documentType: listener.filter.documentType ?? [],
-                scope: listener.filter.scope ?? []
+        const operationSource = this.getOperationSource(source);
+
+        this.listenerStateManager
+          .updateSynchronizationRevisions(
+            drive,
+            [
+              {
+                syncId: "0",
+                driveId: drive,
+                documentId: "",
+                scope: "global",
+                branch: "main",
+                documentType: "powerhouse/document-drive",
+                lastUpdated: lastOperation.timestamp,
+                revision: lastOperation.index,
+              },
+            ],
+            source,
+            () => {
+              this.updateSyncUnitStatus(drive, {
+                [operationSource]: "SYNCING",
+              });
             },
-            callInfo: {
-                data: listener.callInfo?.data ?? '',
-                name: listener.callInfo?.name ?? 'PullResponder',
-                transmitterType:
-                    listener.callInfo?.transmitterType ?? 'PullResponder'
+            this.handleListenerError.bind(this),
+            options?.forceSync ?? source.type === "local",
+          )
+          .then((updates) => {
+            if (updates.length) {
+              this.updateSyncUnitStatus(drive, {
+                [operationSource]: "SUCCESS",
+              });
             }
-        });
-    }
+          })
+          .catch((error) => {
+            logger.error("Non handled error updating sync revision", error);
+            this.updateSyncUnitStatus(
+              drive,
+              { [operationSource]: "ERROR" },
+              error as Error,
+            );
+          });
+      }
+
+      if (this.shouldSyncRemoteDrive(document)) {
+        this.startSyncRemoteDrive(document.state.global.id);
+      } else {
+        this.stopSyncRemoteDrive(document.state.global.id);
+      }
+
+      // after applying all the valid operations,throws
+      // an error if there was an invalid operation
+      if (error) {
+        throw error;
+      }
+
+      return {
+        status: "SUCCESS",
+        document,
+        operations: operationsApplied,
+        signals,
+      } satisfies IOperationResult;
+    } catch (error) {
+      const operationError =
+        error instanceof OperationError
+          ? error
+          : new OperationError(
+              "ERROR",
+              undefined,
+              (error as Error).message,
+              (error as Error).cause,
+            );
 
-    private async removeListener(
-        driveId: string,
-        operation: Operation<Action<'REMOVE_LISTENER', RemoveListenerInput>>
-    ) {
-        const { listenerId } = operation.input;
-        await this.listenerStateManager.removeListener(driveId, listenerId);
+      return {
+        status: operationError.status,
+        error: operationError,
+        document,
+        operations: operationsApplied,
+        signals,
+      } satisfies IOperationResult;
     }
-
-    getTransmitter(
-        driveId: string,
-        listenerId: string
-    ): Promise<ITransmitter | undefined> {
-        return this.listenerStateManager.getTransmitter(driveId, listenerId);
+  }
+
+  private _buildOperations<T extends Action>(
+    document: Document,
+    actions: (T | BaseAction)[],
+  ): Operation<T | BaseAction>[] {
+    const operations: Operation<T | BaseAction>[] = [];
+    const { reducer } = this.getDocumentModel(document.documentType);
+    for (const action of actions) {
+      document = reducer(document, action);
+      const operation = document.operations[action.scope].slice().pop();
+      if (!operation) {
+        throw new Error("Error creating operations");
+      }
+      operations.push(operation);
     }
-
-    getListener(
-        driveId: string,
-        listenerId: string
-    ): Promise<ListenerState | undefined> {
-        return this.listenerStateManager.getListener(driveId, listenerId);
+    return operations;
+  }
+
+  async addAction(
+    drive: string,
+    id: string,
+    action: Action,
+    options?: AddOperationOptions,
+  ): Promise<IOperationResult> {
+    return this.addActions(drive, id, [action], options);
+  }
+
+  async addActions(
+    drive: string,
+    id: string,
+    actions: Action[],
+    options?: AddOperationOptions,
+  ): Promise<IOperationResult> {
+    const document = await this.getDocument(drive, id);
+    const operations = this._buildOperations(document, actions);
+    return this.addOperations(drive, id, operations, options);
+  }
+
+  async addDriveAction(
+    drive: string,
+    action: DocumentDriveAction | BaseAction,
+    options?: AddOperationOptions,
+  ): Promise<IOperationResult<DocumentDriveDocument>> {
+    return this.addDriveActions(drive, [action], options);
+  }
+
+  async addDriveActions(
+    drive: string,
+    actions: (DocumentDriveAction | BaseAction)[],
+    options?: AddOperationOptions,
+  ): Promise<IOperationResult<DocumentDriveDocument>> {
+    const document = await this.getDrive(drive);
+    const operations = this._buildOperations(document, actions);
+    const result = await this.addDriveOperations(drive, operations, options);
+    return result;
+  }
+
+  async addInternalListener(
+    driveId: string,
+    receiver: IReceiver,
+    options: {
+      listenerId: string;
+      label: string;
+      block: boolean;
+      filter: ListenerFilter;
+    },
+  ) {
+    const listener: AddListenerInput["listener"] = {
+      callInfo: {
+        data: "",
+        name: "Interal",
+        transmitterType: "Internal",
+      },
+      system: true,
+      ...options,
+    };
+    await this.addDriveAction(driveId, actions.addListener({ listener }));
+    const transmitter = await this.getTransmitter(driveId, options.listenerId);
+    if (!transmitter) {
+      logger.error("Internal listener not found");
+      throw new Error("Internal listener not found");
+    }
+    if (!(transmitter instanceof InternalTransmitter)) {
+      logger.error("Listener is not an internal transmitter");
+      throw new Error("Listener is not an internal transmitter");
     }
 
-    getSyncStatus(drive: string): SyncStatus {
-        const status = this.syncStatus.get(drive);
-        if (!status) {
-            logger.error(`Sync status not found for drive ${drive}`);
-            throw new Error(`Sync status not found for drive ${drive}`);
-        }
-        return status;
+    transmitter.setReceiver(receiver);
+    return transmitter;
+  }
+
+  async detachDrive(driveId: string) {
+    const documentDrive = await this.getDrive(driveId);
+    const listeners = documentDrive.state.local.listeners || [];
+    const triggers = documentDrive.state.local.triggers || [];
+
+    for (const listener of listeners) {
+      await this.addDriveAction(
+        driveId,
+        actions.removeListener({ listenerId: listener.listenerId }),
+      );
     }
 
-    on<K extends keyof DriveEvents>(event: K, cb: DriveEvents[K]): Unsubscribe {
-        return this.emitter.on(event, cb);
+    for (const trigger of triggers) {
+      await this.addDriveAction(
+        driveId,
+        actions.removeTrigger({ triggerId: trigger.id }),
+      );
     }
 
-    protected emit<K extends keyof DriveEvents>(
-        event: K,
-        ...args: Parameters<DriveEvents[K]>
-    ): void {
-        logger.debug(`Emitting event ${event}`, args);
-        return this.emitter.emit(event, ...args);
+    await this.addDriveAction(
+      driveId,
+      actions.setSharingType({ type: "LOCAL" }),
+    );
+  }
+
+  private async addListener(
+    driveId: string,
+    operation: Operation<Action<"ADD_LISTENER", AddListenerInput>>,
+  ) {
+    const { listener } = operation.input;
+    await this.listenerStateManager.addListener({
+      ...listener,
+      driveId,
+      label: listener.label ?? "",
+      system: listener.system ?? false,
+      filter: {
+        branch: listener.filter.branch ?? [],
+        documentId: listener.filter.documentId ?? [],
+        documentType: listener.filter.documentType ?? [],
+        scope: listener.filter.scope ?? [],
+      },
+      callInfo: {
+        data: listener.callInfo?.data ?? "",
+        name: listener.callInfo?.name ?? "PullResponder",
+        transmitterType: listener.callInfo?.transmitterType ?? "PullResponder",
+      },
+    });
+  }
+
+  private async removeListener(
+    driveId: string,
+    operation: Operation<Action<"REMOVE_LISTENER", RemoveListenerInput>>,
+  ) {
+    const { listenerId } = operation.input;
+    await this.listenerStateManager.removeListener(driveId, listenerId);
+  }
+
+  getTransmitter(
+    driveId: string,
+    listenerId: string,
+  ): Promise<ITransmitter | undefined> {
+    return this.listenerStateManager.getTransmitter(driveId, listenerId);
+  }
+
+  getListener(
+    driveId: string,
+    listenerId: string,
+  ): Promise<ListenerState | undefined> {
+    return this.listenerStateManager.getListener(driveId, listenerId);
+  }
+
+  getSyncStatus(
+    syncUnitId: string,
+  ): SyncStatus | SynchronizationUnitNotFoundError {
+    const status = this.syncStatus.get(syncUnitId);
+    if (!status) {
+      return new SynchronizationUnitNotFoundError(
+        `Sync status not found for syncUnitId: ${syncUnitId}`,
+        syncUnitId,
+      );
     }
+    return this.getCombinedSyncUnitStatus(status);
+  }
+
+  on<K extends keyof DriveEvents>(event: K, cb: DriveEvents[K]): Unsubscribe {
+    return this.emitter.on(event, cb);
+  }
+
+  protected emit<K extends keyof DriveEvents>(
+    event: K,
+    ...args: Parameters<DriveEvents[K]>
+  ): void {
+    logger.debug(`Emitting event ${event}`, args);
+    return this.emitter.emit(event, ...args);
+  }
 }
+
+export const DocumentDriveServer = ReadModeServer(BaseDocumentDriveServer);