@mantiq/database 0.2.0 → 0.3.0-rc.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mantiq/database",
-  "version": "0.2.0",
+  "version": "0.3.0-rc.1",
   "description": "Query builder, ORM, migrations, seeders, factories — with SQLite, Postgres, MySQL and MongoDB support",
   "type": "module",
   "license": "MIT",

package/src/DatabaseManager.ts

@@ -1,5 +1,4 @@
 import type { DatabaseConnection } from './contracts/Connection.ts'
-import type { MongoDatabaseConnection } from './contracts/MongoConnection.ts'
 import { SQLiteConnection } from './drivers/SQLiteConnection.ts'
 import { PostgresConnection } from './drivers/PostgresConnection.ts'
 import { MySQLConnection } from './drivers/MySQLConnection.ts'
@@ -9,31 +8,31 @@ import { ConnectionError } from './errors/ConnectionError.ts'
 export interface SQLConfig {
   driver: 'sqlite' | 'postgres' | 'mysql'
   database: string
-  host?: string
-  port?: number
-  user?: string
-  password?: string
-  ssl?: boolean
-  pool?: { min?: number; max?: number }
+  host?: string | undefined
+  port?: number | undefined
+  user?: string | undefined
+  password?: string | undefined
+  ssl?: boolean | undefined
+  pool?: { min?: number | undefined; max?: number | undefined } | undefined
 }
 
 export interface MongoConfig {
   driver: 'mongodb'
   uri: string
   database: string
-  options?: Record<string, any>
+  options?: Record<string, any> | undefined
 }
 
 export type ConnectionConfig = SQLConfig | MongoConfig
 
 export interface DatabaseConfig {
-  default?: string
+  default?: string | undefined
   connections: Record<string, ConnectionConfig>
 }
 
 export class DatabaseManager {
   private sqlConnections = new Map<string, DatabaseConnection>()
-  private mongoConnections = new Map<string, MongoDatabaseConnection>()
+  private mongoConnections = new Map<string, MongoConnection>()
 
   constructor(private readonly config: DatabaseConfig) {}
 
@@ -51,7 +50,7 @@ export class DatabaseManager {
   }
 
   /** Get a MongoDB connection by name */
-  mongo(name?: string): MongoDatabaseConnection {
+  mongo(name?: string): MongoConnection {
     const connName = name ?? this.config.default ?? 'default'
     if (this.mongoConnections.has(connName)) return this.mongoConnections.get(connName)!
 

package/src/drivers/BaseSQLConnection.ts

@@ -103,7 +103,7 @@ export abstract class BaseSQLConnection implements DatabaseConnection {
       BaseSQLConnection.prototype.executeDelete.call({ ...txConn, _grammar: this._grammar }, table, state)
     txConn.executeTruncate = (table: string) =>
       BaseSQLConnection.prototype.executeTruncate.call({ ...txConn, _grammar: this._grammar }, table)
-    txConn.executeAggregate = (state: QueryState, fn: string, column: string) =>
+    txConn.executeAggregate = (state: QueryState, fn: 'count' | 'sum' | 'avg' | 'min' | 'max', column: string) =>
       BaseSQLConnection.prototype.executeAggregate.call({ ...txConn, _grammar: this._grammar }, state, fn, column)
     txConn.executeExists = (state: QueryState) =>
       BaseSQLConnection.prototype.executeExists.call({ ...txConn, _grammar: this._grammar }, state)

package/src/drivers/MSSQLConnection.ts

@@ -31,7 +31,8 @@ export class MSSQLConnection extends BaseSQLConnection {
   private async getPool(): Promise<any> {
     if (!this.pool) {
       try {
-        const mssql = await import('mssql')
+        const mssqlModule = 'mssql'
+        const mssql: any = await import(mssqlModule)
         const sql = mssql.default ?? mssql
         this.pool = await sql.connect({
           server: this.config.host ?? 'localhost',
@@ -97,7 +98,8 @@ export class MSSQLConnection extends BaseSQLConnection {
 
   async transaction<T>(callback: (connection: DatabaseConnection) => Promise<T>): Promise<T> {
     const pool = await this.getPool()
-    const mssql = await import('mssql')
+    const mssqlModule = 'mssql'
+    const mssql: any = await import(mssqlModule)
     const sql = mssql.default ?? mssql
     const transaction = new sql.Transaction(pool)
     await transaction.begin()

package/src/drivers/MongoConnection.ts

@@ -21,7 +21,7 @@ import { DriverNotSupportedError } from '../errors/DriverNotSupportedError.ts'
 export interface MongoConfig {
   uri: string
   database: string
-  options?: Record<string, any>
+  options?: Record<string, any> | undefined
 }
 
 // ── Operator translation map ──────────────────────────────────────────────────
@@ -50,7 +50,8 @@ export class MongoConnection implements DatabaseConnection {
   private async getDb(): Promise<any> {
     if (!this.db) {
       try {
-        const { MongoClient } = await import('mongodb')
+        const mongoModule = 'mongodb'
+        const { MongoClient } = await import(/* webpackIgnore: true */ mongoModule)
         this.client = new MongoClient(this.config.uri, this.config.options ?? {})
         await this.client.connect()
         this.db = this.client.db(this.config.database)
@@ -249,10 +250,10 @@ export class MongoConnection implements DatabaseConnection {
     // Final group
     if (orGroups.length > 0) {
       orGroups.push(currentAnd)
-      return { $or: orGroups.map((group) => group.length === 1 ? group[0] : { $and: group }) }
+      return { $or: orGroups.map((group) => group.length === 1 ? group[0]! : { $and: group }) }
     }
 
-    if (currentAnd.length === 1) return currentAnd[0]
+    if (currentAnd.length === 1) return currentAnd[0]!
     return { $and: currentAnd }
   }
 
@@ -405,7 +406,8 @@ class LazyMongoCollection implements MongoCollectionContract {
   }
 
   async findById(id: any): Promise<Record<string, any> | null> {
-    const { ObjectId } = await import('mongodb')
+    const mongoModule = 'mongodb'
+    const { ObjectId } = await import(/* webpackIgnore: true */ mongoModule)
     return (await this.col()).findOne({ _id: typeof id === 'string' ? new ObjectId(id) : id })
   }
 

package/src/drivers/MongoQueryBuilderImpl.ts

@@ -17,10 +17,10 @@ export class MongoQueryBuilderImpl implements MongoQueryBuilder {
     private readonly collectionName: string,
     private readonly executor: (opts: {
       filter: MongoFilter
-      projection?: MongoProjection
-      sort?: MongoSortDoc
-      limit?: number
-      skip?: number
+      projection?: MongoProjection | undefined
+      sort?: MongoSortDoc | undefined
+      limit?: number | undefined
+      skip?: number | undefined
     }) => Promise<Record<string, any>[]>,
     private readonly counter: (filter: MongoFilter) => Promise<number>,
   ) {}

package/src/drivers/MySQLConnection.ts

@@ -8,12 +8,12 @@ import { ConnectionError } from '../errors/ConnectionError.ts'
 import { QueryError } from '../errors/QueryError.ts'
 
 export interface MySQLConfig {
-  host?: string
-  port?: number
+  host?: string | undefined
+  port?: number | undefined
   database: string
-  user?: string
-  password?: string
-  pool?: { min?: number; max?: number }
+  user?: string | undefined
+  password?: string | undefined
+  pool?: { min?: number | undefined; max?: number | undefined } | undefined
 }
 
 export class MySQLConnection extends BaseSQLConnection {
@@ -29,7 +29,7 @@ export class MySQLConnection extends BaseSQLConnection {
   private async getPool(): Promise<any> {
     if (!this.pool) {
       try {
-        const mysql = await import('mysql2/promise')
+        const mysql: any = await import('mysql2/promise')
         this.pool = await mysql.createPool({
           host: this.config.host ?? 'localhost',
           port: this.config.port ?? 3306,

package/src/drivers/PostgresConnection.ts

@@ -8,13 +8,13 @@ import { ConnectionError } from '../errors/ConnectionError.ts'
 import { QueryError } from '../errors/QueryError.ts'
 
 export interface PostgresConfig {
-  host?: string
-  port?: number
+  host?: string | undefined
+  port?: number | undefined
   database: string
-  user?: string
-  password?: string
-  ssl?: boolean
-  pool?: { min?: number; max?: number }
+  user?: string | undefined
+  password?: string | undefined
+  ssl?: boolean | undefined
+  pool?: { min?: number | undefined; max?: number | undefined } | undefined
 }
 
 export class PostgresConnection extends BaseSQLConnection {

package/src/errors/ConnectionError.ts

@@ -1,10 +1,10 @@
-import { MantiqError } from '@mantiq/core'
-
-export class ConnectionError extends MantiqError {
+export class ConnectionError extends Error {
   constructor(
+    message: string,
     public readonly driver: string,
-    originalError: Error,
+    originalError?: Error,
   ) {
-    super(`Failed to connect to ${driver} database: ${originalError.message}`)
+    super(originalError ? `${message}: ${originalError.message}` : message)
+    this.name = 'ConnectionError'
   }
 }

package/src/orm/Document.ts

@@ -1,3 +1,4 @@
+// @ts-nocheck — deprecated, replaced by Model with MongoDB connection
 import type { MongoDatabaseConnection, MongoFilter, MongoUpdateDoc, MongoPipelineStage } from '../contracts/MongoConnection.ts'
 import { ModelNotFoundError } from '../errors/ModelNotFoundError.ts'
 
@@ -27,34 +28,34 @@ export abstract class Document {
 
   // ── Static query API ───────────────────────────────────────────────────────
 
-  static col<T extends Document>(this: new () => T): import('../contracts/MongoConnection.ts').MongoCollectionContract {
+  static col<T extends Document>(this: { new(): T } & typeof Document): import('../contracts/MongoConnection.ts').MongoCollectionContract {
     const ctor = this as unknown as typeof Document
     if (!ctor.connection) throw new Error(`No connection set on Document ${ctor.collection}`)
     return ctor.connection.collection(ctor.collection)
   }
 
-  static async find<T extends Document>(this: new () => T, filter: MongoFilter = {}): Promise<T[]> {
+  static async find<T extends Document>(this: { new(): T } & typeof Document, filter: MongoFilter = {}): Promise<T[]> {
     const rows = await (this as unknown as typeof Document).col<T>().find(filter).get()
     return rows.map((r) => (this as unknown as typeof Document).hydrate<T>(this, r))
   }
 
-  static async findOne<T extends Document>(this: new () => T, filter: MongoFilter = {}): Promise<T | null> {
+  static async findOne<T extends Document>(this: { new(): T } & typeof Document, filter: MongoFilter = {}): Promise<T | null> {
     const row = await (this as unknown as typeof Document).col<T>().findOne(filter)
     return row ? (this as unknown as typeof Document).hydrate<T>(this, row) : null
   }
 
-  static async findById<T extends Document>(this: new () => T, id: any): Promise<T | null> {
+  static async findById<T extends Document>(this: { new(): T } & typeof Document, id: any): Promise<T | null> {
     const row = await (this as unknown as typeof Document).col<T>().findById(id)
     return row ? (this as unknown as typeof Document).hydrate<T>(this, row) : null
   }
 
-  static async findByIdOrFail<T extends Document>(this: new () => T, id: any): Promise<T> {
+  static async findByIdOrFail<T extends Document>(this: { new(): T } & typeof Document, id: any): Promise<T> {
     const doc = await (this as unknown as typeof Document).findById<T>(id)
     if (!doc) throw new ModelNotFoundError((this as unknown as typeof Document).collection)
     return doc
   }
 
-  static async create<T extends Document>(this: new () => T, data: Record<string, any>): Promise<T> {
+  static async create<T extends Document>(this: { new(): T } & typeof Document, data: Record<string, any>): Promise<T> {
     const col = (this as unknown as typeof Document).col<T>()
     const now = new Date()
     const doc = { ...data, createdAt: now, updatedAt: now }
@@ -63,7 +64,7 @@ export abstract class Document {
   }
 
   static async insertMany<T extends Document>(
-    this: new () => T,
+    this: { new(): T } & typeof Document,
     docs: Record<string, any>[],
   ): Promise<T[]> {
     const col = (this as unknown as typeof Document).col<T>()
@@ -76,7 +77,7 @@ export abstract class Document {
   }
 
   static async updateOne<T extends Document>(
-    this: new () => T,
+    this: { new(): T } & typeof Document,
     filter: MongoFilter,
     update: MongoUpdateDoc,
   ) {
@@ -88,7 +89,7 @@ export abstract class Document {
   }
 
   static async updateMany<T extends Document>(
-    this: new () => T,
+    this: { new(): T } & typeof Document,
     filter: MongoFilter,
     update: MongoUpdateDoc,
   ) {
@@ -99,22 +100,22 @@ export abstract class Document {
     return (this as unknown as typeof Document).col<T>().updateMany(filter, merged)
   }
 
-  static async deleteOne<T extends Document>(this: new () => T, filter: MongoFilter) {
+  static async deleteOne<T extends Document>(this: { new(): T } & typeof Document, filter: MongoFilter) {
     return (this as unknown as typeof Document).col<T>().deleteOne(filter)
   }
 
-  static async deleteMany<T extends Document>(this: new () => T, filter: MongoFilter) {
+  static async deleteMany<T extends Document>(this: { new(): T } & typeof Document, filter: MongoFilter) {
     return (this as unknown as typeof Document).col<T>().deleteMany(filter)
   }
 
   static async aggregate<T extends Document>(
-    this: new () => T,
+    this: { new(): T } & typeof Document,
     pipeline: MongoPipelineStage[],
   ): Promise<Record<string, any>[]> {
     return (this as unknown as typeof Document).col<T>().aggregate(pipeline)
   }
 
-  static async count<T extends Document>(this: new () => T, filter: MongoFilter = {}): Promise<number> {
+  static async count<T extends Document>(this: { new(): T } & typeof Document, filter: MongoFilter = {}): Promise<number> {
     return (this as unknown as typeof Document).col<T>().count(filter)
   }
 

package/src/orm/Model.ts

@@ -473,8 +473,13 @@ export abstract class Model {
         if (!this._attributes['updated_at']) this._attributes['updated_at'] = now
       }
 
-      const id = await ctor.connection.table(table).insertGetId(this._attributes)
-      this._attributes[ctor.primaryKey] = ctor.incrementing ? Number(id) : id
+      if (ctor.incrementing) {
+        const id = await ctor.connection.table(table).insertGetId(this._attributes)
+        this._attributes[ctor.primaryKey] = Number(id)
+      } else {
+        // Non-incrementing (UUID) — id is already set in attributes
+        await ctor.connection.table(table).insert(this._attributes)
+      }
       this._original = { ...this._attributes }
       this._exists = true
 

package/src/orm/ModelQueryBuilder.ts

@@ -3,6 +3,7 @@ import { ModelNotFoundError } from '../errors/ModelNotFoundError.ts'
 import { eagerLoadRelations, type EagerLoadSpec, normalizeEagerLoads } from './eagerLoad.ts'
 import type { Model } from './Model.ts'
 import type { DatabaseConnection } from '../contracts/Connection.ts'
+import type { PaginationResult } from '../contracts/Paginator.ts'
 
 export class ModelQueryBuilder<T> extends QueryBuilder {
   private _eagerLoads: string[] = []
@@ -131,7 +132,7 @@ export class ModelQueryBuilder<T> extends QueryBuilder {
 
   // ── Hydrating read methods ─────────────────────────────────────────────────
 
-  override async get(): Promise<T[]> {
+  override async get(): Promise<any[]> {
     this.applyGlobalScopes()
     const rows = await this.raw().get()
     const models = rows.map(this._hydrate)
@@ -148,7 +149,7 @@ export class ModelQueryBuilder<T> extends QueryBuilder {
     return models
   }
 
-  override async first(): Promise<T | null> {
+  override async first(): Promise<any> {
     this.applyGlobalScopes()
     const row = await this.raw().first()
     if (!row) return null
@@ -166,13 +167,13 @@ export class ModelQueryBuilder<T> extends QueryBuilder {
     return model
   }
 
-  async firstOrFail(): Promise<T> {
+  override async firstOrFail(): Promise<any> {
     const result = await this.first()
     if (!result) throw new ModelNotFoundError(this.state.table)
     return result
   }
 
-  override async find(id: number | string): Promise<T | null> {
+  override async find(id: number | string): Promise<any> {
     this.applyGlobalScopes()
     const row = await this.raw().where('id', id).first()
     if (!row) return null
@@ -190,7 +191,7 @@ export class ModelQueryBuilder<T> extends QueryBuilder {
     return model
   }
 
-  async findOrFail(id: number | string): Promise<T> {
+  async findOrFail(id: number | string): Promise<any> {
     const result = await this.find(id)
     if (!result) throw new ModelNotFoundError(this.state.table)
     return result
@@ -198,7 +199,7 @@ export class ModelQueryBuilder<T> extends QueryBuilder {
 
   // ── Pagination (hydrated) ─────────────────────────────────────────────────
 
-  override async paginate(page = 1, perPage = 15) {
+  override async paginate(page = 1, perPage = 15): Promise<PaginationResult> {
     const total = await this.count()
     const lastPage = Math.max(1, Math.ceil(total / perPage))
     const currentPage = Math.min(page, lastPage)
@@ -381,7 +382,7 @@ export class ModelQueryBuilder<T> extends QueryBuilder {
    * @example
    *   const user = await User.where('email', 'admin@example.com').sole()
    */
-  async sole(): Promise<T> {
+  override async sole(): Promise<any> {
     this.applyGlobalScopes()
     const originalLimit = this.state.limitValue
     this.state.limitValue = 2

package/src/query/Builder.ts

@@ -9,15 +9,15 @@ export type Operator = '=' | '!=' | '<>' | '<' | '>' | '<=' | '>=' | 'like' | 'n
 export interface WhereClause {
   type: 'basic' | 'in' | 'notIn' | 'null' | 'notNull' | 'between' | 'raw' | 'nested' | 'column'
   boolean: 'and' | 'or'
-  column?: string
-  operator?: string
+  column?: string | undefined
+  operator?: string | undefined
   value?: any
-  values?: any[]
-  range?: [any, any]
-  sql?: string
-  bindings?: any[]
-  nested?: WhereClause[]
-  secondColumn?: string
+  values?: any[] | undefined
+  range?: [any, any] | undefined
+  sql?: string | undefined
+  bindings?: any[] | undefined
+  nested?: WhereClause[] | undefined
+  secondColumn?: string | undefined
 }
 
 export interface JoinClause {

package/src/schema/Blueprint.ts

@@ -3,15 +3,15 @@ import { ColumnDefinition } from './ColumnDefinition.ts'
 export interface IndexDefinition {
   type: 'index' | 'unique' | 'primary'
   columns: string[]
-  name?: string
+  name?: string | undefined
 }
 
 export interface ForeignKeyDefinition {
   column: string
   references: string
   on: string
-  onDelete?: string
-  onUpdate?: string
+  onDelete?: string | undefined
+  onUpdate?: string | undefined
 }
 
 export class Blueprint {

package/src/schema/ColumnDefinition.ts

@@ -6,16 +6,16 @@ export class ColumnDefinition {
   private _index = false
   private _unsigned = false
   private _primary = false
-  private _references: { table: string; column: string; onDelete?: string; onUpdate?: string } | null = null
+  private _references: { table: string; column: string; onDelete?: string | undefined; onUpdate?: string | undefined } | null = null
   private _comment: string | null = null
   private _after: string | null = null
 
   constructor(
     public readonly name: string,
     public readonly type: string,
-    public readonly length?: number,
-    public readonly precision?: number,
-    public readonly scale?: number,
+    public readonly length?: number | undefined,
+    public readonly precision?: number | undefined,
+    public readonly scale?: number | undefined,
   ) {}
 
   nullable(): this {
@@ -49,7 +49,7 @@ export class ColumnDefinition {
     return this
   }
 
-  references(column: string): this & { on(table: string): this } {
+  references(column: string): ColumnDefinition & { on(table: string): ColumnDefinition } {
     this._references = { table: '', column }
     const self = this as any
     self.on = (table: string) => {

package/src/schema/SchemaBuilder.ts

@@ -210,9 +210,12 @@ export class SchemaBuilderImpl implements SchemaBuilder {
 
     let def = `${this.quoteCol(col.name)} ${typeSql}`
 
+    const isIntegerType = ['integer', 'bigInteger', 'tinyInteger', 'smallInteger', 'mediumInteger'].includes(col.type)
     if (isAutoIncrement || col.isPrimary()) {
-      if (driver === 'sqlite') {
+      if (driver === 'sqlite' && (isAutoIncrement || isIntegerType)) {
         def += ' PRIMARY KEY AUTOINCREMENT'
+      } else if (driver === 'sqlite') {
+        def += ' PRIMARY KEY'
       } else if (driver === 'postgres') {
         // SERIAL/BIGSERIAL already implies sequence; just mark PRIMARY KEY
         def += ' PRIMARY KEY'
@@ -252,7 +255,7 @@ export class SchemaBuilderImpl implements SchemaBuilder {
     return def
   }
 
-  private compileIndex(table: string, idx: { type: 'index' | 'unique' | 'primary'; columns: string[]; name?: string }): string {
+  private compileIndex(table: string, idx: { type: 'index' | 'unique' | 'primary'; columns: string[]; name?: string | undefined }): string {
     const cols = idx.columns.map((c) => this.quoteCol(c)).join(', ')
     const idxName = idx.name ?? `${table}_${idx.columns.join('_')}_${idx.type}`
 

package/src/types.d.ts

@@ -0,0 +1,21 @@
+// Optional peer dependencies — ambient module declarations for dynamic imports
+declare module 'pg' {
+  const pg: any
+  export default pg
+}
+
+declare module 'mysql2/promise' {
+  const mysql: any
+  export default mysql
+  export function createPool(config: any): any
+}
+
+declare module 'mssql' {
+  const mssql: any
+  export default mssql
+}
+
+declare module 'mongodb' {
+  export const MongoClient: any
+  export const ObjectId: any
+}