stabilize-orm 1.1.1 → 1.1.3

package/client.ts

@@ -4,12 +4,10 @@ import {
   type DBConfig,
   StabilizeError,
   type PoolMetrics,
-  DBType, // Added DBType for type checking
-  type LoggerConfig, // Kept, but not used in logic
+  DBType,
 } from "./types";
 import { type Logger, ConsoleLogger } from "./logger";
 
-// Helper to determine if we are in Bun SQLite mode based on config
 function isSQLiteConfig(config: DBConfig): boolean {
   return (
     config.type === DBType.SQLite || config.connectionString.includes("sqlite")
@@ -17,14 +15,12 @@ function isSQLiteConfig(config: DBConfig): boolean {
 }
 
 export class DBClient {
-  // Renamed to 'client' for clarity; stores the actual connection (Bun.Database or external driver)
-  // We use 'any' for the SQL client instance since Bun's SQL client is complex (callable function with methods)
   private client: Database | any | null = null;
   private logger: Logger;
   private retryAttempts: number;
   private retryDelay: number;
   private maxJitter: number;
-  // Map stores Bun SQLite Statement objects when in SQLite mode
+
   private preparedStatements: Map<string, Statement> = new Map();
   private config: DBConfig;
 
@@ -38,10 +34,8 @@ export class DBClient {
     this.initializeClient(config);
   }
 
-  // Initializes the connection based on config
   private initializeClient(config: DBConfig) {
     if (isSQLiteConfig(config)) {
-      // Use Bun's native SQLite client, which is synchronous to construct
       try {
         // new Database(path, { create: true }) is the standard Bun method
         this.client = new Database(config.connectionString, { create: true });
@@ -56,9 +50,6 @@ export class DBClient {
         );
       }
     } else {
-      // For other DB types (Postgres/MySQL), initialize a Bun SQL client instance.
-      // This is necessary because the bare `sql` tag is for the default connection,
-      // and we need an instance with specific connection settings, using `SQL` as the constructor.
       this.client = new SQL(config.connectionString);
       this.logger.logDebug(
         `Initialized Bun SQL client for: ${config.connectionString}`,
@@ -70,7 +61,6 @@ export class DBClient {
     return Math.random() * this.maxJitter;
   }
 
-  // Pool metrics are largely irrelevant for single-connection Bun SQLite
   getPoolMetrics(): PoolMetrics {
     return {
       activeConnections: 0,
@@ -112,13 +102,9 @@ export class DBClient {
         let result: T[];
 
         if (stmt) {
-          // Bun SQLite Statement objects use .all() for fetching results
           result = stmt.all(...params) as T[];
         } else if (this.client) {
-          // Path for non-SQLite Bun SQL clients (Postgres/MySQL)
-          // Bun SQL clients do not expose a standard .query() method.
-          // We must use the 'unsafe' helper to execute a raw string query with positional parameters.
-          result = (await (this.client as any).unsafe(query, params)) as T[];
+              result = (await (this.client as any).unsafe(query, params)) as T[];
         } else {
           throw new StabilizeError(
             "Database client is not initialized or does not support query execution.",
@@ -137,7 +123,6 @@ export class DBClient {
             "QUERY_ERROR",
           );
         }
-        // Exponential backoff with jitter
         await new Promise((resolve) =>
           setTimeout(
             resolve,
@@ -150,12 +135,10 @@ export class DBClient {
   }
 
   async transaction<T>(callback: () => Promise<T>): Promise<T> {
-    // Use native Bun SQLite transaction wrapper for safer, faster transactions
     if (this.client instanceof Database) {
       const start = Date.now();
       this.logger.logDebug("Starting native SQLite transaction");
 
-      // Bun's .transaction() automatically handles BEGIN/COMMIT/ROLLBACK
       const tx = this.client.transaction(async () => {
         return callback();
       });
@@ -168,7 +151,6 @@ export class DBClient {
         return result;
       } catch (error) {
         this.logger.logError(error as Error);
-        // The transaction automatically rolls back on error
         throw new StabilizeError(
           `Native transaction failed: ${(error as Error).message}`,
           "TX_ERROR",
@@ -176,13 +158,11 @@ export class DBClient {
       }
     }
 
-    // Fallback to manual transaction with retry logic for non-SQLite
     const start = Date.now();
     this.logger.logDebug("Starting manual transaction (non-SQLite)");
     for (let attempt = 1; attempt <= this.retryAttempts; attempt++) {
       try {
-        // Use this.query, which now correctly handles execution via .unsafe() for non-SQLite
-        await this.query("BEGIN", []);
+          await this.query("BEGIN", []);
         const result = await callback();
         await this.query("COMMIT", []);
         this.logger.logDebug(
@@ -190,7 +170,6 @@ export class DBClient {
         );
         return result;
       } catch (error) {
-        // Attempt rollback, but ignore errors if rollback fails
         await this.query("ROLLBACK", []).catch(() => {
           this.logger.logDebug("Rollback failed. Connection may be invalid.");
         });
@@ -201,7 +180,6 @@ export class DBClient {
             "TX_ERROR",
           );
         }
-        // Exponential backoff with jitter
         await new Promise((resolve) =>
           setTimeout(
             resolve,
@@ -228,7 +206,6 @@ export class DBClient {
       );
       return result;
     } catch (error) {
-      // Attempt rollback, but ignore errors if rollback fails
       await this.query(`ROLLBACK TO SAVEPOINT ${name}`, []).catch(() => {
         this.logger.logDebug(
           `Rollback to savepoint ${name} failed. Connection may be invalid.`,
@@ -241,15 +218,13 @@ export class DBClient {
 
   async close() {
     this.preparedStatements.clear();
-    // Check if the client is a Bun Database instance before closing (Bun SQLite close is sync)
-    if (this.client instanceof Database) {
+      if (this.client instanceof Database) {
       this.client.close();
       this.client = null;
     } else if (
       this.client &&
       typeof (this.client as any).close === "function"
     ) {
-      // Assume external/Bun SQL driver has an async close method
       await (this.client as any).close();
       this.client = null;
     }

package/migrations.ts

@@ -1,14 +1,43 @@
 import { DBClient } from "./client";
 import { ModelKey, ColumnKey, ValidatorKey, SoftDeleteKey } from "./decorators";
-import { type DBConfig, type Migration, StabilizeError } from "./types";
+import { type DBConfig, type Migration, StabilizeError, DBType } from "./types";
 
 type ColumnData = { name: string; type: string };
 type ColumnMetadata = Record<string, ColumnData>;
 type ValidatorMetadata = Record<string, string[]>;
 
+// Helper to get SQL type for auto-increment PK
+function getAutoIncrementPK(dbType: DBType) {
+  switch (dbType) {
+    case DBType.Postgres:
+      return "SERIAL PRIMARY KEY";
+    case DBType.MySQL:
+      return "INT AUTO_INCREMENT PRIMARY KEY";
+    case DBType.SQLite:
+      return "INTEGER PRIMARY KEY AUTOINCREMENT";
+    default: // Default to Postgres
+      return "SERIAL PRIMARY KEY";
+  }
+}
+
+// Helper to get SQL type for timestamps
+function getTimestampType(dbType: DBType) {
+  switch (dbType) {
+    case DBType.Postgres:
+      return "TIMESTAMP";
+    case DBType.MySQL:
+      return "DATETIME";
+    case DBType.SQLite:
+      return "TEXT";
+    default: // Default to Postgres
+      return "TIMESTAMP";
+  }
+}
+
 export async function generateMigration(
   model: new (...args: any[]) => any,
   name: string,
+  dbType: DBType = DBType.Postgres, // default to Postgres
 ): Promise<Migration> {
   const tableName = Reflect.getMetadata(ModelKey, model);
   if (!tableName)
@@ -24,10 +53,19 @@ export async function generateMigration(
   const softDeleteField = Reflect.getMetadata(SoftDeleteKey, model.prototype);
 
   const columnDefs = Object.entries(columns).map(([key, col]) => {
-    let def = `${col.name} ${col.type}`;
-    if (col.name === "id") def += " PRIMARY KEY AUTOINCREMENT";
+    let def: string;
+    if (col.name === "id") {
+      // Use correct PK syntax for each DB
+      def = getAutoIncrementPK(dbType);
+      return def;
+    }
+    def = `${col.name} ${col.type}`;
     if (validators[key]?.includes("required")) def += " NOT NULL";
     if (validators[key]?.includes("unique")) def += " UNIQUE";
+    // Handle timestamps
+    if (["createdAt", "updatedAt"].includes(col.name)) {
+      def = `${col.name} ${getTimestampType(dbType)}`;
+    }
     return def;
   });
 
@@ -45,16 +83,43 @@ export async function generateMigration(
   return { up, down };
 }
 
-export async function runMigrations(config: DBConfig, migrations: Migration[]) {
-  const client = new DBClient(config);
-  try {
-    await client.query(`
-      CREATE TABLE IF NOT EXISTS migrations (
+// Create migrations table with correct types for each DB
+function getMigrationsTableSQL(dbType: DBType) {
+  switch (dbType) {
+    case DBType.Postgres:
+      return `CREATE TABLE IF NOT EXISTS migrations (
+        id SERIAL PRIMARY KEY,
+        name TEXT NOT NULL,
+        applied_at TIMESTAMP NOT NULL
+      )`;
+    case DBType.MySQL:
+      return `CREATE TABLE IF NOT EXISTS migrations (
+        id INT AUTO_INCREMENT PRIMARY KEY,
+        name VARCHAR(255) NOT NULL,
+        applied_at DATETIME NOT NULL
+      )`;
+    case DBType.SQLite:
+      return `CREATE TABLE IF NOT EXISTS migrations (
         id INTEGER PRIMARY KEY AUTOINCREMENT,
         name TEXT NOT NULL,
         applied_at TEXT NOT NULL
-      )
-    `);
+      )`;
+    default: // Default to Postgres
+      return `CREATE TABLE IF NOT EXISTS migrations (
+        id SERIAL PRIMARY KEY,
+        name TEXT NOT NULL,
+        applied_at TIMESTAMP NOT NULL
+      )`;
+  }
+}
+
+export async function runMigrations(config: DBConfig, migrations: Migration[]) {
+  const client = new DBClient(config);
+  try {
+    // Detect DB type from config
+    const dbType = config.type ?? DBType.Postgres;
+
+    await client.query(getMigrationsTableSQL(dbType));
 
     for (const [index, migration] of migrations.entries()) {
       const name = `migration_${index}_${new Date().toISOString().replace(/[-:T.]/g, "")}`;
@@ -78,4 +143,4 @@ export async function runMigrations(config: DBConfig, migrations: Migration[]) {
   }
 }
 
-export type { Migration };
+export type { Migration };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stabilize-orm",
-  "version": "1.1.1",
+  "version": "1.1.3",
   "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",
@@ -25,14 +25,16 @@
     "typescript",
     "database"
   ],
-  "author": "th3b0tk1ill3r <lwazicd@icloud.com>",
+  "author": "ElectronSz <lwazicd@icloud.com>",
   "license": "MIT",
   "dependencies": {
+    "@types/uuid": "^11.0.0",
     "commander": "^12.1.0",
     "figlet": "^1.9.3",
     "glob": "^11.0.0",
     "ioredis": "^5.4.1",
-    "reflect-metadata": "^0.2.2"
+    "reflect-metadata": "^0.2.2",
+    "uuid": "^13.0.0"
   },
   "devDependencies": {
     "@typescript-eslint/eslint-plugin": "^8.7.0",