webspresso 0.0.108 → 0.0.110

package/plugins/queue/api-handlers.js

@@ -0,0 +1,248 @@
+/**
+ * Job Queue Admin API Handlers
+ * REST endpoints for dashboard metrics, job listing, details, retrying, and dispatching
+ * @module plugins/queue/api-handlers
+ */
+
+'use strict';
+
+/**
+ * Create Queue API route handlers
+ * 
+ * @param {import('../../core/queue/manager').QueueManager} queueManager 
+ * @param {Object} [options]
+ * @returns {Record<string, Function>}
+ */
+function createQueueApiHandlers(queueManager, options = {}) {
+  if (!queueManager) {
+    throw new Error('queueManager is required for createQueueApiHandlers');
+  }
+
+  /**
+   * GET /stats — Real-time queue metrics
+   */
+  async function getStatsHandler(req, res) {
+    try {
+      const stats = await queueManager.getStats();
+      return res.status(200).json(stats);
+    } catch (err) {
+      return res.status(500).json({ error: err.message || 'Failed to fetch queue statistics' });
+    }
+  }
+
+  /**
+   * GET /jobs — List jobs with status, search and pagination
+   */
+  async function listJobsHandler(req, res) {
+    try {
+      const query = {
+        status: req.query.status,
+        name: req.query.name,
+        search: req.query.search || req.query.q,
+        page: req.query.page ? parseInt(req.query.page, 10) : 1,
+        limit: req.query.limit ? parseInt(req.query.limit, 10) : 20,
+        sortBy: req.query.sortBy || 'createdAt',
+        sortOrder: req.query.sortOrder || 'desc',
+      };
+      const result = await queueManager.listJobs(query);
+      return res.status(200).json(result);
+    } catch (err) {
+      return res.status(500).json({ error: err.message || 'Failed to list jobs' });
+    }
+  }
+
+  /**
+   * GET /jobs/:id — Get single job details
+   */
+  async function getJobHandler(req, res) {
+    try {
+      const id = req.params.id;
+      const job = await queueManager.getJob(id);
+      if (!job) {
+        return res.status(404).json({ error: `Job #${id} not found` });
+      }
+      return res.status(200).json(typeof job.toJSON === 'function' ? job.toJSON() : job);
+    } catch (err) {
+      return res.status(500).json({ error: err.message || 'Failed to get job' });
+    }
+  }
+
+  /**
+   * POST /jobs/:id/retry — Retry a job
+   */
+  async function retryJobHandler(req, res) {
+    try {
+      const id = req.params.id;
+      const opts = req.body || {};
+      const job = await queueManager.retryJob(id, opts);
+      if (!job) {
+        return res.status(404).json({ error: `Job #${id} not found to retry` });
+      }
+      return res.status(200).json({
+        success: true,
+        message: `Job #${id} has been re-queued for execution`,
+        job: typeof job.toJSON === 'function' ? job.toJSON() : job,
+      });
+    } catch (err) {
+      return res.status(400).json({ error: err.message || 'Failed to retry job' });
+    }
+  }
+
+  /**
+   * POST /jobs/bulk-retry — Bulk retry multiple jobs
+   */
+  async function bulkRetryHandler(req, res) {
+    try {
+      const ids = req.body?.ids || req.body?.jobIds || [];
+      if (!Array.isArray(ids) || ids.length === 0) {
+        return res.status(400).json({ error: 'ids array is required for bulk retry' });
+      }
+      const opts = req.body || {};
+      const result = await queueManager.bulkRetry(ids, opts);
+      return res.status(200).json({
+        success: true,
+        retried: result.retried,
+        total: ids.length,
+      });
+    } catch (err) {
+      return res.status(400).json({ error: err.message || 'Failed to bulk retry jobs' });
+    }
+  }
+
+  /**
+   * DELETE /jobs/:id (or POST /jobs/:id/cancel) — Cancel and remove a job
+   */
+  async function cancelJobHandler(req, res) {
+    try {
+      const id = req.params.id;
+      const result = await queueManager.cancelJob(id);
+      return res.status(200).json(result);
+    } catch (err) {
+      return res.status(400).json({ error: err.message || 'Failed to cancel job' });
+    }
+  }
+
+  /**
+   * POST /jobs/purge — Purge completed and/or failed jobs
+   */
+  async function purgeJobsHandler(req, res) {
+    try {
+      const status = req.body?.status || req.query?.status || ['completed', 'failed'];
+      const purgedCount = await queueManager.purgeJobs({ status });
+      return res.status(200).json({
+        success: true,
+        purged: purgedCount,
+        message: `Successfully purged ${purgedCount} jobs.`,
+      });
+    } catch (err) {
+      return res.status(500).json({ error: err.message || 'Failed to purge jobs' });
+    }
+  }
+
+  /**
+   * POST /dispatch — Manually dispatch an ad-hoc job
+   */
+  async function dispatchJobHandler(req, res) {
+    try {
+      const { name, data, delay, delayMs, priority, attempts, timeout } = req.body || {};
+      if (!name) {
+        return res.status(400).json({ error: 'Job name is required' });
+      }
+
+      const job = await queueManager.dispatch(name, data || {}, {
+        delay: delay !== undefined ? delay : delayMs,
+        priority: priority !== undefined ? Number(priority) : undefined,
+        attempts: attempts !== undefined ? Number(attempts) : undefined,
+        timeout: timeout !== undefined ? timeout : undefined,
+      });
+
+      return res.status(201).json({
+        success: true,
+        message: `Job '${name}' (${job.id}) enqueued successfully`,
+        job: typeof job.toJSON === 'function' ? job.toJSON() : job,
+      });
+    } catch (err) {
+      return res.status(400).json({ error: err.message || 'Failed to dispatch job' });
+    }
+  }
+
+  /**
+   * POST /pause — Pause queue processing
+   */
+  async function pauseQueueHandler(req, res) {
+    try {
+      queueManager.pause();
+      return res.status(200).json({
+        success: true,
+        isPaused: queueManager.isPaused,
+        message: 'Queue processing paused',
+      });
+    } catch (err) {
+      return res.status(500).json({ error: err.message || 'Failed to pause queue' });
+    }
+  }
+
+  /**
+   * POST /resume — Resume queue processing
+   */
+  async function resumeQueueHandler(req, res) {
+    try {
+      queueManager.resume();
+      return res.status(200).json({
+        success: true,
+        isPaused: queueManager.isPaused,
+        message: 'Queue processing resumed',
+      });
+    } catch (err) {
+      return res.status(500).json({ error: err.message || 'Failed to resume queue' });
+    }
+  }
+
+  /**
+   * GET /schedules — List registered schedules (cron jobs)
+   */
+  async function getSchedulesHandler(req, res) {
+    try {
+      const schedules = queueManager.getSchedules ? queueManager.getSchedules() : [];
+      return res.status(200).json(schedules);
+    } catch (err) {
+      return res.status(500).json({ error: err.message || 'Failed to list schedules' });
+    }
+  }
+
+  /**
+   * POST /schedules/:id/trigger — Manually trigger a scheduled job
+   */
+  async function triggerScheduleHandler(req, res) {
+    try {
+      const idOrName = req.params.id || req.body?.id;
+      const job = await queueManager.triggerSchedule(idOrName);
+      return res.status(200).json({
+        success: true,
+        message: `Scheduled task '${idOrName}' triggered successfully`,
+        job: job ? (typeof job.toJSON === 'function' ? job.toJSON() : job) : null,
+      });
+    } catch (err) {
+      return res.status(400).json({ error: err.message || 'Failed to trigger schedule' });
+    }
+  }
+
+  return {
+    getStatsHandler,
+    listJobsHandler,
+    getJobHandler,
+    retryJobHandler,
+    bulkRetryHandler,
+    cancelJobHandler,
+    purgeJobsHandler,
+    dispatchJobHandler,
+    pauseQueueHandler,
+    resumeQueueHandler,
+    getSchedulesHandler,
+    triggerScheduleHandler,
+  };
+}
+
+module.exports = {
+  createQueueApiHandlers,
+};

package/plugins/queue/index.js

@@ -109,6 +109,22 @@ function queuePlugin(options = {}) {
         });
       }
 
+      // Register built-in queue services if service registry is available
+      const registry = ctx.serviceRegistry || ctx.services || ctx.app?.serviceRegistry;
+      if (registry && typeof registry.register === 'function') {
+        try {
+          const { createQueueServices } = require('../../core/services/builtins/queue');
+          const services = createQueueServices({ queueManager });
+          for (const [name, def] of Object.entries(services)) {
+            if (!registry.has(name)) {
+              registry.register(name, def);
+            }
+          }
+        } catch (svcErr) {
+          console.warn('[queuePlugin] Failed to register built-in queue services:', svcErr.message);
+        }
+      }
+
       this.queue = queueManager;
     },
 
@@ -125,6 +141,59 @@ function queuePlugin(options = {}) {
       if (jobsDir && fs.existsSync(jobsDir)) {
         queueManager.loadJobsFromDirectory(jobsDir);
       }
+
+      // Check if admin-panel plugin is active
+      const adminApi = ctx.usePlugin ? ctx.usePlugin('admin-panel') : null;
+      if (adminApi && typeof adminApi.registerModule === 'function') {
+        const { createQueueApiHandlers } = require('./api-handlers');
+        const { generateQueueComponent } = require('./admin-component');
+
+        const pageTitle = options.adminTitle || 'Job Queue';
+        const apiPrefix = options.adminApiPrefix || '/queue';
+        const menuOrder = options.menuOrder !== undefined ? options.menuOrder : 55;
+        const apiHandlers = createQueueApiHandlers(queueManager, options);
+
+        adminApi.registerModule({
+          id: 'queue',
+          title: pageTitle,
+          pages: [
+            {
+              id: 'queue',
+              title: pageTitle,
+              path: '/queue',
+              icon: 'clock',
+              component: generateQueueComponent({ apiPrefix }),
+            },
+          ],
+          menu: [
+            {
+              id: 'queue',
+              label: pageTitle,
+              path: '/queue',
+              icon: 'clock',
+              order: menuOrder,
+            },
+          ],
+          api: {
+            prefix: apiPrefix,
+            routes: [
+              { method: 'get', path: '/stats', handler: apiHandlers.getStatsHandler },
+              { method: 'get', path: '/jobs', handler: apiHandlers.listJobsHandler },
+              { method: 'get', path: '/jobs/:id', handler: apiHandlers.getJobHandler },
+              { method: 'post', path: '/jobs/:id/retry', handler: apiHandlers.retryJobHandler },
+              { method: 'post', path: '/jobs/bulk-retry', handler: apiHandlers.bulkRetryHandler },
+              { method: 'post', path: '/jobs/:id/cancel', handler: apiHandlers.cancelJobHandler },
+              { method: 'delete', path: '/jobs/:id', handler: apiHandlers.cancelJobHandler },
+              { method: 'post', path: '/jobs/purge', handler: apiHandlers.purgeJobsHandler },
+              { method: 'post', path: '/dispatch', handler: apiHandlers.dispatchJobHandler },
+              { method: 'post', path: '/pause', handler: apiHandlers.pauseQueueHandler },
+              { method: 'post', path: '/resume', handler: apiHandlers.resumeQueueHandler },
+              { method: 'get', path: '/schedules', handler: apiHandlers.getSchedulesHandler },
+              { method: 'post', path: '/schedules/:id/trigger', handler: apiHandlers.triggerScheduleHandler },
+            ],
+          },
+        });
+      }
     },
 
     async dispose() {

package/plugins/rest-resources/index.js

@@ -8,7 +8,7 @@ const { getAllModels } = require('../../core/orm/model');
 const { omit } = require('../../core/orm/utils');
 const { trimUrlPathSlashes } = require('../../core/url-path-normalize');
 const { validateQueryComplexity } = require('../../core/orm/complexity');
-const { applyColumnFilters, RESERVED_QUERY_KEYS } = require('../../core/orm/query-filters');
+const { applyColumnFilters, isPublicColumn } = require('../../core/orm/query-filters');
 
 /**
  * Pluralize a PascalCase model name to a URL segment (e.g. User -> users, Company -> companies)
@@ -95,6 +95,7 @@ function sanitizeRecordTree(record, model) {
 
 /**
  * Only real table columns; drop relations and hidden (aligned with repo validation).
+ * When model.rest.writable is set, only those columns are accepted (mass-assignment guard).
  * @param {Object} body
  * @param {import('../../core/orm/types').ModelDefinition} model
  * @returns {Object}
@@ -104,10 +105,14 @@ function pickWritableColumns(body, model) {
   if (!body || typeof body !== 'object') {
     return out;
   }
+  const writable = Array.isArray(model.rest?.writable) ? new Set(model.rest.writable) : null;
   for (const key of Object.keys(body)) {
     if (!model.columns.has(key)) {
       continue;
     }
+    if (writable && !writable.has(key)) {
+      continue;
+    }
     const meta = model.columns.get(key);
     if (meta.primary && meta.autoIncrement) {
       continue;
@@ -181,7 +186,7 @@ function parseSortParams(model, rawSort, rawOrder) {
   function addSort(col, dir) {
     if (!col || typeof col !== 'string') return;
     const cleanCol = col.trim();
-    if (!model.columns.has(cleanCol) || seen.has(cleanCol)) return;
+    if (!isPublicColumn(model, cleanCol) || seen.has(cleanCol)) return;
     seen.add(cleanCol);
     const cleanDir = String(dir || 'asc').toLowerCase() === 'desc' ? 'desc' : 'asc';
     result.push({ column: cleanCol, direction: cleanDir });