webspresso 0.0.102 → 0.0.103

package/core/orm/model.js

@@ -4,9 +4,11 @@
  * @module core/orm/model
  */
 
+const z = require('zod');
 const { trimUrlPathSlashes } = require('../url-path-normalize');
-const { extractColumnsFromSchema } = require('./schema-helpers');
+const { createSchemaHelpers, extractColumnsFromSchema } = require('./schema-helpers');
 const { ModelEvents, Hooks } = require('./events');
+const zdb = z ? createSchemaHelpers(z) : null;
 
 /**
  * Global model registry
@@ -34,6 +36,10 @@ function defineModel(options) {
     queryLimits = {},
     cache: cacheOption,
     searchable,
+    timestamps: timestampsOpt,
+    softDelete: softDeleteOpt,
+    softDeletes: softDeletesOpt,
+    options: nestedOptions = {},
   } = options;
 
   // Validate required fields
@@ -43,15 +49,94 @@ function defineModel(options) {
   if (!table || typeof table !== 'string') {
     throw new Error('Model table is required and must be a string');
   }
-  if (!schema || typeof schema.parse !== 'function') {
+  if (!schema || typeof schema !== 'object' || (typeof schema.parse !== 'function' && Object.keys(schema).length === 0)) {
     throw new Error('Model schema is required and must be a Zod schema');
   }
 
-  let normalizedSchema = schema;
-  if (schema && schema.shape) {
-    for (const [key, val] of Object.entries(schema.shape)) {
+  // Resolve timestamps and softDelete options (from top-level flags, nested options, or scopes)
+  const timestampsConfig = timestampsOpt !== undefined
+    ? timestampsOpt
+    : (nestedOptions.timestamps !== undefined ? nestedOptions.timestamps : scopes.timestamps);
+
+  const softDeleteConfig = softDeleteOpt !== undefined
+    ? softDeleteOpt
+    : (softDeletesOpt !== undefined
+        ? softDeletesOpt
+        : (nestedOptions.softDelete !== undefined
+            ? nestedOptions.softDelete
+            : (nestedOptions.softDeletes !== undefined
+                ? nestedOptions.softDeletes
+                : scopes.softDelete)));
+
+  const isPlainObject = typeof schema.parse !== 'function';
+  const injectedFields = {};
+
+  if (timestampsConfig) {
+    const isSnake = typeof timestampsConfig === 'object'
+      ? Boolean(timestampsConfig.snakeCase || timestampsConfig.format === 'snake')
+      : (timestampsConfig === 'snake');
+    const createdCol = (typeof timestampsConfig === 'object' && timestampsConfig.createdAt)
+      || (isSnake ? 'created_at' : 'createdAt');
+    const updatedCol = (typeof timestampsConfig === 'object' && timestampsConfig.updatedAt)
+      || (isSnake ? 'updated_at' : 'updatedAt');
+
+    const hasCreated = isPlainObject
+      ? (schema[createdCol] !== undefined || schema.created_at !== undefined || schema.createdAt !== undefined)
+      : (schema.shape && (schema.shape[createdCol] !== undefined || schema.shape.created_at !== undefined || schema.shape.createdAt !== undefined));
+    const hasUpdated = isPlainObject
+      ? (schema[updatedCol] !== undefined || schema.updated_at !== undefined || schema.updatedAt !== undefined)
+      : (schema.shape && (schema.shape[updatedCol] !== undefined || schema.shape.updated_at !== undefined || schema.shape.updatedAt !== undefined));
+
+    if (!hasCreated && zdb) {
+      injectedFields[createdCol] = zdb.timestamp({ auto: 'create' });
+    }
+    if (!hasUpdated && zdb) {
+      injectedFields[updatedCol] = zdb.timestamp({ auto: 'update' });
+    }
+  }
+
+  if (softDeleteConfig) {
+    const isSnake = typeof softDeleteConfig === 'object'
+      ? Boolean(softDeleteConfig.snakeCase || softDeleteConfig.format === 'snake')
+      : (softDeleteConfig === 'snake');
+    const deletedCol = (typeof softDeleteConfig === 'object' && softDeleteConfig.deletedAt)
+      || (isSnake ? 'deleted_at' : 'deletedAt');
+
+    const hasDeleted = isPlainObject
+      ? (schema[deletedCol] !== undefined || schema.deleted_at !== undefined || schema.deletedAt !== undefined)
+      : (schema.shape && (schema.shape[deletedCol] !== undefined || schema.shape.deleted_at !== undefined || schema.shape.deletedAt !== undefined));
+
+    if (!hasDeleted && zdb) {
+      injectedFields[deletedCol] = zdb.softDelete();
+    }
+  }
+
+  let normalizedSchema;
+  if (isPlainObject) {
+    if (!zdb) {
+      throw new Error('Zod is required to compile schema object');
+    }
+    normalizedSchema = zdb.schema({
+      ...schema,
+      ...injectedFields,
+    });
+  } else {
+    normalizedSchema = schema;
+    if (Object.keys(injectedFields).length > 0 && typeof normalizedSchema.extend === 'function') {
+      const finalizedInjected = {};
+      for (const [key, field] of Object.entries(injectedFields)) {
+        finalizedInjected[key] = (field && typeof field._finalize === 'function')
+          ? field._finalize()
+          : field;
+      }
+      normalizedSchema = normalizedSchema.extend(finalizedInjected);
+    }
+  }
+
+  if (normalizedSchema && normalizedSchema.shape) {
+    for (const [key, val] of Object.entries(normalizedSchema.shape)) {
       if (val && typeof val._finalize === 'function') {
-        schema.shape[key] = val._finalize();
+        normalizedSchema.shape[key] = val._finalize();
       }
     }
   }
@@ -105,13 +190,19 @@ function defineModel(options) {
     name,
     table,
     schema: normalizedSchema,
+    _partialSchema: typeof normalizedSchema?.partial === 'function' ? normalizedSchema.partial() : normalizedSchema,
     primaryKey,
     relations: normalizedRelations,
     scopes: {
-      softDelete: scopes.softDelete || false,
-      timestamps: scopes.timestamps || false,
+      softDelete: Boolean(softDeleteConfig),
+      timestamps: Boolean(timestampsConfig),
       tenant: scopes.tenant || null,
     },
+    options: {
+      timestamps: timestampsConfig || false,
+      softDelete: softDeleteConfig || false,
+      ...nestedOptions,
+    },
     columns,
     admin: {
       enabled: admin.enabled === true, // Explicit boolean check

package/core/orm/query-builder.js

@@ -42,7 +42,7 @@ class QueryBuilder {
   constructor(model, knex, initialContext, cacheLayer = null) {
     this.model = model;
     this.knex = knex;
-    this.scopeContext = initialContext || createScopeContext();
+    this.scopeContext = initialContext ? { ...initialContext } : createScopeContext();
     this.cacheLayer = cacheLayer;
     this.jsonColumns = getJsonColumns(model);
 
@@ -78,11 +78,11 @@ class QueryBuilder {
   where(columnOrConditions, operatorOrValue, value) {
     // Object form: where({ column: value, ... })
     if (typeof columnOrConditions === 'object' && columnOrConditions !== null) {
-      for (const [col, val] of Object.entries(columnOrConditions)) {
+      for (const col of Object.keys(columnOrConditions)) {
         this.state.wheres.push({
           column: col,
           operator: '=',
-          value: val,
+          value: columnOrConditions[col],
           boolean: 'and',
         });
       }
@@ -176,6 +176,22 @@ class QueryBuilder {
     return this;
   }
 
+  /**
+   * Add a WHERE NOT clause (col != val or multiple columns)
+   * @param {string|Object} column - Column name or object of { col: val }
+   * @param {*} [value] - Value to compare against
+   * @returns {this}
+   */
+  whereNot(column, value) {
+    if (typeof column === 'object' && column !== null) {
+      for (const [col, val] of Object.entries(column)) {
+        this.where(col, '!=', val);
+      }
+      return this;
+    }
+    return this.where(column, '!=', value);
+  }
+
   /**
    * Add a WHERE NOT IN clause
    * @param {string} column - Column name
@@ -477,27 +493,37 @@ class QueryBuilder {
    * @returns {Promise<Object|null>}
    */
   async first() {
-    const ctx = createEventContext(this.model.name, 'find', this._hookTrx());
+    const shouldEmit = (
+      ModelEvents.hasListeners(this.model.name, Hooks.BEFORE_FIND) ||
+      ModelEvents.hasListeners(this.model.name, Hooks.AFTER_FIND)
+    );
+    const ctx = shouldEmit ? createEventContext(this.model.name, 'find', this._hookTrx()) : null;
     const self = this;
 
     async function loadFromDb() {
-      await ModelEvents.emitAsync(self.model.name, Hooks.BEFORE_FIND, {}, ctx);
-      if (ctx.isCancelled) {
-        throw new HookCancellationError(ctx.cancelReason, self.model.name, Hooks.BEFORE_FIND);
+      if (shouldEmit) {
+        await ModelEvents.emitAsync(self.model.name, Hooks.BEFORE_FIND, {}, ctx);
+        if (ctx.isCancelled) {
+          throw new HookCancellationError(ctx.cancelReason, self.model.name, Hooks.BEFORE_FIND);
+        }
       }
 
       const qb = self.toKnex().first();
       const result = await qb;
       if (!result) return null;
 
-      deserializeJsonFields(result, self.jsonColumns);
+      if (self.jsonColumns.size > 0) {
+        deserializeJsonFields(result, self.jsonColumns);
+      }
 
       const withs = self.getWiths();
       if (withs.length > 0) {
         await loadRelations([result], ensureArray(withs), self.model, self.getActiveKnex(), self.scopeContext);
       }
 
-      ModelEvents.emit(self.model.name, Hooks.AFTER_FIND, result, ctx);
+      if (shouldEmit) {
+        ModelEvents.emit(self.model.name, Hooks.AFTER_FIND, result, ctx);
+      }
       return result;
     }
 
@@ -543,19 +569,27 @@ class QueryBuilder {
    * @returns {Promise<Object[]>}
    */
   async list() {
-    const ctx = createEventContext(this.model.name, 'find', this._hookTrx());
+    const shouldEmit = (
+      ModelEvents.hasListeners(this.model.name, Hooks.BEFORE_FIND) ||
+      ModelEvents.hasListeners(this.model.name, Hooks.AFTER_FIND)
+    );
+    const ctx = shouldEmit ? createEventContext(this.model.name, 'find', this._hookTrx()) : null;
     const self = this;
 
     async function loadFromDb() {
-      await ModelEvents.emitAsync(self.model.name, Hooks.BEFORE_FIND, {}, ctx);
-      if (ctx.isCancelled) {
-        throw new HookCancellationError(ctx.cancelReason, self.model.name, Hooks.BEFORE_FIND);
+      if (shouldEmit) {
+        await ModelEvents.emitAsync(self.model.name, Hooks.BEFORE_FIND, {}, ctx);
+        if (ctx.isCancelled) {
+          throw new HookCancellationError(ctx.cancelReason, self.model.name, Hooks.BEFORE_FIND);
+        }
       }
 
       const results = await self.toKnex();
 
-      for (const record of results) {
-        deserializeJsonFields(record, self.jsonColumns);
+      if (self.jsonColumns.size > 0) {
+        for (const record of results) {
+          deserializeJsonFields(record, self.jsonColumns);
+        }
       }
 
       const withs = self.getWiths();
@@ -563,8 +597,10 @@ class QueryBuilder {
         await loadRelations(results, ensureArray(withs), self.model, self.getActiveKnex(), self.scopeContext);
       }
 
-      for (const record of results) {
-        ModelEvents.emit(self.model.name, Hooks.AFTER_FIND, record, ctx);
+      if (shouldEmit) {
+        for (const record of results) {
+          ModelEvents.emit(self.model.name, Hooks.AFTER_FIND, record, ctx);
+        }
       }
       return results;
     }
@@ -676,13 +712,19 @@ class QueryBuilder {
     perPage = validated.perPage;
     page = Math.max(1, parseInt(page, 10) || 1);
 
-    const ctx = createEventContext(this.model.name, 'find', this._hookTrx());
+    const shouldEmit = (
+      ModelEvents.hasListeners(this.model.name, Hooks.BEFORE_FIND) ||
+      ModelEvents.hasListeners(this.model.name, Hooks.AFTER_FIND)
+    );
+    const ctx = shouldEmit ? createEventContext(this.model.name, 'find', this._hookTrx()) : null;
     const self = this;
 
     async function loadFromDb() {
-      await ModelEvents.emitAsync(self.model.name, Hooks.BEFORE_FIND, {}, ctx);
-      if (ctx.isCancelled) {
-        throw new HookCancellationError(ctx.cancelReason, self.model.name, Hooks.BEFORE_FIND);
+      if (shouldEmit) {
+        await ModelEvents.emitAsync(self.model.name, Hooks.BEFORE_FIND, {}, ctx);
+        if (ctx.isCancelled) {
+          throw new HookCancellationError(ctx.cancelReason, self.model.name, Hooks.BEFORE_FIND);
+        }
       }
 
       const base = self.toKnex({ includeLimitOffset: false });
@@ -693,8 +735,10 @@ class QueryBuilder {
       const offset = (page - 1) * perPage;
       const data = await base.clone().limit(perPage).offset(offset);
 
-      for (const record of data) {
-        deserializeJsonFields(record, self.jsonColumns);
+      if (self.jsonColumns.size > 0) {
+        for (const record of data) {
+          deserializeJsonFields(record, self.jsonColumns);
+        }
       }
 
       const withs = self.getWiths();
@@ -702,8 +746,10 @@ class QueryBuilder {
         await loadRelations(data, ensureArray(withs), self.model, self.getActiveKnex(), self.scopeContext);
       }
 
-      for (const record of data) {
-        ModelEvents.emit(self.model.name, Hooks.AFTER_FIND, record, ctx);
+      if (shouldEmit) {
+        for (const record of data) {
+          ModelEvents.emit(self.model.name, Hooks.AFTER_FIND, record, ctx);
+        }
       }
 
       return {

package/core/orm/repository.js

@@ -12,6 +12,7 @@ const {
   applyUpdateModifiers,
   getSoftDeleteData,
   getRestoreData,
+  getSoftDeleteColumn,
   createScopeContext,
   applyScopes,
 } = require('./scopes');
@@ -20,6 +21,24 @@ const { ModelEvents, createEventContext, Hooks, HookCancellationError } = requir
 const { getJsonColumns, serializeJsonFields, deserializeJsonFields } = require('./json-fields');
 const { getAmbientTransaction } = require('./transaction');
 
+/**
+ * Get or cache partial schema for model
+ * @param {import('./types').ModelDefinition} model
+ * @returns {import('zod').ZodTypeAny}
+ */
+function getPartialSchema(model) {
+  if (model && model._partialSchema) {
+    return model._partialSchema;
+  }
+  const partial = (model && model.schema && typeof model.schema.partial === 'function')
+    ? model.schema.partial()
+    : model?.schema;
+  if (model) {
+    model._partialSchema = partial;
+  }
+  return partial;
+}
+
 /**
  * Create a repository for a model
  * @param {import('./types').ModelDefinition} model - Model definition
@@ -29,7 +48,7 @@ const { getAmbientTransaction } = require('./transaction');
  * @returns {import('./types').Repository}
  */
 function createRepository(model, knex, initialContext, cacheLayer = null) {
-  const scopeContext = initialContext || createScopeContext();
+  const scopeContext = initialContext ? { ...initialContext } : createScopeContext();
   const jsonColumns = getJsonColumns(model);
   const hasJson = jsonColumns.size > 0;
 
@@ -302,7 +321,7 @@ function createRepository(model, knex, initialContext, cacheLayer = null) {
     }
 
     // Validate with Zod schema (partial for insert - allows auto fields to be missing)
-    const validated = model.schema.partial().parse(workingData);
+    const validated = getPartialSchema(model).parse(workingData);
 
     // Emit afterValidation
     ModelEvents.emit(model.name, Hooks.AFTER_VALIDATION, validated, ctx);
@@ -381,7 +400,7 @@ function createRepository(model, knex, initialContext, cacheLayer = null) {
     }
 
     // Validate with Zod schema (partial for update)
-    const validated = model.schema.partial().parse(workingData);
+    const validated = getPartialSchema(model).parse(workingData);
 
     // Emit afterValidation
     ModelEvents.emit(model.name, Hooks.AFTER_VALIDATION, validated, ctx);
@@ -438,7 +457,7 @@ function createRepository(model, knex, initialContext, cacheLayer = null) {
    */
   async function updateWhere(conditions, data) {
     // Validate with Zod schema (partial for update)
-    const validated = model.schema.partial().parse(data);
+    const validated = getPartialSchema(model).parse(data);
 
     // Apply update modifiers (timestamps)
     let updateData = applyUpdateModifiers(validated, model);
@@ -493,9 +512,10 @@ function createRepository(model, knex, initialContext, cacheLayer = null) {
       const parentVal = record[localKey];
       if (parentVal === undefined || parentVal === null) continue;
 
+      const deletedCol = getSoftDeleteColumn(relatedModel);
       let childQuery = activeKnex(relatedModel.table)
         .where(foreignKey, parentVal)
-        .whereNull('deleted_at');
+        .whereNull(deletedCol);
 
       if (scopeContext && scopeContext.tenantId !== undefined && relatedModel.scopes.tenant) {
         childQuery = childQuery.where(relatedModel.scopes.tenant, scopeContext.tenantId);
@@ -508,7 +528,7 @@ function createRepository(model, knex, initialContext, cacheLayer = null) {
 
       await activeKnex(relatedModel.table)
         .whereIn(relatedModel.primaryKey, childIds)
-        .update(getSoftDeleteData(deletedAt));
+        .update(getSoftDeleteData(deletedAt, relatedModel));
 
       if (cacheLayer) {
         cacheLayer.invalidateModelAll(relatedModel);
@@ -637,9 +657,10 @@ function createRepository(model, knex, initialContext, cacheLayer = null) {
       const parentVal = trashedRecord[localKey];
       if (parentVal === undefined || parentVal === null) continue;
 
+      const deletedCol = getSoftDeleteColumn(relatedModel);
       let childQuery = activeKnex(relatedModel.table)
         .where(foreignKey, parentVal)
-        .whereNotNull('deleted_at');
+        .whereNotNull(deletedCol);
 
       if (scopeContext && scopeContext.tenantId !== undefined && relatedModel.scopes.tenant) {
         childQuery = childQuery.where(relatedModel.scopes.tenant, scopeContext.tenantId);
@@ -647,7 +668,7 @@ function createRepository(model, knex, initialContext, cacheLayer = null) {
 
       // Selective restore by matching deletion timestamp
       if (!options.allChildren && parentDeletedAt != null) {
-        childQuery = childQuery.where('deleted_at', parentDeletedAt);
+        childQuery = childQuery.where(deletedCol, parentDeletedAt);
       }
 
       const children = await childQuery.select('*');
@@ -658,14 +679,15 @@ function createRepository(model, knex, initialContext, cacheLayer = null) {
       );
       if (hasDeeper) {
         for (const child of children) {
-          await cascadeRestore(relatedModel, child, child.deleted_at || parentDeletedAt, options, visited);
+          const childDeletedAt = child[deletedCol] || child.deleted_at || parentDeletedAt;
+          await cascadeRestore(relatedModel, child, childDeletedAt, options, visited);
         }
       }
 
       const childIds = children.map(c => c[relatedModel.primaryKey]);
       await activeKnex(relatedModel.table)
         .whereIn(relatedModel.primaryKey, childIds)
-        .update(getRestoreData());
+        .update(getRestoreData(relatedModel));
 
       if (cacheLayer) {
         cacheLayer.invalidateModelAll(relatedModel);
@@ -674,7 +696,7 @@ function createRepository(model, knex, initialContext, cacheLayer = null) {
       if (ModelEvents.hasListeners(relatedModel.name, Hooks.AFTER_RESTORE)) {
         for (const child of children) {
           const childCtx = createEventContext(relatedModel.name, 'restore', getHookTrx());
-          ModelEvents.emit(relatedModel.name, Hooks.AFTER_RESTORE, { ...child, deleted_at: null }, childCtx);
+          ModelEvents.emit(relatedModel.name, Hooks.AFTER_RESTORE, { ...child, [deletedCol]: null, deleted_at: null }, childCtx);
         }
       }
     }
@@ -708,7 +730,7 @@ function createRepository(model, knex, initialContext, cacheLayer = null) {
     if (model.scopes.softDelete) {
       const updated = await baseQuery()
         .where(model.primaryKey, id)
-        .update(getSoftDeleteData(deletedAt));
+        .update(getSoftDeleteData(deletedAt, model));
       success = updated > 0;
 
       if (success) {
@@ -791,10 +813,12 @@ function createRepository(model, knex, initialContext, cacheLayer = null) {
 
     const ctx = createEventContext(model.name, 'restore', getHookTrx());
 
+    const deletedCol = getSoftDeleteColumn(model);
+
     // Get the trashed record for hooks (bypass soft delete scope)
     const trashedRecord = await getActiveKnex()(model.table)
       .where(model.primaryKey, id)
-      .whereNotNull('deleted_at')
+      .whereNotNull(deletedCol)
       .first();
 
     if (!trashedRecord) {
@@ -810,8 +834,8 @@ function createRepository(model, knex, initialContext, cacheLayer = null) {
     // Update directly without scopes (to find trashed record)
     const updated = await getActiveKnex()(model.table)
       .where(model.primaryKey, id)
-      .whereNotNull('deleted_at')
-      .update(getRestoreData());
+      .whereNotNull(deletedCol)
+      .update(getRestoreData(model));
 
     if (updated === 0) {
       return null;
@@ -822,7 +846,8 @@ function createRepository(model, knex, initialContext, cacheLayer = null) {
     }
 
     if (!options || options.cascade !== false) {
-      await cascadeRestore(model, trashedRecord, trashedRecord.deleted_at, options);
+      const parentDeletedAt = trashedRecord[deletedCol] || trashedRecord.deleted_at;
+      await cascadeRestore(model, trashedRecord, parentDeletedAt, options);
     }
 
     const record = await findById(id, {}, false);
@@ -838,7 +863,7 @@ function createRepository(model, knex, initialContext, cacheLayer = null) {
    * @returns {import('./query-builder').QueryBuilder}
    */
   function query() {
-    return createQueryBuilder(model, getActiveKnex(), scopeContext, cacheLayer);
+    return createQueryBuilder(model, getActiveKnex(), { ...scopeContext }, cacheLayer);
   }
 
   /**

package/core/orm/schema-helpers.js

@@ -778,6 +778,55 @@ function createSchemaHelpers(z) {
         ...rest,
       }, z);
     },
+
+    /**
+     * Timestamp pair columns (createdAt and updatedAt)
+     * @param {Object} [options={}]
+     * @param {boolean} [options.snakeCase=false] - Use snake_case (created_at, updated_at)
+     * @param {string} [options.createdAt] - Custom created column name
+     * @param {string} [options.updatedAt] - Custom updated column name
+     * @returns {{ [key: string]: SchemaBuilder }}
+     */
+    timestamps(options = {}) {
+      const isSnake = options.snakeCase || options.format === 'snake';
+      const createdKey = options.createdAt || (isSnake ? 'created_at' : 'createdAt');
+      const updatedKey = options.updatedAt || (isSnake ? 'updated_at' : 'updatedAt');
+
+      return {
+        [createdKey]: helpers.timestamp({ auto: 'create', ...options }),
+        [updatedKey]: helpers.timestamp({ auto: 'update', ...options }),
+      };
+    },
+
+    /**
+     * Soft delete column helper (returns a single SchemaBuilder for deletedAt/deleted_at)
+     * @param {Partial<import('./types').ColumnMeta>} [options={}]
+     * @returns {SchemaBuilder}
+     */
+    softDelete(options = {}) {
+      return helpers.timestamp({
+        nullable: true,
+        ...options,
+      });
+    },
+
+    /**
+     * Soft delete field object (returns { deletedAt: SchemaBuilder } or { deleted_at: SchemaBuilder })
+     * @param {Object} [options={}]
+     * @param {boolean} [options.snakeCase=false] - Use snake_case (deleted_at)
+     * @param {string} [options.deletedAt] - Custom deleted column name
+     * @returns {{ [key: string]: SchemaBuilder }}
+     */
+    softDeletes(options = {}) {
+      const isSnake = options.snakeCase || options.format === 'snake';
+      const deletedKey = options.deletedAt || (isSnake ? 'deleted_at' : 'deletedAt');
+      return {
+        [deletedKey]: helpers.timestamp({
+          nullable: true,
+          ...options,
+        }),
+      };
+    },
   };
 
   return helpers;

package/core/orm/scopes.js

@@ -6,6 +6,15 @@
 
 const { generateNanoid } = require('./utils/nanoid');
 
+/**
+ * Determine the soft delete column name for a model
+ * @param {import('./types').ModelDefinition} model - Model definition
+ * @returns {string} Column name ('deletedAt' or 'deleted_at')
+ */
+function getSoftDeleteColumn(model) {
+  return (model && model.columns && model.columns.has('deletedAt')) ? 'deletedAt' : 'deleted_at';
+}
+
 /**
  * Apply soft delete scope to a query builder
  * @param {import('knex').Knex.QueryBuilder} qb - Knex query builder
@@ -18,9 +27,11 @@ function applySoftDeleteScope(qb, context, model) {
     return qb;
   }
 
+  const deletedCol = getSoftDeleteColumn(model);
+
   // If onlyTrashed is set, only return deleted records
   if (context.onlyTrashed) {
-    return qb.whereNotNull('deleted_at');
+    return qb.whereNotNull(deletedCol);
   }
 
   // If withTrashed is set, return all records (no filter)
@@ -29,7 +40,7 @@ function applySoftDeleteScope(qb, context, model) {
   }
 
   // Default: only return non-deleted records
-  return qb.whereNull('deleted_at');
+  return qb.whereNull(deletedCol);
 }
 
 /**
@@ -74,10 +85,13 @@ function applyInsertTimestamps(data, model) {
   }
 
   const now = new Date();
+  const createdCol = (model.columns && model.columns.has('createdAt')) ? 'createdAt' : 'created_at';
+  const updatedCol = (model.columns && model.columns.has('updatedAt')) ? 'updatedAt' : 'updated_at';
+
   return {
     ...data,
-    created_at: data.created_at || now,
-    updated_at: data.updated_at || now,
+    [createdCol]: data[createdCol] !== undefined ? data[createdCol] : (data.createdAt || data.created_at || now),
+    [updatedCol]: data[updatedCol] !== undefined ? data[updatedCol] : (data.updatedAt || data.updated_at || now),
   };
 }
 
@@ -92,9 +106,11 @@ function applyUpdateTimestamps(data, model) {
     return data;
   }
 
+  const updatedCol = (model.columns && model.columns.has('updatedAt')) ? 'updatedAt' : 'updated_at';
+
   return {
     ...data,
-    updated_at: new Date(),
+    [updatedCol]: new Date(),
   };
 }
 
@@ -143,18 +159,32 @@ function applyInsertNanoidPrimary(data, model) {
 /**
  * Get soft delete data (for UPDATE instead of DELETE)
  * @param {Date|string|number} [date=new Date()] - Soft delete timestamp
+ * @param {string|import('./types').ModelDefinition} [colOrModel='deleted_at'] - Column name or model definition
  * @returns {Object} Soft delete update data
  */
-function getSoftDeleteData(date = new Date()) {
-  return { deleted_at: date instanceof Date ? date : new Date(date) };
+function getSoftDeleteData(date = new Date(), colOrModel = 'deleted_at') {
+  let columnName = 'deleted_at';
+  if (typeof colOrModel === 'string') {
+    columnName = colOrModel;
+  } else if (colOrModel && typeof colOrModel === 'object') {
+    columnName = getSoftDeleteColumn(colOrModel);
+  }
+  return { [columnName]: date instanceof Date ? date : new Date(date) };
 }
 
 /**
  * Get restore data (to undo soft delete)
+ * @param {string|import('./types').ModelDefinition} [colOrModel='deleted_at'] - Column name or model definition
  * @returns {Object} Restore update data
  */
-function getRestoreData() {
-  return { deleted_at: null };
+function getRestoreData(colOrModel = 'deleted_at') {
+  let columnName = 'deleted_at';
+  if (typeof colOrModel === 'string') {
+    columnName = colOrModel;
+  } else if (colOrModel && typeof colOrModel === 'object') {
+    columnName = getSoftDeleteColumn(colOrModel);
+  }
+  return { [columnName]: null };
 }
 
 /**
@@ -207,6 +237,7 @@ module.exports = {
   applyUpdateModifiers,
   getSoftDeleteData,
   getRestoreData,
+  getSoftDeleteColumn,
   createScopeContext,
 };