stabilize-orm 1.0.6 → 1.0.7

package/src/client.ts

@@ -1,258 +0,0 @@
-import { sql, SQL } from "bun";
-import { Database, Statement } from "bun:sqlite";
-import {
-  type DBConfig,
-  StabilizeError,
-  type PoolMetrics,
-  DBType, // Added DBType for type checking
-  type LoggerConfig, // Kept, but not used in logic
-} 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")
-  );
-}
-
-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;
-
-  constructor(config: DBConfig, logger: Logger = new ConsoleLogger()) {
-    this.config = config;
-    this.logger = logger;
-    this.retryAttempts = config.retryAttempts || 3;
-    this.retryDelay = config.retryDelay || 1000;
-    this.maxJitter = config.maxJitter || 100;
-
-    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 });
-        this.logger.logDebug(
-          `Initialized Bun SQLite client for: ${config.connectionString}`,
-        );
-      } catch (e) {
-        this.logger.logError(e as Error);
-        throw new StabilizeError(
-          `Failed to initialize SQLite database: ${(e as Error).message}`,
-          "INIT_ERROR",
-        );
-      }
-    } 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}`,
-      );
-    }
-  }
-
-  private getJitter() {
-    return Math.random() * this.maxJitter;
-  }
-
-  // Pool metrics are largely irrelevant for single-connection Bun SQLite
-  getPoolMetrics(): PoolMetrics {
-    return {
-      activeConnections: 0,
-      idleConnections: 0,
-      totalConnections: this.client instanceof Database ? 1 : 0,
-    };
-  }
-
-  async switchConnection(config: DBConfig) {
-    await this.close();
-    this.config = config;
-    this.preparedStatements.clear();
-    this.retryAttempts = config.retryAttempts || 3;
-    this.retryDelay = config.retryDelay || 1000;
-    this.maxJitter = config.maxJitter || 100;
-    this.initializeClient(config);
-  }
-
-  async query<T>(query: string, params: any[] = []): Promise<T[]> {
-    const start = Date.now();
-    this.logger.logQuery(query, params);
-    this.logger.logMetrics(this.getPoolMetrics());
-
-    let stmt: Statement | undefined;
-
-    // Check for Bun SQLite client
-    if (this.client instanceof Database) {
-      const stmtKey = query;
-      // Use prepared statement caching for SQLite
-      if (!this.preparedStatements.has(stmtKey)) {
-        // Use this.client (the Database instance) to prepare the statement
-        this.preparedStatements.set(stmtKey, this.client.prepare(query));
-      }
-      stmt = this.preparedStatements.get(stmtKey);
-    }
-
-    for (let attempt = 1; attempt <= this.retryAttempts; attempt++) {
-      try {
-        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[];
-        } else {
-          throw new StabilizeError(
-            "Database client is not initialized or does not support query execution.",
-            "INIT_ERROR",
-          );
-        }
-
-        const executionTime = Date.now() - start;
-        this.logger.logQuery(query, params, executionTime);
-        return result;
-      } 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",
-          );
-        }
-        // Exponential backoff with jitter
-        await new Promise((resolve) =>
-          setTimeout(
-            resolve,
-            this.retryDelay * Math.pow(2, attempt - 1) + this.getJitter(),
-          ),
-        );
-      }
-    }
-    throw new StabilizeError("Query failed: no attempts made", "QUERY_ERROR");
-  }
-
-  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();
-      });
-
-      try {
-        const result = await tx();
-        this.logger.logDebug(
-          `Native transaction committed in ${Date.now() - start}ms`,
-        );
-        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",
-        );
-      }
-    }
-
-    // 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", []);
-        const result = await callback();
-        await this.query("COMMIT", []);
-        this.logger.logDebug(
-          `Manual transaction committed in ${Date.now() - start}ms`,
-        );
-        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.");
-        });
-        this.logger.logError(error as Error);
-        if (attempt === this.retryAttempts) {
-          throw new StabilizeError(
-            `Manual transaction failed after ${this.retryAttempts} attempts: ${(error as Error).message}`,
-            "TX_ERROR",
-          );
-        }
-        // Exponential backoff with jitter
-        await new Promise((resolve) =>
-          setTimeout(
-            resolve,
-            this.retryDelay * Math.pow(2, attempt - 1) + this.getJitter(),
-          ),
-        );
-      }
-    }
-    throw new StabilizeError(
-      "Transaction failed: no attempts made",
-      "TX_ERROR",
-    );
-  }
-
-  async savepoint<T>(name: string, callback: () => Promise<T>): Promise<T> {
-    const start = Date.now();
-    this.logger.logDebug(`Starting savepoint ${name}`);
-    await this.query(`SAVEPOINT ${name}`, []);
-    try {
-      const result = await callback();
-      await this.query(`RELEASE SAVEPOINT ${name}`, []);
-      this.logger.logDebug(
-        `Savepoint ${name} released in ${Date.now() - start}ms`,
-      );
-      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.`,
-        );
-      });
-      this.logger.logError(error as Error);
-      throw error;
-    }
-  }
-
-  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) {
-      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;
-    }
-    this.logger.logInfo("Database connection closed");
-  }
-}

package/src/decorators.ts

@@ -1,99 +0,0 @@
-import "reflect-metadata";
-import { RelationType } from "./types";
-
-export const ModelKey = Symbol("model");
-export const ColumnKey = Symbol("column");
-export const ValidatorKey = Symbol("validator");
-export const RelationKey = Symbol("relation");
-export const SoftDeleteKey = Symbol("softDelete");
-
-export function Model(tableName: string) {
-  return function (constructor: Function) {
-    Reflect.defineMetadata(ModelKey, tableName, constructor);
-  };
-}
-
-export function Column(name: string, type: string) {
-  return function (target: any, propertyKey: string) {
-    const columns = Reflect.getMetadata(ColumnKey, target) || {};
-    columns[propertyKey] = { name, type };
-    Reflect.defineMetadata(ColumnKey, columns, target);
-  };
-}
-
-export function Required() {
-  return function (target: any, propertyKey: string) {
-    const validators = Reflect.getMetadata(ValidatorKey, target) || {};
-    validators[propertyKey] = [...(validators[propertyKey] || []), "required"];
-    Reflect.defineMetadata(ValidatorKey, validators, target);
-  };
-}
-
-export function Unique() {
-  return function (target: any, propertyKey: string) {
-    const validators = Reflect.getMetadata(ValidatorKey, target) || {};
-    validators[propertyKey] = [...(validators[propertyKey] || []), "unique"];
-    Reflect.defineMetadata(ValidatorKey, validators, target);
-  };
-}
-
-export function SoftDelete() {
-  return function (target: any, propertyKey: string) {
-    Reflect.defineMetadata(SoftDeleteKey, propertyKey, target);
-  };
-}
-
-export function OneToOne(model: () => any, foreignKey: string) {
-  return function (target: any, propertyKey: string) {
-    const relations = Reflect.getMetadata(RelationKey, target) || {};
-    relations[propertyKey] = {
-      type: RelationType.OneToOne,
-      targetModel: model,
-      foreignKey,
-    };
-    Reflect.defineMetadata(RelationKey, relations, target);
-  };
-}
-
-export function ManyToOne(model: () => any, foreignKey: string) {
-  return function (target: any, propertyKey: string) {
-    const relations = Reflect.getMetadata(RelationKey, target) || {};
-    relations[propertyKey] = {
-      type: RelationType.ManyToOne,
-      targetModel: model,
-      foreignKey,
-    };
-    Reflect.defineMetadata(RelationKey, relations, target);
-  };
-}
-
-export function OneToMany(model: () => any, inverseKey: string) {
-  return function (target: any, propertyKey: string) {
-    const relations = Reflect.getMetadata(RelationKey, target) || {};
-    relations[propertyKey] = {
-      type: RelationType.OneToMany,
-      targetModel: model,
-      inverseKey,
-    };
-    Reflect.defineMetadata(RelationKey, relations, target);
-  };
-}
-
-export function ManyToMany(
-  model: () => any,
-  joinTable: string,
-  foreignKey: string,
-  inverseKey: string,
-) {
-  return function (target: any, propertyKey: string) {
-    const relations = Reflect.getMetadata(RelationKey, target) || {};
-    relations[propertyKey] = {
-      type: RelationType.ManyToMany,
-      targetModel: model,
-      joinTable,
-      foreignKey,
-      inverseKey,
-    };
-    Reflect.defineMetadata(RelationKey, relations, target);
-  };
-}

package/src/index.ts

@@ -1,143 +0,0 @@
-import { Cache } from "./cache";
-import { DBClient } from "./client";
-import { type Logger, ConsoleLogger } from "./logger";
-import { QueryBuilder } from "./query-builder";
-import { Repository } from "./repository";
-import { runMigrations, generateMigration, type Migration } from "./migrations";
-import {
-  Model,
-  Column,
-  Required,
-  Unique,
-  SoftDelete,
-  OneToOne,
-  ManyToOne,
-  OneToMany,
-  ManyToMany,
-  ModelKey,
-  ColumnKey,
-  ValidatorKey,
-  RelationKey,
-  SoftDeleteKey,
-} from "./decorators";
-import {
-  type DBConfig,
-  type CacheConfig,
-  type LoggerConfig,
-  DBType,
-  StabilizeError,
-  type PoolMetrics,
-  type QueryHint,
-  RelationType,
-  type CacheStats,
-  LogLevel,
-} from "./types";
-
-export class Stabilize {
-  private client: DBClient;
-  private cache: Cache | null;
-  private logger: Logger;
-
-  constructor(
-    config: DBConfig,
-    cacheConfig: CacheConfig = { enabled: false, ttl: 60 },
-    loggerConfig: LoggerConfig = {},
-  ) {
-    this.logger = new ConsoleLogger(loggerConfig);
-    this.client = new DBClient(config, this.logger);
-    this.cache = cacheConfig.enabled
-      ? new Cache(cacheConfig, this.logger)
-      : null;
-  }
-
-  getRepository<T>(model: new (...args: any[]) => T): Repository<T> {
-    if (this.cache) {
-      const cacheInstance = this.cache as any;
-      const repoCacheConfig: CacheConfig = {
-        enabled: true,
-        ttl: 60,
-        redisUrl: cacheInstance.redisUrl,
-        cachePrefix: cacheInstance.prefix,
-        strategy: this.cache.getStrategy(),
-      };
-      return new Repository(this.client, model, repoCacheConfig, this.logger);
-    }
-
-    return new Repository(
-      this.client,
-      model,
-      { enabled: false, ttl: 60 },
-      this.logger,
-    );
-  }
-
-  async transaction<T>(callback: () => Promise<T>): Promise<T> {
-    return await this.client.transaction(callback);
-  }
-
-  async savepoint<T>(name: string, callback: () => Promise<T>): Promise<T> {
-    return await this.client.savepoint(name, callback);
-  }
-
-  async switchConnection(config: DBConfig) {
-    await this.client.switchConnection(config);
-  }
-
-  async getCacheStats(): Promise<CacheStats> {
-    return this.cache
-      ? await this.cache.getStats()
-      : { hits: 0, misses: 0, keys: 0 };
-  }
-
-  getPoolMetrics(): PoolMetrics {
-    return this.client.getPoolMetrics();
-  }
-
-  async close() {
-    await this.client.close();
-    if (this.cache) await this.cache.disconnect();
-  }
-}
-
-export {
-  // Types
-  DBType,
-  LogLevel,
-  RelationType,
-  StabilizeError,
-  // Decorators
-  Model,
-  Column,
-  Required,
-  Unique,
-  SoftDelete,
-  OneToOne,
-  ManyToOne,
-  OneToMany,
-  ManyToMany,
-  ModelKey,
-  ColumnKey,
-  ValidatorKey,
-  RelationKey,
-  SoftDeleteKey,
-  // Classes
-  Cache,
-  DBClient,
-  QueryBuilder,
-  Repository,
-  ConsoleLogger,
-  // Migrations
-  runMigrations,
-  generateMigration,
-};
-
-export type { Migration };
-export type {
-  DBConfig,
-  CacheConfig,
-  LoggerConfig,
-  QueryHint,
-  PoolMetrics,
-  CacheStats,
-  Logger,
-};

package/src/logger.ts

@@ -1,126 +0,0 @@
-// src/logger.ts
-import * as fs from "fs/promises";
-import * as path from "path";
-import {
-  LogLevel,
-  type LoggerConfig,
-  type PoolMetrics,
-  StabilizeError,
-} from "./types";
-
-export interface Logger {
-  logQuery(query: string, params: any[], executionTime?: number): void;
-  logError(error: Error): void;
-  logMetrics(metrics: PoolMetrics): void;
-  logInfo(message: string): void;
-  logDebug(message: string): void;
-}
-
-export class ConsoleLogger implements Logger {
-  private level: LogLevel;
-  private filePath: string | null;
-  private maxFileSize: number;
-  private maxFiles: number;
-  private currentFileSize: number = 0;
-
-  constructor(config: LoggerConfig = {}) {
-    this.level = config.level || LogLevel.INFO;
-    this.filePath = config.filePath || null;
-    this.maxFileSize = config.maxFileSize || 1 * 1024 * 1024; // 1MB
-    this.maxFiles = config.maxFiles || 3;
-  }
-
-  private shouldLog(messageLevel: LogLevel): boolean {
-    const levels = [
-      LogLevel.ERROR,
-      LogLevel.WARN,
-      LogLevel.INFO,
-      LogLevel.DEBUG,
-    ];
-    return levels.indexOf(messageLevel) <= levels.indexOf(this.level);
-  }
-
-  private async rotateLogFile() {
-    if (!this.filePath) return;
-
-    try {
-      const stats = await fs.stat(this.filePath).catch(() => null);
-      if (stats && stats.size >= this.maxFileSize) {
-        for (let i = this.maxFiles - 1; i > 0; i--) {
-          const oldPath = i === 1 ? this.filePath : `${this.filePath}.${i - 1}`;
-          const newPath = `${this.filePath}.${i}`;
-          if (await fs.stat(oldPath).catch(() => null)) {
-            await fs.rename(oldPath, newPath).catch(() => {});
-          }
-        }
-        await fs.writeFile(this.filePath, "");
-        this.currentFileSize = 0;
-      }
-    } catch (error) {
-      console.error("Log rotation failed:", error);
-    }
-  }
-
-  private async writeToFile(message: string) {
-    if (!this.filePath) return;
-
-    try {
-      await this.rotateLogFile();
-      const logEntry = `${new Date().toISOString()} ${message}\n`;
-      await fs.appendFile(this.filePath, logEntry);
-      this.currentFileSize += Buffer.byteLength(logEntry);
-    } catch (error) {
-      console.error("Failed to write to log file:", error);
-    }
-  }
-
-  logQuery(query: string, params: any[], executionTime?: number) {
-    if (this.shouldLog(LogLevel.DEBUG)) {
-      const message = `[DEBUG] Query: ${query} | Params: ${JSON.stringify(params)} | Time: ${executionTime ? `${executionTime.toFixed(2)}ms` : "N/A"}`;
-      console.log(message);
-      if (this.filePath) {
-        this.writeToFile(message);
-      }
-    }
-  }
-
-  logError(error: Error) {
-    if (this.shouldLog(LogLevel.ERROR)) {
-      const message = `[ERROR] ${error.message}${error.stack ? `\n${error.stack}` : ""}`;
-      console.error(message);
-      if (this.filePath) {
-        this.writeToFile(message);
-      }
-    }
-  }
-
-  logMetrics(metrics: PoolMetrics) {
-    if (this.shouldLog(LogLevel.INFO)) {
-      const message = `[INFO] Pool Metrics: Active=${metrics.activeConnections}, Idle=${metrics.idleConnections}, Total=${metrics.totalConnections}`;
-      console.log(message);
-      if (this.filePath) {
-        this.writeToFile(message);
-      }
-    }
-  }
-
-  logInfo(message: string) {
-    if (this.shouldLog(LogLevel.INFO)) {
-      const formatted = `[INFO] ${message}`;
-      console.log(formatted);
-      if (this.filePath) {
-        this.writeToFile(formatted);
-      }
-    }
-  }
-
-  logDebug(message: string) {
-    if (this.shouldLog(LogLevel.DEBUG)) {
-      const formatted = `[DEBUG] ${message}`;
-      console.log(formatted);
-      if (this.filePath) {
-        this.writeToFile(formatted);
-      }
-    }
-  }
-}

package/src/migrations.ts

@@ -1,81 +0,0 @@
-import { DBClient } from "./client";
-import { ModelKey, ColumnKey, ValidatorKey, SoftDeleteKey } from "./decorators";
-import { type DBConfig, type Migration, StabilizeError } from "./types";
-
-type ColumnData = { name: string; type: string };
-type ColumnMetadata = Record<string, ColumnData>;
-type ValidatorMetadata = Record<string, string[]>;
-
-export async function generateMigration(
-  model: new (...args: any[]) => any,
-  name: string,
-): Promise<Migration> {
-  const tableName = Reflect.getMetadata(ModelKey, model);
-  if (!tableName)
-    throw new StabilizeError(
-      "Model not decorated with @Model",
-      "MIGRATION_ERROR",
-    );
-
-  const columns: ColumnMetadata =
-    Reflect.getMetadata(ColumnKey, model.prototype) || {};
-  const validators: ValidatorMetadata =
-    Reflect.getMetadata(ValidatorKey, model.prototype) || {};
-  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";
-    if (validators[key]?.includes("required")) def += " NOT NULL";
-    if (validators[key]?.includes("unique")) def += " UNIQUE";
-    return def;
-  });
-
-  if (softDeleteField && columns[softDeleteField]) {
-    columnDefs.push(
-      `${columns[softDeleteField].name} ${columns[softDeleteField].type}`,
-    );
-  }
-
-  const up = [
-    `CREATE TABLE IF NOT EXISTS ${tableName} (${columnDefs.join(", ")})`,
-  ];
-  const down = [`DROP TABLE IF EXISTS ${tableName}`];
-
-  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 (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        name TEXT NOT NULL,
-        applied_at TEXT NOT NULL
-      )
-    `);
-
-    for (const [index, migration] of migrations.entries()) {
-      const name = `migration_${index}_${new Date().toISOString().replace(/[-:T.]/g, "")}`;
-      const applied = await client.query<{ id: number }>(
-        `SELECT id FROM migrations WHERE name = ?`,
-        [name],
-      );
-
-      if (applied.length === 0) {
-        for (const query of migration.up) {
-          await client.query(query, []);
-        }
-        await client.query(
-          `INSERT INTO migrations (name, applied_at) VALUES (?, ?)`,
-          [name, new Date().toISOString()],
-        );
-      }
-    }
-  } finally {
-    await client.close();
-  }
-}
-
-export type { Migration };