document-drive 1.0.0-alpha.91 → 1.0.0-alpha.93

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "document-drive",
-    "version": "1.0.0-alpha.91",
+    "version": "1.0.0-alpha.93",
     "license": "AGPL-3.0-only",
     "type": "module",
     "module": "./src/index.ts",
@@ -35,7 +35,7 @@
         "test:watch": "vitest watch"
     },
     "peerDependencies": {
-        "document-model": "^1.7.0",
+        "document-model": "^1.8.0",
         "document-model-libs": "^1.57.0"
     },
     "optionalDependencies": {
@@ -46,6 +46,7 @@
         "sqlite3": "^5.1.7"
     },
     "dependencies": {
+        "change-case": "^5.4.4",
         "exponential-backoff": "^3.1.1",
         "graphql": "^16.9.0",
         "graphql-request": "^6.1.0",
@@ -65,9 +66,10 @@
         "@types/uuid": "^9.0.8",
         "@typescript-eslint/eslint-plugin": "^6.21.0",
         "@typescript-eslint/parser": "^6.21.0",
+        "@vitest/browser": "^2.0.5",
         "@vitest/coverage-v8": "^2.0.5",
         "document-model": "^1.7.0",
-        "document-model-libs": "^1.70.0",
+        "document-model-libs": "^1.83.0",
         "eslint": "^8.57.0",
         "eslint-config-prettier": "^9.1.0",
         "fake-indexeddb": "^5.0.2",
@@ -80,7 +82,9 @@
         "sequelize": "^6.37.2",
         "sqlite3": "^5.1.7",
         "typescript": "^5.5.3",
-        "vitest": "^2.0.5"
+        "vitest": "^2.0.5",
+        "webdriverio": "^9.0.9",
+        "vitest-fetch-mock": "^0.3.0"
     },
     "packageManager": "pnpm@9.1.4+sha256.30a1801ac4e723779efed13a21f4c39f9eb6c9fbb4ced101bce06b422593d7c9"
 }

package/src/queue/base.ts

@@ -4,7 +4,7 @@ import {
 } from 'document-model-libs/document-drive';
 import { Action } from 'document-model/document';
 import { Unsubscribe, createNanoEvents } from 'nanoevents';
-import { generateUUID } from '../utils';
+import { generateUUID, runAsap } from '../utils';
 import { logger } from '../utils/logger';
 import {
     IJob,
@@ -212,10 +212,10 @@ export class BaseQueueManager implements IQueueManager {
     private retryNextJob(timeout?: number) {
         const _timeout = timeout !== undefined ? timeout : this.timeout;
         const retry =
-            _timeout === 0 && typeof setImmediate !== 'undefined'
-                ? setImmediate
-                : (fn: () => void) => setTimeout(fn, _timeout);
-        return retry(() => this.processNextJob());
+            _timeout > 0
+                ? (fn: () => void) => setTimeout(fn, _timeout)
+                : runAsap;
+        retry(() => this.processNextJob());
     }
 
     private async findFirstNonEmptyQueue(

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,127 @@
+import { ListenerFilter } from 'document-model-libs/document-drive';
+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,
+    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>();
+
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        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, filter?: ListenerFilter) {
+            await this.#readModeStorage.addReadDrive(url, filter);
+            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;
+            }
+
+            try {
+                const newDrive = await this.addRemoteDrive(result.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, result.filter);
+                throw error;
+            }
+        }
+
+        onReadDrivesUpdate(listener: ReadDrivesListener) {
+            this.#listeners.add(listener);
+            return Promise.resolve(() => this.#listeners.delete(listener));
+        }
+    };
+}

package/src/read-mode/service.ts

@@ -0,0 +1,212 @@
+import type {
+    DocumentDriveDocument,
+    ListenerFilter
+} from 'document-model-libs/document-drive';
+import * as DocumentDrive from 'document-model-libs/document-drive';
+import { Document, DocumentModel } from 'document-model/document';
+import { GraphQLError } from 'graphql';
+import { DocumentModelNotFoundError } from '../server/error';
+import { fetchDocument, requestPublicDrive } from '../utils/graphql';
+import {
+    ReadDocumentNotFoundError,
+    ReadDriveError,
+    ReadDriveNotFoundError,
+    ReadDriveSlugNotFoundError
+} from './errors';
+import {
+    GetDocumentModel,
+    InferDocumentLocalState,
+    InferDocumentOperation,
+    InferDocumentState,
+    IReadModeDriveService,
+    ReadDrive,
+    ReadDriveContext
+} from './types';
+
+export class ReadModeService implements IReadModeDriveService {
+    #getDocumentModel: GetDocumentModel;
+    #drives = new Map<
+        string,
+        { drive: Omit<ReadDrive, 'readContext'>; context: ReadDriveContext }
+    >();
+
+    constructor(getDocumentModel: GetDocumentModel) {
+        this.#getDocumentModel = getDocumentModel;
+    }
+
+    #parseGraphQLErrors(
+        errors: GraphQLError[],
+        driveId: string,
+        documentId?: string
+    ) {
+        for (const error of errors) {
+            if (error.message === `Drive with id ${driveId} not found`) {
+                return new ReadDriveNotFoundError(driveId);
+            } else if (
+                documentId &&
+                error.message === `Document with id ${documentId} not found`
+            ) {
+                return new ReadDocumentNotFoundError(driveId, documentId);
+            }
+        }
+        const firstError = errors.at(0);
+        if (firstError) {
+            return firstError;
+        }
+    }
+
+    async #fetchDrive(id: string, url: string) {
+        const { errors, document } = await fetchDocument<DocumentDriveDocument>(
+            url,
+            id,
+            DocumentDrive
+        );
+        const error = errors ? this.#parseGraphQLErrors(errors, id) : undefined;
+        return error || document;
+    }
+
+    async fetchDrive(id: string): Promise<ReadDrive | ReadDriveNotFoundError> {
+        const drive = this.#drives.get(id);
+        if (!drive) {
+            return new ReadDriveNotFoundError(id);
+        }
+        const document = await this.fetchDocument<DocumentDriveDocument>(
+            id,
+            id,
+            DocumentDrive.documentModel.id
+        );
+        if (document instanceof Error) {
+            return document;
+        }
+        const result = { ...document, readContext: drive.context };
+        drive.drive = result;
+        return result;
+    }
+
+    async fetchDocument<D extends Document>(
+        driveId: string,
+        documentId: string,
+        documentType: DocumentModel<
+            InferDocumentState<D>,
+            InferDocumentOperation<D>,
+            InferDocumentLocalState<D>
+        >['documentModel']['id']
+    ): Promise<
+        | Document<
+              InferDocumentState<D>,
+              InferDocumentOperation<D>,
+              InferDocumentLocalState<D>
+          >
+        | DocumentModelNotFoundError
+        | ReadDriveNotFoundError
+        | ReadDocumentNotFoundError
+    > {
+        const drive = this.#drives.get(driveId);
+        if (!drive) {
+            return new ReadDriveNotFoundError(driveId);
+        }
+
+        let documentModel:
+            | DocumentModel<
+                  InferDocumentState<D>,
+                  InferDocumentOperation<D>,
+                  InferDocumentLocalState<D>
+              >
+            | undefined = undefined;
+        try {
+            documentModel = this.#getDocumentModel(
+                documentType
+            ) as unknown as DocumentModel<
+                InferDocumentState<D>,
+                InferDocumentOperation<D>,
+                InferDocumentLocalState<D>
+            >;
+        } catch (error) {
+            return new DocumentModelNotFoundError(documentType, error);
+        }
+
+        const { url } = drive.context;
+        const { errors, document } = await fetchDocument<D>(
+            url,
+            documentId,
+            documentModel
+        );
+
+        if (errors) {
+            const error = this.#parseGraphQLErrors(errors, driveId, documentId);
+            if (error instanceof ReadDriveError) {
+                return error;
+            } else if (error) {
+                throw error;
+            }
+        }
+
+        if (!document) {
+            return new ReadDocumentNotFoundError(driveId, documentId);
+        }
+
+        return document;
+    }
+
+    async addReadDrive(url: string, filter?: ListenerFilter): Promise<void> {
+        const { id } = await requestPublicDrive(url);
+
+        const result = await this.#fetchDrive(id, url);
+        if (result instanceof Error) {
+            throw result;
+        } else if (!result) {
+            throw new Error(`Drive "${id}" not found at ${url}`);
+        }
+        this.#drives.set(id, {
+            drive: result as unknown as ReadDrive,
+            context: {
+                url,
+                filter: filter ?? {
+                    documentId: ['*'],
+                    documentType: ['*'],
+                    branch: ['*'],
+                    scope: ['*']
+                }
+            }
+        });
+    }
+
+    async getReadDrives(): Promise<string[]> {
+        return Promise.resolve([...this.#drives.keys()]);
+    }
+
+    async getReadDrive(id: string) {
+        const result = this.#drives.get(id);
+        return Promise.resolve(
+            result
+                ? { ...result.drive, readContext: result.context }
+                : new ReadDriveNotFoundError(id)
+        );
+    }
+
+    async getReadDriveBySlug(
+        slug: string
+    ): Promise<ReadDrive | ReadDriveSlugNotFoundError> {
+        const readDrive = [...this.#drives.values()].find(
+            ({ drive }) => drive.state.global.slug === slug
+        );
+        return Promise.resolve(
+            readDrive
+                ? { ...readDrive.drive, readContext: readDrive.context }
+                : new ReadDriveSlugNotFoundError(slug)
+        );
+    }
+
+    getReadDriveContext(id: string) {
+        return Promise.resolve(
+            this.#drives.get(id)?.context ?? new ReadDriveNotFoundError(id)
+        );
+    }
+
+    deleteReadDrive(id: string): Promise<ReadDriveNotFoundError | undefined> {
+        const deleted = this.#drives.delete(id);
+        return Promise.resolve(
+            deleted ? undefined : new ReadDriveNotFoundError(id)
+        );
+    }
+}

package/src/read-mode/types.ts

@@ -0,0 +1,103 @@
+import {
+    DocumentDriveDocument,
+    ListenerFilter
+} from 'document-model-libs/document-drive';
+import { Action, Document, DocumentModel } from 'document-model/document';
+import { DocumentDriveServerMixin, RemoteDriveOptions } from '../server';
+import { DocumentModelNotFoundError } from '../server/error';
+import {
+    ReadDocumentNotFoundError,
+    ReadDriveNotFoundError,
+    ReadDriveSlugNotFoundError
+} from './errors';
+
+// TODO: move these types to the document-model package
+export type InferDocumentState<D extends Document> =
+    D extends Document<infer S> ? S : never;
+
+export type InferDocumentOperation<D extends Document> =
+    D extends Document<unknown, infer A> ? A : never;
+
+export type InferDocumentLocalState<D extends Document> =
+    D extends Document<unknown, Action, infer L> ? L : never;
+
+export type InferDocumentGenerics<D extends Document> = {
+    state: InferDocumentState<D>;
+    action: InferDocumentOperation<D>;
+    logger: InferDocumentLocalState<D>;
+};
+
+export type ReadModeDriveServerMixin =
+    DocumentDriveServerMixin<IReadModeDriveServer>;
+
+export type ReadDrivesListener = (
+    drives: ReadDrive[],
+    operation: 'add' | 'delete'
+) => void;
+
+export type ReadDrivesListenerUnsubscribe = () => void;
+
+export interface IReadModeDriveServer extends IReadModeDriveService {
+    migrateReadDrive(
+        id: string,
+        options: RemoteDriveOptions
+    ): Promise<DocumentDriveDocument | ReadDriveNotFoundError>;
+    onReadDrivesUpdate(
+        listener: ReadDrivesListener
+    ): Promise<ReadDrivesListenerUnsubscribe>; // TODO: make DriveEvents extensible and reuse event emitter
+}
+
+export type ReadDriveContext = {
+    url: string;
+    filter: ListenerFilter;
+};
+
+export type ReadDrive = DocumentDriveDocument & {
+    readContext: ReadDriveContext;
+};
+
+export type IsDocument<D extends Document> =
+    (<G>() => G extends D ? 1 : 2) extends <G>() => G extends Document ? 1 : 2
+        ? true
+        : false;
+
+export interface IReadModeDriveService {
+    addReadDrive(url: string, filter?: ListenerFilter): Promise<void>;
+
+    getReadDrives(): Promise<string[]>;
+
+    getReadDriveBySlug(
+        slug: string
+    ): Promise<ReadDrive | ReadDriveSlugNotFoundError>;
+
+    getReadDrive(id: string): Promise<ReadDrive | ReadDriveNotFoundError>;
+
+    getReadDriveContext(
+        id: string
+    ): Promise<ReadDriveContext | ReadDriveNotFoundError>;
+
+    fetchDrive(id: string): Promise<ReadDrive | ReadDriveNotFoundError>;
+
+    fetchDocument<D extends Document>(
+        driveId: string,
+        documentId: string,
+        documentType: DocumentModel<
+            InferDocumentState<D>,
+            InferDocumentOperation<D>,
+            InferDocumentLocalState<D>
+        >['documentModel']['id']
+    ): Promise<
+        | Document<
+              InferDocumentState<D>,
+              InferDocumentOperation<D>,
+              InferDocumentLocalState<D>
+          >
+        | DocumentModelNotFoundError
+        | ReadDriveNotFoundError
+        | ReadDocumentNotFoundError
+    >;
+
+    deleteReadDrive(id: string): Promise<ReadDriveNotFoundError | undefined>;
+}
+
+export type GetDocumentModel = (documentType: string) => DocumentModel;

package/src/server/error.ts

@@ -1,6 +1,14 @@
 import type { Operation } from 'document-model/document';
 import type { ErrorStatus } from './types';
 
+export class DocumentModelNotFoundError extends Error {
+    constructor(
+        public id: string,
+        cause?: unknown
+    ) {
+        super(`Document model "${id}" not found`, { cause });
+    }
+}
 export class OperationError extends Error {
     status: ErrorStatus;
     operation: Operation | undefined;