@mongoosejs/studio 0.2.10 → 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');

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,6 +17,7 @@ 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'],

package/eslint.config.js

@@ -37,6 +37,7 @@ module.exports = defineConfig([
         fetch: true,
         __dirname: true,
         process: true,
+        clearTimeout: true,
         setTimeout: true,
         navigator: true,
         TextDecoder: true,

package/express.js

@@ -81,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)};`);