document-drive 5.0.0-staging.9 → 5.0.1-staging.2

package/dist/test/server.test.js

@@ -0,0 +1,957 @@
+import { BrowserStorage, InMemoryCache, MemoryStorage, ReactorBuilder, SynchronizationManager, addFile, addFolder, baseDocumentModels, copyNode, deleteNode, driveDocumentModelModule, driveDocumentReducer, expectUUID, setDriveName, } from "document-drive";
+import { FilesystemStorage } from "document-drive/storage/filesystem";
+import { PrismaStorage } from "document-drive/storage/prisma";
+import { PrismaClient } from "document-drive/storage/prisma/client";
+import { documentModelCreateDocument, documentModelDocumentModelModule, setModelName, } from "document-model";
+import { createPresignedHeader, generateId } from "document-model/core";
+import fs from "node:fs/promises";
+import path from "path";
+import { afterEach, beforeEach, describe, it, vi } from "vitest";
+const documentModels = baseDocumentModels;
+const DocumentDriveUtils = { ...driveDocumentModelModule.utils };
+const DocumentModelUtils = documentModelDocumentModelModule.utils;
+const FileStorageDir = path.join(__dirname, "./file-storage");
+const prismaClient = new PrismaClient();
+const cache = new InMemoryCache();
+const storageLayers = [
+    ["MemoryStorage", async () => new MemoryStorage()],
+    ["FilesystemStorage", async () => new FilesystemStorage(FileStorageDir)],
+    [
+        "BrowserStorage",
+        async () => {
+            const storage = new BrowserStorage();
+            await storage.clear();
+            return storage;
+        },
+    ],
+    ["PrismaStorage", async () => new PrismaStorage(prismaClient, cache)],
+];
+const file = undefined;
+// TODO import RealWorldAssets
+// try {
+//   file = await DocumentModelsLibs.RealWorldAssets.utils.loadFromFile(
+//     "./test/rwa-document.zip",
+//   );
+// } catch {
+//   /* empty */
+// }
+describe.each(storageLayers)("%s", (storageName, buildStorage) => {
+    beforeEach(async () => {
+        vi.setSystemTime(new Date("2024-01-01"));
+        cache.clear();
+        if (storageName === "FilesystemStorage") {
+            return fs.rm(FileStorageDir, { recursive: true, force: true });
+        }
+        else if (storageName === "BrowserStorage") {
+            return (await buildStorage()).clear();
+        }
+        else if (storageName === "PrismaStorage") {
+            await prismaClient.$executeRawUnsafe('DELETE FROM "Attachment";');
+            await prismaClient.$executeRawUnsafe('DELETE FROM "Operation";');
+            await prismaClient.$executeRawUnsafe('DELETE FROM "DriveDocument";');
+            await prismaClient.$executeRawUnsafe('DELETE FROM "Document";');
+            await prismaClient.$executeRawUnsafe('DELETE FROM "Drive";');
+        }
+    });
+    afterEach(async () => {
+        vi.useRealTimers();
+        if (storageName === "FilesystemStorage") {
+            return fs.rm(FileStorageDir, { recursive: true, force: true });
+        }
+        else if (storageName === "BrowserStorage") {
+            return (await buildStorage()).clear();
+        }
+        else if (storageName === "PrismaStorage") {
+            //await prismaClient.$executeRawUnsafe('DELETE FROM "Attachment";');
+            //await prismaClient.$executeRawUnsafe('DELETE FROM "Operation";');
+            //await prismaClient.$executeRawUnsafe('DELETE FROM "Document";');
+            //await prismaClient.$executeRawUnsafe('DELETE FROM "Drive";');
+        }
+    });
+    function createDocumentModelWithId(id) {
+        return {
+            ...documentModelCreateDocument(),
+            header: createPresignedHeader(id, documentModelDocumentModelModule.documentModel.global.id),
+        };
+    }
+    it("adds drive to server", async ({ expect }) => {
+        const driveId = generateId();
+        const server = new ReactorBuilder(documentModels)
+            .withCache(cache)
+            .withStorage(await buildStorage())
+            .build();
+        await server.addDrive({
+            id: driveId,
+            global: {
+                name: "name",
+                icon: "icon",
+            },
+            local: {
+                availableOffline: false,
+                sharingType: "PUBLIC",
+                listeners: [],
+                triggers: [],
+            },
+        });
+        const drive = await server.getDrive(driveId);
+        expect(drive.state).toStrictEqual(DocumentDriveUtils.createState({
+            global: {
+                name: "name",
+                icon: "icon",
+                nodes: [],
+            },
+            local: {
+                availableOffline: false,
+                sharingType: "PUBLIC",
+                listeners: [],
+                triggers: [],
+            },
+        }));
+        const drives = await server.getDrives();
+        expect(drives.includes(driveId)).toBeTruthy();
+    });
+    it.skipIf(!file)("adds file to server", async ({ expect }) => {
+        const driveId = generateId();
+        const documentId = generateId();
+        const server = new ReactorBuilder(documentModels)
+            .withCache(cache)
+            .withStorage(await buildStorage())
+            .build();
+        await server.addDocument(createDocumentModelWithId(documentId));
+        await server.addDrive({
+            id: driveId,
+            slug: "slug",
+            global: {
+                name: "name",
+                icon: "icon",
+            },
+            local: {
+                availableOffline: false,
+                sharingType: "public",
+                listeners: [],
+                triggers: [],
+            },
+        });
+        let drive = await server.getDrive(driveId);
+        // performs ADD_FILE operation locally
+        drive = driveDocumentReducer(drive, addFile({
+            id: documentId,
+            name: "document 1",
+            documentType: "powerhouse/document-model",
+        }));
+        // dispatches operation to server
+        const operation = drive.operations.global[0];
+        const operationResult = await server.addOperation(driveId, operation);
+        expect(operationResult.status).toBe("SUCCESS");
+        drive = await server.getDrive(driveId);
+        expect(drive.state).toStrictEqual(operationResult.document?.state);
+        expect(drive.state.global.nodes[0]).toStrictEqual({
+            id: documentId,
+            kind: "file",
+            name: "document 1",
+            documentType: "powerhouse/document-model",
+            parentFolder: null,
+            synchronizationUnits: [
+                {
+                    branch: "main",
+                    scope: "global",
+                    syncId: expectUUID(expect),
+                },
+                {
+                    branch: "main",
+                    scope: "local",
+                    syncId: expectUUID(expect),
+                },
+            ],
+        });
+    });
+    it("adds document as child when file is added to server", async ({ expect, }) => {
+        const driveId = generateId();
+        const documentId = generateId();
+        const storage = await buildStorage();
+        const server = new ReactorBuilder(documentModels)
+            .withCache(cache)
+            .withStorage(storage)
+            .build();
+        await server.addDrive({
+            id: driveId,
+            slug: "slug",
+            global: {
+                name: "name",
+                icon: "icon",
+            },
+            local: {
+                availableOffline: false,
+                sharingType: "public",
+                listeners: [],
+                triggers: [],
+            },
+        });
+        await server.addDocument(createDocumentModelWithId(documentId));
+        await expect(storage.getChildren(driveId)).resolves.toStrictEqual([]);
+        let drive = await server.getDrive(driveId);
+        drive = driveDocumentReducer(drive, addFile({
+            id: documentId,
+            name: "document 1",
+            documentType: "powerhouse/document-model",
+        }));
+        const operation = drive.operations.global[0];
+        const result = await server.addOperation(driveId, operation);
+        if (result.error) {
+            console.error(result.error);
+            throw result.error;
+        }
+        expect(result.status).toBe("SUCCESS");
+        await expect(storage.getChildren(driveId)).resolves.toStrictEqual([documentId]);
+        const document = await server.getDocument(documentId);
+        expect(document.header.documentType).toBe("powerhouse/document-model");
+        expect(document.state).toStrictEqual(DocumentModelUtils.createState());
+        const driveDocuments = await server.getDocuments(driveId);
+        expect(driveDocuments).toStrictEqual([documentId]);
+    });
+    it("adds document as child even if document is not previously added to server", async ({ expect, }) => {
+        const driveId = generateId();
+        const documentId = generateId();
+        const storage = await buildStorage();
+        const server = new ReactorBuilder(documentModels)
+            .withCache(cache)
+            .withStorage(storage)
+            .build();
+        await server.addDrive({
+            id: driveId,
+            slug: "slug",
+            global: {
+                name: "name",
+                icon: "icon",
+            },
+            local: {
+                availableOffline: false,
+                sharingType: "public",
+                listeners: [],
+                triggers: [],
+            },
+        });
+        await expect(storage.getChildren(driveId)).resolves.toStrictEqual([]);
+        let drive = await server.getDrive(driveId);
+        drive = driveDocumentReducer(drive, addFile({
+            id: documentId,
+            name: "document 1",
+            documentType: "powerhouse/document-model",
+        }));
+        const operation = drive.operations.global[0];
+        const result = await server.addOperation(driveId, operation);
+        if (result.error) {
+            console.error(result.error);
+            throw result.error;
+        }
+        expect(result.status).toBe("SUCCESS");
+        await expect(storage.getChildren(driveId)).resolves.toStrictEqual([documentId]);
+        // const document = await server.getDocument(documentId);
+        // expect(document.documentType).toBe("powerhouse/document-model");
+        // expect(document.state).toStrictEqual(DocumentModelUtils.createState());
+        // const driveDocuments = await server.getDocuments(driveId);
+        // expect(driveDocuments).toStrictEqual([documentId]);
+    });
+    it("removes file as child", async ({ expect }) => {
+        const driveId = generateId();
+        const documentId = generateId();
+        const storage = await buildStorage();
+        const server = new ReactorBuilder(documentModels)
+            .withCache(cache)
+            .withStorage(storage)
+            .build();
+        await server.addDocument(createDocumentModelWithId(documentId));
+        await server.addDrive({
+            id: driveId,
+            slug: "slug",
+            global: {
+                name: "name",
+                icon: "icon",
+            },
+            local: {
+                availableOffline: false,
+                sharingType: "public",
+                listeners: [],
+                triggers: [],
+            },
+        });
+        let drive = await server.getDrive(driveId);
+        // adds file
+        drive = driveDocumentReducer(drive, addFile({
+            id: documentId,
+            name: "document 1",
+            documentType: "powerhouse/document-model",
+        }));
+        let result = await server.addOperation(driveId, drive.operations.global[0]);
+        expect(result.status).toBe("SUCCESS");
+        await expect(storage.getChildren(driveId)).resolves.toStrictEqual([documentId]);
+        // removes file
+        drive = driveDocumentReducer(drive, deleteNode({
+            id: documentId,
+        }));
+        result = await server.addOperation(driveId, drive.operations.global[1]);
+        expect(result.status).toBe("SUCCESS");
+        await expect(storage.getChildren(driveId)).resolves.toStrictEqual([]);
+        const serverDrive = await server.getDrive(driveId);
+        expect(serverDrive.state.global.nodes).toStrictEqual([]);
+    });
+    it("deletes document node when file is removed from server", async ({ expect, }) => {
+        const driveId = generateId();
+        const documentId = generateId();
+        const server = new ReactorBuilder(documentModels)
+            .withCache(cache)
+            .withStorage(await buildStorage())
+            .build();
+        await server.addDrive({
+            id: driveId,
+            slug: "slug",
+            global: {
+                name: "name",
+                icon: "icon",
+            },
+            local: {
+                availableOffline: false,
+                sharingType: "public",
+                listeners: [],
+                triggers: [],
+            },
+        });
+        let drive = await server.getDrive(driveId);
+        drive = driveDocumentReducer(drive, addFile({
+            id: documentId,
+            name: "document 1",
+            documentType: "powerhouse/document-model",
+        }));
+        drive = driveDocumentReducer(drive, deleteNode({
+            id: documentId,
+        }));
+        const result = await server.addOperations(driveId, drive.operations.global);
+        expect(result.status).toBe("SUCCESS");
+        const documents = await server.getDocuments(driveId);
+        expect(documents).toStrictEqual([]);
+        await expect(server.getDocument(documentId)).rejects.toThrowError(`Document with id ${documentId} not found`);
+    });
+    it("removes documents as child when it is removed from inside a folder on a drive", async ({ expect, }) => {
+        const driveId = generateId();
+        const folderId = generateId();
+        const documentId = generateId();
+        const storage = await buildStorage();
+        const server = new ReactorBuilder(documentModels)
+            .withCache(cache)
+            .withStorage(storage)
+            .build();
+        await server.addDrive({
+            id: driveId,
+            slug: "slug",
+            global: {
+                name: "name",
+                icon: "icon",
+            },
+            local: {
+                availableOffline: false,
+                sharingType: "public",
+                listeners: [],
+                triggers: [],
+            },
+        });
+        let drive = await server.getDrive(driveId);
+        const document = createDocumentModelWithId(documentId);
+        await server.addDocument(document);
+        drive = driveDocumentReducer(drive, addFolder({
+            id: folderId,
+            name: "document 1",
+        }));
+        drive = driveDocumentReducer(drive, addFile({
+            id: documentId,
+            name: "document 1",
+            documentType: "powerhouse/document-model",
+            parentFolder: folderId,
+        }));
+        drive = driveDocumentReducer(drive, deleteNode({
+            id: folderId,
+        }));
+        const result = await server.addOperations(driveId, drive.operations.global);
+        expect(result.status).toBe("SUCCESS");
+        await expect(storage.getChildren(driveId)).resolves.toStrictEqual([]);
+        const documents = await server.getDocuments(driveId);
+        expect(documents).toStrictEqual([]);
+        await expect(server.getDocument(documentId)).resolves.toMatchObject(document);
+    });
+    it("deletes drive from server", async ({ expect }) => {
+        const driveId = generateId();
+        const server = new ReactorBuilder(documentModels)
+            .withCache(cache)
+            .withStorage(await buildStorage())
+            .build();
+        await server.addDrive({
+            id: driveId,
+            slug: "slug",
+            global: {
+                name: "name",
+                icon: "icon",
+            },
+            local: {
+                availableOffline: false,
+                sharingType: "public",
+                listeners: [],
+                triggers: [],
+            },
+        });
+        await server.deleteDrive(driveId);
+        const drives = await server.getDrives();
+        expect(drives).toStrictEqual([]);
+    });
+    it("deletes documents when drive is deleted from server", async ({ expect, }) => {
+        const driveId = generateId();
+        const documentId = generateId();
+        const server = new ReactorBuilder(documentModels)
+            .withCache(cache)
+            .withStorage(await buildStorage())
+            .build();
+        await server.addDrive({
+            id: driveId,
+            slug: "slug",
+            global: {
+                name: "name",
+                icon: "icon",
+            },
+            local: {
+                availableOffline: false,
+                sharingType: "public",
+                listeners: [],
+                triggers: [],
+            },
+        });
+        const document = createDocumentModelWithId(documentId);
+        await server.addDocument(document);
+        let drive = await server.getDrive(driveId);
+        drive = driveDocumentReducer(drive, addFile({
+            id: documentId,
+            name: "document 1",
+            documentType: "powerhouse/document-model",
+        }));
+        const result = await server.addOperation(driveId, drive.operations.global[0]);
+        expect(result.status).toBe("SUCCESS");
+        await server.deleteDrive(driveId);
+        const documents = await server.getDocuments(driveId);
+        expect(documents).toStrictEqual([]);
+        await expect(server.getDocument(documentId)).resolves.toMatchObject(document);
+    });
+    it("renames drive", async ({ expect }) => {
+        const driveId = generateId();
+        const server = new ReactorBuilder(documentModels)
+            .withCache(cache)
+            .withStorage(await buildStorage())
+            .build();
+        await server.addDrive({
+            id: driveId,
+            slug: "slug",
+            global: {
+                name: "name",
+                icon: "icon",
+            },
+            local: {
+                availableOffline: false,
+                sharingType: "public",
+                listeners: [],
+                triggers: [],
+            },
+        });
+        let drive = await server.getDrive(driveId);
+        drive = driveDocumentReducer(drive, setDriveName({
+            name: "new name",
+        }));
+        const result = await server.addOperation(driveId, drive.operations.global[0]);
+        expect(result.status).toBe("SUCCESS");
+        drive = await server.getDrive(driveId);
+        expect(drive.state.global.name).toBe("new name");
+    });
+    it("copies document when file is copied drive", async ({ expect }) => {
+        const driveId = generateId();
+        const folder1Id = generateId();
+        const folder2Id = generateId();
+        const document1Id = generateId();
+        const document2Id = generateId();
+        const server = new ReactorBuilder(documentModels)
+            .withCache(cache)
+            .withStorage(await buildStorage())
+            .build();
+        await server.addDocument(createDocumentModelWithId(document1Id));
+        await server.addDocument(createDocumentModelWithId(document2Id));
+        await server.addDrive({
+            id: driveId,
+            slug: "drive",
+            global: {
+                name: "name",
+                icon: "icon",
+            },
+            local: {
+                availableOffline: false,
+                sharingType: "public",
+                listeners: [],
+                triggers: [],
+            },
+        });
+        let drive = await server.getDrive(driveId);
+        drive = driveDocumentReducer(drive, addFolder({
+            id: folder1Id,
+            name: "1",
+        }));
+        drive = driveDocumentReducer(drive, addFolder({
+            id: folder2Id,
+            name: "2",
+        }));
+        drive = driveDocumentReducer(drive, addFile({
+            id: document1Id,
+            name: "1.1",
+            documentType: "powerhouse/document-model",
+            parentFolder: folder1Id,
+        }));
+        drive = driveDocumentReducer(drive, copyNode({
+            srcId: document1Id,
+            targetId: document2Id,
+            targetName: "2.2",
+            targetParentFolder: folder2Id,
+        }));
+        vi.useRealTimers();
+        const result = await server.addOperations(driveId, drive.operations.global);
+        expect(result.status).toBe("SUCCESS");
+        drive = await server.getDrive(driveId);
+        const document = await server.getDocument(document1Id);
+        const documentB = await server.getDocument(document2Id);
+        // slugs have to change, as they are unique
+        expect(document.header.slug).not.toBe(documentB.header.slug);
+        // compare everything but the slug + id (which are supposed to be different)
+        const { header: { slug, id, ...restHeader }, ...rest } = document;
+        const { header: { slug: slug2, id: id2, ...restHeader2 }, ...rest2 } = documentB;
+        expect(rest).toStrictEqual(rest2);
+        expect(restHeader).toStrictEqual(restHeader2);
+        expect(id).toBe(document1Id);
+        expect(slug).toBe(document1Id);
+        expect(id2).toBe(document2Id);
+        expect(slug2).toBe(document2Id);
+    });
+    it("adds document operation", async ({ expect }) => {
+        const driveId = generateId();
+        const documentId = generateId();
+        const server = new ReactorBuilder(documentModels)
+            .withCache(cache)
+            .withStorage(await buildStorage())
+            .build();
+        await server.addDrive({
+            id: driveId,
+            slug: "slug",
+            global: {
+                name: "name",
+                icon: "icon",
+            },
+            local: {
+                availableOffline: false,
+                sharingType: "public",
+                listeners: [],
+                triggers: [],
+            },
+        });
+        let drive = await server.getDrive(driveId);
+        await server.addDocument(createDocumentModelWithId(documentId));
+        // adds file
+        drive = driveDocumentReducer(drive, addFile({
+            id: documentId,
+            name: "document 1",
+            documentType: "powerhouse/document-model",
+        }));
+        await server.addOperation(driveId, drive.operations.global[0]);
+        let document = await server.getDocument(documentId);
+        document = documentModelDocumentModelModule.reducer(document, setModelName({ name: "Test" }));
+        const operation = document.operations.global[0];
+        const result = await server.addOperation(documentId, operation);
+        expect(result.error).toBeUndefined();
+        expect(result.status).toBe("SUCCESS");
+        expect(result.operations[0]).toStrictEqual(expect.objectContaining(operation));
+        const storedDocument = await server.getDocument(documentId);
+        expect(storedDocument.state).toStrictEqual(document.state);
+        expect(storedDocument.operations).toMatchObject(document.operations);
+    });
+    it("adds document operations", async ({ expect }) => {
+        const driveId = generateId();
+        const server = new ReactorBuilder(documentModels)
+            .withCache(cache)
+            .withStorage(await buildStorage())
+            .build();
+        let document = documentModelCreateDocument();
+        const documentId = document.header.id;
+        // adds document
+        await server.addDocument(document);
+        document = await server.getDocument(documentId);
+        document = documentModelDocumentModelModule.reducer(document, documentModelDocumentModelModule.actions.setModelName({ name: "Test" }));
+        document = documentModelDocumentModelModule.reducer(document, documentModelDocumentModelModule.actions.setStateSchema({
+            schema: 'type TestState {\n  "Add your global state fields here"\n  _placeholder: String\n}',
+            scope: "global",
+        }));
+        const operations = document.operations.global;
+        const result = await server.addOperations(documentId, operations);
+        expect(result.error).toBeUndefined();
+        expect(result.status).toBe("SUCCESS");
+        expect(result.operations).toStrictEqual(expect.objectContaining(operations));
+        const storedDocument = await server.getDocument(driveId, documentId);
+        expect(storedDocument.state).toStrictEqual(document.state);
+        expect(storedDocument.operations).toMatchObject(document.operations);
+    });
+    it("adds drive operations", async ({ expect }) => {
+        const driveId = generateId();
+        const server = new ReactorBuilder(documentModels)
+            .withCache(cache)
+            .withStorage(await buildStorage())
+            .build();
+        await server.addDrive({
+            id: driveId,
+            slug: "slug",
+            global: {
+                name: "name",
+                icon: "icon",
+            },
+            local: {
+                availableOffline: false,
+                sharingType: "public",
+                listeners: [],
+                triggers: [],
+            },
+        });
+        let drive = await server.getDrive(driveId);
+        drive = driveDocumentReducer(drive, addFolder({ id: generateId(), name: "folder 1" }));
+        drive = driveDocumentReducer(drive, addFolder({ id: generateId(), name: "folder 2" }));
+        const operations = drive.operations.global;
+        const result = await server.addDriveOperations(driveId, operations);
+        expect(result.status).toBe("SUCCESS");
+        expect(result.operations).toStrictEqual(expect.objectContaining(operations));
+        const storedDrive = await server.getDrive(driveId);
+        expect(storedDrive.state).toStrictEqual(drive.state);
+        expect(storedDrive.operations).toMatchObject(drive.operations);
+    });
+    it("saves operation context", async ({ expect }) => {
+        const driveId = generateId();
+        const documentId = generateId();
+        const server = new ReactorBuilder(documentModels)
+            .withCache(cache)
+            .withStorage(await buildStorage())
+            .build();
+        await server.addDrive({
+            id: driveId,
+            slug: "slug",
+            global: {
+                name: "name",
+                icon: "icon",
+            },
+            local: {
+                availableOffline: false,
+                sharingType: "public",
+                listeners: [],
+                triggers: [],
+            },
+        });
+        let drive = await server.getDrive(driveId);
+        const context = {
+            signer: {
+                user: {
+                    address: "123",
+                    networkId: "1",
+                    chainId: 1,
+                },
+                app: {
+                    name: "name",
+                    key: "key",
+                },
+                signatures: ["test"],
+            },
+        };
+        drive = driveDocumentReducer(drive, {
+            ...addFile({
+                id: documentId,
+                name: "document 1",
+                documentType: "powerhouse/document-model",
+            }),
+            context,
+        });
+        // dispatches operation to server
+        const operation = drive.operations.global[0];
+        const operationResult = await server.addOperation(driveId, operation);
+        expect(operationResult.status).toBe("SUCCESS");
+        drive = await server.getDrive(driveId);
+        expect(drive.operations.global[0]?.action?.context).toStrictEqual(context);
+    });
+    it("get drives by slug", async ({ expect }) => {
+        const driveId1 = generateId();
+        const driveId2 = generateId();
+        const driveId3 = generateId();
+        const driveId4 = generateId();
+        const server = new ReactorBuilder(documentModels)
+            .withCache(cache)
+            .withStorage(await buildStorage())
+            .build();
+        const addDrive = (driveId, slug) => server.addDrive({
+            id: driveId,
+            slug,
+            global: {
+                name: "name",
+                icon: "icon",
+            },
+            local: {
+                availableOffline: false,
+                sharingType: "public",
+                listeners: [],
+                triggers: [],
+            },
+        });
+        await addDrive(driveId1, "slug1");
+        await addDrive(driveId2, "slug2");
+        await addDrive(driveId3, "slug3");
+        // add drive with the same slug as the first drive, which should throw an error
+        try {
+            await addDrive(driveId4, "slug1");
+            throw new Error("created drive with duplicate slug");
+        }
+        catch (error) {
+            expect(error.documentId).toContain(driveId4);
+        }
+        let drive = await server.getDriveBySlug("slug1");
+        expect(drive.header.id).toBe(driveId1);
+        drive = await server.getDriveBySlug("slug2");
+        expect(drive.header.id).toBe(driveId2);
+        drive = await server.getDriveBySlug("slug3");
+        expect(drive.header.id).toBe(driveId3);
+    });
+    it.skipIf(!file)("import document from zip", async ({ expect }) => {
+        const driveId = generateId();
+        const storage = await buildStorage();
+        const server = new ReactorBuilder(documentModels)
+            .withCache(cache)
+            .withStorage(storage)
+            .build();
+        const drive = await server.addDrive({
+            id: driveId,
+            slug: "slug",
+            global: {
+                name: "name",
+                icon: "icon",
+            },
+            local: {
+                availableOffline: false,
+                sharingType: "public",
+                listeners: [],
+                triggers: [],
+            },
+        });
+        const documentId = generateId();
+        await server.addDocument({
+            ...file,
+            header: createPresignedHeader(documentId, file.header.documentType),
+        });
+        const action = addFile({
+            id: documentId,
+            name: "name",
+            parentFolder: null,
+            documentType: file.header.documentType,
+        });
+        const result = await server.addAction(driveId, action);
+        expect(result.status).toBe("SUCCESS");
+        const document = await server.getDocument(documentId);
+        expect(document).toStrictEqual(file);
+    });
+    it("should get synchronization units revision", async ({ expect }) => {
+        const driveId = generateId();
+        const documentId = generateId();
+        const storage = await buildStorage();
+        const cache = new InMemoryCache();
+        const syncManager = new SynchronizationManager(storage, storage, cache, documentModels);
+        const server = new ReactorBuilder(documentModels)
+            .withCache(cache)
+            .withStorage(storage)
+            .withSynchronizationManager(syncManager)
+            .build();
+        await server.addDrive({
+            id: driveId,
+            slug: "slug",
+            global: {
+                name: "name",
+                icon: "icon",
+            },
+            local: {
+                availableOffline: false,
+                sharingType: "public",
+                listeners: [],
+                triggers: [],
+            },
+        });
+        let drive = await server.getDrive(driveId);
+        const syncUnitsInitial = await syncManager.getSynchronizationUnits(driveId, undefined, ["global"]);
+        expect(syncUnitsInitial).toStrictEqual([
+            {
+                documentId: drive.header.id,
+                documentType: "powerhouse/document-drive",
+                scope: "global",
+                branch: "main",
+                lastUpdated: "2024-01-01T00:00:00.000Z",
+                revision: 0,
+            },
+        ]);
+        const storageUnitsInitial = await storage.findStorageUnitsBy({}, 10);
+        expect(storageUnitsInitial.units).toHaveLength(4);
+        await server.addDocument(createDocumentModelWithId(documentId));
+        // adds file
+        drive = driveDocumentReducer(drive, addFile({
+            id: documentId,
+            name: "document 1",
+            documentType: "powerhouse/document-model",
+        }));
+        await server.addOperation(driveId, drive.operations.global[0]);
+        let document = await server.getDocument(documentId);
+        document = documentModelDocumentModelModule.reducer(document, setModelName({ name: "Test" }));
+        const operation = document.operations.global[0];
+        await server.addOperation(documentId, operation);
+        await server.getDocument(documentId);
+        const syncUnits = await syncManager.getSynchronizationUnits(driveId, undefined, ["global"]);
+        expect(syncUnits).toStrictEqual([
+            {
+                documentId: drive.header.id,
+                documentType: "powerhouse/document-drive",
+                scope: "global",
+                branch: "main",
+                lastUpdated: "2024-01-01T00:00:00.000Z",
+                revision: 1,
+            },
+            {
+                documentId: documentId,
+                documentType: "powerhouse/document-model",
+                scope: "global",
+                branch: "main",
+                lastUpdated: "2024-01-01T00:00:00.000Z",
+                revision: 1,
+            },
+        ]);
+        const storageUnits = await storage.findStorageUnitsBy({}, 10);
+        expect(storageUnits.units).toHaveLength(8);
+    });
+    it("should store all operation attributes", async ({ expect }) => {
+        const driveId = generateId();
+        const documentId = generateId();
+        const storage = await buildStorage();
+        const server = new ReactorBuilder(documentModels)
+            .withCache(cache)
+            .withStorage(storage)
+            .build();
+        await server.addDrive({
+            id: driveId,
+            slug: "slug",
+            global: {
+                name: "name",
+                icon: "icon",
+            },
+            local: {
+                availableOffline: false,
+                sharingType: "public",
+                listeners: [],
+                triggers: [],
+            },
+        });
+        let drive = await server.getDrive(driveId);
+        const context = {
+            signer: {
+                user: {
+                    address: "123",
+                    networkId: "1",
+                    chainId: 1,
+                },
+                app: {
+                    name: "name",
+                    key: "key",
+                },
+                signatures: ["test"],
+            },
+        };
+        // adds file
+        drive = driveDocumentReducer(drive, {
+            ...addFile({
+                id: documentId,
+                name: "document 1",
+                documentType: "powerhouse/document-model",
+            }),
+            context,
+        });
+        await server.addOperation(driveId, drive.operations.global[0]);
+        const storedDrive = await server.getDrive(driveId);
+        expect(storedDrive.operations.global[0]).toMatchObject(drive.operations.global[0]);
+    });
+    it("gets document at specific revision", async ({ expect }) => {
+        const driveId = generateId();
+        const documentId = generateId();
+        const server = new ReactorBuilder(documentModels)
+            .withCache(cache)
+            .withStorage(await buildStorage())
+            .build();
+        await server.addDrive({
+            id: driveId,
+            slug: "slug",
+            global: {
+                name: "name",
+                icon: "icon",
+            },
+            local: {
+                availableOffline: false,
+                sharingType: "public",
+                listeners: [],
+                triggers: [],
+            },
+        });
+        const drive = await server.getDrive(driveId);
+        // adds file
+        const newDrive = driveDocumentReducer(drive, addFile({
+            id: documentId,
+            name: "document 1",
+            documentType: "powerhouse/document-model",
+        }));
+        await server.addOperation(driveId, newDrive.operations.global[0]);
+        const drive0 = await server.getDrive(driveId, {
+            revisions: { global: -1 },
+        });
+        expect(drive0.operations.global.length).toBe(0);
+        expect(drive0).toStrictEqual(drive);
+    });
+    it("should allow removing a drive and then adding a new drive with the same id and slug", async ({ expect, }) => {
+        const server = new ReactorBuilder(documentModels)
+            .withCache(cache)
+            .withStorage(await buildStorage())
+            .build();
+        await server.addDrive({
+            id: "test-drive",
+            slug: "test-drive",
+            global: {
+                name: "test-drive",
+                icon: "icon",
+            },
+            local: {
+                availableOffline: false,
+                sharingType: "public",
+                listeners: [],
+                triggers: [],
+            },
+        });
+        await server.deleteDrive("test-drive");
+        await server.addDrive({
+            id: "test-drive",
+            slug: "test-drive",
+            global: {
+                name: "test-drive",
+                icon: "icon",
+            },
+            local: {
+                availableOffline: false,
+                sharingType: "public",
+                listeners: [],
+                triggers: [],
+            },
+        });
+        const drive = await server.getDriveBySlug("test-drive");
+        expect(drive.header.slug).toBe("test-drive");
+    });
+});
+//# sourceMappingURL=server.test.js.map