webspresso 0.0.106 → 0.0.108

package/core/index.js

@@ -11,9 +11,11 @@
 const { CoreApp, createCoreApp } = require('./app');
 const {
   createServiceRegistry,
+  createServiceRegistryAsync,
   defineService,
   ServiceRegistry,
   executeService,
+  composeMiddleware,
   discoverServices,
   filePathToServiceName,
   toCamelCase,
@@ -23,7 +25,10 @@ const {
   stableCacheKey,
   sanitizeInput,
   maskSensitiveData,
-} = require('../src/services');
+  loadModuleSync,
+  loadModuleAsync,
+  extractModuleExport,
+} = require('./services');
 
 const { ShutdownManager } = require('./shutdown');
 const errors = require('./errors');
@@ -37,7 +42,7 @@ const {
   createPluginManager,
   getPluginManager,
   resetPluginManager,
-} = require('../src/plugin-manager');
+} = require('./plugins');
 
 // Lazy-loaded ORM accessor
 let _orm = null;
@@ -53,12 +58,37 @@ module.exports = {
   CoreApp,
   createCoreApp,
 
+  // Context Management Layer (App & Ambient Request Context)
+  context: require('./context'),
+  appContext: require('./context').appContext,
+  requestContext: require('./context').requestContext,
+  runWithContext: require('./context').runWithContext,
+  withContext: require('./context').withContext,
+  getContext: require('./context').getContext,
+  useContext: require('./context').useContext,
+  useDb: require('./context').useDb,
+  useAuth: require('./context').useAuth,
+  useUser: require('./context').useUser,
+  useLogger: require('./context').useLogger,
+  useReq: require('./context').useReq,
+  useRes: require('./context').useRes,
+  useParams: require('./context').useParams,
+  useQuery: require('./context').useQuery,
+  useService: require('./context').useService,
+  useQueue: require('./context').useQueue,
+  useCache: require('./context').useCache,
+  useBreaker: require('./context').useBreaker,
+  useTransaction: require('./context').useTransaction,
+
   // Services Layer
+  services: require('./services'),
   createServiceRegistry,
+  createServiceRegistryAsync,
   defineService,
   service: defineService,
   ServiceRegistry,
   executeService,
+  composeMiddleware,
   discoverServices,
   filePathToServiceName,
   toCamelCase,
@@ -68,6 +98,9 @@ module.exports = {
   stableCacheKey,
   sanitizeInput,
   maskSensitiveData,
+  loadModuleSync,
+  loadModuleAsync,
+  extractModuleExport,
 
   // Route & Endpoint Declarations
   defineApi: require('../src/api/define-api').defineApi,
@@ -296,6 +329,7 @@ Object.defineProperties(module.exports, {
   executeApiPipeline: { get: () => require('./http').executeApiPipeline, enumerable: true, configurable: true },
   executePagePipeline: { get: () => require('./http').executePagePipeline, enumerable: true, configurable: true },
   runMiddlewares: { get: () => require('./http').runMiddlewares, enumerable: true, configurable: true },
+  createPipelineRunner: { get: () => require('./http').createPipelineRunner, enumerable: true, configurable: true },
   enrichRouteError: { get: () => require('./http').enrichRouteError, enumerable: true, configurable: true },
 
   // Authentication & Verification

package/core/mail/mailer.js

@@ -67,7 +67,7 @@ class Mailer {
 
     // Fallback simple text from HTML if text not provided
     if (!msg.text && typeof msg.html === 'string') {
-      msg.text = msg.html.replace(/<[^>]+>/g, ' ').replace(/\s+/g, ' ').trim();
+      msg.text = msg.html.replace(/<[^<>]*>/g, ' ').replace(/\s+/g, ' ').trim();
     }
 
     try {

package/core/orm/eager-loader.js

@@ -8,6 +8,60 @@ const { resolveRelationModel, getRelationKeys } = require('./model');
 const { applyScopes, createScopeContext } = require('./scopes');
 const { getJsonColumns, deserializeJsonFields } = require('./json-fields');
 
+const RELATION_TREE_CACHE_LIMIT = 512;
+const relationTreeCache = new Map();
+
+/**
+ * Generate a deterministic cache key for relation names specifications
+ * @param {string|Array|Object} relationNames
+ * @returns {string|null}
+ */
+function getRelationTreeCacheKey(relationNames) {
+  if (typeof relationNames === 'string') {
+    return 's:' + relationNames;
+  }
+  if (Array.isArray(relationNames)) {
+    for (let i = 0; i < relationNames.length; i++) {
+      if (typeof relationNames[i] !== 'string') {
+        try {
+          return 'o:' + JSON.stringify(relationNames);
+        } catch (_) {
+          return null;
+        }
+      }
+    }
+    return 'a:' + relationNames.join('|');
+  }
+  if (relationNames && typeof relationNames === 'object') {
+    try {
+      return 'o:' + JSON.stringify(relationNames);
+    } catch (_) {
+      return null;
+    }
+  }
+  return null;
+}
+
+/**
+ * Clone a relation tree Map to prevent external mutation from poisoning cache
+ * @param {Map<string, string[]>} tree
+ * @returns {Map<string, string[]>}
+ */
+function cloneRelationTree(tree) {
+  const copy = new Map();
+  for (const [k, v] of tree.entries()) {
+    copy.set(k, v.slice());
+  }
+  return copy;
+}
+
+/**
+ * Clear the internal relation tree cache
+ */
+function clearRelationTreeCache() {
+  relationTreeCache.clear();
+}
+
 /**
  * Parse relation specifications into a grouped structure: Map<topLevelRelation, string[]>
  * Supports dot notation ('author.profile'), arrays (['author', 'comments.author']),
@@ -17,6 +71,21 @@ const { getJsonColumns, deserializeJsonFields } = require('./json-fields');
  * @returns {Map<string, string[]>}
  */
 function parseRelationTree(relationNames) {
+  if (relationNames instanceof Map) {
+    return cloneRelationTree(relationNames);
+  }
+
+  const cacheKey = getRelationTreeCacheKey(relationNames);
+  if (cacheKey) {
+    const cached = relationTreeCache.get(cacheKey);
+    if (cached) {
+      // Refresh LRU order
+      relationTreeCache.delete(cacheKey);
+      relationTreeCache.set(cacheKey, cached);
+      return cloneRelationTree(cached);
+    }
+  }
+
   const tree = new Map();
 
   function addPath(top, nested) {
@@ -81,6 +150,15 @@ function parseRelationTree(relationNames) {
     processItem(item);
   }
 
+  if (cacheKey) {
+    if (relationTreeCache.size >= RELATION_TREE_CACHE_LIMIT) {
+      const firstKey = relationTreeCache.keys().next().value;
+      relationTreeCache.delete(firstKey);
+    }
+    relationTreeCache.set(cacheKey, tree);
+    return cloneRelationTree(tree);
+  }
+
   return tree;
 }
 
@@ -93,74 +171,104 @@ function parseRelationTree(relationNames) {
  * @param {import('./types').ScopeContext} [scopeContext] - Scope context
  * @returns {Promise<Object[]>} Records with relations attached
  */
-async function loadRelations(records, relationNames, model, knex, scopeContext) {
-  if (!records || !records.length || !relationNames || !relationNames.length) {
-    return records;
+/**
+ * Helper to load a single top-level relation and its nested relations
+ * @private
+ */
+async function loadSingleRelation(records, relationName, nestedPaths, model, knex, context) {
+  const relation = model.relations?.[relationName];
+  if (!relation) {
+    console.warn(`Relation "${relationName}" not found on model "${model.name}"`);
+    return;
   }
 
-  const context = scopeContext || createScopeContext();
-  const tree = parseRelationTree(relationNames);
-
-  // Process each relation grouped by top-level
-  for (const [relationName, nestedPaths] of tree.entries()) {
-    const relation = model.relations?.[relationName];
-    if (!relation) {
-      console.warn(`Relation "${relationName}" not found on model "${model.name}"`);
-      continue;
-    }
+  const { localKey, foreignKey, relatedModel } = getRelationKeys(model, relationName);
+
+  switch (relation.type) {
+    case 'belongsTo':
+      await loadBelongsTo(records, relationName, localKey, foreignKey, relatedModel, knex, context);
+      break;
+    case 'hasMany':
+      await loadHasMany(records, relationName, localKey, foreignKey, relatedModel, knex, context);
+      break;
+    case 'hasOne':
+      await loadHasOne(records, relationName, localKey, foreignKey, relatedModel, knex, context);
+      break;
+    default:
+      console.warn(`Unsupported relation type "${relation.type}" for relation "${relationName}" on model "${model.name}"`);
+      return;
+  }
 
-    const { localKey, foreignKey, relatedModel } = getRelationKeys(model, relationName);
-
-    switch (relation.type) {
-      case 'belongsTo':
-        await loadBelongsTo(records, relationName, localKey, foreignKey, relatedModel, knex, context);
-        break;
-      case 'hasMany':
-        await loadHasMany(records, relationName, localKey, foreignKey, relatedModel, knex, context);
-        break;
-      case 'hasOne':
-        await loadHasOne(records, relationName, localKey, foreignKey, relatedModel, knex, context);
-        break;
-      default:
-        console.warn(`Unsupported relation type "${relation.type}" for relation "${relationName}" on model "${model.name}"`);
-        continue;
-    }
+  // Process nested relations if any
+  if (nestedPaths.length > 0) {
+    const childRecords = [];
+    const seenRefs = new Set();
+    const len = records.length;
 
-    // Process nested relations if any
-    if (nestedPaths.length > 0) {
-      const childRecords = [];
-      const seenRefs = new Set();
-      const len = records.length;
-
-      for (let i = 0; i < len; i++) {
-        const child = records[i][relationName];
-        if (!child) continue;
-
-        if (Array.isArray(child)) {
-          for (let j = 0; j < child.length; j++) {
-            const item = child[j];
-            if (item && typeof item === 'object' && !seenRefs.has(item)) {
-              seenRefs.add(item);
-              childRecords.push(item);
-            }
+    for (let i = 0; i < len; i++) {
+      const child = records[i][relationName];
+      if (!child) continue;
+
+      if (Array.isArray(child)) {
+        for (let j = 0; j < child.length; j++) {
+          const item = child[j];
+          if (item && typeof item === 'object' && !seenRefs.has(item)) {
+            seenRefs.add(item);
+            childRecords.push(item);
           }
-        } else if (typeof child === 'object' && !seenRefs.has(child)) {
-          seenRefs.add(child);
-          childRecords.push(child);
         }
+      } else if (typeof child === 'object' && !seenRefs.has(child)) {
+        seenRefs.add(child);
+        childRecords.push(child);
       }
+    }
 
-      if (childRecords.length > 0) {
-        await loadRelations(childRecords, nestedPaths, relatedModel, knex, context);
-      }
+    if (childRecords.length > 0) {
+      await loadRelations(childRecords, nestedPaths, relatedModel, knex, context);
     }
   }
+}
+
+/**
+ * Load relations for a set of records using batch queries (supports nested relations)
+ * Executes independent top-level relations concurrently via Promise.all.
+ *
+ * @param {Object[]} records - Records to load relations for
+ * @param {Array<string|Object>} relationNames - Names of relations to load (e.g. ['author.profile', 'comments.author'])
+ * @param {import('./types').ModelDefinition} model - Model definition
+ * @param {import('knex').Knex|import('knex').Knex.Transaction} knex - Knex instance
+ * @param {import('./types').ScopeContext} [scopeContext] - Scope context
+ * @returns {Promise<Object[]>} Records with relations attached
+ */
+async function loadRelations(records, relationNames, model, knex, scopeContext) {
+  if (!records || !records.length || !relationNames || !relationNames.length) {
+    return records;
+  }
+
+  const context = scopeContext || createScopeContext();
+  const tree = relationNames instanceof Map ? relationNames : parseRelationTree(relationNames);
+  const entries = Array.from(tree.entries());
+
+  if (entries.length === 1) {
+    // Fast path: single top-level relation without Promise.all allocation
+    const [relationName, nestedPaths] = entries[0];
+    await loadSingleRelation(records, relationName, nestedPaths, model, knex, context);
+  } else if (entries.length > 1) {
+    // Concurrent execution for independent top-level relations (eliminates sequential waterfalls)
+    await Promise.all(
+      entries.map(([relationName, nestedPaths]) =>
+        loadSingleRelation(records, relationName, nestedPaths, model, knex, context)
+      )
+    );
+  }
 
   return records;
 }
 
 /**
  * Execute whereIn query in chunks to prevent parameter limits and query planner degradation
+ * Executes multiple chunks concurrently via Promise.all.
+ *
  * @param {import('knex').Knex} knex
  * @param {string} table
  * @param {string} column
@@ -177,13 +285,18 @@ async function queryInChunks(knex, table, column, values, scopeContext, model, c
     return await qb;
   }
 
-  const results = [];
+  const chunkPromises = [];
   for (let i = 0; i < values.length; i += chunkSize) {
     const slice = values.slice(i, i + chunkSize);
     let qb = knex(table).whereIn(column, slice);
     qb = applyScopes(qb, scopeContext, model);
-    const chunkResults = await qb;
-    results.push(...chunkResults);
+    chunkPromises.push(qb);
+  }
+
+  const chunkResults = await Promise.all(chunkPromises);
+  const results = [];
+  for (let i = 0; i < chunkResults.length; i++) {
+    results.push(...chunkResults[i]);
   }
   return results;
 }
@@ -402,4 +515,6 @@ module.exports = {
   loadHasOne,
   queryInChunks,
   parseRelationTree,
+  clearRelationTreeCache,
+  getRelationTreeCacheKey,
 };

package/core/orm/index.js

@@ -9,6 +9,7 @@ const fs = require('fs');
 const { createSchemaHelpers, extractColumnsFromSchema, getColumnMeta } = require('./schema-helpers');
 const { defineModel, getModel, getAllModels, hasModel, clearRegistry, resolveModelName, isCascadeEnabled } = require('./model');
 const { createRepository } = require('./repository');
+const { createQueryBuilder, QueryBuilder } = require('./query-builder');
 const { createMigrationManager } = require('./migrations');
 const { createSeeder } = require('./seeder');
 const { createScopeContext } = require('./scopes');
@@ -278,9 +279,8 @@ function createDatabase(config) {
    */
   function query(modelName, scopeContext) {
     const model = getModelInstance(modelName);
-    const ctx = scopeContext || createScopeContext();
-    const repo = createRepository(model, knexInstance, ctx, ormCacheLayer);
-    return repo.query();
+    const ctx = scopeContext ? { ...scopeContext } : createScopeContext();
+    return createQueryBuilder(model, knexInstance, ctx, ormCacheLayer);
   }
 
   /**
@@ -309,40 +309,7 @@ function createDatabase(config) {
    * @returns {Promise<*>} Result of callback
    */
   async function transaction(callback, scopeContext) {
-    const ambientTrx = getAmbientTransaction();
-    const runner = (ambientTrx && typeof ambientTrx.transaction === 'function') ? ambientTrx : knexInstance;
-
-    return runner.transaction(async (trx) => {
-      let currentScope = scopeContext ? { ...scopeContext } : createScopeContext();
-      const trxContext = {
-        trx,
-        getRepository(modelName, sContext) {
-          const model = getModelInstance(modelName);
-          const ctx = sContext || currentScope;
-          return createRepository(model, trx, ctx, ormCacheLayer);
-        },
-        createRepository(model, sContext) {
-          const ctx = sContext || currentScope;
-          return createRepository(model, trx, ctx, ormCacheLayer);
-        },
-        forTenant(tenantId) {
-          currentScope = { ...currentScope, tenantId };
-          return this;
-        },
-        forUser(user) {
-          currentScope = { ...currentScope, user };
-          return this;
-        },
-        withoutRls() {
-          currentScope = { ...currentScope, rlsDisabled: true };
-          return this;
-        },
-        getScopeContext() {
-          return { ...currentScope };
-        },
-      };
-      return runWithAmbientTransaction(trx, () => callback(trxContext));
-    });
+    return runTransaction(knexInstance, callback, scopeContext, ormCacheLayer, getModelInstance);
   }
 
   /**
@@ -472,6 +439,9 @@ const zdb = z ? createSchemaHelpers(z) : null;
 module.exports = {
   // Main factory
   createDatabase,
+  // Query builder
+  createQueryBuilder,
+  QueryBuilder,
   // ORM cache (provider + layer utilities)
   createMemoryCacheProvider: require('./cache/memory-provider').createMemoryCacheProvider,
   OrmCacheLayer: require('./cache/layer').OrmCacheLayer,
@@ -485,6 +455,8 @@ module.exports = {
   runTransaction,
   // Schema helpers
   zdb,
+  z,
+  zod: z,
   createSchemaHelpers,
   // Model utilities
   defineModel,
@@ -511,6 +483,7 @@ module.exports = {
   loadRelations: require('./eager-loader').loadRelations,
   loadRelation: require('./eager-loader').loadRelation,
   parseRelationTree: require('./eager-loader').parseRelationTree,
+  clearRelationTreeCache: require('./eager-loader').clearRelationTreeCache,
   // Query Complexity & DoS Protection
   QueryComplexityError: require('./complexity').QueryComplexityError,
   validateQueryComplexity: require('./complexity').validateQueryComplexity,
@@ -543,11 +516,16 @@ module.exports = {
   getUserId: require('./scopes').getUserId,
   getTenantId: require('./scopes').getTenantId,
   createScopeContext: require('./scopes').createScopeContext,
-  // Cloudflare D1 Native Edge Dialect
-  createD1Knex: require('./d1').createD1Knex,
-  Client_D1: require('./d1').Client_D1,
-  executeD1Batch: require('./d1').executeD1Batch,
-  normalizeD1Bindings: require('./d1').normalizeD1Bindings,
+  getSoftDeleteColumn: require('./scopes').getSoftDeleteColumn,
+  getCreatedAtColumn: require('./scopes').getCreatedAtColumn,
+  getUpdatedAtColumn: require('./scopes').getUpdatedAtColumn,
+  applyInsertTimestamps: require('./scopes').applyInsertTimestamps,
+  applyUpdateTimestamps: require('./scopes').applyUpdateTimestamps,
+  // Cloudflare D1 Native Edge Dialect (lazy getters to avoid eager dialect loading)
+  get createD1Knex() { return require('./d1').createD1Knex; },
+  get Client_D1() { return require('./d1').Client_D1; },
+  get executeD1Batch() { return require('./d1').executeD1Batch; },
+  get normalizeD1Bindings() { return require('./d1').normalizeD1Bindings; },
   // Serverless Connection Pool Management
   isServerlessEnvironment,
   normalizeServerlessPoolConfig,
@@ -555,9 +533,9 @@ module.exports = {
     isServerlessEnvironment,
     normalizeServerlessPoolConfig,
   },
-  // Cloud Database Migrations
-  waitForDatabaseConnection: require('./migrate-cloud').waitForDatabaseConnection,
-  freeStaleMigrationLock: require('./migrate-cloud').freeStaleMigrationLock,
-  getMigrationStatus: require('./migrate-cloud').getMigrationStatus,
-  runCloudMigration: require('./migrate-cloud').runCloudMigration,
+  // Cloud Database Migrations (lazy getters)
+  get waitForDatabaseConnection() { return require('./migrate-cloud').waitForDatabaseConnection; },
+  get freeStaleMigrationLock() { return require('./migrate-cloud').freeStaleMigrationLock; },
+  get getMigrationStatus() { return require('./migrate-cloud').getMigrationStatus; },
+  get runCloudMigration() { return require('./migrate-cloud').runCloudMigration; },
 };

package/core/orm/json-fields.js

@@ -3,8 +3,6 @@
  * @module core/orm/json-fields
  */
 
-const { safeJsonParse } = require('../utils/json');
-
 /**
  * Get JSON column names from model
  * @param {import('./types').ModelDefinition} model - Model definition
@@ -12,6 +10,14 @@ const { safeJsonParse } = require('../utils/json');
  */
 function getJsonColumns(model) {
   if (model && model._jsonColumns) {
+    if (!model._jsonColumns._array) {
+      Object.defineProperty(model._jsonColumns, '_array', {
+        value: Array.from(model._jsonColumns),
+        writable: true,
+        configurable: true,
+        enumerable: false,
+      });
+    }
     return model._jsonColumns;
   }
   const jsonCols = new Set();
@@ -40,6 +46,12 @@ function getJsonColumns(model) {
       }
     }
   }
+  Object.defineProperty(jsonCols, '_array', {
+    value: Array.from(jsonCols),
+    writable: true,
+    configurable: true,
+    enumerable: false,
+  });
   if (model) {
     model._jsonColumns = jsonCols;
   }
@@ -49,17 +61,22 @@ function getJsonColumns(model) {
 /**
  * Serialize JSON fields for database storage
  * @param {Object} data - Data to serialize
- * @param {Set<string>} jsonColumns - JSON column names
+ * @param {Set<string>|Array<string>} jsonColumns - JSON column names
  * @returns {Object} Serialized data
  */
 function serializeJsonFields(data, jsonColumns) {
-  if (jsonColumns.size === 0) return data;
+  if (!data || !jsonColumns) return data;
+  const size = jsonColumns.size !== undefined ? jsonColumns.size : jsonColumns.length;
+  if (size === 0) return data;
 
+  const cols = jsonColumns._array || (Array.isArray(jsonColumns) ? jsonColumns : Array.from(jsonColumns));
   const serialized = { ...data };
-  for (const col of jsonColumns) {
-    if (col in serialized && serialized[col] !== null && serialized[col] !== undefined) {
-      if (typeof serialized[col] !== 'string') {
-        serialized[col] = JSON.stringify(serialized[col]);
+  for (let i = 0; i < cols.length; i++) {
+    const col = cols[i];
+    if (col in serialized) {
+      const val = serialized[col];
+      if (val !== null && val !== undefined && typeof val !== 'string') {
+        serialized[col] = JSON.stringify(val);
       }
     }
   }
@@ -69,15 +86,28 @@ function serializeJsonFields(data, jsonColumns) {
 /**
  * Deserialize JSON fields from database
  * @param {Object} record - Record from database
- * @param {Set<string>} jsonColumns - JSON column names
+ * @param {Set<string>|Array<string>} jsonColumns - JSON column names
  * @returns {Object} Deserialized record
  */
 function deserializeJsonFields(record, jsonColumns) {
-  if (!record || jsonColumns.size === 0) return record;
+  if (!record || !jsonColumns) return record;
+  const size = jsonColumns.size !== undefined ? jsonColumns.size : jsonColumns.length;
+  if (size === 0) return record;
 
-  for (const col of jsonColumns) {
-    if (col in record && record[col] !== null && record[col] !== undefined) {
-      record[col] = safeJsonParse(record[col], record[col]);
+  const cols = jsonColumns._array || (Array.isArray(jsonColumns) ? jsonColumns : Array.from(jsonColumns));
+  for (let i = 0; i < cols.length; i++) {
+    const col = cols[i];
+    if (col in record) {
+      const val = record[col];
+      // If already parsed (object, array, number, boolean) or null/undefined, skip parsing
+      if (typeof val === 'string') {
+        if (val.length === 0) continue;
+        try {
+          record[col] = JSON.parse(val);
+        } catch (_) {
+          // Keep raw string if parsing fails
+        }
+      }
     }
   }
   return record;
@@ -88,3 +118,4 @@ module.exports = {
   serializeJsonFields,
   deserializeJsonFields,
 };
+

package/core/orm/model.js

@@ -8,6 +8,7 @@ const z = require('zod');
 const { trimUrlPathSlashes } = require('../url-path-normalize');
 const { createSchemaHelpers, extractColumnsFromSchema } = require('./schema-helpers');
 const { ModelEvents, Hooks } = require('./events');
+const { getJsonColumns } = require('./json-fields');
 const zdb = z ? createSchemaHelpers(z) : null;
 
 /**
@@ -22,7 +23,7 @@ const modelRegistry = new Map();
  * @returns {import('./types').ModelDefinition}
  */
 function defineModel(options) {
-  const {
+  let {
     name,
     table,
     schema,
@@ -43,6 +44,11 @@ function defineModel(options) {
     options: nestedOptions = {},
   } = options;
 
+  // Support functional schema definitions: schema: ({ zdb, z }) => ({ ... })
+  if (typeof schema === 'function') {
+    schema = schema({ zdb, z: zdb?.z || z });
+  }
+
   // Validate required fields
   if (!name || typeof name !== 'string') {
     throw new Error('Model name is required and must be a string');
@@ -193,6 +199,11 @@ function defineModel(options) {
     ? rlsConfig
     : null;
 
+  const hasShape = normalizedSchema && normalizedSchema.shape;
+  const resolvedDeletedCol = ((columns && columns.has('deletedAt')) || (hasShape && normalizedSchema.shape.deletedAt)) ? 'deletedAt' : 'deleted_at';
+  const resolvedCreatedCol = ((columns && columns.has('createdAt')) || (hasShape && normalizedSchema.shape.createdAt)) ? 'createdAt' : 'created_at';
+  const resolvedUpdatedCol = ((columns && columns.has('updatedAt')) || (hasShape && normalizedSchema.shape.updatedAt)) ? 'updatedAt' : 'updated_at';
+
   // Create model definition
   const model = {
     name,
@@ -200,6 +211,9 @@ function defineModel(options) {
     schema: normalizedSchema,
     _partialSchema: typeof normalizedSchema?.partial === 'function' ? normalizedSchema.partial() : normalizedSchema,
     primaryKey,
+    _deletedCol: resolvedDeletedCol,
+    _createdCol: resolvedCreatedCol,
+    _updatedCol: resolvedUpdatedCol,
     relations: normalizedRelations,
     scopes: {
       softDelete: Boolean(softDeleteConfig),
@@ -259,6 +273,9 @@ function defineModel(options) {
     cache: cacheOption,
   };
 
+  // Precompute JSON column metadata
+  getJsonColumns(model);
+
   // Register model
   modelRegistry.set(name, model);