document-drive 1.0.0-alpha.92 → 1.0.0-alpha.94

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "document-drive",
-    "version": "1.0.0-alpha.92",
+    "version": "1.0.0-alpha.94",
     "license": "AGPL-3.0-only",
     "type": "module",
     "module": "./src/index.ts",
@@ -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",
@@ -82,7 +83,8 @@
         "sqlite3": "^5.1.7",
         "typescript": "^5.5.3",
         "vitest": "^2.0.5",
-        "webdriverio": "^9.0.9"
+        "webdriverio": "^9.0.9",
+        "vitest-fetch-mock": "^0.3.0"
     },
     "packageManager": "pnpm@9.1.4+sha256.30a1801ac4e723779efed13a21f4c39f9eb6c9fbb4ced101bce06b422593d7c9"
 }

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,128 @@
+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>();
+
+        // 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, 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));
+        }
+    };
+}

package/src/read-mode/service.ts

@@ -0,0 +1,206 @@
+import type { DocumentDriveDocument } 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,
+    ReadDriveOptions
+} 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, options?: ReadDriveOptions): Promise<void> {
+        const { id } =
+            options?.expectedDriveInfo ?? (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: {
+                ...options,
+                url
+            }
+        });
+    }
+
+    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,108 @@
+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 { DriveInfo } from '../utils/graphql';
+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 ReadDriveOptions = {
+    expectedDriveInfo?: DriveInfo;
+    filter?: ListenerFilter;
+};
+
+export type ReadDriveContext = {
+    url: string;
+} & ReadDriveOptions;
+
+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, options?: ReadDriveOptions): 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;

package/src/server/index.ts

@@ -35,6 +35,7 @@ import {
     Job,
     OperationJob
 } from '../queue/types';
+import { ReadModeServer } from '../read-mode';
 import { MemoryStorage } from '../storage/memory';
 import type {
     DocumentDriveStorage,
@@ -77,15 +78,17 @@ import {
     StrandUpdateSource
 } from './listener/transmitter';
 import {
+    AbstractDocumentDriveServer,
     AddOperationOptions,
-    BaseDocumentDriveServer,
     DefaultListenerManagerOptions,
     DocumentDriveServerOptions,
     DriveEvents,
     GetDocumentOptions,
     GetStrandsOptions,
+    IBaseDocumentDriveServer,
     IOperationResult,
     ListenerState,
+    RemoteDriveAccessLevel,
     RemoteDriveOptions,
     StrandUpdate,
     SynchronizationUnitQuery,
@@ -102,8 +105,14 @@ import { filterOperationsByRevision } from './utils';
 export * from './listener';
 export type * from './types';
 
+export * from '../read-mode';
+
 export const PULL_DRIVE_INTERVAL = 5000;
-export class DocumentDriveServer extends BaseDocumentDriveServer {
+
+export class BaseDocumentDriveServer
+    extends AbstractDocumentDriveServer
+    implements IBaseDocumentDriveServer
+{
     private emitter = createNanoEvents<DriveEvents>();
     private cache: ICache;
     private documentModels: DocumentModel[];
@@ -131,11 +140,10 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
     ) {
         super();
         this.options = {
-            defaultRemoteDrives: [],
-            removeOldRemoteDrives: {
-                strategy: 'preserve-all'
-            },
             ...options,
+            defaultDrives: {
+                ...options?.defaultDrives
+            },
             listenerManager: {
                 ...DefaultListenerManagerOptions,
                 ...options?.listenerManager
@@ -180,6 +188,13 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
         return this.defaultDrivesManager.getDefaultRemoteDrives();
     }
 
+    setDefaultDriveAccessLevel(url: string, level: RemoteDriveAccessLevel) {
+        return this.defaultDrivesManager.setDefaultDriveAccessLevel(url, level);
+    }
+    setAllDefaultDrivesAccessLevel(level: RemoteDriveAccessLevel) {
+        return this.defaultDrivesManager.setAllDefaultDrivesAccessLevel(level);
+    }
+
     private getOperationSource(source: StrandUpdateSource) {
         return source.type === 'local' ? 'push' : 'pull';
     }
@@ -899,7 +914,7 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
         }));
     }
 
-    private _getDocumentModel(documentType: string) {
+    protected getDocumentModel(documentType: string) {
         const documentModel = this.documentModels.find(
             model => model.documentModel.id === documentType
         );
@@ -1093,7 +1108,7 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
         // if no document was provided then create a new one
         const document =
             input.document ??
-            this._getDocumentModel(input.documentType).utils.createDocument();
+            this.getDocumentModel(input.documentType).utils.createDocument();
 
         // stores document information
         const documentStorage: DocumentStorage = {
@@ -1331,7 +1346,7 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
             return documentStorage as T;
         }
 
-        const documentModel = this._getDocumentModel(
+        const documentModel = this.getDocumentModel(
             documentStorage.documentType
         );
 
@@ -1369,7 +1384,7 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
         operation: Operation,
         skipHashValidation = false
     ) {
-        const documentModel = this._getDocumentModel(document.documentType);
+        const documentModel = this.getDocumentModel(document.documentType);
 
         const signalResults: SignalResult[] = [];
         let newDocument = document;
@@ -2205,7 +2220,7 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
         actions: (T | BaseAction)[]
     ): Operation<T | BaseAction>[] {
         const operations: Operation<T | BaseAction>[] = [];
-        const { reducer } = this._getDocumentModel(document.documentType);
+        const { reducer } = this.getDocumentModel(document.documentType);
         for (const action of actions) {
             document = reducer(document, action);
             const operation = document.operations[action.scope].slice().pop();
@@ -2369,3 +2384,5 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
         return this.emitter.emit(event, ...args);
     }
 }
+
+export const DocumentDriveServer = ReadModeServer(BaseDocumentDriveServer);

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

@@ -1,7 +1,7 @@
 import { Document, OperationScope } from 'document-model/document';
 import { logger } from '../../../utils/logger';
 import {
-    BaseDocumentDriveServer,
+    IBaseDocumentDriveServer,
     Listener,
     ListenerRevision,
     OperationUpdate,
@@ -28,11 +28,11 @@ export type InternalTransmitterUpdate<
 };
 
 export class InternalTransmitter implements ITransmitter {
-    private drive: BaseDocumentDriveServer;
+    private drive: IBaseDocumentDriveServer;
     private listener: Listener;
     private receiver: IReceiver | undefined;
 
-    constructor(listener: Listener, drive: BaseDocumentDriveServer) {
+    constructor(listener: Listener, drive: IBaseDocumentDriveServer) {
         this.listener = listener;
         this.drive = drive;
     }

package/src/server/listener/transmitter/pull-responder.ts

@@ -6,8 +6,8 @@ import { gql, requestGraphql } from '../../../utils/graphql';
 import { logger as defaultLogger } from '../../../utils/logger';
 import { OperationError } from '../../error';
 import {
-    BaseDocumentDriveServer,
     GetStrandsOptions,
+    IBaseDocumentDriveServer,
     IOperationResult,
     Listener,
     ListenerRevision,
@@ -46,13 +46,13 @@ export interface IPullResponderTransmitter extends ITransmitter {
 }
 
 export class PullResponderTransmitter implements IPullResponderTransmitter {
-    private drive: BaseDocumentDriveServer;
+    private drive: IBaseDocumentDriveServer;
     private listener: Listener;
     private manager: ListenerManager;
 
     constructor(
         listener: Listener,
-        drive: BaseDocumentDriveServer,
+        drive: IBaseDocumentDriveServer,
         manager: ListenerManager
     ) {
         this.listener = listener;
@@ -68,6 +68,11 @@ export class PullResponderTransmitter implements IPullResponderTransmitter {
         );
     }
 
+    disconnect(): Promise<void> {
+        // TODO remove listener from switchboard
+        return Promise.resolve();
+    }
+
     async processAcknowledge(
         driveId: string,
         listenerId: string,