@mantiq/database 0.0.1

package/src/drivers/MSSQLConnection.ts

@@ -0,0 +1,154 @@
+import type { DatabaseConnection } from '../contracts/Connection.ts'
+import type { SchemaBuilder } from '../schema/SchemaBuilder.ts'
+import { QueryBuilder } from '../query/Builder.ts'
+import { MSSQLGrammar } from './MSSQLGrammar.ts'
+import { SchemaBuilderImpl } from '../schema/SchemaBuilder.ts'
+import { ConnectionError } from '../errors/ConnectionError.ts'
+import { QueryError } from '../errors/QueryError.ts'
+
+export interface MSSQLConfig {
+  host?: string
+  port?: number
+  database: string
+  user?: string
+  password?: string
+  encrypt?: boolean
+  trustServerCertificate?: boolean
+  pool?: { min?: number; max?: number }
+}
+
+export class MSSQLConnection implements DatabaseConnection {
+  readonly _grammar = new MSSQLGrammar()
+  private pool: any = null
+  private config: MSSQLConfig
+
+  constructor(config: MSSQLConfig) {
+    this.config = config
+  }
+
+  private async getPool(): Promise<any> {
+    if (!this.pool) {
+      try {
+        const mssql = await import('mssql')
+        const sql = mssql.default ?? mssql
+        this.pool = await sql.connect({
+          server: this.config.host ?? 'localhost',
+          port: this.config.port ?? 1433,
+          database: this.config.database,
+          user: this.config.user,
+          password: this.config.password,
+          options: {
+            encrypt: this.config.encrypt ?? false,
+            trustServerCertificate: this.config.trustServerCertificate ?? true,
+          },
+          pool: {
+            min: this.config.pool?.min ?? 2,
+            max: this.config.pool?.max ?? 10,
+          },
+        })
+      } catch (e: any) {
+        throw new ConnectionError(`MSSQL connection failed: ${e.message}`, 'mssql', e)
+      }
+    }
+    return this.pool
+  }
+
+  private addInputs(request: any, bindings: any[]): any {
+    bindings.forEach((val, i) => {
+      request.input(`p${i + 1}`, val)
+    })
+    return request
+  }
+
+  async select(sql: string, bindings: any[] = []): Promise<Record<string, any>[]> {
+    const pool = await this.getPool()
+    try {
+      const request = this.addInputs(pool.request(), bindings)
+      const result = await request.query(sql)
+      return result.recordset ?? []
+    } catch (e: any) {
+      throw new QueryError(sql, bindings, e)
+    }
+  }
+
+  async statement(sql: string, bindings: any[] = []): Promise<number> {
+    const pool = await this.getPool()
+    try {
+      const request = this.addInputs(pool.request(), bindings)
+      const result = await request.query(sql)
+      return result.rowsAffected?.[0] ?? 0
+    } catch (e: any) {
+      throw new QueryError(sql, bindings, e)
+    }
+  }
+
+  async insertGetId(sql: string, bindings: any[] = []): Promise<number | bigint> {
+    const pool = await this.getPool()
+    try {
+      const request = this.addInputs(pool.request(), bindings)
+      const result = await request.query(sql)
+      return result.recordset?.[0]?.id ?? 0
+    } catch (e: any) {
+      throw new QueryError(sql, bindings, e)
+    }
+  }
+
+  async transaction<T>(callback: (connection: DatabaseConnection) => Promise<T>): Promise<T> {
+    const pool = await this.getPool()
+    const mssql = await import('mssql')
+    const sql = mssql.default ?? mssql
+    const transaction = new sql.Transaction(pool)
+    await transaction.begin()
+    try {
+      const txConn: DatabaseConnection = {
+        select: async (s, b = []) => {
+          const req = transaction.request()
+          b.forEach((val: any, i: number) => req.input(`p${i + 1}`, val))
+          const r = await req.query(s)
+          return r.recordset ?? []
+        },
+        statement: async (s, b = []) => {
+          const req = transaction.request()
+          b.forEach((val: any, i: number) => req.input(`p${i + 1}`, val))
+          const r = await req.query(s)
+          return r.rowsAffected?.[0] ?? 0
+        },
+        insertGetId: async (s, b = []) => {
+          const req = transaction.request()
+          b.forEach((val: any, i: number) => req.input(`p${i + 1}`, val))
+          const r = await req.query(s)
+          return r.recordset?.[0]?.id ?? 0
+        },
+        transaction: (cb) => cb(txConn),
+        table: (name) => new QueryBuilder(txConn, name),
+        schema: () => new SchemaBuilderImpl(txConn),
+        getDriverName: () => 'mssql',
+        getTablePrefix: () => '',
+      }
+      // @ts-ignore — attach grammar
+      txConn._grammar = this._grammar
+      const result = await callback(txConn)
+      await transaction.commit()
+      return result
+    } catch (e) {
+      await transaction.rollback()
+      throw e
+    }
+  }
+
+  table(name: string): QueryBuilder {
+    return new QueryBuilder(this, name)
+  }
+
+  schema(): SchemaBuilder {
+    return new SchemaBuilderImpl(this)
+  }
+
+  getDriverName(): string {
+    return 'mssql'
+  }
+
+  getTablePrefix(): string {
+    return ''
+  }
+}

package/src/drivers/MSSQLGrammar.ts

@@ -0,0 +1,106 @@
+import { BaseGrammar } from './BaseGrammar.ts'
+import { Expression } from '../query/Expression.ts'
+import type { QueryState } from '../query/Builder.ts'
+
+export class MSSQLGrammar extends BaseGrammar {
+  quoteIdentifier(name: string): string {
+    if (name.includes('.')) {
+      return name.split('.').map((p) => `[${p}]`).join('.')
+    }
+    return `[${name}]`
+  }
+
+  placeholder(index: number): string {
+    return `@p${index}`
+  }
+
+  /**
+   * MSSQL uses TOP for limit-only and OFFSET…FETCH for pagination.
+   */
+  override compileSelect(state: QueryState): { sql: string; bindings: any[] } {
+    const bindings: any[] = []
+    const parts: string[] = []
+
+    // Collect raw expression bindings from columns first
+    const colBindings: any[] = []
+    for (const c of state.columns) {
+      if (c instanceof Expression) colBindings.push(...c.bindings)
+    }
+
+    const cols = state.columns.map((c) => {
+      if (c instanceof Expression) return c.value
+      const s = c as string
+      if (s === '*' || s.endsWith('.*')) return s
+      return this.quoteIdentifier(s)
+    }).join(', ')
+
+    // TOP n when limit is set but offset is not
+    const useTop = state.limitValue !== null && state.offsetValue === null
+    parts.push(`SELECT ${state.distinct ? 'DISTINCT ' : ''}${useTop ? `TOP ${state.limitValue} ` : ''}${cols}`)
+    parts.push(`FROM ${this.quoteIdentifier(state.table)}`)
+
+    // JOINs
+    for (const j of state.joins) {
+      const type = j.type.toUpperCase()
+      parts.push(`${type} JOIN ${this.quoteIdentifier(j.table)} ON ${j.first} ${j.operator} ${j.second}`)
+    }
+
+    // WHERE
+    if (state.wheres.length) {
+      const { sql: whereSql, bindings: wb } = this.compileWheres(state.wheres, colBindings.length + 1)
+      parts.push(`WHERE ${whereSql}`)
+      bindings.push(...wb)
+    }
+
+    // GROUP BY
+    if (state.groups.length) {
+      parts.push(`GROUP BY ${state.groups.map((g) => this.quoteIdentifier(g)).join(', ')}`)
+    }
+
+    // HAVING
+    if (state.havings.length) {
+      const havingStartIdx = colBindings.length + bindings.length + 1
+      const { sql: havingSql, bindings: hb } = this.compileWheres(state.havings, havingStartIdx)
+      parts.push(`HAVING ${havingSql}`)
+      bindings.push(...hb)
+    }
+
+    // ORDER BY
+    if (state.orders.length) {
+      const orderStr = state.orders.map((o) => {
+        const col = o.column instanceof Expression
+          ? o.column.value
+          : this.quoteIdentifier(o.column as string)
+        return `${col} ${o.direction.toUpperCase()}`
+      }).join(', ')
+      parts.push(`ORDER BY ${orderStr}`)
+    }
+
+    // OFFSET…FETCH pagination (requires ORDER BY)
+    if (state.offsetValue !== null) {
+      if (!state.orders.length) {
+        parts.push('ORDER BY (SELECT NULL)')
+      }
+      parts.push(`OFFSET ${state.offsetValue} ROWS`)
+      if (state.limitValue !== null) {
+        parts.push(`FETCH NEXT ${state.limitValue} ROWS ONLY`)
+      }
+    }
+
+    return { sql: parts.join(' '), bindings: [...colBindings, ...bindings] }
+  }
+
+  override compileInsertGetId(table: string, data: Record<string, any>): { sql: string; bindings: any[] } {
+    const keys = Object.keys(data)
+    const cols = keys.map((k) => this.quoteIdentifier(k)).join(', ')
+    const placeholders = keys.map((_, i) => this.placeholder(i + 1)).join(', ')
+    return {
+      sql: `INSERT INTO ${this.quoteIdentifier(table)} (${cols}) OUTPUT INSERTED.[id] VALUES (${placeholders})`,
+      bindings: Object.values(data),
+    }
+  }
+
+  override compileTruncate(table: string): string {
+    return `TRUNCATE TABLE ${this.quoteIdentifier(table)}`
+  }
+}

package/src/drivers/MongoConnection.ts

@@ -0,0 +1,298 @@
+import type {
+  MongoDatabaseConnection,
+  MongoCollectionContract,
+  MongoFilter,
+  MongoUpdateDoc,
+  MongoPipelineStage,
+  MongoInsertResult,
+  MongoInsertManyResult,
+  MongoUpdateResult,
+  MongoDeleteResult,
+  MongoQueryBuilder,
+} from '../contracts/MongoConnection.ts'
+import { MongoQueryBuilderImpl } from './MongoQueryBuilderImpl.ts'
+import { ConnectionError } from '../errors/ConnectionError.ts'
+import { QueryError } from '../errors/QueryError.ts'
+
+export interface MongoConfig {
+  uri: string
+  database: string
+  options?: Record<string, any>
+}
+
+class MongoCollectionImpl implements MongoCollectionContract {
+  constructor(
+    private readonly col: any,
+    private readonly name: string,
+  ) {}
+
+  find(filter: MongoFilter = {}): MongoQueryBuilder {
+    return new MongoQueryBuilderImpl(
+      this.name,
+      async (opts) => {
+        let cursor = this.col.find(opts.filter ?? {})
+        if (opts.projection) cursor = cursor.project(opts.projection)
+        if (opts.sort) cursor = cursor.sort(opts.sort)
+        if (opts.skip) cursor = cursor.skip(opts.skip)
+        if (opts.limit) cursor = cursor.limit(opts.limit)
+        return cursor.toArray()
+      },
+      async (f) => this.col.countDocuments(f),
+    )
+  }
+
+  async findOne(filter: MongoFilter = {}): Promise<Record<string, any> | null> {
+    return this.col.findOne(filter)
+  }
+
+  async findById(id: any): Promise<Record<string, any> | null> {
+    const { ObjectId } = await import('mongodb')
+    return this.col.findOne({ _id: typeof id === 'string' ? new ObjectId(id) : id })
+  }
+
+  async insertOne(doc: Record<string, any>): Promise<MongoInsertResult> {
+    const result = await this.col.insertOne(doc)
+    return { insertedId: result.insertedId, acknowledged: result.acknowledged }
+  }
+
+  async insertMany(docs: Record<string, any>[]): Promise<MongoInsertManyResult> {
+    const result = await this.col.insertMany(docs)
+    return {
+      insertedIds: Object.values(result.insertedIds),
+      acknowledged: result.acknowledged,
+      insertedCount: result.insertedCount,
+    }
+  }
+
+  async updateOne(filter: MongoFilter, update: MongoUpdateDoc): Promise<MongoUpdateResult> {
+    const result = await this.col.updateOne(filter, update)
+    return { matchedCount: result.matchedCount, modifiedCount: result.modifiedCount, acknowledged: result.acknowledged }
+  }
+
+  async updateMany(filter: MongoFilter, update: MongoUpdateDoc): Promise<MongoUpdateResult> {
+    const result = await this.col.updateMany(filter, update)
+    return { matchedCount: result.matchedCount, modifiedCount: result.modifiedCount, acknowledged: result.acknowledged }
+  }
+
+  async replaceOne(filter: MongoFilter, replacement: Record<string, any>): Promise<MongoUpdateResult> {
+    const result = await this.col.replaceOne(filter, replacement)
+    return { matchedCount: result.matchedCount, modifiedCount: result.modifiedCount, acknowledged: result.acknowledged }
+  }
+
+  async upsert(filter: MongoFilter, update: MongoUpdateDoc): Promise<MongoUpdateResult> {
+    const result = await this.col.updateOne(filter, update, { upsert: true })
+    return { matchedCount: result.matchedCount, modifiedCount: result.modifiedCount, acknowledged: result.acknowledged }
+  }
+
+  async deleteOne(filter: MongoFilter): Promise<MongoDeleteResult> {
+    const result = await this.col.deleteOne(filter)
+    return { deletedCount: result.deletedCount, acknowledged: result.acknowledged }
+  }
+
+  async deleteMany(filter: MongoFilter): Promise<MongoDeleteResult> {
+    const result = await this.col.deleteMany(filter)
+    return { deletedCount: result.deletedCount, acknowledged: result.acknowledged }
+  }
+
+  async aggregate(pipeline: MongoPipelineStage[]): Promise<Record<string, any>[]> {
+    return this.col.aggregate(pipeline).toArray()
+  }
+
+  async count(filter: MongoFilter = {}): Promise<number> {
+    return this.col.countDocuments(filter)
+  }
+
+  async createIndex(spec: Record<string, any>, options?: Record<string, any>): Promise<string> {
+    return this.col.createIndex(spec, options)
+  }
+
+  async drop(): Promise<boolean> {
+    return this.col.drop()
+  }
+}
+
+export class MongoConnection implements MongoDatabaseConnection {
+  private client: any = null
+  private db: any = null
+  private config: MongoConfig
+
+  constructor(config: MongoConfig) {
+    this.config = config
+  }
+
+  private async getDb(): Promise<any> {
+    if (!this.db) {
+      try {
+        const { MongoClient } = await import('mongodb')
+        this.client = new MongoClient(this.config.uri, this.config.options ?? {})
+        await this.client.connect()
+        this.db = this.client.db(this.config.database)
+      } catch (e: any) {
+        throw new ConnectionError(`MongoDB connection failed: ${e.message}`, 'mongodb', e)
+      }
+    }
+    return this.db
+  }
+
+  collection(name: string): MongoCollectionContract {
+    // Lazily get collection — actual DB ops will connect
+    const self = this
+    const col = {
+      async getCol() {
+        const db = await self.getDb()
+        return db.collection(name)
+      },
+    }
+
+    // We need to return a proxy that defers the actual collection resolution
+    return new LazyMongoCollection(name, async () => {
+      const db = await self.getDb()
+      return db.collection(name)
+    })
+  }
+
+  async command(command: Record<string, any>): Promise<any> {
+    const db = await this.getDb()
+    return db.command(command)
+  }
+
+  async listCollections(): Promise<string[]> {
+    const db = await this.getDb()
+    const collections = await db.listCollections().toArray()
+    return collections.map((c: any) => c.name)
+  }
+
+  async transaction<T>(callback: (conn: MongoDatabaseConnection) => Promise<T>): Promise<T> {
+    const client = await this.getClient()
+    const session = client.startSession()
+    try {
+      let result!: T
+      await session.withTransaction(async () => {
+        const txConn = new MongoConnection(this.config)
+        txConn.client = this.client
+        txConn.db = this.db
+        result = await callback(txConn)
+      })
+      return result
+    } finally {
+      await session.endSession()
+    }
+  }
+
+  private async getClient(): Promise<any> {
+    await this.getDb()
+    return this.client
+  }
+
+  getDriverName(): string {
+    return 'mongodb'
+  }
+
+  async disconnect(): Promise<void> {
+    await this.client?.close()
+    this.client = null
+    this.db = null
+  }
+}
+
+class LazyMongoCollection implements MongoCollectionContract {
+  private _col: any = null
+
+  constructor(
+    private readonly name: string,
+    private readonly resolver: () => Promise<any>,
+  ) {}
+
+  private async col(): Promise<any> {
+    if (!this._col) this._col = await this.resolver()
+    return this._col
+  }
+
+  find(filter: MongoFilter = {}): MongoQueryBuilder {
+    return new MongoQueryBuilderImpl(
+      this.name,
+      async (opts) => {
+        const c = await this.col()
+        let cursor = c.find(opts.filter ?? {})
+        if (opts.projection) cursor = cursor.project(opts.projection)
+        if (opts.sort) cursor = cursor.sort(opts.sort)
+        if (opts.skip) cursor = cursor.skip(opts.skip)
+        if (opts.limit) cursor = cursor.limit(opts.limit)
+        return cursor.toArray()
+      },
+      async (f) => {
+        const c = await this.col()
+        return c.countDocuments(f)
+      },
+    )
+  }
+
+  async findOne(filter: MongoFilter = {}): Promise<Record<string, any> | null> {
+    return (await this.col()).findOne(filter)
+  }
+
+  async findById(id: any): Promise<Record<string, any> | null> {
+    const { ObjectId } = await import('mongodb')
+    return (await this.col()).findOne({ _id: typeof id === 'string' ? new ObjectId(id) : id })
+  }
+
+  async insertOne(doc: Record<string, any>): Promise<MongoInsertResult> {
+    const result = await (await this.col()).insertOne(doc)
+    return { insertedId: result.insertedId, acknowledged: result.acknowledged }
+  }
+
+  async insertMany(docs: Record<string, any>[]): Promise<MongoInsertManyResult> {
+    const result = await (await this.col()).insertMany(docs)
+    return {
+      insertedIds: Object.values(result.insertedIds),
+      acknowledged: result.acknowledged,
+      insertedCount: result.insertedCount,
+    }
+  }
+
+  async updateOne(filter: MongoFilter, update: MongoUpdateDoc): Promise<MongoUpdateResult> {
+    const result = await (await this.col()).updateOne(filter, update)
+    return { matchedCount: result.matchedCount, modifiedCount: result.modifiedCount, acknowledged: result.acknowledged }
+  }
+
+  async updateMany(filter: MongoFilter, update: MongoUpdateDoc): Promise<MongoUpdateResult> {
+    const result = await (await this.col()).updateMany(filter, update)
+    return { matchedCount: result.matchedCount, modifiedCount: result.modifiedCount, acknowledged: result.acknowledged }
+  }
+
+  async replaceOne(filter: MongoFilter, replacement: Record<string, any>): Promise<MongoUpdateResult> {
+    const result = await (await this.col()).replaceOne(filter, replacement)
+    return { matchedCount: result.matchedCount, modifiedCount: result.modifiedCount, acknowledged: result.acknowledged }
+  }
+
+  async upsert(filter: MongoFilter, update: MongoUpdateDoc): Promise<MongoUpdateResult> {
+    const result = await (await this.col()).updateOne(filter, update, { upsert: true })
+    return { matchedCount: result.matchedCount, modifiedCount: result.modifiedCount, acknowledged: result.acknowledged }
+  }
+
+  async deleteOne(filter: MongoFilter): Promise<MongoDeleteResult> {
+    const result = await (await this.col()).deleteOne(filter)
+    return { deletedCount: result.deletedCount, acknowledged: result.acknowledged }
+  }
+
+  async deleteMany(filter: MongoFilter): Promise<MongoDeleteResult> {
+    const result = await (await this.col()).deleteMany(filter)
+    return { deletedCount: result.deletedCount, acknowledged: result.acknowledged }
+  }
+
+  async aggregate(pipeline: MongoPipelineStage[]): Promise<Record<string, any>[]> {
+    return (await this.col()).aggregate(pipeline).toArray()
+  }
+
+  async count(filter: MongoFilter = {}): Promise<number> {
+    return (await this.col()).countDocuments(filter)
+  }
+
+  async createIndex(spec: Record<string, any>, options?: Record<string, any>): Promise<string> {
+    return (await this.col()).createIndex(spec, options)
+  }
+
+  async drop(): Promise<boolean> {
+    return (await this.col()).drop()
+  }
+}

package/src/drivers/MongoQueryBuilderImpl.ts

@@ -0,0 +1,77 @@
+import type {
+  MongoFilter,
+  MongoProjection,
+  MongoSortDoc,
+  MongoQueryBuilder,
+} from '../contracts/MongoConnection.ts'
+import { ModelNotFoundError } from '../errors/ModelNotFoundError.ts'
+
+export class MongoQueryBuilderImpl implements MongoQueryBuilder {
+  private _filter: MongoFilter = {}
+  private _projection: MongoProjection | undefined
+  private _sort: MongoSortDoc | undefined
+  private _limit: number | undefined
+  private _skip: number | undefined
+
+  constructor(
+    private readonly collectionName: string,
+    private readonly executor: (opts: {
+      filter: MongoFilter
+      projection?: MongoProjection
+      sort?: MongoSortDoc
+      limit?: number
+      skip?: number
+    }) => Promise<Record<string, any>[]>,
+    private readonly counter: (filter: MongoFilter) => Promise<number>,
+  ) {}
+
+  where(filter: MongoFilter): this {
+    this._filter = { ...this._filter, ...filter }
+    return this
+  }
+
+  select(projection: MongoProjection): this {
+    this._projection = projection
+    return this
+  }
+
+  sort(sort: MongoSortDoc): this {
+    this._sort = sort
+    return this
+  }
+
+  limit(n: number): this {
+    this._limit = n
+    return this
+  }
+
+  skip(n: number): this {
+    this._skip = n
+    return this
+  }
+
+  async get(): Promise<Record<string, any>[]> {
+    return this.executor({
+      filter: this._filter,
+      projection: this._projection,
+      sort: this._sort,
+      limit: this._limit,
+      skip: this._skip,
+    })
+  }
+
+  async first(): Promise<Record<string, any> | null> {
+    const results = await this.limit(1).get()
+    return results[0] ?? null
+  }
+
+  async firstOrFail(): Promise<Record<string, any>> {
+    const row = await this.first()
+    if (!row) throw new ModelNotFoundError(this.collectionName)
+    return row
+  }
+
+  async count(): Promise<number> {
+    return this.counter(this._filter)
+  }
+}