stabilize-orm 1.1.5 → 1.1.7

package/client.ts

@@ -103,41 +103,50 @@ export class DBClient {
    * const users = await dbClient.query('SELECT * FROM users WHERE status = ?', ['active']);
    * ```
    */
-  async query<T>(query: string, params: any[] = []): Promise<T[]> {
-    const start = Date.now();
-    this.logger.logQuery(query, params);
-
-    for (let attempt = 1; attempt <= this.retryAttempts; attempt++) {
-      try {
-        let result: any;
-
-        if (this.client instanceof Database) { // SQLite
-          let stmt = this.preparedStatements.get(query);
-          if (!stmt) {
-            stmt = this.client.prepare(query);
-            this.preparedStatements.set(query, stmt);
-          }
-          result = stmt.all(...params);
-        } else if (isMySQLPool(this.client) || ('query' in this.client && 'release' in this.client)) { // mysql2 Pool or Connection
-            const [rows] = await (this.client as mysql.Pool).query(query, params);
-            result = rows;
-        } else { // Postgres Pool or Client
-          const pgQuery = query.replace(/\?/g, (_, i) => `$${i + 1}`);
-          const pgResult = await (this.client as Pool).query(pgQuery, params);
-          result = pgResult.rows;
+  
+    async query<T>(query: string, params: any[] = []): Promise<T[]> {
+        const start = Date.now();
+        
+        for (let attempt = 1; attempt <= this.retryAttempts; attempt++) {
+            try {
+                let result: any;
+                
+                // Log the query before execution
+                this.logger.logQuery(query, params);
+
+                if (this.client instanceof Database) { // SQLite
+                    let stmt = this.preparedStatements.get(query);
+                    if (!stmt) {
+                        stmt = this.client.prepare(query);
+                        this.preparedStatements.set(query, stmt);
+                    }
+                    result = stmt.all(...params);
+                } else if (isMySQLPool(this.client) || ('query' in this.client && 'release' in this.client && !(this.client instanceof Pool))) { // mysql2 Pool or Connection
+                    const [rows] = await (this.client as mysql.Pool).query(query, params);
+                    result = rows;
+                } else { // Postgres Pool or Client
+                    
+                    // Correctly replace '?' with '$1', '$2', etc.
+                    let paramIndex = 0;
+                    const pgQuery = query.replace(/\?/g, () => `$${++paramIndex}`);
+                    const pgResult = await (this.client as Pool).query(pgQuery, params);
+                    result = pgResult.rows;
+                }
+
+                const executionTime = Date.now() - start;
+                this.logger.logQuery(query, params, executionTime);
+                return result as T[];
+            } catch (error) {
+                this.logger.logError(error as Error);
+                if (attempt === this.retryAttempts) {
+                    throw new StabilizeError(`Query failed after ${this.retryAttempts} attempts: ${(error as Error).message}`, "QUERY_ERROR");
+                }
+                await new Promise(res => setTimeout(res, this.retryDelay * Math.pow(2, attempt - 1) + this.getJitter()));
+            }
         }
-
-        const executionTime = Date.now() - start;
-        this.logger.logQuery(query, params, executionTime);
-        return result as T[];
-      } catch (error) {
-        this.logger.logError(error as Error);
-        if (attempt === this.retryAttempts) throw new StabilizeError(`Query failed: ${(error as Error).message}`, "QUERY_ERROR");
-        await new Promise(res => setTimeout(res, this.retryDelay * Math.pow(2, attempt - 1) + this.getJitter()));
-      }
+        // This line should theoretically be unreachable if retryAttempts >= 1
+        throw new StabilizeError("Query failed: maximum retries reached without success", "QUERY_ERROR");
     }
-    throw new StabilizeError("Query failed: no attempts made", "QUERY_ERROR");
-  }
 
   /**
    * Executes a series of database operations within a single atomic transaction.

package/migrations.ts

@@ -2,6 +2,7 @@
  * @file migrations.ts
  * @description Contains functions for generating and running database migrations based on model metadata.
  * @author ElectronSz
+ * @date 2025-10-15 20:55:49
  */
 
 import { DBClient } from "./client";
@@ -12,6 +13,23 @@ type ColumnData = { name: string; type: string };
 type ColumnMetadata = Record<string, ColumnData>;
 type ValidatorMetadata = Record<string, string[]>;
 
+// --- FIX: New Helper Function to format queries for different DBs ---
+/**
+ * @internal
+ * Formats a SQL query with placeholders for the target database dialect.
+ * Replaces '?' with '$1', '$2', etc. for PostgreSQL.
+ * @param query The SQL query string with '?' placeholders.
+ * @param dbType The target database dialect.
+ * @returns The formatted SQL query string.
+ */
+function formatQuery(query: string, dbType: DBType): string {
+  if (dbType === DBType.Postgres) {
+    let paramIndex = 1;
+    return query.replace(/\?/g, () => `$${paramIndex++}`);
+  }
+  return query;
+}
+
 /**
  * @internal
  * Gets the database-specific SQL for an auto-incrementing primary key.
@@ -74,23 +92,6 @@ function getTimestampDefault(dbType: DBType): string {
  * @param name A descriptive name for the migration (used for the migration object).
  * @param dbType The target database dialect to generate SQL for. Defaults to Postgres.
  * @returns A promise that resolves to a `Migration` object containing the `up` and `down` SQL scripts.
- * @example
- * ```
- * // In a script like 'scripts/generate_user_migration.ts'
- * import { generateMigration, DBType } from 'stabilize-orm';
- * import { User } from './models/user';
- * import fs from 'fs';
- *
- * async function createMigration() {
- *   const migration = await generateMigration(User, 'create_users_table', DBType.Postgres);
- *   fs.writeFileSync(
- *     `migrations/${new Date().getTime()}_create_users.json`,
- *     JSON.stringify(migration, null, 2)
- *   );
- * }
- *
- * createMigration();
- * ```
  */
 export async function generateMigration(
   model: new (...args: any[]) => any,
@@ -180,24 +181,6 @@ function getMigrationsTableSQL(dbType: DBType): string {
  *
  * @param config The database configuration object.
  * @param migrations An array of `Migration` objects to be executed.
- * @example
- * ```
- * // In a script like 'scripts/run_all_migrations.ts'
- * import { runMigrations } from 'stabilize-orm';
- * import { dbConfig } from './config';
- * import migration1 from '../migrations/1_create_users.json';
- * import migration2 from '../migrations.ts/2_create_profiles.json';
- *
- * const allMigrations = [migration1, migration2];
- *
- * async function applyMigrations() {
- *   console.log('Starting migration process...');
- *   await runMigrations(dbConfig, allMigrations);
- *   console.log('All pending migrations applied successfully.');
- * }
- *
- * applyMigrations();
- * ```
  */
 export async function runMigrations(config: DBConfig, migrations: Migration[]) {
   const client = new DBClient(config);
@@ -208,10 +191,8 @@ export async function runMigrations(config: DBConfig, migrations: Migration[]) {
     for (const [index, migration] of migrations.entries()) {
       const name = migration.name || `migration_${index}_${new Date().getTime()}`;
       
-      const applied = await client.query<{ id: number }>(
-        `SELECT id FROM migrations WHERE name = ?`,
-        [name],
-      );
+      const selectQuery = formatQuery(`SELECT id FROM migrations WHERE name = ?`, dbType);
+      const applied = await client.query<{ id: number }>(selectQuery, [name]);
 
       if (applied.length === 0) {
         await client.transaction(async (txClient) => {
@@ -219,10 +200,10 @@ export async function runMigrations(config: DBConfig, migrations: Migration[]) {
           for (const query of migration.up) {
             await txClient.query(query);
           }
-          await txClient.query(
-            `INSERT INTO migrations (name, applied_at) VALUES (?, ?)`,
-            [name, new Date().toISOString()],
-          );
+          
+          const insertQuery = formatQuery(`INSERT INTO migrations (name, applied_at) VALUES (?, ?)`, dbType);
+          await txClient.query(insertQuery, [name, new Date().toISOString()]);
+          
           console.log(`Migration ${name} applied successfully.`);
         });
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stabilize-orm",
-  "version": "1.1.5",
+  "version": "1.1.7",
   "description": "A lightweight, type-safe ORM for Bun.js with support for SQLite, MySQL, PostgreSQL, and Redis caching",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",