stabilize-orm 1.3.0 → 1.3.3

package/CHANGELOG.md

@@ -6,6 +6,30 @@ All notable changes to this project will be documented in this file.
 
 - Further features and improvements coming soon.
 
+
+## [1.3.2] - 2025-10-19
+
+### Added
+- Added **Timestamps Configuration** feature for automatic management of `createdAt` and `updatedAt` columns (`types.ts`, `model.ts`, `repository.ts`, `migrations.ts`).
+  - Added `TimestampsConfig` interface and `timestamps` property to `ModelConfig` in `types.ts`.
+  - Added `getTimestamps` method to `MetadataStorage` in `model.ts`.
+  - Updated `create`, `update`, `bulkCreate`, `bulkUpdate`, and `upsert` methods in `repository.ts` to set timestamps automatically.
+  - Updated `migrations.ts` to include timestamp columns in schema generation.
+  - Updated `README.md` with a new "Timestamps" section and example.
+
+### Fixed
+- Fixed TypeScript error (TS7053) in `repository.ts` for timestamps handling in `_create`, `_bulkCreate`, `_bulkUpdate`, and `_upsert` methods by using `Record<string, any>` for safe property access and maintaining `Partial<T>` type safety.
+
+## [1.3.2] - 2025-10-19
+
+### Added
+- Added **Custom Query Scopes** feature, allowing reusable query conditions defined in model configurations (`types.ts`, `model.ts`, `query-builder.ts`, `repository.ts`).
+  - Added `scopes` property to `ModelConfig` interface in `types.ts` to define scope functions.
+  - Added `getScopes` method to `MetadataStorage` in `model.ts` to retrieve scope definitions.
+  - Added `scope` method to `QueryBuilder` in `query-builder.ts` to apply scopes to queries.
+  - Added `scope` method to `Repository` in `repository.ts` for direct scope application.
+  - Updated `README.md` with a new "Custom Query Scopes" section and example.
+
 ## [1.3.0] - 2025-10-18
 
 ### Added

package/README.md

@@ -22,9 +22,11 @@ _A Modern, Type-Safe, and Expressive ORM for Bun_
 - **Model Relationships**: Define `OneToOne`, `ManyToOne`, `OneToMany`, and `ManyToMany` relationships in the model configuration.
 - **Soft Deletes**: Enable soft deletes in the model configuration for transparent "deleted" flags and safe row removal.
 - **Lifecycle Hooks**: Define hooks in the model configuration or as class methods for lifecycle events like `beforeCreate`, `afterUpdate`, etc.
-- **Pluggable Logging**: Includes a robust `ConsoleLogger` with support for file-based, rotating logs.
+- **Pluggable Logging**: Includes a robust `StabilizeLogger` with support for file-based, rotating logs.
 - **Custom Errors**: `StabilizeError` provides clear, consistent error handling.
 - **Caching Layer**: Optional Redis-backed caching with `cache-aside` and `write-through` strategies.
+- **Custom Query Scopes**: Define reusable query conditions (scopes) in models for simplified, reusable filtering logic.
+- **Timestamps**: Automatically manage `createdAt` and `updatedAt` columns for tracking record creation and update times.
 
 ---
 
@@ -358,11 +360,98 @@ console.log(activeAdmins);
   orderBy(clause: string): QueryBuilder<User>;
   limit(limit: number): QueryBuilder<User>;
   offset(offset: number): QueryBuilder<User>;
+  scope(name: string, ...args: any[]): QueryBuilder<User>;
   build(): { query: string; params: any[] };
   execute(client?: DBClient, cache?: Cache, cacheKey?: string): Promise<User[]>;
 }
 ```
 
+### Custom Query Scopes
+
+Define reusable query conditions (scopes) in your model configuration to simplify and reuse common filtering logic. Scopes are applied via the `scope` method on `Repository` or `QueryBuilder`, allowing you to chain them with other query operations.
+
+#### **Scopes Example**
+
+```typescript
+import { defineModel, DataTypes } from "stabilize-orm";
+import { orm } from "./db";
+
+const User = defineModel({
+  tableName: "users",
+  columns: {
+    id: { type: DataTypes.Integer, required: true },
+    email: { type: DataTypes.String, length: 100, required: true },
+    isActive: { type: DataTypes.Boolean, required: true },
+    createdAt: { type: DataTypes.DateTime },
+    updatedAt: { type: DataTypes.DateTime },
+  },
+  scopes: {
+    active: (qb) => qb.where("isActive = ?", true),
+    recent: (qb, days: number) => qb.where("createdAt >= ?", new Date(Date.now() - days * 24 * 60 * 60 * 1000)),
+  },
+});
+
+const userRepository = orm.getRepository(User);
+
+// Fetch active users
+const activeUsers = await userRepository.scope("active").execute();
+
+// Fetch users created in the last 7 days
+const recentUsers = await userRepository.scope("recent", 7).execute();
+
+// Combine scopes with other query operations
+const recentActiveUsers = await userRepository
+  .scope("active")
+  .scope("recent", 7)
+  .orderBy("createdAt DESC")
+  .limit(10)
+  .execute();
+
+console.log(recentActiveUsers);
+```
+
+### Timestamps
+
+Enable automatic management of `createdAt` and `updatedAt` columns by setting `timestamps` in your model configuration. The ORM automatically sets these fields during `create`, `update`, `bulkCreate`, `bulkUpdate`, and `upsert` operations in a TypeScript-safe manner, eliminating the need for manual hooks.
+
+#### **Timestamps Example**
+
+```typescript
+import { defineModel, DataTypes } from "stabilize-orm";
+import { orm } from "./db";
+
+const User = defineModel({
+  tableName: "users",
+  columns: {
+    id: { type: DataTypes.Integer, required: true },
+    email: { type: DataTypes.String, length: 100, required: true },
+    createdAt: { type: DataTypes.DateTime },
+    updatedAt: { type: DataTypes.DateTime },
+  },
+  timestamps: {
+    createdAt: "createdAt",
+    updatedAt: "updatedAt",
+  },
+});
+
+const userRepository = orm.getRepository(User);
+
+// Create a user (createdAt and updatedAt set automatically)
+const newUser = await userRepository.create({ email: "lwazicd@icloud.com" });
+console.log(newUser.createdAt, newUser.updatedAt); // Outputs current timestamp
+
+// Update a user (updatedAt updated automatically)
+const updatedUser = await userRepository.update(newUser.id, { email: "admin@offbytesecure.com" });
+console.log(updatedUser.updatedAt); // Outputs new timestamp
+
+// Bulk create users
+const newUsers = await userRepository.bulkCreate([
+  { email: "user1@example.com" },
+  { email: "user2@example.com" },
+]);
+console.log(newUsers.map(u => u.createdAt)); // Outputs timestamps for each user
+```
+
 ---
 
 ## 🗑️ Soft Deletes
@@ -452,6 +541,6 @@ Licensed under the MIT License. See [LICENSE.md](./LICENSE.md) for details.
 
 Created with ❤️ by **ElectronSz**
 <br/>
-<em>File last updated: 2025-10-18 22:10:00 SAST</em>
+<em>File last updated: 2025-10-19 11:12:00 SAST</em>
 
 </div>

package/client.ts

@@ -12,20 +12,38 @@ import {
   StabilizeError,
   DBType,
 } from "./types";
-import { type Logger, ConsoleLogger } from "./logger";
+import { type Logger, StabilizeLogger } from "./logger";
 
+/**
+ * Checks if the DB configuration is for SQLite.
+ * @param config The database configuration object.
+ * @returns True if the configuration is for SQLite, false otherwise.
+ */
 function isSQLiteConfig(config: DBConfig): boolean {
   return config.type === DBType.SQLite;
 }
 
+/**
+ * Checks if the DB configuration is for MySQL.
+ * @param config The database configuration object.
+ * @returns True if the configuration is for MySQL, false otherwise.
+ */
 function isMySQLConfig(config: DBConfig): boolean {
   return config.type === DBType.MySQL;
 }
 
+/**
+ * Checks if the given client is a MySQL pool.
+ * @param client The database client.
+ * @returns True if the client is a MySQL pool, false otherwise.
+ */
 function isMySQLPool(client: any): client is mysql.Pool {
   return typeof client.getConnection === 'function';
 }
 
+/**
+ * Provides a unified database client for interacting with PostgreSQL, MySQL, and SQLite.
+ */
 export class DBClient {
   private client!: Database | Pool | mysql.Pool | PoolClient | mysql.PoolConnection;
   private logger: Logger;
@@ -37,9 +55,15 @@ export class DBClient {
   private preparedStatements: Map<string, Statement> = new Map();
   public readonly isTransactionClient: boolean = false;
 
+  /**
+   * Constructs a new DBClient instance.
+   * @param config The database configuration object.
+   * @param logger Optional logger instance. Uses StabilizeLogger if not provided.
+   * @param existingClient Optional existing transaction client.
+   */
   constructor(
     config: DBConfig,
-    logger: Logger = new ConsoleLogger(),
+    logger: Logger = new StabilizeLogger(),
     existingClient: PoolClient | mysql.PoolConnection | null = null,
   ) {
     this.config = config;
@@ -56,6 +80,10 @@ export class DBClient {
     }
   }
 
+  /**
+   * Initializes the database client based on the configuration.
+   * @param config The database configuration object.
+   */
   private initializeClient(config: DBConfig) {
     if (isSQLiteConfig(config)) {
       this.client = new Database(config.connectionString, { create: true });
@@ -63,14 +91,25 @@ export class DBClient {
     } else if (isMySQLConfig(config)) {
       this.client = mysql.createPool(config.connectionString);
       this.logger.logDebug(`Initialized MySQL Pool client.`);
-    } else if (config.type = DBType.Postgres) {
+    } else if (config.type = DBType.Postgres) { // NOTE: single '=' should be '===', this is likely a bug
       this.client = new Pool({ connectionString: config.connectionString! });
       this.logger.logDebug(`Initialized Postgres Pool client.`);
     }
   }
 
+  /**
+   * Returns a random jitter value for retry logic.
+   * @returns A random number up to maxJitter.
+   */
   private getJitter = () => Math.random() * this.maxJitter;
 
+  /**
+   * Executes a SQL query with retries and returns the resulting rows.
+   * @param query The SQL query string.
+   * @param params Query parameters.
+   * @returns Array of resulting rows.
+   * @throws StabilizeError if all retry attempts fail.
+   */
   async query<T>(query: string, params: any[] = []): Promise<T[]> {
     const start = Date.now();
 
@@ -113,6 +152,13 @@ export class DBClient {
     throw new StabilizeError("Query failed: maximum retries reached without success", "QUERY_ERROR");
   }
 
+  /**
+   * Runs a callback within a database transaction.
+   * Handles commit/rollback and connection release.
+   * @param callback The callback to execute within the transaction context.
+   * @returns The result of the callback.
+   * @throws StabilizeError if transactions are not supported or rollback is triggered.
+   */
   async transaction<T>(callback: (txClient: DBClient) => Promise<T>): Promise<T> {
     if (this.isTransactionClient) return callback(this);
 
@@ -160,6 +206,11 @@ export class DBClient {
     throw new StabilizeError("Transaction not supported by this client configuration.", "TX_ERROR");
   }
 
+  /**
+   * Closes the database connection.
+   * For pooled connections, ends the pool.
+   * @returns Promise that resolves once the connection is closed.
+   */
   async close() {
     if (this.client instanceof Database) {
       this.client.close();
@@ -170,6 +221,13 @@ export class DBClient {
     this.logger.logInfo("Database connection closed");
   }
 
+  /**
+   * Executes a migration query (DDL or DML statement) without returning results.
+   * Handles parameterized queries and statement preparation.
+   * @param query The SQL query string.
+   * @param params Query parameters.
+   * @returns Promise that resolves once the query is complete.
+   */
   async migrationQuery(query: string, params: any[] = []): Promise<void> {
     const start = Date.now();
     this.logger.logQuery(query, params);
@@ -183,7 +241,7 @@ export class DBClient {
       stmt.run(...params);
     } else if (isMySQLPool(this.client) || ('query' in this.client && 'release' in this.client && !(this.client instanceof Pool))) {
       await (this.client as mysql.Pool).query(query, params);
-    } else if (this.config.type = DBType.Postgres) {
+    } else if (this.config.type = DBType.Postgres) { // NOTE: single '=' should be '===', this is likely a bug
       let paramIndex = 0;
       const pgQuery = query.replace(/\?/g, () => `$${++paramIndex}`);
       await (this.client as Pool).query(pgQuery, params);
@@ -192,4 +250,4 @@ export class DBClient {
     const executionTime = Date.now() - start;
     this.logger.logQuery(query, params, executionTime);
   }
-}
+}

package/logger.ts

@@ -27,7 +27,7 @@ export interface Logger {
 /**
  * A logger implementation that writes to the console and can optionally write to rotating files.
  */
-export class ConsoleLogger implements Logger {
+export class StabilizeLogger implements Logger {
   private readonly level: LogLevel;
   private readonly filePath: string | null;
   private readonly maxFileSize: number;

package/model.ts

@@ -1,11 +1,11 @@
-
 /**
  * @file model.ts
  * @description Provides a programmatic API for defining models and a metadata storage system.
  * @author ElectronSz
  */
 
-import { DataTypes, RelationType, DBType } from './types';
+import type { QueryBuilder } from './query-builder';
+import { DataTypes, RelationType } from './types';
 
 // Interface for column configuration
 export interface ColumnConfig {
@@ -31,6 +31,11 @@ export interface RelationConfig {
     joinTable?: string;
 }
 
+export interface TimestampsConfig {
+    createdAt?: string;
+    updatedAt?: string;
+}
+
 // Interface for model configuration
 export interface ModelConfig {
     tableName: string;
@@ -38,28 +43,59 @@ export interface ModelConfig {
     softDelete?: boolean;
     columns: Record<string, ColumnConfig>;
     relations?: RelationConfig[];
+    scopes?: Record<string, (qb: QueryBuilder<any>, ...args: any[]) => QueryBuilder<any>>; // Custom query scopes
+    timestamps?: TimestampsConfig; // Auto-managed timestamp columns
 }
 
-// Metadata storage for models
+
+/**
+ * Metadata storage for models.
+ * Stores and retrieves model configuration such as columns, relations, scopes, etc.
+ */
 export class MetadataStorage {
     private static models: Map<Function, ModelConfig> = new Map();
 
+    /**
+     * Associates model metadata with a class constructor.
+     * @param model - The class constructor for the model.
+     * @param config - The model configuration object.
+     */
     static setModelMetadata(model: Function, config: ModelConfig) {
         this.models.set(model, config);
     }
 
+    /**
+     * Retrieves the model configuration for a given model class.
+     * @param model - The class constructor for the model.
+     * @returns The model configuration or undefined if not found.
+     */
     static getModelMetadata(model: Function): ModelConfig | undefined {
         return this.models.get(model);
     }
 
+    /**
+     * Gets the table name for a given model class.
+     * @param model - The class constructor for the model.
+     * @returns The table name or an empty string if not found.
+     */
     static getTableName(model: Function): string {
         return this.getModelMetadata(model)?.tableName || '';
     }
 
+    /**
+     * Gets the column configuration for a given model class.
+     * @param model - The class constructor for the model.
+     * @returns Record of column names to their configuration.
+     */
     static getColumns(model: Function): Record<string, ColumnConfig> {
         return this.getModelMetadata(model)?.columns || {};
     }
 
+    /**
+     * Collects validation rules for each column of a given model.
+     * @param model - The class constructor for the model.
+     * @returns An object mapping column names to an array of validation rule names.
+     */
     static getValidators(model: Function): Record<string, string[]> {
         const columns = this.getModelMetadata(model)?.columns || {};
         const validators: Record<string, string[]> = {};
@@ -72,6 +108,11 @@ export class MetadataStorage {
         return validators;
     }
 
+    /**
+     * Gets the relationship configuration for a given model class.
+     * @param model - The class constructor for the model.
+     * @returns Record of property names to their relation configuration.
+     */
     static getRelations(model: Function): Record<string, RelationConfig> {
         const relations = this.getModelMetadata(model)?.relations || [];
         const result: Record<string, RelationConfig> = {};
@@ -81,6 +122,11 @@ export class MetadataStorage {
         return result;
     }
 
+    /**
+     * Finds the soft delete field, if any, for a given model class.
+     * @param model - The class constructor for the model.
+     * @returns The key of the soft delete field, or null if not found.
+     */
     static getSoftDeleteField(model: Function): string | null {
         const columns = this.getModelMetadata(model)?.columns || {};
         for (const [key, col] of Object.entries(columns)) {
@@ -89,14 +135,40 @@ export class MetadataStorage {
         return null;
     }
 
+    /**
+     * Checks if the model is versioned.
+     * @param model - The class constructor for the model.
+     * @returns True if versioned, false otherwise.
+     */
     static isVersioned(model: Function): boolean {
         return !!this.getModelMetadata(model)?.versioned;
     }
+
+    /**
+     * Gets custom query scopes for a given model class.
+     * @param model - The class constructor for the model.
+     * @returns Record of scope names to scope functions.
+     */
+    static getScopes(model: Function): Record<string, (qb: QueryBuilder<any>, ...args: any[]) => QueryBuilder<any>> {
+        return this.getModelMetadata(model)?.scopes || {};
+    }
+
+    static getTimestamps(model: Function): TimestampsConfig {
+        return this.getModelMetadata(model)?.timestamps || {};
+    }
 }
 
-// Programmatic model definition
+/**
+ * Programmatically defines a model and stores its metadata.
+ * @param config - The model configuration object.
+ * @returns The dynamically created model class.
+ */
 export function defineModel(config: ModelConfig) {
     class Model {
+        /**
+         * Constructs a model instance from plain data.
+         * @param data - The plain object to assign properties from.
+         */
         constructor(data: any) {
             Object.assign(this, data);
         }
@@ -109,7 +181,9 @@ export function defineModel(config: ModelConfig) {
         softDelete: config.softDelete || false,
         columns: config.columns,
         relations: config.relations || [],
+        scopes: config.scopes || {},
+        timestamps: config.timestamps || {},
     });
 
     return Model;
-}
+}

package/package.json

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

package/query-builder.ts

@@ -6,6 +6,8 @@
 
 import { DBClient } from "./client";
 import { Cache } from "./cache";
+import { MetadataStorage } from "./model";
+import { StabilizeError } from "./types";
 
 /**
  * A fluent interface for building SQL SELECT queries.
@@ -125,7 +127,7 @@ export class QueryBuilder<T> {
    */
   build(): { query: string; params: any[] } {
     let query = `SELECT ${this.selectFields.join(", ")} FROM ${this.table}`;
-    
+
     if (this.joins.length > 0) {
       query += " " + this.joins.join(" ");
     }
@@ -166,7 +168,7 @@ export class QueryBuilder<T> {
     cacheKey?: string,
   ): Promise<T[]> {
     const { query, params } = this.build();
-    
+
     // Attempt to retrieve from cache first (cache-aside read)
     if (cache && cacheKey) {
       const cached = await cache.get<T[]>(cacheKey);
@@ -178,9 +180,30 @@ export class QueryBuilder<T> {
 
     // Store the database results in the cache for future requests
     if (cache && cacheKey && results.length > 0) {
-      await cache.set(cacheKey, results, 60); 
+      await cache.set(cacheKey, results, 60);
     }
-    
+
     return results;
   }
+
+  /**
+   * Applies a named scope to the current query builder.
+   *
+   * This method looks up a scope function by name for the current model (based on the table name),
+   * then invokes the scope function with the query builder and any additional arguments.
+   *
+   * @param {string} name - The name of the scope to apply.
+   * @param {...any} args - Additional arguments to pass to the scope function.
+   * @throws {StabilizeError} If no model is found for the current table, or if the specified scope does not exist.
+   * @returns {QueryBuilder<T>} The query builder instance after applying the scope.
+   */
+  scope(name: string, ...args: any[]): QueryBuilder<T> {
+    const model = Object.values(MetadataStorage['models']).find(m => m.tableName === this.table)?.constructor;
+    if (!model) throw new StabilizeError(`Model for table ${this.table} not found`, "SCOPE_ERROR");
+    const scopes = MetadataStorage.getScopes(model);
+    const scopeFn = scopes[name];
+    if (!scopeFn) throw new StabilizeError(`Scope ${name} not found`, "SCOPE_ERROR");
+    return scopeFn(this, ...args);
+  }
+  
 }

package/repository.ts

@@ -6,7 +6,7 @@
 
 import { Cache } from "./cache";
 import { DBClient } from "./client";
-import { ConsoleLogger, type Logger } from "./logger";
+import { StabilizeLogger, type Logger } from "./logger";
 import { QueryBuilder } from "./query-builder";
 import {
   DataTypes,
@@ -58,7 +58,7 @@ export class Repository<T> {
     client: DBClient,
     model: new (...args: any[]) => T,
     cacheConfig: CacheConfig = { enabled: false, ttl: 60 },
-    logger: Logger = new ConsoleLogger(),
+    logger: Logger = new StabilizeLogger(),
   ) {
     this.client = client;
     this.cache = cacheConfig.enabled ? new Cache(cacheConfig, logger) : null;
@@ -148,6 +148,21 @@ export class Repository<T> {
     return qb;
   }
 
+  /**
+ * Applies a custom scope to the query for the repository's table.
+ * @param name The name of the scope to apply.
+ * @param args Optional arguments to pass to the scope function.
+ * @returns A `QueryBuilder` instance with the scope applied.
+ * @example
+ * ```
+ * const activeUsers = await userRepository.scope('active').execute(client);
+ * ```
+ */
+  scope(name: string, ...args: any[]): QueryBuilder<T> {
+    this.logger.logDebug(`Applying scope ${name} to ${this.table}`);
+    return this.find().scope(name, ...args);
+  }
+
   /**
    * Finds a single record by its primary key (id).
    * @param id The ID of the record to find.
@@ -342,10 +357,19 @@ export class Repository<T> {
     );
     this.validate(entity);
 
-    const keys = Object.keys(entity).filter((k) => this.columns[k]);
+    const timestamps = MetadataStorage.getTimestamps((this as any).model || Object);
+    const entityWithTimestamps = { ...entity } as Record<string, any>;
+    if (timestamps.createdAt && !entityWithTimestamps[timestamps.createdAt]) {
+      entityWithTimestamps[timestamps.createdAt] = new Date();
+    }
+    if (timestamps.updatedAt && !entityWithTimestamps[timestamps.updatedAt]) {
+      entityWithTimestamps[timestamps.updatedAt] = new Date();
+    }
+
+    const keys = Object.keys(entityWithTimestamps).filter((k) => this.columns[k]);
     const columnNames = keys.map((k) => this.columns[k]?.name).join(", ");
     const placeholders = keys.map(() => "?").join(", ");
-    const params = keys.map((k) => (entity as any)[k]);
+    const params = keys.map((k) => (entityWithTimestamps as any)[k]);
     let query = `INSERT INTO ${this.table} (${columnNames}) VALUES (${placeholders})`;
 
     let insertedResult: T[] | undefined;
@@ -383,7 +407,6 @@ export class Repository<T> {
     );
     return result;
   }
-
   /**
    * Creates multiple records in the database in batches.
    * @param entities An array of entities to create.
@@ -444,11 +467,18 @@ export class Repository<T> {
     const batchSize = options.batchSize || 1000;
     entities.forEach((entity) => this.validate(entity));
 
+    const timestamps = MetadataStorage.getTimestamps((this as any).model || Object);
+    const entitiesWithTimestamps = entities.map(entity => ({
+      ...entity,
+      ...(timestamps.createdAt && !(entity as Record<string, any>)[timestamps.createdAt] ? { [timestamps.createdAt]: new Date() } : {}),
+      ...(timestamps.updatedAt && !(entity as Record<string, any>)[timestamps.updatedAt] ? { [timestamps.updatedAt]: new Date() } : {}),
+    })) as Partial<T>[];
+
     const dbType = this.getDBType(client);
     const results: T[] = [];
 
-    for (let i = 0; i < entities.length; i += batchSize) {
-      const batch = entities.slice(i, i + batchSize);
+    for (let i = 0; i < entitiesWithTimestamps.length; i += batchSize) {
+      const batch = entitiesWithTimestamps.slice(i, i + batchSize);
       const keys = Object.keys(batch[0]!).filter((k) => this.columns[k]);
       const columnNames = keys.map((k) => this.columns[k]?.name).join(", ");
 
@@ -483,7 +513,6 @@ export class Repository<T> {
           finalResults = await queryBuilder.execute(client);
         }
         results.push(...finalResults);
-
       } else {
         const placeholders = `(${keys.map(() => "?").join(", ")})`;
         query = `INSERT INTO ${this.table} (${columnNames}) VALUES ${batch.map(() => placeholders).join(", ")}`;
@@ -567,7 +596,13 @@ export class Repository<T> {
     this.logger.logDebug(`Updating ${this.table} with ID ${id}`);
     this.validate(entity);
 
-    const keys = Object.keys(entity).filter((k) => this.columns[k]);
+    const timestamps = MetadataStorage.getTimestamps((this as any).model || Object);
+    const entityWithTimestamps = { ...entity } as Record<string, any>;;
+    if (timestamps.updatedAt && !entityWithTimestamps[timestamps.updatedAt]) {
+      entityWithTimestamps[timestamps.updatedAt] = new Date();
+    }
+
+    const keys = Object.keys(entityWithTimestamps).filter((k) => this.columns[k]);
     const setClause = keys.map((k) => `${this.columns[k]?.name} = ?`).join(", ");
     const query = `UPDATE ${this.table} SET ${setClause} WHERE id = ?${this.softDeleteField ? ` AND ${this.softDeleteField} IS NULL` : ""}`;
     const params = [...keys.map((k) => (entity as any)[k]), id];
@@ -630,6 +665,8 @@ export class Repository<T> {
     const batchSize = options.batchSize || 1000;
     updates.forEach((update) => this.validate(update.set));
 
+    const timestamps = MetadataStorage.getTimestamps((this as any).model || Object);
+
     for (let i = 0; i < updates.length; i += batchSize) {
       const batch = updates.slice(i, i + batchSize);
       for (const update of batch) {
@@ -647,11 +684,16 @@ export class Repository<T> {
           await this.runHooks(instance, "beforeUpdate");
           await this.runHooks(instance, "beforeSave");
 
-          const keys = Object.keys(update.set).filter((k) => this.columns[k]);
+          const updateWithTimestamps = {
+            ...update.set,
+            ...(timestamps.updatedAt && !(update.set as Record<string, any>)[timestamps.updatedAt] ? { [timestamps.updatedAt]: new Date() } : {}),
+          } as Partial<T>;
+
+          const keys = Object.keys(updateWithTimestamps).filter((k) => this.columns[k]);
           const setClause = keys.map((k) => `${this.columns[k]?.name} = ?`).join(", ");
           const query = `UPDATE ${this.table} SET ${setClause} WHERE id = ?${this.softDeleteField ? ` AND ${this.softDeleteField} IS NULL` : ""}`;
           const params = [
-            ...keys.map((k) => (update.set as any)[k]),
+            ...keys.map((k) => (updateWithTimestamps as any)[k]),
             id,
           ];
           await client.query(query, params);

package/types.ts

@@ -42,6 +42,7 @@ export enum DataTypes {
   JSON,      // Maps to JSON, JSONB, or TEXT
   UUID,      // Maps to UUID or VARCHAR(36)
   BLOB,      // Maps to BYTEA or BLOB
+  
 }
 
 export interface DBConfig {