stabilize-orm 1.0.5

package/src/index.ts

@@ -0,0 +1,143 @@
+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

@@ -0,0 +1,126 @@
+// 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

@@ -0,0 +1,81 @@
+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 };

package/src/query-builder.ts

@@ -0,0 +1,96 @@
+import { DBClient } from "./client";
+import { Cache } from "./cache";
+import { type QueryHint } from "./types";
+
+export class QueryBuilder<T> {
+  private table: string;
+  private selectFields: string[] = ["*"];
+  private joins: string[] = [];
+  private whereConditions: string[] = [];
+  private whereParams: any[] = [];
+  private orderByClause: string | null = null;
+  private limitValue: number | null = null;
+  private offsetValue: number | null = null;
+  private hints: QueryHint[] = [];
+
+  constructor(table: string) {
+    this.table = table;
+  }
+
+  select(...fields: string[]): QueryBuilder<T> {
+    this.selectFields = fields.length > 0 ? fields : ["*"];
+    return this;
+  }
+
+  where(condition: string, ...params: any[]): QueryBuilder<T> {
+    this.whereConditions.push(condition);
+    this.whereParams.push(...params);
+    return this;
+  }
+
+  join(table: string, condition: string): QueryBuilder<T> {
+    this.joins.push(`LEFT JOIN ${table} ON ${condition}`);
+    return this;
+  }
+
+  orderBy(clause: string): QueryBuilder<T> {
+    this.orderByClause = clause;
+    return this;
+  }
+
+  limit(limit: number): QueryBuilder<T> {
+    this.limitValue = limit;
+    return this;
+  }
+
+  offset(offset: number): QueryBuilder<T> {
+    this.offsetValue = offset;
+    return this;
+  }
+
+  hint(hint: QueryHint): QueryBuilder<T> {
+    this.hints.push(hint);
+    return this;
+  }
+
+  build(): { query: string; params: any[] } {
+    let query = `SELECT ${this.selectFields.join(", ")} FROM ${this.table}`;
+    if (this.hints.length > 0) {
+      const hintStr = this.hints.map((h) => `${h.type}(${h.value})`).join(" ");
+      query = `SELECT ${hintStr} ${this.selectFields.join(", ")} FROM ${this.table}`;
+    }
+    if (this.joins.length > 0) {
+      query += " " + this.joins.join(" ");
+    }
+    if (this.whereConditions.length > 0) {
+      query += " WHERE " + this.whereConditions.join(" AND ");
+    }
+    if (this.orderByClause) {
+      query += ` ORDER BY ${this.orderByClause}`;
+    }
+    if (this.limitValue !== null) {
+      query += ` LIMIT ${this.limitValue}`;
+    }
+    if (this.offsetValue !== null) {
+      query += ` OFFSET ${this.offsetValue}`;
+    }
+    return { query, params: this.whereParams };
+  }
+
+  async execute(
+    client: DBClient,
+    cache?: Cache,
+    cacheKey?: string,
+  ): Promise<T[]> {
+    const { query, params } = this.build();
+    if (cache && cacheKey) {
+      const cached = await cache.get<T[]>(cacheKey);
+      if (cached) return cached;
+    }
+    const results = await client.query<T>(query, params);
+    if (cache && cacheKey && results.length > 0) {
+      await cache.set(cacheKey, results);
+    }
+    return results;
+  }
+}