webspresso 0.0.97 → 0.0.99

package/plugins/audit-log/api-handlers.js

@@ -3,6 +3,8 @@
  * @module plugins/audit-log/api-handlers
  */
 
+const { purgeAuditLogs } = require('./purge');
+
 /**
  * @param {Object} options
  * @param {import('knex').Knex} options.knex
@@ -19,12 +21,34 @@ function createAuditLogHandlers(options) {
     if (query.action) {
       qb.where('action', String(query.action));
     }
+    const recordId = query.recordId || query.resource_id || query.resourceId;
+    if (recordId !== undefined && recordId !== null && String(recordId).trim() !== '') {
+      qb.where('resource_id', String(recordId));
+    }
+    const actorId = query.actorId || query.actor_id;
+    if (actorId !== undefined && actorId !== null && String(actorId).trim() !== '') {
+      qb.where('actor_id', Number(actorId));
+    }
+    const actorEmail = query.actorEmail || query.actor_email;
+    if (actorEmail) {
+      qb.where('actor_email', 'like', `%${String(actorEmail).trim()}%`);
+    }
     if (query.from) {
       qb.where('created_at', '>=', String(query.from));
     }
     if (query.to) {
       qb.where('created_at', '<=', String(query.to));
     }
+    const searchTerm = query.search || query.q;
+    if (searchTerm && String(searchTerm).trim() !== '') {
+      const term = `%${String(searchTerm).trim()}%`;
+      qb.where((sub) => {
+        sub.where('actor_email', 'like', term)
+          .orWhere('path', 'like', term)
+          .orWhere('resource_id', 'like', term)
+          .orWhere('resource_model', 'like', term);
+      });
+    }
   }
 
   async function listHandler(req, res) {
@@ -51,13 +75,119 @@ function createAuditLogHandlers(options) {
     }
   }
 
+  /**
+   * Dedicated Record Timeline Handler
+   * GET /audit-logs/timeline/:model/:id or GET /audit-logs/timeline?model=Post&id=1
+   */
+  async function timelineHandler(req, res) {
+    try {
+      const model = req.params?.model || req.query?.model;
+      const recordId = req.params?.id || req.query?.id || req.query?.recordId || req.query?.resource_id;
+
+      if (!model || recordId === undefined) {
+        return res.status(400).json({ error: 'model and id are required to fetch timeline' });
+      }
+
+      const rows = await knex(tableName)
+        .where({
+          resource_model: String(model),
+          resource_id: String(recordId),
+        })
+        .orderBy('created_at', 'asc');
+
+      const totalChanges = rows.length;
+      const createdEvent = rows.find((r) => r.action === 'create') || null;
+      const lastModifiedEvent = rows.length > 0 ? rows[rows.length - 1] : null;
+
+      const events = rows.map((r, index) => {
+        let parsedMetadata = r.metadata;
+        if (typeof parsedMetadata === 'string') {
+          try {
+            parsedMetadata = JSON.parse(parsedMetadata);
+          } catch {}
+        }
+
+        const changedFields = Array.isArray(parsedMetadata?.changedFields)
+          ? parsedMetadata.changedFields
+          : [];
+
+        return {
+          id: r.id,
+          action: r.action,
+          createdAt: r.created_at,
+          actor: {
+            id: r.actor_id,
+            email: r.actor_email,
+          },
+          resourceModel: r.resource_model,
+          resourceId: r.resource_id,
+          httpMethod: r.http_method,
+          path: r.path,
+          ip: r.ip,
+          userAgent: r.user_agent,
+          changedFields,
+          metadata: parsedMetadata,
+          index: index + 1,
+        };
+      });
+
+      res.json({
+        model: String(model),
+        recordId: String(recordId),
+        summary: {
+          totalChanges,
+          createdAt: createdEvent?.created_at || (events[0] ? events[0].createdAt : null),
+          createdBy: createdEvent?.actor_email || (events[0] ? events[0].actor?.email : null),
+          lastModifiedAt: lastModifiedEvent?.created_at || null,
+          lastModifiedBy: lastModifiedEvent?.actor_email || null,
+        },
+        timeline: events,
+      });
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  }
+
+  async function purgeHandler(req, res) {
+    try {
+      const body = req.body || {};
+      const query = req.query || {};
+      const rawDays = body.days !== undefined
+        ? body.days
+        : (body.retentionDays !== undefined ? body.retentionDays : (query.days !== undefined ? query.days : 90));
+      const days = parseInt(rawDays, 10);
+      if (Number.isNaN(days) || days < 1) {
+        return res.status(400).json({ error: 'days must be a positive integer' });
+      }
+
+      const olderThan = body.olderThan
+        ? new Date(body.olderThan)
+        : new Date(Date.now() - days * 24 * 60 * 60 * 1000);
+
+      if (Number.isNaN(olderThan.getTime())) {
+        return res.status(400).json({ error: 'invalid olderThan date' });
+      }
+
+      const deleted = await purgeAuditLogs(knex, {
+        tableName,
+        olderThan,
+      });
+
+      res.json({ ok: true, success: true, deleted, olderThan: olderThan.toISOString() });
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  }
+
   /**
    * Programmatic list (for other plugins)
    * @param {Object} [filters]
    * @param {string} [filters.model]
    * @param {string} [filters.action]
+   * @param {string} [filters.recordId]
    * @param {string} [filters.from]
    * @param {string} [filters.to]
+   * @param {string} [filters.search]
    * @param {number} [filters.limit=100]
    * @param {number} [filters.offset=0]
    */
@@ -72,9 +202,27 @@ function createAuditLogHandlers(options) {
       .limit(limit);
   }
 
+  /**
+   * Programmatic query for single record timeline
+   * @param {string} model
+   * @param {string|number} recordId
+   */
+  async function queryTimeline(model, recordId) {
+    if (!model || recordId === undefined) return [];
+    return knex(tableName)
+      .where({
+        resource_model: String(model),
+        resource_id: String(recordId),
+      })
+      .orderBy('created_at', 'asc');
+  }
+
   return {
     listHandler,
+    timelineHandler,
+    purgeHandler,
     queryLogs,
+    queryTimeline,
   };
 }
 

package/plugins/audit-log/index.js

@@ -16,40 +16,167 @@ const { purgeAuditLogs } = require('./purge');
  * @param {string} [options.tableName='audit_logs']
  * @param {boolean} [options.includeDefaultPage=true] - Register Mithril list page + menu
  * @param {string} [options.apiPrefix='/audit-logs'] - GET list under admin API
+ * @param {Object|boolean} [options.retention] - Retention policy configuration (set false to disable)
+ * @param {number} [options.retention.days=90] - Days to retain audit logs
+ * @param {number} [options.retention.intervalMs=86400000] - Auto-cleanup timer frequency (24h)
+ * @param {boolean} [options.retention.runOnStart=true] - Run initial purge shortly after startup
+ * @param {number} [options.retentionDays=90] - Shorthand for retention.days
+ * @param {number} [options.cleanupIntervalMs=86400000] - Shorthand for retention.intervalMs
+ * @param {boolean} [options.autoCleanup=true] - Enable automatic background cleanup
+ * @param {boolean} [options.cleanupOnStart=true] - Run initial purge on start
+ * @param {number} [options.cleanupStartDelayMs] - Delay in ms before start purge
  */
 function auditLogPlugin(options = {}) {
   const {
     db,
+    title,
+    adminTitle,
+    pageTitle: customPageTitle,
     adminPath: adminPathOpt,
     tableName = 'audit_logs',
     includeDefaultPage = true,
     apiPrefix = '/audit-logs',
+    registerRecordAction = true,
   } = options;
 
+  const pageTitle = title || adminTitle || customPageTitle || 'Audit log';
+
   if (!db) {
     throw new Error('audit-log plugin requires a database instance. Pass `db` in options.');
   }
 
   const knex = db.knex || db;
 
+  // Retention configuration
+  const retentionOption = options.retention;
+  const isRetentionDisabled =
+    retentionOption === false ||
+    (typeof retentionOption === 'object' && retentionOption.enabled === false) ||
+    options.retentionDays === null ||
+    options.retentionDays === 0;
+
+  const autoCleanupEnabled =
+    !isRetentionDisabled &&
+    options.autoCleanup !== false &&
+    (typeof retentionOption !== 'object' || retentionOption.autoCleanup !== false);
+
+  const retentionConfig = {
+    enabled: !isRetentionDisabled,
+    autoCleanup: autoCleanupEnabled,
+    days: (typeof options.retentionDays === 'number' && options.retentionDays > 0)
+      ? options.retentionDays
+      : (typeof retentionOption === 'object' && retentionOption?.days ? retentionOption.days : 90),
+    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 : true),
+  };
+
+  let cleanupInterval = null;
+  let cleanupStartTimeout = null;
+
+  async function runCleanup() {
+    try {
+      return await purgeAuditLogs(knex, {
+        tableName,
+        days: retentionConfig.days,
+      });
+    } catch (err) {
+      if (process.env.NODE_ENV !== 'test') {
+        console.warn('[audit-log] Failed to run retention cleanup:', err.message);
+      }
+    }
+  }
+
+  function startCleanup(customIntervalMs) {
+    stopCleanup();
+    if (!retentionConfig.enabled) return;
+    if (typeof customIntervalMs === 'number' && customIntervalMs > 0) {
+      retentionConfig.intervalMs = customIntervalMs;
+    }
+
+    if (retentionConfig.runOnStart) {
+      const delayMs = typeof options.cleanupStartDelayMs === 'number'
+        ? options.cleanupStartDelayMs
+        : (process.env.NODE_ENV === 'test' ? 50 : 5000);
+      cleanupStartTimeout = setTimeout(() => {
+        runCleanup();
+      }, delayMs);
+      if (cleanupStartTimeout && cleanupStartTimeout.unref) {
+        cleanupStartTimeout.unref();
+      }
+    }
+
+    cleanupInterval = setInterval(() => {
+      runCleanup();
+    }, retentionConfig.intervalMs);
+    if (cleanupInterval && cleanupInterval.unref) {
+      cleanupInterval.unref();
+    }
+  }
+
+  function stopCleanup() {
+    if (cleanupStartTimeout) {
+      clearTimeout(cleanupStartTimeout);
+      cleanupStartTimeout = null;
+    }
+    if (cleanupInterval) {
+      clearInterval(cleanupInterval);
+      cleanupInterval = null;
+    }
+  }
+
   const handlers = createAuditLogHandlers({ knex, tableName });
 
   return {
     name: 'audit-log',
     version: '1.0.0',
-    description: 'Audit trail for admin panel model CRUD API',
+    description: 'Audit trail for admin panel model CRUD API with retention cleanup',
     dependencies: { 'admin-panel': '*' },
 
     api: {
+      purge(opts = {}) {
+        return purgeAuditLogs(knex, {
+          tableName,
+          days: opts.days !== undefined ? opts.days : (opts.retentionDays !== undefined ? opts.retentionDays : retentionConfig.days),
+          olderThan: opts.olderThan,
+          ...opts,
+        });
+      },
       purgeAuditLogs: (kx, opts = {}) =>
-        purgeAuditLogs(kx || knex, { tableName: opts.tableName || tableName, olderThan: opts.olderThan }),
+        purgeAuditLogs(kx || knex, { tableName: opts.tableName || tableName, olderThan: opts.olderThan, days: opts.days, retentionDays: opts.retentionDays }),
+      startCleanup,
+      stopCleanup,
+      getRetentionConfig() {
+        return { ...retentionConfig };
+      },
       queryLogs: (filters) => handlers.queryLogs(filters),
+      queryTimeline: (model, recordId) => handlers.queryTimeline(model, recordId),
+      getRecordTimeline: (model, recordId) => handlers.queryTimeline(model, recordId),
       getMigrationTemplate: (name) => generateAuditLogsMigration(name || tableName),
     },
 
     register(ctx) {
       const adminPath = adminPathOpt || '/_admin';
       ctx.app.use(createAuditMiddleware({ knex, adminPath, tableName }));
+
+      if (retentionConfig.enabled && autoCleanupEnabled) {
+        startCleanup();
+      }
+
+      return () => {
+        stopCleanup();
+      };
+    },
+
+    dispose() {
+      stopCleanup();
+    },
+
+    shutdown() {
+      stopCleanup();
     },
 
     onRoutesReady(ctx) {
@@ -61,11 +188,12 @@ function auditLogPlugin(options = {}) {
 
       adminApi.registerModule({
         id: 'audit-log',
+        title: pageTitle,
 
         pages: includeDefaultPage
           ? [{
             id: 'audit-log',
-            title: 'Audit log',
+            title: pageTitle,
             path: '/audit-log',
             icon: 'database',
             component: generateAuditLogComponent({ apiPrefix }),
@@ -86,9 +214,31 @@ function auditLogPlugin(options = {}) {
           prefix: apiPrefix,
           routes: [
             { method: 'get', path: '', handler: handlers.listHandler },
+            { method: 'get', path: '/timeline', handler: handlers.timelineHandler },
+            { method: 'get', path: '/timeline/:model/:id', handler: handlers.timelineHandler },
+            { method: 'post', path: '/purge', handler: handlers.purgeHandler },
           ],
         },
       });
+
+      if (registerRecordAction && typeof adminApi.registerAction === 'function') {
+        adminApi.registerAction('audit-timeline', {
+          id: 'audit-timeline',
+          label: 'Zaman Tüneli',
+          icon: 'clock',
+          color: 'blue',
+          models: '*',
+          handler: async (record, model) => {
+            const primaryKey = model?.primaryKey || 'id';
+            const id = record ? record[primaryKey] : null;
+            const modelName = model?.name || (typeof model === 'string' ? model : '');
+            return {
+              redirect: `/audit-log?model=${encodeURIComponent(modelName)}&recordId=${encodeURIComponent(id)}`,
+              message: `Zaman tüneli: ${modelName} #${id}`,
+            };
+          },
+        });
+      }
     },
   };
 }

package/plugins/audit-log/purge.js

@@ -3,24 +3,74 @@
  * @module plugins/audit-log/purge
  */
 
+'use strict';
+
 /**
  * @param {import('knex').Knex} knex
- * @param {Object} options
+ * @param {Object} [options={}]
  * @param {string} [options.tableName='audit_logs']
- * @param {Date|string} options.olderThan - Rows with created_at strictly before this are removed
- * @returns {Promise<number>} Deleted row count (driver-dependent; 0 if unknown)
+ * @param {Date|string|number} [options.olderThan] - Rows with created_at strictly before this are removed
+ * @param {number} [options.days] - Number of days of audit logs to keep
+ * @param {number} [options.retentionDays=90] - Alias for days
+ * @returns {Promise<number>} Deleted row count
  */
-async function purgeAuditLogs(knex, options) {
+async function purgeAuditLogs(knex, options = {}) {
+  if (!knex) {
+    throw new Error('purgeAuditLogs requires a database (knex) instance');
+  }
+
   const tableName = options.tableName || 'audit_logs';
-  const olderThan = options.olderThan instanceof Date
-    ? options.olderThan
-    : new Date(options.olderThan);
 
-  if (Number.isNaN(olderThan.getTime())) {
-    throw new Error('purgeAuditLogs: invalid olderThan date');
+  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('purgeAuditLogs: invalid olderThan date');
+    }
+  } else {
+    const rawDays = options.days !== undefined ? options.days : (options.retentionDays !== undefined ? options.retentionDays : 90);
+    const days = typeof rawDays === 'number' ? rawDays : Number(rawDays);
+    if (Number.isNaN(days) || days <= 0) {
+      throw new Error('purgeAuditLogs: days must be a positive number');
+    }
+    olderThan = new Date(Date.now() - days * 24 * 60 * 60 * 1000);
+  }
+
+  let hasTable = true;
+  if (knex.schema && typeof knex.schema.hasTable === 'function') {
+    try {
+      hasTable = await knex.schema.hasTable(tableName);
+    } catch {
+      hasTable = false;
+    }
+  }
+
+  if (!hasTable) {
+    return 0;
+  }
+
+  const client = knex?.client?.config?.client;
+  const isSqlite = client === 'sqlite3' || client === 'better-sqlite3';
+
+  let query = knex(tableName);
+  if (isSqlite) {
+    const iso = olderThan.toISOString();
+    const cutoffMs = olderThan.getTime();
+    query = query.where((builder) => {
+      builder.whereRaw(
+        "((typeof(created_at) = 'integer' and created_at < ?) or (typeof(created_at) = 'text' and created_at < ?))",
+        [cutoffMs, iso]
+      );
+    });
+  } else {
+    query = query.where('created_at', '<', olderThan);
   }
 
-  return knex(tableName).where('created_at', '<', olderThan).delete();
+  const deleted = await query.delete();
+  return Number(deleted) || 0;
 }
 
 module.exports = {