@mongoosejs/studio 0.2.9 → 0.2.11

package/backend/actions/Model/executeDocumentScript.js

@@ -0,0 +1,61 @@
+'use strict';
+
+const Archetype = require('archetype');
+const authorize = require('../../authorize');
+const mongoose = require('mongoose');
+const util = require('util');
+const vm = require('vm');
+
+const ExecuteDocumentScriptParams = new Archetype({
+  model: {
+    $type: 'string',
+    $required: true
+  },
+  documentId: {
+    $type: 'string',
+    $required: true
+  },
+  script: {
+    $type: 'string',
+    $required: true
+  },
+  roles: {
+    $type: ['string']
+  }
+}).compile('ExecuteDocumentScriptParams');
+
+module.exports = ({ db }) => async function executeDocumentScript(params) {
+  const { model, documentId, script, roles } = new ExecuteDocumentScriptParams(params);
+
+  await authorize('Model.executeDocumentScript', roles);
+
+  const Model = db.models[model];
+  if (Model == null) {
+    throw new Error(`Model ${model} not found`);
+  }
+
+  const doc = await Model.findById(documentId).setOptions({ sanitizeFilter: true }).orFail();
+
+  const logs = [];
+  if (!db.Types) {
+    db.Types = mongoose.Types;
+  }
+  const sandbox = { db, mongoose, doc, console: {}, ObjectId: mongoose.Types.ObjectId };
+
+  sandbox.console.log = function() {
+    const args = Array.from(arguments);
+    logs.push(args.map(arg => typeof arg === 'object' ? util.inspect(arg) : arg).join(' '));
+  };
+
+  const context = vm.createContext(sandbox);
+  const result = await vm.runInContext(wrappedScript(script), context);
+
+  return {
+    result,
+    logs: logs.join('\n')
+  };
+};
+
+const wrappedScript = script => `(async () => {
+  ${script}
+})()`;

package/backend/actions/Model/index.js

@@ -6,6 +6,7 @@ exports.createDocument = require('./createDocument');
 exports.deleteDocument = require('./deleteDocument');
 exports.deleteDocuments = require('./deleteDocuments');
 exports.dropIndex = require('./dropIndex');
+exports.executeDocumentScript = require('./executeDocumentScript');
 exports.exportQueryResults = require('./exportQueryResults');
 exports.getDocument = require('./getDocument');
 exports.getDocuments = require('./getDocuments');
@@ -13,6 +14,7 @@ exports.getDocumentsStream = require('./getDocumentsStream');
 exports.getCollectionInfo = require('./getCollectionInfo');
 exports.getIndexes = require('./getIndexes');
 exports.listModels = require('./listModels');
+exports.streamDocumentChanges = require('./streamDocumentChanges');
 exports.streamChatMessage = require('./streamChatMessage');
 exports.updateDocument = require('./updateDocument');
 exports.updateDocuments = require('./updateDocuments');

package/backend/actions/Model/listModels.js

@@ -2,6 +2,8 @@
 
 const Archetype = require('archetype');
 const authorize = require('../../authorize');
+const getRefFromSchemaType = require('../../helpers/getRefFromSchemaType');
+const removeSpecifiedPaths = require('../../helpers/removeSpecifiedPaths');
 
 const ListModelsParams = new Archetype({
   roles: {
@@ -15,8 +17,41 @@ module.exports = ({ db }) => async function listModels(params) {
 
   const readyState = db.connection?.readyState ?? db.readyState;
 
+  const models = Object.keys(db.models).filter(key => !key.startsWith('__Studio_')).sort();
+
+  const modelSchemaPaths = {};
+  for (const modelName of models) {
+    const Model = db.models[modelName];
+    const schemaPaths = {};
+    modelSchemaPaths[modelName] = schemaPaths;
+    for (const path of Object.keys(Model.schema.paths)) {
+      const schemaType = Model.schema.paths[path];
+      schemaPaths[path] = {
+        instance: schemaType.instance,
+        path,
+        ref: getRefFromSchemaType(schemaType),
+        required: schemaType.options?.required,
+        enum: schemaType.options?.enum
+      };
+      if (schemaType.schema) {
+        schemaPaths[path].schema = {};
+        for (const subpath of Object.keys(schemaType.schema.paths)) {
+          schemaPaths[path].schema[subpath] = {
+            instance: schemaType.schema.paths[subpath].instance,
+            path: subpath,
+            ref: getRefFromSchemaType(schemaType.schema.paths[subpath]),
+            required: schemaType.schema.paths[subpath].options?.required,
+            enum: schemaType.schema.paths[subpath].options?.enum
+          };
+        }
+      }
+    }
+    removeSpecifiedPaths(schemaPaths, '.$*');
+  }
+
   return {
-    models: Object.keys(db.models).filter(key => !key.startsWith('__Studio_')).sort(),
+    models,
+    modelSchemaPaths,
     readyState
   };
 };

package/backend/actions/Model/streamDocumentChanges.js

@@ -0,0 +1,123 @@
+'use strict';
+
+const Archetype = require('archetype');
+const authorize = require('../../authorize');
+
+const StreamDocumentChangesParams = new Archetype({
+  model: {
+    $type: 'string',
+    $required: true
+  },
+  documentId: {
+    $type: 'string',
+    $required: true
+  },
+  roles: {
+    $type: ['string']
+  }
+}).compile('StreamDocumentChangesParams');
+
+module.exports = ({ db, changeStream }) => async function* streamDocumentChanges(params) {
+  const { model, documentId, roles } = new StreamDocumentChangesParams(params);
+
+  await authorize('Model.streamDocumentChanges', roles);
+
+  const Model = db.models[model];
+  if (Model == null) {
+    throw new Error(`Model ${model} not found`);
+  }
+
+  if (!changeStream) {
+    throw new Error('Change streams are not enabled');
+  }
+
+  const collectionName = Model.collection.name;
+  const targetId = String(documentId);
+
+  const queue = [];
+  let resolveQueue = null;
+  let streamError = null;
+  let streamEnded = false;
+
+  function enqueue(payload) {
+    queue.push(payload);
+    if (resolveQueue) {
+      const resolve = resolveQueue;
+      resolveQueue = null;
+      resolve();
+    }
+  }
+
+  function handleChange(change) {
+    if (!change || change.ns?.coll !== collectionName) {
+      return;
+    }
+    if (!change.documentKey || change.documentKey._id == null) {
+      return;
+    }
+    if (String(change.documentKey._id) !== targetId) {
+      return;
+    }
+
+    enqueue({
+      type: 'change',
+      operationType: change.operationType,
+      documentKey: change.documentKey,
+      ns: change.ns,
+      updateDescription: change.updateDescription,
+      clusterTime: change.clusterTime
+    });
+  }
+
+  function handleError(err) {
+    streamError = err || new Error('Change stream error');
+    enqueue({ type: 'error', message: streamError.message });
+  }
+
+  function handleEnd() {
+    streamEnded = true;
+    enqueue({ type: 'end' });
+  }
+
+  changeStream.on('change', handleChange);
+  changeStream.on('error', handleError);
+  changeStream.on('end', handleEnd);
+
+  try {
+    while (true) {
+      if (streamError) {
+        throw streamError;
+      }
+
+      if (queue.length === 0) {
+        await new Promise(resolve => {
+          resolveQueue = resolve;
+        });
+      }
+
+      if (streamError) {
+        throw streamError;
+      }
+
+      while (queue.length > 0) {
+        const payload = queue.shift();
+        if (payload?.type === 'end') {
+          return;
+        }
+        yield payload;
+      }
+
+      if (streamEnded) {
+        return;
+      }
+    }
+  } finally {
+    changeStream.off('change', handleChange);
+    changeStream.off('error', handleError);
+    changeStream.off('end', handleEnd);
+    if (resolveQueue) {
+      resolveQueue();
+      resolveQueue = null;
+    }
+  }
+};

package/backend/actions/Task/cancelTask.js

@@ -0,0 +1,24 @@
+'use strict';
+
+const Archetype = require('archetype');
+const mongoose = require('mongoose');
+
+const CancelTaskParams = new Archetype({
+  taskId: {
+    $type: mongoose.Types.ObjectId,
+    $required: true
+  }
+}).compile('CancelTaskParams');
+
+module.exports = ({ db }) => async function cancelTask(params) {
+  params = new CancelTaskParams(params);
+  const { taskId } = params;
+  const { Task } = db.models;
+
+  const task = await Task.findOne({ _id: taskId }).orFail();
+
+  const cancelledTask = await Task.cancelTask({ _id: taskId });
+  return {
+    task: cancelledTask
+  };
+};

package/backend/actions/Task/createTask.js

@@ -0,0 +1,33 @@
+'use strict';
+
+const Archetype = require('archetype');
+
+const CreateTaskParams = new Archetype({
+  name: {
+    $type: 'string',
+    $required: true
+  },
+  scheduledAt: {
+    $type: Date,
+    $required: true
+  },
+  repeatAfterMS: {
+    $type: 'number'
+  },
+  payload: {
+    $type: Archetype.Any
+  }
+}).compile('CreateTaskParams');
+
+module.exports = ({ db }) => async function createTask(params) {
+  params = new CreateTaskParams(params);
+ 
+  const { name, scheduledAt, payload, repeatAfterMS } = params;
+  const { Task } = db.models;
+
+  const task = await Task.schedule(name, scheduledAt, payload, repeatAfterMS);
+ 
+  return {
+    task
+  };
+};

package/backend/actions/Task/getTasks.js

@@ -0,0 +1,62 @@
+'use strict';
+
+const Archetype = require('archetype');
+
+const GetTasksParams = new Archetype({
+  start: {
+    $type: Date
+  },
+  end: {
+    $type: Date
+  },
+  status: {
+    $type: 'string'
+  },
+  name: {
+    $type: 'string'
+  }
+}).compile('GetTasksParams');
+
+module.exports = ({ db }) => async function getTasks(params) {
+  params = new GetTasksParams(params);
+  const { start, end, status, name } = params;
+  const { Task } = db.models;
+
+  const filter = {};
+
+  if (start && end) {
+    filter.scheduledAt = { $gte: start, $lt: end };
+  } else if (start) {
+    filter.scheduledAt = { $gte: start };
+  }
+  if (status) {
+    filter.status = status;
+  }
+  if (name) {
+    filter.name = { $regex: name, $options: 'i' };
+  }
+
+  const tasks = await Task.find(filter);
+  
+  // Define all possible statuses
+  const allStatuses = ['pending', 'in_progress', 'succeeded', 'failed', 'cancelled', 'unknown'];
+  
+  // Initialize groupedTasks with all statuses
+  const groupedTasks = allStatuses.reduce((groups, status) => {
+    groups[status] = [];
+    return groups;
+  }, {});
+  
+  // Group tasks by status
+  tasks.forEach(task => {
+    const taskStatus = task.status || 'unknown';
+    if (groupedTasks.hasOwnProperty(taskStatus)) {
+      groupedTasks[taskStatus].push(task);
+    }
+  });
+ 
+  return {
+    tasks,
+    groupedTasks
+  };
+};

package/backend/actions/Task/index.js

@@ -0,0 +1,7 @@
+'use strict';
+
+exports.cancelTask = require('./cancelTask');
+exports.createTask = require('./createTask');
+exports.getTasks = require('./getTasks');
+exports.rescheduleTask = require('./rescheduleTask');
+exports.runTask = require('./runTask');

package/backend/actions/Task/rescheduleTask.js

@@ -0,0 +1,39 @@
+'use strict';
+
+const Archetype = require('archetype');
+const mongoose = require('mongoose');
+
+const RescheduleTaskParams = new Archetype({
+  taskId: {
+    $type: mongoose.Types.ObjectId,
+    $required: true
+  },
+  scheduledAt: {
+    $type: Date,
+    $required: true
+  }
+}).compile('RescheduleTaskParams');
+
+module.exports = ({ db }) => async function rescheduleTask(params) {
+  params = new RescheduleTaskParams(params);
+  const { taskId, scheduledAt } = params;
+  const { Task } = db.models;
+
+  const task = await Task.findOne({ _id: taskId }).orFail();
+
+  if (scheduledAt < Date.now()) {
+    throw new Error('Cannot reschedule a task for the past');
+  }
+
+  if (task.status != 'pending') {
+    throw new Error('Cannot reschedule a task that is not pending');
+  }
+
+  task.scheduledAt = scheduledAt;
+
+  await task.save();
+ 
+  return {
+    task
+  };
+};

package/backend/actions/Task/runTask.js

@@ -0,0 +1,25 @@
+'use strict';
+
+const Archetype = require('archetype');
+const mongoose = require('mongoose');
+
+const RunTaskParams = new Archetype({
+  taskId: {
+    $type: mongoose.Types.ObjectId,
+    $required: true
+  }
+}).compile('RunTaskParams');
+
+module.exports = ({ db }) => async function runTask(params) {
+  params = new RunTaskParams(params);
+  const { taskId } = params;
+  const { Task } = db.models;
+
+  const task = await Task.findOne({ _id: taskId }).orFail();
+
+  const executedTask = await Task.execute(task);
+ 
+  return {
+    task: executedTask
+  };
+};

package/backend/actions/index.js

@@ -6,3 +6,4 @@ exports.Dashboard = require('./Dashboard');
 exports.Model = require('./Model');
 exports.Script = require('./Script');
 exports.status = require('./status');
+exports.Task = require('./Task');

package/backend/authorize.js

@@ -17,12 +17,14 @@ const actionsToRequiredRoles = {
   'Model.deleteDocument': ['owner', 'admin', 'member'],
   'Model.deleteDocuments': ['owner', 'admin', 'member'],
   'Model.dropIndex': ['owner', 'admin'],
+  'Model.executeDocumentScript': ['owner', 'admin', 'member'],
   'Model.exportQueryResults': ['owner', 'admin', 'member', 'readonly'],
   'Model.getDocument': ['owner', 'admin', 'member', 'readonly'],
   'Model.getDocuments': ['owner', 'admin', 'member', 'readonly'],
   'Model.getDocumentsStream': ['owner', 'admin', 'member', 'readonly'],
   'Model.getIndexes': ['owner', 'admin', 'member', 'readonly'],
   'Model.listModels': ['owner', 'admin', 'member', 'readonly'],
+  'Model.streamDocumentChanges': ['owner', 'admin', 'member', 'readonly'],
   'Model.streamChatMessage': ['owner', 'admin', 'member', 'readonly'],
   'Model.updateDocuments': ['owner', 'admin', 'member']
 };

package/backend/index.js

@@ -16,6 +16,12 @@ module.exports = function backend(db, studioConnection, options) {
   const ChatMessage = studioConnection.model('__Studio_ChatMessage', chatMessageSchema, 'studio__chatMessages');
   const ChatThread = studioConnection.model('__Studio_ChatThread', chatThreadSchema, 'studio__chatThreads');
 
-  const actions = applySpec(Actions, { db, studioConnection, options });
+  let changeStream = null;
+  if (options?.changeStream) {
+    changeStream = db.watch();
+  }
+
+  const actions = applySpec(Actions, { db, studioConnection, options, changeStream });
+  actions.services = { changeStream };
   return actions;
 };

package/eslint.config.js

@@ -37,9 +37,12 @@ module.exports = defineConfig([
         fetch: true,
         __dirname: true,
         process: true,
+        clearTimeout: true,
         setTimeout: true,
         navigator: true,
-        TextDecoder: true
+        TextDecoder: true,
+        AbortController: true,
+        clearTimeout: true
       },
       sourceType: 'commonjs'
     },

package/express.js

@@ -7,8 +7,9 @@ const { toRoute, objectRouter } = require('extrovert');
 
 module.exports = async function mongooseStudioExpressApp(apiUrl, conn, options) {
   const router = express.Router();
+  options = options ? { changeStream: true, ...options } : { changeStream: true };
 
-  const mothershipUrl = options?._mothershipUrl || 'https://mongoose-js.netlify.app/.netlify/functions';
+  const mothershipUrl = options._mothershipUrl || 'https://mongoose-js.netlify.app/.netlify/functions';
   let workspace = null;
   if (options?.apiKey) {
     ({ workspace } = await fetch(`${mothershipUrl}/getWorkspace`, {
@@ -31,7 +32,7 @@ module.exports = async function mongooseStudioExpressApp(apiUrl, conn, options)
   }
 
   apiUrl = apiUrl || 'api';
-  const backend = Backend(conn, options?.studioConnection, options);
+  const backend = Backend(conn, options.studioConnection, options);
 
   router.use(
     '/api',
@@ -80,6 +81,7 @@ module.exports = async function mongooseStudioExpressApp(apiUrl, conn, options)
   );
 
   const { config } = await frontend(apiUrl, false, options, workspace);
+  config.enableTaskVisualizer = options.enableTaskVisualizer;
   router.get('/config.js', function (req, res) {
     res.setHeader('Content-Type', 'application/javascript');
     res.end(`window.MONGOOSE_STUDIO_CONFIG = ${JSON.stringify(config, null, 2)};`);