fix: aggregate and shell view, enhance auto completion

README.md

@@ -116,15 +116,16 @@ Per-database user management. Common-role shortcuts plus arbitrary custom roles.
 
 ### Query modes
 
-| Mode            | Surface                                   | Highlights                                                                                                             |
-| --------------- | ----------------------------------------- | ---------------------------------------------------------------------------------------------------------------------- |
-| **Simple**      | filter · projection · sort · skip · limit | EJSON or shell syntax, field-name autocomplete from last results                                                       |
-| **Aggregation** | pipeline as `[{ $match: … }, …]`          | Monaco, full operator autocomplete                                                                                     |
-| **Shell**       | `db.coll.find({…}).sort({…}).limit(n)`    | Curated subset of mongosh syntax — `find`, `findOne`, `aggregate`, `count`, `countDocuments`, `estimatedDocumentCount` |
+| Mode            | Surface                                   | Highlights                                                                                                                                                                                                                                             |
+| --------------- | ----------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| **Simple**      | filter · projection · sort · skip · limit | EJSON or shell syntax, field-name autocomplete from last results                                                                                                                                                                                       |
+| **Aggregation** | pipeline as `[{ $match: … }, …]`          | Monaco, full operator autocomplete                                                                                                                                                                                                                     |
+| **Shell**       | `db.coll.find({…}).sort({…}).limit(n)`    | Curated subset of mongosh syntax - reads (`find`, `findOne`, `aggregate`, `count`, `countDocuments`) and writes (`insertOne`, `insertMany`, `updateOne`, `updateMany`, `replaceOne`, `deleteOne`, `deleteMany`), across any collection of the database |
 
 - **Run:** click button or `Ctrl+Enter` / `Cmd+Enter`
 - **Format:** `Shift+Alt+F` — custom formatter that preserves shell helpers
-- **Operator autocomplete** for every standard query operator (`$eq`, `$in`, `$elemMatch`, `$geoWithin`, `$jsonSchema`, …)
+- **Context-aware autocomplete:** query operators in filters, stages and expressions in pipelines, update operators inside `updateOne` / `updateMany`, `db` → collection → method chaining in the shell, plus parameter hints and hover docs
+- **Guardrails:** write commands never run on a refetch, only on an explicit Run, and `deleteMany({})` / `updateMany({})` ask before touching the whole collection
 
 ### Documents
 

src/main/ipc/channels.ts

@@ -39,7 +39,10 @@ export const Channels = {
   QueryInsertOne: 'query:insertOne',
   QueryInsertMany: 'query:insertMany',
   QueryDeleteOne: 'query:deleteOne',
-  QueryDeleteMany: 'query:deleteMany'
+  QueryDeleteMany: 'query:deleteMany',
+  QueryUpdateByFilter: 'query:updateByFilter',
+  QueryDeleteByFilter: 'query:deleteByFilter',
+  QueryReplaceByFilter: 'query:replaceByFilter'
 } as const
 
 export type ChannelName = (typeof Channels)[keyof typeof Channels]

src/main/ipc/router.ts

@@ -15,6 +15,7 @@ import {
   CreateIndexSchema,
   CreateUserSchema,
   DatabaseRefSchema,
+  DeleteByFilterRequestSchema,
   DeleteManyRequestSchema,
   DeleteOneRequestSchema,
   DropIndexSchema,
@@ -25,7 +26,9 @@ import {
   InsertOneRequestSchema,
   RenameCollectionSchema,
   ReorderConnectionsSchema,
+  ReplaceByFilterRequestSchema,
   ReplaceOneRequestSchema,
+  UpdateByFilterRequestSchema,
   UpdateUserSchema
 } from '@shared/schemas'
 import type { Result } from '@shared/result'
@@ -228,6 +231,21 @@ export function registerIpcHandlers(services: Services): void {
     withResult(DeleteManyRequestSchema, (request) => queries.deleteMany(request))
   )
 
+  ipcMain.handle(
+    Channels.QueryUpdateByFilter,
+    withResult(UpdateByFilterRequestSchema, (request) => queries.updateByFilter(request))
+  )
+
+  ipcMain.handle(
+    Channels.QueryDeleteByFilter,
+    withResult(DeleteByFilterRequestSchema, (request) => queries.deleteByFilter(request))
+  )
+
+  ipcMain.handle(
+    Channels.QueryReplaceByFilter,
+    withResult(ReplaceByFilterRequestSchema, (request) => queries.replaceByFilter(request))
+  )
+
   ipcMain.handle(
     Channels.IndexesList,
     withResult(IndexesListSchema, ({ connectionId, db, coll }) =>

src/main/services/QueryService.ts

@@ -1,8 +1,10 @@
-import type { Document, Filter, Sort } from 'mongodb'
+import type { Document, Filter, Sort, UpdateFilter } from 'mongodb'
 import { EJSON } from 'bson'
 import type {
   AggregateRequest,
   AggregateResponse,
+  DeleteByFilterRequest,
+  DeleteByFilterResponse,
   DeleteManyRequest,
   DeleteManyResponse,
   DeleteOneRequest,
@@ -14,8 +16,12 @@ import type {
   InsertManyResponse,
   InsertOneRequest,
   InsertOneResponse,
+  ReplaceByFilterRequest,
+  ReplaceByFilterResponse,
   ReplaceOneRequest,
-  ReplaceOneResponse
+  ReplaceOneResponse,
+  UpdateByFilterRequest,
+  UpdateByFilterResponse
 } from '@shared/types'
 import type { ConnectionService } from './ConnectionService'
 import { canonicalHash, parseFilter, toCanonicalString, toRelaxed } from '../lib/ejson'
@@ -155,6 +161,46 @@ export class QueryService {
     const result = await coll.deleteOne(idFilter)
     return { deletedCount: result.deletedCount }
   }
+
+  async updateByFilter(req: UpdateByFilterRequest): Promise<UpdateByFilterResponse> {
+    const client = this.connections.getClient(req.connectionId)
+    const coll = client.db(req.db).collection(req.coll)
+    const filter = parseFilter(req.filter) as Filter<Document>
+    const update = parseUpdate(req.update)
+
+    const result = req.many
+      ? await coll.updateMany(filter, update, { upsert: req.upsert })
+      : await coll.updateOne(filter, update, { upsert: req.upsert })
+
+    return {
+      matched: result.matchedCount,
+      modified: result.modifiedCount,
+      upsertedId: result.upsertedId ? toCanonicalString(result.upsertedId) : null
+    }
+  }
+
+  async deleteByFilter(req: DeleteByFilterRequest): Promise<DeleteByFilterResponse> {
+    const client = this.connections.getClient(req.connectionId)
+    const coll = client.db(req.db).collection(req.coll)
+    const filter = parseFilter(req.filter) as Filter<Document>
+
+    const result = req.many ? await coll.deleteMany(filter) : await coll.deleteOne(filter)
+    return { deletedCount: result.deletedCount }
+  }
+
+  async replaceByFilter(req: ReplaceByFilterRequest): Promise<ReplaceByFilterResponse> {
+    const client = this.connections.getClient(req.connectionId)
+    const coll = client.db(req.db).collection(req.coll)
+    const filter = parseFilter(req.filter) as Filter<Document>
+    const replacement = parseDocument(req.replacement)
+
+    const result = await coll.replaceOne(filter, replacement, { upsert: req.upsert })
+    return {
+      matched: result.matchedCount,
+      modified: result.modifiedCount,
+      upsertedId: result.upsertedId ? toCanonicalString(result.upsertedId) : null
+    }
+  }
 }
 
 function toEnvelope(doc: Document): DocumentEnvelope {
@@ -181,6 +227,28 @@ function parseDocument(canonical: string): Document {
   return parsed as Document
 }
 
+/**
+ * Update documents must consist of update operators (`$set`, `$inc`, …) or
+ * be an aggregation pipeline. A plain document would silently replace the
+ * whole record, which is what `replaceByFilter` is for.
+ */
+function parseUpdate(canonical: string): UpdateFilter<Document> | Document[] {
+  const parsed = EJSON.parse(canonical, { relaxed: false })
+  if (Array.isArray(parsed)) return parsePipeline(canonical)
+  if (typeof parsed !== 'object' || parsed === null) {
+    const e = new Error('Update must be a JSON object')
+    e.name = 'ValidationError'
+    throw e
+  }
+  const keys = Object.keys(parsed)
+  if (keys.length === 0 || !keys.every((key) => key.startsWith('$'))) {
+    const e = new Error('Update must only contain update operators such as $set or $inc')
+    e.name = 'ValidationError'
+    throw e
+  }
+  return parsed as UpdateFilter<Document>
+}
+
 function parsePipeline(canonical: string): Document[] {
   const parsed = EJSON.parse(canonical, { relaxed: false })
   if (!Array.isArray(parsed)) {

src/preload/index.ts

@@ -16,6 +16,8 @@ import type {
   CreateUserPayload,
   DatabaseInfo,
   DatabaseUser,
+  DeleteByFilterRequest,
+  DeleteByFilterResponse,
   DeleteManyRequest,
   DeleteManyResponse,
   DeleteOneRequest,
@@ -30,9 +32,13 @@ import type {
   InsertOneRequest,
   InsertOneResponse,
   RenameCollectionPayload,
+  ReplaceByFilterRequest,
+  ReplaceByFilterResponse,
   ReplaceOneRequest,
   ReplaceOneResponse,
   ServerStats,
+  UpdateByFilterRequest,
+  UpdateByFilterResponse,
   UpdateUserPayload
 } from '@shared/types'
 
@@ -83,7 +89,13 @@ const api: Api = {
       invoke<InsertManyResponse>('query:insertMany', request),
     deleteOne: (request: DeleteOneRequest) => invoke<DeleteOneResponse>('query:deleteOne', request),
     deleteMany: (request: DeleteManyRequest) =>
-      invoke<DeleteManyResponse>('query:deleteMany', request)
+      invoke<DeleteManyResponse>('query:deleteMany', request),
+    updateByFilter: (request: UpdateByFilterRequest) =>
+      invoke<UpdateByFilterResponse>('query:updateByFilter', request),
+    deleteByFilter: (request: DeleteByFilterRequest) =>
+      invoke<DeleteByFilterResponse>('query:deleteByFilter', request),
+    replaceByFilter: (request: ReplaceByFilterRequest) =>
+      invoke<ReplaceByFilterResponse>('query:replaceByFilter', request)
   },
   users: {
     list: (payload: { connectionId: string; db: string }) =>