document-drive 0.0.27 → 0.0.29

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

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

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

@@ -0,0 +1,18 @@
+import {
+    PullResponderTriggerData,
+    Trigger
+} from 'document-model-libs/document-drive';
+import { ListenerRevision, StrandUpdate } from '../..';
+
+export interface ITransmitter {
+    transmit(strands: StrandUpdate[]): Promise<ListenerRevision[]>;
+}
+
+export interface InternalTransmitterService extends ITransmitter {
+    getName(): string;
+}
+
+export type PullResponderTrigger = Omit<Trigger, 'data' | 'type'> & {
+    data: PullResponderTriggerData;
+    type: 'PullResponder';
+};

package/src/server/types.ts

@@ -2,68 +2,254 @@ import type {
     DocumentDriveAction,
     DocumentDriveDocument,
     DocumentDriveLocalState,
-    DocumentDriveState
+    DocumentDriveState,
+    ListenerCallInfo,
+    ListenerFilter
 } from 'document-model-libs/document-drive';
 import type {
     BaseAction,
+    CreateChildDocumentInput,
     Document,
     Operation,
+    OperationScope,
     Signal,
     State
 } from 'document-model/document';
+import { OperationError } from './error';
+import { ITransmitter } from './listener/transmitter/types';
 
 export type DriveInput = State<
-    Omit<DocumentDriveState, '__typename' | 'nodes'>,
+    Omit<DocumentDriveState, '__typename' | 'id' | 'nodes'> & { id?: string },
     DocumentDriveLocalState
 >;
 
-export type CreateDocumentInput = {
-    id: string;
-    documentType: string;
-    document?: Document;
+export type RemoteDriveOptions = DocumentDriveLocalState & {
+    // TODO make local state optional
+    pullFilter?: ListenerFilter;
+    pullInterval?: number;
 };
 
+export type CreateDocumentInput = CreateChildDocumentInput;
+
 export type SignalResult = {
     signal: Signal;
     result: unknown; // infer from return types on document-model
 };
 
 export type IOperationResult<T extends Document = Document> = {
-    success: boolean;
-    error?: Error;
+    status: UpdateStatus;
+    error?: OperationError;
     operations: Operation[];
     document: T | undefined;
     signals: SignalResult[];
 };
 
-export interface IDocumentDriveServer {
-    getDrives(): Promise<string[]>;
-    addDrive(drive: DriveInput): Promise<void>;
-    deleteDrive(id: string): Promise<void>;
-    getDrive(id: string): Promise<DocumentDriveDocument>;
+export type SynchronizationUnit = {
+    syncId: string;
+    driveId: string;
+    documentId: string;
+    documentType: string;
+    scope: string;
+    branch: string;
+    lastUpdated: string;
+    revision: number;
+};
+
+export type Listener = {
+    driveId: string;
+    listenerId: string;
+    label?: string;
+    block: boolean;
+    system: boolean;
+    filter: ListenerFilter;
+    callInfo?: ListenerCallInfo;
+};
+
+export type CreateListenerInput = {
+    driveId: string;
+    label?: string;
+    block: boolean;
+    system: boolean;
+    filter: ListenerFilter;
+    callInfo?: ListenerCallInfo;
+};
+
+export enum TransmitterType {
+    Internal,
+    SwitchboardPush,
+    PullResponder,
+    SecureConnect,
+    MatrixConnect,
+    RESTWebhook
+}
+
+export type ListenerRevision = {
+    driveId: string;
+    documentId: string;
+    scope: string;
+    branch: string;
+    status: UpdateStatus;
+    revision: number;
+};
+
+export type UpdateStatus = 'SUCCESS' | 'CONFLICT' | 'MISSING' | 'ERROR';
+export type ErrorStatus = Exclude<UpdateStatus, 'SUCCESS'>;
+
+export type OperationUpdate = {
+    timestamp: string;
+    index: number;
+    skip: number;
+    type: string;
+    input: object;
+    hash: string;
+};
+
+export type StrandUpdate = {
+    driveId: string;
+    documentId: string;
+    scope: OperationScope;
+    branch: string;
+    operations: OperationUpdate[];
+};
+
+export type SyncStatus = 'SYNCING' | UpdateStatus;
+
+export abstract class BaseDocumentDriveServer {
+    /** Public methods **/
+    abstract getDrives(): Promise<string[]>;
+    abstract addDrive(drive: DriveInput): Promise<void>;
+    abstract addRemoteDrive(
+        url: string,
+        options: RemoteDriveOptions
+    ): Promise<void>;
+    abstract deleteDrive(id: string): Promise<void>;
+    abstract getDrive(id: string): Promise<DocumentDriveDocument>;
 
-    getDocuments: (drive: string) => Promise<string[]>;
-    getDocument: (drive: string, id: string) => Promise<Document>;
-    createDocument(drive: string, document: CreateDocumentInput): Promise<void>;
-    deleteDocument(drive: string, id: string): Promise<void>;
+    abstract getDocuments(drive: string): Promise<string[]>;
+    abstract getDocument(drive: string, id: string): Promise<Document>;
 
-    addOperation(
+    abstract addOperation(
         drive: string,
         id: string,
         operation: Operation
-    ): Promise<IOperationResult>;
-    addOperations(
+    ): Promise<IOperationResult<Document>>;
+    abstract addOperations(
         drive: string,
         id: string,
         operations: Operation[]
-    ): Promise<IOperationResult>;
+    ): Promise<IOperationResult<Document>>;
 
-    addDriveOperation(
+    abstract addDriveOperation(
         drive: string,
         operation: Operation<DocumentDriveAction | BaseAction>
     ): Promise<IOperationResult<DocumentDriveDocument>>;
-    addDriveOperations(
+    abstract addDriveOperations(
         drive: string,
         operations: Operation<DocumentDriveAction | BaseAction>[]
     ): Promise<IOperationResult<DocumentDriveDocument>>;
+
+    abstract getSyncStatus(drive: string): SyncStatus;
+
+    /** Synchronization methods */
+    abstract getSynchronizationUnits(
+        driveId: string,
+        documentId?: string[],
+        scope?: string[],
+        branch?: string[]
+    ): Promise<SynchronizationUnit[]>;
+
+    abstract getSynchronizationUnit(
+        driveId: string,
+        syncId: string
+    ): Promise<SynchronizationUnit>;
+
+    abstract getOperationData(
+        driveId: string,
+        syncId: string,
+        filter: {
+            since?: string;
+            fromRevision?: number;
+        }
+    ): Promise<OperationUpdate[]>;
+
+    /** Internal methods **/
+    protected abstract createDocument(
+        drive: string,
+        document: CreateDocumentInput
+    ): Promise<Document>;
+    protected abstract deleteDocument(drive: string, id: string): Promise<void>;
+
+    abstract getTransmitter(
+        driveId: string,
+        listenerId: string
+    ): Promise<ITransmitter | undefined>;
+}
+
+export abstract class BaseListenerManager {
+    protected drive: BaseDocumentDriveServer;
+    protected listenerState: Map<string, Map<string, ListenerState>> =
+        new Map();
+    protected transmitters: Record<
+        DocumentDriveState['id'],
+        Record<Listener['listenerId'], ITransmitter>
+    > = {};
+
+    constructor(
+        drive: BaseDocumentDriveServer,
+        listenerState: Map<string, Map<string, ListenerState>> = new Map()
+    ) {
+        this.drive = drive;
+        this.listenerState = listenerState;
+    }
+
+    abstract init(): Promise<void>;
+    abstract addListener(listener: Listener): Promise<ITransmitter>;
+    abstract removeListener(
+        driveId: string,
+        listenerId: string
+    ): Promise<boolean>;
+    abstract getTransmitter(
+        driveId: string,
+        listenerId: string
+    ): Promise<ITransmitter | undefined>;
+    abstract updateSynchronizationRevision(
+        driveId: string,
+        syncId: string,
+        syncRev: number,
+        lastUpdated: string
+    ): Promise<void>;
+
+    abstract updateListenerRevision(
+        listenerId: string,
+        driveId: string,
+        syncId: string,
+        listenerRev: number
+    ): Promise<void>;
+}
+
+export type IDocumentDriveServer = Pick<
+    BaseDocumentDriveServer,
+    keyof BaseDocumentDriveServer
+>;
+
+export type ListenerStatus =
+    | 'CREATED'
+    | 'PENDING'
+    | 'SUCCESS'
+    | 'MISSING'
+    | 'CONFLICT'
+    | 'ERROR';
+
+export interface ListenerState {
+    driveId: string;
+    block: boolean;
+    pendingTimeout: string;
+    listener: Listener;
+    syncUnits: SyncronizationUnitState[];
+    listenerStatus: ListenerStatus;
+}
+
+export interface SyncronizationUnitState extends SynchronizationUnit {
+    listenerRev: number;
+    syncRev: number;
 }

package/src/storage/browser.ts

@@ -5,7 +5,7 @@ import {
     DocumentHeader,
     Operation
 } from 'document-model/document';
-import { mergeOperations } from '..';
+import { applyUpdatedOperations, mergeOperations } from '..';
 import { DocumentDriveStorage, DocumentStorage, IDriveStorage } from './types';
 
 export class BrowserStorage implements IDriveStorage {
@@ -57,7 +57,8 @@ export class BrowserStorage implements IDriveStorage {
         drive: string,
         id: string,
         operations: Operation[],
-        header: DocumentHeader
+        header: DocumentHeader,
+        updatedOperations: Operation[] = []
     ): Promise<void> {
         const document = await this.getDocument(drive, id);
         if (!document) {
@@ -69,12 +70,17 @@ export class BrowserStorage implements IDriveStorage {
             operations
         );
 
+        const mergedUpdatedOperations = applyUpdatedOperations(
+            mergedOperations,
+            updatedOperations
+        );
+
         await (
             await this.db
         ).setItem(this.buildKey(drive, id), {
             ...document,
             ...header,
-            operations: mergedOperations
+            operations: mergedUpdatedOperations
         });
     }
 

package/src/storage/filesystem.ts

@@ -9,9 +9,10 @@ import {
     writeFileSync
 } from 'fs';
 import fs from 'fs/promises';
+import stringify from 'json-stringify-deterministic';
 import path from 'path';
 import sanitize from 'sanitize-filename';
-import { mergeOperations } from '..';
+import { applyUpdatedOperations, mergeOperations } from '..';
 import { DocumentDriveStorage, DocumentStorage, IDriveStorage } from './types';
 
 type FSError = {
@@ -83,7 +84,6 @@ export class FilesystemStorage implements IDriveStorage {
             });
             return JSON.parse(content) as Promise<DocumentStorage>;
         } catch (error) {
-            console.error(error);
             throw new Error(`Document with id ${id} not found`);
         }
     }
@@ -91,7 +91,7 @@ export class FilesystemStorage implements IDriveStorage {
     async createDocument(drive: string, id: string, document: DocumentStorage) {
         const documentPath = this._buildDocumentPath(drive, id);
         await ensureDir(path.dirname(documentPath));
-        await writeFileSync(documentPath, JSON.stringify(document), {
+        await writeFileSync(documentPath, stringify(document), {
             encoding: 'utf-8'
         });
     }
@@ -104,7 +104,8 @@ export class FilesystemStorage implements IDriveStorage {
         drive: string,
         id: string,
         operations: Operation[],
-        header: DocumentHeader
+        header: DocumentHeader,
+        updatedOperations: Operation[] = []
     ) {
         const document = await this.getDocument(drive, id);
         if (!document) {
@@ -116,10 +117,15 @@ export class FilesystemStorage implements IDriveStorage {
             operations
         );
 
+        const mergedUpdatedOperations = applyUpdatedOperations(
+            mergedOperations,
+            updatedOperations
+        );
+
         this.createDocument(drive, id, {
             ...document,
             ...header,
-            operations: mergedOperations
+            operations: mergedUpdatedOperations
         });
     }
 

package/src/storage/index.ts

@@ -1,5 +1 @@
-export { BrowserStorage } from './browser';
-export { FilesystemStorage } from './filesystem';
-export { MemoryStorage } from './memory';
-export { PrismaStorage } from './prisma';
 export type * from './types';

package/src/storage/memory.ts

@@ -5,7 +5,7 @@ import {
     DocumentHeader,
     Operation
 } from 'document-model/document';
-import { mergeOperations } from '..';
+import { applyUpdatedOperations, mergeOperations } from '..';
 import { DocumentDriveStorage, DocumentStorage, IDriveStorage } from './types';
 
 export class MemoryStorage implements IDriveStorage {
@@ -30,6 +30,7 @@ export class MemoryStorage implements IDriveStorage {
         if (!document) {
             throw new Error(`Document with id ${id} not found`);
         }
+
         return document;
     }
 
@@ -47,7 +48,8 @@ export class MemoryStorage implements IDriveStorage {
             revision,
             documentType,
             created,
-            lastModified
+            lastModified,
+            clipboard
         } = document;
         this.documents[drive]![id] = {
             operations,
@@ -56,7 +58,8 @@ export class MemoryStorage implements IDriveStorage {
             revision,
             documentType,
             created,
-            lastModified
+            lastModified,
+            clipboard
         };
     }
 
@@ -64,7 +67,8 @@ export class MemoryStorage implements IDriveStorage {
         drive: string,
         id: string,
         operations: Operation[],
-        header: DocumentHeader
+        header: DocumentHeader,
+        updatedOperations: Operation[] = []
     ): Promise<void> {
         const document = await this.getDocument(drive, id);
         if (!document) {
@@ -76,10 +80,15 @@ export class MemoryStorage implements IDriveStorage {
             operations
         );
 
+        const mergedUpdatedOperations = applyUpdatedOperations(
+            mergedOperations,
+            updatedOperations
+        );
+
         this.documents[drive]![id] = {
             ...document,
             ...header,
-            operations: mergedOperations
+            operations: mergedUpdatedOperations
         };
     }