@mountsqli/mongodb 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,91 @@
+import { Table, TableConfig, Column, Session, Logger, QueryWithTypings, PreparedQuery, Driver } from '@mountsqli/core';
+
+/**
+ * MongoDB collection factory.
+ */
+
+declare class MongoCollection$1 extends Table<TableConfig & {
+    dialect: 'mongo';
+}> {
+}
+type MongoCollectionColumns = Record<string, Column>;
+declare function mongoCollection<TColumns extends MongoCollectionColumns>(name: string, columns: TColumns): MongoCollection$1 & {
+    columns: TColumns;
+};
+
+/**
+ * MongoDB session — wraps native MongoDB driver.
+ */
+
+interface MongoDb {
+    collection(name: string): MongoCollection;
+    close(): Promise<void>;
+}
+interface MongoCollection {
+    find(filter?: any, options?: any): MongoCursor;
+    findOne(filter?: any, options?: any): Promise<any>;
+    insertOne(doc: any): Promise<{
+        insertedId: any;
+    }>;
+    insertMany(docs: any[]): Promise<{
+        insertedIds: any[];
+    }>;
+    updateOne(filter: any, update: any): Promise<any>;
+    updateMany(filter: any, update: any): Promise<any>;
+    deleteOne(filter: any): Promise<any>;
+    deleteMany(filter: any): Promise<any>;
+    aggregate(pipeline: any[]): MongoCursor;
+    countDocuments(filter?: any): Promise<number>;
+}
+interface MongoCursor {
+    toArray(): Promise<any[]>;
+    sort(spec: any): MongoCursor;
+    limit(n: number): MongoCursor;
+    skip(n: number): MongoCursor;
+    project(spec: any): MongoCursor;
+}
+declare class MongoSession extends Session {
+    private _db;
+    constructor(db: MongoDb, logger: Logger);
+    execute<T>(query: QueryWithTypings): Promise<T>;
+    prepare<T>(query: QueryWithTypings): PreparedQuery<T>;
+    transaction<T>(fn: (tx: any) => Promise<T>): Promise<T>;
+    dispose(): Promise<void>;
+}
+declare class MongoTransaction extends Session {
+    private _db;
+    constructor(db: MongoDb, logger: Logger);
+    execute<T>(query: QueryWithTypings): Promise<T>;
+    prepare<T>(query: QueryWithTypings): PreparedQuery<T>;
+    transaction<T>(fn: (tx: any) => Promise<T>): Promise<T>;
+    rollback(): Promise<never>;
+    commit(): Promise<void>;
+    setTransactionIsolation(_level: string): Promise<void>;
+    dispose(): Promise<void>;
+}
+
+/**
+ * MongoDB native driver.
+ */
+
+interface MongoNativeDriverConfig {
+    /** MongoDB connection URI */
+    uri: string;
+    /** Database name */
+    database: string;
+    logger?: Logger | boolean;
+}
+declare class MongoNativeDriver implements Driver {
+    readonly dialect: "mongo";
+    private _config;
+    private _client;
+    private _db;
+    private _logger;
+    constructor(config: MongoNativeDriverConfig);
+    createSession(): MongoSession;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    ping(): Promise<boolean>;
+}
+
+export { MongoCollection$1 as MongoCollection, type MongoCollectionColumns, MongoNativeDriver, MongoSession, MongoTransaction, mongoCollection };

package/dist/index.js

@@ -0,0 +1,133 @@
+// src/mongo-core/collection.ts
+import { Table } from "@mountsqli/core";
+var MongoCollection = class extends Table {
+};
+function mongoCollection(name, columns) {
+  const collection = new MongoCollection(name, void 0, name);
+  for (const [key, col] of Object.entries(columns)) {
+    collection.columns[key] = col;
+    col.tableName = name;
+  }
+  const result = collection;
+  result.columns = columns;
+  return result;
+}
+
+// src/mongo-core/session.ts
+import { Session } from "@mountsqli/core";
+var MongoPreparedQuery = class {
+  _operation;
+  constructor(operation) {
+    this._operation = operation;
+  }
+  async execute() {
+    return this._operation();
+  }
+  async all() {
+    const result = await this._operation();
+    return Array.isArray(result) ? result : [result];
+  }
+  async values() {
+    const rows = await this.all();
+    return rows.map((row) => Object.values(row));
+  }
+  getQuery() {
+    return { sql: "mongo", params: [] };
+  }
+};
+var MongoSession = class extends Session {
+  _db;
+  constructor(db, logger) {
+    super(logger);
+    this._db = db;
+  }
+  async execute(query) {
+    throw new Error("MongoDB execute not directly supported \u2014 use collection methods");
+  }
+  prepare(query) {
+    return new MongoPreparedQuery(async () => {
+      return this.execute(query);
+    });
+  }
+  async transaction(fn) {
+    const tx = new MongoTransaction(this._db, this.logger);
+    return fn(tx);
+  }
+  async dispose() {
+    await this._db.close();
+  }
+};
+var MongoTransaction = class _MongoTransaction extends Session {
+  _db;
+  constructor(db, logger) {
+    super(logger);
+    this._db = db;
+    this.inTransaction = true;
+  }
+  async execute(query) {
+    throw new Error("MongoDB transaction execute not directly supported");
+  }
+  prepare(query) {
+    return new MongoPreparedQuery(async () => {
+      return this.execute(query);
+    });
+  }
+  async transaction(fn) {
+    const tx = new _MongoTransaction(this._db, this.logger);
+    return fn(tx);
+  }
+  async rollback() {
+    throw new Error("Transaction rolled back");
+  }
+  async commit() {
+  }
+  async setTransactionIsolation(_level) {
+  }
+  async dispose() {
+  }
+};
+
+// src/drivers/native/driver.ts
+import { createLogger } from "@mountsqli/core";
+var MongoNativeDriver = class {
+  dialect = "mongo";
+  _config;
+  _client = null;
+  _db = null;
+  _logger;
+  constructor(config) {
+    this._config = config;
+    this._logger = typeof config.logger === "boolean" ? createLogger({ enabled: config.logger }) : config.logger ?? createLogger({ enabled: false });
+  }
+  createSession() {
+    if (!this._db) throw new Error("Not connected");
+    return new MongoSession(this._db, this._logger);
+  }
+  async connect() {
+    const { MongoClient } = await import("mongodb");
+    this._client = new MongoClient(this._config.uri);
+    await this._client.connect();
+    this._db = this._client.db(this._config.database);
+  }
+  async disconnect() {
+    if (this._client) {
+      await this._client.close();
+      this._client = null;
+      this._db = null;
+    }
+  }
+  async ping() {
+    try {
+      await this._client?.db(this._config.database).command({ ping: 1 });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+export {
+  MongoNativeDriver,
+  MongoSession,
+  MongoTransaction,
+  mongoCollection
+};

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@mountsqli/mongodb",
+  "version": "0.1.0",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": ["dist", "LICENSE", "README.md"],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "dev": "tsup --watch",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "@mountsqli/core": "workspace:*",
+    "@mountsqli/shared": "workspace:*"
+  },
+  "peerDependencies": {
+    "mongodb": "^6.0.0"
+  },
+  "peerDependenciesMeta": {
+    "mongodb": { "optional": true }
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.7.0",
+    "tsup": "^8.0.0",
+    "vitest": "^3.0.0"
+  }
+}