document-drive 1.19.0 → 1.20.0

package/dist/src/drive-document-model/src/utils.js

@@ -0,0 +1,146 @@
+import { v4 as generateUUID } from "uuid";
+import { addFile, copyNode } from "../gen/node/creators.js";
+export function isFileNode(node) {
+    return node.kind === "file";
+}
+export function isFolderNode(node) {
+    return node.kind === "folder";
+}
+export function getAncestors(node, allNodes) {
+    if (!node.parentFolder) {
+        return [];
+    }
+    else {
+        const parentNode = allNodes.find((_node) => _node.id === node.parentFolder);
+        if (!parentNode) {
+            throw new Error(`Parent node with id ${node.parentFolder} not found`);
+        }
+        return [parentNode, ...getAncestors(parentNode, allNodes)];
+    }
+}
+export function getDescendants(node, allNodes) {
+    const children = allNodes.filter((_node) => _node.parentFolder === node.id);
+    const descendants = children.map((child) => getDescendants(child, allNodes));
+    return [...children, ...descendants.flat()];
+}
+/**
+ * Generates a copy of nodes based on the provided source and target information.
+ * @param src - The source information for generating the copy.
+ * @param idGenerator - The function used to generate new IDs for the copied nodes.
+ * @param nodes - The array of nodes to copy from.
+ * @returns An array of copied nodes with updated IDs and parent folders.
+ * @throws Error if the root node with the specified ID is not found.
+ */
+export function generateNodesCopy(src, idGenerator, nodes) {
+    const rootNode = nodes.find((node) => node.id === src.srcId);
+    if (!rootNode) {
+        throw new Error(`Node with id ${src.srcId} not found`);
+    }
+    const nodesToCopy = [
+        {
+            ...rootNode,
+            name: src.targetName || rootNode.name,
+            parentFolder: src.targetParentFolder || null,
+        },
+        ...getDescendants(rootNode, nodes),
+    ];
+    const ids = {};
+    // Add targetParentFolder to ids so that is not replaced by a new id
+    if (src.targetParentFolder) {
+        ids[src.targetParentFolder] = src.targetParentFolder;
+    }
+    const getNewNodeId = (id) => {
+        let newId = ids[id];
+        if (!newId) {
+            const oldId = id;
+            newId = idGenerator(id);
+            ids[oldId] = newId;
+        }
+        return newId;
+    };
+    const copyNodesInput = nodesToCopy.map((node) => ({
+        srcId: node.id,
+        targetId: getNewNodeId(node.id),
+        targetName: node.name,
+        targetParentFolder: node.parentFolder
+            ? getNewNodeId(node.parentFolder)
+            : null,
+        synchronizationUnits: isFileNode(node)
+            ? node.synchronizationUnits.map((unit) => ({
+                ...unit,
+                syncId: generateSynchronizationUnitId(nodes),
+            }))
+            : undefined,
+    }));
+    return copyNodesInput;
+}
+export function generateSynchronizationUnitId(nodes) {
+    let syncId = "";
+    while (!syncId ||
+        nodes.find((node) => isFileNode(node) &&
+            node.synchronizationUnits.find((unit) => unit.syncId === syncId))) {
+        syncId = generateUUID();
+    }
+    return syncId;
+}
+export function generateSynchronizationUnits(state, scopes, branch = "main") {
+    return scopes.map((scope) => ({
+        scope,
+        branch,
+        syncId: generateSynchronizationUnitId(state.nodes),
+    }));
+}
+export function generateAddNodeAction(state, action, scopes) {
+    return addFile({
+        ...action,
+        synchronizationUnits: generateSynchronizationUnits(state, scopes),
+    });
+}
+export function generateCopyNodeAction(state, action) {
+    const originalNode = state.nodes.find((node) => node.id === action.srcId);
+    if (!originalNode) {
+        throw new Error(`Node with id ${action.srcId} not found`);
+    }
+    let synchronizationUnits = undefined;
+    if (isFileNode(originalNode)) {
+        synchronizationUnits = originalNode.synchronizationUnits.map((syncUnit) => ({
+            ...syncUnit,
+            syncId: generateSynchronizationUnitId(state.nodes),
+        }));
+    }
+    return copyNode({
+        ...action,
+        synchronizationUnits,
+    });
+}
+export function getNextCopyNumber(files, baseFilename) {
+    let maxNumber = 0; // Start by assuming no copies exist
+    // Regex to find files that match the base filename followed by " (copy)" and possibly a number
+    const regex = new RegExp(`^${escapeRegExp(baseFilename)} \\(copy\\)(?: (\\d+))?$`);
+    for (const file of files) {
+        const match = file.match(regex);
+        if (match) {
+            const number = match[1] ? parseInt(match[1], 10) : 1;
+            if (number > maxNumber) {
+                maxNumber = number;
+            }
+        }
+    }
+    return maxNumber + 1;
+}
+export function escapeRegExp(string) {
+    return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+export function handleTargetNameCollisions(params) {
+    const { nodes, targetParentFolder, srcName } = params;
+    const targetNodeChildrenNames = nodes
+        .filter((node) => targetParentFolder === ""
+        ? node.parentFolder === null
+        : node.parentFolder === targetParentFolder)
+        .map((node) => node.name);
+    const targetHasNodesWithSameName = targetNodeChildrenNames.includes(srcName);
+    const targetName = targetHasNodesWithSameName
+        ? `${srcName} (copy) ${getNextCopyNumber(targetNodeChildrenNames, srcName)}`
+        : srcName;
+    return targetName;
+}

package/dist/src/queue/base.d.ts

@@ -0,0 +1,43 @@
+import { Unsubscribe } from "nanoevents";
+import { IJob, IJobQueue, IQueue, IQueueManager, IServerDelegate, Job, JobId, QueueEvents } from "./types.js";
+export declare class MemoryQueue<T> implements IQueue<T> {
+    private id;
+    private blocked;
+    private deleted;
+    private items;
+    private dependencies;
+    constructor(id: string);
+    setDeleted(deleted: boolean): Promise<void>;
+    isDeleted(): Promise<boolean>;
+    addJob(data: IJob<T>): Promise<void>;
+    getNextJob(): Promise<IJob<T> | undefined>;
+    amountOfJobs(): Promise<number>;
+    getId(): string;
+    setBlocked(blocked: boolean): Promise<void>;
+    isBlocked(): Promise<boolean>;
+    getJobs(): Promise<IJob<T>[]>;
+    addDependencies(job: IJob<Job>): Promise<void>;
+    removeDependencies(job: IJob<Job>): Promise<void>;
+}
+export declare class BaseQueueManager implements IQueueManager {
+    protected emitter: import("nanoevents").Emitter<QueueEvents>;
+    protected ticker: number;
+    protected queues: IJobQueue[];
+    protected workers: number;
+    protected timeout: number;
+    private delegate;
+    constructor(workers?: number, timeout?: number);
+    init(delegate: IServerDelegate, onError: (error: Error) => void): Promise<void>;
+    addJob(job: Job): Promise<JobId>;
+    getQueue(driveId: string, documentId?: string): IJobQueue;
+    removeQueue(driveId: string, documentId?: string): void;
+    getQueueByIndex(index: number): IJobQueue | null;
+    getQueues(): string[];
+    private retryNextJob;
+    private findFirstNonEmptyQueue;
+    private processNextJob;
+    protected emit<K extends keyof QueueEvents>(event: K, ...args: Parameters<QueueEvents[K]>): void;
+    on<K extends keyof QueueEvents>(event: K, cb: QueueEvents[K]): Unsubscribe;
+    protected getQueueId(driveId: string, documentId?: string): string;
+}
+//# sourceMappingURL=base.d.ts.map

package/dist/src/queue/base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../../src/queue/base.ts"],"names":[],"mappings":"AAKA,OAAO,EAAoB,WAAW,EAAE,MAAM,YAAY,CAAC;AAC3D,OAAO,EACL,IAAI,EACJ,SAAS,EACT,MAAM,EACN,aAAa,EACb,eAAe,EAEf,GAAG,EACH,KAAK,EACL,WAAW,EACZ,MAAM,YAAY,CAAC;AAEpB,qBAAa,WAAW,CAAC,CAAC,CAAE,YAAW,MAAM,CAAC,CAAC,CAAC;IAC9C,OAAO,CAAC,EAAE,CAAS;IACnB,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,KAAK,CAAiB;IAC9B,OAAO,CAAC,YAAY,CAA0B;gBAElC,EAAE,EAAE,MAAM;IAIhB,UAAU,CAAC,OAAO,EAAE,OAAO;IAI3B,SAAS;IAIT,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC;IAKpB,UAAU;IAKV,YAAY;IAIlB,KAAK;IAIC,UAAU,CAAC,OAAO,EAAE,OAAO;IAI3B,SAAS;IAIT,OAAO;IAIP,eAAe,CAAC,GAAG,EAAE,IAAI,CAAC,GAAG,CAAC;IAS9B,kBAAkB,CAAC,GAAG,EAAE,IAAI,CAAC,GAAG,CAAC;CAQxC;AAED,qBAAa,gBAAiB,YAAW,aAAa;IACpD,SAAS,CAAC,OAAO,4CAAmC;IACpD,SAAS,CAAC,MAAM,SAAK;IACrB,SAAS,CAAC,MAAM,EAAE,SAAS,EAAE,CAAM;IACnC,SAAS,CAAC,OAAO,EAAE,MAAM,CAAC;IAC1B,SAAS,CAAC,OAAO,EAAE,MAAM,CAAC;IAC1B,OAAO,CAAC,QAAQ,CAA8B;gBAElC,OAAO,SAAI,EAAE,OAAO,SAAI;IAK9B,IAAI,CACR,QAAQ,EAAE,eAAe,EACzB,OAAO,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,GAC9B,OAAO,CAAC,IAAI,CAAC;IAWV,MAAM,CAAC,GAAG,EAAE,GAAG,GAAG,OAAO,CAAC,KAAK,CAAC;IA8DtC,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM;IAY7C,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM;IAMhD,eAAe,CAAC,KAAK,EAAE,MAAM;IAS7B,SAAS;IAIT,OAAO,CAAC,YAAY;YAON,sBAAsB;YAatB,cAAc;IA0E5B,SAAS,CAAC,IAAI,CAAC,CAAC,SAAS,MAAM,WAAW,EACxC,KAAK,EAAE,CAAC,EACR,GAAG,IAAI,EAAE,UAAU,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;IAK9B,EAAE,CAAC,CAAC,SAAS,MAAM,WAAW,EACnC,KAAK,EAAE,CAAC,EACR,EAAE,EAAE,WAAW,CAAC,CAAC,CAAC,GACjB,WAAW;IAId,SAAS,CAAC,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM;CAG1D"}

package/dist/src/queue/base.js

@@ -0,0 +1,241 @@
+import { logger } from "#utils/logger";
+import { generateUUID, runAsap } from "#utils/misc";
+import { createNanoEvents } from "nanoevents";
+import { isOperationJob, } from "./types.js";
+export class MemoryQueue {
+    id;
+    blocked = false;
+    deleted = false;
+    items = [];
+    dependencies = new Array();
+    constructor(id) {
+        this.id = id;
+    }
+    async setDeleted(deleted) {
+        this.deleted = deleted;
+    }
+    async isDeleted() {
+        return this.deleted;
+    }
+    async addJob(data) {
+        this.items.push(data);
+        return Promise.resolve();
+    }
+    async getNextJob() {
+        const job = this.items.shift();
+        return Promise.resolve(job);
+    }
+    async amountOfJobs() {
+        return Promise.resolve(this.items.length);
+    }
+    getId() {
+        return this.id;
+    }
+    async setBlocked(blocked) {
+        this.blocked = blocked;
+    }
+    async isBlocked() {
+        return this.blocked;
+    }
+    async getJobs() {
+        return this.items;
+    }
+    async addDependencies(job) {
+        if (!this.dependencies.find((j) => j.jobId === job.jobId)) {
+            this.dependencies.push(job);
+        }
+        if (!this.isBlocked()) {
+            this.setBlocked(true);
+        }
+    }
+    async removeDependencies(job) {
+        this.dependencies = this.dependencies.filter((j) => j.jobId !== job.jobId && j.driveId !== job.driveId);
+        if (this.dependencies.length === 0) {
+            await this.setBlocked(false);
+        }
+    }
+}
+export class BaseQueueManager {
+    emitter = createNanoEvents();
+    ticker = 0;
+    queues = [];
+    workers;
+    timeout;
+    delegate;
+    constructor(workers = 3, timeout = 0) {
+        this.workers = workers;
+        this.timeout = timeout;
+    }
+    async init(delegate, onError) {
+        this.delegate = delegate;
+        for (let i = 0; i < this.workers; i++) {
+            setTimeout(() => this.processNextJob.bind(this)().catch(onError), 100 * i);
+        }
+        return Promise.resolve();
+    }
+    async addJob(job) {
+        if (!this.delegate) {
+            throw new Error("No server delegate defined");
+        }
+        const jobId = generateUUID();
+        const queue = this.getQueue(job.driveId, job.documentId);
+        if (await queue.isDeleted()) {
+            throw new Error("Queue is deleted");
+        }
+        // checks if the job is for a document that doesn't exist in storage yet
+        const newDocument = job.documentId &&
+            !(await this.delegate.checkDocumentExists(job.driveId, job.documentId));
+        // if it is a new document and queue is not yet blocked then
+        // blocks it so the jobs are not processed until it's ready
+        if (newDocument && !(await queue.isBlocked())) {
+            await queue.setBlocked(true);
+            // checks if there any job in the queue adding the file and adds as dependency
+            const driveQueue = this.getQueue(job.driveId);
+            const jobs = await driveQueue.getJobs();
+            for (const driveJob of jobs) {
+                const actions = isOperationJob(driveJob)
+                    ? driveJob.operations
+                    : driveJob.actions;
+                const op = actions.find((j) => {
+                    const input = j.input;
+                    return j.type === "ADD_FILE" && input.id === job.documentId;
+                });
+                if (op) {
+                    await queue.addDependencies(driveJob);
+                }
+            }
+        }
+        // if it has ADD_FILE operations then adds the job as
+        // a dependency to the corresponding document queues
+        const actions = isOperationJob(job) ? job.operations : (job.actions ?? []);
+        const addFileOps = actions.filter((j) => j.type === "ADD_FILE");
+        for (const addFileOp of addFileOps) {
+            const input = addFileOp.input;
+            const q = this.getQueue(job.driveId, input.id);
+            await q.addDependencies({ jobId, ...job });
+        }
+        // remove document if operations contains delete_node
+        const removeFileOps = actions.filter((j) => j.type === "DELETE_NODE");
+        for (const removeFileOp of removeFileOps) {
+            const input = removeFileOp.input;
+            const queue = this.getQueue(job.driveId, input.id);
+            await queue.setDeleted(true);
+        }
+        await queue.addJob({ jobId, ...job });
+        return jobId;
+    }
+    getQueue(driveId, documentId) {
+        const queueId = this.getQueueId(driveId, documentId);
+        let queue = this.queues.find((q) => q.getId() === queueId);
+        if (!queue) {
+            queue = new MemoryQueue(queueId);
+            this.queues.push(queue);
+        }
+        return queue;
+    }
+    removeQueue(driveId, documentId) {
+        const queueId = this.getQueueId(driveId, documentId);
+        this.queues = this.queues.filter((q) => q.getId() !== queueId);
+        this.emit("queueRemoved", queueId);
+    }
+    getQueueByIndex(index) {
+        const queue = this.queues[index];
+        if (queue) {
+            return queue;
+        }
+        return null;
+    }
+    getQueues() {
+        return this.queues.map((q) => q.getId());
+    }
+    retryNextJob(timeout) {
+        const _timeout = timeout !== undefined ? timeout : this.timeout;
+        const retry = _timeout > 0 ? (fn) => setTimeout(fn, _timeout) : runAsap;
+        retry(() => this.processNextJob());
+    }
+    async findFirstNonEmptyQueue(ticker) {
+        const numQueues = this.queues.length;
+        for (let i = 0; i < numQueues; i++) {
+            const index = (ticker + i) % numQueues;
+            const queue = this.queues[index];
+            if (queue && (await queue.amountOfJobs()) > 0) {
+                return index;
+            }
+        }
+        return null;
+    }
+    async processNextJob() {
+        if (!this.delegate) {
+            throw new Error("No server delegate defined");
+        }
+        if (this.queues.length === 0) {
+            this.retryNextJob();
+            return;
+        }
+        const queue = this.queues[this.ticker];
+        if (!queue) {
+            this.ticker = 0;
+            this.retryNextJob();
+            return;
+        }
+        // if no jobs in the current queue then looks for the
+        // next queue with jobs. If no jobs in any queue then
+        // retries after a timeout
+        const amountOfJobs = await queue.amountOfJobs();
+        if (amountOfJobs === 0) {
+            const nextTicker = await this.findFirstNonEmptyQueue(this.ticker);
+            if (nextTicker !== null) {
+                this.ticker = nextTicker;
+                this.retryNextJob(0);
+            }
+            else {
+                this.retryNextJob();
+            }
+            return;
+        }
+        this.ticker = this.ticker === this.queues.length - 1 ? 0 : this.ticker + 1;
+        const isBlocked = await queue.isBlocked();
+        if (isBlocked) {
+            this.retryNextJob();
+            return;
+        }
+        await queue.setBlocked(true);
+        const nextJob = await queue.getNextJob();
+        if (!nextJob) {
+            this.retryNextJob();
+            return;
+        }
+        try {
+            const result = await this.delegate.processJob(nextJob);
+            // unblock the document queues of each add_file operation
+            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.id);
+                    await documentQueue.removeDependencies(nextJob);
+                }
+            }
+            this.emit("jobCompleted", nextJob, result);
+        }
+        catch (e) {
+            logger.error(`job failed`, e);
+            this.emit("jobFailed", nextJob, e);
+        }
+        finally {
+            await queue.setBlocked(false);
+            this.retryNextJob(0);
+        }
+    }
+    emit(event, ...args) {
+        this.emitter.emit(event, ...args);
+    }
+    on(event, cb) {
+        return this.emitter.on(event, cb);
+    }
+    getQueueId(driveId, documentId) {
+        return `queue:${driveId}${documentId ? `:${documentId}` : ""}`;
+    }
+}

package/dist/src/queue/redis.d.ts

@@ -0,0 +1,28 @@
+import { RedisClientType } from "redis";
+import { BaseQueueManager } from "./base.js";
+import { IJob, IQueue, IQueueManager, IServerDelegate, Job } from "./types.js";
+export declare class RedisQueue<T> implements IQueue<T> {
+    private id;
+    private client;
+    constructor(id: string, client: RedisClientType);
+    addJob(data: any): Promise<void>;
+    getNextJob(): Promise<IJob<T> | undefined>;
+    amountOfJobs(): Promise<number>;
+    setBlocked(blocked: boolean): Promise<void>;
+    isBlocked(): Promise<boolean>;
+    getId(): string;
+    getJobs(): Promise<IJob<T>[]>;
+    addDependencies(job: IJob<Job>): Promise<void>;
+    hasDependency(job: IJob<Job>): Promise<boolean>;
+    removeDependencies(job: IJob<Job>): Promise<void>;
+    isDeleted(): Promise<boolean>;
+    setDeleted(deleted: boolean): Promise<void>;
+}
+export declare class RedisQueueManager extends BaseQueueManager implements IQueueManager {
+    private client;
+    constructor(workers: number | undefined, timeout: number | undefined, client: RedisClientType);
+    init(delegate: IServerDelegate, onError: (error: Error) => void): Promise<void>;
+    getQueue(driveId: string, documentId?: string): import("./types.js").IJobQueue;
+    removeQueue(driveId: string, documentId?: string | undefined): void;
+}
+//# sourceMappingURL=redis.d.ts.map

package/dist/src/queue/redis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redis.d.ts","sourceRoot":"","sources":["../../../src/queue/redis.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,OAAO,CAAC;AACxC,OAAO,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAC7C,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,aAAa,EAAE,eAAe,EAAE,GAAG,EAAE,MAAM,YAAY,CAAC;AAE/E,qBAAa,UAAU,CAAC,CAAC,CAAE,YAAW,MAAM,CAAC,CAAC,CAAC;IAC7C,OAAO,CAAC,EAAE,CAAS;IACnB,OAAO,CAAC,MAAM,CAAkB;gBAEpB,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,eAAe;IAOzC,MAAM,CAAC,IAAI,EAAE,GAAG;IAIhB,UAAU;IAQV,YAAY;IAIZ,UAAU,CAAC,OAAO,EAAE,OAAO;IAQ3B,SAAS;IASf,KAAK;IAIC,OAAO;IAKP,eAAe,CAAC,GAAG,EAAE,IAAI,CAAC,GAAG,CAAC;IAQ9B,aAAa,CAAC,GAAG,EAAE,IAAI,CAAC,GAAG,CAAC;IAK5B,kBAAkB,CAAC,GAAG,EAAE,IAAI,CAAC,GAAG,CAAC;IAUjC,SAAS;IAKT,UAAU,CAAC,OAAO,EAAE,OAAO;CAOlC;AAED,qBAAa,iBACX,SAAQ,gBACR,YAAW,aAAa;IAExB,OAAO,CAAC,MAAM,CAAkB;gBAEpB,OAAO,oBAAI,EAAE,OAAO,oBAAI,EAAE,MAAM,EAAE,eAAe;IAKvD,IAAI,CACR,QAAQ,EAAE,eAAe,EACzB,OAAO,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,GAC9B,OAAO,CAAC,IAAI,CAAC;IAWhB,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM;IAY7C,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI;CAMpE"}

package/dist/src/queue/redis.js

@@ -0,0 +1,110 @@
+import { BaseQueueManager } from "./base.js";
+export class RedisQueue {
+    id;
+    client;
+    constructor(id, client) {
+        this.client = client;
+        this.id = id;
+        this.client.hSet("queues", id, "true");
+        this.client.hSet(this.id, "blocked", "false");
+    }
+    async addJob(data) {
+        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);
+    }
+    async amountOfJobs() {
+        return this.client.lLen(this.id + "-jobs");
+    }
+    async setBlocked(blocked) {
+        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));
+    }
+    async addDependencies(job) {
+        if (await this.hasDependency(job)) {
+            return;
+        }
+        await this.client.lPush(this.id + "-deps", JSON.stringify(job));
+        await this.setBlocked(true);
+    }
+    async hasDependency(job) {
+        const deps = await this.client.lRange(this.id + "-deps", 0, -1);
+        return deps.some((d) => d === JSON.stringify(job));
+    }
+    async removeDependencies(job) {
+        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) {
+        if (deleted) {
+            await this.client.hSet("queues", this.id, "false");
+        }
+        else {
+            await this.client.hSet("queues", this.id, "true");
+        }
+    }
+}
+export class RedisQueueManager extends BaseQueueManager {
+    client;
+    constructor(workers = 3, timeout = 0, client) {
+        super(workers, timeout);
+        this.client = client;
+    }
+    async init(delegate, onError) {
+        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, documentId) {
+        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, documentId) {
+        super.removeQueue(driveId, documentId);
+        const queueId = this.getQueueId(driveId, documentId);
+        this.client.hDel("queues", queueId);
+    }
+}

package/dist/src/queue/types.d.ts

@@ -0,0 +1,55 @@
+import type { Action, Operation } from "document-model";
+import type { Unsubscribe } from "nanoevents";
+import { AddOperationOptions, IOperationResult } from "#server/types";
+export interface BaseJob {
+    driveId: string;
+    documentId?: string;
+    actions?: Action[];
+    options?: AddOperationOptions;
+}
+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<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>;
+}
+export interface IQueueManager {
+    addJob: (job: Job) => Promise<JobId>;
+    getQueue: (driveId: string, documentId?: string) => IQueue<Job>;
+    removeQueue: (driveId: string, documentId?: string) => void;
+    getQueueByIndex: (index: number) => IQueue<Job> | 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> {
+    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>;
+export declare function isOperationJob(job: Job): job is OperationJob;
+export declare function isActionJob(job: Job): job is ActionJob;
+//# sourceMappingURL=types.d.ts.map

package/dist/src/queue/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/queue/types.ts"],"names":[],"mappings":"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"}

package/dist/src/queue/types.js

@@ -0,0 +1,6 @@
+export function isOperationJob(job) {
+    return "operations" in job;
+}
+export function isActionJob(job) {
+    return "actions" in job;
+}

package/dist/src/read-mode/errors.d.ts

@@ -0,0 +1,12 @@
+export declare abstract class ReadDriveError extends Error {
+}
+export declare class ReadDriveNotFoundError extends ReadDriveError {
+    constructor(driveId: string);
+}
+export declare class ReadDriveSlugNotFoundError extends ReadDriveError {
+    constructor(slug: string);
+}
+export declare class ReadDocumentNotFoundError extends ReadDriveError {
+    constructor(drive: string, id: string);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/src/read-mode/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/read-mode/errors.ts"],"names":[],"mappings":"AAAA,8BAAsB,cAAe,SAAQ,KAAK;CAAG;AAErD,qBAAa,sBAAuB,SAAQ,cAAc;gBAC5C,OAAO,EAAE,MAAM;CAG5B;AAED,qBAAa,0BAA2B,SAAQ,cAAc;gBAChD,IAAI,EAAE,MAAM;CAGzB;AAED,qBAAa,yBAA0B,SAAQ,cAAc;gBAC/C,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM;CAGtC"}