@intranefr/superbackend 1.4.4 → 1.5.1

package/src/controllers/blogAiAdmin.controller.js

@@ -0,0 +1,224 @@
+const llmService = require('../services/llm.service');
+
+function safeJsonExtract(raw) {
+  const text = String(raw || '').trim();
+  if (!text) return null;
+
+  let cleaned = text;
+  if (cleaned.startsWith('```')) {
+    cleaned = cleaned.replace(/^```[a-zA-Z]*\s*/m, '').replace(/```\s*$/m, '').trim();
+  }
+
+  const firstObj = cleaned.indexOf('{');
+  const lastObj = cleaned.lastIndexOf('}');
+  const firstArr = cleaned.indexOf('[');
+  const lastArr = cleaned.lastIndexOf(']');
+
+  let candidate = cleaned;
+  if (firstObj !== -1 && lastObj !== -1 && lastObj > firstObj) {
+    candidate = cleaned.slice(firstObj, lastObj + 1);
+  } else if (firstArr !== -1 && lastArr !== -1 && lastArr > firstArr) {
+    candidate = cleaned.slice(firstArr, lastArr + 1);
+  }
+
+  try {
+    return JSON.parse(candidate);
+  } catch {
+    return null;
+  }
+}
+
+exports.generateField = async (req, res) => {
+  try {
+    const { field, context, providerKey, model } = req.body || {};
+    const f = String(field || '').trim();
+    if (!f) return res.status(400).json({ error: 'field is required' });
+    if (!providerKey) return res.status(400).json({ error: 'providerKey is required' });
+
+    const ctx = context && typeof context === 'object' ? context : {};
+
+    const system =
+      'You are an expert blog editor. You write clear, concise, SEO-friendly copy. ' +
+      'Return ONLY the requested output with no extra commentary.';
+
+    const instructionsByField = {
+      title: 'Generate a compelling blog post title. Keep it SEO-friendly. Max 70 characters. Return only the title.',
+      excerpt: 'Generate a short excerpt (1-2 sentences). SEO-friendly, no markdown, no quotes. Return only the excerpt.',
+      category: 'Suggest a single category (2-4 words). Return only the category.',
+      tags: 'Generate 5-10 relevant tags. Return as a comma-separated list, lowercase where appropriate.',
+      seoTitle: 'Generate an SEO title. Max 60 characters. Return only the SEO title.',
+      seoDescription: 'Generate an SEO meta description. Max 155 characters. Return only the description.',
+    };
+
+    const instruction =
+      instructionsByField[f] || `Generate a value for field "${f}". Return only the value.`;
+
+    const result = await llmService.callAdhoc(
+      {
+        providerKey,
+        model,
+        promptKeyForAudit: `blog.ai.generate.${f}`,
+        messages: [
+          { role: 'system', content: system },
+          { role: 'user', content: instruction + '\n\nContext (JSON):\n' + JSON.stringify(ctx, null, 2) },
+        ],
+      },
+      { temperature: 0.6, max_tokens: 256 },
+    );
+
+    res.json({ value: String(result?.content || '').trim(), usage: result?.usage || null });
+  } catch (error) {
+    console.error('[blog-ai] generate-field error', error);
+    res.status(500).json({ error: error.message || 'Failed to generate field' });
+  }
+};
+
+exports.generateAll = async (req, res) => {
+  try {
+    const { context, providerKey, model } = req.body || {};
+    if (!providerKey) return res.status(400).json({ error: 'providerKey is required' });
+
+    const ctx = context && typeof context === 'object' ? context : {};
+
+    const system = 'Return ONLY a valid JSON object, no markdown fences.';
+
+    const user =
+      'Generate blog metadata fields based on the blog content and context.\n' +
+      'Return a JSON object with keys: title, excerpt, category, tags, seoTitle, seoDescription.\n' +
+      'tags must be an array of strings.\n\n' +
+      'Context (JSON):\n' +
+      JSON.stringify(ctx, null, 2);
+
+    const result = await llmService.callAdhoc(
+      {
+        providerKey,
+        model,
+        promptKeyForAudit: 'blog.ai.generate_all',
+        messages: [
+          { role: 'system', content: system },
+          { role: 'user', content: user },
+        ],
+      },
+      { temperature: 0.6, max_tokens: 600 },
+    );
+
+    const parsed = safeJsonExtract(result?.content) || null;
+    if (!parsed || typeof parsed !== 'object') {
+      return res.status(500).json({ error: 'AI returned invalid JSON', raw: String(result?.content || '') });
+    }
+
+    if (typeof parsed.tags === 'string') {
+      parsed.tags = parsed.tags
+        .split(',')
+        .map((t) => String(t || '').trim())
+        .filter(Boolean);
+    }
+    if (parsed.tags !== undefined && !Array.isArray(parsed.tags)) {
+      parsed.tags = [];
+    }
+
+    res.json({ values: parsed, usage: result?.usage || null });
+  } catch (error) {
+    console.error('[blog-ai] generate-all error', error);
+    res.status(500).json({ error: error.message || 'Failed to generate all' });
+  }
+};
+
+exports.formatMarkdown = async (req, res) => {
+  try {
+    const { text, context, providerKey, model } = req.body || {};
+    if (!providerKey) return res.status(400).json({ error: 'providerKey is required' });
+
+    const input = String(text || '');
+    if (!input.trim()) return res.status(400).json({ error: 'text is required' });
+
+    const ctx = context && typeof context === 'object' ? context : {};
+
+    const system = 'You are an expert blog editor. Output only markdown. Do not wrap in code fences.';
+
+    const user =
+      'Convert the following content into clean, well-structured markdown with headings, lists, and short paragraphs.\n' +
+      'Preserve meaning, improve readability.\n\n' +
+      'Context (JSON):\n' +
+      JSON.stringify(ctx, null, 2) +
+      '\n\nInput:\n' +
+      input;
+
+    const result = await llmService.callAdhoc(
+      {
+        providerKey,
+        model,
+        promptKeyForAudit: 'blog.ai.format_markdown',
+        messages: [
+          { role: 'system', content: system },
+          { role: 'user', content: user },
+        ],
+      },
+      { temperature: 0.4, max_tokens: 2000 },
+    );
+
+    res.json({ markdown: String(result?.content || ''), usage: result?.usage || null });
+  } catch (error) {
+    console.error('[blog-ai] format-markdown error', error);
+    res.status(500).json({ error: error.message || 'Failed to format markdown' });
+  }
+};
+
+exports.refineMarkdown = async (req, res) => {
+  try {
+    const { markdown, instruction, selectionStart, selectionEnd, context, providerKey, model } = req.body || {};
+    if (!providerKey) return res.status(400).json({ error: 'providerKey is required' });
+
+    const md = String(markdown || '');
+    if (!md.trim()) return res.status(400).json({ error: 'markdown is required' });
+
+    const instr = String(instruction || '').trim();
+    if (!instr) return res.status(400).json({ error: 'instruction is required' });
+
+    const ctx = context && typeof context === 'object' ? context : {};
+
+    const start = Number(selectionStart);
+    const end = Number(selectionEnd);
+    const hasSelection = Number.isFinite(start) && Number.isFinite(end) && end > start;
+    const selected = hasSelection ? md.slice(start, end) : '';
+
+    const system = 'You are an expert blog editor. Output only markdown. Do not wrap in code fences.';
+
+    const user = hasSelection
+      ? 'Refine ONLY the selected markdown according to the instruction. Return ONLY the replacement markdown for the selection.\n\n' +
+        'Instruction:\n' + instr +
+        '\n\nContext (JSON):\n' + JSON.stringify(ctx, null, 2) +
+        '\n\nSelected markdown:\n' + selected
+      : 'Refine the full markdown according to the instruction. Return ONLY the full updated markdown.\n\n' +
+        'Instruction:\n' + instr +
+        '\n\nContext (JSON):\n' + JSON.stringify(ctx, null, 2) +
+        '\n\nMarkdown:\n' + md;
+
+    const result = await llmService.callAdhoc(
+      {
+        providerKey,
+        model,
+        promptKeyForAudit: hasSelection ? 'blog.ai.refine.selection' : 'blog.ai.refine.full',
+        messages: [
+          { role: 'system', content: system },
+          { role: 'user', content: user },
+        ],
+      },
+      { temperature: 0.5, max_tokens: 2000 },
+    );
+
+    const replacement = String(result?.content || '');
+    const nextMarkdown = hasSelection ? md.slice(0, start) + replacement + md.slice(end) : replacement;
+
+    res.json({
+      markdown: nextMarkdown,
+      replaced: hasSelection,
+      selectionStart: hasSelection ? start : null,
+      selectionEnd: hasSelection ? start + replacement.length : null,
+      usage: result?.usage || null,
+    });
+  } catch (error) {
+    console.error('[blog-ai] refine-markdown error', error);
+    res.status(500).json({ error: error.message || 'Failed to refine markdown' });
+  }
+};

package/src/controllers/blogAutomationAdmin.controller.js

@@ -0,0 +1,141 @@
+const blogAutomationService = require('../services/blogAutomation.service');
+
+exports.getConfig = async (req, res) => {
+  res.status(400).json({
+    error: 'Deprecated endpoint. Use /api/admin/blog-automation/configs instead.',
+  });
+};
+
+exports.saveConfig = async (req, res) => {
+  res.status(400).json({
+    error: 'Deprecated endpoint. Use /api/admin/blog-automation/configs instead.',
+  });
+};
+
+exports.listConfigs = async (req, res) => {
+  try {
+    const configs = await blogAutomationService.getBlogAutomationConfigs();
+    res.json({ configs });
+  } catch (error) {
+    console.error('Error listing blog automation configs:', error);
+    res.status(500).json({ error: 'Failed to load configs' });
+  }
+};
+
+exports.previewPromptsByConfigId = async (req, res) => {
+  try {
+    const configId = String(req.params.id || '').trim();
+    if (!configId) return res.status(400).json({ error: 'configId is required' });
+    const prompts = await blogAutomationService.previewPromptsByConfigId(configId);
+    res.json({ prompts });
+  } catch (error) {
+    const status = Number(error?.statusCode || 500);
+    if (status !== 500) return res.status(status).json({ error: String(error?.message || 'Invalid request') });
+    console.error('Error previewing blog automation prompts:', error);
+    res.status(500).json({ error: 'Failed to preview prompts' });
+  }
+};
+
+exports.getConfigById = async (req, res) => {
+  try {
+    const cfg = await blogAutomationService.getBlogAutomationConfigById(req.params.id);
+    res.json({ config: cfg });
+  } catch (error) {
+    const status = Number(error?.statusCode || 500);
+    if (status !== 500) return res.status(status).json({ error: String(error?.message || 'Invalid request') });
+    console.error('Error getting blog automation config:', error);
+    res.status(500).json({ error: 'Failed to load config' });
+  }
+};
+
+exports.createConfig = async (req, res) => {
+  try {
+    const name = String(req.body?.name || '').trim();
+    const created = await blogAutomationService.createAutomationConfig({ name });
+    const blogCronsBootstrap = require('../services/blogCronsBootstrap.service');
+    await blogCronsBootstrap.bootstrap();
+    res.json({ config: created });
+  } catch (error) {
+    console.error('Error creating blog automation config:', error);
+    res.status(500).json({ error: 'Failed to create config' });
+  }
+};
+
+exports.updateConfigById = async (req, res) => {
+  try {
+    const config = req.body?.config;
+    if (!config || typeof config !== 'object') {
+      return res.status(400).json({ error: 'config object is required' });
+    }
+    const updated = await blogAutomationService.updateAutomationConfig(req.params.id, config);
+    const blogCronsBootstrap = require('../services/blogCronsBootstrap.service');
+    await blogCronsBootstrap.bootstrap();
+    res.json({ config: updated });
+  } catch (error) {
+    const status = Number(error?.statusCode || 500);
+    if (status !== 500) return res.status(status).json({ error: String(error?.message || 'Invalid request') });
+    console.error('Error updating blog automation config:', error);
+    res.status(500).json({ error: 'Failed to update config' });
+  }
+};
+
+exports.deleteConfigById = async (req, res) => {
+  try {
+    await blogAutomationService.deleteAutomationConfig(req.params.id);
+    const blogCronsBootstrap = require('../services/blogCronsBootstrap.service');
+    await blogCronsBootstrap.bootstrap();
+    res.json({ success: true });
+  } catch (error) {
+    const status = Number(error?.statusCode || 500);
+    if (status !== 500) return res.status(status).json({ error: String(error?.message || 'Invalid request') });
+    console.error('Error deleting blog automation config:', error);
+    res.status(500).json({ error: 'Failed to delete config' });
+  }
+};
+
+exports.getStyleGuide = async (req, res) => {
+  try {
+    const styleGuide = await blogAutomationService.getBlogAutomationStyleGuide();
+    res.json({ styleGuide });
+  } catch (error) {
+    console.error('Error getting blog automation style guide:', error);
+    res.status(500).json({ error: 'Failed to load style guide' });
+  }
+};
+
+exports.saveStyleGuide = async (req, res) => {
+  try {
+    const styleGuide = String(req.body?.styleGuide ?? '');
+    await blogAutomationService.updateStyleGuide(styleGuide);
+    res.json({ success: true });
+  } catch (error) {
+    console.error('Error saving blog automation style guide:', error);
+    res.status(500).json({ error: 'Failed to save style guide' });
+  }
+};
+
+exports.listRuns = async (req, res) => {
+  try {
+    const limit = Math.min(100, Math.max(1, Number(req.query.limit || 30) || 30));
+    const configId = String(req.query.configId || '').trim();
+    const runs = await blogAutomationService.listRuns({ limit, configId });
+    res.json({ runs });
+  } catch (error) {
+    console.error('Error listing blog automation runs:', error);
+    res.status(500).json({ error: 'Failed to load runs' });
+  }
+};
+
+exports.runNow = async (req, res) => {
+  try {
+    const configId = String(req.body?.configId || '').trim();
+    if (!configId) return res.status(400).json({ error: 'configId is required' });
+    const run = await blogAutomationService.runBlogAutomation({ trigger: 'manual', configId });
+    res.json({ run });
+  } catch (error) {
+    const status = Number(error?.statusCode || 500);
+    if (status !== 500) return res.status(status).json({ error: String(error?.message || 'Invalid request') });
+    console.error('Error starting blog automation run:', error);
+    res.status(500).json({ error: 'Failed to run automation' });
+  }
+};

package/src/controllers/blogInternal.controller.js

@@ -0,0 +1,26 @@
+const blogAutomationService = require('../services/blogAutomation.service');
+const blogPublishingService = require('../services/blogPublishing.service');
+
+exports.runAutomation = async (req, res) => {
+  try {
+    const trigger = req.body?.trigger === 'scheduled' ? 'scheduled' : 'manual';
+    const configId = String(req.body?.configId || '').trim();
+    if (!configId) return res.status(400).json({ error: 'configId is required' });
+    const run = await blogAutomationService.runBlogAutomation({ trigger, configId });
+    res.json({ run });
+  } catch (error) {
+    console.error('internal automation run error:', error);
+    res.status(500).json({ error: 'Failed to run automation' });
+  }
+};
+
+exports.publishScheduled = async (req, res) => {
+  try {
+    const limit = req.body?.limit;
+    const result = await blogPublishingService.publishScheduledDue({ limit });
+    res.json({ result });
+  } catch (error) {
+    console.error('internal publish scheduled error:', error);
+    res.status(500).json({ error: 'Failed to publish scheduled posts' });
+  }
+};

package/src/controllers/blogPublic.controller.js

@@ -0,0 +1,89 @@
+const BlogPost = require('../models/BlogPost');
+const { parsePagination } = require('../services/blog.service');
+
+exports.listPublished = async (req, res) => {
+  try {
+    const { page, limit, skip } = parsePagination({
+      page: req.query.page,
+      limit: req.query.limit,
+      maxLimit: 100,
+      defaultLimit: 20,
+    });
+
+    const filter = { status: 'published' };
+
+    const tag = String(req.query.tag || '').trim();
+    if (tag) {
+      filter.tags = tag;
+    }
+
+    const category = String(req.query.category || '').trim();
+    if (category) {
+      filter.category = category;
+    }
+
+    const q = String(req.query.q || '').trim();
+    if (q) {
+      const re = new RegExp(q.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'i');
+      filter.$or = [{ title: re }, { excerpt: re }];
+    }
+
+    const [items, total] = await Promise.all([
+      BlogPost.find(filter)
+        .sort({ publishedAt: -1, createdAt: -1 })
+        .select('title slug excerpt coverImageUrl category tags authorName publishedAt createdAt updatedAt')
+        .skip(skip)
+        .limit(limit)
+        .lean(),
+      BlogPost.countDocuments(filter),
+    ]);
+
+    res.json({
+      items,
+      pagination: {
+        page,
+        limit,
+        total,
+        pages: Math.ceil(total / limit),
+      },
+    });
+  } catch (error) {
+    console.error('Error listing blog posts:', error);
+    res.status(500).json({ error: 'Failed to list blog posts' });
+  }
+};
+
+exports.getPublishedBySlug = async (req, res) => {
+  try {
+    const slug = String(req.params.slug || '').trim();
+    if (!slug) return res.status(400).json({ error: 'slug is required' });
+
+    const post = await BlogPost.findOne({ slug, status: 'published' }).lean();
+    if (!post) return res.status(404).json({ error: 'Not found' });
+
+    res.json({
+      post: {
+        _id: post._id,
+        title: post.title,
+        slug: post.slug,
+        status: post.status,
+        excerpt: post.excerpt,
+        markdown: post.markdown,
+        html: post.html,
+        coverImageUrl: post.coverImageUrl,
+        category: post.category,
+        tags: post.tags,
+        authorName: post.authorName,
+        seoTitle: post.seoTitle,
+        seoDescription: post.seoDescription,
+        scheduledAt: post.scheduledAt,
+        publishedAt: post.publishedAt,
+        createdAt: post.createdAt,
+        updatedAt: post.updatedAt,
+      },
+    });
+  } catch (error) {
+    console.error('Error getting blog post:', error);
+    res.status(500).json({ error: 'Failed to get blog post' });
+  }
+};

package/src/controllers/fileManager.controller.js

@@ -0,0 +1,190 @@
+const fileManagerService = require('../services/fileManager.service');
+
+exports.listDrives = async (req, res) => {
+  try {
+    const orgId = req.query.orgId || req.headers['x-org-id'] || null;
+    const payload = await fileManagerService.listDrives({ userId: req.user._id, orgId });
+    return res.json(payload);
+  } catch (error) {
+    const code = error?.code;
+    if (code === 'VALIDATION') return res.status(400).json({ error: error.message });
+    console.error('Error listing file manager drives:', error);
+    return res.status(500).json({ error: 'Failed to list drives' });
+  }
+};
+
+exports.listFolder = async (req, res) => {
+  try {
+    const orgId = req.query.orgId || req.body?.orgId || req.headers['x-org-id'] || null;
+    const driveType = req.query.driveType || req.body?.driveType;
+    const driveId = req.query.driveId || req.body?.driveId;
+    const folderPath = req.query.folderPath || req.query.path || req.body?.folderPath || '/';
+    const payload = await fileManagerService.listFolder({
+      orgId,
+      driveType,
+      driveId,
+      parentPath: folderPath || '/',
+    });
+    return res.json(payload);
+  } catch (error) {
+    const code = error?.code;
+    if (code === 'VALIDATION') return res.status(400).json({ error: error.message });
+    console.error('Error listing file manager folder:', error);
+    return res.status(500).json({ error: 'Failed to list folder' });
+  }
+};
+
+exports.upload = async (req, res) => {
+  try {
+    if (!req.file && !req.files?.file) {
+      return res.status(400).json({ error: 'No file provided' });
+    }
+
+    const file = req.file || req.files.file;
+    const buffer = file.buffer || (file.data ? file.data : null);
+
+    if (!buffer) {
+      return res.status(400).json({ error: 'Unable to read file buffer' });
+    }
+
+    const contentType = file.mimetype;
+    const name = req.body?.name || file.originalname || file.name;
+
+    const overwriteRaw = req.body?.overwrite ?? req.query?.overwrite;
+    const overwrite = overwriteRaw === 'true' || overwriteRaw === true || overwriteRaw === '1';
+
+    const orgId = req.body?.orgId ?? req.query?.orgId;
+    const driveType = req.body?.driveType ?? req.query?.driveType;
+    const driveId = req.body?.driveId ?? req.query?.driveId;
+    const folderPath = req.body?.folderPath ?? req.query?.folderPath;
+
+    const payload = await fileManagerService.uploadFile({
+      userId: req.user._id,
+      orgId,
+      driveType,
+      driveId,
+      parentPath: folderPath || '/',
+      name,
+      buffer,
+      contentType,
+      overwrite,
+      requestedVisibility: req.body?.visibility,
+    });
+
+    return res.status(201).json(payload);
+  } catch (error) {
+    const code = error?.code;
+    if (code === 'VALIDATION') return res.status(400).json({ error: error.message });
+    if (code === 'CONFLICT') return res.status(409).json({ error: error.message, ...error.details });
+    if (code === 'UPLOAD_REJECTED') return res.status(400).json({ error: error.message, ...error.details });
+
+    console.error('Error uploading file manager file:', error);
+    return res.status(500).json({ error: 'Failed to upload file' });
+  }
+};
+
+exports.download = async (req, res) => {
+  try {
+    const orgId = req.query.orgId || req.headers['x-org-id'] || null;
+    const driveType = req.query.driveType;
+    const driveId = req.query.driveId;
+
+    const result = await fileManagerService.downloadFile({
+      orgId,
+      driveType,
+      driveId,
+      fileId: req.params.id,
+    });
+
+    res.set('Content-Type', result.contentType);
+    if (result.asset?.originalName) {
+      res.set('Content-Disposition', `inline; filename="${result.asset.originalName}"`);
+    }
+    res.send(result.body);
+  } catch (error) {
+    const code = error?.code;
+    if (code === 'VALIDATION') return res.status(400).json({ error: error.message });
+    if (code === 'NOT_FOUND') return res.status(404).json({ error: 'Not found' });
+
+    console.error('Error downloading file manager file:', error);
+    return res.status(500).json({ error: 'Failed to download file' });
+  }
+};
+
+exports.delete = async (req, res) => {
+  try {
+    const orgId = req.query.orgId || req.body?.orgId || req.headers['x-org-id'] || null;
+    const driveType = req.query.driveType || req.body?.driveType;
+    const driveId = req.query.driveId || req.body?.driveId;
+
+    const payload = await fileManagerService.deleteFile({
+      orgId,
+      driveType,
+      driveId,
+      fileId: req.params.id,
+    });
+
+    return res.json(payload);
+  } catch (error) {
+    const code = error?.code;
+    if (code === 'VALIDATION') return res.status(400).json({ error: error.message });
+    if (code === 'NOT_FOUND') return res.status(404).json({ error: 'Not found' });
+
+    console.error('Error deleting file manager file:', error);
+    return res.status(500).json({ error: 'Failed to delete file' });
+  }
+};
+
+exports.update = async (req, res) => {
+  try {
+    const orgId = req.body?.orgId || req.query.orgId || req.headers['x-org-id'] || null;
+    const driveType = req.body?.driveType || req.query.driveType;
+    const driveId = req.body?.driveId || req.query.driveId;
+
+    const payload = await fileManagerService.updateFile({
+      orgId,
+      driveType,
+      driveId,
+      fileId: req.params.id,
+      name: req.body?.name,
+      parentPath: req.body?.folderPath,
+    });
+
+    return res.json(payload);
+  } catch (error) {
+    const code = error?.code;
+    if (code === 'VALIDATION') return res.status(400).json({ error: error.message });
+    if (code === 'CONFLICT') return res.status(409).json({ error: error.message, ...error.details });
+    if (code === 'NOT_FOUND') return res.status(404).json({ error: 'Not found' });
+
+    console.error('Error updating file manager file:', error);
+    return res.status(500).json({ error: 'Failed to update file' });
+  }
+};
+
+exports.setShare = async (req, res) => {
+  try {
+    const orgId = req.body?.orgId || req.query.orgId || req.headers['x-org-id'] || null;
+    const driveType = req.body?.driveType || req.query.driveType;
+    const driveId = req.body?.driveId || req.query.driveId;
+    const enabled = req.body?.enabled === true || req.body?.enabled === 'true' || req.body?.enabled === '1';
+
+    const payload = await fileManagerService.setShare({
+      orgId,
+      driveType,
+      driveId,
+      fileId: req.params.id,
+      enabled,
+    });
+
+    return res.json(payload);
+  } catch (error) {
+    const code = error?.code;
+    if (code === 'VALIDATION') return res.status(400).json({ error: error.message });
+    if (code === 'NOT_FOUND') return res.status(404).json({ error: 'Not found' });
+    if (code === 'VISIBILITY_ENFORCED') return res.status(400).json({ error: error.message });
+
+    console.error('Error toggling file manager share:', error);
+    return res.status(500).json({ error: 'Failed to update share status' });
+  }
+};

package/src/controllers/fileManagerStoragePolicy.controller.js

@@ -0,0 +1,23 @@
+const fileManagerStoragePolicyService = require('../services/fileManagerStoragePolicy.service');
+
+exports.getStoragePolicy = async (req, res) => {
+  try {
+    const orgId = req.query.orgId || req.headers['x-org-id'] || null;
+    const driveType = req.query.driveType;
+    const driveId = req.query.driveId;
+
+    const payload = await fileManagerStoragePolicyService.getEffectivePolicy({
+      userId: req.user._id,
+      orgId,
+      driveType,
+      driveId,
+    });
+
+    return res.json(payload);
+  } catch (error) {
+    const code = error?.code;
+    if (code === 'VALIDATION') return res.status(400).json({ error: error.message });
+    console.error('Error getting file manager storage policy:', error);
+    return res.status(500).json({ error: 'Failed to get storage policy' });
+  }
+};