stabilize-orm 1.3.3 → 1.3.8

package/cache.ts

@@ -6,7 +6,7 @@
 
 import Redis from "ioredis";
 import { type CacheConfig, type CacheStats } from "./types";
-import { ConsoleLogger, type Logger } from "./logger";
+import { StabilizeLogger, type Logger } from "./logger";
 
 /**
  * A caching client that uses Redis to store and retrieve query results.
@@ -26,7 +26,7 @@ export class Cache {
    * @param config The configuration for the cache, including Redis URL and TTL.
    * @param logger A logger instance for logging messages.
    */
-  constructor(config: CacheConfig, logger: Logger = new ConsoleLogger()) {
+  constructor(config: CacheConfig, logger: Logger = new StabilizeLogger()) {
     this.config = config;
     this.logger = logger;
 

package/client.ts

@@ -117,8 +117,6 @@ export class DBClient {
       try {
         let result: any;
 
-        this.logger.logQuery(query, params);
-
         if (this.client instanceof Database) {
           let stmt = this.preparedStatements.get(query);
           if (!stmt) {
@@ -126,7 +124,7 @@ export class DBClient {
             this.preparedStatements.set(query, stmt);
           }
           result = stmt.all(...params);
-        } else if (this.config.type === DBType.MySQL && isMySQLPool(this.client)) {
+        } else if (this.config.type === DBType.MySQL) {
           const [rows] = await (this.client as mysql.Pool).query(query, params);
           result = rows;
         } else if (this.config.type === DBType.Postgres ) {
@@ -230,8 +228,6 @@ export class DBClient {
    */
   async migrationQuery(query: string, params: any[] = []): Promise<void> {
     const start = Date.now();
-    this.logger.logQuery(query, params);
-
     if (this.client instanceof Database) {
       let stmt = this.preparedStatements.get(query);
       if (!stmt) {

package/docker-compose.yml

@@ -0,0 +1,22 @@
+
+services:
+  db:
+    image: mariadb:latest
+    container_name: mariadb-container
+    restart: always
+    environment:
+      # Required: set a secure root password
+      MARIADB_ROOT_PASSWORD: P@ssw0rd
+      # Optional: set up a default database and user
+      MARIADB_DATABASE: db
+      MARIADB_USER: admin
+      MARIADB_PASSWORD: P@ssw0rd
+    ports:
+      # Map host port 3306 to container port 3306
+      - '3306:3306'
+    volumes:
+      # Create a named volume for persistent data storage
+      - mariadb_data:/var/lib/mysql
+
+volumes:
+  mariadb_data:

package/hooks.ts

@@ -26,7 +26,7 @@ export interface Hook {
 // Extend ModelConfig to include hooks
 declare module "./model" {
   interface ModelConfig {
-    hooks?: Record<HookType, HookCallback | HookCallback[]>;
+    hooks?:  Partial<Record<HookType, HookCallback | HookCallback[]>>;
   }
 }
 

package/index.ts

@@ -5,10 +5,10 @@
  */
 import { Cache } from "./cache";
 import { DBClient } from "./client";
-import { type Logger, ConsoleLogger } from "./logger";
+import { type Logger, StabilizeLogger } from "./logger";
 import { QueryBuilder } from "./query-builder";
 import { Repository } from "./repository";
-import { runMigrations, generateMigration, type Migration } from "./migrations";
+import { runMigrations, generateMigration, type Migration, mapDataTypeToSql} from "./migrations";
 import {
   type DBConfig,
   type CacheConfig,
@@ -22,7 +22,7 @@ import {
   type CacheStats,
   LogLevel,
 } from "./types";
-import { defineModel } from "./model";
+import { defineModel, MetadataStorage } from "./model";
 import type { Hook } from "./hooks";
 
 export class Stabilize {
@@ -42,7 +42,7 @@ export class Stabilize {
     loggerConfig: LoggerConfig = {},
     existingClient?: DBClient,
   ) {
-    this.logger = new ConsoleLogger(loggerConfig);
+    this.logger = new StabilizeLogger(loggerConfig);
     this.client = existingClient || new DBClient(config, this.logger);
     this.cache = existingClient ? null : (cacheConfig.enabled
       ? new Cache(cacheConfig, this.logger)
@@ -131,15 +131,18 @@ export {
   DBClient,
   QueryBuilder,
   Cache,
-  ConsoleLogger,
+  StabilizeLogger,
   DBType,
   DataTypes,
   LogLevel,
   RelationType,
+  MetadataStorage,
+  mapDataTypeToSql,
   StabilizeError,
   runMigrations,
   generateMigration,
   defineModel,
+  
 };
 
 export type {

package/migrations.ts

@@ -133,6 +133,7 @@ export async function generateMigration(
   const columns = MetadataStorage.getColumns(model);
   const validators = MetadataStorage.getValidators(model);
   const versioned = MetadataStorage.isVersioned(model);
+  const timestamps = MetadataStorage.getTimestamps(model);
 
   const columnDefs: string[] = [];
 
@@ -163,6 +164,28 @@ export async function generateMigration(
     columnDefs.push(defParts.join(" "));
   }
 
+  // Add timestamp columns if enabled
+  if (timestamps) {
+    for (const [field, colName] of Object.entries(timestamps)) {
+      // Use the field name defined in the timestamps config
+      let sqlType = dbType === DBType.Postgres ? "TIMESTAMP" : "DATETIME";
+      let def = `${colName} ${sqlType} NOT NULL`;
+
+      // Set default value for createdAt, and optionally for updatedAt
+      if (field === "createdAt") {
+        def += " DEFAULT CURRENT_TIMESTAMP";
+      } else if (field === "updatedAt") {
+        def += " DEFAULT CURRENT_TIMESTAMP";
+        // For MySQL, add ON UPDATE CURRENT_TIMESTAMP
+        if (dbType === DBType.MySQL) {
+          def += " ON UPDATE CURRENT_TIMESTAMP";
+        }
+      }
+
+      columnDefs.push(def);
+    }
+  }
+
   const up: string[] = [`CREATE TABLE IF NOT EXISTS ${tableName} (${columnDefs.join(", ")})`];
   const down: string[] = [`DROP TABLE IF EXISTS ${tableName}`];
 
@@ -194,8 +217,15 @@ function generateHistoryMigration(
   let modByType = dbType === DBType.MySQL ? "VARCHAR(255)" : "TEXT";
   let modAtType = tsType + (dbType === DBType.Postgres ? " DEFAULT CURRENT_TIMESTAMP" : "");
 
+  // Strip constraints for history columns
+  function cleanColumnDef(def: string): string {
+    return def
+      .replace(/\s+PRIMARY\s+KEY\b/gi, "")
+      .replace(/\s+UNIQUE\b/gi, "");
+  }
+
   const historyColumns = [
-    ...columnDefs,
+    ...columnDefs.map(cleanColumnDef),
     `operation ${opType}`,
     `version ${versionType}`,
     `valid_from ${tsType} NOT NULL`,
@@ -264,7 +294,13 @@ export async function runMigrations(config: DBConfig, migrations: Migration[]) {
           }
 
           const insertQuery = formatQuery(`INSERT INTO stabilize_migrations (name, applied_at) VALUES (?, ?)`, dbType);
-          await txClient.query(insertQuery, [name, new Date().toISOString()]);
+          let appliedAt: string;
+          if (dbType === DBType.MySQL) {
+            appliedAt = new Date().toISOString().slice(0, 19).replace("T", " ");
+          } else {
+            appliedAt = new Date().toISOString();
+          }
+          await txClient.query(insertQuery, [name, appliedAt]);
 
           console.log(`Migration ${name} applied successfully.`);
         });
@@ -279,3 +315,4 @@ export async function runMigrations(config: DBConfig, migrations: Migration[]) {
 }
 
 export type { Migration };
+export { mapDataTypeToSql };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stabilize-orm",
-  "version": "1.3.3",
+  "version": "1.3.8",
   "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",

package/repository.ts

@@ -46,6 +46,7 @@ export class Repository<T> {
   private logger: Logger;
   private versioned: boolean;
   private historyTable: string;
+  private model: new (...args: any[]) => T;
 
   /**
    * Creates an instance of Repository.
@@ -87,6 +88,7 @@ export class Repository<T> {
     this.logger = logger;
     this.versioned = MetadataStorage.isVersioned(model);
     this.historyTable = `${this.table}_history`;
+    this.model = model;
   }
 
   /**
@@ -287,15 +289,34 @@ export class Repository<T> {
       "modified_at"
     ];
 
-    const values = propertyKeys.map((k) => entity[k]);
+    // Helper to sanitize each value before inserting into SQLite/Postgres/MySQL
+    function sanitizeSqlValue(val: any, dbType: DBType): string | number | boolean | bigint | null {
+      if (val === undefined) return null;
+      if (val instanceof Date) {
+        if (dbType === DBType.MySQL) {
+          // MySQL DATETIME: 'YYYY-MM-DD HH:MM:SS'
+          return val.toISOString().slice(0, 19).replace('T', ' ');
+        }
+        return val.toISOString();
+      }
+      if (typeof val === "boolean") return val ? 1 : 0;
+      if (
+        typeof val === "string" ||
+        typeof val === "number" ||
+        typeof val === "bigint"
+      ) return val;
+      return null;
+    }
+    const dbType = client.config.type;
+    const values = propertyKeys.map((k) => sanitizeSqlValue(entity[k], dbType));
     const params = [
       ...values,
-      operation,
-      entity.version || 1,
-      new Date(),
-      null,
-      user || "system",
-      new Date()
+      sanitizeSqlValue(operation, dbType),
+      sanitizeSqlValue(entity.version || 1, dbType),
+      sanitizeSqlValue(new Date(), dbType),
+      sanitizeSqlValue(null, dbType),
+      sanitizeSqlValue(user || "system", dbType),
+      sanitizeSqlValue(new Date(), dbType)
     ];
 
     let placeholders: string;