document-drive 0.0.27 → 0.0.29

package/src/storage/prisma.ts

@@ -1,9 +1,9 @@
-import { type Prisma } from '@prisma/client';
+import { PrismaClient, type Prisma } from '@prisma/client';
 import {
     DocumentDriveLocalState,
     DocumentDriveState
 } from 'document-model-libs/document-drive';
-import {
+import type {
     DocumentHeader,
     ExtendedState,
     Operation,
@@ -12,12 +12,14 @@ import {
 import { DocumentDriveStorage, DocumentStorage, IDriveStorage } from './types';
 
 export class PrismaStorage implements IDriveStorage {
-    private db: Prisma.TransactionClient;
+    private db: PrismaClient;
 
-    constructor(db: Prisma.TransactionClient) {
+    constructor(db: PrismaClient) {
         this.db = db;
     }
+
     async createDrive(id: string, drive: DocumentDriveStorage): Promise<void> {
+        // drive for all drive documents
         await this.createDocument('drives', id, drive as DocumentStorage);
     }
     async addDriveOperations(
@@ -27,6 +29,7 @@ export class PrismaStorage implements IDriveStorage {
     ): Promise<void> {
         await this.addDocumentOperations('drives', id, operations, header);
     }
+
     async createDocument(
         drive: string,
         id: string,
@@ -84,7 +87,8 @@ export class PrismaStorage implements IDriveStorage {
                             timestamp: op.timestamp,
                             type: op.type,
                             scope: op.scope,
-                            branch: 'main'
+                            branch: 'main',
+                            skip: op.skip
                         },
                         update: {
                             driveId: drive,
@@ -95,18 +99,17 @@ export class PrismaStorage implements IDriveStorage {
                             timestamp: op.timestamp,
                             type: op.type,
                             scope: op.scope,
-                            branch: 'main'
+                            branch: 'main',
+                            skip: op.skip
                         }
                     });
                 })
             );
 
-            await this.db.document.update({
+            await this.db.document.updateMany({
                 where: {
-                    id_driveId: {
-                        id,
-                        driveId: 'drives'
-                    }
+                    id,
+                    driveId: drive
                 },
                 data: {
                     lastModified: header.lastModified,
@@ -163,6 +166,9 @@ export class PrismaStorage implements IDriveStorage {
             },
             include: {
                 operations: {
+                    orderBy: {
+                        index: 'asc'
+                    },
                     include: {
                         attachments: true
                     }
@@ -175,7 +181,6 @@ export class PrismaStorage implements IDriveStorage {
         }
 
         const dbDoc = result;
-
         const doc = {
             created: dbDoc.created.toISOString(),
             name: dbDoc.name ? dbDoc.name : '',
@@ -184,11 +189,12 @@ export class PrismaStorage implements IDriveStorage {
                 DocumentDriveState,
                 DocumentDriveLocalState
             >,
-            lastModified: dbDoc.lastModified.toISOString(),
+            lastModified: new Date(dbDoc.lastModified).toISOString(),
             operations: {
                 global: dbDoc.operations
-                    .filter(op => op.scope === 'global')
+                    .filter(op => op.scope === 'global' && !op.clipboard)
                     .map(op => ({
+                        skip: op.skip,
                         hash: op.hash,
                         index: op.index,
                         timestamp: new Date(op.timestamp).toISOString(),
@@ -198,8 +204,9 @@ export class PrismaStorage implements IDriveStorage {
                         // attachments: fileRegistry
                     })),
                 local: dbDoc.operations
-                    .filter(op => op.scope === 'local')
+                    .filter(op => op.scope === 'local' && !op.clipboard)
                     .map(op => ({
+                        skip: op.skip,
                         hash: op.hash,
                         index: op.index,
                         timestamp: new Date(op.timestamp).toISOString(),
@@ -209,19 +216,67 @@ export class PrismaStorage implements IDriveStorage {
                         // attachments: fileRegistry
                     }))
             },
-            revision: dbDoc.revision as Required<Record<OperationScope, number>>
+            clipboard: dbDoc.operations
+                .filter(op => op.clipboard)
+                .map(op => ({
+                    skip: op.skip,
+                    hash: op.hash,
+                    index: op.index,
+                    timestamp: new Date(op.timestamp).toISOString(),
+                    input: op.input,
+                    type: op.type,
+                    scope: op.scope as OperationScope
+                    // attachments: fileRegistry
+                })),
+            revision: dbDoc.revision as Record<OperationScope, number>
         };
 
         return doc;
     }
 
     async deleteDocument(drive: string, id: string) {
-        await this.db.document.deleteMany({
+        await this.db.attachment.deleteMany({
             where: {
                 driveId: drive,
-                id: id
+                documentId: id
             }
         });
+
+        await this.db.operation.deleteMany({
+            where: {
+                driveId: drive,
+                documentId: id
+            }
+        });
+
+        await this.db.document.delete({
+            where: {
+                id_driveId: {
+                    driveId: drive,
+                    id: id
+                }
+            }
+        });
+
+        if (drive === 'drives') {
+            await this.db.attachment.deleteMany({
+                where: {
+                    driveId: id
+                }
+            });
+
+            await this.db.operation.deleteMany({
+                where: {
+                    driveId: id
+                }
+            });
+
+            await this.db.document.deleteMany({
+                where: {
+                    driveId: id
+                }
+            });
+        }
     }
 
     async getDrives() {
@@ -229,15 +284,15 @@ export class PrismaStorage implements IDriveStorage {
     }
 
     async getDrive(id: string) {
-        return this.getDocument('drives', id) as Promise<DocumentDriveStorage>;
+        try {
+            const doc = await this.getDocument('drives', id);
+            return doc as DocumentDriveStorage;
+        } catch (e) {
+            throw new Error(`Drive with id ${id} not found`);
+        }
     }
 
     async deleteDrive(id: string) {
         await this.deleteDocument('drives', id);
-        await this.db.document.deleteMany({
-            where: {
-                driveId: id
-            }
-        });
     }
 }

package/src/storage/types.ts

@@ -27,7 +27,8 @@ export interface IStorage {
         drive: string,
         id: string,
         operations: Operation[],
-        header: DocumentHeader
+        header: DocumentHeader,
+        updatedOperations?: Operation[]
     ): Promise<void>;
     deleteDocument(drive: string, id: string): Promise<void>;
 }

package/src/utils/graphql.ts

@@ -0,0 +1,46 @@
+import request, { GraphQLClient, gql } from 'graphql-request';
+
+export { gql } from 'graphql-request';
+
+export type DriveInfo = {
+    id: string;
+    name: string;
+    slug: string;
+    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);
+}
+
+export async function requestPublicDrive(url: string): Promise<DriveInfo> {
+    let drive: DriveInfo;
+    try {
+        const result = await requestGraphql<{ drive: DriveInfo }>(
+            url,
+            gql`
+                query getDrive {
+                    drive {
+                        id
+                        name
+                        icon
+                        slug
+                    }
+                }
+            `
+        );
+        drive = result.drive;
+    } catch (e) {
+        console.error(e);
+        throw new Error("Couldn't find drive info");
+    }
+
+    if (!drive) {
+        throw new Error('Drive not found');
+    }
+
+    return drive;
+}

package/src/utils/index.ts

@@ -0,0 +1,77 @@
+import {
+    DocumentDriveDocument,
+    documentModel as DocumentDriveModel,
+    z
+} from 'document-model-libs/document-drive';
+import {
+    Action,
+    BaseAction,
+    Document,
+    DocumentOperations,
+    Operation
+} from 'document-model/document';
+
+export function isDocumentDrive(
+    document: Document
+): document is DocumentDriveDocument {
+    return (
+        document.documentType === DocumentDriveModel.id &&
+        z.DocumentDriveStateSchema().safeParse(document.state.global).success
+    );
+}
+
+export function mergeOperations<A extends Action = Action>(
+    currentOperations: DocumentOperations<A>,
+    newOperations: Operation<A | BaseAction>[]
+): DocumentOperations<A> {
+    return newOperations.reduce((acc, curr) => {
+        const operations = acc[curr.scope] ?? [];
+        acc[curr.scope] = [...operations, curr] as Operation<A>[];
+        return acc;
+    }, currentOperations);
+}
+
+export function generateUUID(): string {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const crypto =
+        typeof window !== 'undefined' ? window.crypto : require('crypto');
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+    return crypto.randomUUID() as string;
+}
+
+export function applyUpdatedOperations<A extends Action = Action>(
+    currentOperations: DocumentOperations<A>,
+    updatedOperations: Operation<A | BaseAction>[]
+): DocumentOperations<A> {
+    return updatedOperations.reduce(
+        (acc, curr) => {
+            const operations = acc[curr.scope] ?? [];
+            acc[curr.scope] = operations.map(op => {
+                return op.index === curr.index ? curr : op;
+            });
+            return acc;
+        },
+        { ...currentOperations }
+    );
+}
+
+export function isNoopUpdate(
+    operation: Operation,
+    latestOperation?: Operation
+) {
+    if (!latestOperation) {
+        return false;
+    }
+
+    const isNoopOp = operation.type === 'NOOP';
+    const isNoopLatestOp = latestOperation.type === 'NOOP';
+    const isSameIndexOp = operation.index === latestOperation.index;
+    const isSkipOpGreaterThanLatestOp = operation.skip > latestOperation.skip;
+
+    return (
+        isNoopOp &&
+        isNoopLatestOp &&
+        isSameIndexOp &&
+        isSkipOpGreaterThanLatestOp
+    );
+}

package/src/utils.ts

@@ -1,32 +0,0 @@
-import {
-    DocumentDriveDocument,
-    documentModel as DocumentDriveModel,
-    z
-} from 'document-model-libs/document-drive';
-import {
-    Action,
-    BaseAction,
-    Document,
-    DocumentOperations,
-    Operation
-} from 'document-model/document';
-
-export function isDocumentDrive(
-    document: Document
-): document is DocumentDriveDocument {
-    return (
-        document.documentType === DocumentDriveModel.id &&
-        z.DocumentDriveStateSchema().safeParse(document.state.global).success
-    );
-}
-
-export function mergeOperations<A extends Action = Action>(
-    currentOperations: DocumentOperations<A>,
-    newOperations: Operation<A | BaseAction>[]
-): DocumentOperations<A> {
-    return newOperations.reduce((acc, curr) => {
-        const operations = acc[curr.scope] ?? [];
-        acc[curr.scope] = [...operations, curr] as Operation<A>[];
-        return acc;
-    }, currentOperations);
-}