document-drive 1.19.0 → 1.20.0

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

@@ -1,341 +0,0 @@
-import {
-  DefaultRemoteDriveInfo,
-  DocumentDriveServerOptions,
-  DriveEvents,
-  IBaseDocumentDriveServer,
-  IReadModeDriveServer,
-  RemoteDriveAccessLevel,
-  RemoveDriveStrategy,
-  RemoveOldRemoteDrivesOption,
-} from "../server";
-import { DriveNotFoundError } from "../server/error";
-import { requestPublicDrive } from "./graphql";
-import { logger } from "./logger";
-
-export interface IServerDelegateDrivesManager {
-  emit: (...args: Parameters<DriveEvents["defaultRemoteDrive"]>) => void;
-  detachDrive: (driveId: string) => Promise<void>;
-}
-
-function isReadModeDriveServer(obj: unknown): obj is IReadModeDriveServer {
-  return typeof (obj as IReadModeDriveServer).getReadDrives === "function";
-}
-
-export interface IDefaultDrivesManager {
-  initializeDefaultRemoteDrives(): Promise<void>;
-  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:
-      | IBaseDocumentDriveServer
-      | (IBaseDocumentDriveServer & IReadModeDriveServer),
-    private delegate: IServerDelegateDrivesManager,
-    options?: Pick<DocumentDriveServerOptions, "defaultDrives">,
-  ) {
-    if (options?.defaultDrives.remoteDrives) {
-      for (const defaultDrive of options.defaultDrives.remoteDrives) {
-        this.defaultRemoteDrives.set(defaultDrive.url, {
-          ...defaultDrive,
-          status: "PENDING",
-        });
-      }
-    }
-
-    this.removeOldRemoteDrivesConfig = options?.defaultDrives
-      .removeOldRemoteDrives || {
-      strategy: "preserve-all",
-    };
-  }
-
-  getDefaultRemoteDrives() {
-    return new Map(
-      JSON.parse(
-        JSON.stringify(Array.from(this.defaultRemoteDrives)),
-      ) as Iterable<[string, DefaultRemoteDriveInfo]>,
-    );
-  }
-
-  private async deleteDriveById(driveId: string) {
-    try {
-      await this.server.deleteDrive(driveId);
-    } catch (error) {
-      if (!(error instanceof DriveNotFoundError)) {
-        logger.error(error);
-      }
-    }
-  }
-
-  private async preserveDrivesById(
-    driveIdsToPreserve: string[],
-    drives: string[],
-    removeStrategy: RemoveDriveStrategy = "detach",
-  ) {
-    const getAllDrives = drives.map((driveId) => this.server.getDrive(driveId));
-
-    const drivesToRemove = (await Promise.all(getAllDrives))
-      .filter(
-        (drive) =>
-          drive.state.local.listeners.length > 0 ||
-          drive.state.local.triggers.length > 0,
-      )
-      .filter((drive) => !driveIdsToPreserve.includes(drive.state.global.id));
-
-    const driveIds = drivesToRemove.map((drive) => drive.state.global.id);
-
-    if (removeStrategy === "detach") {
-      await this.detachDrivesById(driveIds);
-    } else {
-      await this.removeDrivesById(driveIds);
-    }
-  }
-
-  private async removeDrivesById(driveIds: string[]) {
-    for (const driveId of driveIds) {
-      await this.deleteDriveById(driveId);
-    }
-  }
-
-  private async detachDrivesById(driveIds: string[]) {
-    const detachDrivesPromises = driveIds.map((driveId) =>
-      this.delegate.detachDrive(driveId),
-    );
-
-    await Promise.all(detachDrivesPromises);
-  }
-
-  async removeOldremoteDrives() {
-    const driveids = await this.server.getDrives();
-
-    switch (this.removeOldRemoteDrivesConfig.strategy) {
-      case "preserve-by-id-and-detach":
-      case "preserve-by-id": {
-        const detach: RemoveDriveStrategy =
-          this.removeOldRemoteDrivesConfig.strategy ===
-          "preserve-by-id-and-detach"
-            ? "detach"
-            : "remove";
-
-        await this.preserveDrivesById(
-          this.removeOldRemoteDrivesConfig.ids,
-          driveids,
-          detach,
-        );
-        break;
-      }
-      case "preserve-by-url-and-detach":
-      case "preserve-by-url": {
-        const detach: RemoveDriveStrategy =
-          this.removeOldRemoteDrivesConfig.strategy ===
-          "preserve-by-url-and-detach"
-            ? "detach"
-            : "remove";
-
-        const getDrivesInfo = this.removeOldRemoteDrivesConfig.urls.map((url) =>
-          requestPublicDrive(url),
-        );
-
-        const drivesIdsToPreserve = (await Promise.all(getDrivesInfo)).map(
-          (driveInfo) => driveInfo.id,
-        );
-
-        await this.preserveDrivesById(drivesIdsToPreserve, driveids, detach);
-        break;
-      }
-      case "remove-by-id": {
-        const drivesIdsToRemove = this.removeOldRemoteDrivesConfig.ids.filter(
-          (driveId) => driveids.includes(driveId),
-        );
-
-        await this.removeDrivesById(drivesIdsToRemove);
-        break;
-      }
-      case "remove-by-url": {
-        const getDrivesInfo = this.removeOldRemoteDrivesConfig.urls.map(
-          (driveUrl) => requestPublicDrive(driveUrl),
-        );
-        const drivesInfo = await Promise.all(getDrivesInfo);
-
-        const drivesIdsToRemove = drivesInfo
-          .map((driveInfo) => driveInfo.id)
-          .filter((driveId) => driveids.includes(driveId));
-
-        await this.removeDrivesById(drivesIdsToRemove);
-        break;
-      }
-      case "remove-all": {
-        const getDrives = driveids.map((driveId) =>
-          this.server.getDrive(driveId),
-        );
-        const drives = await Promise.all(getDrives);
-        const drivesToRemove = drives
-          .filter(
-            (drive) =>
-              drive.state.local.listeners.length > 0 ||
-              drive.state.local.triggers.length > 0,
-          )
-          .map((drive) => drive.state.global.id);
-
-        await this.removeDrivesById(drivesToRemove);
-        break;
-      }
-      case "detach-by-id": {
-        const drivesIdsToRemove = this.removeOldRemoteDrivesConfig.ids.filter(
-          (driveId) => driveids.includes(driveId),
-        );
-        const detachDrivesPromises = drivesIdsToRemove.map((driveId) =>
-          this.delegate.detachDrive(driveId),
-        );
-
-        await Promise.all(detachDrivesPromises);
-        break;
-      }
-      case "detach-by-url": {
-        const getDrivesInfo = this.removeOldRemoteDrivesConfig.urls.map(
-          (driveUrl) => requestPublicDrive(driveUrl),
-        );
-        const drivesInfo = await Promise.all(getDrivesInfo);
-
-        const drivesIdsToRemove = drivesInfo
-          .map((driveInfo) => driveInfo.id)
-          .filter((driveId) => driveids.includes(driveId));
-
-        const detachDrivesPromises = drivesIdsToRemove.map((driveId) =>
-          this.delegate.detachDrive(driveId),
-        );
-
-        await Promise.all(detachDrivesPromises);
-        break;
-      }
-    }
-  }
-
-  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 defaultDrives) {
-      let remoteDriveInfo = { ...remoteDrive };
-
-      try {
-        const driveInfo =
-          remoteDrive.metadata ?? (await requestPublicDrive(remoteDrive.url));
-
-        remoteDriveInfo = { ...remoteDrive, metadata: driveInfo };
-
-        this.defaultRemoteDrives.set(remoteDrive.url, remoteDriveInfo);
-
-        const driveIsAdded = drives.includes(driveInfo.id);
-        const readDriveIsAdded = readDrives?.includes(driveInfo.id);
-
-        const hasAccessLevel = remoteDrive.options.accessLevel !== undefined;
-        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 =
-          hasAccessLevel && (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(remoteDrive.url, remoteDriveInfo);
-          this.delegate.emit(
-            "ALREADY_ADDED",
-            this.defaultRemoteDrives,
-            remoteDriveInfo,
-            driveInfo.id,
-            driveInfo.name,
-          );
-          continue;
-        }
-
-        remoteDriveInfo.status = "ADDING";
-
-        this.defaultRemoteDrives.set(remoteDrive.url, remoteDriveInfo);
-        this.delegate.emit("ADDING", this.defaultRemoteDrives, remoteDriveInfo);
-
-        if ((!hasAccessLevel && readServer) || readMode) {
-          await readServer.addReadDrive(remoteDrive.url, {
-            ...remoteDrive.options,
-            expectedDriveInfo: driveInfo,
-          });
-        } else {
-          await this.server.addRemoteDrive(remoteDrive.url, {
-            ...remoteDrive.options,
-            expectedDriveInfo: driveInfo,
-          });
-        }
-
-        remoteDriveInfo.status = "SUCCESS";
-
-        this.defaultRemoteDrives.set(remoteDrive.url, remoteDriveInfo);
-        this.delegate.emit(
-          "SUCCESS",
-          this.defaultRemoteDrives,
-          remoteDriveInfo,
-          driveInfo.id,
-          driveInfo.name,
-        );
-      } catch (error) {
-        remoteDriveInfo.status = "ERROR";
-
-        this.defaultRemoteDrives.set(remoteDrive.url, remoteDriveInfo);
-        this.delegate.emit(
-          "ERROR",
-          this.defaultRemoteDrives,
-          remoteDriveInfo,
-          undefined,
-          undefined,
-          error as Error,
-        );
-      }
-    }
-  }
-}

package/src/utils/document-helpers.ts

@@ -1,21 +0,0 @@
-import { utils } from "document-model/document";
-
-export const {
-  attachBranch,
-  garbageCollect,
-  groupOperationsByScope,
-  merge,
-  split,
-  precedes,
-  removeExistingOperations,
-  reshuffleByTimestamp,
-  sortOperations,
-  addUndo,
-  checkOperationsIntegrity,
-  checkCleanedOperationsIntegrity,
-  reshuffleByTimestampAndIndex,
-  nextSkipNumber,
-  prepareOperations,
-  IntegrityIssueSubType,
-  IntegrityIssueType,
-} = utils.documentHelpers;

package/src/utils/graphql.ts

@@ -1,301 +0,0 @@
-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;
-  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 {
-            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
-                        error
-                        hash
-                        index
-                        skip
-                        timestamp
-                        type
-                        inputText
-                        context {
-                            signer {
-                                user {
-                                    address
-                                    networkId
-                                    chainId
-                                }
-                                app {
-                                    name
-                                    key
-                                }
-                                signatures
-                            }
-                        }
-                    }
-                    ... 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,
-  };
-}