@mongoosejs/studio 0.0.82 → 0.0.84

package/astra.js

@@ -0,0 +1,159 @@
+'use strict';
+
+const mongoose = require('mongoose');
+const { createAstraUri, driver, Vectorize } = require('@datastax/astra-mongoose');
+const express = require('express');
+const studio = require('./express');
+
+const app = express();
+
+const m = new mongoose.Mongoose();
+m.setDriver(driver);
+m.set('autoCreate', false);
+m.set('autoIndex', false);
+
+(function () {
+  const schema = new m.Schema({
+    email: {
+      type: String,
+      required: true,
+      unique: true
+    },
+    firstName: {
+      type: String,
+      required: true
+    },
+    lastName: {
+      type: String,
+      required: true
+    }
+  });
+
+  schema.virtual('displayName').get(function() {
+    return this.firstName + ' ' + this.lastName.slice(0, 1) + '.';
+  });
+
+  m.model('User', schema);
+})();
+
+(function () {
+  const schema = new m.Schema({
+    make: {
+      type: String,
+      required: true
+    },
+    model: {
+      type: String,
+      required: true
+    },
+    year: {
+      type: Number,
+      required: true,
+      validate: (v) => Number.isInteger(v) && v >= 1950
+    },
+    images: {
+      type: [String]
+    },
+    numReviews: {
+      type: Number,
+      required: true,
+      default: 0
+    },
+    averageReview: {
+      type: Number,
+      required: true,
+      default: 0
+    }
+  });
+
+  m.model('Vehicle', schema);
+})();
+
+(function () {
+  const schema = new m.Schema({
+    rating: {
+      type: Number,
+      required: true,
+      validate: (v) => Number.isInteger(v)
+    },
+    text: {
+      type: String,
+      required: true,
+      validate: (v) => v.length >= 30
+    },
+    userId: {
+      type: 'ObjectId',
+      required: true
+    },
+    vehicleId: {
+      type: 'ObjectId',
+      required: true
+    }
+  }, { timestamps: true });
+
+  schema.virtual('user', {
+    ref: 'User',
+    localField: 'userId',
+    foreignField: '_id',
+    justOne: true
+  });
+
+  schema.virtual('vehicle', {
+    ref: 'Vehicle',
+    localField: 'vehicleId',
+    foreignField: '_id',
+    justOne: true
+  });
+
+  schema.pre('save', async function updateVehicleRating() {
+    if (!this.isNew) {
+      return;
+    }
+    const vehicle = await mongoose.model('Vehicle').findById(this.vehicleId).orFail();
+    vehicle.numReviews += 1;
+    const vehicleReviews = await mongoose.model('Review').find({ vehicleId: this.vehicleId });
+    const reviewRatings = vehicleReviews.map((entry) => entry.rating);
+    reviewRatings.push(this.rating);
+    const average = calculateAverage(reviewRatings);
+    vehicle.averageReview = average;
+    await vehicle.save();
+  });
+
+  function calculateAverage(ratings) {
+    if (ratings.length === 0) {
+      return 0;
+    }
+    let sum = 0;
+    for (let i = 0; i < ratings.length; i++) {
+      sum += ratings[i];
+    }
+    const average = sum / ratings.length;
+    return average;
+  }
+
+  m.model('Review', schema);
+})();
+
+const uri = createAstraUri(
+  'https://fbced748-d6ed-40b1-ab9d-b618015a2c2c-us-east-2.apps.astra.datastax.com',
+  'AstraCS:kjSUArrrkLKrDlrMpUQOUYlw:50c9eda620df1099ad2dd77eb36e7755daaa48494acb158ff6de8df3deee40f6',
+  'reviews_dev2'
+);
+
+void async function main() {
+  await m.connect(uri);
+  const studioConnection = await mongoose.createConnection('mongodb://127.0.0.1:27017/mongoose_studio_test').asPromise();
+
+  app.use('/studio', await studio('/studio/api', m, { __build: true, apiKey: '123456789', studioConnection }));
+
+  await app.listen(7770);
+  console.log('Listening on port 7770');
+}();
+
+/*
+# Astra Notes
+
+1. Must use collections. Tables don't support `countDocuments()` or `estimatedDocumentCount()`.
+2. Annoying issue: collections don't let you store keys that start with '$'
+
+*/

package/backend/actions/ChatMessage/executeScript.js

@@ -16,9 +16,9 @@ const ExecuteScriptParams = new Archetype({
   }
 }).compile('ExecuteScriptParams');
 
-module.exports = ({ db }) => async function executeScript(params) {
+module.exports = ({ db, studioConnection }) => async function executeScript(params) {
   const { userId, chatMessageId, script } = new ExecuteScriptParams(params);
-  const ChatMessage = db.model('__Studio_ChatMessage');
+  const ChatMessage = studioConnection.model('__Studio_ChatMessage');
 
   const chatMessage = await ChatMessage.findById(chatMessageId);
   if (!chatMessage) {

package/backend/actions/ChatThread/createChatMessage.js

@@ -55,10 +55,10 @@ return { numUsers: users.length };
 Here is a description of the user's models. Assume these are the only models available in the system unless explicitly instructed otherwise by the user.
 `.trim();
 
-module.exports = ({ db }) => async function createChatMessage(params) {
+module.exports = ({ db, studioConnection }) => async function createChatMessage(params) {
   const { chatThreadId, userId, content, script, authorization } = new CreateChatMessageParams(params);
-  const ChatThread = db.model('__Studio_ChatThread');
-  const ChatMessage = db.model('__Studio_ChatMessage');
+  const ChatThread = studioConnection.model('__Studio_ChatThread');
+  const ChatMessage = studioConnection.model('__Studio_ChatMessage');
 
   // Check that the user owns the thread
   const chatThread = await ChatThread.findOne({ _id: chatThreadId });

package/backend/actions/ChatThread/createChatThread.js

@@ -9,9 +9,9 @@ const CreateChatThreadParams = new Archetype({
   }
 }).compile('CreateChatThreadParams');
 
-module.exports = ({ db }) => async function createChatThread(params) {
+module.exports = ({ studioConnection }) => async function createChatThread(params) {
   const { userId } = new CreateChatThreadParams(params);
-  const ChatThread = db.model('__Studio_ChatThread');
+  const ChatThread = studioConnection.model('__Studio_ChatThread');
 
   const chatThread = await ChatThread.create({ userId });
 

package/backend/actions/ChatThread/getChatThread.js

@@ -12,17 +12,17 @@ const GetChatThreadParams = new Archetype({
   }
 }).compile('GetChatThreadParams');
 
-module.exports = ({ db }) => async function getChatThread(params) {
+module.exports = ({ db, studioConnection }) => async function getChatThread(params) {
   const { chatThreadId, userId } = new GetChatThreadParams(params);
-  const ChatThread = db.model('__Studio_ChatThread');
-  const ChatMessage = db.model('__Studio_ChatMessage');
+  const ChatThread = studioConnection.model('__Studio_ChatThread');
+  const ChatMessage = studioConnection.model('__Studio_ChatMessage');
 
   const chatThread = await ChatThread.findById(chatThreadId);
 
   if (!chatThread) {
     throw new Error('Chat thread not found');
   }
-  if (userId && chatThread.userId.toString() !== userId.toString()) {
+  if (userId && chatThread.userId?.toString() !== userId.toString()) {
     throw new Error('Not authorized');
   }
 

package/backend/actions/ChatThread/listChatThreads.js

@@ -9,10 +9,10 @@ const ListChatThreadsParams = new Archetype({
   }
 }).compile('ListChatThreadsParams');
 
-module.exports = ({ db }) => async function listChatThreads(params) {
+module.exports = ({ db, studioConnection }) => async function listChatThreads(params) {
   // Just validate the params object, but no actual parameters needed
   const { userId } = new ListChatThreadsParams(params);
-  const ChatThread = db.model('__Studio_ChatThread');
+  const ChatThread = studioConnection.model('__Studio_ChatThread');
 
   // Get all chat threads
   const chatThreads = await ChatThread.find(userId ? { userId } : {})

package/backend/actions/Model/deleteDocuments.js

@@ -0,0 +1,38 @@
+'use strict';
+
+const Archetype = require('archetype');
+
+const DeleteDocumentsParams = new Archetype({
+  model: {
+    $type: 'string',
+    $required: true
+  },
+  documentIds: {
+    $type: 'string',
+    $required: true
+  },
+  roles: {
+    $type: ['string'],
+  }
+}).compile('DeleteDocumentsParams');
+
+module.exports = ({ db }) => async function DeleteDocuments(params) {
+  const { model, documentIds, roles } = new DeleteDocumentsParams(params);
+
+  const Model = db.models[model];
+
+  if (roles && roles.includes('readonly')) {
+    throw new Error('Not authorized');
+  }
+  if (Model == null) {
+    throw new Error(`Model ${model} not found`);
+  }
+
+  await Model.
+    deleteMany({_id: { $in: documentIds }}).
+    setOptions({ sanitizeFilter: true }).
+    orFail();
+   
+  
+  return { };
+};

package/backend/actions/Model/getDocuments.js

@@ -65,10 +65,10 @@ module.exports = ({ db }) => async function getDocuments(params) {
   const numDocuments = filter == null ?
     await Model.estimatedDocumentCount() :
     await Model.countDocuments(filter);
-  
+
   return {
     docs: docs.map(doc => doc.toJSON({ virtuals: false, getters: false, transform: false })),
     schemaPaths,
     numDocs: numDocuments
   };
-};
+};

package/backend/actions/Model/index.js

@@ -2,9 +2,11 @@
 
 exports.createDocument = require('./createDocument')
 exports.deleteDocument = require('./deleteDocument');
+exports.deleteDocuments = require('./deleteDocuments');
 exports.exportQueryResults = require('./exportQueryResults');
 exports.getDocument = require('./getDocument');
 exports.getDocuments = require('./getDocuments');
 exports.getIndexes = require('./getIndexes');
 exports.listModels = require('./listModels');
 exports.updateDocument = require('./updateDocument');
+exports.updateDocuments = require('./updateDocuments');

package/backend/actions/Model/updateDocuments.js

@@ -0,0 +1,46 @@
+'use strict';
+
+const Archetype = require('archetype');
+const mongoose = require('mongoose');
+
+const UpdateDocumentsParams = new Archetype({
+  model: {
+    $type: 'string',
+    $required: true
+  },
+  _id: {
+    $type: ['string'],
+    $required: true
+  },
+  update: {
+    $type: Object,
+    $required: true
+  },
+  roles: {
+    $type: ['string'],
+  }
+}).compile('UpdateDocumentsParams');
+
+module.exports = ({ db }) => async function updateDocuments(params) {
+  const { model, _id, update, roles } = new UpdateDocumentsParams(params);
+
+  if (roles && roles.includes('readonly')) {
+    throw new Error('Not authorized');
+  }
+  const Model = db.models[model];
+  if (Model == null) {
+    throw new Error(`Model ${model} not found`);
+  }
+
+  let processedUpdate = update;
+  if (Object.keys(update).length > 0) {
+    processedUpdate = Object.fromEntries(
+      Object.entries(update).map(([key, value]) => [key, value === 'null' ? null : value === 'undefined' ? undefined : value])
+    );
+  }
+
+  const result = await Model.
+    updateMany({ _id: { $in: _id } }, processedUpdate, { overwriteImmutable: true, runValidators: false });
+  
+  return { result };
+};

package/backend/index.js

@@ -8,15 +8,14 @@ const chatMessageSchema = require('./db/chatMessageSchema');
 const chatThreadSchema = require('./db/chatThreadSchema');
 const dashboardSchema = require('./db/dashboardSchema');
 
-const getModelDescriptions = require('./helpers/getModelDescriptions');
-
-module.exports = function backend(db) {
+module.exports = function backend(db, studioConnection) {
   db = db || mongoose.connection;
 
-  const Dashboard = db.model('__Studio_Dashboard', dashboardSchema, 'studio__dashboards');
-  const ChatMessage = db.model('__Studio_ChatMessage', chatMessageSchema, 'studio__chatMessages');
-  const ChatThread = db.model('__Studio_ChatThread', chatThreadSchema, 'studio__chatThreads');
+  studioConnection = studioConnection ?? db;
+  const Dashboard = studioConnection.model('__Studio_Dashboard', dashboardSchema, 'studio__dashboards');
+  const ChatMessage = studioConnection.model('__Studio_ChatMessage', chatMessageSchema, 'studio__chatMessages');
+  const ChatThread = studioConnection.model('__Studio_ChatThread', chatThreadSchema, 'studio__chatThreads');
 
-  const actions = applySpec(Actions, { db });
+  const actions = applySpec(Actions, { db, studioConnection });
   return actions;
 };

package/express.js

@@ -31,7 +31,7 @@ module.exports = async function(apiUrl, conn, options) {
   }
 
   apiUrl = apiUrl || 'api';
-  const backend = Backend(conn);
+  const backend = Backend(conn, options?.studioConnection);
 
   router.use(
     '/api',