document-drive 1.0.0-alpha.70 → 1.0.0-alpha.71

package/package.json

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

package/src/queue/base.ts

@@ -1,8 +1,7 @@
-import { IJob, IJobQueue, IQueue, IQueueManager, IServerDelegate, JobId, OperationJob, QueueEvents } from "./types";
+import { IJob, IJobQueue, IQueue, IQueueManager, IServerDelegate, JobId, Job, QueueEvents, isOperationJob } from "./types";
 import { generateUUID } from "../utils";
-import { IOperationResult } from "../server";
 import { createNanoEvents, Unsubscribe } from 'nanoevents';
-import { Operation } from "document-model/document";
+import { Action } from "document-model/document";
 import { AddFileInput, DeleteNodeInput } from "document-model-libs/document-drive";
 
 export class MemoryQueue<T, R> implements IQueue<T, R> {
@@ -10,7 +9,7 @@ export class MemoryQueue<T, R> implements IQueue<T, R> {
     private blocked = false;
     private deleted = false;
     private items: IJob<T>[] = [];
-    private dependencies = new Array<IJob<OperationJob>>();
+    private dependencies = new Array<IJob<Job>>();
 
     constructor(id: string) {
         this.id = id;
@@ -54,7 +53,7 @@ export class MemoryQueue<T, R> implements IQueue<T, R> {
         return this.items;
     }
 
-    async addDependencies(job: IJob<OperationJob>) {
+    async addDependencies(job: IJob<Job>) {
         if (!this.dependencies.find(j => j.jobId === job.jobId)) {
             this.dependencies.push(job);
         }
@@ -63,7 +62,7 @@ export class MemoryQueue<T, R> implements IQueue<T, R> {
         }
     }
 
-    async removeDependencies(job: IJob<OperationJob>) {
+    async removeDependencies(job: IJob<Job>) {
         this.dependencies = this.dependencies.filter((j) => j.jobId !== job.jobId && j.driveId !== job.driveId);
         if (this.dependencies.length === 0) {
             await this.setBlocked(false);
@@ -92,7 +91,7 @@ export class BaseQueueManager implements IQueueManager {
         return Promise.resolve()
     }
 
-    async addJob(job: OperationJob): Promise<JobId> {
+    async addJob(job: Job): Promise<JobId> {
         if (!this.delegate) {
             throw new Error("No server delegate defined");
         }
@@ -115,7 +114,8 @@ export class BaseQueueManager implements IQueueManager {
             const driveQueue = this.getQueue(job.driveId);
             const jobs = await driveQueue.getJobs();
             for (const driveJob of jobs) {
-                const op = driveJob.operations.find((j: Operation) => {
+                const actions = isOperationJob(driveJob) ? driveJob.operations : driveJob.actions;
+                const op = actions.find((j: Action) => {
                     const input = j.input as AddFileInput;
                     return j.type === "ADD_FILE" && input.id === job.documentId
                 })
@@ -127,7 +127,8 @@ export class BaseQueueManager implements IQueueManager {
 
         // if it has ADD_FILE operations then adds the job as
         // a dependency to the corresponding document queues
-        const addFileOps = job.operations.filter((j: Operation) => j.type === "ADD_FILE");
+        const actions = isOperationJob(job) ? job.operations : job.actions;
+        const addFileOps = actions.filter((j: Action) => j.type === "ADD_FILE");
         for (const addFileOp of addFileOps) {
             const input = addFileOp.input as AddFileInput;
             const q = this.getQueue(job.driveId, input.id)
@@ -135,7 +136,7 @@ export class BaseQueueManager implements IQueueManager {
         }
 
         // remove document if operations contains delete_node
-        const removeFileOps = job.operations.filter((j: Operation) => j.type === "DELETE_NODE");
+        const removeFileOps = actions.filter((j: Action) => j.type === "DELETE_NODE");
         for (const removeFileOp of removeFileOps) {
             const input = removeFileOp.input as DeleteNodeInput;
             const queue = this.getQueue(job.driveId, input.id);
@@ -221,17 +222,17 @@ export class BaseQueueManager implements IQueueManager {
         }
 
         try {
-            const result = await this.delegate.processOperationJob(nextJob);
+            const result = await this.delegate.processJob(nextJob);
 
             // unblock the document queues of each add_file operation
-            const addFileOperations = nextJob.operations.filter((op) => op.type === "ADD_FILE");
-            if (addFileOperations.length > 0) {
-                addFileOperations.map(async (addFileOp) => {
-                    const documentQueue = this.getQueue(nextJob.driveId, (addFileOp.input as AddFileInput).id);
+            const actions = isOperationJob(nextJob) ? nextJob.operations : nextJob.actions;
+            const addFileActions = actions.filter((op) => op.type === "ADD_FILE");
+            if (addFileActions.length > 0) {
+                for (const addFile of addFileActions) {
+                    const documentQueue = this.getQueue(nextJob.driveId, (addFile.input as AddFileInput).id);
                     await documentQueue.removeDependencies(nextJob);
-                });
+                };
             }
-
             this.emit("jobCompleted", nextJob, result);
         } catch (e) {
             this.emit("jobFailed", nextJob, e as Error);

package/src/queue/redis.ts

@@ -20,9 +20,9 @@ export class RedisQueue<T, R> implements IQueue<T, R> {
     async getNextJob() {
         const job = await this.client.rPop(this.id + "-jobs");
         if (!job) {
-            return null;
+            return undefined;
         }
-        return JSON.parse(job);
+        return JSON.parse(job) as IJob<T>;
     }
 
     async amountOfJobs() {
@@ -52,7 +52,7 @@ export class RedisQueue<T, R> implements IQueue<T, R> {
 
     async getJobs() {
         const entries = await this.client.lRange(this.id + "-jobs", 0, -1)
-        return entries.map(e => JSON.parse(e));
+        return entries.map(e => JSON.parse(e) as IJob<T>);
     }
 
     async addDependencies(job: IJob<OperationJob>) {

package/src/queue/types.ts

@@ -1,31 +1,42 @@
-import { Operation } from "document-model/document";
+import { Action, Operation } from "document-model/document";
 import { IOperationResult } from "../server";
 import type { Unsubscribe } from "nanoevents";
 
-export type OperationJob = {
+export interface BaseJob {
     driveId: string;
     documentId?: string
-    operations: Operation[]
+    actions?: Action[]
     forceSync?: boolean
 }
 
+export interface OperationJob extends BaseJob {
+    operations: Operation[]
+}
+
+export interface ActionJob extends BaseJob {
+    actions: Action[]
+}
+
+export type Job = OperationJob | ActionJob;
+
 export type JobId = string;
 
 export interface QueueEvents {
-    jobCompleted: (job: IJob<OperationJob>, result: IOperationResult) => void;
-    jobFailed: (job: IJob<OperationJob>, error: Error) => void;
+    jobCompleted: (job: IJob<Job>, result: IOperationResult) => void;
+    jobFailed: (job: IJob<Job>, error: Error) => void;
+    queueRemoved: (queueId: string) => void;
 }
 
 export interface IServerDelegate {
     checkDocumentExists: (driveId: string, documentId: string) => Promise<boolean>;
-    processOperationJob: (job: OperationJob) => Promise<IOperationResult>;
-}
+    processJob: (job: Job) => Promise<IOperationResult>;
+};
 
 export interface IQueueManager {
-    addJob(job: OperationJob): Promise<JobId>;
-    getQueue(driveId: string, document?: string): IQueue<OperationJob, IOperationResult>;
+    addJob(job: Job): Promise<JobId>;
+    getQueue(driveId: string, document?: string): IQueue<Job, IOperationResult>;
     removeQueue(driveId: string, documentId?: string): void;
-    getQueueByIndex(index: number): IQueue<OperationJob, IOperationResult> | null;
+    getQueueByIndex(index: number): IQueue<Job, IOperationResult> | null;
     getQueues(): string[];
     init(delegate: IServerDelegate, onError: (error: Error) => void): Promise<void>;
     on<K extends keyof QueueEvents>(
@@ -47,8 +58,16 @@ export interface IQueue<T, R> {
     isDeleted(): Promise<boolean>;
     setDeleted(deleted: boolean): Promise<void>;
     getJobs(): Promise<IJob<T>[]>;
-    addDependencies(job: IJob<OperationJob>): Promise<void>;
-    removeDependencies(job: IJob<OperationJob>): Promise<void>;
+    addDependencies(job: IJob<Job>): Promise<void>;
+    removeDependencies(job: IJob<Job>): Promise<void>;
+}
+
+export type IJobQueue = IQueue<Job, IOperationResult>;
+
+export function isOperationJob(job: Job): job is OperationJob {
+    return "operations" in job;
 }
 
-export type IJobQueue = IQueue<OperationJob, IOperationResult>;
+export function isActionJob(job: Job): job is ActionJob {
+    return "actions" in job;
+}

package/src/server/index.ts

@@ -70,7 +70,7 @@ import {
 } from './types';
 import { filterOperationsByRevision } from './utils';
 import { BaseQueueManager } from '../queue/base';
-import { IQueueManager } from '../queue/types';
+import { ActionJob, IQueueManager, isActionJob, isOperationJob, Job, OperationJob } from '../queue/types';
 
 export * from './listener';
 export type * from './types';
@@ -232,6 +232,25 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
         return this.triggerMap.delete(driveId);
     }
 
+    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);
+            }
+        }
+    };
+
     async initialize() {
         const errors: Error[] = [];
         const drives = await this.getDrives();
@@ -242,13 +261,7 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
             });
         }
 
-        await this.queueManager.init({
-            checkDocumentExists: (driveId: string, documentId: string): Promise<boolean> => this.storage.checkDocumentExists(driveId, documentId),
-            processOperationJob: ({ driveId, documentId, operations, forceSync }) => documentId ?
-                this.addOperations(driveId, documentId, operations, forceSync)
-                : this.addDriveOperations(driveId, operations as Operation<DocumentDriveAction | BaseAction>[], forceSync)
-
-        }, error => {
+        await this.queueManager.init(this.queueDelegate, error => {
             logger.error(`Error initializing queue manager`, error);
             errors.push(error);
         })
@@ -944,6 +957,61 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
         }
     }
 
+    async queueAction(drive: string, id: string, action: Action, forceSync?: boolean | undefined): Promise<IOperationResult> {
+        return this.queueActions(drive, id, [action], forceSync);
+    }
+
+    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);
+                    }
+                });
+            })
+        } catch (error) {
+            logger.error('Error adding job', error);
+            throw error;
+        }
+    }
+
+    async queueDriveAction(drive: string, action: DocumentDriveAction | BaseAction, forceSync?: boolean | undefined): Promise<IOperationResult<DocumentDriveDocument>> {
+        return this.queueDriveActions(drive, [action], forceSync);
+    }
+
+    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);
+                }
+            });
+
+        })
+    }
+
     async addOperations(
         drive: string,
         id: string,
@@ -1277,35 +1345,39 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
     async addAction(
         drive: string,
         id: string,
-        action: Action
+        action: Action,
+        forceSync = true
     ): Promise<IOperationResult> {
-        return this.addActions(drive, id, [action]);
+        return this.addActions(drive, id, [action], forceSync);
     }
 
     async addActions(
         drive: string,
         id: string,
-        actions: Action[]
+        actions: Action[],
+        forceSync = true
     ): Promise<IOperationResult> {
         const document = await this.getDocument(drive, id);
         const operations = this._buildOperations(document, actions);
-        return this.queueOperations(drive, id, operations);
+        return this.addOperations(drive, id, operations, forceSync);
     }
 
     async addDriveAction(
         drive: string,
-        action: DocumentDriveAction | BaseAction
+        action: DocumentDriveAction | BaseAction,
+        forceSync = true
     ): Promise<IOperationResult<DocumentDriveDocument>> {
-        return this.addDriveActions(drive, [action]);
+        return this.addDriveActions(drive, [action], forceSync);
     }
 
     async addDriveActions(
         drive: string,
-        actions: (DocumentDriveAction | BaseAction)[]
+        actions: (DocumentDriveAction | BaseAction)[],
+        forceSync = true
     ): Promise<IOperationResult<DocumentDriveDocument>> {
         const document = await this.getDrive(drive);
         const operations = this._buildOperations(document, actions);
-        const result = await this.queueDriveOperations(drive, operations);
+        const result = await this.addDriveOperations(drive, operations, forceSync);
         return result;
     }
 

package/src/server/types.ts

@@ -178,6 +178,7 @@ export abstract class BaseDocumentDriveServer {
         operation: Operation,
         forceSync?: boolean
     ): Promise<IOperationResult>;
+
     abstract addOperations(
         drive: string,
         id: string,
@@ -191,6 +192,7 @@ export abstract class BaseDocumentDriveServer {
         operation: Operation,
         forceSync?: boolean
     ): Promise<IOperationResult>;
+
     abstract queueOperations(
         drive: string,
         id: string,
@@ -198,6 +200,20 @@ export abstract class BaseDocumentDriveServer {
         forceSync?: boolean
     ): Promise<IOperationResult>;
 
+    abstract queueAction(
+        drive: string,
+        id: string,
+        action: Action,
+        forceSync?: boolean
+    ): Promise<IOperationResult>;
+
+    abstract queueActions(
+        drive: string,
+        id: string,
+        actions: Action[],
+        forceSync?: boolean
+    ): Promise<IOperationResult>;
+
     abstract addDriveOperation(
         drive: string,
         operation: Operation<DocumentDriveAction | BaseAction>,
@@ -220,24 +236,40 @@ export abstract class BaseDocumentDriveServer {
         forceSync?: boolean
     ): Promise<IOperationResult<DocumentDriveDocument>>;
 
+    abstract queueDriveAction(
+        drive: string,
+        action: DocumentDriveAction | BaseAction,
+        forceSync?: boolean
+    ): Promise<IOperationResult<DocumentDriveDocument>>;
+
+    abstract queueDriveActions(
+        drive: string,
+        actions: Array<DocumentDriveAction | BaseAction>,
+        forceSync?: boolean
+    ): Promise<IOperationResult<DocumentDriveDocument>>;
+
     abstract addAction(
         drive: string,
         id: string,
-        action: Action
+        action: Action,
+        forceSync?: boolean
     ): Promise<IOperationResult>;
     abstract addActions(
         drive: string,
         id: string,
-        actions: Action[]
+        actions: Action[],
+        forceSync?: boolean
     ): Promise<IOperationResult>;
 
     abstract addDriveAction(
         drive: string,
-        action: DocumentDriveAction | BaseAction
+        action: DocumentDriveAction | BaseAction,
+        forceSync?: boolean
     ): Promise<IOperationResult<DocumentDriveDocument>>;
     abstract addDriveActions(
         drive: string,
-        actions: (DocumentDriveAction | BaseAction)[]
+        actions: (DocumentDriveAction | BaseAction)[],
+        forceSync?: boolean
     ): Promise<IOperationResult<DocumentDriveDocument>>;
 
     abstract getSyncStatus(drive: string): SyncStatus;