document-drive 1.0.0-websockets → 1.0.0

package/src/utils/graphql.ts

@@ -1,47 +1,301 @@
-import request, { GraphQLClient, gql } from 'graphql-request';
-import { logger } from './logger';
+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';
+export { gql } from "graphql-request";
 
-export type DriveInfo = {
-    id: string;
-    name: string;
-    slug: string;
-    icon?: string;
+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>) {
-    const [url, ...requestArgs] = args;
-    const client = new GraphQLClient(url, { fetch });
-    return client.request<T>(...requestArgs);
+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;
+  slug: string;
+  icon?: string;
+};
+
+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> {
-    let drive: DriveInfo;
-    try {
-        const result = await requestGraphql<{ drive: DriveInfo }>(
-            url,
-            gql`
-                query getDrive {
-                    drive {
+  let drive: DriveInfo;
+  try {
+    const result = await requestGraphql<{ drive: DriveInfo }>(
+      url,
+      gql`
+        query getDrive {
+          drive {
+            id
+            name
+            icon
+            slug
+          }
+        }
+      `,
+    );
+    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");
+  }
+
+  return drive;
+}
+
+export type DriveState = DriveInfo &
+  Pick<DocumentDriveLocalState, "availableOffline" | "sharingType"> & {
+    nodes: Array<FolderNode | Omit<FileNode, "synchronizationUnits">>;
+  };
+
+export type DocumentGraphQLResult<D extends 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"
+    | "context"
+  > & { inputText: string })[];
+};
+
+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: DocumentGraphQLResult<D>;
+  }>(
+    url,
+    gql`
+            query ($id: String!) {
+                document(id: $id) {
+                    id
+                    name
+                    created
+                    documentType
+                    lastModified
+                    revision
+                    operations {
                         id
-                        name
-                        icon
-                        slug
+                        error
+                        hash
+                        index
+                        skip
+                        timestamp
+                        type
+                        inputText
+                        context {
+                            signer {
+                                user {
+                                    address
+                                    networkId
+                                    chainId
+                                }
+                                app {
+                                    name
+                                    key
+                                }
+                                signatures
+                            }
+                        }
+                    }
+                    ... on ${name} {
+                        state {
+                            ${stateFields}
+                        }
+                        initialState {
+                            ${stateFields}
+                        }
                     }
                 }
-            `
-        );
-        drive = result.drive;
-    } catch (e) {
-        logger.error(e);
-        throw new Error("Couldn't find drive info");
-    }
-
-    if (!drive) {
-        throw new Error('Drive not found');
-    }
+            }
+        `,
+    { 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 drive;
+  return {
+    ...result,
+    document,
+  };
 }

package/src/utils/index.ts

@@ -1,89 +1,91 @@
-import { v4 as uuidv4 } from 'uuid';
 import {
-    DocumentDriveDocument,
-    documentModel as DocumentDriveModel,
-    z
-} from 'document-model-libs/document-drive';
+  DocumentDriveDocument,
+  documentModel as DocumentDriveModel,
+} from "document-model-libs/document-drive";
 import {
-    Action,
-    BaseAction,
-    Document,
-    DocumentOperations,
-    Operation,
-    OperationScope
-} from 'document-model/document';
-import { OperationError } from '../server/error';
-import { DocumentDriveStorage, DocumentStorage } from '../storage';
+  Action,
+  BaseAction,
+  Document,
+  DocumentOperations,
+  Operation,
+  OperationScope,
+} from "document-model/document";
+// import setAsap from 'setasap';
+import { v4 as uuidv4 } from "uuid";
+import { OperationError } from "../server/error";
+import { DocumentDriveStorage, DocumentStorage } from "../storage";
+import { RunAsap } from "./run-asap";
+export * from "./run-asap";
+
+export const runAsap = RunAsap.runAsap;
+export const runAsapAsync = RunAsap.runAsapAsync;
 
 export function isDocumentDriveStorage(
-    document: DocumentStorage
+  document: DocumentStorage,
 ): document is DocumentDriveStorage {
-    return (
-        document.documentType === DocumentDriveModel.id
-    );
+  return document.documentType === DocumentDriveModel.id;
 }
 
 export function isDocumentDrive(
-    document: Document
+  document: Document,
 ): document is DocumentDriveDocument {
-    return (
-        document.documentType === DocumentDriveModel.id
-    );
+  return document.documentType === DocumentDriveModel.id;
 }
 
 export function mergeOperations<A extends Action = Action>(
-    currentOperations: DocumentOperations<A>,
-    newOperations: Operation<A | BaseAction>[]
+  currentOperations: DocumentOperations<A>,
+  newOperations: Operation<A | BaseAction>[],
 ): DocumentOperations<A> {
-    const minIndexByScope = Object.keys(currentOperations).reduce<Partial<Record<OperationScope, number>>>((acc, curr) => {
-        const scope = curr as OperationScope;
-        acc[scope] = currentOperations[scope].at(-1)?.index ?? 0
-        return acc;
-    }, {});
+  const minIndexByScope = Object.keys(currentOperations).reduce<
+    Partial<Record<OperationScope, number>>
+  >((acc, curr) => {
+    const scope = curr as OperationScope;
+    acc[scope] = currentOperations[scope].at(-1)?.index ?? 0;
+    return acc;
+  }, {});
 
-    const conflictOp = newOperations.find(op => op.index < (minIndexByScope[op.scope] ?? 0));
-    if (conflictOp) {
-        throw new OperationError(
-            "ERROR",
-            conflictOp,
-            `Tried to add operation with index ${conflictOp.index} and document is at index ${minIndexByScope[conflictOp.scope]}`
-        );
-    }
+  const conflictOp = newOperations.find(
+    (op) => op.index < (minIndexByScope[op.scope] ?? 0),
+  );
+  if (conflictOp) {
+    throw new OperationError(
+      "ERROR",
+      conflictOp,
+      `Tried to add operation with index ${conflictOp.index} and document is at index ${minIndexByScope[conflictOp.scope]}`,
+    );
+  }
 
-    return newOperations.sort((a, b) => a.index - b.index
-    ).reduce<DocumentOperations<A>>((acc, curr) => {
-        const existingOperations = acc[curr.scope] || [];
-        return { ...acc, [curr.scope]: [...existingOperations, curr] };
+  return newOperations
+    .sort((a, b) => a.index - b.index)
+    .reduce<DocumentOperations<A>>((acc, curr) => {
+      const existingOperations = acc[curr.scope] || [];
+      return { ...acc, [curr.scope]: [...existingOperations, curr] };
     }, currentOperations);
 }
 
 export function generateUUID(): string {
-    return uuidv4();
+  return uuidv4();
 }
 
 export function isNoopUpdate(
-    operation: Operation,
-    latestOperation?: Operation
+  operation: Operation,
+  latestOperation?: Operation,
 ) {
-    if (!latestOperation) {
-        return false;
-    }
+  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;
+  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
-    );
+  return (
+    isNoopOp && isNoopLatestOp && isSameIndexOp && isSkipOpGreaterThanLatestOp
+  );
 }
 
 // return true if dateA is before dateB
 export function isBefore(dateA: Date | string, dateB: Date | string) {
-    return new Date(dateA) < new Date(dateB);
+  return new Date(dateA) < new Date(dateB);
 }
-

package/src/utils/logger.ts

@@ -1,41 +1,43 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-export type ILogger = Pick<Console, 'log' | 'info' | 'warn' | 'error' | 'debug' | 'trace'>;
+export type ILogger = Pick<
+  Console,
+  "log" | "info" | "warn" | "error" | "debug" | "trace"
+>;
 class Logger implements ILogger {
-    #logger: ILogger = console;
-
-    set logger(logger: ILogger) {
-        this.#logger = logger;
-    }
-
-    log(...data: any[]): void {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-        return this.#logger.log(...data);
-    }
-
-    info(...data: any[]): void {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-        return this.#logger.info(...data);
-    }
-
-    warn(...data: any[]): void {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-        return this.#logger.warn(...data);
-    }
-
-    error(...data: any[]): void {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-        return this.#logger.error(...data);
-    }
-
-    debug(...data: any[]): void {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-        return this.#logger.debug(...data);
-    }
-
-    trace(...data: any[]): void {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-        return this.#logger.trace(...data);
-    }
+  #logger: ILogger = console;
+
+  set logger(logger: ILogger) {
+    this.#logger = logger;
+  }
+
+  log(...data: any[]): void {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+    return this.#logger.log(...data);
+  }
+
+  info(...data: any[]): void {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+    return this.#logger.info(...data);
+  }
+
+  warn(...data: any[]): void {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+    return this.#logger.warn(...data);
+  }
+
+  error(...data: any[]): void {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+    return this.#logger.error(...data);
+  }
+
+  debug(...data: any[]): void {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+    return this.#logger.debug(...data);
+  }
+
+  trace(...data: any[]): void {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+    return this.#logger.trace(...data);
+  }
 }
 
 const loggerInstance = new Logger();

package/src/utils/migrations.ts

@@ -0,0 +1,58 @@
+import {
+  Action,
+  Document,
+  DocumentOperations,
+  Operation,
+  OperationScope,
+} from "document-model/document";
+import { DocumentStorage } from "../storage/types";
+
+export function migrateDocumentOperationSigatures<D extends Document>(
+  document: DocumentStorage<D>,
+): DocumentStorage<D> | undefined {
+  let legacy = false;
+  const operations = Object.entries(document.operations).reduce<
+    DocumentOperations<Action>
+  >(
+    (acc, [key, operations]) => {
+      const scope = key as unknown as OperationScope;
+      for (const op of operations) {
+        const newOp = migrateLegacyOperationSignature(op);
+        acc[scope].push(newOp);
+        if (newOp !== op) {
+          legacy = true;
+        }
+      }
+      return acc;
+    },
+    { global: [], local: [] },
+  );
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+  return legacy ? { ...document, operations } : document;
+}
+
+export function migrateLegacyOperationSignature<A extends Action>(
+  operation: Operation<A>,
+): Operation<A> {
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+  if (!operation.context?.signer || operation.context.signer.signatures) {
+    return operation;
+  }
+  const { signer } = operation.context;
+  if ("signature" in signer) {
+    const signature = signer.signature as string | undefined;
+    return {
+      ...operation,
+      context: {
+        ...operation.context,
+        signer: {
+          user: signer.user,
+          app: signer.app,
+          signatures: signature?.length ? [signature] : [],
+        },
+      },
+    };
+  } else {
+    return operation;
+  }
+}