@intranefr/superbackend 1.7.7 → 1.7.9

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

@@ -0,0 +1,367 @@
+#!/usr/bin/env node
+
+/**
+ * Additional resources: experiments, rate-limits, demo, blog-automation, execution history
+ */
+
+const mongoose = require("mongoose");
+
+const demos = {
+  async execute(options) {
+    const SuperDemo = mongoose.model("SuperDemo");
+    switch (options.command) {
+      case "list": {
+        const demos = await SuperDemo.find().lean();
+        return { items: demos, count: demos.length };
+      }
+      case "get": {
+        if (!options.id) throw new Error("Demo ID is required");
+        const demo = await SuperDemo.findById(options.id).lean();
+        if (!demo) throw new Error("Demo not found");
+        return demo;
+      }
+      case "create": {
+        if (!options.name) throw new Error("--name is required");
+        const demo = await SuperDemo.create({
+          name: options.name,
+          demoId: `demo_${Date.now()}`,
+          projectId: options.description || "default",
+          status: "draft",
+        });
+        return demo;
+      }
+      case "delete": {
+        if (!options.id) throw new Error("Demo ID is required");
+        const demo = await SuperDemo.findByIdAndDelete(options.id);
+        if (!demo) throw new Error("Demo not found");
+        return { success: true, id: options.id };
+      }
+      default:
+        throw new Error(`Unknown demos command: ${options.command}`);
+    }
+  },
+};
+
+const experiments = {
+  async execute(options) {
+    const Experiment = mongoose.model("Experiment");
+    switch (options.command) {
+      case "list": {
+        const experiments = await Experiment.find().lean();
+        return { items: experiments, count: experiments.length };
+      }
+      case "get": {
+        if (!options.id) throw new Error("Experiment ID is required");
+        const experiment = await Experiment.findById(options.id).lean();
+        if (!experiment) throw new Error("Experiment not found");
+        return experiment;
+      }
+      case "create": {
+        if (!options.name) throw new Error("--name is required");
+        const experiment = await Experiment.create({
+          name: options.name,
+          description: options.description || "",
+          status: "draft",
+        });
+        return experiment;
+      }
+      case "delete": {
+        if (!options.id) throw new Error("Experiment ID is required");
+        const experiment = await Experiment.findByIdAndDelete(options.id);
+        if (!experiment) throw new Error("Experiment not found");
+        return { success: true, id: options.id };
+      }
+      default:
+        throw new Error(`Unknown experiments command: ${options.command}`);
+    }
+  },
+};
+
+const experimentAssignments = {
+  async execute(options) {
+    const ExperimentAssignment = mongoose.model("ExperimentAssignment");
+    switch (options.command) {
+      case "list": {
+        const limit = parseInt(options.value) || 50;
+        const assignments = await ExperimentAssignment.find()
+          .sort({ createdAt: -1 })
+          .limit(limit)
+          .lean();
+        return { items: assignments, count: assignments.length };
+      }
+      case "get": {
+        if (!options.id) throw new Error("Assignment ID is required");
+        const assignment = await ExperimentAssignment.findById(
+          options.id,
+        ).lean();
+        if (!assignment) throw new Error("Assignment not found");
+        return assignment;
+      }
+      case "clear": {
+        const result = await ExperimentAssignment.deleteMany({});
+        return { success: true, deletedCount: result.deletedCount };
+      }
+      default:
+        throw new Error(
+          `Unknown experiment-assignments command: ${options.command}`,
+        );
+    }
+  },
+};
+
+const rateLimits = {
+  async execute(options) {
+    const RateLimitCounter = mongoose.model("RateLimitCounter");
+    switch (options.command) {
+      case "list": {
+        const limit = parseInt(options.value) || 50;
+        const counters = await RateLimitCounter.find()
+          .sort({ createdAt: -1 })
+          .limit(limit)
+          .lean();
+        return { items: counters, count: counters.length };
+      }
+      case "get": {
+        if (!options.key) throw new Error("--key (limit key) is required");
+        const counter = await RateLimitCounter.findOne({
+          key: options.key,
+        }).lean();
+        if (!counter) throw new Error("Rate limit counter not found");
+        return counter;
+      }
+      case "delete": {
+        if (!options.key) throw new Error("--key (limit key) is required");
+        const counter = await RateLimitCounter.findOneAndDelete({
+          key: options.key,
+        });
+        if (!counter) throw new Error("Rate limit counter not found");
+        return { success: true, key: options.key };
+      }
+      case "clear": {
+        const result = await RateLimitCounter.deleteMany({});
+        return { success: true, deletedCount: result.deletedCount };
+      }
+      default:
+        throw new Error(`Unknown rate-limits command: ${options.command}`);
+    }
+  },
+};
+
+const demoProjects = {
+  async execute(options) {
+    const SuperDemoProject = mongoose.model("SuperDemoProject");
+    switch (options.command) {
+      case "list": {
+        const projects = await SuperDemoProject.find().lean();
+        return { items: projects, count: projects.length };
+      }
+      case "get": {
+        if (!options.id) throw new Error("Demo project ID is required");
+        const project = await SuperDemoProject.findById(options.id).lean();
+        if (!project) throw new Error("Demo project not found");
+        return project;
+      }
+      case "create": {
+        if (!options.name) throw new Error("--name is required");
+        const project = await SuperDemoProject.create({
+          name: options.name,
+          description: options.description || "",
+        });
+        return project;
+      }
+      case "delete": {
+        if (!options.id) throw new Error("Demo project ID is required");
+        const project = await SuperDemoProject.findByIdAndDelete(options.id);
+        if (!project) throw new Error("Demo project not found");
+        return { success: true, id: options.id };
+      }
+      default:
+        throw new Error(`Unknown demo-projects command: ${options.command}`);
+    }
+  },
+};
+
+const demoSteps = {
+  async execute(options) {
+    const SuperDemoStep = mongoose.model("SuperDemoStep");
+    switch (options.command) {
+      case "list": {
+        const limit = parseInt(options.value) || 50;
+        const steps = await SuperDemoStep.find()
+          .sort({ createdAt: -1 })
+          .limit(limit)
+          .lean();
+        return { items: steps, count: steps.length };
+      }
+      case "get": {
+        if (!options.id) throw new Error("Demo step ID is required");
+        const step = await SuperDemoStep.findById(options.id).lean();
+        if (!step) throw new Error("Demo step not found");
+        return step;
+      }
+      case "delete": {
+        if (!options.id) throw new Error("Demo step ID is required");
+        const step = await SuperDemoStep.findByIdAndDelete(options.id);
+        if (!step) throw new Error("Demo step not found");
+        return { success: true, id: options.id };
+      }
+      case "clear": {
+        const result = await SuperDemoStep.deleteMany({});
+        return { success: true, deletedCount: result.deletedCount };
+      }
+      default:
+        throw new Error(`Unknown demo-steps command: ${options.command}`);
+    }
+  },
+};
+
+const blogAutomationLocks = {
+  async execute(options) {
+    const BlogAutomationLock = mongoose.model("BlogAutomationLock");
+    switch (options.command) {
+      case "list": {
+        const locks = await BlogAutomationLock.find().lean();
+        return { items: locks, count: locks.length };
+      }
+      case "clear": {
+        const result = await BlogAutomationLock.deleteMany({});
+        return { success: true, deletedCount: result.deletedCount };
+      }
+      default:
+        throw new Error(
+          `Unknown blog-automation-locks command: ${options.command}`,
+        );
+    }
+  },
+};
+
+const blogAutomationRuns = {
+  async execute(options) {
+    const BlogAutomationRun = mongoose.model("BlogAutomationRun");
+    switch (options.command) {
+      case "list": {
+        const limit = parseInt(options.value) || 50;
+        const runs = await BlogAutomationRun.find()
+          .sort({ createdAt: -1 })
+          .limit(limit)
+          .lean();
+        return { items: runs, count: runs.length };
+      }
+      case "get": {
+        if (!options.id) throw new Error("Automation run ID is required");
+        const run = await BlogAutomationRun.findById(options.id).lean();
+        if (!run) throw new Error("Automation run not found");
+        return run;
+      }
+      case "clear": {
+        const result = await BlogAutomationRun.deleteMany({});
+        return { success: true, deletedCount: result.deletedCount };
+      }
+      default:
+        throw new Error(
+          `Unknown blog-automation-runs command: ${options.command}`,
+        );
+    }
+  },
+};
+
+const cronExecutions = {
+  async execute(options) {
+    const CronExecution = mongoose.model("CronExecution");
+    switch (options.command) {
+      case "list": {
+        const limit = parseInt(options.value) || 50;
+        const executions = await CronExecution.find()
+          .sort({ createdAt: -1 })
+          .limit(limit)
+          .lean();
+        return { items: executions, count: executions.length };
+      }
+      case "clear": {
+        const days = parseInt(options.value) || 7;
+        const cutoffDate = new Date(Date.now() - days * 24 * 60 * 60 * 1000);
+        const result = await CronExecution.deleteMany({
+          createdAt: { $lt: cutoffDate },
+        });
+        return {
+          success: true,
+          deletedCount: result.deletedCount,
+          olderThan: cutoffDate.toISOString(),
+        };
+      }
+      default:
+        throw new Error(`Unknown cron-executions command: ${options.command}`);
+    }
+  },
+};
+
+const workflowExecutions = {
+  async execute(options) {
+    const WorkflowExecution = mongoose.model("WorkflowExecution");
+    switch (options.command) {
+      case "list": {
+        const limit = parseInt(options.value) || 50;
+        const executions = await WorkflowExecution.find()
+          .sort({ createdAt: -1 })
+          .limit(limit)
+          .lean();
+        return { items: executions, count: executions.length };
+      }
+      case "get": {
+        if (!options.id) throw new Error("Workflow execution ID is required");
+        const execution = await WorkflowExecution.findById(options.id).lean();
+        if (!execution) throw new Error("Workflow execution not found");
+        return execution;
+      }
+      case "clear": {
+        const result = await WorkflowExecution.deleteMany({});
+        return { success: true, deletedCount: result.deletedCount };
+      }
+      default:
+        throw new Error(
+          `Unknown workflow-executions command: ${options.command}`,
+        );
+    }
+  },
+};
+
+const scriptRuns = {
+  async execute(options) {
+    const ScriptRun = mongoose.model("ScriptRun");
+    switch (options.command) {
+      case "list": {
+        const limit = parseInt(options.value) || 50;
+        const runs = await ScriptRun.find()
+          .sort({ createdAt: -1 })
+          .limit(limit)
+          .lean();
+        return { items: runs, count: runs.length };
+      }
+      case "get": {
+        if (!options.id) throw new Error("Script run ID is required");
+        const run = await ScriptRun.findById(options.id).lean();
+        if (!run) throw new Error("Script run not found");
+        return run;
+      }
+      case "clear": {
+        const result = await ScriptRun.deleteMany({});
+        return { success: true, deletedCount: result.deletedCount };
+      }
+      default:
+        throw new Error(`Unknown script-runs command: ${options.command}`);
+    }
+  },
+};
+
+module.exports = {
+  experiments,
+  experimentAssignments,
+  rateLimits,
+  demoProjects,
+  demoSteps,
+  blogAutomationLocks,
+  blogAutomationRuns,
+  cronExecutions,
+  workflowExecutions,
+  scriptRuns,
+};

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

@@ -0,0 +1,152 @@
+#!/usr/bin/env node
+
+/**
+ * Health & Metrics: health-incidents, health-attempts, error-aggregates, metric-buckets
+ */
+
+const mongoose = require("mongoose");
+
+const healthIncidents = {
+  async execute(options) {
+    const HealthIncident = mongoose.model("HealthIncident");
+    switch (options.command) {
+      case "list": {
+        const incidents = await HealthIncident.find()
+          .sort({ createdAt: -1 })
+          .lean();
+        return { items: incidents, count: incidents.length };
+      }
+      case "clear": {
+        const result = await HealthIncident.deleteMany({});
+        return { success: true, deletedCount: result.deletedCount };
+      }
+      default:
+        throw new Error(`Unknown health-incidents command: ${options.command}`);
+    }
+  },
+};
+
+const healthAttempts = {
+  async execute(options) {
+    const HealthAutoHealAttempt = mongoose.model("HealthAutoHealAttempt");
+    switch (options.command) {
+      case "list": {
+        const attempts = await HealthAutoHealAttempt.find()
+          .sort({ createdAt: -1 })
+          .lean();
+        return { items: attempts, count: attempts.length };
+      }
+      case "clear": {
+        const result = await HealthAutoHealAttempt.deleteMany({});
+        return { success: true, deletedCount: result.deletedCount };
+      }
+      default:
+        throw new Error(`Unknown health-attempts command: ${options.command}`);
+    }
+  },
+};
+
+const errorAggregates = {
+  async execute(options) {
+    const ErrorAggregate = mongoose.model("ErrorAggregate");
+    switch (options.command) {
+      case "list": {
+        const aggregates = await ErrorAggregate.find()
+          .sort({ count: -1 })
+          .lean();
+        return { items: aggregates, count: aggregates.length };
+      }
+      case "clear": {
+        const result = await ErrorAggregate.deleteMany({});
+        return { success: true, deletedCount: result.deletedCount };
+      }
+      default:
+        throw new Error(`Unknown error-aggregates command: ${options.command}`);
+    }
+  },
+};
+
+const metricBuckets = {
+  async execute(options) {
+    const RateLimitMetricBucket = mongoose.model("RateLimitMetricBucket");
+    switch (options.command) {
+      case "list": {
+        const limit = parseInt(options.value) || 50;
+        const buckets = await RateLimitMetricBucket.find()
+          .sort({ createdAt: -1 })
+          .limit(limit)
+          .lean();
+        return { items: buckets, count: buckets.length };
+      }
+      case "clear": {
+        const result = await RateLimitMetricBucket.deleteMany({});
+        return { success: true, deletedCount: result.deletedCount };
+      }
+      default:
+        throw new Error(`Unknown metric-buckets command: ${options.command}`);
+    }
+  },
+};
+
+const virtualEjsFiles = {
+  async execute(options) {
+    const VirtualEjsFile = mongoose.model("VirtualEjsFile");
+    switch (options.command) {
+      case "list": {
+        const files = await VirtualEjsFile.find().lean();
+        return { items: files, count: files.length };
+      }
+      case "get": {
+        if (!options.id) throw new Error("Virtual file ID is required");
+        const file = await VirtualEjsFile.findById(options.id).lean();
+        if (!file) throw new Error("Virtual file not found");
+        return file;
+      }
+      case "delete": {
+        if (!options.id) throw new Error("Virtual file ID is required");
+        const file = await VirtualEjsFile.findByIdAndDelete(options.id);
+        if (!file) throw new Error("Virtual file not found");
+        return { success: true, id: options.id };
+      }
+      case "clear": {
+        const result = await VirtualEjsFile.deleteMany({});
+        return { success: true, deletedCount: result.deletedCount };
+      }
+      default:
+        throw new Error(
+          `Unknown virtual-ejs-files command: ${options.command}`,
+        );
+    }
+  },
+};
+
+const virtualEjsGroups = {
+  async execute(options) {
+    const VirtualEjsGroup = mongoose.model("VirtualEjsGroup");
+    switch (options.command) {
+      case "list": {
+        const groups = await VirtualEjsGroup.find().lean();
+        return { items: groups, count: groups.length };
+      }
+      case "delete": {
+        if (!options.id) throw new Error("Virtual group ID is required");
+        const group = await VirtualEjsGroup.findByIdAndDelete(options.id);
+        if (!group) throw new Error("Virtual group not found");
+        return { success: true, id: options.id };
+      }
+      default:
+        throw new Error(
+          `Unknown virtual-ejs-groups command: ${options.command}`,
+        );
+    }
+  },
+};
+
+module.exports = {
+  healthIncidents,
+  healthAttempts,
+  errorAggregates,
+  metricBuckets,
+  virtualEjsFiles,
+  virtualEjsGroups,
+};

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

@@ -0,0 +1,182 @@
+#!/usr/bin/env node
+
+/**
+ * Integration resources: telegram, webhooks, stripe-items, stripe-events, external-dbs
+ */
+
+const mongoose = require('mongoose');
+
+const telegram = {
+  async execute(options) {
+    const TelegramBot = mongoose.model('TelegramBot');
+    switch (options.command) {
+      case 'list': {
+        const bots = await TelegramBot.find().lean();
+        return { items: bots, count: bots.length };
+      }
+      case 'get': {
+        if (!options.id) throw new Error('Bot ID is required');
+        const bot = await TelegramBot.findById(options.id).lean();
+        if (!bot) throw new Error('Bot not found');
+        return bot;
+      }
+      case 'create': {
+        if (!options.name) throw new Error('--name is required');
+        if (!options.key) throw new Error('--key (bot token) is required');
+        const bot = await TelegramBot.create({ name: options.name, token: options.key, enabled: true });
+        return bot;
+      }
+      case 'delete': {
+        if (!options.id) throw new Error('Bot ID is required');
+        const bot = await TelegramBot.findByIdAndDelete(options.id);
+        if (!bot) throw new Error('Bot not found');
+        return { success: true, id: options.id };
+      }
+      case 'enable': {
+        if (!options.id) throw new Error('Bot ID is required');
+        const bot = await TelegramBot.findByIdAndUpdate(options.id, { enabled: true }, { new: true });
+        if (!bot) throw new Error('Bot not found');
+        return bot;
+      }
+      case 'disable': {
+        if (!options.id) throw new Error('Bot ID is required');
+        const bot = await TelegramBot.findByIdAndUpdate(options.id, { enabled: false }, { new: true });
+        if (!bot) throw new Error('Bot not found');
+        return bot;
+      }
+      default:
+        throw new Error(`Unknown telegram command: ${options.command}`);
+    }
+  },
+};
+
+const webhooks = {
+  async execute(options) {
+    const Webhook = mongoose.model('Webhook');
+    switch (options.command) {
+      case 'list': {
+        const webhooks = await Webhook.find().lean();
+        return { items: webhooks, count: webhooks.length };
+      }
+      case 'get': {
+        if (!options.id) throw new Error('Webhook ID is required');
+        const webhook = await Webhook.findById(options.id).lean();
+        if (!webhook) throw new Error('Webhook not found');
+        return webhook;
+      }
+      case 'create': {
+        if (!options.name) throw new Error('--name is required');
+        if (!options.key) throw new Error('--key (URL) is required');
+        const webhook = await Webhook.create({ name: options.name, url: options.key, enabled: true });
+        return webhook;
+      }
+      case 'delete': {
+        if (!options.id) throw new Error('Webhook ID is required');
+        const webhook = await Webhook.findByIdAndDelete(options.id);
+        if (!webhook) throw new Error('Webhook not found');
+        return { success: true, id: options.id };
+      }
+      case 'enable': {
+        if (!options.id) throw new Error('Webhook ID is required');
+        const webhook = await Webhook.findByIdAndUpdate(options.id, { enabled: true }, { new: true });
+        if (!webhook) throw new Error('Webhook not found');
+        return webhook;
+      }
+      case 'disable': {
+        if (!options.id) throw new Error('Webhook ID is required');
+        const webhook = await Webhook.findByIdAndUpdate(options.id, { enabled: false }, { new: true });
+        if (!webhook) throw new Error('Webhook not found');
+        return webhook;
+      }
+      default:
+        throw new Error(`Unknown webhooks command: ${options.command}`);
+    }
+  },
+};
+
+const stripeItems = {
+  async execute(options) {
+    const StripeCatalogItem = mongoose.model('StripeCatalogItem');
+    switch (options.command) {
+      case 'list': {
+        const items = await StripeCatalogItem.find().lean();
+        return { items, count: items.length };
+      }
+      case 'get': {
+        if (!options.id) throw new Error('Stripe item ID is required');
+        const item = await StripeCatalogItem.findById(options.id).lean();
+        if (!item) throw new Error('Stripe item not found');
+        return item;
+      }
+      case 'clear': {
+        const result = await StripeCatalogItem.deleteMany({});
+        return { success: true, deletedCount: result.deletedCount };
+      }
+      default:
+        throw new Error(`Unknown stripe-items command: ${options.command}`);
+    }
+  },
+};
+
+const stripeEvents = {
+  async execute(options) {
+    const StripeWebhookEvent = mongoose.model('StripeWebhookEvent');
+    switch (options.command) {
+      case 'list': {
+        const limit = parseInt(options.value) || 50;
+        const events = await StripeWebhookEvent.find().sort({ createdAt: -1 }).limit(limit).lean();
+        return { items: events, count: events.length };
+      }
+      case 'get': {
+        if (!options.id) throw new Error('Stripe event ID is required');
+        const event = await StripeWebhookEvent.findById(options.id).lean();
+        if (!event) throw new Error('Stripe event not found');
+        return event;
+      }
+      case 'clear': {
+        const result = await StripeWebhookEvent.deleteMany({});
+        return { success: true, deletedCount: result.deletedCount };
+      }
+      default:
+        throw new Error(`Unknown stripe-events command: ${options.command}`);
+    }
+  },
+};
+
+const externalDbs = {
+  async execute(options) {
+    const ExternalDbConnection = mongoose.model('ExternalDbConnection');
+    switch (options.command) {
+      case 'list': {
+        const connections = await ExternalDbConnection.find().lean();
+        return { items: connections, count: connections.length };
+      }
+      case 'get': {
+        if (!options.id) throw new Error('External DB connection ID is required');
+        const connection = await ExternalDbConnection.findById(options.id).lean();
+        if (!connection) throw new Error('External DB connection not found');
+        return connection;
+      }
+      case 'create': {
+        if (!options.name) throw new Error('--name is required');
+        if (!options.key) throw new Error('--key (connection string) is required');
+        const connection = await ExternalDbConnection.create({
+          name: options.name,
+          connectionString: options.key,
+          type: options.description || 'mongodb',
+        });
+        return connection;
+      }
+      case 'delete': {
+        if (!options.id) throw new Error('External DB connection ID is required');
+        const connection = await ExternalDbConnection.findByIdAndDelete(options.id);
+        if (!connection) throw new Error('External DB connection not found');
+        return { success: true, id: options.id };
+      }
+      default:
+        throw new Error(`Unknown external-dbs command: ${options.command}`);
+    }
+  },
+};
+
+module.exports = { telegram, webhooks, stripeItems, stripeEvents, externalDbs };