@gravito/dark-matter 1.0.0-alpha.2

package/README.md

@@ -0,0 +1,182 @@
+# @gravito/dark-matter
+
+> MongoDB client for Gravito - Bun native, Laravel-style API
+
+## Installation
+
+```bash
+bun add @gravito/dark-matter mongodb
+```
+
+## Quick Start
+
+```typescript
+import { Mongo } from '@gravito/dark-matter'
+
+// Configure
+Mongo.configure({
+  default: 'main',
+  connections: {
+    main: { uri: 'mongodb://localhost:27017', database: 'myapp' }
+  }
+})
+
+// Connect
+await Mongo.connect()
+
+// Use
+const users = await Mongo.collection('users')
+  .where('status', 'active')
+  .orderBy('createdAt', 'desc')
+  .limit(10)
+  .get()
+
+// Disconnect
+await Mongo.disconnect()
+```
+
+## Features
+
+- 🚀 **Bun Native** - Optimized for Bun runtime
+- 🎯 **Laravel-style API** - Familiar fluent interface
+- 🔍 **Query Builder** - Type-safe query building
+- 📊 **Aggregation Pipeline** - Fluent aggregation API
+- 🔌 **Multi-connection** - Named connections support
+
+## API Reference
+
+### Query Builder
+
+```typescript
+// Basic queries
+const users = await Mongo.collection('users')
+  .where('status', 'active')
+  .where('age', '>', 18)
+  .whereIn('role', ['admin', 'editor'])
+  .get()
+
+// Sorting & Pagination
+const latest = await Mongo.collection('posts')
+  .orderBy('createdAt', 'desc')
+  .limit(10)
+  .skip(20)
+  .get()
+
+// Select specific fields
+const names = await Mongo.collection('users')
+  .select('name', 'email')
+  .get()
+
+// Find by ID
+const user = await Mongo.collection('users').find('507f1f77bcf86cd799439011')
+
+// Count & Exists
+const count = await Mongo.collection('users').where('status', 'active').count()
+const exists = await Mongo.collection('users').where('email', 'john@example.com').exists()
+```
+
+### CRUD Operations
+
+```typescript
+// Insert
+const result = await Mongo.collection('users').insert({
+  name: 'John',
+  email: 'john@example.com',
+  createdAt: new Date()
+})
+console.log(result.insertedId)
+
+// Insert Many
+const results = await Mongo.collection('users').insertMany([
+  { name: 'Alice' },
+  { name: 'Bob' }
+])
+
+// Update
+await Mongo.collection('users')
+  .where('_id', userId)
+  .update({ status: 'inactive' })
+
+// Update Many
+await Mongo.collection('users')
+  .where('status', 'pending')
+  .updateMany({ status: 'active' })
+
+// Delete
+await Mongo.collection('users')
+  .where('_id', userId)
+  .delete()
+
+// Delete Many
+await Mongo.collection('users')
+  .where('status', 'deleted')
+  .deleteMany()
+```
+
+### Aggregation Pipeline
+
+```typescript
+// Group and count
+const stats = await Mongo.collection('orders')
+  .aggregate()
+  .match({ status: 'completed' })
+  .group({
+    _id: '$customerId',
+    totalOrders: { $sum: 1 },
+    totalAmount: { $sum: '$amount' }
+  })
+  .sort({ totalAmount: 'desc' })
+  .limit(10)
+  .get()
+
+// Lookup (JOIN)
+const ordersWithCustomers = await Mongo.collection('orders')
+  .aggregate()
+  .lookup({
+    from: 'customers',
+    localField: 'customerId',
+    foreignField: '_id',
+    as: 'customer'
+  })
+  .unwind('$customer')
+  .get()
+
+// Project specific fields
+const projected = await Mongo.collection('users')
+  .aggregate()
+  .project({
+    name: 1,
+    email: 1,
+    fullName: { $concat: ['$firstName', ' ', '$lastName'] }
+  })
+  .get()
+```
+
+### Multiple Connections
+
+```typescript
+Mongo.configure({
+  default: 'main',
+  connections: {
+    main: { uri: 'mongodb://localhost:27017', database: 'app' },
+    analytics: { uri: 'mongodb://analytics.example.com:27017', database: 'analytics' }
+  }
+})
+
+// Use specific connection
+const data = await Mongo.connection('analytics')
+  .collection('events')
+  .where('type', 'pageview')
+  .get()
+```
+
+## Roadmap
+
+- [ ] Schema validation
+- [ ] Transactions
+- [ ] Change streams
+- [ ] GridFS support
+
+## License
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,564 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/index.ts
+var exports_src = {};
+__export(exports_src, {
+  MongoQueryBuilder: () => MongoQueryBuilder,
+  MongoManager: () => MongoManager,
+  MongoClient: () => MongoClient,
+  MongoAggregateBuilder: () => MongoAggregateBuilder,
+  Mongo: () => Mongo
+});
+module.exports = __toCommonJS(exports_src);
+
+// src/MongoQueryBuilder.ts
+class MongoQueryBuilder {
+  nativeCollection;
+  collectionName;
+  filters = {};
+  orFilters = [];
+  projection = {};
+  sortSpec = {};
+  limitCount;
+  skipCount;
+  constructor(nativeCollection, collectionName) {
+    this.nativeCollection = nativeCollection;
+    this.collectionName = collectionName;
+  }
+  where(field, operatorOrValue, value) {
+    if (value === undefined) {
+      this.filters[field] = operatorOrValue;
+    } else {
+      const operator = operatorOrValue;
+      this.filters[field] = this.mapOperator(operator, value);
+    }
+    return this;
+  }
+  orWhere(field, operatorOrValue, value) {
+    const filter = {};
+    if (value === undefined) {
+      filter[field] = operatorOrValue;
+    } else {
+      const operator = operatorOrValue;
+      filter[field] = this.mapOperator(operator, value);
+    }
+    this.orFilters.push(filter);
+    return this;
+  }
+  whereIn(field, values) {
+    this.filters[field] = { $in: values };
+    return this;
+  }
+  whereNotIn(field, values) {
+    this.filters[field] = { $nin: values };
+    return this;
+  }
+  whereNull(field) {
+    this.filters[field] = null;
+    return this;
+  }
+  whereNotNull(field) {
+    this.filters[field] = { $ne: null };
+    return this;
+  }
+  whereExists(field, exists = true) {
+    this.filters[field] = { $exists: exists };
+    return this;
+  }
+  whereRegex(field, pattern) {
+    this.filters[field] = { $regex: pattern };
+    return this;
+  }
+  select(...fields) {
+    for (const field of fields) {
+      this.projection[field] = 1;
+    }
+    return this;
+  }
+  exclude(...fields) {
+    for (const field of fields) {
+      this.projection[field] = 0;
+    }
+    return this;
+  }
+  orderBy(field, direction = "asc") {
+    this.sortSpec[field] = direction === "asc" || direction === 1 ? 1 : -1;
+    return this;
+  }
+  latest(field = "createdAt") {
+    return this.orderBy(field, "desc");
+  }
+  oldest(field = "createdAt") {
+    return this.orderBy(field, "asc");
+  }
+  limit(count) {
+    this.limitCount = count;
+    return this;
+  }
+  skip(count) {
+    this.skipCount = count;
+    return this;
+  }
+  offset(count) {
+    return this.skip(count);
+  }
+  async get() {
+    const cursor = this.nativeCollection.find(this.toFilter(), {
+      projection: Object.keys(this.projection).length > 0 ? this.projection : undefined,
+      sort: Object.keys(this.sortSpec).length > 0 ? this.sortSpec : undefined,
+      limit: this.limitCount,
+      skip: this.skipCount
+    });
+    return await cursor.toArray();
+  }
+  async first() {
+    const result = await this.nativeCollection.findOne(this.toFilter(), {
+      projection: Object.keys(this.projection).length > 0 ? this.projection : undefined,
+      sort: Object.keys(this.sortSpec).length > 0 ? this.sortSpec : undefined
+    });
+    return result;
+  }
+  async find(id) {
+    const { ObjectId } = await this.loadObjectId();
+    const result = await this.nativeCollection.findOne({ _id: new ObjectId(id) }, { projection: Object.keys(this.projection).length > 0 ? this.projection : undefined });
+    return result;
+  }
+  async count() {
+    return await this.nativeCollection.countDocuments(this.toFilter());
+  }
+  async exists() {
+    const count = await this.nativeCollection.countDocuments(this.toFilter(), { limit: 1 });
+    return count > 0;
+  }
+  async distinct(field) {
+    return await this.nativeCollection.distinct(field, this.toFilter());
+  }
+  async insert(document) {
+    const result = await this.nativeCollection.insertOne(document);
+    return {
+      insertedId: result.insertedId.toString(),
+      acknowledged: result.acknowledged
+    };
+  }
+  async insertMany(documents) {
+    const result = await this.nativeCollection.insertMany(documents);
+    return {
+      insertedIds: Object.values(result.insertedIds).map((id) => id.toString()),
+      insertedCount: result.insertedCount,
+      acknowledged: result.acknowledged
+    };
+  }
+  async update(update) {
+    const updateDoc = this.normalizeUpdate(update);
+    const result = await this.nativeCollection.updateOne(this.toFilter(), updateDoc);
+    return {
+      matchedCount: result.matchedCount,
+      modifiedCount: result.modifiedCount,
+      acknowledged: result.acknowledged,
+      ...result.upsertedId ? { upsertedId: result.upsertedId.toString() } : {}
+    };
+  }
+  async updateMany(update) {
+    const updateDoc = this.normalizeUpdate(update);
+    const result = await this.nativeCollection.updateMany(this.toFilter(), updateDoc);
+    return {
+      matchedCount: result.matchedCount,
+      modifiedCount: result.modifiedCount,
+      acknowledged: result.acknowledged,
+      ...result.upsertedId ? { upsertedId: result.upsertedId.toString() } : {}
+    };
+  }
+  async delete() {
+    const result = await this.nativeCollection.deleteOne(this.toFilter());
+    return {
+      deletedCount: result.deletedCount,
+      acknowledged: result.acknowledged
+    };
+  }
+  async deleteMany() {
+    const result = await this.nativeCollection.deleteMany(this.toFilter());
+    return {
+      deletedCount: result.deletedCount,
+      acknowledged: result.acknowledged
+    };
+  }
+  aggregate() {
+    return new MongoAggregateBuilder(this.nativeCollection, this.toFilter());
+  }
+  toFilter() {
+    if (this.orFilters.length === 0) {
+      return { ...this.filters };
+    }
+    return {
+      $or: [this.filters, ...this.orFilters]
+    };
+  }
+  clone() {
+    const cloned = new MongoQueryBuilder(this.nativeCollection, this.collectionName);
+    cloned.filters = { ...this.filters };
+    cloned.orFilters = [...this.orFilters];
+    cloned.projection = { ...this.projection };
+    cloned.sortSpec = { ...this.sortSpec };
+    cloned.limitCount = this.limitCount;
+    cloned.skipCount = this.skipCount;
+    return cloned;
+  }
+  mapOperator(operator, value) {
+    switch (operator) {
+      case "=":
+        return value;
+      case "!=":
+        return { $ne: value };
+      case ">":
+        return { $gt: value };
+      case ">=":
+        return { $gte: value };
+      case "<":
+        return { $lt: value };
+      case "<=":
+        return { $lte: value };
+      case "in":
+        return { $in: value };
+      case "nin":
+        return { $nin: value };
+      case "exists":
+        return { $exists: value };
+      case "regex":
+        return { $regex: value };
+      default:
+        return value;
+    }
+  }
+  normalizeUpdate(update) {
+    const hasOperator = Object.keys(update).some((key) => key.startsWith("$"));
+    if (hasOperator) {
+      return update;
+    }
+    return { $set: update };
+  }
+  async loadObjectId() {
+    const mongodb = await import("mongodb");
+    return mongodb;
+  }
+}
+
+class MongoAggregateBuilder {
+  nativeCollection;
+  pipeline = [];
+  constructor(nativeCollection, initialFilter) {
+    this.nativeCollection = nativeCollection;
+    if (initialFilter && Object.keys(initialFilter).length > 0) {
+      this.pipeline.push({ $match: initialFilter });
+    }
+  }
+  match(filter) {
+    this.pipeline.push({ $match: filter });
+    return this;
+  }
+  group(spec) {
+    this.pipeline.push({ $group: spec });
+    return this;
+  }
+  project(projection) {
+    this.pipeline.push({ $project: projection });
+    return this;
+  }
+  sort(spec) {
+    const normalizedSpec = {};
+    for (const [key, value] of Object.entries(spec)) {
+      normalizedSpec[key] = value === "asc" || value === 1 ? 1 : -1;
+    }
+    this.pipeline.push({ $sort: normalizedSpec });
+    return this;
+  }
+  limit(count) {
+    this.pipeline.push({ $limit: count });
+    return this;
+  }
+  skip(count) {
+    this.pipeline.push({ $skip: count });
+    return this;
+  }
+  unwind(field) {
+    this.pipeline.push({ $unwind: field });
+    return this;
+  }
+  lookup(options) {
+    this.pipeline.push({ $lookup: options });
+    return this;
+  }
+  addFields(fields) {
+    this.pipeline.push({ $addFields: fields });
+    return this;
+  }
+  count(fieldName) {
+    this.pipeline.push({ $count: fieldName });
+    return this;
+  }
+  async get() {
+    const cursor = this.nativeCollection.aggregate(this.pipeline);
+    return await cursor.toArray();
+  }
+  async first() {
+    this.pipeline.push({ $limit: 1 });
+    const results = await this.get();
+    return results[0] ?? null;
+  }
+  toPipeline() {
+    return [...this.pipeline];
+  }
+}
+
+// src/MongoClient.ts
+class MongoClient {
+  config;
+  client = null;
+  db = null;
+  connected = false;
+  mongodb = null;
+  constructor(config = {}) {
+    this.config = config;
+  }
+  async connect() {
+    if (this.connected) {
+      return;
+    }
+    this.mongodb = await this.loadMongoDBModule();
+    const uri = this.buildConnectionUri();
+    const options = {
+      maxPoolSize: this.config.maxPoolSize ?? 10,
+      minPoolSize: this.config.minPoolSize ?? 1
+    };
+    if (this.config.connectTimeoutMS) {
+      options.connectTimeoutMS = this.config.connectTimeoutMS;
+    }
+    if (this.config.socketTimeoutMS) {
+      options.socketTimeoutMS = this.config.socketTimeoutMS;
+    }
+    this.client = new this.mongodb.MongoClient(uri, options);
+    await this.client.connect();
+    const dbName = this.config.database ?? "test";
+    this.db = this.client.db(dbName);
+    this.connected = true;
+  }
+  async disconnect() {
+    if (this.client) {
+      await this.client.close();
+      this.client = null;
+      this.db = null;
+    }
+    this.connected = false;
+  }
+  isConnected() {
+    return this.connected && this.client !== null;
+  }
+  database(name) {
+    const client = this.getClient();
+    const db = name ? client.db(name) : this.db;
+    return new MongoDatabaseWrapper(db);
+  }
+  collection(name) {
+    const db = this.getDatabase();
+    const nativeCollection = db.collection(name);
+    return new MongoQueryBuilder(nativeCollection, name);
+  }
+  buildConnectionUri() {
+    if (this.config.uri) {
+      return this.config.uri;
+    }
+    const host = this.config.host ?? "localhost";
+    const port = this.config.port ?? 27017;
+    const protocol = this.config.tls ? "mongodb+srv" : "mongodb";
+    let uri = `${protocol}://`;
+    if (this.config.username && this.config.password) {
+      uri += `${encodeURIComponent(this.config.username)}:${encodeURIComponent(this.config.password)}@`;
+    }
+    uri += `${host}`;
+    if (!this.config.tls) {
+      uri += `:${port}`;
+    }
+    if (this.config.database) {
+      uri += `/${this.config.database}`;
+    }
+    const params = [];
+    if (this.config.authSource) {
+      params.push(`authSource=${this.config.authSource}`);
+    }
+    if (this.config.replicaSet) {
+      params.push(`replicaSet=${this.config.replicaSet}`);
+    }
+    if (params.length > 0) {
+      uri += `?${params.join("&")}`;
+    }
+    return uri;
+  }
+  async loadMongoDBModule() {
+    try {
+      const mongodb = await import("mongodb");
+      return mongodb;
+    } catch {
+      throw new Error('MongoDB client requires the "mongodb" package. Please install it: bun add mongodb');
+    }
+  }
+  getClient() {
+    if (!this.client) {
+      throw new Error("MongoDB client not connected. Call connect() first.");
+    }
+    return this.client;
+  }
+  getDatabase() {
+    if (!this.db) {
+      throw new Error("MongoDB client not connected. Call connect() first.");
+    }
+    return this.db;
+  }
+}
+
+class MongoDatabaseWrapper {
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  collection(name) {
+    const nativeCollection = this.db.collection(name);
+    return new MongoQueryBuilder(nativeCollection, name);
+  }
+  async listCollections() {
+    const collections = await this.db.listCollections().toArray();
+    return collections.map((c) => c.name);
+  }
+  async dropCollection(name) {
+    return await this.db.dropCollection(name);
+  }
+  async createCollection(name) {
+    await this.db.createCollection(name);
+  }
+}
+
+// src/MongoManager.ts
+class MongoManager {
+  connections = new Map;
+  defaultConnection = "default";
+  configs = new Map;
+  configure(config) {
+    this.defaultConnection = config.default ?? "default";
+    for (const [name, connectionConfig] of Object.entries(config.connections)) {
+      this.configs.set(name, connectionConfig);
+    }
+  }
+  addConnection(name, config) {
+    this.configs.set(name, config);
+  }
+  connection(name) {
+    const connectionName = name ?? this.defaultConnection;
+    if (!this.connections.has(connectionName)) {
+      const config = this.configs.get(connectionName);
+      if (!config) {
+        throw new Error(`MongoDB connection "${connectionName}" not configured`);
+      }
+      this.connections.set(connectionName, new MongoClient(config));
+    }
+    return this.connections.get(connectionName);
+  }
+  getDefault() {
+    return this.connection(this.defaultConnection);
+  }
+  async connectAll() {
+    for (const [name] of this.configs) {
+      const client = this.connection(name);
+      await client.connect();
+    }
+  }
+  async disconnectAll() {
+    for (const client of this.connections.values()) {
+      await client.disconnect();
+    }
+    this.connections.clear();
+  }
+  hasConnection(name) {
+    return this.configs.has(name);
+  }
+  async removeConnection(name) {
+    const client = this.connections.get(name);
+    if (client) {
+      await client.disconnect();
+      this.connections.delete(name);
+    }
+    this.configs.delete(name);
+  }
+}
+
+// src/Mongo.ts
+var manager = new MongoManager;
+
+class Mongo {
+  static configure(config) {
+    manager.configure(config);
+  }
+  static addConnection(name, config) {
+    manager.addConnection(name, config);
+  }
+  static connection(name) {
+    return manager.connection(name);
+  }
+  static async connect() {
+    await manager.getDefault().connect();
+  }
+  static async connectAll() {
+    await manager.connectAll();
+  }
+  static async disconnect() {
+    await manager.getDefault().disconnect();
+  }
+  static async disconnectAll() {
+    await manager.disconnectAll();
+  }
+  static isConnected() {
+    return manager.getDefault().isConnected();
+  }
+  static database(name) {
+    return manager.getDefault().database(name);
+  }
+  static collection(name) {
+    return manager.getDefault().collection(name);
+  }
+}

package/dist/index.mjs

@@ -0,0 +1,538 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/MongoQueryBuilder.ts
+class MongoQueryBuilder {
+  nativeCollection;
+  collectionName;
+  filters = {};
+  orFilters = [];
+  projection = {};
+  sortSpec = {};
+  limitCount;
+  skipCount;
+  constructor(nativeCollection, collectionName) {
+    this.nativeCollection = nativeCollection;
+    this.collectionName = collectionName;
+  }
+  where(field, operatorOrValue, value) {
+    if (value === undefined) {
+      this.filters[field] = operatorOrValue;
+    } else {
+      const operator = operatorOrValue;
+      this.filters[field] = this.mapOperator(operator, value);
+    }
+    return this;
+  }
+  orWhere(field, operatorOrValue, value) {
+    const filter = {};
+    if (value === undefined) {
+      filter[field] = operatorOrValue;
+    } else {
+      const operator = operatorOrValue;
+      filter[field] = this.mapOperator(operator, value);
+    }
+    this.orFilters.push(filter);
+    return this;
+  }
+  whereIn(field, values) {
+    this.filters[field] = { $in: values };
+    return this;
+  }
+  whereNotIn(field, values) {
+    this.filters[field] = { $nin: values };
+    return this;
+  }
+  whereNull(field) {
+    this.filters[field] = null;
+    return this;
+  }
+  whereNotNull(field) {
+    this.filters[field] = { $ne: null };
+    return this;
+  }
+  whereExists(field, exists = true) {
+    this.filters[field] = { $exists: exists };
+    return this;
+  }
+  whereRegex(field, pattern) {
+    this.filters[field] = { $regex: pattern };
+    return this;
+  }
+  select(...fields) {
+    for (const field of fields) {
+      this.projection[field] = 1;
+    }
+    return this;
+  }
+  exclude(...fields) {
+    for (const field of fields) {
+      this.projection[field] = 0;
+    }
+    return this;
+  }
+  orderBy(field, direction = "asc") {
+    this.sortSpec[field] = direction === "asc" || direction === 1 ? 1 : -1;
+    return this;
+  }
+  latest(field = "createdAt") {
+    return this.orderBy(field, "desc");
+  }
+  oldest(field = "createdAt") {
+    return this.orderBy(field, "asc");
+  }
+  limit(count) {
+    this.limitCount = count;
+    return this;
+  }
+  skip(count) {
+    this.skipCount = count;
+    return this;
+  }
+  offset(count) {
+    return this.skip(count);
+  }
+  async get() {
+    const cursor = this.nativeCollection.find(this.toFilter(), {
+      projection: Object.keys(this.projection).length > 0 ? this.projection : undefined,
+      sort: Object.keys(this.sortSpec).length > 0 ? this.sortSpec : undefined,
+      limit: this.limitCount,
+      skip: this.skipCount
+    });
+    return await cursor.toArray();
+  }
+  async first() {
+    const result = await this.nativeCollection.findOne(this.toFilter(), {
+      projection: Object.keys(this.projection).length > 0 ? this.projection : undefined,
+      sort: Object.keys(this.sortSpec).length > 0 ? this.sortSpec : undefined
+    });
+    return result;
+  }
+  async find(id) {
+    const { ObjectId } = await this.loadObjectId();
+    const result = await this.nativeCollection.findOne({ _id: new ObjectId(id) }, { projection: Object.keys(this.projection).length > 0 ? this.projection : undefined });
+    return result;
+  }
+  async count() {
+    return await this.nativeCollection.countDocuments(this.toFilter());
+  }
+  async exists() {
+    const count = await this.nativeCollection.countDocuments(this.toFilter(), { limit: 1 });
+    return count > 0;
+  }
+  async distinct(field) {
+    return await this.nativeCollection.distinct(field, this.toFilter());
+  }
+  async insert(document) {
+    const result = await this.nativeCollection.insertOne(document);
+    return {
+      insertedId: result.insertedId.toString(),
+      acknowledged: result.acknowledged
+    };
+  }
+  async insertMany(documents) {
+    const result = await this.nativeCollection.insertMany(documents);
+    return {
+      insertedIds: Object.values(result.insertedIds).map((id) => id.toString()),
+      insertedCount: result.insertedCount,
+      acknowledged: result.acknowledged
+    };
+  }
+  async update(update) {
+    const updateDoc = this.normalizeUpdate(update);
+    const result = await this.nativeCollection.updateOne(this.toFilter(), updateDoc);
+    return {
+      matchedCount: result.matchedCount,
+      modifiedCount: result.modifiedCount,
+      acknowledged: result.acknowledged,
+      ...result.upsertedId ? { upsertedId: result.upsertedId.toString() } : {}
+    };
+  }
+  async updateMany(update) {
+    const updateDoc = this.normalizeUpdate(update);
+    const result = await this.nativeCollection.updateMany(this.toFilter(), updateDoc);
+    return {
+      matchedCount: result.matchedCount,
+      modifiedCount: result.modifiedCount,
+      acknowledged: result.acknowledged,
+      ...result.upsertedId ? { upsertedId: result.upsertedId.toString() } : {}
+    };
+  }
+  async delete() {
+    const result = await this.nativeCollection.deleteOne(this.toFilter());
+    return {
+      deletedCount: result.deletedCount,
+      acknowledged: result.acknowledged
+    };
+  }
+  async deleteMany() {
+    const result = await this.nativeCollection.deleteMany(this.toFilter());
+    return {
+      deletedCount: result.deletedCount,
+      acknowledged: result.acknowledged
+    };
+  }
+  aggregate() {
+    return new MongoAggregateBuilder(this.nativeCollection, this.toFilter());
+  }
+  toFilter() {
+    if (this.orFilters.length === 0) {
+      return { ...this.filters };
+    }
+    return {
+      $or: [this.filters, ...this.orFilters]
+    };
+  }
+  clone() {
+    const cloned = new MongoQueryBuilder(this.nativeCollection, this.collectionName);
+    cloned.filters = { ...this.filters };
+    cloned.orFilters = [...this.orFilters];
+    cloned.projection = { ...this.projection };
+    cloned.sortSpec = { ...this.sortSpec };
+    cloned.limitCount = this.limitCount;
+    cloned.skipCount = this.skipCount;
+    return cloned;
+  }
+  mapOperator(operator, value) {
+    switch (operator) {
+      case "=":
+        return value;
+      case "!=":
+        return { $ne: value };
+      case ">":
+        return { $gt: value };
+      case ">=":
+        return { $gte: value };
+      case "<":
+        return { $lt: value };
+      case "<=":
+        return { $lte: value };
+      case "in":
+        return { $in: value };
+      case "nin":
+        return { $nin: value };
+      case "exists":
+        return { $exists: value };
+      case "regex":
+        return { $regex: value };
+      default:
+        return value;
+    }
+  }
+  normalizeUpdate(update) {
+    const hasOperator = Object.keys(update).some((key) => key.startsWith("$"));
+    if (hasOperator) {
+      return update;
+    }
+    return { $set: update };
+  }
+  async loadObjectId() {
+    const mongodb = await import("mongodb");
+    return mongodb;
+  }
+}
+
+class MongoAggregateBuilder {
+  nativeCollection;
+  pipeline = [];
+  constructor(nativeCollection, initialFilter) {
+    this.nativeCollection = nativeCollection;
+    if (initialFilter && Object.keys(initialFilter).length > 0) {
+      this.pipeline.push({ $match: initialFilter });
+    }
+  }
+  match(filter) {
+    this.pipeline.push({ $match: filter });
+    return this;
+  }
+  group(spec) {
+    this.pipeline.push({ $group: spec });
+    return this;
+  }
+  project(projection) {
+    this.pipeline.push({ $project: projection });
+    return this;
+  }
+  sort(spec) {
+    const normalizedSpec = {};
+    for (const [key, value] of Object.entries(spec)) {
+      normalizedSpec[key] = value === "asc" || value === 1 ? 1 : -1;
+    }
+    this.pipeline.push({ $sort: normalizedSpec });
+    return this;
+  }
+  limit(count) {
+    this.pipeline.push({ $limit: count });
+    return this;
+  }
+  skip(count) {
+    this.pipeline.push({ $skip: count });
+    return this;
+  }
+  unwind(field) {
+    this.pipeline.push({ $unwind: field });
+    return this;
+  }
+  lookup(options) {
+    this.pipeline.push({ $lookup: options });
+    return this;
+  }
+  addFields(fields) {
+    this.pipeline.push({ $addFields: fields });
+    return this;
+  }
+  count(fieldName) {
+    this.pipeline.push({ $count: fieldName });
+    return this;
+  }
+  async get() {
+    const cursor = this.nativeCollection.aggregate(this.pipeline);
+    return await cursor.toArray();
+  }
+  async first() {
+    this.pipeline.push({ $limit: 1 });
+    const results = await this.get();
+    return results[0] ?? null;
+  }
+  toPipeline() {
+    return [...this.pipeline];
+  }
+}
+
+// src/MongoClient.ts
+class MongoClient {
+  config;
+  client = null;
+  db = null;
+  connected = false;
+  mongodb = null;
+  constructor(config = {}) {
+    this.config = config;
+  }
+  async connect() {
+    if (this.connected) {
+      return;
+    }
+    this.mongodb = await this.loadMongoDBModule();
+    const uri = this.buildConnectionUri();
+    const options = {
+      maxPoolSize: this.config.maxPoolSize ?? 10,
+      minPoolSize: this.config.minPoolSize ?? 1
+    };
+    if (this.config.connectTimeoutMS) {
+      options.connectTimeoutMS = this.config.connectTimeoutMS;
+    }
+    if (this.config.socketTimeoutMS) {
+      options.socketTimeoutMS = this.config.socketTimeoutMS;
+    }
+    this.client = new this.mongodb.MongoClient(uri, options);
+    await this.client.connect();
+    const dbName = this.config.database ?? "test";
+    this.db = this.client.db(dbName);
+    this.connected = true;
+  }
+  async disconnect() {
+    if (this.client) {
+      await this.client.close();
+      this.client = null;
+      this.db = null;
+    }
+    this.connected = false;
+  }
+  isConnected() {
+    return this.connected && this.client !== null;
+  }
+  database(name) {
+    const client = this.getClient();
+    const db = name ? client.db(name) : this.db;
+    return new MongoDatabaseWrapper(db);
+  }
+  collection(name) {
+    const db = this.getDatabase();
+    const nativeCollection = db.collection(name);
+    return new MongoQueryBuilder(nativeCollection, name);
+  }
+  buildConnectionUri() {
+    if (this.config.uri) {
+      return this.config.uri;
+    }
+    const host = this.config.host ?? "localhost";
+    const port = this.config.port ?? 27017;
+    const protocol = this.config.tls ? "mongodb+srv" : "mongodb";
+    let uri = `${protocol}://`;
+    if (this.config.username && this.config.password) {
+      uri += `${encodeURIComponent(this.config.username)}:${encodeURIComponent(this.config.password)}@`;
+    }
+    uri += `${host}`;
+    if (!this.config.tls) {
+      uri += `:${port}`;
+    }
+    if (this.config.database) {
+      uri += `/${this.config.database}`;
+    }
+    const params = [];
+    if (this.config.authSource) {
+      params.push(`authSource=${this.config.authSource}`);
+    }
+    if (this.config.replicaSet) {
+      params.push(`replicaSet=${this.config.replicaSet}`);
+    }
+    if (params.length > 0) {
+      uri += `?${params.join("&")}`;
+    }
+    return uri;
+  }
+  async loadMongoDBModule() {
+    try {
+      const mongodb = await import("mongodb");
+      return mongodb;
+    } catch {
+      throw new Error('MongoDB client requires the "mongodb" package. Please install it: bun add mongodb');
+    }
+  }
+  getClient() {
+    if (!this.client) {
+      throw new Error("MongoDB client not connected. Call connect() first.");
+    }
+    return this.client;
+  }
+  getDatabase() {
+    if (!this.db) {
+      throw new Error("MongoDB client not connected. Call connect() first.");
+    }
+    return this.db;
+  }
+}
+
+class MongoDatabaseWrapper {
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  collection(name) {
+    const nativeCollection = this.db.collection(name);
+    return new MongoQueryBuilder(nativeCollection, name);
+  }
+  async listCollections() {
+    const collections = await this.db.listCollections().toArray();
+    return collections.map((c) => c.name);
+  }
+  async dropCollection(name) {
+    return await this.db.dropCollection(name);
+  }
+  async createCollection(name) {
+    await this.db.createCollection(name);
+  }
+}
+
+// src/MongoManager.ts
+class MongoManager {
+  connections = new Map;
+  defaultConnection = "default";
+  configs = new Map;
+  configure(config) {
+    this.defaultConnection = config.default ?? "default";
+    for (const [name, connectionConfig] of Object.entries(config.connections)) {
+      this.configs.set(name, connectionConfig);
+    }
+  }
+  addConnection(name, config) {
+    this.configs.set(name, config);
+  }
+  connection(name) {
+    const connectionName = name ?? this.defaultConnection;
+    if (!this.connections.has(connectionName)) {
+      const config = this.configs.get(connectionName);
+      if (!config) {
+        throw new Error(`MongoDB connection "${connectionName}" not configured`);
+      }
+      this.connections.set(connectionName, new MongoClient(config));
+    }
+    return this.connections.get(connectionName);
+  }
+  getDefault() {
+    return this.connection(this.defaultConnection);
+  }
+  async connectAll() {
+    for (const [name] of this.configs) {
+      const client = this.connection(name);
+      await client.connect();
+    }
+  }
+  async disconnectAll() {
+    for (const client of this.connections.values()) {
+      await client.disconnect();
+    }
+    this.connections.clear();
+  }
+  hasConnection(name) {
+    return this.configs.has(name);
+  }
+  async removeConnection(name) {
+    const client = this.connections.get(name);
+    if (client) {
+      await client.disconnect();
+      this.connections.delete(name);
+    }
+    this.configs.delete(name);
+  }
+}
+
+// src/Mongo.ts
+var manager = new MongoManager;
+
+class Mongo {
+  static configure(config) {
+    manager.configure(config);
+  }
+  static addConnection(name, config) {
+    manager.addConnection(name, config);
+  }
+  static connection(name) {
+    return manager.connection(name);
+  }
+  static async connect() {
+    await manager.getDefault().connect();
+  }
+  static async connectAll() {
+    await manager.connectAll();
+  }
+  static async disconnect() {
+    await manager.getDefault().disconnect();
+  }
+  static async disconnectAll() {
+    await manager.disconnectAll();
+  }
+  static isConnected() {
+    return manager.getDefault().isConnected();
+  }
+  static database(name) {
+    return manager.getDefault().database(name);
+  }
+  static collection(name) {
+    return manager.getDefault().collection(name);
+  }
+}
+export {
+  MongoQueryBuilder,
+  MongoManager,
+  MongoClient,
+  MongoAggregateBuilder,
+  Mongo
+};

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@gravito/dark-matter",
+  "version": "1.0.0-alpha.2",
+  "description": "MongoDB client for Gravito - Bun native, Laravel-style API",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "bun run build.ts",
+    "test": "bun test",
+    "typecheck": "bunx tsc --noEmit"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "keywords": [
+    "gravito",
+    "mongodb",
+    "nosql",
+    "bun",
+    "document-database"
+  ],
+  "author": "Gravito Team",
+  "license": "MIT",
+  "peerDependencies": {
+    "mongodb": "^6.0.0"
+  },
+  "peerDependenciesMeta": {
+    "mongodb": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "typescript": "^5.0.0"
+  }
+}