@mongoosejs/studio 0.5.2 → 0.5.4

package/backend/actions/ChatThread/streamChatMessage.js

@@ -4,8 +4,7 @@ const Archetype = require('archetype');
 const assert = require('assert');
 const authorize = require('../../authorize');
 const callLLM = require('../../integrations/callLLM');
-const agentSystemPrompt = require('../../chatAgent/agentSystemPrompt');
-const getAgentTools = require('../../chatAgent/getAgentTools');
+const runChatAgent = require('../../chatAgent/runChatAgent');
 const streamLLM = require('../../integrations/streamLLM');
 const getModelDescriptions = require('../../helpers/getModelDescriptions');
 const mongoose = require('mongoose');
@@ -86,14 +85,6 @@ module.exports = ({ db, studioConnection, options }) => async function* streamCh
     );
   }
 
-  const modelDescriptions = getModelDescriptions(db);
-  const system = [
-    chatThread.agentMode ? agentSystemPrompt : systemPrompt,
-    currentDateTime ? `Current date: ${currentDateTime}` : null,
-    modelDescriptions,
-    options?.context
-  ].filter(Boolean).join('\n\n');
-
   const userChatMessage = await ChatMessage.create({
     chatThreadId,
     role: 'user',
@@ -111,10 +102,19 @@ module.exports = ({ db, studioConnection, options }) => async function* streamCh
     script: null,
     executionResult: null
   });
-  const llmOptions = chatThread.agentMode ? { ...options, tools: getAgentTools(db) } : options;
   let textStream;
   try {
-    textStream = streamLLM(llmMessages, system, llmOptions);
+    if (chatThread.agentMode) {
+      textStream = runChatAgent({ db, llmMessages, currentDateTime, options });
+    } else {
+      const system = [
+        systemPrompt,
+        currentDateTime ? `Current date: ${currentDateTime}` : null,
+        getModelDescriptions(db),
+        options?.context
+      ].filter(Boolean).join('\n\n');
+      textStream = streamLLM(llmMessages, system, options);
+    }
   } catch (err) {
     yield { message: err?.message || 'Failed to stream response' };
     return {};

package/backend/chatAgent/agentSystemPrompt.js

@@ -5,24 +5,30 @@ You are a data querying assistant with access to tools that can query MongoDB di
 
 Your tools are for EXPLORATION ONLY — use them to understand the data before writing a script. NEVER use tool results as the data source for the final script. The final script must be fully self-contained: it must query MongoDB itself and not depend on any data you retrieved via tools.
 
-Follow this process for each query:
+Always follow this process for each query (do not skip steps):
 
 1. **Identify models**: Based on the user's question and the model descriptions below, identify which models are relevant.
-2. **Check document counts**: Use estimatedDocumentCount on the relevant models to understand data volume. This helps you decide whether a query is safe to run or needs limits/filters.
-3. **Test assumptions**: Use find or findOne to sample real documents and verify your assumptions about the shape of the data, field values, and relationships. Do not guess field values when you can look them up.
-4. **Type-check**: Before presenting the script, run it through the typeCheck tool to catch errors. The sandbox globals are: db (a mongoose.Connection — use db.model('ModelName') to get models), mongoose, ObjectId, console, and MongooseStudioChartColors. Fix any errors and re-check until clean.
-5. **Write the final script**: Once you understand the data, produce a self-contained script that queries MongoDB directly. The script must NOT use hard-coded data from your tool calls — it must run its own queries.
+2. **Check document counts**: Use estimatedDocumentCount on each relevant model to understand data volume and choose safe query patterns.
+3. **Test assumptions with evidence**: Use find/findOne on each relevant model to verify field names, value shapes, and relationships. Treat every unverified field name, status value, or relationship as unknown until observed.
+4. **Draft script**: Write a self-contained script that queries MongoDB directly. Access models via \`db.models.ModelName\` (for example \`db.models.User.findOne(...)\`). Do NOT use \`mongoose.model('Name')\` — schemas are registered on the \`db\` connection, not on the global \`mongoose\` instance — and do NOT use bare \`db.ModelName\` (the model lives under \`db.models\`).
+5. **Type-check every draft**: Run typeCheck on the script before responding.
+6. **Fix and re-check loop**: If typeCheck reports issues, fix them and run typeCheck again. Repeat until clean.
+7. **Return final answer**: Provide one final script by default, or multiple scripts only if the user explicitly asks for multiple scripts, and include a brief description.
+
+Hard requirements before finalizing:
+- You MUST run at least one assumption-checking query (find/findOne) unless the user only asks for pure counts.
+- You MUST run typeCheck immediately before finalizing any script.
+- If you could not run an expected step (tool failure, timeout, missing model), explicitly say what failed and provide the safest possible fallback script.
+- Do not claim a field exists unless you observed it in exploration.
 
 Keep scripts concise. Avoid unnecessary comments, error handling, and temporary variables.
 
 Do not write any imports or require() statements, that will cause the script to break.
 
-If the user approves the script, the script will run in the Node.js server in a sandboxed vm.createContext() call with the following globals: db (the Mongoose connection), mongoose, ObjectId (mongoose.Types.ObjectId), console, and MongooseStudioChartColors (an array of 8 hex color strings for chart dataset colors). The script return value will then send the response via JSON to the client. Be aware that the result of the query will be serialized to JSON before being displayed to the user. MAKE SURE TO RETURN A VALUE FROM THE SCRIPT.
+If the user approves the script, the script will run in the Node.js server in a sandboxed vm.createContext() call with the following globals: db (the Mongoose connection; access models via \`db.models.ModelName\`), mongoose, ObjectId (mongoose.Types.ObjectId), console, and MongooseStudioChartColors (an array of 8 hex color strings for chart dataset colors). The script return value will then send the response via JSON to the client. Be aware that the result of the query will be serialized to JSON before being displayed to the user. MAKE SURE TO RETURN A VALUE FROM THE SCRIPT.
 
 Optimize scripts for readability first, followed by reliability, followed by performance. Avoid using the aggregation framework unless explicitly requested by the user. Use indexed fields in queries where possible.
 
-Avoid using the aggregation framework unless explicitly asked by the user.
-
 Assume the user has pre-defined schemas and models. Do not define any new schemas or models for the user.
 
 Use async/await where possible. Assume top-level await is allowed.
@@ -33,11 +39,17 @@ Format output as Markdown, including code fences for any scripts the user reques
 
 Add a brief text description of what the script does.
 
+Before the final script, include a brief checklist with this exact structure:
+- Models identified: ...
+- Counts checked: yes/no
+- Assumptions tested: yes/no
+- Type-check passed: yes/no
+
 If the user's query is best answered with a chart, return a Chart.js 4 configuration as \`return { $chart: chartJSConfig };\`. Disable ChartJS animation by default unless user asks for it. Set responsive: true, maintainAspectRatio: false options unless the user explicitly asks. Use MongooseStudioChartColors for dataset backgroundColor and borderColor by default. For line/bar charts, use MongooseStudioChartColors[i] as borderColor and MongooseStudioChartColors[i] + '33' as backgroundColor for each dataset. For pie/doughnut charts, use MongooseStudioChartColors.slice(0, data.length) as backgroundColor. Only use custom colors if the user explicitly requests specific colors.
 
-If the user's query is best answered by a map, return an object { $featureCollection } which contains a GeoJSON FeatureCollection
+If the user's query is best answered by a map, return an object { $featureCollection } which contains a GeoJSON FeatureCollection.
 
-If the user's query is best answered by a table, return an object { $table: { columns: string[], rows: any[][] } }
+If the user's query is best answered by a table, return an object { $table: { columns: string[], rows: any[][] } }.
 
 -----------
 

package/backend/chatAgent/getAgentTools.js

@@ -5,6 +5,7 @@ const ts = require('typescript');
 const { tool } = require('ai');
 const { jsonSchema } = require('@ai-sdk/provider-utils');
 const agentToolMetadata = require('./agentToolMetadata');
+const debugging = require('../../debugging');
 
 module.exports = function getAgentTools(db) {
   const modelNames = Object.keys(db.models).filter(name => !name.startsWith('__Studio'));
@@ -21,7 +22,7 @@ module.exports = function getAgentTools(db) {
         required: ['modelName']
       }),
       execute: async({ modelName }) => {
-        console.log(`estimatedDocumentCount: modelName=${modelName}`);
+        debugLog(`estimatedDocumentCount: modelName=${modelName}`);
         const Model = db.models[modelName];
         if (Model == null) {
           return { error: `Model ${modelName} not found. Available models: ${modelNames.join(', ')}` };
@@ -42,7 +43,7 @@ module.exports = function getAgentTools(db) {
         required: ['modelName']
       }),
       execute: async({ modelName, filter = {}, limit = 10 }) => {
-        console.log(`find: modelName=${modelName}, filter=${JSON.stringify(filter)}, limit=${limit}`);
+        debugLog(`find: modelName=${modelName}, filter=${JSON.stringify(filter)}, limit=${limit}`);
         const Model = db.models[modelName];
         if (Model == null) {
           return { error: `Model ${modelName} not found. Available models: ${modelNames.join(', ')}` };
@@ -62,7 +63,7 @@ module.exports = function getAgentTools(db) {
         required: ['modelName']
       }),
       execute: async({ modelName, filter = {} }) => {
-        console.log(`findOne: modelName=${modelName}, filter=${JSON.stringify(filter)}`);
+        debugLog(`findOne: modelName=${modelName}, filter=${JSON.stringify(filter)}`);
         const Model = db.models[modelName];
         if (Model == null) {
           return { error: `Model ${modelName} not found. Available models: ${modelNames.join(', ')}` };
@@ -72,7 +73,7 @@ module.exports = function getAgentTools(db) {
       }
     }),
     typeCheck: tool({
-      description: toolDescriptions.typeCheck + ' The script will run in a sandbox with globals: db (mongoose.Connection), mongoose, ObjectId (mongoose.Types.ObjectId), console, and MongooseStudioChartColors (string[]). Pass the raw script body (no imports, no wrapping function). Returns any TypeScript errors or JavaScript syntax errors found. Remember that you should write JavaScript, NOT TypeScript. This tool is just to check for obvious errors.',
+      description: toolDescriptions.typeCheck + ' The script will run in a sandbox with globals: db (mongoose.Connection — access models via db.models.ModelName), mongoose, ObjectId (mongoose.Types.ObjectId), console, and MongooseStudioChartColors (string[]). Pass the raw script body (no imports, no wrapping function). Returns any TypeScript errors or JavaScript syntax errors found. Remember that you should write JavaScript, NOT TypeScript. This tool is just to check for obvious errors.',
       inputSchema: jsonSchema({
         type: 'object',
         properties: {
@@ -81,7 +82,8 @@ module.exports = function getAgentTools(db) {
         required: ['script']
       }),
       execute: async({ script }) => {
-        const wrapped = wrapScriptForTypeCheck(script);
+        debugLog(`typeCheck: script=${script}`);
+        const wrapped = wrapScriptForTypeCheck(script, modelNames);
         const fileName = '__check.ts';
         const compilerOptions = {
           noEmit: true,
@@ -118,7 +120,7 @@ module.exports = function getAgentTools(db) {
           return { ok: true };
         }
 
-        console.log('Errors', errors);
+        debugLog('Errors', errors);
 
         return { ok: false, errors };
       }
@@ -126,10 +128,19 @@ module.exports = function getAgentTools(db) {
   };
 };
 
-const wrapScriptForTypeCheck = (script) => `
+function debugLog() {
+  if (debugging.isDebuggingEnabled()) {
+    console.log(...arguments);
+  }
+}
+
+const wrapScriptForTypeCheck = (script, modelNames) => `
 import mongoose from 'mongoose';
-declare const db: Omit<mongoose.Connection, 'model'> & {
+declare const db: Omit<mongoose.Connection, 'model' | 'models'> & {
   model(name: string): mongoose.Model<any>;
+  models: {
+${modelNames.map(name => `    ${JSON.stringify(name)}: mongoose.Model<any>;`).join('\n')}
+  };
 };
 declare const ObjectId: typeof mongoose.Types.ObjectId;
 declare const console: Console;

package/backend/chatAgent/runChatAgent.js

@@ -0,0 +1,17 @@
+'use strict';
+
+const agentSystemPrompt = require('./agentSystemPrompt');
+const getAgentTools = require('./getAgentTools');
+const streamLLM = require('../integrations/streamLLM');
+const getModelDescriptions = require('../helpers/getModelDescriptions');
+
+module.exports = function runChatAgent({ db, llmMessages, currentDateTime, options }) {
+  const system = [
+    agentSystemPrompt,
+    currentDateTime ? `Current date: ${currentDateTime}` : null,
+    getModelDescriptions(db),
+    options?.context
+  ].filter(Boolean).join('\n\n');
+
+  return streamLLM(llmMessages, system, { ...options, tools: getAgentTools(db) });
+};

package/backend/index.js

@@ -11,6 +11,9 @@ const dashboardResultSchema = require('./db/dashboardResultSchema');
 
 module.exports = function backend(db, studioConnection, options) {
   db = db || mongoose.connection;
+  if (db instanceof mongoose.Mongoose) {
+    db = db.connection;
+  }
 
   studioConnection = studioConnection ?? db;
   const Dashboard = studioConnection.model('__Studio_Dashboard', dashboardSchema, 'studio__dashboards');

package/debugging.js

@@ -0,0 +1,11 @@
+'use strict';
+
+let debuggingEnabled = false;
+
+exports.enableDebugging = function enableDebugging() {
+  debuggingEnabled = true;
+};
+
+exports.isDebuggingEnabled = function isDebuggingEnabled() {
+  return debuggingEnabled;
+};

package/eval/agent/cases.js

@@ -0,0 +1,168 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+
+module.exports = [
+  {
+    id: 'simple-1-user-count',
+    category: 'simple',
+    fixture: 'ecommerce',
+    prompt: 'How many users do we have in total, including deleted ones?',
+    assert(trace) {
+      assert.equal(trace.executionError, null, `script error: ${trace.executionError}`);
+      const got = typeof trace.output === 'number' ? trace.output : trace.output?.count;
+      assert.equal(got, 4, `expected 4 users, got ${JSON.stringify(trace.output)}`);
+    }
+  },
+  {
+    id: 'simple-2-most-expensive-product',
+    category: 'simple',
+    fixture: 'ecommerce',
+    prompt: 'What is the single most expensive product? Return an object with its name and price.',
+    assert(trace) {
+      assert.equal(trace.executionError, null, `script error: ${trace.executionError}`);
+      assert.equal(trace.output?.name, 'Laptop', `expected name=Laptop, got ${JSON.stringify(trace.output)}`);
+      assert.equal(trace.output?.price, 1200, `expected price=1200, got ${JSON.stringify(trace.output)}`);
+    }
+  },
+  {
+    id: 'simple-3-active-bookings',
+    category: 'simple',
+    fixture: 'carsharing',
+    prompt: 'How many bookings currently have status "active"?',
+    assert(trace) {
+      assert.equal(trace.executionError, null, `script error: ${trace.executionError}`);
+      const got = typeof trace.output === 'number' ? trace.output : trace.output?.count;
+      assert.equal(got, 2, `expected 2 active bookings, got ${JSON.stringify(trace.output)}`);
+    }
+  },
+  {
+    id: 'simple-4-list-evs',
+    category: 'simple',
+    fixture: 'carsharing',
+    prompt: 'List every electric vehicle in the fleet, returning an array with make and model.',
+    assert(trace) {
+      assert.equal(trace.executionError, null, `script error: ${trace.executionError}`);
+      const list = Array.isArray(trace.output) ? trace.output : trace.output?.vehicles;
+      assert.equal(list?.length, 2, `expected 2 EVs, got ${JSON.stringify(trace.output)}`);
+      const json = JSON.stringify(list);
+      assert.ok(json.includes('Tesla') && json.includes('Leaf'), `expected Tesla and Leaf, got ${json}`);
+    }
+  },
+  {
+    id: 'simple-5-orders-by-status',
+    category: 'simple',
+    fixture: 'ecommerce',
+    prompt: 'Show a table with the count of orders grouped by status.',
+    assert(trace) {
+      assert.equal(trace.executionError, null, `script error: ${trace.executionError}`);
+      assert.ok(trace.output?.$table, `expected $table, got ${JSON.stringify(trace.output)}`);
+      assert.equal(trace.output.$table.rows.length, 5, `expected 5 status rows, got ${trace.output.$table.rows.length}`);
+      const json = JSON.stringify(trace.output.$table);
+      for (const status of ['pending', 'paid', 'shipped', 'delivered', 'cancelled']) {
+        assert.ok(json.includes(status), `expected "${status}" in table, got ${json}`);
+      }
+    }
+  },
+
+  {
+    id: 'nested-1-orders-by-month',
+    category: 'nested',
+    fixture: 'ecommerce',
+    prompt: 'How many orders were placed each month over the past 6 months? Return a table.',
+    assert(trace) {
+      assert.equal(trace.executionError, null, `script error: ${trace.executionError}`);
+      assert.ok(trace.output?.$table, `expected $table, got ${JSON.stringify(trace.output)}`);
+      assert.ok(trace.output.$table.rows.length >= 3, `expected ≥3 month rows, got ${trace.output.$table.rows.length}`);
+    }
+  },
+  {
+    id: 'nested-2-late-returns-unpaid',
+    category: 'nested',
+    fixture: 'carsharing',
+    prompt: 'Return an array of bookings that were returned late (returnedAt after endAt) and have at least one unpaid charge.',
+    assert(trace) {
+      assert.equal(trace.executionError, null, `script error: ${trace.executionError}`);
+      assert.ok(Array.isArray(trace.output), `expected array, got ${JSON.stringify(trace.output)}`);
+      assert.equal(trace.output.length, 2, `expected 2 late+unpaid bookings, got ${trace.output.length}`);
+    }
+  },
+  {
+    id: 'nested-3-paid-orders-with-electronics',
+    category: 'nested',
+    fixture: 'ecommerce',
+    prompt: 'Return an array of paid orders that contain at least one electronics product.',
+    assert(trace) {
+      assert.equal(trace.executionError, null, `script error: ${trace.executionError}`);
+      assert.ok(Array.isArray(trace.output), `expected array, got ${JSON.stringify(trace.output)}`);
+      assert.equal(trace.output.length, 2, `expected 2 paid+electronics orders, got ${trace.output.length}`);
+    }
+  },
+
+  {
+    id: 'dashboard-1-top-products',
+    category: 'dashboard',
+    fixture: 'ecommerce',
+    prompt: 'Build a dashboard showing the top 5 products by gross revenue from paid orders.',
+    assert(trace) {
+      assert.equal(trace.executionError, null, `script error: ${trace.executionError}`);
+      const renderable = trace.output?.$chart || trace.output?.$table;
+      assert.ok(renderable, `expected $chart or $table, got ${JSON.stringify(trace.output)}`);
+      assert.ok(JSON.stringify(renderable).includes('Headphones'), `Headphones should be top product, got ${JSON.stringify(renderable)}`);
+    }
+  },
+  {
+    id: 'dashboard-2-bookings-per-vehicle-type',
+    category: 'dashboard',
+    fixture: 'carsharing',
+    prompt: 'Show a chart of total bookings broken down by vehicle type.',
+    assert(trace) {
+      assert.equal(trace.executionError, null, `script error: ${trace.executionError}`);
+      assert.ok(trace.output?.$chart, `expected $chart, got ${JSON.stringify(trace.output)}`);
+      const json = JSON.stringify(trace.output.$chart);
+      for (const type of ['ev', 'sedan', 'suv']) {
+        assert.ok(json.includes(type), `expected "${type}" in chart, got ${json}`);
+      }
+    }
+  },
+  {
+    id: 'dashboard-3-revenue-by-month',
+    category: 'dashboard',
+    fixture: 'ecommerce',
+    prompt: 'Chart total revenue per month from paid orders. Include only months that contain at least one paid order, in chronological order, using "YYYY-MM" format for the labels.',
+    assert(trace) {
+      assert.equal(trace.executionError, null, `script error: ${trace.executionError}`);
+      assert.ok(trace.output?.$chart, `expected $chart, got ${JSON.stringify(trace.output)}`);
+      assert.deepEqual(trace.output.$chart.data.labels, ['2026-02', '2026-03', '2026-04']);
+      assert.equal(trace.output.$chart.data.datasets.length, 1, `expected 1 dataset, got ${JSON.stringify(trace.output.$chart.data.datasets)}`);
+      assert.deepEqual(trace.output.$chart.data.datasets[0].data, [300, 60, 222]);
+    }
+  },
+
+  {
+    id: 'ambig-1-missing-user',
+    category: 'ambiguous',
+    fixture: 'carsharing',
+    prompt: 'Why does Jane Doe have a negative balance?',
+    assert(trace) {
+      assert.ok(
+        trace.toolCalls.some(t => t.toolName === 'findOne' || t.toolName === 'find'),
+        'agent should look up the user before answering'
+      );
+      const lower = trace.text.toLowerCase();
+      assert.ok(
+        lower.includes('50') || lower.includes('positive') || lower.includes('not negative'),
+        `agent should note Jane's balance is actually positive; text was: ${trace.text.slice(0, 500)}`
+      );
+    }
+  },
+  {
+    id: 'ambig-2-investigate',
+    category: 'ambiguous',
+    fixture: 'ecommerce',
+    prompt: 'Some orders look weird. Can you investigate?',
+    assert(trace) {
+      assert.ok(trace.toolCalls.length >= 2, `expected ≥2 tool calls; saw ${trace.toolCalls.length}`);
+    }
+  }
+];

package/eval/agent/fixtures/carsharing.js

@@ -0,0 +1,147 @@
+'use strict';
+
+const mongoose = require('mongoose');
+
+const { Schema } = mongoose;
+
+const userSchema = new Schema({
+  name: String,
+  email: String,
+  balance: Number,
+  joinedAt: Date
+});
+
+const vehicleSchema = new Schema({
+  make: String,
+  model: String,
+  type: { type: String, enum: ['sedan', 'suv', 'ev'] },
+  licensePlate: String,
+  dailyRate: Number
+});
+
+const bookingSchema = new Schema({
+  userId: { type: Schema.Types.ObjectId, ref: 'User' },
+  vehicleId: { type: Schema.Types.ObjectId, ref: 'Vehicle' },
+  startAt: Date,
+  endAt: Date,
+  returnedAt: Date,
+  status: { type: String, enum: ['active', 'completed', 'cancelled'] }
+});
+
+const chargeSchema = new Schema({
+  userId: { type: Schema.Types.ObjectId, ref: 'User' },
+  bookingId: { type: Schema.Types.ObjectId, ref: 'Booking' },
+  amount: Number,
+  paid: Boolean,
+  createdAt: Date
+});
+
+module.exports = {
+  name: 'carsharing',
+  defineModels(connection) {
+    return {
+      User: connection.model('User', userSchema),
+      Vehicle: connection.model('Vehicle', vehicleSchema),
+      Booking: connection.model('Booking', bookingSchema),
+      Charge: connection.model('Charge', chargeSchema)
+    };
+  },
+  async seed({ User, Vehicle, Booking, Charge }) {
+    const users = await User.create([
+      { name: 'Jane Doe', email: 'jane@example.com', balance: 50, joinedAt: new Date('2025-02-01') },
+      { name: 'John Smith', email: 'john@example.com', balance: -25, joinedAt: new Date('2025-03-15') },
+      { name: 'Alice Wonder', email: 'alice@example.com', balance: 100, joinedAt: new Date('2025-06-22') },
+      { name: 'Bob Lee', email: 'bob@example.com', balance: 0, joinedAt: new Date('2026-01-10') }
+    ]);
+
+    const vehicles = await Vehicle.create([
+      { make: 'Tesla', model: 'Model 3', type: 'ev', licensePlate: 'EV-001', dailyRate: 80 },
+      { make: 'Toyota', model: 'Camry', type: 'sedan', licensePlate: 'SD-110', dailyRate: 50 },
+      { make: 'Honda', model: 'CR-V', type: 'suv', licensePlate: 'SU-220', dailyRate: 70 },
+      { make: 'Nissan', model: 'Leaf', type: 'ev', licensePlate: 'EV-330', dailyRate: 60 }
+    ]);
+
+    const dayOffset = (n) => {
+      const d = new Date('2026-05-13T12:00:00.000Z');
+      d.setUTCDate(d.getUTCDate() + n);
+      return d;
+    };
+    const daysAgo = (n) => dayOffset(-n);
+
+    const bookings = await Booking.create([
+      {
+        userId: users[0]._id,
+        vehicleId: vehicles[0]._id,
+        startAt: daysAgo(40),
+        endAt: daysAgo(38),
+        returnedAt: daysAgo(38),
+        status: 'completed'
+      },
+      {
+        userId: users[1]._id,
+        vehicleId: vehicles[1]._id,
+        startAt: daysAgo(30),
+        endAt: daysAgo(28),
+        returnedAt: daysAgo(27),
+        status: 'completed'
+      },
+      {
+        userId: users[1]._id,
+        vehicleId: vehicles[2]._id,
+        startAt: daysAgo(20),
+        endAt: daysAgo(18),
+        returnedAt: daysAgo(15),
+        status: 'completed'
+      },
+      {
+        userId: users[2]._id,
+        vehicleId: vehicles[3]._id,
+        startAt: daysAgo(10),
+        endAt: daysAgo(8),
+        returnedAt: daysAgo(8),
+        status: 'completed'
+      },
+      {
+        userId: users[2]._id,
+        vehicleId: vehicles[0]._id,
+        startAt: daysAgo(3),
+        endAt: dayOffset(2),
+        returnedAt: null,
+        status: 'active'
+      },
+      {
+        userId: users[3]._id,
+        vehicleId: vehicles[1]._id,
+        startAt: daysAgo(1),
+        endAt: dayOffset(5),
+        returnedAt: null,
+        status: 'active'
+      },
+      {
+        userId: users[3]._id,
+        vehicleId: vehicles[3]._id,
+        startAt: daysAgo(60),
+        endAt: daysAgo(58),
+        returnedAt: null,
+        status: 'cancelled'
+      },
+      {
+        userId: users[0]._id,
+        vehicleId: vehicles[2]._id,
+        startAt: daysAgo(50),
+        endAt: daysAgo(48),
+        returnedAt: daysAgo(46),
+        status: 'completed'
+      }
+    ]);
+
+    await Charge.create([
+      { userId: users[0]._id, bookingId: bookings[0]._id, amount: 160, paid: true, createdAt: daysAgo(38) },
+      { userId: users[1]._id, bookingId: bookings[1]._id, amount: 100, paid: true, createdAt: daysAgo(27) },
+      { userId: users[1]._id, bookingId: bookings[2]._id, amount: 140, paid: false, createdAt: daysAgo(15) },
+      { userId: users[1]._id, bookingId: bookings[2]._id, amount: 35, paid: false, createdAt: daysAgo(15) },
+      { userId: users[2]._id, bookingId: bookings[3]._id, amount: 120, paid: true, createdAt: daysAgo(8) },
+      { userId: users[0]._id, bookingId: bookings[7]._id, amount: 140, paid: false, createdAt: daysAgo(46) }
+    ]);
+  }
+};