@mongoosejs/studio 0.5.13 → 0.6.0

package/AGENTS.md

@@ -0,0 +1,74 @@
+# Repository guidance
+
+The project's name is Mongoose Studio. Do not refer to the project as "Studio" - the repository is named "studio" to maintain parity between the npm package name `@mongoosejs/studio` and the GitHub repository `mongoosejs/studio`.
+
+The Mongoose connection passed to Mongoose Studio is owned by the host application.
+Do not change connection-level settings, options, configuration, models, middleware, plugins, collection objects, or methods on the application connection to implement Studio behavior.
+Apply Mongoose-Studio-specific behavior to individual operations whenever possible.
+When isolation requires a derived connection, copy any Mongoose state that `useDb()` shares with its source before changing the derived connection.
+Sandbox wrappers must remain confined to sandbox-owned models and collections.
+
+# Frontend Guidelines
+
+Conceptually, the frontend's job is to render the data and provide a user interface for accessing API calls.
+The frontend should minimize transformations and renaming of data provided by the backend: default to displaying the raw data as-is.
+
+## API Client
+
+`src/client/api.js` exposes one wrapper function per backend action; every wrapper POSTs to `${baseUrl}/<endpoint>` and resolves with the response payload directly (`res.data`), not the axios response. The endpoint list lives in `src/endpoints.js`, which `build.js` generates from the files in `backend/actions/` — do not edit it by hand. Flat action files become flat wrappers like `api.addToCart`, while capitalized `Model/action.js` directories become namespaced wrappers like `api.quote.createQuote`, so adding an action file automatically makes its wrapper available on the next build.
+
+## Vue User Input
+
+Prefer explicit DOM event handlers such as `@change`, `@input`, and `@update:modelValue` over `watch` for reacting to user input. Use `watch` only when the behavior is truly derived from state changes that do not have a single clear DOM event source.
+
+## Vue Templates
+
+Prefer safe property access directly in HTML over computed properties or methods for simple display values. For example, use `{{ user?.name ?? '-' }}` instead of creating a `userName` computed property. Keep display behavior local unless the logic is reused or too complex to read inline.
+
+Prefer using mustache interpolation (`{{ expr }}`) over `v-text` for rendering text values in Vue templates.
+
+## Component API Ownership
+
+Components that present an async action must own the API request for that action. Do not emit an event to a parent solely so the parent can make the HTTP request. Emit events after the component finishes the request when the parent needs to close a modal, refresh a list, or update surrounding state.
+
+## Async Buttons
+
+For a button that triggers an async action, use the `<async-button>` component instead of tracking a `saveStatus`/`loading` flag by hand. It manages the in-progress state, disables itself while running, and shows a spinner. Do not add a component-level status property, a `try/finally` to reset it, or `.finally()` on the API call just to toggle a button label.
+
+```html
+<!-- ❌ Incorrect: hand-rolled status + disabled + label swap -->
+<button :disabled="saveStatus === 'saving'" @click="save">
+  <span v-if="saveStatus === 'saving'">Saving...</span>
+  <span v-else>Save</span>
+</button>
+
+<!-- ✅ Correct -->
+<async-button @click="save">Save</async-button>
+```
+
+The click handler is just an `async` method that does the work; let errors propagate to the global handler. Keep any real `:disabled` condition (e.g. invalid input) — `async-button` ORs it with its own in-progress state.
+
+## Avoid trivial helpers
+
+Minimize scattered helpers on the frontend - functions and computed properties carry real cognitive overhead and need to earn their existence.
+Optimize for locality and terseness over abstraction.
+
+For example, instead of:
+
+```
+computed: {
+  displayName() {
+    return `${user.firstName} ${user.lastName}`;
+  }
+}
+```
+
+and:
+
+<div>{{ displayName }}</div>
+
+Write:
+
+<div>{{ user.firstName }} {{ user.lastName }}</div>
+
+No single-expression helper functions or computed properties unless there's heavy repetition (25+ instances).

package/README.md

@@ -39,6 +39,10 @@ opts.model = 'gpt-4o-mini';
 opts.openAIAPIKey = process.env.OPENAI_API_KEY;
 opts.anthropicAPIKey = process.env.ANTHROPIC_API_KEY;
 opts.googleGeminiAPIKey = process.env.GOOGLE_GEMINI_API_KEY;
+// Apply a maximum execution time to all read operations, including reads in scripts.
+// MongoDB does not support maxTimeMS for inserts and index operations.
+// This is also a ceiling: a request may ask for a lower limit, never a higher one.
+opts.maxTimeMS = 10000;
 
 // Mount Mongoose Studio on '/studio'
 app.use('/studio', await studio('/studio/api', mongoose, opts));
@@ -52,6 +56,29 @@ app.use('/studio', await studio('/studio/api', mongoose, {
 }));
 ```
 
+The Express integration also exposes a Streamable HTTP MCP endpoint at `/studio/mcp`.
+Set `mcp: false` to turn it off, along with the OAuth protected resource metadata that advertises it.
+It provides authorized Dashboard and Model actions, plus `Script.createScript`, as MCP tools.
+With a Pro API key, pass the logged-in Studio access token in the `Authorization` header (either directly or as a bearer token); tools receive that user's roles and permissions.
+Without workspace authentication, the MCP endpoint uses the same localhost and `bindIp` restrictions as the rest of Studio.
+
+#### Connecting ChatGPT or Claude with OAuth
+
+With a Pro API key, `/studio/mcp` is also an OAuth 2.1 protected resource, so MCP clients such as ChatGPT and Claude can connect to it directly.
+Point the client at your `/studio/mcp` URL and it will discover the Mongoose Studio authorization server, walk the user through signing in and approving access, and receive a short-lived access token.
+Users review and revoke these connections from their Mongoose Studio account page, and the access an AI client gets can never exceed the access the user who approved it already has.
+
+Mongoose Studio advertises itself to MCP clients using its externally reachable URL.
+When MCP and a Pro API key are enabled, set `publicUrl` to the URL where Mongoose Studio is mounted:
+
+```javascript
+opts.publicUrl = 'https://app.example.com/studio';
+```
+
+Mongoose Studio finds the authorization server through the mothership it is already configured to use, so it needs no separate authorization server configuration.
+
+See `docs/mcp-oauth.md` for how the flow and the delegated access policy work.
+
 ### Next.js
 
 First, add `withMongooseStudio` to your `next.config.js` file:

package/backend/actions/ChatMessage/executeScript.js

@@ -4,6 +4,8 @@ const Archetype = require('archetype');
 const authorize = require('../../authorize');
 const createSandbox = require('../../sandbox/createSandbox');
 const mongoose = require('mongoose');
+const readOperationOptions = require('../../helpers/readOperationOptions');
+const operationOptions = require('../../helpers/operationOptions');
 
 const ExecuteScriptParams = new Archetype({
   initiatedById: {
@@ -21,27 +23,35 @@ const ExecuteScriptParams = new Archetype({
   },
   roles: {
     $type: ['string']
+  },
+  maxTimeMS: {
+    $type: 'number'
+  },
+  readPreference: {
+    $type: 'string',
+    $enum: ['secondary', 'secondaryPreferred', 'primary']
   }
 }).compile('ExecuteScriptParams');
 
-module.exports = ({ db, studioConnection }) => async function executeScript(params) {
+module.exports = ({ db, studioConnection, options }) => async function executeScript(params) {
   const { initiatedById, chatMessageId, script, dryRun, roles } = new ExecuteScriptParams(params);
   const ChatThread = studioConnection.model('__Studio_ChatThread');
   const ChatMessage = studioConnection.model('__Studio_ChatMessage');
 
   await authorize('ChatMessage.executeScript', roles);
 
-  const chatMessage = await ChatMessage.findById(chatMessageId);
+  const dbOptions = operationOptions(options, params);
+  const chatMessage = await ChatMessage.findById(chatMessageId).setOptions(dbOptions);
   if (!chatMessage) {
     throw new Error('Chat message not found');
   }
-  const chatThread = await ChatThread.findById(chatMessage.chatThreadId).orFail();
+  const chatThread = await ChatThread.findById(chatMessage.chatThreadId).setOptions(dbOptions).orFail();
 
   if (initiatedById && chatThread.userId?.toString() !== initiatedById.toString()) {
     throw new Error('Unauthorized');
   }
 
-  const sandbox = createSandbox({ db });
+  const sandbox = createSandbox(db, { ...readOperationOptions(options, params) });
 
   let output;
   let error;
@@ -74,7 +84,7 @@ module.exports = ({ db, studioConnection }) => async function executeScript(para
           dryRun: !!dryRun
         }
       }
-    );
+    ).setOptions(operationOptions(options, params));
 
     throw new Error(`Script execution failed: ${error}`);
   } finally {

package/backend/actions/ChatThread/createChatMessage.js

@@ -8,6 +8,7 @@ const callLLM = require('../../integrations/callLLM');
 const getAgentTools = require('../../chatAgent/getAgentTools');
 const getModelDescriptions = require('../../helpers/getModelDescriptions');
 const mongoose = require('mongoose');
+const operationOptions = require('../../helpers/operationOptions');
 
 const CreateChatMessageParams = new Archetype({
   chatThreadId: {
@@ -25,6 +26,9 @@ const CreateChatMessageParams = new Archetype({
   },
   roles: {
     $type: ['string']
+  },
+  maxTimeMS: {
+    $type: 'number'
   }
 }).compile('CreateChatMessageParams');
 
@@ -36,7 +40,8 @@ module.exports = ({ db, studioConnection, options }) => async function createCha
   await authorize('ChatThread.createChatMessage', roles);
 
   // Check that the user owns the thread
-  const chatThread = await ChatThread.findOne({ _id: chatThreadId });
+  const dbOptions = operationOptions(options, params);
+  const chatThread = await ChatThread.findOne({ _id: chatThreadId }).setOptions(dbOptions);
   if (!chatThread) {
     throw new Error('Chat thread not found');
   }
@@ -44,7 +49,7 @@ module.exports = ({ db, studioConnection, options }) => async function createCha
     throw new Error('Not authorized');
   }
 
-  const messages = await ChatMessage.find({ chatThreadId }).sort({ createdAt: 1 });
+  const messages = await ChatMessage.find({ chatThreadId }).setOptions(dbOptions).sort({ createdAt: 1 });
   const llmMessages = messages.map(m => ({
     role: m.role,
     content: [{

package/backend/actions/ChatThread/getChatThread.js

@@ -3,6 +3,7 @@
 const Archetype = require('archetype');
 const authorize = require('../../authorize');
 const mongoose = require('mongoose');
+const operationOptions = require('../../helpers/operationOptions');
 
 const GetChatThreadParams = new Archetype({
   chatThreadId: {
@@ -16,17 +17,21 @@ const GetChatThreadParams = new Archetype({
   },
   $workspaceId: {
     $type: mongoose.Types.ObjectId
+  },
+  maxTimeMS: {
+    $type: 'number'
   }
 }).compile('GetChatThreadParams');
 
-module.exports = ({ db, studioConnection }) => async function getChatThread(params) {
+module.exports = ({ db, studioConnection, options }) => async function getChatThread(params) {
   const { chatThreadId, initiatedById, roles, $workspaceId } = new GetChatThreadParams(params);
   const ChatThread = studioConnection.model('__Studio_ChatThread');
   const ChatMessage = studioConnection.model('__Studio_ChatMessage');
 
   await authorize('ChatThread.getChatThread', roles);
 
-  const chatThread = await ChatThread.findById(chatThreadId);
+  const dbOptions = operationOptions(options, params);
+  const chatThread = await ChatThread.findById(chatThreadId).setOptions(dbOptions);
 
   if (!chatThread) {
     throw new Error('Chat thread not found');
@@ -39,6 +44,7 @@ module.exports = ({ db, studioConnection }) => async function getChatThread(para
   }
 
   const chatMessages = await ChatMessage.find({ chatThreadId })
+    .setOptions(dbOptions)
     .sort({ createdAt: -1 });
 
   return {

package/backend/actions/ChatThread/listChatThreads.js

@@ -3,6 +3,7 @@
 const Archetype = require('archetype');
 const authorize = require('../../authorize');
 const mongoose = require('mongoose');
+const operationOptions = require('../../helpers/operationOptions');
 
 const ListChatThreadsParams = new Archetype({
   initiatedById: {
@@ -10,10 +11,13 @@ const ListChatThreadsParams = new Archetype({
   },
   roles: {
     $type: ['string']
+  },
+  maxTimeMS: {
+    $type: 'number'
   }
 }).compile('ListChatThreadsParams');
 
-module.exports = ({ db, studioConnection }) => async function listChatThreads(params) {
+module.exports = ({ db, studioConnection, options }) => async function listChatThreads(params) {
   // Validate the params object
   const { initiatedById, roles } = new ListChatThreadsParams(params);
   const ChatThread = studioConnection.model('__Studio_ChatThread');
@@ -24,6 +28,7 @@ module.exports = ({ db, studioConnection }) => async function listChatThreads(pa
 
   // Get all chat threads
   const chatThreads = await ChatThread.find(query)
+    .setOptions(operationOptions(options, params))
     .sort({ updatedAt: -1 }); // Sort by most recently updated
 
   return {

package/backend/actions/ChatThread/shareChatThread.js

@@ -3,6 +3,7 @@
 const Archetype = require('archetype');
 const authorize = require('../../authorize');
 const mongoose = require('mongoose');
+const operationOptions = require('../../helpers/operationOptions');
 
 const ShareChatThreadParams = new Archetype({
   chatThreadId: {
@@ -19,16 +20,21 @@ const ShareChatThreadParams = new Archetype({
   },
   $workspaceId: {
     $type: mongoose.Types.ObjectId
+  },
+  maxTimeMS: {
+    $type: 'number'
   }
 }).compile('ShareChatThreadParams');
 
-module.exports = ({ studioConnection }) => async function shareChatThread(params) {
+module.exports = ({ studioConnection, options }) => async function shareChatThread(params) {
   const { chatThreadId, share, initiatedById, roles, $workspaceId } = new ShareChatThreadParams(params);
   const ChatThread = studioConnection.model('__Studio_ChatThread');
 
   await authorize('ChatThread.shareChatThread', roles);
 
-  const chatThread = await ChatThread.findById(chatThreadId).orFail();
+  const chatThread = await ChatThread.findById(chatThreadId).
+    setOptions(operationOptions(options, params)).
+    orFail();
   if (initiatedById != null && chatThread.userId?.toString() !== initiatedById.toString()) {
     throw new Error('Not authorized');
   }

package/backend/actions/ChatThread/streamChatMessage.js

@@ -8,6 +8,7 @@ const runChatAgent = require('../../chatAgent/runChatAgent');
 const streamLLM = require('../../integrations/streamLLM');
 const getModelDescriptions = require('../../helpers/getModelDescriptions');
 const mongoose = require('mongoose');
+const operationOptions = require('../../helpers/operationOptions');
 
 const CreateChatMessageParams = new Archetype({
   chatThreadId: {
@@ -25,6 +26,9 @@ const CreateChatMessageParams = new Archetype({
   },
   roles: {
     $type: ['string']
+  },
+  maxTimeMS: {
+    $type: 'number'
   }
 }).compile('CreateChatMessageParams');
 
@@ -36,7 +40,8 @@ module.exports = ({ db, studioConnection, options }) => async function* streamCh
   await authorize('ChatThread.createChatMessage', roles);
 
   // Check that the user owns the thread
-  const chatThread = await ChatThread.findOne({ _id: chatThreadId });
+  const dbOptions = operationOptions(options, params);
+  const chatThread = await ChatThread.findOne({ _id: chatThreadId }).setOptions(dbOptions);
   if (!chatThread) {
     throw new Error('Chat thread not found');
   }
@@ -44,7 +49,7 @@ module.exports = ({ db, studioConnection, options }) => async function* streamCh
     throw new Error('Not authorized');
   }
 
-  const messages = await ChatMessage.find({ chatThreadId }).sort({ createdAt: 1 });
+  const messages = await ChatMessage.find({ chatThreadId }).setOptions(dbOptions).sort({ createdAt: 1 });
   const llmMessages = messages.map(m => ({
     role: m.role,
     content: [{

package/backend/actions/ChatThread/toggleAgentMode.js

@@ -3,6 +3,7 @@
 const Archetype = require('archetype');
 const authorize = require('../../authorize');
 const mongoose = require('mongoose');
+const operationOptions = require('../../helpers/operationOptions');
 
 const ToggleAgentModeParams = new Archetype({
   chatThreadId: {
@@ -16,16 +17,21 @@ const ToggleAgentModeParams = new Archetype({
   },
   roles: {
     $type: ['string']
+  },
+  maxTimeMS: {
+    $type: 'number'
   }
 }).compile('ToggleAgentModeParams');
 
-module.exports = ({ studioConnection }) => async function toggleAgentMode(params) {
+module.exports = ({ studioConnection, options }) => async function toggleAgentMode(params) {
   const { chatThreadId, agentMode, initiatedById, roles } = new ToggleAgentModeParams(params);
   const ChatThread = studioConnection.model('__Studio_ChatThread');
 
   await authorize('ChatThread.toggleAgentMode', roles);
 
-  const chatThread = await ChatThread.findById(chatThreadId).orFail();
+  const chatThread = await ChatThread.findById(chatThreadId).
+    setOptions(operationOptions(options, params)).
+    orFail();
   if (initiatedById != null && chatThread.userId?.toString() !== initiatedById.toString()) {
     throw new Error('Not authorized');
   }

package/backend/actions/Dashboard/createDashboard.js

@@ -37,3 +37,6 @@ module.exports = ({ studioConnection }) => async function createDashboard(params
 
   return { dashboard };
 };
+
+module.exports.paramsType = CreateDashboardParams;
+module.exports.tags = [];

package/backend/actions/Dashboard/deleteDashboard.js

@@ -2,6 +2,7 @@
 
 const Archetype = require('archetype');
 const authorize = require('../../authorize');
+const operationOptions = require('../../helpers/operationOptions');
 
 const DeleteDashboardParams = new Archetype({
   dashboardId: {
@@ -10,17 +11,26 @@ const DeleteDashboardParams = new Archetype({
   },
   roles: {
     $type: ['string']
+  },
+  maxTimeMS: {
+    $type: 'number'
   }
 }).compile('DeleteDashboardParams');
 
-module.exports = ({ studioConnection }) => async function deleteDashboard(params) {
+module.exports = ({ studioConnection, options }) => async function deleteDashboard(params) {
   const { dashboardId, roles } = new DeleteDashboardParams(params);
   const Dashboard = studioConnection.model('__Studio_Dashboard');
   const DashboardResult = studioConnection.model('__Studio_DashboardResult');
 
   await authorize('Dashboard.deleteDashboard', roles);
 
-  const result = await Dashboard.deleteOne({ _id: dashboardId }).orFail();
-  await DashboardResult.deleteMany({ dashboardId });
+  const result = await Dashboard.deleteOne({ _id: dashboardId }).
+    setOptions(operationOptions(options, params)).
+    orFail();
+  await DashboardResult.deleteMany({ dashboardId }).
+    setOptions(operationOptions(options, params));
   return { result };
 };
+
+module.exports.paramsType = DeleteDashboardParams;
+module.exports.tags = ['destructive'];

package/backend/actions/Dashboard/getDashboard.js

@@ -4,6 +4,8 @@ const Archetype = require('archetype');
 const authorize = require('../../authorize');
 const createSandbox = require('../../sandbox/createSandbox');
 const mongoose = require('mongoose');
+const readOperationOptions = require('../../helpers/readOperationOptions');
+const operationOptions = require('../../helpers/operationOptions');
 const { defaultMothershipURL } = require('../../../constants');
 
 const GetDashboardParams = new Archetype({
@@ -25,6 +27,13 @@ const GetDashboardParams = new Archetype({
   },
   roles: {
     $type: ['string']
+  },
+  maxTimeMS: {
+    $type: 'number'
+  },
+  readPreference: {
+    $type: 'string',
+    $enum: ['secondary', 'secondaryPreferred', 'primary']
   }
 }).compile('GetDashboardParams');
 
@@ -36,10 +45,12 @@ module.exports = ({ db, studioConnection, options }) => async function getDashbo
 
   await authorize('Dashboard.getDashboard', roles);
 
-  const dashboard = await Dashboard.findOne({ _id: dashboardId });
+  const dashboardOptions = operationOptions(options, params);
+  const dashboard = await Dashboard.findOne({ _id: dashboardId }).
+    setOptions(dashboardOptions);
   if (evaluate) {
     let result = null;
-    const sandbox = createSandbox({ db });
+    const sandbox = createSandbox(db, { ...readOperationOptions(options, params) });
     const startExec = startDashboardEvaluate(DashboardResult, dashboardId, $workspaceId, userId);
     startExec.catch(() => {}); // Avoid unhandled promise rejections - we will handle this error later.
     try {
@@ -56,7 +67,8 @@ module.exports = ({ db, studioConnection, options }) => async function getDashbo
           dashboardResult._id,
           null,
           { message: error.message },
-          'failed'
+          'failed',
+          dashboardOptions
         );
       });
       return { dashboard, dashboardResult, error: { message: error.message } };
@@ -79,7 +91,8 @@ module.exports = ({ db, studioConnection, options }) => async function getDashbo
           dashboardResult._id,
           result,
           undefined,
-          'completed'
+          'completed',
+          dashboardOptions
         );
       });
 
@@ -93,21 +106,25 @@ module.exports = ({ db, studioConnection, options }) => async function getDashbo
       dashboardId,
       $workspaceId,
       authorization,
-      mothershipUrl
+      mothershipUrl,
+      dashboardOptions
     );
     return { dashboard, dashboardResults };
   }
 };
 
-async function completeDashboardEvaluate(Dashboard, DashboardResult, dashboardResultId, result, error, status) {
-  const dashboardResult = await DashboardResult.findById(dashboardResultId).orFail();
+async function completeDashboardEvaluate(Dashboard, DashboardResult, dashboardResultId, result, error, status, dashboardOptions) {
+  const dashboardResult = await DashboardResult.findById(dashboardResultId).
+    setOptions(dashboardOptions).
+    orFail();
   const finishedEvaluatingAt = new Date();
   dashboardResult.finishedEvaluatingAt = finishedEvaluatingAt;
   dashboardResult.result = result;
   dashboardResult.error = error;
   dashboardResult.status = status;
   await dashboardResult.save();
-  await Dashboard.updateOne({ _id: dashboardResult.dashboardId }, { $set: { lastEvaluatedAt: finishedEvaluatingAt } });
+  await Dashboard.updateOne({ _id: dashboardResult.dashboardId }, { $set: { lastEvaluatedAt: finishedEvaluatingAt } }).
+    setOptions(dashboardOptions);
   return { dashboardResult };
 }
 
@@ -123,14 +140,17 @@ async function startDashboardEvaluate(DashboardResult, dashboardId, workspaceId,
   return { dashboardResult };
 }
 
-async function getDashboardResults(DashboardResult, dashboardId, workspaceId, authorization, mothershipUrl) {
+async function getDashboardResults(DashboardResult, dashboardId, workspaceId, authorization, mothershipUrl, dashboardOptions) {
   const filter = { dashboardId };
   if (workspaceId != null) {
     filter.workspaceId = workspaceId;
   }
 
   const [localResultsRes, remoteResultsRes] = await Promise.allSettled([
-    DashboardResult.find(filter).sort({ _id: -1 }).limit(10),
+    DashboardResult.find(filter).
+      sort({ _id: -1 }).
+      limit(10).
+      setOptions(dashboardOptions),
     getMothershipDashboardResults(dashboardId, workspaceId, authorization, mothershipUrl)
   ]);
 
@@ -201,3 +221,6 @@ function addDocumentSchemaPaths(result) {
   }
   result.$document.schemaPaths = schemaPaths;
 }
+
+module.exports.paramsType = GetDashboardParams;
+module.exports.tags = ['readOnly'];

package/backend/actions/Dashboard/getDashboards.js

@@ -2,14 +2,18 @@
 
 const Archetype = require('archetype');
 const authorize = require('../../authorize');
+const operationOptions = require('../../helpers/operationOptions');
 
 const GetDashboardParams = new Archetype({
   roles: {
     $type: ['string']
+  },
+  maxTimeMS: {
+    $type: 'number'
   }
 }).compile('GetDashboardParams');
 
-module.exports = ({ studioConnection }) => async function getDashboards(params) {
+module.exports = ({ studioConnection, options }) => async function getDashboards(params) {
   const Dashboard = studioConnection.model('__Studio_Dashboard');
   const { roles } = new GetDashboardParams(params);
 
@@ -17,7 +21,11 @@ module.exports = ({ studioConnection }) => async function getDashboards(params)
 
   const dashboards = await Dashboard
     .find()
+    .setOptions(operationOptions(options, params))
     .sort({ isPinned: -1, createdAt: -1, _id: -1 });
 
   return { dashboards };
 };
+
+module.exports.paramsType = GetDashboardParams;
+module.exports.tags = ['readOnly'];

package/backend/actions/Dashboard/updateDashboard.js

@@ -2,6 +2,7 @@
 
 const Archetype = require('archetype');
 const authorize = require('../../authorize');
+const operationOptions = require('../../helpers/operationOptions');
 
 const UpdateDashboardParams = new Archetype({
   dashboardId: {
@@ -22,10 +23,13 @@ const UpdateDashboardParams = new Archetype({
   },
   roles: {
     $type: ['string']
+  },
+  maxTimeMS: {
+    $type: 'number'
   }
 }).compile('UpdateDashboardParams');
 
-module.exports = ({ studioConnection }) => async function updateDashboard(params) {
+module.exports = ({ studioConnection, options }) => async function updateDashboard(params) {
   const { dashboardId, code, title, description, isPinned, roles, evaluate } = new UpdateDashboardParams(params);
 
   const Dashboard = studioConnection.models['__Studio_Dashboard'];
@@ -54,7 +58,10 @@ module.exports = ({ studioConnection }) => async function updateDashboard(params
     dashboardId,
     updateObj,
     { sanitizeFilter: true, returnDocument: 'after' }
-  );
+  ).setOptions(operationOptions(options, params));
 
   return { doc };
 };
+
+module.exports.paramsType = UpdateDashboardParams;
+module.exports.tags = [];

package/backend/actions/Model/addField.js

@@ -2,6 +2,7 @@
 
 const Archetype = require('archetype');
 const authorize = require('../../authorize');
+const operationOptions = require('../../helpers/operationOptions');
 
 const AddFieldParams = new Archetype({
   model: {
@@ -22,10 +23,13 @@ const AddFieldParams = new Archetype({
   },
   roles: {
     $type: ['string']
+  },
+  maxTimeMS: {
+    $type: 'number'
   }
 }).compile('AddFieldParams');
 
-module.exports = ({ db }) => async function addField(params) {
+module.exports = ({ db, options }) => async function addField(params) {
   const { model, _id, fieldName, fieldValue, roles } = new AddFieldParams(params);
 
   await authorize('Model.updateDocument', roles);
@@ -48,7 +52,10 @@ module.exports = ({ db }) => async function addField(params) {
       runValidators: false,
       strict: false
     }
-  );
+  ).setOptions(operationOptions(options, params));
 
   return { doc };
 };
+
+module.exports.paramsType = AddFieldParams;
+module.exports.tags = [];