document-drive 1.0.0-websockets.1 → 1.0.0

package/src/queue/redis.ts

@@ -1,133 +1,144 @@
 import { RedisClientType } from "redis";
-import { IJob, IQueue, IQueueManager, IServerDelegate, OperationJob } from "./types";
 import { BaseQueueManager } from "./base";
+import {
+  IJob,
+  IQueue,
+  IQueueManager,
+  IServerDelegate,
+  OperationJob,
+} from "./types";
 
 export class RedisQueue<T, R> implements IQueue<T, R> {
-    private id: string;
-    private client: RedisClientType;
-
-    constructor(id: string, client: RedisClientType) {
-        this.client = client;
-        this.id = id;
-        this.client.hSet("queues", id, "true");
-        this.client.hSet(this.id, "blocked", "false");
-    }
-
-    async addJob(data: any) {
-        await this.client.lPush(this.id + "-jobs", JSON.stringify(data));
-    }
-
-    async getNextJob() {
-        const job = await this.client.rPop(this.id + "-jobs");
-        if (!job) {
-            return undefined;
-        }
-        return JSON.parse(job) as IJob<T>;
-    }
-
-    async amountOfJobs() {
-        return this.client.lLen(this.id + "-jobs");
-    }
-
-    async setBlocked(blocked: boolean) {
-        if (blocked) {
-            await this.client.hSet(this.id, "blocked", "true");
-        } else {
-            await this.client.hSet(this.id, "blocked", "false");
-        }
-    }
-
-    async isBlocked() {
-        const blockedResult = await this.client.hGet(this.id, "blocked");
-        if (blockedResult === "true") {
-            return true;
-        }
-
-        return false;
-    }
-
-    getId() {
-        return this.id;
-    }
-
-    async getJobs() {
-        const entries = await this.client.lRange(this.id + "-jobs", 0, -1)
-        return entries.map(e => JSON.parse(e) as IJob<T>);
-    }
-
-    async addDependencies(job: IJob<OperationJob>) {
-        if (await this.hasDependency(job)) {
-            return;
-        }
-        await this.client.lPush(this.id + "-deps", JSON.stringify(job));
-        await this.setBlocked(true);
-    }
-
-    async hasDependency(job: IJob<OperationJob>) {
-        const deps = await this.client.lRange(this.id + "-deps", 0, -1);
-        return deps.some(d => d === JSON.stringify(job));
-    }
-
-    async removeDependencies(job: IJob<OperationJob>) {
-        await this.client.lRem(this.id + "-deps", 1, JSON.stringify(job));
-        const allDeps = await this.client.lLen(this.id + "-deps");
-        if (allDeps > 0) {
-            await this.setBlocked(true);
-        } else {
-            await this.setBlocked(false);
-        }
-    }
-
-    async isDeleted() {
-        const active = await this.client.hGet("queues", this.id);
-        return active === "false";
-    }
-
-    async setDeleted(deleted: boolean) {
-        if (deleted) {
-            await this.client.hSet("queues", this.id, "false");
-        } else {
-            await this.client.hSet("queues", this.id, "true");
-        }
-    }
+  private id: string;
+  private client: RedisClientType;
+
+  constructor(id: string, client: RedisClientType) {
+    this.client = client;
+    this.id = id;
+    this.client.hSet("queues", id, "true");
+    this.client.hSet(this.id, "blocked", "false");
+  }
+
+  async addJob(data: any) {
+    await this.client.lPush(this.id + "-jobs", JSON.stringify(data));
+  }
+
+  async getNextJob() {
+    const job = await this.client.rPop(this.id + "-jobs");
+    if (!job) {
+      return undefined;
+    }
+    return JSON.parse(job) as IJob<T>;
+  }
+
+  async amountOfJobs() {
+    return this.client.lLen(this.id + "-jobs");
+  }
+
+  async setBlocked(blocked: boolean) {
+    if (blocked) {
+      await this.client.hSet(this.id, "blocked", "true");
+    } else {
+      await this.client.hSet(this.id, "blocked", "false");
+    }
+  }
+
+  async isBlocked() {
+    const blockedResult = await this.client.hGet(this.id, "blocked");
+    if (blockedResult === "true") {
+      return true;
+    }
+
+    return false;
+  }
+
+  getId() {
+    return this.id;
+  }
+
+  async getJobs() {
+    const entries = await this.client.lRange(this.id + "-jobs", 0, -1);
+    return entries.map((e) => JSON.parse(e) as IJob<T>);
+  }
+
+  async addDependencies(job: IJob<OperationJob>) {
+    if (await this.hasDependency(job)) {
+      return;
+    }
+    await this.client.lPush(this.id + "-deps", JSON.stringify(job));
+    await this.setBlocked(true);
+  }
+
+  async hasDependency(job: IJob<OperationJob>) {
+    const deps = await this.client.lRange(this.id + "-deps", 0, -1);
+    return deps.some((d) => d === JSON.stringify(job));
+  }
+
+  async removeDependencies(job: IJob<OperationJob>) {
+    await this.client.lRem(this.id + "-deps", 1, JSON.stringify(job));
+    const allDeps = await this.client.lLen(this.id + "-deps");
+    if (allDeps > 0) {
+      await this.setBlocked(true);
+    } else {
+      await this.setBlocked(false);
+    }
+  }
+
+  async isDeleted() {
+    const active = await this.client.hGet("queues", this.id);
+    return active === "false";
+  }
+
+  async setDeleted(deleted: boolean) {
+    if (deleted) {
+      await this.client.hSet("queues", this.id, "false");
+    } else {
+      await this.client.hSet("queues", this.id, "true");
+    }
+  }
 }
 
-export class RedisQueueManager extends BaseQueueManager implements IQueueManager {
-
-    private client: RedisClientType;
-
-    constructor(workers = 3, timeout = 0, client: RedisClientType) {
-        super(workers, timeout);
-        this.client = client;
-    }
-
-    async init(delegate: IServerDelegate, onError: (error: Error) => void): Promise<void> {
-        await super.init(delegate, onError);
-        const queues = await this.client.hGetAll("queues");
-        for (const queueId in queues) {
-            const active = await this.client.hGet("queues", queueId);
-            if (active === "true") {
-                this.queues.push(new RedisQueue(queueId, this.client));
-            }
-        }
-    }
-
-    getQueue(driveId: string, documentId?: string) {
-        const queueId = this.getQueueId(driveId, documentId);
-        let queue = this.queues.find((q) => q.getId() === queueId);
-
-        if (!queue) {
-            queue = new RedisQueue(queueId, this.client);
-            this.queues.push(queue);
-        }
-
-        return queue;
-    }
-
-    removeQueue(driveId: string, documentId?: string | undefined): void {
-        super.removeQueue(driveId, documentId);
-
-        const queueId = this.getQueueId(driveId, documentId);
-        this.client.hDel("queues", queueId);
-    }
-}
+export class RedisQueueManager
+  extends BaseQueueManager
+  implements IQueueManager
+{
+  private client: RedisClientType;
+
+  constructor(workers = 3, timeout = 0, client: RedisClientType) {
+    super(workers, timeout);
+    this.client = client;
+  }
+
+  async init(
+    delegate: IServerDelegate,
+    onError: (error: Error) => void,
+  ): Promise<void> {
+    await super.init(delegate, onError);
+    const queues = await this.client.hGetAll("queues");
+    for (const queueId in queues) {
+      const active = await this.client.hGet("queues", queueId);
+      if (active === "true") {
+        this.queues.push(new RedisQueue(queueId, this.client));
+      }
+    }
+  }
+
+  getQueue(driveId: string, documentId?: string) {
+    const queueId = this.getQueueId(driveId, documentId);
+    let queue = this.queues.find((q) => q.getId() === queueId);
+
+    if (!queue) {
+      queue = new RedisQueue(queueId, this.client);
+      this.queues.push(queue);
+    }
+
+    return queue;
+  }
+
+  removeQueue(driveId: string, documentId?: string | undefined): void {
+    super.removeQueue(driveId, documentId);
+
+    const queueId = this.getQueueId(driveId, documentId);
+    this.client.hDel("queues", queueId);
+  }
+}

package/src/queue/types.ts

@@ -1,20 +1,20 @@
 import { Action, Operation } from "document-model/document";
-import { IOperationResult } from "../server";
 import type { Unsubscribe } from "nanoevents";
+import { AddOperationOptions, IOperationResult } from "../server";
 
 export interface BaseJob {
-    driveId: string;
-    documentId?: string
-    actions?: Action[]
-    forceSync?: boolean
+  driveId: string;
+  documentId?: string;
+  actions?: Action[];
+  options?: AddOperationOptions;
 }
 
 export interface OperationJob extends BaseJob {
-    operations: Operation[]
+  operations: Operation[];
 }
 
 export interface ActionJob extends BaseJob {
-    actions: Action[]
+  actions: Action[];
 }
 
 export type Job = OperationJob | ActionJob;
@@ -22,52 +22,58 @@ export type Job = OperationJob | ActionJob;
 export type JobId = string;
 
 export interface QueueEvents {
-    jobCompleted: (job: IJob<Job>, result: IOperationResult) => void;
-    jobFailed: (job: IJob<Job>, error: Error) => void;
-    queueRemoved: (queueId: string) => 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>;
-    processJob: (job: Job) => Promise<IOperationResult>;
-};
+  checkDocumentExists: (
+    driveId: string,
+    documentId: string,
+  ) => Promise<boolean>;
+  processJob: (job: Job) => Promise<IOperationResult>;
+}
 
 export interface IQueueManager {
-    addJob(job: Job): Promise<JobId>;
-    getQueue(driveId: string, document?: string): IQueue<Job, IOperationResult>;
-    removeQueue(driveId: string, documentId?: string): void;
-    getQueueByIndex(index: number): IQueue<Job, IOperationResult> | null;
-    getQueues(): string[];
-    init(delegate: IServerDelegate, onError: (error: Error) => void): Promise<void>;
-    on<K extends keyof QueueEvents>(
-        this: this,
-        event: K,
-        cb: QueueEvents[K]
-    ): Unsubscribe;
+  addJob(job: Job): Promise<JobId>;
+  getQueue(driveId: string, document?: string): IQueue<Job, IOperationResult>;
+  removeQueue(driveId: string, documentId?: string): void;
+  getQueueByIndex(index: number): IQueue<Job, IOperationResult> | null;
+  getQueues(): string[];
+  init(
+    delegate: IServerDelegate,
+    onError: (error: Error) => void,
+  ): Promise<void>;
+  on<K extends keyof QueueEvents>(
+    this: this,
+    event: K,
+    cb: QueueEvents[K],
+  ): Unsubscribe;
 }
 
 export type IJob<T> = { jobId: JobId } & T;
 
 export interface IQueue<T, R> {
-    addJob(data: IJob<T>): Promise<void>;
-    getNextJob(): Promise<IJob<T> | undefined>;
-    amountOfJobs(): Promise<number>;
-    getId(): string;
-    setBlocked(blocked: boolean): Promise<void>;
-    isBlocked(): Promise<boolean>;
-    isDeleted(): Promise<boolean>;
-    setDeleted(deleted: boolean): Promise<void>;
-    getJobs(): Promise<IJob<T>[]>;
-    addDependencies(job: IJob<Job>): Promise<void>;
-    removeDependencies(job: IJob<Job>): Promise<void>;
+  addJob(data: IJob<T>): Promise<void>;
+  getNextJob(): Promise<IJob<T> | undefined>;
+  amountOfJobs(): Promise<number>;
+  getId(): string;
+  setBlocked(blocked: boolean): Promise<void>;
+  isBlocked(): Promise<boolean>;
+  isDeleted(): Promise<boolean>;
+  setDeleted(deleted: boolean): Promise<void>;
+  getJobs(): Promise<IJob<T>[]>;
+  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;
+  return "operations" in job;
 }
 
 export function isActionJob(job: Job): job is ActionJob {
-    return "actions" in job;
-}
+  return "actions" in job;
+}

package/src/read-mode/errors.ts

@@ -0,0 +1,19 @@
+export abstract class ReadDriveError extends Error {}
+
+export class ReadDriveNotFoundError extends ReadDriveError {
+  constructor(driveId: string) {
+    super(`Read drive ${driveId} not found.`);
+  }
+}
+
+export class ReadDriveSlugNotFoundError extends ReadDriveError {
+  constructor(slug: string) {
+    super(`Read drive with slug ${slug} not found.`);
+  }
+}
+
+export class ReadDocumentNotFoundError extends ReadDriveError {
+  constructor(drive: string, id: string) {
+    super(`Document with id ${id} not found on read drive ${drive}.`);
+  }
+}

package/src/read-mode/index.ts

@@ -0,0 +1,125 @@
+import { Document } from "document-model/document";
+import { DocumentDriveServerConstructor, RemoteDriveOptions } from "../server";
+import { logger } from "../utils/logger";
+import { ReadDriveSlugNotFoundError } from "./errors";
+import { ReadModeService } from "./service";
+import {
+  IReadModeDriveServer,
+  IReadModeDriveService,
+  ReadDrive,
+  ReadDriveOptions,
+  ReadDrivesListener,
+  ReadModeDriveServerMixin,
+} from "./types";
+
+export * from "./errors";
+export * from "./types";
+
+export function ReadModeServer<TBase extends DocumentDriveServerConstructor>(
+  Base: TBase,
+): ReadModeDriveServerMixin {
+  return class ReadMode extends Base implements IReadModeDriveServer {
+    #readModeStorage: IReadModeDriveService;
+    #listeners = new Set<ReadDrivesListener>();
+
+    constructor(...args: any[]) {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+      super(...args);
+
+      this.#readModeStorage = new ReadModeService(
+        this.getDocumentModel.bind(this),
+      );
+
+      this.#buildDrives()
+        .then((drives) => {
+          if (drives.length) {
+            this.#notifyListeners(drives, "add");
+          }
+        })
+        .catch(logger.error);
+    }
+
+    async #buildDrives() {
+      const driveIds = await this.getReadDrives();
+      const drives = (
+        await Promise.all(driveIds.map((driveId) => this.getReadDrive(driveId)))
+      ).filter((drive) => !(drive instanceof Error)) as ReadDrive[];
+      return drives;
+    }
+
+    #notifyListeners(drives: ReadDrive[], operation: "add" | "delete") {
+      this.#listeners.forEach((listener) => listener(drives, operation));
+    }
+
+    getReadDrives(): Promise<string[]> {
+      return this.#readModeStorage.getReadDrives();
+    }
+
+    getReadDrive(id: string) {
+      return this.#readModeStorage.getReadDrive(id);
+    }
+
+    getReadDriveBySlug(
+      slug: string,
+    ): Promise<ReadDrive | ReadDriveSlugNotFoundError> {
+      return this.#readModeStorage.getReadDriveBySlug(slug);
+    }
+
+    getReadDriveContext(id: string) {
+      return this.#readModeStorage.getReadDriveContext(id);
+    }
+
+    async addReadDrive(url: string, options?: ReadDriveOptions) {
+      await this.#readModeStorage.addReadDrive(url, options);
+      this.#notifyListeners(await this.#buildDrives(), "add");
+    }
+
+    fetchDrive(id: string) {
+      return this.#readModeStorage.fetchDrive(id);
+    }
+
+    fetchDocument<D extends Document>(
+      driveId: string,
+      documentId: string,
+      documentType: string,
+    ) {
+      return this.#readModeStorage.fetchDocument<D>(
+        driveId,
+        documentId,
+        documentType,
+      );
+    }
+
+    async deleteReadDrive(id: string) {
+      const error = await this.#readModeStorage.deleteReadDrive(id);
+      if (error) {
+        return error;
+      }
+
+      this.#notifyListeners(await this.#buildDrives(), "delete");
+    }
+
+    async migrateReadDrive(id: string, options: RemoteDriveOptions) {
+      const result = await this.getReadDriveContext(id);
+      if (result instanceof Error) {
+        return result;
+      }
+
+      const { url, ...readOptions } = result;
+      try {
+        const newDrive = await this.addRemoteDrive(url, options);
+        return newDrive;
+      } catch (error) {
+        // if an error is thrown, then add the read drive again
+        logger.error(error);
+        await this.addReadDrive(result.url, readOptions);
+        throw error;
+      }
+    }
+
+    onReadDrivesUpdate(listener: ReadDrivesListener) {
+      this.#listeners.add(listener);
+      return Promise.resolve(() => this.#listeners.delete(listener));
+    }
+  };
+}