webspresso 0.0.97 → 0.0.98

package/core/orm/model.js

@@ -107,6 +107,22 @@ function defineModel(options) {
       sortable: admin.sortable,
       sortableColumns: admin.sortableColumns,
       columns: admin.columns,
+      listColumns: Array.isArray(admin.listColumns) ? admin.listColumns : null,
+      searchFields: Array.isArray(admin.searchFields) ? admin.searchFields : null,
+      displayField: typeof admin.displayField === 'string' ? admin.displayField : null,
+      readOnly: admin.readOnly === true,
+      permissions: {
+        create: admin.permissions?.create !== false,
+        edit: admin.permissions?.edit !== false,
+        delete: admin.permissions?.delete !== false,
+      },
+      defaultSort: typeof admin.defaultSort === 'object' && admin.defaultSort !== null ? admin.defaultSort : null,
+      group: typeof admin.group === 'string' ? admin.group : (typeof admin.menuGroup === 'string' ? admin.menuGroup : null),
+      menuOrder: typeof admin.menuOrder === 'number' ? admin.menuOrder : 10,
+      actions: Array.isArray(admin.actions) ? admin.actions : null,
+      bulkActions: Array.isArray(admin.bulkActions) ? admin.bulkActions : null,
+      hooks: typeof admin.hooks === 'object' && admin.hooks !== null ? admin.hooks : null,
+      relations: typeof admin.relations === 'object' && admin.relations !== null ? admin.relations : null,
     },
     rest: {
       enabled: rest.enabled === true,
@@ -152,13 +168,36 @@ function registerModelHooks(modelName, hooks) {
   }
 }
 
+/**
+ * Extract model name string from string, String object, or model definition/context
+ * @param {string|Object} nameOrModel - Model name or object
+ * @returns {string}
+ */
+function resolveModelName(nameOrModel) {
+  if (typeof nameOrModel === 'string') {
+    return nameOrModel;
+  }
+  if (nameOrModel && typeof nameOrModel === 'object') {
+    if (typeof nameOrModel.name === 'string') return nameOrModel.name;
+    if (typeof nameOrModel.modelName === 'string') return nameOrModel.modelName;
+    if (typeof nameOrModel.model === 'string') return nameOrModel.model;
+    if (typeof nameOrModel.valueOf === 'function') {
+      const val = nameOrModel.valueOf();
+      if (typeof val === 'string') return val;
+    }
+    return String(nameOrModel);
+  }
+  return nameOrModel != null ? String(nameOrModel) : '';
+}
+
 /**
  * Get a model by name
- * @param {string} name - Model name
+ * @param {string|Object} name - Model name
  * @returns {import('./types').ModelDefinition|undefined}
  */
 function getModel(name) {
-  return modelRegistry.get(name);
+  const modelName = resolveModelName(name);
+  return modelRegistry.get(modelName);
 }
 
 /**
@@ -171,11 +210,12 @@ function getAllModels() {
 
 /**
  * Check if a model exists
- * @param {string} name - Model name
+ * @param {string|Object} name - Model name
  * @returns {boolean}
  */
 function hasModel(name) {
-  return modelRegistry.has(name);
+  const modelName = resolveModelName(name);
+  return modelRegistry.has(modelName);
 }
 
 /**
@@ -187,11 +227,12 @@ function clearRegistry() {
 
 /**
  * Unregister a model by name
- * @param {string} name - Model name
+ * @param {string|Object} name - Model name
  * @returns {boolean} Whether the model was removed
  */
 function unregisterModel(name) {
-  return modelRegistry.delete(name);
+  const modelName = resolveModelName(name);
+  return modelRegistry.delete(modelName);
 }
 
 /**
@@ -201,7 +242,7 @@ function unregisterModel(name) {
  */
 function resolveRelationModel(relation) {
   let model = typeof relation.model === 'function' ? relation.model() : relation.model;
-  if (typeof model === 'string') {
+  if (typeof model === 'string' || (model && typeof model === 'object' && !model.table)) {
     model = getModel(model);
   }
   if (!model || !model.name) {
@@ -239,6 +280,7 @@ module.exports = {
   hasModel,
   clearRegistry,
   unregisterModel,
+  resolveModelName,
   resolveRelationModel,
   getRelationKeys,
   // Export registry for testing

package/core/queue/adapters/database.js

@@ -271,6 +271,100 @@ class DatabaseQueueAdapter {
     return stats;
   }
 
+  /**
+   * Delete completed or failed jobs older than a cutoff date
+   * @param {Object} [options={}]
+   * @param {string|string[]} [options.status=['completed']] - Job statuses to prune
+   * @param {Date|string|number} [options.olderThan] - Explicit cutoff date
+   * @param {number} [options.days=7] - Retention in days (used if olderThan not provided)
+   * @param {number} [options.retentionDays] - Alias for days
+   * @param {number} [options.limit] - Max number of records to delete
+   * @returns {Promise<number>} Number of deleted jobs
+   */
+  async clean(options = {}) {
+    await this.ensureTable();
+
+    let olderThan;
+    if (options.olderThan !== undefined) {
+      olderThan = options.olderThan instanceof Date
+        ? options.olderThan
+        : new Date(options.olderThan);
+
+      if (Number.isNaN(olderThan.getTime())) {
+        throw new Error('clean: invalid olderThan date');
+      }
+    } else {
+      const rawDays = options.days !== undefined
+        ? options.days
+        : (options.retentionDays !== undefined ? options.retentionDays : 7);
+      const days = typeof rawDays === 'number' ? rawDays : Number(rawDays);
+      if (Number.isNaN(days) || days < 0) {
+        throw new Error('clean: days must be a non-negative number');
+      }
+      olderThan = new Date(Date.now() - days * 24 * 60 * 60 * 1000);
+    }
+
+    let statuses = ['completed'];
+    if (options.status) {
+      if (Array.isArray(options.status)) {
+        statuses = options.status;
+      } else if (typeof options.status === 'string') {
+        if (options.status === '*' || options.status === 'all') {
+          statuses = ['completed', 'failed', 'pending'];
+        } else {
+          statuses = options.status.split(',').map((s) => s.trim()).filter(Boolean);
+        }
+      }
+    }
+
+    const client = this.knex?.client?.config?.client;
+    const isSqlite = client === 'sqlite3' || client === 'better-sqlite3';
+
+    let query = this.knex(this.tableName);
+
+    if (statuses.length === 1) {
+      query = query.where('status', statuses[0]);
+    } else if (statuses.length > 1) {
+      query = query.whereIn('status', statuses);
+    }
+
+    if (isSqlite) {
+      const iso = olderThan.toISOString();
+      const cutoffMs = olderThan.getTime();
+      query = query.where((builder) => {
+        builder
+          .whereRaw(
+            "((typeof(updated_at) = 'integer' and updated_at < ?) or (typeof(updated_at) = 'text' and updated_at < ?))",
+            [cutoffMs, iso]
+          )
+          .orWhere((b2) => {
+            b2.whereNull('updated_at').andWhereRaw(
+              "((typeof(created_at) = 'integer' and created_at < ?) or (typeof(created_at) = 'text' and created_at < ?))",
+              [cutoffMs, iso]
+            );
+          });
+      });
+    } else {
+      query = query.where((builder) => {
+        builder.where('updated_at', '<', olderThan)
+          .orWhere((b2) => {
+            b2.whereNull('updated_at').andWhere('created_at', '<', olderThan);
+          });
+      });
+    }
+
+    if (typeof options.limit === 'number' && options.limit > 0) {
+      const rows = await query.clone().select('id').limit(options.limit);
+      if (rows.length === 0) return 0;
+      const ids = rows.map((r) => r.id);
+      const deleted = await this.knex(this.tableName).whereIn('id', ids).del();
+      return Number(deleted) || 0;
+    }
+
+    const deleted = await query.del();
+    return Number(deleted) || 0;
+  }
+
   /**
    * Clear all jobs from table
    * @returns {Promise<void>}

package/core/queue/adapters/memory.js

@@ -164,6 +164,68 @@ class MemoryQueueAdapter {
     };
   }
 
+  /**
+   * Delete completed or failed jobs older than a cutoff date
+   * @param {Object} [options={}]
+   * @param {string|string[]} [options.status=['completed']]
+   * @param {Date|string|number} [options.olderThan]
+   * @param {number} [options.days=7]
+   * @param {number} [options.retentionDays]
+   * @param {number} [options.limit]
+   * @returns {Promise<number>}
+   */
+  async clean(options = {}) {
+    let olderThan;
+    if (options.olderThan !== undefined) {
+      olderThan = options.olderThan instanceof Date
+        ? options.olderThan
+        : new Date(options.olderThan);
+
+      if (Number.isNaN(olderThan.getTime())) {
+        throw new Error('clean: invalid olderThan date');
+      }
+    } else {
+      const rawDays = options.days !== undefined
+        ? options.days
+        : (options.retentionDays !== undefined ? options.retentionDays : 7);
+      const days = typeof rawDays === 'number' ? rawDays : Number(rawDays);
+      if (Number.isNaN(days) || days < 0) {
+        throw new Error('clean: days must be a non-negative number');
+      }
+      olderThan = new Date(Date.now() - days * 24 * 60 * 60 * 1000);
+    }
+
+    let statuses = ['completed'];
+    if (options.status) {
+      if (Array.isArray(options.status)) {
+        statuses = options.status;
+      } else if (typeof options.status === 'string') {
+        if (options.status === '*' || options.status === 'all') {
+          statuses = ['completed', 'failed', 'pending'];
+        } else {
+          statuses = options.status.split(',').map((s) => s.trim()).filter(Boolean);
+        }
+      }
+    }
+
+    const cutoffTime = olderThan.getTime();
+    let deletedCount = 0;
+    const limit = typeof options.limit === 'number' && options.limit > 0 ? options.limit : Infinity;
+
+    for (const [id, job] of this.jobs.entries()) {
+      if (deletedCount >= limit) break;
+      if (!statuses.includes(job.status)) continue;
+
+      const jobTime = (job.updatedAt instanceof Date ? job.updatedAt.getTime() : (job.createdAt instanceof Date ? job.createdAt.getTime() : 0));
+      if (jobTime < cutoffTime) {
+        this.jobs.delete(id);
+        deletedCount++;
+      }
+    }
+
+    return deletedCount;
+  }
+
   /**
    * Clear all jobs
    * @returns {Promise<void>}

package/core/queue/adapters/redis.js

@@ -336,6 +336,86 @@ class RedisQueueAdapter {
     };
   }
 
+  /**
+   * Delete completed or failed jobs older than a cutoff date
+   * @param {Object} [options={}]
+   * @param {string|string[]} [options.status=['completed']]
+   * @param {Date|string|number} [options.olderThan]
+   * @param {number} [options.days=7]
+   * @param {number} [options.retentionDays]
+   * @param {number} [options.limit]
+   * @returns {Promise<number>}
+   */
+  async clean(options = {}) {
+    let olderThan;
+    if (options.olderThan !== undefined) {
+      olderThan = options.olderThan instanceof Date
+        ? options.olderThan
+        : new Date(options.olderThan);
+
+      if (Number.isNaN(olderThan.getTime())) {
+        throw new Error('clean: invalid olderThan date');
+      }
+    } else {
+      const rawDays = options.days !== undefined
+        ? options.days
+        : (options.retentionDays !== undefined ? options.retentionDays : 7);
+      const days = typeof rawDays === 'number' ? rawDays : Number(rawDays);
+      if (Number.isNaN(days) || days < 0) {
+        throw new Error('clean: days must be a non-negative number');
+      }
+      olderThan = new Date(Date.now() - days * 24 * 60 * 60 * 1000);
+    }
+
+    let statuses = ['completed'];
+    if (options.status) {
+      if (Array.isArray(options.status)) {
+        statuses = options.status;
+      } else if (typeof options.status === 'string') {
+        if (options.status === '*' || options.status === 'all') {
+          statuses = ['completed', 'failed'];
+        } else {
+          statuses = options.status.split(',').map((s) => s.trim()).filter(Boolean);
+        }
+      }
+    }
+
+    const cutoffTime = olderThan.getTime();
+    let deletedCount = 0;
+    const limit = typeof options.limit === 'number' && options.limit > 0 ? options.limit : Infinity;
+
+    for (const status of statuses) {
+      const setKey = this._key(status);
+      let jobIds = [];
+      try {
+        if (typeof this.client.smembers === 'function') {
+          jobIds = (await this.client.smembers(setKey)) || [];
+        } else if (typeof this.client.sMembers === 'function') {
+          jobIds = (await this.client.sMembers(setKey)) || [];
+        }
+      } catch {}
+
+      for (const id of jobIds) {
+        if (deletedCount >= limit) break;
+        const job = await this.getJob(id);
+        const jobTime = job?.updatedAt ? new Date(job.updatedAt).getTime() : 0;
+        if (!job || jobTime < cutoffTime) {
+          if (typeof this.client.srem === 'function') {
+            await this.client.srem(setKey, id);
+          } else if (typeof this.client.sRem === 'function') {
+            await this.client.sRem(setKey, id);
+          }
+          if (typeof this.client.del === 'function') {
+            await this.client.del(this._key('job:' + id));
+          }
+          deletedCount++;
+        }
+      }
+    }
+
+    return deletedCount;
+  }
+
   /**
    * Clear all queue keys
    * @returns {Promise<void>}

package/core/queue/manager.js

@@ -42,6 +42,42 @@ class QueueManager extends EventEmitter {
     this.isRunning = false;
     this._timer = null;
 
+    // Retention configuration
+    const retentionOption = options.retention;
+    const isRetentionDisabled =
+      retentionOption === false ||
+      (typeof retentionOption === 'object' && retentionOption.enabled === false) ||
+      options.retentionDays === null;
+
+    const autoCleanupEnabled =
+      !isRetentionDisabled &&
+      options.autoCleanup !== false &&
+      (typeof retentionOption !== 'object' || retentionOption.autoCleanup !== false) &&
+      (retentionOption !== undefined || options.retentionDays !== undefined || options.cleanupIntervalMs !== undefined);
+
+    this.retentionConfig = {
+      enabled: !isRetentionDisabled && autoCleanupEnabled,
+      days: (typeof options.retentionDays === 'number' && options.retentionDays >= 0)
+        ? options.retentionDays
+        : (typeof retentionOption === 'object' && retentionOption?.days ? retentionOption.days : 7),
+      statuses: (typeof retentionOption === 'object' && retentionOption?.statuses)
+        ? retentionOption.statuses
+        : (options.retentionStatuses || ['completed']),
+      intervalMs: (typeof options.cleanupIntervalMs === 'number' && options.cleanupIntervalMs > 0)
+        ? options.cleanupIntervalMs
+        : (typeof retentionOption === 'object' && retentionOption?.intervalMs ? retentionOption.intervalMs : 24 * 60 * 60 * 1000),
+      runOnStart: (typeof retentionOption === 'object' && retentionOption?.runOnStart !== undefined)
+        ? !!retentionOption.runOnStart
+        : (options.cleanupOnStart !== undefined ? !!options.cleanupOnStart : false),
+    };
+
+    this._cleanupInterval = null;
+    this._cleanupStartTimeout = null;
+
+    if (this.retentionConfig.enabled) {
+      this.startCleanup();
+    }
+
     if (this.jobsDir && fs.existsSync(this.jobsDir)) {
       this.loadJobsFromDirectory(this.jobsDir);
     }
@@ -199,6 +235,7 @@ class QueueManager extends EventEmitter {
 
     this.isDraining = false;
     this.isRunning = false;
+    this.stopCleanup();
     this.emit('drain');
   }
 
@@ -208,9 +245,95 @@ class QueueManager extends EventEmitter {
   async stop() {
     this.pause();
     this.isRunning = false;
+    this.stopCleanup();
     this.emit('stop');
   }
 
+  /**
+   * Delete completed or failed jobs older than a cutoff date
+   * @param {Object} [options={}]
+   * @param {string|string[]} [options.status=['completed']]
+   * @param {Date|string|number} [options.olderThan]
+   * @param {number} [options.days=7]
+   * @param {number} [options.retentionDays]
+   * @param {number} [options.limit]
+   * @returns {Promise<number>}
+   */
+  async clean(options = {}) {
+    if (this.adapter && typeof this.adapter.clean === 'function') {
+      return this.adapter.clean(options);
+    }
+    return 0;
+  }
+
+  /**
+   * Run one-time retention cleanup pass
+   * @returns {Promise<number>}
+   */
+  async runCleanup() {
+    try {
+      return await this.clean({
+        status: this.retentionConfig.statuses,
+        days: this.retentionConfig.days,
+      });
+    } catch (err) {
+      if (process.env.NODE_ENV !== 'test') {
+        console.warn('[QueueManager] Failed to run retention cleanup:', err.message);
+      }
+      return 0;
+    }
+  }
+
+  /**
+   * Start auto-retention cleanup timer
+   * @param {number} [customIntervalMs]
+   */
+  startCleanup(customIntervalMs) {
+    this.stopCleanup();
+    if (!this.retentionConfig.enabled) return;
+    if (typeof customIntervalMs === 'number' && customIntervalMs > 0) {
+      this.retentionConfig.intervalMs = customIntervalMs;
+    }
+
+    if (this.retentionConfig.runOnStart) {
+      const delayMs = process.env.NODE_ENV === 'test' ? 50 : 5000;
+      this._cleanupStartTimeout = setTimeout(() => {
+        this.runCleanup();
+      }, delayMs);
+      if (this._cleanupStartTimeout && this._cleanupStartTimeout.unref) {
+        this._cleanupStartTimeout.unref();
+      }
+    }
+
+    this._cleanupInterval = setInterval(() => {
+      this.runCleanup();
+    }, this.retentionConfig.intervalMs);
+    if (this._cleanupInterval && this._cleanupInterval.unref) {
+      this._cleanupInterval.unref();
+    }
+  }
+
+  /**
+   * Stop auto-retention cleanup timer
+   */
+  stopCleanup() {
+    if (this._cleanupStartTimeout) {
+      clearTimeout(this._cleanupStartTimeout);
+      this._cleanupStartTimeout = null;
+    }
+    if (this._cleanupInterval) {
+      clearInterval(this._cleanupInterval);
+      this._cleanupInterval = null;
+    }
+  }
+
+  /**
+   * Get retention configuration
+   */
+  getRetentionConfig() {
+    return { ...this.retentionConfig };
+  }
+
   /**
    * Get queue statistics
    */

package/core/ssr/stream.js

@@ -182,6 +182,17 @@ function renderStream(res, templatePath, context = {}, options = {}) {
     };
 
     res.on('close', cleanup);
+    if (typeof res.on === 'function') {
+      res.on('error', (err) => {
+        if (!finished) {
+          finished = true;
+          if (!stream.destroyed) {
+            stream.destroy(err);
+          }
+          reject(err);
+        }
+      });
+    }
 
     stream.on('data', (chunk) => {
       if (!finished && !res.writableEnded) {