reorganize dirs for dockerize

api/models/Conversation.js

@@ -0,0 +1,95 @@
+const mongoose = require('mongoose');
+const { getMessages, deleteMessages } = require('./Message');
+
+const convoSchema = mongoose.Schema({
+  conversationId: {
+    type: String,
+    unique: true,
+    required: true
+  },
+  parentMessageId: {
+    type: String,
+    required: true
+  },
+  title: {
+    type: String,
+    default: 'New conversation'
+  },
+  conversationSignature: {
+    type: String
+  },
+  clientId: {
+    type: String
+  },
+  invocationId: {
+    type: String
+  },
+  chatGptLabel: {
+    type: String
+  },
+  promptPrefix: {
+    type: String
+  },
+  model: {
+    type: String
+  },
+  suggestions: [{ type: String }],
+  messages: [{ type: mongoose.Schema.Types.ObjectId, ref: 'Message' }],
+  created: {
+    type: Date,
+    default: Date.now
+  }
+});
+
+const Conversation =
+  mongoose.models.Conversation || mongoose.model('Conversation', convoSchema);
+
+module.exports = {
+  saveConvo: async ({ conversationId, title, ...convo }) => {
+    try {
+      const messages = await getMessages({ conversationId });
+      const update = { ...convo, messages };
+      if (title) {
+        update.title = title;
+      }
+
+      return await Conversation.findOneAndUpdate(
+        { conversationId },
+        { $set: update },
+        { new: true, upsert: true }
+      ).exec();
+    } catch (error) {
+      console.log(error);
+      return { message: 'Error saving conversation' };
+    }
+  },
+  updateConvo: async ({ conversationId, ...update }) => {
+    try {
+      return await Conversation.findOneAndUpdate({ conversationId }, update, {
+        new: true
+      }).exec();
+    } catch (error) {
+      console.log(error);
+      return { message: 'Error updating conversation' };
+    }
+  },
+  // getConvos: async () => await Conversation.find({}).sort({ created: -1 }).exec(),
+  getConvos: async (pageNumber = 1, pageSize = 12) => {
+    const skip = (pageNumber - 1) * pageSize;
+    // const limit = pageNumber * pageSize;
+
+    const conversations = await Conversation.find({})
+      .sort({ created: -1 })
+      .skip(skip)
+      // .limit(limit)
+      .limit(pageSize)
+      .exec();
+
+    return conversations;
+  },
+  deleteConvos: async (filter) => {
+    let deleteCount = await Conversation.deleteMany(filter).exec();
+    deleteCount.messages = await deleteMessages(filter);
+    return deleteCount;
+  }
+};

api/models/CustomGpt.js

@@ -0,0 +1,73 @@
+const mongoose = require('mongoose');
+
+const customGptSchema = mongoose.Schema({
+  chatGptLabel: {
+    type: String,
+    required: true
+  },
+  promptPrefix: {
+    type: String
+  },
+  value: {
+    type: String,
+    required: true
+  },
+  created: {
+    type: Date,
+    default: Date.now
+  }
+});
+
+const CustomGpt = mongoose.models.CustomGpt || mongoose.model('CustomGpt', customGptSchema);
+
+const createCustomGpt = async ({ chatGptLabel, promptPrefix, value }) => {
+  try {
+    await CustomGpt.create({
+      chatGptLabel,
+      promptPrefix,
+      value
+    });
+    return { chatGptLabel, promptPrefix, value };
+  } catch (error) {
+    console.error(error);
+    return { customGpt: 'Error saving customGpt' };
+  }
+};
+
+module.exports = {
+  getCustomGpts: async (filter) => {
+    try {
+      return await CustomGpt.find(filter).exec();
+    } catch (error) {
+      console.error(error);
+      return { customGpt: 'Error getting customGpts' };
+    }
+  },
+  updateCustomGpt: async ({ value, ...update }) => {
+    try {
+      console.log('updateCustomGpt', value, update);
+
+      const customGpt = await CustomGpt.findOne({ value }).exec();
+
+      if (!customGpt) {
+        return await createCustomGpt({ value, ...update });
+      } else {
+        return await CustomGpt.findOneAndUpdate({ value }, update, {
+          new: true,
+          upsert: true
+        }).exec();
+      }
+    } catch (error) {
+      console.log(error);
+      return { message: 'Error updating customGpt' };
+    }
+  },
+  deleteCustomGpts: async (filter) => {
+    try {
+      return await CustomGpt.deleteMany(filter).exec();
+    } catch (error) {
+      console.error(error);
+      return { customGpt: 'Error deleting customGpts' };
+    }
+  }
+};

api/models/Message.js

@@ -0,0 +1,75 @@
+const mongoose = require('mongoose');
+
+const messageSchema = mongoose.Schema({
+  id: {
+    type: String,
+    unique: true,
+    required: true
+  },
+  conversationId: {
+    type: String,
+    required: true
+  },
+  conversationSignature: {
+    type: String,
+    // required: true
+  },
+  clientId: {
+    type: String,
+  },
+  invocationId: {
+    type: String,
+  },
+  parentMessageId: {
+    type: String,
+    // required: true
+  },
+  sender: {
+    type: String,
+    required: true
+  },
+  text: {
+    type: String,
+    required: true
+  },
+  created: {
+    type: Date,
+    default: Date.now
+  }
+});
+
+const Message = mongoose.models.Message || mongoose.model('Message', messageSchema);
+
+module.exports = {
+  saveMessage: async ({ id, conversationId, parentMessageId, sender, text }) => {
+    try {
+      await Message.create({
+        id,
+        conversationId,
+        parentMessageId,
+        sender,
+        text
+      });
+      return { id, conversationId, parentMessageId, sender, text };
+    } catch (error) {
+      console.error(error);
+      return { message: 'Error saving message' };
+    }
+  },
+  getMessages: async (filter) => {
+    try {
+      return await Message.find(filter).exec()
+    } catch (error) {
+      console.error(error);
+      return { message: 'Error getting messages' };
+    }
+  },
+  deleteMessages: async (filter) => {
+    try {
+      return await Message.deleteMany(filter).exec()
+    } catch (error) {
+      console.error(error);
+      return { message: 'Error deleting messages' };
+    }
+  }
+}

api/models/Prompt.js

@@ -0,0 +1,52 @@
+const mongoose = require('mongoose');
+
+const promptSchema = mongoose.Schema({
+  title: {
+    type: String,
+    required: true
+  },
+  prompt: {
+    type: String,
+    required: true
+  },
+  category: {
+    type: String,
+  },
+  created: {
+    type: Date,
+    default: Date.now
+  }
+});
+
+const Prompt = mongoose.models.Prompt || mongoose.model('Prompt', promptSchema);
+
+module.exports = {
+  savePrompt: async ({ title, prompt }) => {
+    try {
+      await Prompt.create({
+        title,
+        prompt
+      });
+      return { title, prompt };
+    } catch (error) {
+      console.error(error);
+      return { prompt: 'Error saving prompt' };
+    }
+  },
+  getPrompts: async (filter) => {
+    try {
+      return await Prompt.find(filter).exec()
+    } catch (error) {
+      console.error(error);
+      return { prompt: 'Error getting prompts' };
+    }
+  },
+  deletePrompts: async (filter) => {
+    try {
+      return await Prompt.deleteMany(filter).exec()
+    } catch (error) {
+      console.error(error);
+      return { prompt: 'Error deleting prompts' };
+    }
+  }
+}

api/models/dbConnect.js

@@ -0,0 +1,44 @@
+require('dotenv').config();
+const mongoose = require('mongoose');
+const MONGO_URI = process.env.MONGO_URI;
+
+if (!MONGO_URI) {
+  throw new Error('Please define the MONGO_URI environment variable inside .env.local');
+}
+
+/**
+ * Global is used here to maintain a cached connection across hot reloads
+ * in development. This prevents connections growing exponentially
+ * during API Route usage.
+ */
+let cached = global.mongoose;
+
+if (!cached) {
+  cached = global.mongoose = { conn: null, promise: null };
+}
+
+async function dbConnect() {
+  if (cached.conn) {
+    return cached.conn;
+  }
+
+  if (!cached.promise) {
+    const opts = {
+      useNewUrlParser: true,
+      useUnifiedTopology: true,
+      bufferCommands: false
+      // bufferMaxEntries: 0,
+      // useFindAndModify: true,
+      // useCreateIndex: true
+    };
+
+    mongoose.set('strictQuery', true);
+    cached.promise = mongoose.connect(MONGO_URI, opts).then((mongoose) => {
+      return mongoose;
+    });
+  }
+  cached.conn = await cached.promise;
+  return cached.conn;
+}
+
+module.exports = dbConnect;

api/models/index.js

@@ -0,0 +1,12 @@
+const { saveMessage, deleteMessages } = require('./Message');
+const { getCustomGpts, updateCustomGpt, deleteCustomGpts } = require('./CustomGpt');
+const { saveConvo } = require('./Conversation');
+
+module.exports = {
+  saveMessage,
+  deleteMessages,
+  saveConvo,
+  getCustomGpts,
+  updateCustomGpt,
+  deleteCustomGpts
+};