@mongoosejs/studio 0.2.8 → 0.2.10

package/backend/actions/Dashboard/getDashboard.js

@@ -66,7 +66,7 @@ module.exports = ({ db }) => async function getDashboard(params) {
         );
       });
 
-      return { dashboard, dashboardResult };
+      return { dashboard, dashboardResult, result };
     } catch (error) {
       return { dashboard, error: { message: error.message } };
     }

package/backend/actions/Model/index.js

@@ -13,6 +13,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/authorize.js

@@ -23,6 +23,7 @@ const actionsToRequiredRoles = {
   '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/backend/next.js

@@ -5,9 +5,66 @@ const Backend = require('./');
 module.exports = function next(conn, options) {
   const backend = Backend(conn, options?.studioConnection, options);
 
-  return function wrappedNextJSFunction(req, res) {
-    const params = { ...req.query, ...req.body, ...req.params };
+  const mothershipUrl = options?._mothershipUrl || 'https://mongoose-js.netlify.app/.netlify/functions';
+  let workspace = null;
+
+  return async function wrappedNextJSFunction(req, res) {
+    const params = { ...req.query, ...req.body, ...req.params, authorization: req.headers.authorization };
     const actionName = params?.action;
+
+    const authorization = params?.authorization;
+    if (options?.apiKey) {
+      if (!authorization) {
+        throw new Error('Not authorized');
+      }
+
+      if (workspace == null) {
+        ({ workspace } = await fetch(`${mothershipUrl}/getWorkspace`, {
+          method: 'POST',
+          body: JSON.stringify({ apiKey: options.apiKey }),
+          headers: {
+            Authorization: `Bearer ${options.apiKey}`,
+            'Content-Type': 'application/json'
+          }
+        })
+          .then(response => {
+            if (response.status < 200 || response.status >= 400) {
+              return response.json().then(data => {
+                throw new Error(`Error getting workspace ${response.status}: ${require('util').inspect(data)}`);
+              });
+            }
+            return response;
+          })
+          .then(res => res.json()));
+      }
+
+      const { user, roles } = await fetch(`${mothershipUrl}/me?`, {
+        method: 'POST',
+        body: JSON.stringify({ workspaceId: workspace._id }),
+        headers: {
+          Authorization: authorization,
+          'Content-Type': 'application/json'
+        }
+      })
+        .then(response => {
+          if (response.status < 200 || response.status >= 400) {
+            return response.json().then(data => {
+              throw new Error(`Mongoose Studio API Key Error ${response.status}: ${require('util').inspect(data)}`);
+            });
+          }
+          return response;
+        })
+        .then(res => res.json());
+      if (!user || !roles) {
+        throw new Error('Not authorized');
+      }
+
+      params.$workspaceId = workspace._id;
+      params.roles = roles;
+      params.userId = user._id;
+      params.initiatedById = user._id;
+    }
+
     if (typeof actionName !== 'string') {
       throw new Error('No action specified');
     }
@@ -24,7 +81,10 @@ module.exports = function next(conn, options) {
     }
 
     return actionFn(params)
-      .then(result => res.status(200).json(result))
+      .then(result => {
+        res.status(200).json(result);
+        return result;
+      })
       .catch(error => res.status(500).json({ message: error.message }));
   };
 };

package/eslint.config.js

@@ -39,7 +39,9 @@ module.exports = defineConfig([
         process: 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',