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

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "document-drive",
-    "version": "1.0.0-alpha.92",
+    "version": "1.0.0-alpha.93",
     "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,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;

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,

package/src/server/listener/transmitter/switchboard-push.ts

@@ -2,7 +2,7 @@ import stringify from 'json-stringify-deterministic';
 import { gql, requestGraphql } from '../../../utils/graphql';
 import { logger } from '../../../utils/logger';
 import {
-    BaseDocumentDriveServer,
+    IBaseDocumentDriveServer,
     Listener,
     ListenerRevision,
     StrandUpdate
@@ -10,11 +10,11 @@ import {
 import { ITransmitter, StrandUpdateSource } from './types';
 
 export class SwitchboardPushTransmitter implements ITransmitter {
-    private drive: BaseDocumentDriveServer;
+    private drive: IBaseDocumentDriveServer;
     private listener: Listener;
     private targetURL: string;
 
-    constructor(listener: Listener, drive: BaseDocumentDriveServer) {
+    constructor(listener: Listener, drive: IBaseDocumentDriveServer) {
         this.listener = listener;
         this.drive = drive;
         this.targetURL = listener.callInfo!.data!;

package/src/server/types.ts

@@ -13,6 +13,7 @@ import type {
     BaseAction,
     CreateChildDocumentInput,
     Document,
+    DocumentModel,
     Operation,
     OperationScope,
     ReducerOptions,
@@ -20,7 +21,10 @@ import type {
     State
 } from 'document-model/document';
 import { Unsubscribe } from 'nanoevents';
+import { BaseDocumentDriveServer } from '.';
+import { IReadModeDriveServer } from '../read-mode/types';
 import { RunAsap } from '../utils';
+import { IDefaultDrivesManager } from '../utils/default-drives-manager';
 import { DriveInfo } from '../utils/graphql';
 import { OperationError, SynchronizationUnitNotFoundError } from './error';
 import {
@@ -29,16 +33,34 @@ import {
     StrandUpdateSource
 } from './listener/transmitter/types';
 
+// eslint-disable-next-line @typescript-eslint/ban-types, @typescript-eslint/no-explicit-any
+export type Constructor<T = object> = new (...args: any[]) => T;
+
+export type DocumentDriveServerConstructor =
+    Constructor<BaseDocumentDriveServer>;
+
+// Mixin type that returns a type extending both the base class and the interface
+export type Mixin<T extends Constructor, I> = T &
+    Constructor<InstanceType<T> & I>;
+
+export type DocumentDriveServerMixin<I> = Mixin<
+    typeof BaseDocumentDriveServer,
+    I
+>;
+
 export type DriveInput = State<
     Omit<DocumentDriveState, '__typename' | 'id' | 'nodes'> & { id?: string },
     DocumentDriveLocalState
 >;
 
+export type RemoteDriveAccessLevel = 'READ' | 'WRITE';
+
 export type RemoteDriveOptions = DocumentDriveLocalState & {
     // TODO make local state optional
     pullFilter?: ListenerFilter;
     pullInterval?: number;
     expectedDriveInfo?: DriveInfo;
+    accessLevel?: RemoteDriveAccessLevel;
 };
 
 export type CreateDocumentInput = CreateChildDocumentInput;
@@ -234,8 +256,10 @@ export type RemoveOldRemoteDrivesOption =
       };
 
 export type DocumentDriveServerOptions = {
-    defaultRemoteDrives?: Array<DefaultRemoteDriveInput>;
-    removeOldRemoteDrives?: RemoveOldRemoteDrivesOption;
+    defaultDrives: {
+        remoteDrives?: Array<DefaultRemoteDriveInput>;
+        removeOldRemoteDrives?: RemoveOldRemoteDrivesOption;
+    };
     /* method to queue heavy tasks that might block the event loop.
      * If set to null then it will queued as micro task.
      * Defaults to the most appropriate method according to the system
@@ -250,7 +274,7 @@ export type GetStrandsOptions = {
     fromRevision?: number;
 };
 
-export abstract class BaseDocumentDriveServer {
+export abstract class AbstractDocumentDriveServer {
     /** Public methods **/
     abstract getDrives(): Promise<string[]>;
     abstract addDrive(drive: DriveInput): Promise<DocumentDriveDocument>;
@@ -416,6 +440,8 @@ export abstract class BaseDocumentDriveServer {
     ): Promise<Document>;
     protected abstract deleteDocument(drive: string, id: string): Promise<void>;
 
+    protected abstract getDocumentModel(documentType: string): DocumentModel;
+
     /** Event methods **/
     protected abstract emit<K extends keyof DriveEvents>(
         this: this,
@@ -450,17 +476,26 @@ export const DefaultListenerManagerOptions = {
     sequentialUpdates: true
 };
 
+export type IBaseDocumentDriveServer = Pick<
+    AbstractDocumentDriveServer,
+    keyof AbstractDocumentDriveServer
+>;
+
+export type IDocumentDriveServer = IBaseDocumentDriveServer &
+    IDefaultDrivesManager &
+    IReadModeDriveServer;
+
 export abstract class BaseListenerManager {
-    protected drive: BaseDocumentDriveServer;
-    protected options: ListenerManagerOptions;
+    protected drive: IBaseDocumentDriveServer;
     protected listenerState = new Map<string, Map<string, ListenerState>>();
+    protected options: ListenerManagerOptions;
     protected transmitters: Record<
         DocumentDriveState['id'],
         Record<Listener['listenerId'], ITransmitter>
     > = {};
 
     constructor(
-        drive: BaseDocumentDriveServer,
+        drive: IBaseDocumentDriveServer,
         listenerState = new Map<string, Map<string, ListenerState>>(),
         options: ListenerManagerOptions = DefaultListenerManagerOptions
     ) {
@@ -514,11 +549,6 @@ export abstract class BaseListenerManager {
     ): Promise<void>;
 }
 
-export type IDocumentDriveServer = Pick<
-    BaseDocumentDriveServer,
-    keyof BaseDocumentDriveServer
->;
-
 export type ListenerStatus =
     | 'CREATED'
     | 'PENDING'

package/src/storage/base.ts

@@ -0,0 +1,84 @@
+import { DocumentDriveAction } from 'document-model-libs/document-drive';
+import { BaseAction, DocumentHeader, Operation } from 'document-model/document';
+import { SynchronizationUnitQuery } from '../server';
+import {
+    DocumentDriveStorage,
+    DocumentStorage,
+    IDriveStorage,
+    IStorage,
+    IStorageDelegate
+} from './types';
+
+abstract class BaseStorage implements IStorage {
+    abstract checkDocumentExists(drive: string, id: string): Promise<boolean>;
+
+    abstract getDocuments(drive: string): Promise<string[]>;
+
+    abstract getDocument(drive: string, id: string): Promise<DocumentStorage>;
+
+    abstract createDocument(
+        drive: string,
+        id: string,
+        document: DocumentStorage
+    ): Promise<void>;
+
+    abstract addDocumentOperations(
+        drive: string,
+        id: string,
+        operations: Operation[],
+        header: DocumentHeader
+    ): Promise<void>;
+
+    abstract addDocumentOperationsWithTransaction?(
+        drive: string,
+        id: string,
+        callback: (document: DocumentStorage) => Promise<{
+            operations: Operation[];
+            header: DocumentHeader;
+        }>
+    ): Promise<void>;
+
+    abstract deleteDocument(drive: string, id: string): Promise<void>;
+
+    abstract getOperationResultingState?(
+        drive: string,
+        id: string,
+        index: number,
+        scope: string,
+        branch: string
+    ): Promise<unknown>;
+
+    abstract setStorageDelegate?(delegate: IStorageDelegate): void;
+
+    abstract getSynchronizationUnitsRevision(
+        units: SynchronizationUnitQuery[]
+    ): Promise<
+        {
+            driveId: string;
+            documentId: string;
+            scope: string;
+            branch: string;
+            lastUpdated: string;
+            revision: number;
+        }[]
+    >;
+}
+
+export abstract class BaseDriveStorage
+    extends BaseStorage
+    implements IDriveStorage
+{
+    abstract getDrives(): Promise<string[]>;
+    abstract getDrive(id: string): Promise<DocumentDriveStorage>;
+    abstract getDriveBySlug(slug: string): Promise<DocumentDriveStorage>;
+    abstract createDrive(
+        id: string,
+        drive: DocumentDriveStorage
+    ): Promise<void>;
+    abstract deleteDrive(id: string): Promise<void>;
+    abstract addDriveOperations(
+        id: string,
+        operations: Operation<DocumentDriveAction | BaseAction>[],
+        header: DocumentHeader
+    ): Promise<void>;
+}

package/src/storage/index.ts

@@ -1 +1,2 @@
+export * from './base';
 export type * from './types';

package/src/utils/default-drives-manager.ts

@@ -1,8 +1,10 @@
 import {
-    BaseDocumentDriveServer,
     DefaultRemoteDriveInfo,
     DocumentDriveServerOptions,
     DriveEvents,
+    IBaseDocumentDriveServer,
+    IReadModeDriveServer,
+    RemoteDriveAccessLevel,
     RemoveOldRemoteDrivesOption
 } from '../server';
 import { DriveNotFoundError } from '../server/error';
@@ -13,20 +15,34 @@ export interface IServerDelegateDrivesManager {
     emit: (...args: Parameters<DriveEvents['defaultRemoteDrive']>) => void;
 }
 
-export class DefaultDrivesManager {
+function isReadModeDriveServer(obj: unknown): obj is IReadModeDriveServer {
+    return typeof (obj as IReadModeDriveServer).getReadDrives === 'function';
+}
+
+export interface IDefaultDrivesManager {
+    getDefaultRemoteDrives(): Map<string, DefaultRemoteDriveInfo>;
+    setDefaultDriveAccessLevel(
+        url: string,
+        level: RemoteDriveAccessLevel
+    ): Promise<void>;
+    setAllDefaultDrivesAccessLevel(
+        level: RemoteDriveAccessLevel
+    ): Promise<void>;
+}
+
+export class DefaultDrivesManager implements IDefaultDrivesManager {
     private defaultRemoteDrives = new Map<string, DefaultRemoteDriveInfo>();
     private removeOldRemoteDrivesConfig: RemoveOldRemoteDrivesOption;
 
     constructor(
-        private server: BaseDocumentDriveServer,
+        private server:
+            | IBaseDocumentDriveServer
+            | (IBaseDocumentDriveServer & IReadModeDriveServer),
         private delegate: IServerDelegateDrivesManager,
-        options?: Pick<
-            DocumentDriveServerOptions,
-            'defaultRemoteDrives' | 'removeOldRemoteDrives'
-        >
+        options?: Pick<DocumentDriveServerOptions, 'defaultDrives'>
     ) {
-        if (options?.defaultRemoteDrives) {
-            for (const defaultDrive of options.defaultRemoteDrives) {
+        if (options?.defaultDrives.remoteDrives) {
+            for (const defaultDrive of options.defaultDrives.remoteDrives) {
                 this.defaultRemoteDrives.set(defaultDrive.url, {
                     ...defaultDrive,
                     status: 'PENDING'
@@ -34,13 +50,18 @@ export class DefaultDrivesManager {
             }
         }
 
-        this.removeOldRemoteDrivesConfig = options?.removeOldRemoteDrives || {
+        this.removeOldRemoteDrivesConfig = options?.defaultDrives
+            .removeOldRemoteDrives || {
             strategy: 'preserve-all'
         };
     }
 
     getDefaultRemoteDrives() {
-        return this.defaultRemoteDrives;
+        return new Map(
+            JSON.parse(
+                JSON.stringify(Array.from(this.defaultRemoteDrives))
+            ) as Iterable<[string, DefaultRemoteDriveInfo]>
+        );
     }
 
     private async deleteDriveById(driveId: string) {
@@ -145,10 +166,40 @@ export class DefaultDrivesManager {
         }
     }
 
-    async initializeDefaultRemoteDrives() {
+    async setAllDefaultDrivesAccessLevel(level: RemoteDriveAccessLevel) {
+        const drives = this.defaultRemoteDrives.values();
+        for (const drive of drives) {
+            await this.setDefaultDriveAccessLevel(drive.url, level);
+        }
+    }
+
+    async setDefaultDriveAccessLevel(
+        url: string,
+        level: RemoteDriveAccessLevel
+    ) {
+        const drive = this.defaultRemoteDrives.get(url);
+        if (drive && drive.options.accessLevel !== level) {
+            const newDriveValue = {
+                ...drive,
+                options: { ...drive.options, accessLevel: level }
+            };
+            this.defaultRemoteDrives.set(url, newDriveValue);
+            await this.initializeDefaultRemoteDrives([newDriveValue]);
+        }
+    }
+
+    async initializeDefaultRemoteDrives(
+        defaultDrives: DefaultRemoteDriveInfo[] = Array.from(
+            this.defaultRemoteDrives.values()
+        )
+    ) {
         const drives = await this.server.getDrives();
+        const readServer = isReadModeDriveServer(this.server)
+            ? (this.server as IReadModeDriveServer)
+            : undefined;
+        const readDrives = await readServer?.getReadDrives();
 
-        for (const remoteDrive of this.defaultRemoteDrives.values()) {
+        for (const remoteDrive of defaultDrives) {
             let remoteDriveInfo = { ...remoteDrive };
 
             try {
@@ -158,7 +209,29 @@ export class DefaultDrivesManager {
 
                 this.defaultRemoteDrives.set(remoteDrive.url, remoteDriveInfo);
 
-                if (drives.includes(driveInfo.id)) {
+                const driveIsAdded = drives.includes(driveInfo.id);
+                const readDriveIsAdded = readDrives?.includes(driveInfo.id);
+
+                const readMode =
+                    readServer && remoteDrive.options.accessLevel === 'READ';
+                const isAdded = readMode ? readDriveIsAdded : driveIsAdded;
+
+                // if the read mode has changed then existing drives
+                // in the previous mode should be deleted
+                const driveToDelete = readMode
+                    ? driveIsAdded
+                    : readDriveIsAdded;
+                if (driveToDelete) {
+                    try {
+                        await (readMode
+                            ? this.server.deleteDrive(driveInfo.id)
+                            : readServer?.deleteReadDrive(driveInfo.id));
+                    } catch (e) {
+                        logger.error(e);
+                    }
+                }
+
+                if (isAdded) {
                     remoteDriveInfo.status = 'ALREADY_ADDED';
 
                     this.defaultRemoteDrives.set(

package/src/utils/graphql.ts

@@ -1,8 +1,60 @@
+import { pascalCase } from 'change-case';
+import {
+    DocumentDriveLocalState,
+    FileNode,
+    FolderNode
+} from 'document-model-libs/document-drive';
+import { Document, DocumentModel, Operation } from 'document-model/document';
+import { DocumentModelState } from 'document-model/document-model';
+import {
+    BuildSchemaOptions,
+    GraphQLError,
+    GraphQLList,
+    GraphQLNonNull,
+    GraphQLObjectType,
+    GraphQLOutputType,
+    GraphQLScalarType,
+    GraphQLUnionType,
+    ParseOptions,
+    buildSchema
+} from 'graphql';
 import request, { GraphQLClient, gql } from 'graphql-request';
+import {
+    InferDocumentLocalState,
+    InferDocumentOperation,
+    InferDocumentState
+} from '../read-mode/types';
 import { logger } from './logger';
 
 export { gql } from 'graphql-request';
 
+type ReqGraphQLError = {
+    message: string;
+};
+
+export type GraphQLResult<T> = { [K in keyof T]: T[K] | null } & {
+    errors?: GraphQLError[];
+};
+
+// replaces fetch so it can be used in Node and Browser envs
+export async function requestGraphql<T>(
+    ...args: Parameters<typeof request>
+): Promise<GraphQLResult<T>> {
+    const [url, ...requestArgs] = args;
+    const client = new GraphQLClient(url, { fetch });
+    const { errors, ...response } = await client.request<
+        { [K in keyof T]: T[K] | null } & { errors?: ReqGraphQLError[] }
+    >(...requestArgs);
+
+    const result = { ...response } as GraphQLResult<T>;
+    if (errors?.length) {
+        result.errors = errors.map(
+            ({ message, ...options }) => new GraphQLError(message, options)
+        );
+    }
+    return result;
+}
+
 export type DriveInfo = {
     id: string;
     name: string;
@@ -10,11 +62,80 @@ export type DriveInfo = {
     icon?: string;
 };
 
-// replaces fetch so it can be used in Node and Browser envs
-export async function requestGraphql<T>(...args: Parameters<typeof request>) {
-    const [url, ...requestArgs] = args;
-    const client = new GraphQLClient(url, { fetch });
-    return client.request<T>(...requestArgs);
+function getFields(type: GraphQLOutputType): string {
+    if (type instanceof GraphQLObjectType) {
+        return Object.entries(type.getFields())
+            .map(([fieldName, field]) => {
+                const fieldType =
+                    field.type instanceof GraphQLNonNull
+                        ? field.type.ofType
+                        : field.type;
+
+                if (
+                    fieldType instanceof GraphQLObjectType ||
+                    fieldType instanceof GraphQLUnionType
+                ) {
+                    return `${fieldName} { ${getFields(fieldType)} }`;
+                }
+
+                if (fieldType instanceof GraphQLList) {
+                    const listItemType =
+                        fieldType.ofType instanceof GraphQLNonNull
+                            ? fieldType.ofType.ofType
+                            : fieldType.ofType;
+
+                    if (listItemType instanceof GraphQLScalarType) {
+                        return fieldName;
+                    } else if (
+                        listItemType instanceof GraphQLObjectType ||
+                        listItemType instanceof GraphQLUnionType
+                    ) {
+                        return `${fieldName} { ${getFields(listItemType)} }`;
+                    } else {
+                        throw new Error(
+                            `List item type ${listItemType.toString()} is not handled`
+                        );
+                    }
+                }
+
+                return fieldName;
+            })
+            .join(' ');
+    } else if (type instanceof GraphQLUnionType) {
+        return type
+            .getTypes()
+            .map(unionType => {
+                return `... on ${unionType.name} { ${getFields(unionType)} }`;
+            })
+            .join(' ');
+    }
+    return '';
+}
+
+export function generateDocumentStateQueryFields(
+    documentModel: DocumentModelState,
+    options?: BuildSchemaOptions & ParseOptions
+): string {
+    const name = pascalCase(documentModel.name);
+    const spec = documentModel.specifications.at(-1);
+    if (!spec) {
+        throw new Error('No document model specification found');
+    }
+    const source = `${spec.state.global.schema} type Query { ${name}: ${name}State }`;
+    const schema = buildSchema(source, options);
+    const queryType = schema.getQueryType();
+    if (!queryType) {
+        throw new Error('No query type found');
+    }
+    const fields = queryType.getFields();
+    const stateQuery = fields[name];
+
+    if (!stateQuery) {
+        throw new Error('No state query found');
+    }
+
+    const queryFields = getFields(stateQuery.type);
+    return queryFields;
 }
 
 export async function requestPublicDrive(url: string): Promise<DriveInfo> {
@@ -33,15 +154,135 @@ export async function requestPublicDrive(url: string): Promise<DriveInfo> {
                 }
             `
         );
+        if (result.errors?.length || !result.drive) {
+            throw result.errors?.at(0) ?? new Error('Drive not found');
+        }
         drive = result.drive;
     } catch (e) {
         logger.error(e);
         throw new Error("Couldn't find drive info");
     }
 
-    if (!drive) {
-        throw new Error('Drive not found');
-    }
-
     return drive;
 }
+
+export type DriveState = DriveInfo &
+    Pick<DocumentDriveLocalState, 'availableOffline' | 'sharingType'> & {
+        nodes: Array<FolderNode | Omit<FileNode, 'synchronizationUnits'>>;
+    };
+
+export async function fetchDocument<D extends Document>(
+    url: string,
+    documentId: string,
+    documentModelLib: DocumentModel<
+        InferDocumentState<D>,
+        InferDocumentOperation<D>,
+        InferDocumentLocalState<D>
+    >
+): Promise<
+    GraphQLResult<{
+        document: Document<
+            InferDocumentState<D>,
+            InferDocumentOperation<D>,
+            InferDocumentLocalState<D>
+        >;
+    }>
+> {
+    const { documentModel, utils } = documentModelLib;
+    const stateFields = generateDocumentStateQueryFields(documentModel);
+    const name = pascalCase(documentModel.name);
+    const result = await requestGraphql<{
+        document: Pick<
+            D,
+            'name' | 'created' | 'documentType' | 'lastModified'
+        > & {
+            id: string;
+            revision: number;
+            state: InferDocumentState<D>;
+            initialState: InferDocumentState<D>;
+            operations: (Pick<
+                Operation,
+                | 'id'
+                | 'hash'
+                | 'index'
+                | 'skip'
+                | 'timestamp'
+                | 'type'
+                | 'error'
+            > & { inputText: string })[];
+        };
+    }>(
+        url,
+        gql`
+            query ($id: String!) {
+                document(id: $id) {
+                    id
+                    name
+                    created
+                    documentType
+                    lastModified
+                    revision
+                    operations {
+                        id
+                        error
+                        hash
+                        index
+                        skip
+                        timestamp
+                        type
+                        inputText
+                    }
+                    ... on ${name} {
+                        state {
+                            ${stateFields}
+                        }
+                        initialState {
+                            ${stateFields}
+                        }
+                    }
+                }
+            }
+        `,
+        { id: documentId }
+    );
+    const document: Document<
+        InferDocumentState<D>,
+        InferDocumentOperation<D>,
+        InferDocumentLocalState<D>
+    > | null = result.document
+        ? {
+              ...result.document,
+              revision: {
+                  global: result.document.revision,
+                  local: 0
+              },
+              state: utils.createState({ global: result.document.state }),
+              operations: {
+                  global: result.document.operations.map(
+                      ({ inputText, ...o }) => ({
+                          ...o,
+                          error: o.error ?? undefined,
+                          scope: 'global',
+                          input: JSON.parse(inputText) as D
+                      })
+                  ),
+                  local: []
+              },
+              attachments: {},
+              initialState: utils.createExtendedState({
+                  // TODO: getDocument should return all the initial state fields
+                  created: result.document.created,
+                  lastModified: result.document.created,
+                  state: utils.createState({
+                      global: result.document.initialState
+                  })
+              }),
+              clipboard: []
+          }
+        : null;
+
+    return {
+        ...result,
+        document
+    };
+}