fix: add the redis extension conditionally (#5524)

* fix: add the redis extension conditionally

* chore: import order and stuff

* fix: added logger, error handling and routing

* feat: configured sentry with source maps

* fix: sentry config and returning json

* fix: remove on change logs

* fix: add pretty print

live/src/core/config/sentry-config.ts

@@ -0,0 +1,19 @@
+import * as Sentry from "@sentry/node";
+import { nodeProfilingIntegration } from "@sentry/profiling-node";
+
+// Ensure to call this before importing any other modules!
+Sentry.init({
+  dsn: process.env.LIVE_SENTRY_DSN,
+  environment: process.env.LIVE_SENTRY_ENVIRONMENT || "development",
+
+  integrations: [
+    // Add our Profiling integration
+    nodeProfilingIntegration(),
+  ],
+  // Add Tracing by setting tracesSampleRate
+  // We recommend adjusting this value in production
+  tracesSampleRate: Number(process.env.LIVE_SENTRY_TRACES_SAMPLE_RATE) || 0.5,
+  // Set sampling rate for profiling
+  // This is relative to tracesSampleRate
+  profilesSampleRate: 1.0,
+});

live/src/core/extensions/index.ts

@@ -0,0 +1,137 @@
+// Third-party libraries
+import { Redis } from "ioredis";
+
+// Hocuspocus extensions and core
+import { Database } from "@hocuspocus/extension-database";
+import { Extension } from "@hocuspocus/server";
+import { Logger } from "@hocuspocus/extension-logger";
+import { Redis as HocusPocusRedis } from "@hocuspocus/extension-redis";
+
+// Core helpers and utilities
+import { manualLogger } from "@/core/helpers/logger.js";
+import { getRedisUrl } from "@/core/lib/utils/redis-url.js";
+
+// Core libraries
+import {
+  fetchPageDescriptionBinary,
+  updatePageDescription,
+} from "@/core/lib/page.js";
+
+// Core types
+import { TDocumentTypes } from "@/core/types/common.js";
+
+// Plane live libraries
+import { fetchDocument } from "@/plane-live/lib/fetch-document.js";
+import { updateDocument } from "@/plane-live/lib/update-document.js";
+
+export const getExtensions: () => Extension[] = () => {
+  const extensions: Extension[] = [
+    new Logger({
+      onChange: false,
+      log: (message) => {
+        manualLogger.info(message);
+      },
+    }),
+    new Database({
+      fetch: async ({
+        documentName: pageId,
+        requestHeaders,
+        requestParameters,
+      }) => {
+        // request headers
+        const cookie = requestHeaders.cookie?.toString();
+        // query params
+        const params = requestParameters;
+        const documentType = params.get("documentType")?.toString() as
+          | TDocumentTypes
+          | undefined;
+
+        return new Promise(async (resolve) => {
+          try {
+            let fetchedData = null;
+            if (documentType === "project_page") {
+              fetchedData = await fetchPageDescriptionBinary(
+                params,
+                pageId,
+                cookie,
+              );
+            } else {
+              fetchedData = await fetchDocument({
+                cookie,
+                documentType,
+                pageId,
+                params,
+              });
+            }
+            resolve(fetchedData);
+          } catch (error) {
+            console.error("Error in fetching document", error);
+          }
+        });
+      },
+      store: async ({
+        state,
+        documentName: pageId,
+        requestHeaders,
+        requestParameters,
+      }) => {
+        // request headers
+        const cookie = requestHeaders.cookie?.toString();
+        // query params
+        const params = requestParameters;
+        const documentType = params.get("documentType")?.toString() as
+          | TDocumentTypes
+          | undefined;
+
+        return new Promise(async () => {
+          try {
+            if (documentType === "project_page") {
+              await updatePageDescription(params, pageId, state, cookie);
+            } else {
+              await updateDocument({
+                cookie,
+                documentType,
+                pageId,
+                params,
+                updatedDescription: state,
+              });
+            }
+          } catch (error) {
+            console.error("Error in updating document", error);
+          }
+        });
+      },
+    }),
+  ];
+
+  const redisUrl = getRedisUrl();
+
+  // Add the Redis extension only if configured
+  if (redisUrl) {
+    try {
+      const redisClient = new Redis(redisUrl);
+      redisClient.on("error", (error: any) => {
+        // if auth fails or the server is down, disconnect redis
+        if (
+          error?.code === "ENOTFOUND" ||
+          error.message.includes("WRONGPASS") ||
+          error.message.includes("NOAUTH")
+        ) {
+          redisClient.disconnect();
+        }
+        manualLogger.error(
+          `Redis Client wasn't able to connect, continuing without Redis (you won't be able to sync data betwen multiple plane live servers)`,
+        );
+        manualLogger.error(error);
+      });
+      redisClient.on("ready", () => {
+        manualLogger.info("Redis Client connected");
+        extensions.push(new HocusPocusRedis({ redis: redisClient }));
+      });
+    } catch (error) {
+      manualLogger.error("Failed to connect to Redis:", error);
+    }
+  }
+
+  return extensions;
+};

live/src/core/helpers/error-handler.ts

@@ -0,0 +1,21 @@
+import { ErrorRequestHandler } from "express";
+import { manualLogger } from "@/core/helpers/logger.js";
+
+export const errorHandler: ErrorRequestHandler = (err, _req, res, _next) => {
+  // Log the error
+  manualLogger.error(err);
+
+  // Set the response status
+  res.status(err.status || 500);
+
+  // Send the response
+  res.json({
+    error: {
+      message:
+        process.env.NODE_ENV === "production"
+          ? "An unexpected error occurred"
+          : err.message,
+      ...(process.env.NODE_ENV !== "production" && { stack: err.stack }),
+    },
+  });
+};

live/src/core/helpers/logger.ts

@@ -0,0 +1,15 @@
+import { pinoHttp } from "pino-http";
+
+const transport = {
+  target: "pino-pretty",
+  options: {
+    colorize: true,
+  },
+};
+
+export const logger = pinoHttp({
+  level: "info",
+  transport: transport,
+});
+
+export const manualLogger = logger.logger;

live/src/core/hocuspocus-server.ts

@@ -0,0 +1,35 @@
+import { Server } from "@hocuspocus/server";
+
+import { handleAuthentication } from "@/core/lib/authentication.js";
+import { getExtensions } from "@/core/extensions/index.js";
+
+export const HocusPocusServer = Server.configure({
+  onAuthenticate: async ({
+    requestHeaders,
+    requestParameters,
+    connection,
+    // user id used as token for authentication
+    token,
+  }) => {
+    // request headers
+    const cookie = requestHeaders.cookie?.toString();
+    // params
+    const params = requestParameters;
+
+    if (!cookie) {
+      throw Error("Credentials not provided");
+    }
+
+    try {
+      await handleAuthentication({
+        connection,
+        cookie,
+        params,
+        token,
+      });
+    } catch (error) {
+      throw Error("Authentication unsuccessful!");
+    }
+  },
+  extensions: getExtensions(),
+});