document-drive 1.0.0-alpha.52 → 1.0.0-alpha.53

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "document-drive",
-    "version": "1.0.0-alpha.52",
+    "version": "1.0.0-alpha.53",
     "license": "AGPL-3.0-only",
     "type": "module",
     "module": "./src/index.ts",

package/src/server/index.ts

@@ -122,16 +122,16 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
 
         const result = await (!strand.documentId
             ? this.addDriveOperations(
-                  strand.driveId,
-                  operations as Operation<DocumentDriveAction | BaseAction>[],
-                  false
-              )
+                strand.driveId,
+                operations as Operation<DocumentDriveAction | BaseAction>[],
+                false
+            )
             : this.addOperations(
-                  strand.driveId,
-                  strand.documentId,
-                  operations,
-                  false
-              ));
+                strand.driveId,
+                strand.documentId,
+                operations,
+                false
+            ));
 
         if (result.status === 'ERROR') {
             this.updateSyncStatus(strand.driveId, result.status, result.error);
@@ -299,14 +299,14 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
             const nodeUnits =
                 scope?.length || branch?.length
                     ? node.synchronizationUnits.filter(
-                          unit =>
-                              (!scope?.length ||
-                                  scope.includes(unit.scope) ||
-                                  scope.includes('*')) &&
-                              (!branch?.length ||
-                                  branch.includes(unit.branch) ||
-                                  branch.includes('*'))
-                      )
+                        unit =>
+                            (!scope?.length ||
+                                scope.includes(unit.scope) ||
+                                scope.includes('*')) &&
+                            (!branch?.length ||
+                                branch.includes(unit.branch) ||
+                                branch.includes('*'))
+                    )
                     : node.synchronizationUnits;
             if (!nodeUnits.length) {
                 continue;
@@ -494,19 +494,7 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
             logger.error('Error getting drive from cache', e);
         }
         const driveStorage = await this.storage.getDrive(drive);
-        const documentModel = this._getDocumentModel(driveStorage.documentType);
-        const document = baseUtils.replayDocument(
-            driveStorage.initialState,
-            filterOperationsByRevision(
-                driveStorage.operations,
-                options?.revisions
-            ),
-            documentModel.reducer,
-            undefined,
-            driveStorage,
-            undefined,
-            { checkHashes: false }
-        );
+        const document = this._replayDocument(driveStorage, options);
         if (!isDocumentDrive(document)) {
             throw new Error(
                 `Document with id ${drive} is not a Document Drive`
@@ -519,6 +507,30 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
         }
     }
 
+    async getDriveBySlug(slug: string, options?: GetDocumentOptions) {
+        try {
+            const document = await this.cache.getDocument('drives', slug);
+            if (document && isDocumentDrive(document)) {
+                return document;
+            }
+        } catch (e) {
+            logger.error('Error getting drive from cache', e);
+        }
+
+        const driveStorage = await this.storage.getDriveBySlug(slug);
+        const document = this._replayDocument(driveStorage, options);
+        if (!isDocumentDrive(document)) {
+            throw new Error(
+                `Document with slug ${slug} is not a Document Drive`
+            );
+        } else {
+            this.cache
+                .setDocument('drives', slug, document)
+                .catch(logger.error);
+            return document;
+        }
+    }
+
     async getDocument(drive: string, id: string, options?: GetDocumentOptions) {
         try {
             const document = await this.cache.getDocument(drive, id);
@@ -664,11 +676,11 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
                         e instanceof OperationError
                             ? e
                             : new OperationError(
-                                  'ERROR',
-                                  nextOperation,
-                                  (e as Error).message,
-                                  (e as Error).cause
-                              );
+                                'ERROR',
+                                nextOperation,
+                                (e as Error).message,
+                                (e as Error).cause
+                            );
 
                     // TODO: don't break on errors...
                     break;
@@ -925,11 +937,11 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
                 error instanceof OperationError
                     ? error
                     : new OperationError(
-                          'ERROR',
-                          undefined,
-                          (error as Error).message,
-                          (error as Error).cause
-                      );
+                        'ERROR',
+                        undefined,
+                        (error as Error).message,
+                        (error as Error).cause
+                    );
 
             return {
                 status: operationError.status,
@@ -1097,11 +1109,11 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
                 error instanceof OperationError
                     ? error
                     : new OperationError(
-                          'ERROR',
-                          undefined,
-                          (error as Error).message,
-                          (error as Error).cause
-                      );
+                        'ERROR',
+                        undefined,
+                        (error as Error).message,
+                        (error as Error).cause
+                    );
 
             return {
                 status: operationError.status,
@@ -1268,4 +1280,22 @@ export class DocumentDriveServer extends BaseDocumentDriveServer {
         logger.debug(`Emitting event ${event}`, args);
         return this.emitter.emit(event, ...args);
     }
+
+    private _replayDocument(documentStorage: DocumentStorage, options?: GetDocumentOptions) {
+        const documentModel = this._getDocumentModel(documentStorage.documentType);
+        const document = baseUtils.replayDocument(
+            documentStorage.initialState,
+            filterOperationsByRevision(
+                documentStorage.operations,
+                options?.revisions
+            ),
+            documentModel.reducer,
+            undefined,
+            documentStorage,
+            undefined,
+            { checkHashes: false }
+        );
+
+        return document;
+    }
 }

package/src/storage/browser.ts

@@ -111,6 +111,19 @@ export class BrowserStorage implements IDriveStorage {
         return drive;
     }
 
+    async getDriveBySlug(slug: string) {
+        // get oldes drives first
+        const drives = (await this.getDrives()).reverse();
+        for (const drive of drives) {
+            const driveData = await this.getDrive(drive);
+            if (driveData.initialState.state.global.slug === slug) {
+                return this.getDrive(drive);
+            }
+        }
+
+        throw new Error(`Drive with slug ${slug} not found`);
+    }
+
     async createDrive(id: string, drive: DocumentDriveStorage) {
         const db = await this.db;
         await db.setItem(this.buildKey(BrowserStorage.DRIVES_KEY, id), drive);

package/src/storage/filesystem.ts

@@ -197,6 +197,18 @@ export class FilesystemStorage implements IDriveStorage {
         }
     }
 
+    async getDriveBySlug(slug: string) {
+        // get oldes drives first
+        const drives = (await this.getDrives()).reverse();
+        for (const drive of drives) {
+            const { initialState: { state: { global: { slug: driveSlug } } } } = await this.getDrive(drive);
+            if (driveSlug === slug) {
+                return this.getDrive(drive);
+            }
+        }
+        throw new Error(`Drive with slug ${slug} not found`);
+    }
+
     createDrive(id: string, drive: DocumentDriveStorage) {
         return this.createDocument(FilesystemStorage.DRIVES_DIR, id, drive);
     }

package/src/storage/memory.ts

@@ -11,6 +11,7 @@ import { DocumentDriveStorage, DocumentStorage, IDriveStorage } from './types';
 export class MemoryStorage implements IDriveStorage {
     private documents: Record<string, Record<string, DocumentStorage>>;
     private drives: Record<string, DocumentDriveStorage>;
+    private slugToDriveId: Record<string, string> = {};
 
     constructor() {
         this.documents = {};
@@ -116,8 +117,20 @@ export class MemoryStorage implements IDriveStorage {
         return drive;
     }
 
+    async getDriveBySlug(slug: string) {
+        const driveId = this.slugToDriveId[slug];
+        if (!driveId) {
+            throw new Error(`Drive with slug ${slug} not found`);
+        }
+        return this.getDrive(driveId);
+    }
+
     async createDrive(id: string, drive: DocumentDriveStorage) {
         this.drives[id] = drive;
+        const { slug } = drive.initialState.state.global;
+        if (slug) {
+            this.slugToDriveId[slug] = id;
+        }
     }
 
     async addDriveOperations(

package/src/storage/prisma.ts

@@ -17,7 +17,6 @@ import type {
 import { ConflictOperationError } from '../server/error';
 import { logger } from '../utils/logger';
 import { DocumentDriveStorage, DocumentStorage, IDriveStorage } from './types';
-import { JitterType } from 'exponential-backoff/dist/options';
 
 type Transaction = Omit<
     PrismaClient<Prisma.PrismaClientOptions, never>,
@@ -79,6 +78,18 @@ export class PrismaStorage implements IDriveStorage {
     async createDrive(id: string, drive: DocumentDriveStorage): Promise<void> {
         // drive for all drive documents
         await this.createDocument('drives', id, drive as DocumentStorage);
+        const count = await this.db.drive.upsert({
+            where: {
+                slug: drive.initialState.state.global.slug ?? id
+            },
+            create: {
+                id: id,
+                slug: drive.initialState.state.global.slug ?? id
+            },
+            update: {
+                id
+            }
+        });
     }
     async addDriveOperations(
         id: string,
@@ -391,6 +402,20 @@ export class PrismaStorage implements IDriveStorage {
         }
     }
 
+    async getDriveBySlug(slug: string) {
+        const driveEntity = await this.db.drive.findFirst({
+            where: {
+                slug
+            }
+        });
+
+        if (!driveEntity) {
+            throw new Error(`Drive with slug ${slug} not found`);
+        }
+
+        return this.getDrive(driveEntity.id);
+    }
+
     async deleteDrive(id: string) {
         await this.db.document.deleteMany({
             where: {

package/src/storage/sequelize.ts

@@ -20,6 +20,13 @@ export class SequelizeStorage implements IDriveStorage {
     }
 
     public syncModels() {
+        const Drive = this.db.define('drive', {
+            slug: {
+                type: DataTypes.STRING,
+                primaryKey: true
+            },
+            id: DataTypes.STRING,
+        })
         const Document = this.db.define('document', {
             id: {
                 type: DataTypes.STRING,
@@ -113,6 +120,8 @@ export class SequelizeStorage implements IDriveStorage {
 
     async createDrive(id: string, drive: DocumentDriveStorage): Promise<void> {
         await this.createDocument('drives', id, drive as DocumentStorage);
+        const Drive = this.db.models.drive;
+        await Drive?.upsert({ id, slug: drive.initialState.state.global.slug });
     }
     async addDriveOperations(
         id: string,
@@ -379,6 +388,25 @@ export class SequelizeStorage implements IDriveStorage {
         return doc as DocumentDriveStorage;
     }
 
+    async getDriveBySlug(slug: string) {
+        const Drive = this.db.models.drive;
+        if (!Drive) {
+            throw new Error('Drive model not found');
+        }
+
+        const driveEntity = await Drive.findOne({
+            where: {
+                slug
+            }
+        });
+
+        if (!driveEntity) {
+            throw new Error(`Drive with slug ${slug} not found`);
+        }
+
+        return this.getDrive(driveEntity.dataValues.id);
+    }
+
     async deleteDrive(id: string) {
         await this.deleteDocument('drives', id);
 
@@ -392,5 +420,14 @@ export class SequelizeStorage implements IDriveStorage {
                 driveId: id
             }
         });
+
+        const Drive = this.db.models.drive;
+        if (Drive) {
+            await Drive.destroy({
+                where: {
+                    id: id
+                }
+            });
+        }
     }
 }

package/src/storage/types.ts

@@ -8,6 +8,7 @@ import type {
     DocumentHeader,
     Operation
 } from 'document-model/document';
+import { GetDocumentOptions } from '../server';
 
 export type DocumentStorage<D extends Document = Document> = Omit<
     D,
@@ -45,6 +46,7 @@ export interface IStorage {
 export interface IDriveStorage extends IStorage {
     getDrives(): Promise<string[]>;
     getDrive(id: string): Promise<DocumentDriveStorage>;
+    getDriveBySlug(slug: string): Promise<DocumentDriveStorage>;
     createDrive(id: string, drive: DocumentDriveStorage): Promise<void>;
     deleteDrive(id: string): Promise<void>;
     clearStorage?(): Promise<void>;

package/src/utils/index.ts

@@ -98,3 +98,4 @@ export function isNoopUpdate(
 export function isBefore(dateA: Date | string, dateB: Date | string) {
     return new Date(dateA) < new Date(dateB);
 }
+