document-drive 1.17.2 → 1.18.0

package/src/server/types.ts

@@ -22,15 +22,15 @@ import type {
 } from "document-model/document";
 import { Unsubscribe } from "nanoevents";
 import { BaseDocumentDriveServer } from ".";
-import {
-  IReceiver as IInternalListener,
-  IInternalTransmitter,
-} from "./listener/transmitter/internal";
 import { IReadModeDriveServer } from "../read-mode/types";
 import { RunAsap } from "../utils";
 import { IDefaultDrivesManager } from "../utils/default-drives-manager";
 import { DriveInfo } from "../utils/graphql";
 import { OperationError, SynchronizationUnitNotFoundError } from "./error";
+import {
+  IReceiver as IInternalListener,
+  IInternalTransmitter,
+} from "./listener/transmitter/internal";
 import {
   ITransmitter,
   PullResponderTrigger,
@@ -105,6 +105,7 @@ export type Listener = {
   system: boolean;
   filter: ListenerFilter;
   callInfo?: ListenerCallInfo;
+  transmitter?: ITransmitter;
 };
 
 export type CreateListenerInput = {
@@ -317,137 +318,150 @@ export type GetStrandsOptions = {
   fromRevision?: number;
 };
 
-export abstract class AbstractDocumentDriveServer {
-  /** Public methods **/
-  abstract initialize(): Promise<Error[] | null>;
-  abstract setDocumentModels(models: DocumentModel[]): void;
-  abstract getDrives(): Promise<string[]>;
-  abstract addDrive(drive: DriveInput): Promise<DocumentDriveDocument>;
-  abstract addRemoteDrive(
+export type ListenerManagerOptions = {
+  sequentialUpdates?: boolean;
+};
+
+export const DefaultListenerManagerOptions = {
+  sequentialUpdates: true,
+};
+
+type PublicKeys<T> = {
+  [K in keyof T]: T extends { [P in K]: T[K] } ? K : never;
+}[keyof T];
+
+type PublicPart<T> = Pick<T, PublicKeys<T>>;
+
+export interface IBaseDocumentDriveServer {
+  initialize(): Promise<Error[] | null>;
+  setDocumentModels(models: DocumentModel[]): void;
+  getDrives(): Promise<string[]>;
+  addDrive(input: DriveInput): Promise<DocumentDriveDocument>;
+  addRemoteDrive(
     url: string,
     options: RemoteDriveOptions,
   ): Promise<DocumentDriveDocument>;
-  abstract deleteDrive(id: string): Promise<void>;
-  abstract getDrive(
-    id: string,
+  deleteDrive(driveId: string): Promise<void>;
+  getDrive(
+    driveId: string,
     options?: GetDocumentOptions,
   ): Promise<DocumentDriveDocument>;
 
-  abstract getDriveBySlug(slug: string): Promise<DocumentDriveDocument>;
+  getDriveBySlug(slug: string): Promise<DocumentDriveDocument>;
 
-  abstract getDocuments(drive: string): Promise<string[]>;
-  abstract getDocument(
-    drive: string,
-    id: string,
+  getDocuments(driveId: string): Promise<string[]>;
+  getDocument(
+    driveId: string,
+    documentId: string,
     options?: GetDocumentOptions,
   ): Promise<Document>;
 
-  abstract addOperation(
-    drive: string,
-    id: string,
+  addOperation(
+    driveId: string,
+    documentId: string,
     operation: Operation,
     options?: AddOperationOptions,
   ): Promise<IOperationResult>;
 
-  abstract addOperations(
-    drive: string,
-    id: string,
+  addOperations(
+    driveId: string,
+    documentId: string,
     operations: Operation[],
     options?: AddOperationOptions,
   ): Promise<IOperationResult>;
 
-  abstract queueOperation(
-    drive: string,
-    id: string,
+  queueOperation(
+    driveId: string,
+    documentId: string,
     operation: Operation,
     options?: AddOperationOptions,
   ): Promise<IOperationResult>;
 
-  abstract queueOperations(
-    drive: string,
-    id: string,
+  queueOperations(
+    driveId: string,
+    documentId: string,
     operations: Operation[],
     options?: AddOperationOptions,
   ): Promise<IOperationResult>;
 
-  abstract queueAction(
-    drive: string,
-    id: string,
+  queueAction(
+    driveId: string,
+    documentId: string,
     action: Action,
     options?: AddOperationOptions,
   ): Promise<IOperationResult>;
 
-  abstract queueActions(
-    drive: string,
-    id: string,
+  queueActions(
+    driveId: string,
+    documentId: string,
     actions: Action[],
     options?: AddOperationOptions,
   ): Promise<IOperationResult>;
 
-  abstract addDriveOperation(
-    drive: string,
+  addDriveOperation(
+    driveId: string,
     operation: Operation<DocumentDriveAction | BaseAction>,
     options?: AddOperationOptions,
   ): Promise<IOperationResult<DocumentDriveDocument>>;
-  abstract addDriveOperations(
-    drive: string,
+  addDriveOperations(
+    driveId: string,
     operations: Operation<DocumentDriveAction | BaseAction>[],
     options?: AddOperationOptions,
   ): Promise<IOperationResult<DocumentDriveDocument>>;
 
-  abstract queueDriveOperation(
-    drive: string,
+  queueDriveOperation(
+    driveId: string,
     operation: Operation<DocumentDriveAction | BaseAction>,
     options?: AddOperationOptions,
   ): Promise<IOperationResult<DocumentDriveDocument>>;
 
-  abstract queueDriveOperations(
-    drive: string,
+  queueDriveOperations(
+    driveId: string,
     operations: Operation<DocumentDriveAction | BaseAction>[],
     options?: AddOperationOptions,
   ): Promise<IOperationResult<DocumentDriveDocument>>;
 
-  abstract queueDriveAction(
-    drive: string,
+  queueDriveAction(
+    driveId: string,
     action: DocumentDriveAction | BaseAction,
     options?: AddOperationOptions,
   ): Promise<IOperationResult<DocumentDriveDocument>>;
 
-  abstract queueDriveActions(
-    drive: string,
+  queueDriveActions(
+    driveId: string,
     actions: Array<DocumentDriveAction | BaseAction>,
     options?: AddOperationOptions,
   ): Promise<IOperationResult<DocumentDriveDocument>>;
 
-  abstract addAction(
-    drive: string,
-    id: string,
+  addAction(
+    driveId: string,
+    documentId: string,
     action: Action,
     options?: AddOperationOptions,
   ): Promise<IOperationResult>;
-  abstract addActions(
-    drive: string,
-    id: string,
+  addActions(
+    driveId: string,
+    documentId: string,
     actions: Action[],
     options?: AddOperationOptions,
   ): Promise<IOperationResult>;
 
-  abstract addDriveAction(
-    drive: string,
+  addDriveAction(
+    driveId: string,
     action: DocumentDriveAction | BaseAction,
     options?: AddOperationOptions,
   ): Promise<IOperationResult<DocumentDriveDocument>>;
-  abstract addDriveActions(
-    drive: string,
+  addDriveActions(
+    driveId: string,
     actions: (DocumentDriveAction | BaseAction)[],
     options?: AddOperationOptions,
   ): Promise<IOperationResult<DocumentDriveDocument>>;
 
-  abstract getSyncStatus(
+  getSyncStatus(
     syncUnitId: string,
   ): SyncStatus | SynchronizationUnitNotFoundError;
 
-  abstract addInternalListener(
+  addInternalListener(
     driveId: string,
     receiver: IInternalListener,
     options: {
@@ -459,7 +473,7 @@ export abstract class AbstractDocumentDriveServer {
   ): Promise<IInternalTransmitter>;
 
   /** Synchronization methods */
-  abstract getSynchronizationUnits(
+  getSynchronizationUnits(
     driveId: string,
     documentId?: string[],
     scope?: string[],
@@ -468,13 +482,13 @@ export abstract class AbstractDocumentDriveServer {
     loadedDrive?: DocumentDriveDocument,
   ): Promise<SynchronizationUnit[]>;
 
-  abstract getSynchronizationUnit(
+  getSynchronizationUnit(
     driveId: string,
     syncId: string,
     loadedDrive?: DocumentDriveDocument,
   ): Promise<SynchronizationUnit | undefined>;
 
-  abstract getSynchronizationUnitsIds(
+  getSynchronizationUnitsIds(
     driveId: string,
     documentId?: string[],
     scope?: string[],
@@ -482,7 +496,7 @@ export abstract class AbstractDocumentDriveServer {
     documentType?: string[],
   ): Promise<SynchronizationUnitQuery[]>;
 
-  abstract getOperationData(
+  getOperationData(
     driveId: string,
     syncId: string,
     filter: GetStrandsOptions,
@@ -490,117 +504,73 @@ export abstract class AbstractDocumentDriveServer {
   ): Promise<OperationUpdate[]>;
 
   /** Internal methods **/
-  protected abstract createDocument(
-    drive: string,
-    document: CreateDocumentInput,
-  ): Promise<Document>;
-  protected abstract deleteDocument(drive: string, id: string): Promise<void>;
-
-  protected abstract getDocumentModel(documentType: string): DocumentModel;
-  abstract getDocumentModels(): DocumentModel[];
-
-  /** Event methods **/
-  protected abstract emit<K extends keyof DriveEvents>(
-    event: K,
-    ...args: Parameters<DriveEvents[K]>
-  ): void;
-  abstract on<K extends keyof DriveEvents>(
-    event: K,
-    cb: DriveEvents[K],
-  ): Unsubscribe;
-
-  abstract getTransmitter(
+  getDocumentModels(): DocumentModel[];
+
+  getTransmitter(
     driveId: string,
     listenerId: string,
   ): Promise<ITransmitter | undefined>;
 
-  abstract clearStorage(): Promise<void>;
+  clearStorage(): Promise<void>;
 
-  abstract registerPullResponderTrigger(
+  registerPullResponderTrigger(
     id: string,
     url: string,
     options: Pick<RemoteDriveOptions, "pullFilter" | "pullInterval">,
   ): Promise<PullResponderTrigger>;
-}
-
-export type ListenerManagerOptions = {
-  sequentialUpdates?: boolean;
-};
-
-export const DefaultListenerManagerOptions = {
-  sequentialUpdates: true,
-};
-
-type PublicKeys<T> = {
-  [K in keyof T]: T extends { [P in K]: T[K] } ? K : never;
-}[keyof T];
-
-type PublicPart<T> = Pick<T, PublicKeys<T>>;
 
-export type IBaseDocumentDriveServer = PublicPart<AbstractDocumentDriveServer>;
+  on<K extends keyof DriveEvents>(event: K, cb: DriveEvents[K]): Unsubscribe;
+}
 
 export type IDocumentDriveServer = IBaseDocumentDriveServer &
   IDefaultDrivesManager &
   IReadModeDriveServer;
 
-export abstract class BaseListenerManager {
-  protected drive: IBaseDocumentDriveServer;
-  protected listenerState = new Map<string, Map<string, ListenerState>>();
-  protected options: ListenerManagerOptions;
-  protected transmitters: Record<
-    DocumentDriveState["id"],
-    Record<Listener["listenerId"], ITransmitter>
-  > = {};
-
-  constructor(
-    drive: IBaseDocumentDriveServer,
-    listenerState = new Map<string, Map<string, ListenerState>>(),
-    options: ListenerManagerOptions = DefaultListenerManagerOptions,
-  ) {
-    this.drive = drive;
-    this.listenerState = listenerState;
-    this.options = { ...DefaultListenerManagerOptions, ...options };
-  }
-
-  abstract initDrive(drive: DocumentDriveDocument): Promise<void>;
-  abstract removeDrive(driveId: DocumentDriveState["id"]): Promise<void>;
-
-  abstract driveHasListeners(driveId: string): boolean;
-  abstract addListener(listener: Listener): Promise<ITransmitter>;
-  abstract removeListener(
-    driveId: string,
-    listenerId: string,
-  ): Promise<boolean>;
-  abstract getListener(
-    driveId: string,
-    listenerId: string,
-  ): Promise<ListenerState | undefined>;
+export type DriveUpdateErrorHandler = (
+  error: Error,
+  driveId: string,
+  listener: ListenerState,
+) => void;
 
-  abstract getTransmitter(
-    driveId: string,
-    listenerId: string,
-  ): Promise<ITransmitter | undefined>;
+export interface IListenerManager {
+  initialize(handler: DriveUpdateErrorHandler): Promise<void>;
 
-  abstract getStrands(
+  removeDrive(driveId: DocumentDriveState["id"]): Promise<void>;
+  driveHasListeners(driveId: string): boolean;
+
+  setListener(driveId: string, listener: Listener): Promise<void>;
+  removeListener(driveId: string, listenerId: string): Promise<boolean>;
+  getListenerState(driveId: string, listenerId: string): ListenerState;
+
+  getStrands(
     driveId: string,
     listenerId: string,
     options?: GetStrandsOptions,
   ): Promise<StrandUpdate[]>;
-
-  abstract updateSynchronizationRevisions(
+  updateSynchronizationRevisions(
     driveId: string,
     syncUnits: SynchronizationUnit[],
     source: StrandUpdateSource,
     willUpdate?: (listeners: Listener[]) => void,
     onError?: (error: Error, driveId: string, listener: ListenerState) => void,
+    forceSync?: boolean,
   ): Promise<ListenerUpdate[]>;
-
-  abstract updateListenerRevision(
+  updateListenerRevision(
     listenerId: string,
     driveId: string,
     syncId: string,
     listenerRev: number,
   ): Promise<void>;
+
+  // todo: re-evaluate
+  getListenerSyncUnitIds(
+    driveId: string,
+    listenerId: string,
+  ): Promise<SynchronizationUnitQuery[]>;
+  removeSyncUnits(
+    driveId: string,
+    syncUnits: Pick<SynchronizationUnit, "syncId">[],
+  ): Promise<void>;
 }
 
 export type ListenerStatus =