@intranefr/superbackend 1.7.7 → 1.7.9

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

@@ -0,0 +1,247 @@
+#!/usr/bin/env node
+
+/**
+ * CMS & Content handlers: blog-posts, pages, assets, forms, i18n, markdowns
+ */
+
+const mongoose = require('mongoose');
+
+const blogPosts = {
+  async execute(options) {
+    const BlogPost = mongoose.model('BlogPost');
+    switch (options.command) {
+      case 'list': {
+        const posts = await BlogPost.find().lean();
+        return { items: posts, count: posts.length };
+      }
+      case 'get': {
+        if (!options.id) throw new Error('Post ID is required');
+        const post = await BlogPost.findById(options.id).lean();
+        if (!post) throw new Error('Post not found');
+        return post;
+      }
+      case 'create': {
+        if (!options.name) throw new Error('--name (title) is required');
+        const post = await BlogPost.create({
+          title: options.name,
+          content: options.description || '',
+          status: 'draft',
+        });
+        return post;
+      }
+      case 'update': {
+        if (!options.id) throw new Error('Post ID is required');
+        const updateData = {};
+        if (options.name) updateData.title = options.name;
+        if (options.description) updateData.content = options.description;
+        const post = await BlogPost.findByIdAndUpdate(options.id, updateData, { new: true });
+        if (!post) throw new Error('Post not found');
+        return post;
+      }
+      case 'delete': {
+        if (!options.id) throw new Error('Post ID is required');
+        const post = await BlogPost.findByIdAndDelete(options.id);
+        if (!post) throw new Error('Post not found');
+        return { success: true, id: options.id };
+      }
+      case 'publish': {
+        if (!options.id) throw new Error('Post ID is required');
+        const post = await BlogPost.findByIdAndUpdate(
+          options.id,
+          { status: 'published', publishedAt: new Date() },
+          { new: true }
+        );
+        if (!post) throw new Error('Post not found');
+        return post;
+      }
+      case 'unpublish': {
+        if (!options.id) throw new Error('Post ID is required');
+        const post = await BlogPost.findByIdAndUpdate(options.id, { status: 'draft' }, { new: true });
+        if (!post) throw new Error('Post not found');
+        return post;
+      }
+      default:
+        throw new Error(`Unknown blog-posts command: ${options.command}`);
+    }
+  },
+};
+
+const pages = {
+  async execute(options) {
+    const Page = mongoose.model('Page');
+    switch (options.command) {
+      case 'list': {
+        const pages = await Page.find().lean();
+        return { items: pages, count: pages.length };
+      }
+      case 'get': {
+        if (!options.id) throw new Error('Page ID is required');
+        const page = await Page.findById(options.id).lean();
+        if (!page) throw new Error('Page not found');
+        return page;
+      }
+      case 'create': {
+        if (!options.name) throw new Error('--name (slug) is required');
+        const page = await Page.create({
+          slug: options.name,
+          title: options.description || options.name,
+          content: options.value || '',
+        });
+        return page;
+      }
+      case 'update': {
+        if (!options.id) throw new Error('Page ID is required');
+        const updateData = {};
+        if (options.name) updateData.slug = options.name;
+        if (options.description) updateData.title = options.description;
+        if (options.value) updateData.content = options.value;
+        const page = await Page.findByIdAndUpdate(options.id, updateData, { new: true });
+        if (!page) throw new Error('Page not found');
+        return page;
+      }
+      case 'delete': {
+        if (!options.id) throw new Error('Page ID is required');
+        const page = await Page.findByIdAndDelete(options.id);
+        if (!page) throw new Error('Page not found');
+        return { success: true, id: options.id };
+      }
+      default:
+        throw new Error(`Unknown pages command: ${options.command}`);
+    }
+  },
+};
+
+const assets = {
+  async execute(options) {
+    const Asset = mongoose.model('Asset');
+    switch (options.command) {
+      case 'list': {
+        const limit = parseInt(options.value) || 50;
+        const assets = await Asset.find().sort({ createdAt: -1 }).limit(limit).lean();
+        return { items: assets, count: assets.length };
+      }
+      case 'get': {
+        if (!options.id) throw new Error('Asset ID is required');
+        const asset = await Asset.findById(options.id).lean();
+        if (!asset) throw new Error('Asset not found');
+        return asset;
+      }
+      case 'delete': {
+        if (!options.id) throw new Error('Asset ID is required');
+        const asset = await Asset.findByIdAndDelete(options.id);
+        if (!asset) throw new Error('Asset not found');
+        return { success: true, id: options.id };
+      }
+      case 'clear': {
+        await Asset.deleteMany({});
+        return { success: true, message: 'All assets cleared' };
+      }
+      default:
+        throw new Error(`Unknown assets command: ${options.command}`);
+    }
+  },
+};
+
+const forms = {
+  async execute(options) {
+    const FormSubmission = mongoose.model('FormSubmission');
+    switch (options.command) {
+      case 'list': {
+        const limit = parseInt(options.value) || 50;
+        const submissions = await FormSubmission.find().sort({ createdAt: -1 }).limit(limit).lean();
+        return { items: submissions, count: submissions.length };
+      }
+      case 'get': {
+        if (!options.id) throw new Error('Submission ID is required');
+        const submission = await FormSubmission.findById(options.id).lean();
+        if (!submission) throw new Error('Submission not found');
+        return submission;
+      }
+      case 'delete': {
+        if (!options.id) throw new Error('Submission ID is required');
+        const submission = await FormSubmission.findByIdAndDelete(options.id);
+        if (!submission) throw new Error('Submission not found');
+        return { success: true, id: options.id };
+      }
+      case 'clear': {
+        await FormSubmission.deleteMany({});
+        return { success: true, message: 'All form submissions cleared' };
+      }
+      default:
+        throw new Error(`Unknown forms command: ${options.command}`);
+    }
+  },
+};
+
+const i18n = {
+  async execute(options) {
+    const I18nEntry = mongoose.model('I18nEntry');
+    switch (options.command) {
+      case 'list': {
+        const limit = parseInt(options.value) || 50;
+        const entries = await I18nEntry.find().sort({ createdAt: -1 }).limit(limit).lean();
+        return { items: entries, count: entries.length };
+      }
+      case 'get': {
+        if (!options.id) throw new Error('I18n entry ID is required');
+        const entry = await I18nEntry.findById(options.id).lean();
+        if (!entry) throw new Error('I18n entry not found');
+        return entry;
+      }
+      case 'create': {
+        if (!options.key) throw new Error('--key is required');
+        if (!options.value) throw new Error('--value is required');
+        const entry = await I18nEntry.create({
+          key: options.key,
+          values: { en: options.value },
+          locale: 'en',
+        });
+        return entry;
+      }
+      case 'delete': {
+        if (!options.id) throw new Error('I18n entry ID is required');
+        const entry = await I18nEntry.findByIdAndDelete(options.id);
+        if (!entry) throw new Error('I18n entry not found');
+        return { success: true, id: options.id };
+      }
+      default:
+        throw new Error(`Unknown i18n command: ${options.command}`);
+    }
+  },
+};
+
+const markdowns = {
+  async execute(options) {
+    const Markdown = mongoose.model('Markdown');
+    switch (options.command) {
+      case 'list': {
+        const markdowns = await Markdown.find().lean();
+        return { items: markdowns, count: markdowns.length };
+      }
+      case 'get': {
+        if (!options.id) throw new Error('Markdown ID is required');
+        const markdown = await Markdown.findById(options.id).lean();
+        if (!markdown) throw new Error('Markdown not found');
+        return markdown;
+      }
+      case 'create': {
+        if (!options.name) throw new Error('--name (slug) is required');
+        const markdown = await Markdown.create({
+          slug: options.name,
+          content: options.value || '',
+        });
+        return markdown;
+      }
+      case 'delete': {
+        if (!options.id) throw new Error('Markdown ID is required');
+        const markdown = await Markdown.findByIdAndDelete(options.id);
+        if (!markdown) throw new Error('Markdown not found');
+        return { success: true, id: options.id };
+      }
+      default:
+        throw new Error(`Unknown markdowns command: ${options.command}`);
+    }
+  },
+};
+
+module.exports = { blogPosts, pages, assets, forms, i18n, markdowns };

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

@@ -0,0 +1,253 @@
+#!/usr/bin/env node
+
+/**
+ * Core resource handlers: agents, settings, users, json-configs
+ */
+
+const mongoose = require("mongoose");
+
+const agents = {
+  async execute(options) {
+    const Agent = mongoose.model("Agent");
+    switch (options.command) {
+      case "list": {
+        const agents = await Agent.find().lean();
+        return { items: agents, count: agents.length };
+      }
+      case "get": {
+        if (!options.id) throw new Error("Agent ID is required");
+        const agent = await Agent.findById(options.id).lean();
+        if (!agent) throw new Error("Agent not found");
+        return agent;
+      }
+      case "create": {
+        if (!options.name) throw new Error("--name is required");
+        if (!options.model) throw new Error("--model is required");
+        if (!options.key) throw new Error("--key (providerKey) is required");
+        const agent = await Agent.create({
+          name: options.name,
+          model: options.model,
+          providerKey: options.key,
+          systemPrompt: options.description || "",
+        });
+        return agent;
+      }
+      case "update": {
+        if (!options.id) throw new Error("Agent ID is required");
+        const updateData = {};
+        if (options.name) updateData.name = options.name;
+        if (options.model) updateData.model = options.model;
+        if (options.description) updateData.systemPrompt = options.description;
+        const agent = await Agent.findByIdAndUpdate(options.id, updateData, {
+          new: true,
+        });
+        if (!agent) throw new Error("Agent not found");
+        return agent;
+      }
+      case "delete": {
+        if (!options.id) throw new Error("Agent ID is required");
+        const agent = await Agent.findByIdAndDelete(options.id);
+        if (!agent) throw new Error("Agent not found");
+        return { success: true, id: options.id };
+      }
+      default:
+        throw new Error(`Unknown agents command: ${options.command}`);
+    }
+  },
+};
+
+const settings = {
+  async execute(options) {
+    const GlobalSetting = mongoose.model("GlobalSetting");
+    switch (options.command) {
+      case "list": {
+        const settings = await GlobalSetting.find().lean();
+        return { items: settings, count: settings.length };
+      }
+      case "get": {
+        if (!options.key) throw new Error("--key is required");
+        const setting = await GlobalSetting.findOne({
+          key: options.key,
+        }).lean();
+        if (!setting) throw new Error("Setting not found");
+        return setting;
+      }
+      case "create": {
+        if (!options.key) throw new Error("--key is required");
+        if (options.value === undefined) throw new Error("--value is required");
+        let parsedValue = options.value;
+        try {
+          parsedValue = JSON.parse(options.value);
+        } catch (e) {}
+        const setting = await GlobalSetting.create({
+          key: options.key,
+          value: parsedValue,
+          description: options.description || "",
+        });
+        return setting;
+      }
+      case "update": {
+        if (!options.key) throw new Error("--key is required");
+        const updateData = {};
+        if (options.value !== undefined) {
+          try {
+            updateData.value = JSON.parse(options.value);
+          } catch (e) {
+            updateData.value = options.value;
+          }
+        }
+        if (options.description) updateData.description = options.description;
+        const setting = await GlobalSetting.findOneAndUpdate(
+          { key: options.key },
+          updateData,
+          { new: true },
+        );
+        if (!setting) throw new Error("Setting not found");
+        return setting;
+      }
+      case "delete": {
+        if (!options.key) throw new Error("--key is required");
+        const setting = await GlobalSetting.findOneAndDelete({
+          key: options.key,
+        });
+        if (!setting) throw new Error("Setting not found");
+        return { success: true, key: options.key };
+      }
+      default:
+        throw new Error(`Unknown settings command: ${options.command}`);
+    }
+  },
+};
+
+const users = {
+  async execute(options) {
+    const User = mongoose.model("User");
+    switch (options.command) {
+      case "list": {
+        const users = await User.find().select("-password").lean();
+        return { items: users, count: users.length };
+      }
+      case "get": {
+        if (!options.id) throw new Error("User ID is required");
+        const user = await User.findById(options.id).select("-password").lean();
+        if (!user) throw new Error("User not found");
+        return user;
+      }
+      case "create": {
+        if (!options.email) throw new Error("--email is required");
+        if (!options.password) throw new Error("--password is required");
+        const bcrypt = require("bcryptjs");
+        const passwordHash = await bcrypt.hash(options.password, 10);
+        const user = await User.create({
+          email: options.email,
+          passwordHash: passwordHash,
+          role: options.role || "user",
+        });
+        return { _id: user._id, email: user.email, role: user.role };
+      }
+      case "update": {
+        if (!options.id) throw new Error("User ID is required");
+        const updateData = {};
+        if (options.email) updateData.email = options.email;
+        if (options.password) updateData.password = options.password;
+        if (options.role) updateData.role = options.role;
+        const user = await User.findByIdAndUpdate(options.id, updateData, {
+          new: true,
+        });
+        if (!user) throw new Error("User not found");
+        return { _id: user._id, email: user.email, role: user.role };
+      }
+      case "delete": {
+        if (!options.id) throw new Error("User ID is required");
+        const user = await User.findByIdAndDelete(options.id);
+        if (!user) throw new Error("User not found");
+        return { success: true, id: options.id };
+      }
+      case "disable": {
+        if (!options.id) throw new Error("User ID is required");
+        const user = await User.findByIdAndUpdate(
+          options.id,
+          { disabled: true },
+          { new: true },
+        );
+        if (!user) throw new Error("User not found");
+        return { success: true, id: options.id, disabled: true };
+      }
+      case "enable": {
+        if (!options.id) throw new Error("User ID is required");
+        const user = await User.findByIdAndUpdate(
+          options.id,
+          { disabled: false },
+          { new: true },
+        );
+        if (!user) throw new Error("User not found");
+        return { success: true, id: options.id, disabled: false };
+      }
+      default:
+        throw new Error(`Unknown users command: ${options.command}`);
+    }
+  },
+};
+
+const jsonConfigs = {
+  async execute(options) {
+    const JsonConfig = mongoose.model("JsonConfig");
+    switch (options.command) {
+      case "list": {
+        const configs = await JsonConfig.find().lean();
+        return { items: configs, count: configs.length };
+      }
+      case "get": {
+        if (!options.alias) throw new Error("--alias is required");
+        const config = await JsonConfig.findOne({
+          alias: options.alias,
+        }).lean();
+        if (!config) throw new Error("Config not found");
+        return config;
+      }
+      case "create": {
+        if (!options.alias) throw new Error("--alias is required");
+        if (!options.json) throw new Error("--json is required");
+        let parsedJson;
+        try {
+          parsedJson = JSON.parse(options.json);
+        } catch (e) {
+          throw new Error("--json must be valid JSON");
+        }
+        const config = await JsonConfig.create({
+          alias: options.alias,
+          jsonRaw: options.json,
+        });
+        return config;
+      }
+      case "update": {
+        if (!options.alias) throw new Error("--alias is required");
+        if (!options.json) throw new Error("--json is required");
+        try {
+          JSON.parse(options.json);
+        } catch (e) {
+          throw new Error("--json must be valid JSON");
+        }
+        const config = await JsonConfig.findOneAndUpdate(
+          { alias: options.alias },
+          { jsonRaw: options.json },
+          { new: true },
+        );
+        if (!config) throw new Error("Config not found");
+        return config;
+      }
+      case "delete": {
+        if (!options.alias) throw new Error("--alias is required");
+        const config = await JsonConfig.findOneAndDelete({
+          alias: options.alias,
+        });
+        if (!config) throw new Error("Config not found");
+        return { success: true, alias: options.alias };
+      }
+      default:
+        throw new Error(`Unknown json-configs command: ${options.command}`);
+    }
+  },
+};
+
+module.exports = { agents, settings, users, jsonConfigs };