@abyss-project/workspace 0.0.0-stage → 1.0.0

package/src/server-sent-events/protocols/atlas/atlas.sse-protocol.ts

@@ -0,0 +1,90 @@
+import { SystemSSEMessageContent } from '..';
+import { ValueOf } from '../../../types';
+import { IAtlas, IAtlasGroup, IAtlasPage, IAtlasDocument } from '../../../types/interface';
+
+export enum AtlasSSEEvent {
+  ATLAS_UPDATED = 'ATLAS_UPDATED',
+  ATLAS_DELETED = 'ATLAS_DELETED',
+  GROUP_CREATED = 'GROUP_CREATED',
+  GROUP_UPDATED = 'GROUP_UPDATED',
+  GROUP_DELETED = 'GROUP_DELETED',
+  PAGE_CREATED = 'PAGE_CREATED',
+  PAGE_UPDATED = 'PAGE_UPDATED',
+  PAGE_DELETED = 'PAGE_DELETED',
+  PAGE_CONTENT_DIFF_UPDATED = 'PAGE_CONTENT_DIFF_UPDATED',
+  ATLAS_DOCUMENT_CREATE = 'ATLAS_DOCUMENT_CREATE',
+  ATLAS_DOCUMENT_DELETE = 'ATLAS_DOCUMENT_DELETE',
+}
+
+export type AtlasSSEMessageContent = ValueOf<
+  {
+    [K in AtlasSSEEvent]: {
+      type: K;
+      payload: SourceAtlasSSEEventPayload[K];
+    };
+  }
+>;
+
+export class SourceAtlasSSEEventPayload implements Record<AtlasSSEEvent, Record<string, any>> {
+  [AtlasSSEEvent.ATLAS_UPDATED]!: {
+    atlasId: string;
+    atlas: IAtlas;
+  };
+
+  [AtlasSSEEvent.ATLAS_DELETED]!: {
+    atlasId: string;
+    userId?: string;
+  };
+
+  [AtlasSSEEvent.GROUP_CREATED]!: {
+    atlasId: string;
+    group: IAtlasGroup;
+  };
+
+  [AtlasSSEEvent.GROUP_UPDATED]!: {
+    atlasId: string;
+    group: IAtlasGroup;
+  };
+
+  [AtlasSSEEvent.GROUP_DELETED]!: {
+    atlasId: string;
+    groupId: string;
+  };
+
+  [AtlasSSEEvent.PAGE_CREATED]!: {
+    atlasId: string;
+    page: IAtlasPage;
+  };
+
+  [AtlasSSEEvent.PAGE_UPDATED]!: {
+    atlasId: string;
+    page: IAtlasPage;
+  };
+
+  [AtlasSSEEvent.PAGE_DELETED]!: {
+    atlasId: string;
+    pageId: string;
+  };
+
+  [AtlasSSEEvent.PAGE_CONTENT_DIFF_UPDATED]!: {
+    atlasId: string;
+    pageId: string;
+    diff: string | null;
+    version: number;
+    lastModifiedByUserId?: string;
+  };
+
+  [AtlasSSEEvent.ATLAS_DOCUMENT_CREATE]!: {
+    atlasId: string;
+    atlasPageId: string;
+    atlasDocument: IAtlasDocument;
+  };
+
+  [AtlasSSEEvent.ATLAS_DOCUMENT_DELETE]!: {
+    atlasId: string;
+    atlasPageId: string;
+    atlasDocumentId: string;
+  };
+}
+
+export type AtlasSSEEventContent = AtlasSSEMessageContent | SystemSSEMessageContent;

package/src/server-sent-events/protocols/atlas/index.ts

@@ -0,0 +1 @@
+export * from './atlas.sse-protocol';

package/src/server-sent-events/protocols/board/board.sse-protocol.ts

@@ -0,0 +1,115 @@
+import { SystemSSEMessageContent } from '..';
+import {
+  IBoardCardChecklist,
+  IBoardCardComment,
+  IBoardCardDocument,
+  IBoardCardMember,
+  IGetBoardData,
+  IListBoardLabelData,
+  ValueOf,
+} from '../../../types';
+
+export enum BoardSSEEvent {
+  BOARD_UPDATE = 'BOARD_UPDATE',
+  BOARD_DELETE = 'BOARD_DELETE',
+
+  BOARD_LABELS = 'BOARD_LABELS',
+
+  BOARD_CARD_MEMBER_CREATE = 'BOARD_CARD_MEMBER_CREATE',
+  BOARD_CARD_MEMBER_DELETE = 'BOARD_CARD_MEMBER_DELETE',
+
+  BOARD_CARD_DOCUMENT_CREATE = 'BOARD_CARD_DOCUMENT_CREATE',
+  BOARD_CARD_DOCUMENT_DELETE = 'BOARD_CARD_DOCUMENT_DELETE',
+
+  BOARD_CARD_COMMENT_CREATE = 'BOARD_CARD_COMMENT_CREATE',
+  BOARD_CARD_COMMENT_DELETE = 'BOARD_CARD_COMMENT_DELETE',
+  BOARD_CARD_COMMENT_UPDATE = 'BOARD_CARD_COMMENT_UPDATE',
+
+  BOARD_CARD_CHECKLIST_CREATE = 'BOARD_CARD_CHECKLIST_CREATE',
+  BOARD_CARD_CHECKLIST_DELETE = 'BOARD_CARD_CHECKLIST_DELETE',
+  BOARD_CARD_CHECKLIST_UPDATE = 'BOARD_CARD_CHECKLIST_UPDATE',
+}
+
+export type BoardSSEMessageContent = ValueOf<
+  {
+    [K in BoardSSEEvent]: {
+      type: K;
+      payload: SourceBoardSSEEventPayload[K];
+    };
+  }
+>;
+
+export class SourceBoardSSEEventPayload implements Record<BoardSSEEvent, Record<string, any>> {
+  [BoardSSEEvent.BOARD_UPDATE]!: {
+    boardId: string;
+    boardData: IGetBoardData;
+  };
+  [BoardSSEEvent.BOARD_DELETE]!: {
+    boardId: string;
+  };
+
+  [BoardSSEEvent.BOARD_LABELS]!: {
+    boardId: string;
+    boardLabels: IListBoardLabelData['boardLabels'];
+  };
+
+  [BoardSSEEvent.BOARD_CARD_MEMBER_CREATE]!: {
+    boardId: string;
+    boardCardMember: IBoardCardMember;
+    boardData: IGetBoardData;
+  };
+  [BoardSSEEvent.BOARD_CARD_MEMBER_DELETE]!: {
+    boardId: string;
+    boardCardId: string;
+    userId: string;
+    boardData: IGetBoardData;
+  };
+
+  [BoardSSEEvent.BOARD_CARD_DOCUMENT_CREATE]!: {
+    boardId: string;
+    boardCardDocument: IBoardCardDocument;
+    boardData: IGetBoardData;
+  };
+  [BoardSSEEvent.BOARD_CARD_DOCUMENT_DELETE]!: {
+    boardId: string;
+    boardCardId: string;
+    boardCardDocumentId: string;
+    boardData: IGetBoardData;
+  };
+
+  [BoardSSEEvent.BOARD_CARD_COMMENT_CREATE]!: {
+    boardId: string;
+    boardCardComment: IBoardCardComment;
+    boardData: IGetBoardData;
+  };
+  [BoardSSEEvent.BOARD_CARD_COMMENT_DELETE]!: {
+    boardId: string;
+    boardCardId: string;
+    boardCardCommentId: string;
+    boardData: IGetBoardData;
+  };
+  [BoardSSEEvent.BOARD_CARD_COMMENT_UPDATE]!: {
+    boardId: string;
+    boardCardComment: IBoardCardComment;
+    boardData: IGetBoardData;
+  };
+
+  [BoardSSEEvent.BOARD_CARD_CHECKLIST_CREATE]!: {
+    boardId: string;
+    boardCardChecklist: IBoardCardChecklist;
+    boardData: IGetBoardData;
+  };
+  [BoardSSEEvent.BOARD_CARD_CHECKLIST_DELETE]!: {
+    boardId: string;
+    boardCardId: string;
+    boardCardChecklistId: string;
+    boardData: IGetBoardData;
+  };
+  [BoardSSEEvent.BOARD_CARD_CHECKLIST_UPDATE]!: {
+    boardId: string;
+    boardCardChecklist: IBoardCardChecklist;
+    boardData: IGetBoardData;
+  };
+}
+
+export type BoardSSEEventContent = BoardSSEMessageContent | SystemSSEMessageContent;

package/src/server-sent-events/protocols/board/index.ts

@@ -0,0 +1 @@
+export * from './board.sse-protocol';

package/src/server-sent-events/protocols/board-card/board-card.sse-protocol.ts

@@ -0,0 +1,26 @@
+import { SystemSSEMessageContent } from '..';
+import { IGetBoardCardData, ValueOf } from '../../../types';
+
+export enum BoardCardSSEEvent {
+  BOARD_CARD_UPDATE = 'BOARD_CARD_UPDATE',
+}
+
+export type BoardCardSSEMessageContent = ValueOf<
+  {
+    [K in BoardCardSSEEvent]: {
+      type: K;
+      payload: SourceBoardCardSSEEventPayload[K];
+    };
+  }
+>;
+
+export class SourceBoardCardSSEEventPayload
+  implements Record<BoardCardSSEEvent, Record<string, any>>
+{
+  [BoardCardSSEEvent.BOARD_CARD_UPDATE]!: {
+    boardCardId: string;
+    boardData: IGetBoardCardData;
+  };
+}
+
+export type BoardCardSSEEventContent = BoardCardSSEMessageContent | SystemSSEMessageContent;

package/src/server-sent-events/protocols/board-card/index.ts

@@ -0,0 +1 @@
+export * from './board-card.sse-protocol';

package/src/server-sent-events/protocols/index.ts

@@ -0,0 +1,26 @@
+import { ValueOf } from '../..';
+
+export * from './board';
+export * from './board-card';
+export * from './retrospective';
+export * from './atlas';
+
+export enum SYSTEM_PROTOCOL_EVENTS {
+  PING = 'PING',
+}
+
+export type SystemSSEMessageContent = ValueOf<
+  {
+    [K in SYSTEM_PROTOCOL_EVENTS]: {
+      type: K;
+      payload: SystemSSEEventPayload[K];
+    };
+  }
+>;
+
+export class SystemSSEEventPayload implements Record<SYSTEM_PROTOCOL_EVENTS, Record<string, any>> {
+  [SYSTEM_PROTOCOL_EVENTS.PING]!: {
+    openedAt: number;
+    timestamp: number;
+  };
+}

package/src/server-sent-events/protocols/retrospective/index.ts

@@ -0,0 +1 @@
+export * from './retrospective.sse-protocol';

package/src/server-sent-events/protocols/retrospective/retrospective.sse-protocol.ts

@@ -0,0 +1,138 @@
+import { SystemSSEMessageContent } from '..';
+import { ValueOf } from '../../../types';
+import { RetrospectivePhase } from '../../../types/enum/retrospective-phase.enum';
+import {
+  IRetrospective,
+  IRetrospectiveCard,
+  IRetrospectiveSection,
+  IRetrospectiveParticipant,
+  IRetrospectiveAction,
+} from '../../../types/interface';
+
+export enum RetrospectiveSSEEvent {
+  RETROSPECTIVE_UPDATED = 'RETROSPECTIVE_UPDATED',
+  RETROSPECTIVE_DELETED = 'RETROSPECTIVE_DELETED',
+  PHASE_CHANGED = 'PHASE_CHANGED',
+  CARD_CREATED = 'CARD_CREATED',
+  CARD_UPDATED = 'CARD_UPDATED',
+  CARD_DELETED = 'CARD_DELETED',
+  CARD_VOTES_CHANGED = 'CARD_VOTES_CHANGED',
+  SECTION_CREATED = 'SECTION_CREATED',
+  SECTION_UPDATED = 'SECTION_UPDATED',
+  SECTION_DELETED = 'SECTION_DELETED',
+  MEMBER_JOINED = 'MEMBER_JOINED',
+  MEMBER_UPDATED = 'MEMBER_UPDATED',
+  MEMBER_LEFT = 'MEMBER_LEFT',
+  ACTION_CREATED = 'ACTION_CREATED',
+  ACTION_UPDATED = 'ACTION_UPDATED',
+  ACTION_DELETED = 'ACTION_DELETED',
+}
+
+export type RetrospectiveSSEMessageContent = ValueOf<
+  {
+    [K in RetrospectiveSSEEvent]: {
+      type: K;
+      payload: SourceRetrospectiveSSEEventPayload[K];
+    };
+  }
+>;
+
+export class SourceRetrospectiveSSEEventPayload
+  implements Record<RetrospectiveSSEEvent, Record<string, any>>
+{
+  /** The retrospective alone: no cards, no members (the client reloads them by GET). */
+  [RetrospectiveSSEEvent.RETROSPECTIVE_UPDATED]!: {
+    retrospectiveId: string;
+    retrospective: IRetrospective;
+  };
+
+  [RetrospectiveSSEEvent.PHASE_CHANGED]!: {
+    retrospectiveId: string;
+    phase: RetrospectivePhase;
+    phaseChangedAt: Date;
+    /** The votes per member in force once the change is done. */
+    voteBudget: number;
+  };
+
+  [RetrospectiveSSEEvent.RETROSPECTIVE_DELETED]!: {
+    retrospectiveId: string;
+    userId?: string;
+  };
+
+  [RetrospectiveSSEEvent.CARD_CREATED]!: {
+    retrospectiveId: string;
+    card: IRetrospectiveCard;
+  };
+
+  [RetrospectiveSSEEvent.CARD_UPDATED]!: {
+    retrospectiveId: string;
+    card: IRetrospectiveCard;
+  };
+
+  [RetrospectiveSSEEvent.CARD_DELETED]!: {
+    retrospectiveId: string;
+    cardId: string;
+  };
+
+  /**
+   * The votes of a card changed. Blind vote: during the VOTE phase only the connections of the
+   * member who voted receive it (nobody else learns that a vote happened); from the DISCUSS phase
+   * on every connection receives it, with the total in `card.voteCount`. Never the identity of a
+   * voter.
+   */
+  [RetrospectiveSSEEvent.CARD_VOTES_CHANGED]!: {
+    retrospectiveId: string;
+    cardId: string;
+    /** The card projected for the receiving connection. */
+    card: IRetrospectiveCard;
+    /** How many votes of the budget the receiving reader has spent. */
+    votesUsed: number;
+  };
+
+  [RetrospectiveSSEEvent.SECTION_CREATED]!: {
+    retrospectiveId: string;
+    section: IRetrospectiveSection;
+  };
+
+  [RetrospectiveSSEEvent.SECTION_UPDATED]!: {
+    retrospectiveId: string;
+    section: IRetrospectiveSection;
+  };
+
+  [RetrospectiveSSEEvent.SECTION_DELETED]!: {
+    retrospectiveId: string;
+    sectionId: string;
+  };
+
+  [RetrospectiveSSEEvent.MEMBER_JOINED]!: {
+    retrospectiveId: string;
+    member: IRetrospectiveParticipant;
+  };
+
+  [RetrospectiveSSEEvent.MEMBER_UPDATED]!: {
+    retrospectiveId: string;
+    member: IRetrospectiveParticipant;
+  };
+
+  [RetrospectiveSSEEvent.MEMBER_LEFT]!: {
+    retrospectiveId: string;
+    memberId: string;
+  };
+
+  [RetrospectiveSSEEvent.ACTION_CREATED]!: {
+    retrospectiveId: string;
+    action: IRetrospectiveAction;
+  };
+
+  [RetrospectiveSSEEvent.ACTION_UPDATED]!: {
+    retrospectiveId: string;
+    action: IRetrospectiveAction;
+  };
+
+  [RetrospectiveSSEEvent.ACTION_DELETED]!: {
+    retrospectiveId: string;
+    actionId: string;
+  };
+}
+
+export type RetrospectiveSSEEventContent = RetrospectiveSSEMessageContent | SystemSSEMessageContent;

package/src/server-sent-events/server-sent-events.manager.ts

@@ -0,0 +1,127 @@
+import { Request, Response } from 'express-serve-static-core';
+import { v4 as uuidv4 } from 'uuid';
+import { SYSTEM_PROTOCOL_EVENTS, SystemSSEMessageContent } from './protocols';
+
+export class ServerSentEventBaseContext {
+  id = uuidv4();
+  createdAt = new Date();
+
+  req!: Request;
+  res!: Response;
+}
+
+export type RedisSSEMessage = {
+  key: string;
+  data: unknown;
+};
+
+/**
+ * Decides what one connection receives of a published message: the message to write on it, or
+ * `null` to write nothing. `R` is the published (raw) message, `P` what a connection may receive.
+ */
+export type ServerSentEventProjection<
+  T extends ServerSentEventBaseContext,
+  P extends { type: string; payload: unknown },
+  R extends object,
+> = (context: T, data: R) => P | null | Promise<P | null>;
+
+export type ServerSentEventsManagerOptions<
+  T extends ServerSentEventBaseContext,
+  P extends { type: string; payload: unknown },
+  R extends object,
+> = {
+  /**
+   * When set, every published message goes through it once per connection and is never written
+   * as published. Without it the message is broadcast as is (then `R` is `P`).
+   */
+  project?: ServerSentEventProjection<T, P, R>;
+  /** A projection that throws writes nothing to that connection; this reports why. */
+  onProjectionError?: (error: unknown, context: T) => void;
+};
+
+export class ServerSentEventsManager<
+  T extends ServerSentEventBaseContext,
+  P extends { type: string; payload: unknown },
+  R extends object = P,
+> {
+  private contexts: Map<string, Set<T>>;
+
+  // Projections can be asynchronous: each connection writes its messages one after the other, in
+  // the order they were published.
+  private writeQueues = new WeakMap<T, Promise<void>>();
+
+  // Le nom du canal est accepte pour ne rien casser chez les appelants, mais il
+  // n'est pas conserve : l'aiguillage se fait par la CLE de la table des
+  // gestionnaires (`AppConfig.sse[SSEChannels.X]`), jamais par un champ porte par
+  // le gestionnaire lui-meme. Le champ qui le stockait n'etait lu nulle part.
+  constructor(
+    _channelName: string,
+    private readonly options: ServerSentEventsManagerOptions<T, P, R> = {},
+  ) {
+    this.contexts = new Map();
+  }
+
+  add(key: string, context: T, onClose: () => void) {
+    context.res.setHeader('Content-Type', 'text/event-stream');
+    context.res.setHeader('Cache-Control', 'no-cache');
+    context.res.setHeader('Connection', 'keep-alive');
+    context.res.flushHeaders?.(); // Support Express
+
+    const row = this.contexts.get(key);
+    if (!row) {
+      this.contexts.set(key, new Set([context]));
+    } else {
+      row.add(context);
+    }
+
+    const pingTimeout = setInterval(() => {
+      const payload: SystemSSEMessageContent = {
+        type: SYSTEM_PROTOCOL_EVENTS.PING,
+        payload: {
+          openedAt: context.createdAt.getTime(),
+          timestamp: Date.now(),
+        },
+      };
+      context.res.write(`data: ${JSON.stringify(payload)}\n\n`);
+    }, 10_000);
+
+    context.res.on('close', () => {
+      clearInterval(pingTimeout);
+      onClose();
+      const row = this.contexts.get(key);
+      row?.delete(context);
+    });
+  }
+
+  sendToContext(key: string, data: R, { senderId }: { senderId?: string } = {}): void {
+    const { project, onProjectionError } = this.options;
+    const date = new Date();
+
+    const clients = this.contexts.get(key);
+    clients?.forEach((client) => {
+      if (client.id === senderId) {
+        return;
+      }
+      if (!project) {
+        client.res.write(`data: ${JSON.stringify({ ...data, date })}
+
+`);
+        return;
+      }
+
+      const write = async (): Promise<void> => {
+        try {
+          const projected = await project(client, data);
+          if (projected !== null) {
+            client.res.write(`data: ${JSON.stringify({ ...projected, date })}
+
+`);
+          }
+        } catch (error: unknown) {
+          onProjectionError?.(error, client);
+        }
+      };
+      this.writeQueues.set(client, (this.writeQueues.get(client) ?? Promise.resolve()).then(write));
+    });
+  }
+}