🚀feat: shared links

api/models/Share.js

@@ -0,0 +1,91 @@
+const crypto = require('crypto');
+const { getMessages } = require('./Message');
+const SharedLink = require('./schema/shareSchema');
+const logger = require('~/config/winston');
+
+module.exports = {
+  SharedLink,
+  getSharedMessages: async (shareId) => {
+    try {
+      const share = await SharedLink.findOne({ shareId }).populate('messages').lean();
+      if (!share || !share.conversationId || !share.isPublic) {
+        return null;
+      }
+
+      const anonymousMessage = share.messages.map((message) => {
+        if (share.isAnonymous) {
+          return {
+            ...message,
+            user: 'anonymous',
+          };
+        }
+        return message;
+      });
+      return {
+        ...share,
+        messages: anonymousMessage,
+      };
+    } catch (error) {
+      logger.error('[getShare] Error getting share link', error);
+      return { message: 'Error getting share link' };
+    }
+  },
+
+  getSharedLinks: async (user, pageNumber = 1, pageSize = 25, isPublic = true) => {
+    const query = { user, isPublic };
+    try {
+      const totalConvos = (await SharedLink.countDocuments(query)) || 1;
+      const totalPages = Math.ceil(totalConvos / pageSize);
+      const shares = await SharedLink.find(query)
+        .sort({ updatedAt: -1 })
+        .skip((pageNumber - 1) * pageSize)
+        .limit(pageSize)
+        .lean();
+      return { sharedLinks: shares, pages: totalPages, pageNumber, pageSize };
+    } catch (error) {
+      logger.error('[getShareByPage] Error getting shares', error);
+      return { message: 'Error getting shares' };
+    }
+  },
+
+  createSharedLink: async (user, { conversationId, ...shareData }) => {
+    const share = await SharedLink.findOne({ conversationId }).lean();
+    if (share) {
+      return share;
+    }
+
+    try {
+      const shareId = crypto.randomUUID();
+      const messages = await getMessages({ conversationId });
+      const update = { ...shareData, shareId, messages, user };
+      return await SharedLink.findOneAndUpdate({ conversationId: conversationId, user }, update, {
+        new: true,
+        upsert: true,
+      });
+    } catch (error) {
+      logger.error('[saveShareMessage] Error saving conversation', error);
+      return { message: 'Error saving conversation' };
+    }
+  },
+  updateSharedLink: async (user, { conversationId, ...shareData }) => {
+    const share = await SharedLink.findOne({ conversationId }).lean();
+    if (!share) {
+      return { message: 'Share not found' };
+    }
+    // update messages to the latest
+    const messages = await getMessages({ conversationId });
+    const update = { ...shareData, messages, user };
+    return await SharedLink.findOneAndUpdate({ conversationId: conversationId, user }, update, {
+      new: true,
+      upsert: false,
+    });
+  },
+
+  deleteSharedLink: async (user, { shareId }) => {
+    const share = await SharedLink.findOne({ shareId, user });
+    if (!share) {
+      return { message: 'Share not found' };
+    }
+    return await SharedLink.findOneAndDelete({ shareId, user });
+  },
+};

api/models/schema/shareSchema.js

@@ -0,0 +1,38 @@
+const mongoose = require('mongoose');
+
+const shareSchema = mongoose.Schema(
+  {
+    conversationId: {
+      type: String,
+      required: true,
+    },
+    title: {
+      type: String,
+      index: true,
+    },
+    user: {
+      type: String,
+      index: true,
+    },
+    messages: [{ type: mongoose.Schema.Types.ObjectId, ref: 'Message' }],
+    shareId: {
+      type: String,
+      index: true,
+    },
+    isPublic: {
+      type: Boolean,
+      default: false,
+    },
+    isVisible: {
+      type: Boolean,
+      default: false,
+    },
+    isAnonymous: {
+      type: Boolean,
+      default: true,
+    },
+  },
+  { timestamps: true },
+);
+
+module.exports = mongoose.model('SharedLink', shareSchema);

api/server/index.js

@@ -85,6 +85,7 @@ const startServer = async () => {
   app.use('/api/assistants', routes.assistants);
   app.use('/api/files', await routes.files.initialize());
   app.use('/images/', validateImageRequest, routes.staticRoute);
+  app.use('/api/share', routes.share);
 
   app.use((req, res) => {
     res.status(404).sendFile(path.join(app.locals.paths.dist, 'index.html'));

api/server/routes/index.js

@@ -18,6 +18,7 @@ const config = require('./config');
 const assistants = require('./assistants');
 const files = require('./files');
 const staticRoute = require('./static');
+const share = require('./share');
 
 module.exports = {
   search,
@@ -40,4 +41,5 @@ module.exports = {
   assistants,
   files,
   staticRoute,
+  share,
 };

api/server/routes/share.js

@@ -0,0 +1,75 @@
+const express = require('express');
+
+const {
+  getSharedMessages,
+  createSharedLink,
+  updateSharedLink,
+  getSharedLinks,
+  deleteSharedLink,
+} = require('~/models/Share');
+const requireJwtAuth = require('~/server/middleware/requireJwtAuth');
+const router = express.Router();
+
+/**
+ * Shared messages
+ * this route does not require authentication
+ */
+router.get('/:shareId', async (req, res) => {
+  const share = await getSharedMessages(req.params.shareId);
+
+  if (share) {
+    res.status(200).json(share);
+  } else {
+    res.status(404).end();
+  }
+});
+
+/**
+ * Shared links
+ */
+router.get('/', requireJwtAuth, async (req, res) => {
+  let pageNumber = req.query.pageNumber || 1;
+  pageNumber = parseInt(pageNumber, 10);
+
+  if (isNaN(pageNumber) || pageNumber < 1) {
+    return res.status(400).json({ error: 'Invalid page number' });
+  }
+
+  let pageSize = req.query.pageSize || 25;
+  pageSize = parseInt(pageSize, 10);
+
+  if (isNaN(pageSize) || pageSize < 1) {
+    return res.status(400).json({ error: 'Invalid page size' });
+  }
+  const isPublic = req.query.isPublic === 'true';
+  res.status(200).send(await getSharedLinks(req.user.id, pageNumber, pageSize, isPublic));
+});
+
+router.post('/', requireJwtAuth, async (req, res) => {
+  const created = await createSharedLink(req.user.id, req.body);
+  if (created) {
+    res.status(200).json(created);
+  } else {
+    res.status(404).end();
+  }
+});
+
+router.patch('/', requireJwtAuth, async (req, res) => {
+  const updated = await updateSharedLink(req.user.id, req.body);
+  if (updated) {
+    res.status(200).json(updated);
+  } else {
+    res.status(404).end();
+  }
+});
+
+router.delete('/:shareId', requireJwtAuth, async (req, res) => {
+  const deleted = await deleteSharedLink(req.user.id, { shareId: req.params.shareId });
+  if (deleted) {
+    res.status(200).json(deleted);
+  } else {
+    res.status(404).end();
+  }
+});
+
+module.exports = router;

client/src/components/Auth/BlinkAnimation.tsx

@@ -0,0 +1,29 @@
+export const BlinkAnimation = ({
+  active,
+  children,
+}: {
+  active: boolean;
+  children: React.ReactNode;
+}) => {
+  const style = `
+  @keyframes blink-animation {
+    0%,
+    100% {
+      opacity: 1;
+    }
+    50% {
+      opacity: 0;
+    }
+  }`;
+
+  if (!active) {
+    return <>{children}</>;
+  }
+
+  return (
+    <>
+      <style>{style}</style>
+      <div style={{ animation: 'blink-animation 3s infinite' }}>{children}</div>
+    </>
+  );
+};