webspresso 0.0.88 → 0.0.89

package/core/orm/eager-loader.js

@@ -63,39 +63,37 @@ async function loadRelations(records, relationNames, model, knex, scopeContext)
  * @param {import('./types').ScopeContext} scopeContext - Scope context
  */
 async function loadBelongsTo(records, relationName, localKey, foreignKey, relatedModel, knex, scopeContext) {
-  // Collect unique foreign key values
-  const foreignKeyValues = [...new Set(
-    records
-      .map(r => r[foreignKey])
-      .filter(v => v !== null && v !== undefined)
-  )];
-
-  if (foreignKeyValues.length === 0) {
-    // No foreign keys, set all relations to null
-    for (const record of records) {
-      record[relationName] = null;
+  const fkSet = new Set();
+  const len = records.length;
+  for (let i = 0; i < len; i++) {
+    const v = records[i][foreignKey];
+    if (v !== null && v !== undefined) fkSet.add(v);
+  }
+
+  if (fkSet.size === 0) {
+    for (let i = 0; i < len; i++) {
+      records[i][relationName] = null;
     }
     return;
   }
 
-  // Build query for related records
+  const foreignKeyValues = Array.from(fkSet);
   let qb = knex(relatedModel.table).whereIn(relatedModel.primaryKey, foreignKeyValues);
-  
-  // Apply scopes to related model
   qb = applyScopes(qb, scopeContext, relatedModel);
-
   const relatedRecords = await qb;
 
-  // Index related records by primary key
   const relatedMap = new Map();
-  for (const related of relatedRecords) {
-    relatedMap.set(related[relatedModel.primaryKey], related);
+  const rLen = relatedRecords.length;
+  const pk = relatedModel.primaryKey;
+  for (let i = 0; i < rLen; i++) {
+    const item = relatedRecords[i];
+    relatedMap.set(item[pk], item);
   }
 
-  // Attach related records to parent records
-  for (const record of records) {
-    const fkValue = record[foreignKey];
-    record[relationName] = fkValue !== null && fkValue !== undefined
+  for (let i = 0; i < len; i++) {
+    const rec = records[i];
+    const fkValue = rec[foreignKey];
+    rec[relationName] = fkValue !== null && fkValue !== undefined
       ? relatedMap.get(fkValue) || null
       : null;
   }
@@ -115,43 +113,42 @@ async function loadBelongsTo(records, relationName, localKey, foreignKey, relate
  * @param {import('./types').ScopeContext} scopeContext - Scope context
  */
 async function loadHasMany(records, relationName, localKey, foreignKey, relatedModel, knex, scopeContext) {
-  // Collect unique primary key values from parent records
-  const primaryKeyValues = [...new Set(
-    records
-      .map(r => r[localKey])
-      .filter(v => v !== null && v !== undefined)
-  )];
-
-  if (primaryKeyValues.length === 0) {
-    // No primary keys, set all relations to empty arrays
-    for (const record of records) {
-      record[relationName] = [];
+  const pkSet = new Set();
+  const len = records.length;
+  for (let i = 0; i < len; i++) {
+    const v = records[i][localKey];
+    if (v !== null && v !== undefined) pkSet.add(v);
+  }
+
+  if (pkSet.size === 0) {
+    for (let i = 0; i < len; i++) {
+      records[i][relationName] = [];
     }
     return;
   }
 
-  // Build query for related records
+  const primaryKeyValues = Array.from(pkSet);
   let qb = knex(relatedModel.table).whereIn(foreignKey, primaryKeyValues);
-  
-  // Apply scopes to related model
   qb = applyScopes(qb, scopeContext, relatedModel);
-
   const relatedRecords = await qb;
 
-  // Group related records by foreign key
   const relatedGroups = new Map();
-  for (const related of relatedRecords) {
-    const fkValue = related[foreignKey];
-    if (!relatedGroups.has(fkValue)) {
-      relatedGroups.set(fkValue, []);
+  const rLen = relatedRecords.length;
+  for (let i = 0; i < rLen; i++) {
+    const item = relatedRecords[i];
+    const fkValue = item[foreignKey];
+    let group = relatedGroups.get(fkValue);
+    if (group === undefined) {
+      group = [];
+      relatedGroups.set(fkValue, group);
     }
-    relatedGroups.get(fkValue).push(related);
+    group.push(item);
   }
 
-  // Attach related records to parent records
-  for (const record of records) {
-    const pkValue = record[localKey];
-    record[relationName] = relatedGroups.get(pkValue) || [];
+  for (let i = 0; i < len; i++) {
+    const rec = records[i];
+    const pkValue = rec[localKey];
+    rec[relationName] = (pkValue !== null && pkValue !== undefined ? relatedGroups.get(pkValue) : undefined) || [];
   }
 }
 
@@ -169,42 +166,39 @@ async function loadHasMany(records, relationName, localKey, foreignKey, relatedM
  * @param {import('./types').ScopeContext} scopeContext - Scope context
  */
 async function loadHasOne(records, relationName, localKey, foreignKey, relatedModel, knex, scopeContext) {
-  // Collect unique primary key values from parent records
-  const primaryKeyValues = [...new Set(
-    records
-      .map(r => r[localKey])
-      .filter(v => v !== null && v !== undefined)
-  )];
-
-  if (primaryKeyValues.length === 0) {
-    // No primary keys, set all relations to null
-    for (const record of records) {
-      record[relationName] = null;
+  const pkSet = new Set();
+  const len = records.length;
+  for (let i = 0; i < len; i++) {
+    const v = records[i][localKey];
+    if (v !== null && v !== undefined) pkSet.add(v);
+  }
+
+  if (pkSet.size === 0) {
+    for (let i = 0; i < len; i++) {
+      records[i][relationName] = null;
     }
     return;
   }
 
-  // Build query for related records
+  const primaryKeyValues = Array.from(pkSet);
   let qb = knex(relatedModel.table).whereIn(foreignKey, primaryKeyValues);
-  
-  // Apply scopes to related model
   qb = applyScopes(qb, scopeContext, relatedModel);
-
   const relatedRecords = await qb;
 
-  // Index related records by foreign key (first occurrence wins for hasOne)
   const relatedMap = new Map();
-  for (const related of relatedRecords) {
-    const fkValue = related[foreignKey];
+  const rLen = relatedRecords.length;
+  for (let i = 0; i < rLen; i++) {
+    const item = relatedRecords[i];
+    const fkValue = item[foreignKey];
     if (!relatedMap.has(fkValue)) {
-      relatedMap.set(fkValue, related);
+      relatedMap.set(fkValue, item);
     }
   }
 
-  // Attach related records to parent records
-  for (const record of records) {
-    const pkValue = record[localKey];
-    record[relationName] = relatedMap.get(pkValue) || null;
+  for (let i = 0; i < len; i++) {
+    const rec = records[i];
+    const pkValue = rec[localKey];
+    rec[relationName] = (pkValue !== null && pkValue !== undefined ? relatedMap.get(pkValue) : undefined) || null;
   }
 }
 

package/core/orm/events.js

@@ -154,6 +154,23 @@ class ModelEventsClass {
     return listeners.length > 0 ? listeners : EMPTY_ARRAY;
   }
 
+  /**
+   * Fast boolean check whether any listener matches
+   * @param {string} model - Model name
+   * @param {string} hook - Hook name
+   * @returns {boolean}
+   */
+  hasListeners(model, hook) {
+    if (this.listeners.size === 0) return false;
+    const l = this.listeners;
+    return (
+      l.has(`${model}.${hook}`) ||
+      l.has(`*.${hook}`) ||
+      l.has(`${model}.*`) ||
+      l.has('*.*')
+    );
+  }
+
   /**
    * Emit an event synchronously (for after hooks)
    * @param {string} model - Model name
@@ -163,6 +180,7 @@ class ModelEventsClass {
    */
   emit(model, hook, data, context) {
     const listeners = this.getMatchingListeners(model, hook);
+    if (listeners.length === 0) return;
     const ctx = context || createEventContext(model, hook);
 
     for (const listener of listeners) {
@@ -187,6 +205,7 @@ class ModelEventsClass {
   async emitAsync(model, hook, data, context) {
     const listeners = this.getMatchingListeners(model, hook);
     const ctx = context || createEventContext(model, hook);
+    if (listeners.length === 0) return ctx;
 
     for (const listener of listeners) {
       if (ctx.isCancelled) break;

package/core/orm/repository.js

@@ -28,6 +28,7 @@ const { getJsonColumns, serializeJsonFields, deserializeJsonFields } = require('
 function createRepository(model, knex, initialContext, cacheLayer = null) {
   const scopeContext = initialContext || createScopeContext();
   const jsonColumns = getJsonColumns(model);
+  const hasJson = jsonColumns.size > 0;
 
   /**
    * Get base query builder
@@ -47,12 +48,15 @@ function createRepository(model, knex, initialContext, cacheLayer = null) {
    */
   async function findById(id, options = {}, emitEvents = true) {
     const { with: withs = [], select } = options;
-    const ctx = createEventContext(model.name, 'find');
-    const query = { [model.primaryKey]: id };
+    const shouldEmit = emitEvents && (
+      ModelEvents.hasListeners(model.name, Hooks.BEFORE_FIND) ||
+      ModelEvents.hasListeners(model.name, Hooks.AFTER_FIND)
+    );
+    const ctx = shouldEmit ? createEventContext(model.name, 'find') : null;
 
     async function loadFromDb() {
-      if (emitEvents) {
-        await ModelEvents.emitAsync(model.name, Hooks.BEFORE_FIND, query, ctx);
+      if (shouldEmit) {
+        await ModelEvents.emitAsync(model.name, Hooks.BEFORE_FIND, { [model.primaryKey]: id }, ctx);
         if (ctx.isCancelled) {
           throw new HookCancellationError(ctx.cancelReason, model.name, Hooks.BEFORE_FIND);
         }
@@ -70,13 +74,15 @@ function createRepository(model, knex, initialContext, cacheLayer = null) {
         return null;
       }
 
-      deserializeJsonFields(record, jsonColumns);
+      if (hasJson) {
+        deserializeJsonFields(record, jsonColumns);
+      }
 
       if (withs.length > 0) {
         await loadRelations([record], ensureArray(withs), model, knex, scopeContext);
       }
 
-      if (emitEvents) {
+      if (shouldEmit) {
         ModelEvents.emit(model.name, Hooks.AFTER_FIND, record, ctx);
       }
 
@@ -113,7 +119,11 @@ function createRepository(model, knex, initialContext, cacheLayer = null) {
    */
   async function findOne(conditions, options = {}) {
     const { with: withs = [], select } = options;
-    const ctx = createEventContext(model.name, 'find');
+    const shouldEmit = (
+      ModelEvents.hasListeners(model.name, Hooks.BEFORE_FIND) ||
+      ModelEvents.hasListeners(model.name, Hooks.AFTER_FIND)
+    );
+    const ctx = shouldEmit ? createEventContext(model.name, 'find') : null;
 
     const condKeys = Object.keys(conditions);
     const isPkOnly =
@@ -122,9 +132,11 @@ function createRepository(model, knex, initialContext, cacheLayer = null) {
       condKeys[0] === model.primaryKey;
 
     async function loadFromDb() {
-      await ModelEvents.emitAsync(model.name, Hooks.BEFORE_FIND, conditions, ctx);
-      if (ctx.isCancelled) {
-        throw new HookCancellationError(ctx.cancelReason, model.name, Hooks.BEFORE_FIND);
+      if (shouldEmit) {
+        await ModelEvents.emitAsync(model.name, Hooks.BEFORE_FIND, conditions, ctx);
+        if (ctx.isCancelled) {
+          throw new HookCancellationError(ctx.cancelReason, model.name, Hooks.BEFORE_FIND);
+        }
       }
 
       let qb = baseQuery();
@@ -143,13 +155,17 @@ function createRepository(model, knex, initialContext, cacheLayer = null) {
         return null;
       }
 
-      deserializeJsonFields(record, jsonColumns);
+      if (hasJson) {
+        deserializeJsonFields(record, jsonColumns);
+      }
 
       if (withs.length > 0) {
         await loadRelations([record], ensureArray(withs), model, knex, scopeContext);
       }
 
-      ModelEvents.emit(model.name, Hooks.AFTER_FIND, record, ctx);
+      if (shouldEmit) {
+        ModelEvents.emit(model.name, Hooks.AFTER_FIND, record, ctx);
+      }
 
       return record;
     }
@@ -183,12 +199,18 @@ function createRepository(model, knex, initialContext, cacheLayer = null) {
    */
   async function findAll(options = {}) {
     const { with: withs = [], select } = options;
-    const ctx = createEventContext(model.name, 'find');
+    const shouldEmit = (
+      ModelEvents.hasListeners(model.name, Hooks.BEFORE_FIND) ||
+      ModelEvents.hasListeners(model.name, Hooks.AFTER_FIND)
+    );
+    const ctx = shouldEmit ? createEventContext(model.name, 'find') : null;
 
     async function loadFromDb() {
-      await ModelEvents.emitAsync(model.name, Hooks.BEFORE_FIND, {}, ctx);
-      if (ctx.isCancelled) {
-        throw new HookCancellationError(ctx.cancelReason, model.name, Hooks.BEFORE_FIND);
+      if (shouldEmit) {
+        await ModelEvents.emitAsync(model.name, Hooks.BEFORE_FIND, {}, ctx);
+        if (ctx.isCancelled) {
+          throw new HookCancellationError(ctx.cancelReason, model.name, Hooks.BEFORE_FIND);
+        }
       }
 
       let qb = baseQuery();
@@ -199,16 +221,22 @@ function createRepository(model, knex, initialContext, cacheLayer = null) {
 
       const records = await qb;
 
-      for (const record of records) {
-        deserializeJsonFields(record, jsonColumns);
+      if (hasJson) {
+        const len = records.length;
+        for (let i = 0; i < len; i++) {
+          deserializeJsonFields(records[i], jsonColumns);
+        }
       }
 
       if (withs.length > 0 && records.length > 0) {
         await loadRelations(records, ensureArray(withs), model, knex, scopeContext);
       }
 
-      for (const record of records) {
-        ModelEvents.emit(model.name, Hooks.AFTER_FIND, record, ctx);
+      if (shouldEmit) {
+        const len = records.length;
+        for (let i = 0; i < len; i++) {
+          ModelEvents.emit(model.name, Hooks.AFTER_FIND, records[i], ctx);
+        }
       }
 
       return records;
@@ -261,7 +289,9 @@ function createRepository(model, knex, initialContext, cacheLayer = null) {
     let insertData = applyInsertModifiers(validated, scopeContext, model);
 
     // Serialize JSON fields
-    insertData = serializeJsonFields(insertData, jsonColumns);
+    if (hasJson) {
+      insertData = serializeJsonFields(insertData, jsonColumns);
+    }
 
     // Insert and return the record
     const [id] = await knex(model.table).insert(insertData).returning(model.primaryKey);
@@ -341,7 +371,9 @@ function createRepository(model, knex, initialContext, cacheLayer = null) {
     delete updateData[model.primaryKey];
 
     // Serialize JSON fields
-    updateData = serializeJsonFields(updateData, jsonColumns);
+    if (hasJson) {
+      updateData = serializeJsonFields(updateData, jsonColumns);
+    }
 
     // Update the record
     const updated = await baseQuery()

package/core/orm/schema-helpers.js

@@ -5,6 +5,9 @@
  */
 
 const METADATA_MARKER = '__wdb__';
+const metaWeakMap = new WeakMap();
+const metaStringCache = new Map();
+const schemaColumnsWeakMap = new WeakMap();
 
 /**
  * Encode column metadata into a JSON string for Zod .describe()
@@ -22,14 +25,25 @@ function encodeColumnMeta(meta) {
  */
 function decodeColumnMeta(description) {
   if (!description) return null;
+  const cached = metaStringCache.get(description);
+  if (cached !== undefined) return cached;
+
   try {
     const parsed = JSON.parse(description);
     if (parsed && parsed[METADATA_MARKER]) {
-      return parsed.meta;
+      const meta = parsed.meta;
+      if (metaStringCache.size < 500) {
+        metaStringCache.set(description, meta);
+      }
+      return meta;
     }
   } catch {
     // Not our metadata, ignore
   }
+
+  if (metaStringCache.size < 500) {
+    metaStringCache.set(description, null);
+  }
   return null;
 }
 
@@ -39,7 +53,7 @@ function decodeColumnMeta(description) {
  * @returns {boolean}
  */
 function hasColumnMeta(schema) {
-  return decodeColumnMeta(schema.description) !== null;
+  return getColumnMeta(schema) !== null;
 }
 
 /**
@@ -48,6 +62,10 @@ function hasColumnMeta(schema) {
  * @returns {import('./types').ColumnMeta|null}
  */
 function getColumnMeta(schema) {
+  if (!schema) return null;
+  const direct = metaWeakMap.get(schema);
+  if (direct !== undefined) return direct;
+  if (schema._wdbMeta) return schema._wdbMeta;
   return decodeColumnMeta(schema.description);
 }
 
@@ -253,6 +271,7 @@ class SchemaBuilder {
 
     // Apply metadata to schema
     this._schema = this._schema.describe(encodeColumnMeta(finalMeta));
+    metaWeakMap.set(this._schema, finalMeta);
     this._finalized = true;
     return this._schema;
   }
@@ -770,6 +789,15 @@ function createSchemaHelpers(z) {
  * @returns {Map<string, import('./types').ColumnMeta>}
  */
 function extractColumnsFromSchema(schema) {
+  if (!schema || typeof schema !== 'object' || !schema.shape) {
+    return new Map();
+  }
+
+  const cached = schemaColumnsWeakMap.get(schema);
+  if (cached !== undefined) {
+    return cached;
+  }
+
   const columns = new Map();
   const shape = schema.shape;
 
@@ -806,6 +834,7 @@ function extractColumnsFromSchema(schema) {
     }
   }
 
+  schemaColumnsWeakMap.set(schema, columns);
   return columns;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webspresso",
-  "version": "0.0.88",
+  "version": "0.0.89",
   "description": "Minimal, production-ready SSR framework for Node.js with file-based routing, Nunjucks templating, built-in i18n, and CLI tooling",
   "main": "index.js",
   "types": "index.d.ts",