document-drive 1.19.0 → 1.20.0

package/src/queue/types.ts

@@ -1,79 +0,0 @@
-import { Action, Operation } from "document-model/document";
-import type { Unsubscribe } from "nanoevents";
-import { AddOperationOptions, IOperationResult } from "../server";
-
-export interface BaseJob {
-  driveId: string;
-  documentId?: string;
-  actions?: Action[];
-  options?: AddOperationOptions;
-}
-
-export interface OperationJob extends BaseJob {
-  operations: Operation[];
-}
-
-export interface ActionJob extends BaseJob {
-  actions: Action[];
-}
-
-export type Job = OperationJob | ActionJob;
-
-export type JobId = string;
-
-export interface QueueEvents {
-  jobCompleted: (job: IJob<Job>, result: IOperationResult) => void;
-  jobFailed: (job: IJob<Job>, error: Error) => void;
-  queueRemoved: (queueId: string) => void;
-}
-
-export interface IServerDelegate {
-  checkDocumentExists: (
-    driveId: string,
-    documentId: string,
-  ) => Promise<boolean>;
-  processJob: (job: Job) => Promise<IOperationResult>;
-}
-
-export interface IQueueManager {
-  addJob(job: Job): Promise<JobId>;
-  getQueue(driveId: string, document?: string): IQueue<Job, IOperationResult>;
-  removeQueue(driveId: string, documentId?: string): void;
-  getQueueByIndex(index: number): IQueue<Job, IOperationResult> | null;
-  getQueues(): string[];
-  init(
-    delegate: IServerDelegate,
-    onError: (error: Error) => void,
-  ): Promise<void>;
-  on<K extends keyof QueueEvents>(
-    this: this,
-    event: K,
-    cb: QueueEvents[K],
-  ): Unsubscribe;
-}
-
-export type IJob<T> = { jobId: JobId } & T;
-
-export interface IQueue<T, R> {
-  addJob(data: IJob<T>): Promise<void>;
-  getNextJob(): Promise<IJob<T> | undefined>;
-  amountOfJobs(): Promise<number>;
-  getId(): string;
-  setBlocked(blocked: boolean): Promise<void>;
-  isBlocked(): Promise<boolean>;
-  isDeleted(): Promise<boolean>;
-  setDeleted(deleted: boolean): Promise<void>;
-  getJobs(): Promise<IJob<T>[]>;
-  addDependencies(job: IJob<Job>): Promise<void>;
-  removeDependencies(job: IJob<Job>): Promise<void>;
-}
-
-export type IJobQueue = IQueue<Job, IOperationResult>;
-
-export function isOperationJob(job: Job): job is OperationJob {
-  return "operations" in job;
-}
-
-export function isActionJob(job: Job): job is ActionJob {
-  return "actions" in job;
-}

package/src/read-mode/errors.ts

@@ -1,19 +0,0 @@
-export abstract class ReadDriveError extends Error {}
-
-export class ReadDriveNotFoundError extends ReadDriveError {
-  constructor(driveId: string) {
-    super(`Read drive ${driveId} not found.`);
-  }
-}
-
-export class ReadDriveSlugNotFoundError extends ReadDriveError {
-  constructor(slug: string) {
-    super(`Read drive with slug ${slug} not found.`);
-  }
-}
-
-export class ReadDocumentNotFoundError extends ReadDriveError {
-  constructor(drive: string, id: string) {
-    super(`Document with id ${id} not found on read drive ${drive}.`);
-  }
-}

package/src/read-mode/index.ts

@@ -1,125 +0,0 @@
-import { Document } from "document-model/document";
-import { DocumentDriveServerConstructor, RemoteDriveOptions } from "../server";
-import { logger } from "../utils/logger";
-import { ReadDriveSlugNotFoundError } from "./errors";
-import { ReadModeService } from "./service";
-import {
-  IReadModeDriveServer,
-  IReadModeDriveService,
-  ReadDrive,
-  ReadDriveOptions,
-  ReadDrivesListener,
-  ReadModeDriveServerMixin,
-} from "./types";
-
-export * from "./errors";
-export * from "./types";
-
-export function ReadModeServer<TBase extends DocumentDriveServerConstructor>(
-  Base: TBase,
-): ReadModeDriveServerMixin {
-  return class ReadMode extends Base implements IReadModeDriveServer {
-    #readModeStorage: IReadModeDriveService;
-    #listeners = new Set<ReadDrivesListener>();
-
-    constructor(...args: any[]) {
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-      super(...args);
-
-      this.#readModeStorage = new ReadModeService(
-        this.getDocumentModel.bind(this),
-      );
-
-      this.#buildDrives()
-        .then((drives) => {
-          if (drives.length) {
-            this.#notifyListeners(drives, "add");
-          }
-        })
-        .catch(logger.error);
-    }
-
-    async #buildDrives() {
-      const driveIds = await this.getReadDrives();
-      const drives = (
-        await Promise.all(driveIds.map((driveId) => this.getReadDrive(driveId)))
-      ).filter((drive) => !(drive instanceof Error)) as ReadDrive[];
-      return drives;
-    }
-
-    #notifyListeners(drives: ReadDrive[], operation: "add" | "delete") {
-      this.#listeners.forEach((listener) => listener(drives, operation));
-    }
-
-    getReadDrives(): Promise<string[]> {
-      return this.#readModeStorage.getReadDrives();
-    }
-
-    getReadDrive(id: string) {
-      return this.#readModeStorage.getReadDrive(id);
-    }
-
-    getReadDriveBySlug(
-      slug: string,
-    ): Promise<ReadDrive | ReadDriveSlugNotFoundError> {
-      return this.#readModeStorage.getReadDriveBySlug(slug);
-    }
-
-    getReadDriveContext(id: string) {
-      return this.#readModeStorage.getReadDriveContext(id);
-    }
-
-    async addReadDrive(url: string, options?: ReadDriveOptions) {
-      await this.#readModeStorage.addReadDrive(url, options);
-      this.#notifyListeners(await this.#buildDrives(), "add");
-    }
-
-    fetchDrive(id: string) {
-      return this.#readModeStorage.fetchDrive(id);
-    }
-
-    fetchDocument<D extends Document>(
-      driveId: string,
-      documentId: string,
-      documentType: string,
-    ) {
-      return this.#readModeStorage.fetchDocument<D>(
-        driveId,
-        documentId,
-        documentType,
-      );
-    }
-
-    async deleteReadDrive(id: string) {
-      const error = await this.#readModeStorage.deleteReadDrive(id);
-      if (error) {
-        return error;
-      }
-
-      this.#notifyListeners(await this.#buildDrives(), "delete");
-    }
-
-    async migrateReadDrive(id: string, options: RemoteDriveOptions) {
-      const result = await this.getReadDriveContext(id);
-      if (result instanceof Error) {
-        return result;
-      }
-
-      const { url, ...readOptions } = result;
-      try {
-        const newDrive = await this.addRemoteDrive(url, options);
-        return newDrive;
-      } catch (error) {
-        // if an error is thrown, then add the read drive again
-        logger.error(error);
-        await this.addReadDrive(result.url, readOptions);
-        throw error;
-      }
-    }
-
-    onReadDrivesUpdate(listener: ReadDrivesListener) {
-      this.#listeners.add(listener);
-      return Promise.resolve(() => this.#listeners.delete(listener));
-    }
-  };
-}

package/src/read-mode/service.ts

@@ -1,207 +0,0 @@
-import type { DocumentDriveDocument } from "document-model-libs/document-drive";
-import * as DocumentDrive from "document-model-libs/document-drive";
-import { Document, DocumentModel } from "document-model/document";
-import { GraphQLError } from "graphql";
-import { DocumentModelNotFoundError } from "../server/error";
-import { fetchDocument, requestPublicDrive } from "../utils/graphql";
-import {
-  ReadDocumentNotFoundError,
-  ReadDriveError,
-  ReadDriveNotFoundError,
-  ReadDriveSlugNotFoundError,
-} from "./errors";
-import {
-  GetDocumentModel,
-  InferDocumentLocalState,
-  InferDocumentOperation,
-  InferDocumentState,
-  IReadModeDriveService,
-  ReadDrive,
-  ReadDriveContext,
-  ReadDriveOptions,
-} from "./types";
-
-export class ReadModeService implements IReadModeDriveService {
-  #getDocumentModel: GetDocumentModel;
-  #drives = new Map<
-    string,
-    { drive: Omit<ReadDrive, "readContext">; context: ReadDriveContext }
-  >();
-
-  constructor(getDocumentModel: GetDocumentModel) {
-    this.#getDocumentModel = getDocumentModel;
-  }
-
-  #parseGraphQLErrors(
-    errors: GraphQLError[],
-    driveId: string,
-    documentId?: string,
-  ) {
-    for (const error of errors) {
-      if (error.message === `Drive with id ${driveId} not found`) {
-        return new ReadDriveNotFoundError(driveId);
-      } else if (
-        documentId &&
-        error.message === `Document with id ${documentId} not found`
-      ) {
-        return new ReadDocumentNotFoundError(driveId, documentId);
-      }
-    }
-    const firstError = errors.at(0);
-    if (firstError) {
-      return firstError;
-    }
-  }
-
-  async #fetchDrive(id: string, url: string) {
-    const { errors, document } = await fetchDocument<DocumentDriveDocument>(
-      url,
-      id,
-      DocumentDrive,
-    );
-    const error = errors ? this.#parseGraphQLErrors(errors, id) : undefined;
-    return error || document;
-  }
-
-  async fetchDrive(id: string): Promise<ReadDrive | ReadDriveNotFoundError> {
-    const drive = this.#drives.get(id);
-    if (!drive) {
-      return new ReadDriveNotFoundError(id);
-    }
-    const document = await this.fetchDocument<DocumentDriveDocument>(
-      id,
-      id,
-      DocumentDrive.documentModel.id,
-    );
-    if (document instanceof Error) {
-      return document;
-    }
-    const result = { ...document, readContext: drive.context };
-    drive.drive = result;
-    return result;
-  }
-
-  async fetchDocument<D extends Document>(
-    driveId: string,
-    documentId: string,
-    documentType: DocumentModel<
-      InferDocumentState<D>,
-      InferDocumentOperation<D>,
-      InferDocumentLocalState<D>
-    >["documentModel"]["id"],
-  ): Promise<
-    | Document<
-        InferDocumentState<D>,
-        InferDocumentOperation<D>,
-        InferDocumentLocalState<D>
-      >
-    | DocumentModelNotFoundError
-    | ReadDriveNotFoundError
-    | ReadDocumentNotFoundError
-  > {
-    const drive = this.#drives.get(driveId);
-    if (!drive) {
-      return new ReadDriveNotFoundError(driveId);
-    }
-
-    let documentModel:
-      | DocumentModel<
-          InferDocumentState<D>,
-          InferDocumentOperation<D>,
-          InferDocumentLocalState<D>
-        >
-      | undefined = undefined;
-    try {
-      documentModel = this.#getDocumentModel(
-        documentType,
-      ) as unknown as DocumentModel<
-        InferDocumentState<D>,
-        InferDocumentOperation<D>,
-        InferDocumentLocalState<D>
-      >;
-    } catch (error) {
-      return new DocumentModelNotFoundError(documentType, error);
-    }
-
-    const { url } = drive.context;
-    const { errors, document } = await fetchDocument<D>(
-      url,
-      documentId,
-      documentModel,
-    );
-
-    if (errors) {
-      const error = this.#parseGraphQLErrors(errors, driveId, documentId);
-      if (error instanceof ReadDriveError) {
-        return error;
-      } else if (error) {
-        throw error;
-      }
-    }
-
-    if (!document) {
-      return new ReadDocumentNotFoundError(driveId, documentId);
-    }
-
-    return document;
-  }
-
-  async addReadDrive(url: string, options?: ReadDriveOptions): Promise<void> {
-    const { id } =
-      options?.expectedDriveInfo ?? (await requestPublicDrive(url));
-
-    const result = await this.#fetchDrive(id, url);
-    if (result instanceof Error) {
-      throw result;
-    } else if (!result) {
-      throw new Error(`Drive "${id}" not found at ${url}`);
-    }
-    this.#drives.set(id, {
-      drive: result as unknown as ReadDrive,
-      context: {
-        ...options,
-        url,
-      },
-    });
-  }
-
-  async getReadDrives() {
-    return Promise.resolve([...this.#drives.keys()]);
-  }
-
-  async getReadDrive(id: string) {
-    const result = this.#drives.get(id);
-    return Promise.resolve(
-      result
-        ? { ...result.drive, readContext: result.context }
-        : new ReadDriveNotFoundError(id),
-    );
-  }
-
-  async getReadDriveBySlug(
-    slug: string,
-  ): Promise<ReadDrive | ReadDriveSlugNotFoundError> {
-    const readDrive = [...this.#drives.values()].find(
-      ({ drive }) => drive.state.global.slug === slug,
-    );
-
-    return Promise.resolve(
-      readDrive
-        ? { ...readDrive.drive, readContext: readDrive.context }
-        : new ReadDriveSlugNotFoundError(slug),
-    );
-  }
-
-  getReadDriveContext(id: string) {
-    return Promise.resolve(
-      this.#drives.get(id)?.context ?? new ReadDriveNotFoundError(id),
-    );
-  }
-
-  deleteReadDrive(id: string): Promise<ReadDriveNotFoundError | undefined> {
-    const deleted = this.#drives.delete(id);
-    return Promise.resolve(
-      deleted ? undefined : new ReadDriveNotFoundError(id),
-    );
-  }
-}

package/src/read-mode/types.ts

@@ -1,108 +0,0 @@
-import {
-  DocumentDriveDocument,
-  ListenerFilter,
-} from "document-model-libs/document-drive";
-import { Action, Document, DocumentModel } from "document-model/document";
-import { DocumentDriveServerMixin, RemoteDriveOptions } from "../server";
-import { DocumentModelNotFoundError } from "../server/error";
-import { DriveInfo } from "../utils/graphql";
-import {
-  ReadDocumentNotFoundError,
-  ReadDriveNotFoundError,
-  ReadDriveSlugNotFoundError,
-} from "./errors";
-
-// TODO: move these types to the document-model package
-export type InferDocumentState<D extends Document> =
-  D extends Document<infer S> ? S : never;
-
-export type InferDocumentOperation<D extends Document> =
-  D extends Document<unknown, infer A> ? A : never;
-
-export type InferDocumentLocalState<D extends Document> =
-  D extends Document<unknown, Action, infer L> ? L : never;
-
-export type InferDocumentGenerics<D extends Document> = {
-  state: InferDocumentState<D>;
-  action: InferDocumentOperation<D>;
-  logger: InferDocumentLocalState<D>;
-};
-
-export type ReadModeDriveServerMixin =
-  DocumentDriveServerMixin<IReadModeDriveServer>;
-
-export type ReadDrivesListener = (
-  drives: ReadDrive[],
-  operation: "add" | "delete",
-) => void;
-
-export type ReadDrivesListenerUnsubscribe = () => void;
-
-export interface IReadModeDriveServer extends IReadModeDriveService {
-  migrateReadDrive(
-    id: string,
-    options: RemoteDriveOptions,
-  ): Promise<DocumentDriveDocument | ReadDriveNotFoundError>;
-  onReadDrivesUpdate(
-    listener: ReadDrivesListener,
-  ): Promise<ReadDrivesListenerUnsubscribe>; // TODO: make DriveEvents extensible and reuse event emitter
-}
-
-export type ReadDriveOptions = {
-  expectedDriveInfo?: DriveInfo;
-  filter?: ListenerFilter;
-};
-
-export type ReadDriveContext = {
-  url: string;
-} & ReadDriveOptions;
-
-export type ReadDrive = DocumentDriveDocument & {
-  readContext: ReadDriveContext;
-};
-
-export type IsDocument<D extends Document> =
-  (<G>() => G extends D ? 1 : 2) extends <G>() => G extends Document ? 1 : 2
-    ? true
-    : false;
-
-export interface IReadModeDriveService {
-  addReadDrive(url: string, options?: ReadDriveOptions): Promise<void>;
-
-  getReadDrives(): Promise<string[]>;
-
-  getReadDriveBySlug(
-    slug: string,
-  ): Promise<ReadDrive | ReadDriveSlugNotFoundError>;
-
-  getReadDrive(id: string): Promise<ReadDrive | ReadDriveNotFoundError>;
-
-  getReadDriveContext(
-    id: string,
-  ): Promise<ReadDriveContext | ReadDriveNotFoundError>;
-
-  fetchDrive(id: string): Promise<ReadDrive | ReadDriveNotFoundError>;
-
-  fetchDocument<D extends Document>(
-    driveId: string,
-    documentId: string,
-    documentType: DocumentModel<
-      InferDocumentState<D>,
-      InferDocumentOperation<D>,
-      InferDocumentLocalState<D>
-    >["documentModel"]["id"],
-  ): Promise<
-    | Document<
-        InferDocumentState<D>,
-        InferDocumentOperation<D>,
-        InferDocumentLocalState<D>
-      >
-    | DocumentModelNotFoundError
-    | ReadDriveNotFoundError
-    | ReadDocumentNotFoundError
-  >;
-
-  deleteReadDrive(id: string): Promise<ReadDriveNotFoundError | undefined>;
-}
-
-export type GetDocumentModel = (documentType: string) => DocumentModel;

package/src/server/error.ts

@@ -1,70 +0,0 @@
-import type { Operation } from "document-model/document";
-import type { ErrorStatus } from "./types";
-
-export class DocumentModelNotFoundError extends Error {
-  constructor(
-    public id: string,
-    cause?: unknown,
-  ) {
-    super(`Document model "${id}" not found`, { cause });
-  }
-}
-export class OperationError extends Error {
-  status: ErrorStatus;
-  operation: Operation | undefined;
-
-  constructor(
-    status: ErrorStatus,
-    operation?: Operation,
-    message?: string,
-    cause?: unknown,
-  ) {
-    super(message, { cause: cause ?? operation });
-    this.status = status;
-    this.operation = operation;
-  }
-}
-
-export class ConflictOperationError extends OperationError {
-  constructor(existingOperation: Operation, newOperation: Operation) {
-    super(
-      "CONFLICT",
-      newOperation,
-      `Conflicting operation on index ${newOperation.index}`,
-      { existingOperation, newOperation },
-    );
-  }
-}
-
-export class MissingOperationError extends OperationError {
-  constructor(index: number, operation: Operation) {
-    super("MISSING", operation, `Missing operation on index ${index}`);
-  }
-}
-
-export class DriveAlreadyExistsError extends Error {
-  driveId: string;
-
-  constructor(driveId: string) {
-    super(`Drive already exists. ID: ${driveId}`);
-    this.driveId = driveId;
-  }
-}
-
-export class DriveNotFoundError extends Error {
-  driveId: string;
-
-  constructor(driveId: string) {
-    super(`Drive with id ${driveId} not found`);
-    this.driveId = driveId;
-  }
-}
-
-export class SynchronizationUnitNotFoundError extends Error {
-  syncUnitId: string;
-
-  constructor(message: string, syncUnitId: string) {
-    super(message);
-    this.syncUnitId = syncUnitId;
-  }
-}