@intranefr/superbackend 1.6.7 → 1.7.8

package/src/cli/direct/resources-logs.js

@@ -0,0 +1,204 @@
+#!/usr/bin/env node
+
+/**
+ * Log resources: notifications, cache, audit-logs, console-logs, activity-logs, email-logs
+ */
+
+const mongoose = require('mongoose');
+
+const notifications = {
+  async execute(options) {
+    const Notification = mongoose.model('Notification');
+    switch (options.command) {
+      case 'list': {
+        const limit = parseInt(options.value) || 50;
+        const notifications = await Notification.find().sort({ createdAt: -1 }).limit(limit).lean();
+        return { items: notifications, count: notifications.length };
+      }
+      case 'get': {
+        if (!options.id) throw new Error('Notification ID is required');
+        const notification = await Notification.findById(options.id).lean();
+        if (!notification) throw new Error('Notification not found');
+        return notification;
+      }
+      case 'delete': {
+        if (!options.id) throw new Error('Notification ID is required');
+        const notification = await Notification.findByIdAndDelete(options.id);
+        if (!notification) throw new Error('Notification not found');
+        return { success: true, id: options.id };
+      }
+      case 'clear': {
+        await Notification.deleteMany({});
+        return { success: true, message: 'All notifications cleared' };
+      }
+      default:
+        throw new Error(`Unknown notifications command: ${options.command}`);
+    }
+  },
+};
+
+const cache = {
+  async execute(options) {
+    const CacheEntry = mongoose.model('CacheEntry');
+    switch (options.command) {
+      case 'list': {
+        const limit = parseInt(options.value) || 50;
+        const entries = await CacheEntry.find().sort({ createdAt: -1 }).limit(limit).lean();
+        return { items: entries, count: entries.length };
+      }
+      case 'get': {
+        if (!options.key) throw new Error('--key is required');
+        const entry = await CacheEntry.findOne({ key: options.key }).lean();
+        if (!entry) throw new Error('Cache entry not found');
+        return entry;
+      }
+      case 'delete': {
+        if (!options.key) throw new Error('--key is required');
+        const entry = await CacheEntry.findOneAndDelete({ key: options.key });
+        if (!entry) throw new Error('Cache entry not found');
+        return { success: true, key: options.key };
+      }
+      case 'clear': {
+        const result = await CacheEntry.deleteMany({});
+        return { success: true, deletedCount: result.deletedCount };
+      }
+      default:
+        throw new Error(`Unknown cache command: ${options.command}`);
+    }
+  },
+};
+
+const auditLogs = {
+  async execute(options) {
+    const AuditEvent = mongoose.model('AuditEvent');
+    switch (options.command) {
+      case 'list': {
+        const limit = parseInt(options.value) || 50;
+        const events = await AuditEvent.find().sort({ createdAt: -1 }).limit(limit).lean();
+        return { items: events, count: events.length };
+      }
+      case 'get': {
+        if (!options.id) throw new Error('Audit event ID is required');
+        const event = await AuditEvent.findById(options.id).lean();
+        if (!event) throw new Error('Audit event not found');
+        return event;
+      }
+      case 'clear': {
+        const days = parseInt(options.value) || 90;
+        const cutoffDate = new Date(Date.now() - days * 24 * 60 * 60 * 1000);
+        const result = await AuditEvent.deleteMany({ createdAt: { $lt: cutoffDate } });
+        return { success: true, deletedCount: result.deletedCount, olderThan: cutoffDate.toISOString() };
+      }
+      default:
+        throw new Error(`Unknown audit-logs command: ${options.command}`);
+    }
+  },
+};
+
+const consoleLogs = {
+  async execute(options) {
+    const ConsoleLog = mongoose.model('ConsoleLog');
+    switch (options.command) {
+      case 'list': {
+        const limit = parseInt(options.value) || 50;
+        const logs = await ConsoleLog.find().sort({ createdAt: -1 }).limit(limit).lean();
+        return { items: logs, count: logs.length };
+      }
+      case 'get': {
+        if (!options.id) throw new Error('Log ID is required');
+        const log = await ConsoleLog.findById(options.id).lean();
+        if (!log) throw new Error('Log not found');
+        return log;
+      }
+      case 'clear': {
+        const days = parseInt(options.value) || 7;
+        const cutoffDate = new Date(Date.now() - days * 24 * 60 * 60 * 1000);
+        const result = await ConsoleLog.deleteMany({ createdAt: { $lt: cutoffDate } });
+        return { success: true, deletedCount: result.deletedCount, olderThan: cutoffDate.toISOString() };
+      }
+      default:
+        throw new Error(`Unknown console-logs command: ${options.command}`);
+    }
+  },
+};
+
+const activityLogs = {
+  async execute(options) {
+    const ActivityLog = mongoose.model('ActivityLog');
+    switch (options.command) {
+      case 'list': {
+        const limit = parseInt(options.value) || 50;
+        const logs = await ActivityLog.find().sort({ createdAt: -1 }).limit(limit).lean();
+        return { items: logs, count: logs.length };
+      }
+      case 'get': {
+        if (!options.id) throw new Error('Activity log ID is required');
+        const log = await ActivityLog.findById(options.id).lean();
+        if (!log) throw new Error('Activity log not found');
+        return log;
+      }
+      case 'clear': {
+        const days = parseInt(options.value) || 30;
+        const cutoffDate = new Date(Date.now() - days * 24 * 60 * 60 * 1000);
+        const result = await ActivityLog.deleteMany({ createdAt: { $lt: cutoffDate } });
+        return { success: true, deletedCount: result.deletedCount, olderThan: cutoffDate.toISOString() };
+      }
+      default:
+        throw new Error(`Unknown activity-logs command: ${options.command}`);
+    }
+  },
+};
+
+const emailLogs = {
+  async execute(options) {
+    const EmailLog = mongoose.model('EmailLog');
+    switch (options.command) {
+      case 'list': {
+        const limit = parseInt(options.value) || 50;
+        const logs = await EmailLog.find().sort({ createdAt: -1 }).limit(limit).lean();
+        return { items: logs, count: logs.length };
+      }
+      case 'get': {
+        if (!options.id) throw new Error('Email log ID is required');
+        const log = await EmailLog.findById(options.id).lean();
+        if (!log) throw new Error('Email log not found');
+        return log;
+      }
+      case 'clear': {
+        const days = parseInt(options.value) || 30;
+        const cutoffDate = new Date(Date.now() - days * 24 * 60 * 60 * 1000);
+        const result = await EmailLog.deleteMany({ createdAt: { $lt: cutoffDate } });
+        return { success: true, deletedCount: result.deletedCount, olderThan: cutoffDate.toISOString() };
+      }
+      default:
+        throw new Error(`Unknown email-logs command: ${options.command}`);
+    }
+  },
+};
+
+const waitingList = {
+  async execute(options) {
+    const WaitingList = mongoose.model('WaitingList');
+    switch (options.command) {
+      case 'list': {
+        const limit = parseInt(options.value) || 50;
+        const entries = await WaitingList.find().sort({ createdAt: -1 }).limit(limit).lean();
+        return { items: entries, count: entries.length };
+      }
+      case 'delete': {
+        if (!options.id) throw new Error('Waiting list entry ID is required');
+        const entry = await WaitingList.findByIdAndDelete(options.id);
+        if (!entry) throw new Error('Waiting list entry not found');
+        return { success: true, id: options.id };
+      }
+      case 'clear': {
+        await WaitingList.deleteMany({});
+        return { success: true, message: 'All waiting list entries cleared' };
+      }
+      default:
+        throw new Error(`Unknown waiting-list command: ${options.command}`);
+    }
+  },
+};
+
+module.exports = { notifications, cache, auditLogs, consoleLogs, activityLogs, emailLogs, waitingList };

package/src/cli/direct/resources-org-rbac.js

@@ -0,0 +1,187 @@
+#!/usr/bin/env node
+
+/**
+ * Organization & RBAC handlers: orgs, rbac-roles, rbac-groups, invites, org-members
+ */
+
+const mongoose = require("mongoose");
+
+const orgs = {
+  async execute(options) {
+    const Organization = mongoose.model("Organization");
+    switch (options.command) {
+      case "list": {
+        const orgs = await Organization.find().lean();
+        return { items: orgs, count: orgs.length };
+      }
+      case "get": {
+        if (!options.id) throw new Error("Org ID is required");
+        const org = await Organization.findById(options.id).lean();
+        if (!org) throw new Error("Org not found");
+        return org;
+      }
+      case "create": {
+        if (!options.name) throw new Error("--name is required");
+        const org = await Organization.create({
+          name: options.name,
+          description: options.description || "",
+        });
+        return org;
+      }
+      case "update": {
+        if (!options.id) throw new Error("Org ID is required");
+        const updateData = {};
+        if (options.name) updateData.name = options.name;
+        if (options.description) updateData.description = options.description;
+        const org = await Org.findByIdAndUpdate(options.id, updateData, {
+          new: true,
+        });
+        if (!org) throw new Error("Org not found");
+        return org;
+      }
+      case "delete": {
+        if (!options.id) throw new Error("Org ID is required");
+        const org = await Org.findByIdAndDelete(options.id);
+        if (!org) throw new Error("Org not found");
+        return { success: true, id: options.id };
+      }
+      default:
+        throw new Error(`Unknown orgs command: ${options.command}`);
+    }
+  },
+};
+
+const rbacRoles = {
+  async execute(options) {
+    const RbacRole = mongoose.model("RbacRole");
+    switch (options.command) {
+      case "list": {
+        const roles = await RbacRole.find().lean();
+        return { items: roles, count: roles.length };
+      }
+      case "get": {
+        if (!options.id) throw new Error("Role ID is required");
+        const role = await RbacRole.findById(options.id).lean();
+        if (!role) throw new Error("Role not found");
+        return role;
+      }
+      case "create": {
+        if (!options.name) throw new Error("--name is required");
+        const role = await RbacRole.create({
+          name: options.name,
+          description: options.description || "",
+        });
+        return role;
+      }
+      case "delete": {
+        if (!options.id) throw new Error("Role ID is required");
+        const role = await RbacRole.findByIdAndDelete(options.id);
+        if (!role) throw new Error("Role not found");
+        return { success: true, id: options.id };
+      }
+      default:
+        throw new Error(`Unknown rbac-roles command: ${options.command}`);
+    }
+  },
+};
+
+const rbacGroups = {
+  async execute(options) {
+    const RbacGroup = mongoose.model("RbacGroup");
+    switch (options.command) {
+      case "list": {
+        const groups = await RbacGroup.find().lean();
+        return { items: groups, count: groups.length };
+      }
+      case "get": {
+        if (!options.id) throw new Error("Group ID is required");
+        const group = await RbacGroup.findById(options.id).lean();
+        if (!group) throw new Error("Group not found");
+        return group;
+      }
+      case "create": {
+        if (!options.name) throw new Error("--name is required");
+        const group = await RbacGroup.create({
+          name: options.name,
+          description: options.description || "",
+        });
+        return group;
+      }
+      case "delete": {
+        if (!options.id) throw new Error("Group ID is required");
+        const group = await RbacGroup.findByIdAndDelete(options.id);
+        if (!group) throw new Error("Group not found");
+        return { success: true, id: options.id };
+      }
+      default:
+        throw new Error(`Unknown rbac-groups command: ${options.command}`);
+    }
+  },
+};
+
+const invites = {
+  async execute(options) {
+    const Invite = mongoose.model("Invite");
+    switch (options.command) {
+      case "list": {
+        const limit = parseInt(options.value) || 50;
+        const invites = await Invite.find()
+          .sort({ createdAt: -1 })
+          .limit(limit)
+          .lean();
+        return { items: invites, count: invites.length };
+      }
+      case "get": {
+        if (!options.id) throw new Error("Invite ID is required");
+        const invite = await Invite.findById(options.id).lean();
+        if (!invite) throw new Error("Invite not found");
+        return invite;
+      }
+      case "create": {
+        if (!options.email) throw new Error("--email is required");
+        const invite = await Invite.create({
+          email: options.email,
+          role: options.role || "user",
+          expiresAt: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000),
+        });
+        return invite;
+      }
+      case "delete": {
+        if (!options.id) throw new Error("Invite ID is required");
+        const invite = await Invite.findByIdAndDelete(options.id);
+        if (!invite) throw new Error("Invite not found");
+        return { success: true, id: options.id };
+      }
+      case "clear": {
+        await Invite.deleteMany({ used: true });
+        return { success: true, message: "Cleared used invites" };
+      }
+      default:
+        throw new Error(`Unknown invites command: ${options.command}`);
+    }
+  },
+};
+
+const orgMembers = {
+  async execute(options) {
+    const OrganizationMember = mongoose.model("OrganizationMember");
+    switch (options.command) {
+      case "list": {
+        const members = await OrganizationMember.find()
+          .populate("userId")
+          .lean();
+        return { items: members, count: members.length };
+      }
+      case "delete": {
+        if (!options.id) throw new Error("Member ID is required");
+        const member = await OrganizationMember.findByIdAndDelete(options.id);
+        if (!member) throw new Error("Member not found");
+        return { success: true, id: options.id };
+      }
+      default:
+        throw new Error(`Unknown org-members command: ${options.command}`);
+    }
+  },
+};
+
+module.exports = { orgs, rbacRoles, rbacGroups, invites, orgMembers };

package/src/cli/direct/resources-system.js

@@ -0,0 +1,236 @@
+#!/usr/bin/env node
+
+/**
+ * System resources: crons, errors, scripts, workflows, health-checks
+ */
+
+const mongoose = require("mongoose");
+
+const crons = {
+  async execute(options) {
+    const CronJob = mongoose.model("CronJob");
+    switch (options.command) {
+      case "list": {
+        const crons = await CronJob.find().lean();
+        return { items: crons, count: crons.length };
+      }
+      case "get": {
+        if (!options.id) throw new Error("Cron ID is required");
+        const cron = await CronJob.findById(options.id).lean();
+        if (!cron) throw new Error("Cron not found");
+        return cron;
+      }
+      case "create": {
+        if (!options.name) throw new Error("--name is required");
+        if (!options.description)
+          throw new Error("--description (cron expression) is required");
+        const cron = await CronJob.create({
+          name: options.name,
+          description: options.description,
+          enabled: true,
+        });
+        return cron;
+      }
+      case "delete": {
+        if (!options.id) throw new Error("Cron ID is required");
+        const cron = await CronJob.findByIdAndDelete(options.id);
+        if (!cron) throw new Error("Cron not found");
+        return { success: true, id: options.id };
+      }
+      case "enable": {
+        if (!options.id) throw new Error("Cron ID is required");
+        const cron = await CronJob.findByIdAndUpdate(
+          options.id,
+          { enabled: true },
+          { new: true },
+        );
+        if (!cron) throw new Error("Cron not found");
+        return cron;
+      }
+      case "disable": {
+        if (!options.id) throw new Error("Cron ID is required");
+        const cron = await CronJob.findByIdAndUpdate(
+          options.id,
+          { enabled: false },
+          { new: true },
+        );
+        if (!cron) throw new Error("Cron not found");
+        return cron;
+      }
+      default:
+        throw new Error(`Unknown crons command: ${options.command}`);
+    }
+  },
+};
+
+const errors = {
+  async execute(options) {
+    const ErrorAggregate = mongoose.model("ErrorAggregate");
+    switch (options.command) {
+      case "list": {
+        const limit = parseInt(options.value) || 50;
+        const errors = await ErrorAggregate.find()
+          .sort({ count: -1 })
+          .limit(limit)
+          .lean();
+        return { items: errors, count: errors.length };
+      }
+      case "get": {
+        if (!options.id) throw new Error("Error ID is required");
+        const error = await ErrorAggregate.findById(options.id).lean();
+        if (!error) throw new Error("Error not found");
+        return error;
+      }
+      case "delete": {
+        if (!options.id) throw new Error("Error ID is required");
+        const error = await ErrorAggregate.findByIdAndDelete(options.id);
+        if (!error) throw new Error("Error not found");
+        return { success: true, id: options.id };
+      }
+      case "clear": {
+        await ErrorAggregate.deleteMany({});
+        return { success: true, message: "All errors cleared" };
+      }
+      default:
+        throw new Error(`Unknown errors command: ${options.command}`);
+    }
+  },
+};
+
+const scripts = {
+  async execute(options) {
+    const ScriptDefinition = mongoose.model("ScriptDefinition");
+    switch (options.command) {
+      case "list": {
+        const scripts = await ScriptDefinition.find().lean();
+        return { items: scripts, count: scripts.length };
+      }
+      case "get": {
+        if (!options.id) throw new Error("Script ID is required");
+        const script = await ScriptDefinition.findById(options.id).lean();
+        if (!script) throw new Error("Script not found");
+        return script;
+      }
+      case "create": {
+        if (!options.name) throw new Error("--name is required");
+        if (!options.description)
+          throw new Error("--description (script code) is required");
+        const script = await ScriptDefinition.create({
+          name: options.name,
+          description: options.description,
+          enabled: true,
+        });
+        return script;
+      }
+      case "delete": {
+        if (!options.id) throw new Error("Script ID is required");
+        const script = await ScriptDefinition.findByIdAndDelete(options.id);
+        if (!script) throw new Error("Script not found");
+        return { success: true, id: options.id };
+      }
+      default:
+        throw new Error(`Unknown scripts command: ${options.command}`);
+    }
+  },
+};
+
+const workflows = {
+  async execute(options) {
+    const Workflow = mongoose.model("Workflow");
+    switch (options.command) {
+      case "list": {
+        const workflows = await Workflow.find().lean();
+        return { items: workflows, count: workflows.length };
+      }
+      case "get": {
+        if (!options.id) throw new Error("Workflow ID is required");
+        const workflow = await Workflow.findById(options.id).lean();
+        if (!workflow) throw new Error("Workflow not found");
+        return workflow;
+      }
+      case "create": {
+        if (!options.name) throw new Error("--name is required");
+        const workflow = await Workflow.create({
+          name: options.name,
+          description: options.description || "",
+          enabled: true,
+        });
+        return workflow;
+      }
+      case "delete": {
+        if (!options.id) throw new Error("Workflow ID is required");
+        const workflow = await Workflow.findByIdAndDelete(options.id);
+        if (!workflow) throw new Error("Workflow not found");
+        return { success: true, id: options.id };
+      }
+      case "enable": {
+        if (!options.id) throw new Error("Workflow ID is required");
+        const workflow = await Workflow.findByIdAndUpdate(
+          options.id,
+          { enabled: true },
+          { new: true },
+        );
+        if (!workflow) throw new Error("Workflow not found");
+        return workflow;
+      }
+      case "disable": {
+        if (!options.id) throw new Error("Workflow ID is required");
+        const workflow = await Workflow.findByIdAndUpdate(
+          options.id,
+          { enabled: false },
+          { new: true },
+        );
+        if (!workflow) throw new Error("Workflow not found");
+        return workflow;
+      }
+      default:
+        throw new Error(`Unknown workflows command: ${options.command}`);
+    }
+  },
+};
+
+const healthChecks = {
+  async execute(options) {
+    const HealthCheck = mongoose.model("HealthCheck");
+    switch (options.command) {
+      case "list": {
+        const checks = await HealthCheck.find().lean();
+        return { items: checks, count: checks.length };
+      }
+      case "get": {
+        if (!options.id) throw new Error("Health check ID is required");
+        const check = await HealthCheck.findById(options.id).lean();
+        if (!check) throw new Error("Health check not found");
+        return check;
+      }
+      case "create": {
+        if (!options.name) throw new Error("--name is required");
+        if (!options.value)
+          throw new Error("--value (cron expression) is required");
+        if (!options.key)
+          throw new Error(
+            "--key (checkType: http/script/internal) is required",
+          );
+        const check = await HealthCheck.create({
+          name: options.name,
+          description: options.description || "",
+          cronExpression: options.value,
+          checkType: options.key,
+          createdBy: "cli",
+          enabled: true,
+        });
+        return check;
+      }
+      case "delete": {
+        if (!options.id) throw new Error("Health check ID is required");
+        const check = await HealthCheck.findByIdAndDelete(options.id);
+        if (!check) throw new Error("Health check not found");
+        return { success: true, id: options.id };
+      }
+      default:
+        throw new Error(`Unknown health-checks command: ${options.command}`);
+    }
+  },
+};
+
+module.exports = { crons, errors, scripts, workflows, healthChecks };