@jhits/plugin-dep 0.0.12 → 0.0.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jhits/plugin-dep",
-  "version": "0.0.12",
+  "version": "0.0.14",
   "description": "DEPRECATED: Legacy dependencies and shared logic for JHITS (Phase out in progress)",
   "publishConfig": {
     "access": "public"
@@ -40,7 +40,7 @@
     "@types/jsonwebtoken": "^9.0.10",
     "@types/node": "^25.2.3",
     "@types/nodemailer": "^7.0.10",
-    "@jhits/plugin-core": "0.0.8"
+    "@jhits/plugin-core": "0.0.10"
   },
   "peerDependencies": {
     "next": ">=15.0.0"
@@ -50,6 +50,7 @@
     "typescript": "^5.9.3"
   },
   "files": [
+    "src",
     "dist",
     "package.json"
   ],

package/src/actions.ts

@@ -0,0 +1,659 @@
+/**
+ * Plugin Deprecated - Actions
+ * Framework-agnostic business logic for deprecated client API routes
+ * 
+ * SERVER-ONLY: This module must never be imported by client code
+ */
+
+import 'server-only';
+
+import { ObjectId, MongoClient } from 'mongodb';
+import { DepApiConfig } from './types';
+import bcrypt from 'bcryptjs';
+import jwt from 'jsonwebtoken';
+import fs from 'fs';
+import path from 'path';
+import { exec, execSync } from 'child_process';
+import nodemailer from 'nodemailer';
+
+// ============================================================================
+// AUTH ACTIONS
+// ============================================================================
+
+export async function getMe(config: DepApiConfig, session?: any) {
+    if (!session || !session.user) {
+        return { loggedIn: false };
+    }
+
+    return {
+        loggedIn: true,
+        user: {
+            id: (session.user as any).id,
+            email: session.user.email,
+            name: session.user.name || '',
+            role: (session.user as any).role || '',
+        },
+    };
+}
+
+// ============================================================================
+// FEEDBACK ACTIONS
+// ============================================================================
+
+export async function createFeedback(
+    config: DepApiConfig,
+    data: { type: string; message: string; image?: string },
+    userId?: string
+) {
+    const client = await config.mongoClient;
+    const db = client.db();
+
+    let senderInfo = { name: 'Onbekend', email: 'Onbekend' };
+    if (userId) {
+        const user = await db.collection('users').findOne({ _id: new ObjectId(userId) });
+        if (user) {
+            senderInfo = { name: user.name, email: user.email };
+        }
+    }
+
+    const result = await db.collection('feedback').insertOne({
+        type: data.type,
+        message: data.message,
+        image: data.image,
+        sender: senderInfo,
+        status: 'Open',
+        createdAt: new Date(),
+    });
+
+    await db.collection('notifications').insertOne({
+        category: data.type === 'Foutmelding' ? 'alert' : 'feedback',
+        title: `Nieuwe ${data.type}`,
+        description: `${senderInfo.name}: ${data.message.substring(0, 60)}${data.message.length > 60 ? '...' : ''}`,
+        link: '/dashboard/feedback',
+        forRole: 'dev',
+        feedbackId: result.insertedId,
+        senderId: userId,
+        createdAt: new Date(),
+    });
+
+    return { success: true, id: result.insertedId };
+}
+
+export async function listFeedback(config: DepApiConfig) {
+    const client = await config.mongoClient;
+    const db = client.db();
+    const reports = await db.collection('feedback')
+        .find({})
+        .sort({ createdAt: -1 })
+        .toArray();
+    return reports;
+}
+
+export async function updateFeedback(
+    config: DepApiConfig,
+    id: string,
+    data: { status: string }
+) {
+    const client = await config.mongoClient;
+    const db = client.db();
+    await db.collection('feedback').updateOne(
+        { _id: new ObjectId(id) },
+        { $set: { status: data.status, updatedAt: new Date() } }
+    );
+    return { success: true };
+}
+
+export async function deleteFeedback(config: DepApiConfig, id: string) {
+    const client = await config.mongoClient;
+    const db = client.db();
+    await db.collection('feedback').deleteOne({ _id: new ObjectId(id) });
+    return { success: true };
+}
+
+// ============================================================================
+// SETTINGS ACTIONS
+// ============================================================================
+
+export async function getSettings(config: DepApiConfig) {
+    const client = await config.mongoClient;
+    const db = client.db();
+    const settings = await db.collection('settings').findOne({ identifier: 'site_config' });
+    return settings || {};
+}
+
+export async function updateSettings(config: DepApiConfig, data: any) {
+    const client = await config.mongoClient;
+    const db = client.db();
+    const { _id, ...updateData } = data;
+    await db.collection('settings').updateOne(
+        { identifier: 'site_config' },
+        {
+            $set: {
+                ...updateData,
+                updatedAt: new Date(),
+            },
+        },
+        { upsert: true }
+    );
+    return { success: true };
+}
+
+export async function getMaintenanceMode(config: DepApiConfig) {
+    const client = await config.mongoClient;
+    const db = client.db();
+    const setting = await db.collection('settings').findOne({ key: 'maintenance_mode' });
+    return { active: setting?.value ?? true };
+}
+
+export async function setMaintenanceMode(config: DepApiConfig, active: boolean) {
+    const client = await config.mongoClient;
+    const db = client.db();
+    await db.collection('settings').updateOne(
+        { key: 'maintenance_mode' },
+        { $set: { value: active, updatedAt: new Date() } },
+        { upsert: true }
+    );
+    return { success: true, active };
+}
+
+// ============================================================================
+// USER ACTIONS
+// ============================================================================
+
+export async function listUsers(config: DepApiConfig) {
+    const client = await config.mongoClient;
+    const db = client.db();
+    const users = await db.collection('users')
+        .find({}, { projection: { password: 0 } })
+        .toArray();
+    return users;
+}
+
+export async function createUser(
+    config: DepApiConfig,
+    data: { email: string; name: string; role: string; password: string }
+) {
+    if (!data.password || data.password.length < 6) {
+        throw new Error('Password too short');
+    }
+
+    const client = await config.mongoClient;
+    const db = client.db();
+
+    const exists = await db.collection('users').findOne({ email: data.email });
+    if (exists) {
+        throw new Error('User already exists');
+    }
+
+    const hashedPassword = await bcrypt.hash(data.password, 12);
+    const result = await db.collection('users').insertOne({
+        email: data.email,
+        name: data.name,
+        role: data.role || 'editor',
+        password: hashedPassword,
+        createdAt: new Date(),
+    });
+
+    return {
+        _id: result.insertedId,
+        email: data.email,
+        name: data.name,
+        role: data.role,
+        createdAt: new Date(),
+    };
+}
+
+export async function updateUser(
+    config: DepApiConfig,
+    id: string,
+    data: { role?: string; name?: string; password?: string; currentPassword?: string }
+) {
+    const client = await config.mongoClient;
+    const db = client.db();
+
+    const updateData: any = { updatedAt: new Date() };
+    if (data.role) updateData.role = data.role;
+    if (data.name) updateData.name = data.name;
+
+    if (data.password) {
+        const user = await db.collection('users').findOne({ _id: new ObjectId(id) });
+        if (!user) {
+            throw new Error('User not found');
+        }
+
+        if (!data.currentPassword) {
+            throw new Error('Current password is required');
+        }
+
+        const isCorrect = await bcrypt.compare(data.currentPassword, user.password);
+        if (!isCorrect) {
+            throw new Error('Current password is incorrect');
+        }
+
+        if (data.password.length < 6) {
+            throw new Error('New password too short');
+        }
+
+        updateData.password = await bcrypt.hash(data.password, 12);
+    }
+
+    const result = await db.collection('users').updateOne(
+        { _id: new ObjectId(id) },
+        { $set: updateData }
+    );
+
+    if (result.matchedCount === 0) {
+        throw new Error('User not found');
+    }
+
+    return { message: 'Update successful' };
+}
+
+export async function deleteUser(config: DepApiConfig, id: string) {
+    const client = await config.mongoClient;
+    const db = client.db();
+
+    const user = await db.collection('users').findOne({ _id: new ObjectId(id) });
+    if (user?.role === 'dev') {
+        throw new Error('Cannot delete developer account');
+    }
+
+    await db.collection('users').deleteOne({ _id: new ObjectId(id) });
+    return { message: 'User deleted' };
+}
+
+// ============================================================================
+// NEWSLETTER ACTIONS
+// ============================================================================
+
+export async function subscribeNewsletter(
+    config: DepApiConfig,
+    data: { email: string; language: string },
+    host?: string
+) {
+    if (!data.email || !data.email.includes('@')) {
+        throw new Error('Invalid email address.');
+    }
+
+    const client = await config.mongoClient;
+    const db = client.db();
+    const collection = db.collection('subscribers');
+
+    const existing = await collection.findOne({ email: data.email.toLowerCase() });
+    if (existing) {
+        throw new Error('You are already subscribed!');
+    }
+
+    await collection.insertOne({
+        email: data.email.toLowerCase(),
+        language: data.language || 'en',
+        subscribedAt: new Date(),
+    });
+
+    return { message: 'Success' };
+}
+
+export async function listSubscribers(config: DepApiConfig) {
+    const client = await config.mongoClient;
+    const db = client.db();
+    const subscribers = await db.collection('subscribers')
+        .find({})
+        .sort({ subscribedAt: -1 })
+        .toArray();
+    return subscribers;
+}
+
+export async function getSubscriber(config: DepApiConfig, email: string) {
+    const client = await config.mongoClient;
+    const db = client.db();
+    const subscriber = await db.collection('subscribers').findOne({ email: email.toLowerCase() });
+    if (!subscriber) {
+        throw new Error('Subscriber not found');
+    }
+    return subscriber;
+}
+
+export async function deleteSubscriber(config: DepApiConfig, email: string) {
+    const client = await config.mongoClient;
+    const db = client.db();
+    const result = await db.collection('subscribers').deleteOne({ email: email.toLowerCase() });
+    if (result.deletedCount === 0) {
+        throw new Error('Subscriber not found');
+    }
+    return { message: 'Subscriber successfully removed' };
+}
+
+export async function getNewsletterSettings(config: DepApiConfig) {
+    const client = await config.mongoClient;
+    const db = client.db();
+    const newsletter = await db.collection('newsletters').findOne({ id: 'welcome_automation' });
+    return newsletter || {};
+}
+
+export async function updateNewsletterSettings(config: DepApiConfig, data: { languages: any }) {
+    const client = await config.mongoClient;
+    const db = client.db();
+    await db.collection('newsletters').updateOne(
+        { id: 'welcome_automation' },
+        {
+            $set: {
+                languages: data.languages,
+                updatedAt: new Date(),
+            },
+        },
+        { upsert: true }
+    );
+    return { success: true };
+}
+
+// ============================================================================
+// NOTIFICATIONS ACTIONS
+// ============================================================================
+
+export async function getNotificationStream(
+    config: DepApiConfig,
+    userRole: string,
+    userId: string | null
+) {
+    const client = await config.mongoClient;
+    const db = client.db();
+    const collection = db.collection('notifications');
+
+    const history = await collection
+        .find({
+            removedBy: { $ne: userId },
+            $and: [
+                {
+                    $or: [
+                        { forRole: { $in: [userRole] } },
+                        { forRole: 'all' },
+                        { forRole: { $exists: false } },
+                    ],
+                },
+                { senderId: { $ne: userId } },
+            ],
+        })
+        .sort({ createdAt: -1 })
+        .limit(20)
+        .toArray();
+
+    return {
+        history: history.reverse().map((notif) => ({
+            ...notif,
+            id: notif._id,
+            isRead: notif.readBy?.includes(userId) || false,
+        })),
+        pipeline: [
+            {
+                $match: {
+                    $and: [
+                        { operationType: 'insert' },
+                        {
+                            $or: [
+                                { 'fullDocument.forRole': { $in: [userRole] } },
+                                { 'fullDocument.forRole': 'all' },
+                                { 'fullDocument.forRole': { $exists: false } },
+                            ],
+                        },
+                        { 'fullDocument.senderId': { $ne: userId } },
+                        { 'fullDocument.category': { $in: ['alert', 'feedback', 'system', 'success'] } },
+                    ],
+                },
+            },
+        ],
+    };
+}
+
+export async function updateNotification(
+    config: DepApiConfig,
+    data: { notificationId?: string; action: 'read' | 'remove'; all?: boolean },
+    userId: string
+) {
+    const client = await config.mongoClient;
+    const db = client.db();
+
+    const updateOperation = data.action === 'remove'
+        ? { $addToSet: { removedBy: userId, readBy: userId } }
+        : { $addToSet: { readBy: userId } };
+
+    if (data.all) {
+        await db.collection('notifications').updateMany(
+            {
+                $or: [
+                    { forRole: 'all' },
+                    { forRole: { $exists: false } },
+                ],
+                removedBy: { $ne: userId },
+            },
+            {
+                $addToSet: {
+                    removedBy: userId,
+                    readBy: userId,
+                },
+            }
+        );
+    } else if (data.notificationId) {
+        await db.collection('notifications').updateOne(
+            { _id: new ObjectId(String(data.notificationId)) },
+            updateOperation
+        );
+    }
+
+    // Cleanup old notifications
+    await db.collection('notifications').deleteMany({
+        $or: [
+            { createdAt: { $lt: new Date(Date.now() - 30 * 24 * 60 * 60 * 1000) } },
+            {
+                $and: [
+                    { 'readBy.0': { $exists: true } },
+                    { createdAt: { $lt: new Date(Date.now() - 7 * 24 * 60 * 60 * 1000) } },
+                ],
+            },
+        ],
+    });
+
+    return { success: true };
+}
+
+// ============================================================================
+// TRANSLATION ACTIONS
+// ============================================================================
+
+export async function saveTranslation(
+    config: DepApiConfig,
+    data: { locale: string; messages: Record<string, any> }
+) {
+    if (!data.locale || !data.messages) {
+        throw new Error('Missing locale or messages');
+    }
+
+    const localesDir = config.localesDir || path.join(process.cwd(), 'data/locales');
+    const currentLocaleDir = path.join(localesDir, data.locale);
+
+    if (!fs.existsSync(currentLocaleDir)) {
+        fs.mkdirSync(currentLocaleDir, { recursive: true });
+    }
+
+    for (const [namespace, content] of Object.entries(data.messages)) {
+        const filePath = path.join(currentLocaleDir, `${namespace}.json`);
+        await fs.promises.writeFile(filePath, JSON.stringify(content, null, 2), 'utf8');
+
+        const otherLocales = fs.readdirSync(localesDir).filter((d) => d !== data.locale);
+        for (const other of otherLocales) {
+            const otherFilePath = path.join(localesDir, other, `${namespace}.json`);
+            if (!fs.existsSync(otherFilePath)) {
+                await fs.promises.writeFile(otherFilePath, JSON.stringify({}, null, 2), 'utf8');
+            }
+        }
+    }
+
+    return { success: true };
+}
+
+// ============================================================================
+// STATS ACTIONS
+// ============================================================================
+
+export async function getStorageStats(config: DepApiConfig) {
+    try {
+        const stats = execSync('df -m .').toString().split('\n')[1].split(/\s+/);
+        const totalMB = parseInt(stats[1]);
+        const usedMB = parseInt(stats[2]);
+        const availableMB = parseInt(stats[3]);
+        const percent = (usedMB / totalMB) * 100;
+
+        return {
+            usedMB,
+            totalMB,
+            availableMB,
+            percent: parseFloat(percent.toFixed(1)),
+            unit: 'MB',
+        };
+    } catch (error) {
+        return {
+            usedMB: 0,
+            totalMB: 25000,
+            percent: 0,
+            error: 'Could not read disk',
+        };
+    }
+}
+
+export async function getMediaStats(config: DepApiConfig) {
+    const dirPath = config.uploadsDir || path.join(process.cwd(), 'data/uploads');
+
+    if (!fs.existsSync(dirPath)) {
+        return { totalSizeMB: 0, fileCount: 0 };
+    }
+
+    const files = fs.readdirSync(dirPath);
+    let totalBytes = 0;
+
+    files.forEach((file) => {
+        const stats = fs.statSync(path.join(dirPath, file));
+        totalBytes += stats.size;
+    });
+
+    return {
+        totalSizeMB: (totalBytes / (1024 * 1024)).toFixed(2),
+        fileCount: files.length,
+    };
+}
+
+// ============================================================================
+// VERSION ACTIONS
+// ============================================================================
+
+export async function getVersion() {
+    return { version: process.env.NEXT_PUBLIC_BUILD_ID || Date.now().toString() };
+}
+
+// ============================================================================
+// GITHUB DEPLOYMENT ACTIONS
+// ============================================================================
+
+export async function getDeploymentStatus(config: DepApiConfig) {
+    const flagPath = config.deploymentPaths?.flagPath || '/home/pi/botanics/update-pending.json';
+    if (fs.existsSync(flagPath)) {
+        const data = JSON.parse(fs.readFileSync(flagPath, 'utf8'));
+        return { pending: true, ...data };
+    }
+    return { pending: false };
+}
+
+export async function triggerDeployment(
+    config: DepApiConfig,
+    signature: string,
+    payload?: any
+) {
+    const flagPath = config.deploymentPaths?.flagPath || '/home/pi/botanics/update-pending.json';
+    const scriptPath = config.deploymentPaths?.scriptPath || '/home/pi/botanics/scripts/update.sh';
+
+    if (signature === 'manual') {
+        if (fs.existsSync(flagPath)) {
+            const current = JSON.parse(fs.readFileSync(flagPath, 'utf8'));
+            fs.writeFileSync(flagPath, JSON.stringify({ ...current, status: 'building' }));
+        }
+
+        await createNotification(config, 'Update Gestart', 'De installatie is handmatig gestart.', 'system');
+        executeDeploymentScript(config, scriptPath, flagPath);
+        return { message: 'Deployment started' };
+    }
+
+    if (!config.githubWebhookSecret) {
+        throw new Error('Server configuration error');
+    }
+
+    if (payload?.ref === 'refs/heads/main') {
+        const commitId = payload.after?.substring(0, 7) || '???';
+        const commitMsg = payload.head_commit?.message || 'Nieuwe wijzigingen';
+
+        fs.writeFileSync(flagPath, JSON.stringify({
+            pending: true,
+            at: new Date().toISOString(),
+            commit: commitId,
+        }));
+
+        await createNotification(
+            config,
+            'Update Beschikbaar',
+            `📦 Nieuwe versie: "${commitMsg}" (${commitId}). Klik hier om te installeren.`,
+            'system'
+        );
+
+        return { message: 'Update flagged' };
+    }
+
+    return { message: 'Ignored branch' };
+}
+
+// ============================================================================
+// HELPER FUNCTIONS
+// ============================================================================
+
+async function createNotification(
+    config: DepApiConfig,
+    title: string,
+    description: string,
+    category: string
+) {
+    try {
+        const client = await config.mongoClient;
+        const db = client.db();
+        await db.collection('notifications').insertOne({
+            category,
+            title,
+            description,
+            forRole: ['admin', 'dev'],
+            link: '/dashboard/settings',
+            createdAt: new Date().toISOString(),
+            read: false,
+        });
+    } catch (e) {
+        console.error('Failed to create notification document', e);
+    }
+}
+
+function executeDeploymentScript(
+    config: DepApiConfig,
+    scriptPath: string,
+    flagPath: string
+) {
+    const cmd = `sudo -u pi bash ${scriptPath}`;
+
+    exec(cmd, async (error, stdout, stderr) => {
+        if (!error) {
+            console.log(`Deployment Success: ${stdout}`);
+            if (fs.existsSync(flagPath)) fs.unlinkSync(flagPath);
+            await createNotification(config, 'Update Voltooid', 'De website is succesvol bijgewerkt!', 'success');
+        } else {
+            console.error(`Deployment Error: ${stderr || error.message}`);
+            if (fs.existsSync(flagPath)) {
+                const current = JSON.parse(fs.readFileSync(flagPath, 'utf8'));
+                fs.writeFileSync(flagPath, JSON.stringify({ ...current, status: 'failed' }));
+            }
+            await createNotification(config, 'Update Mislukt', 'De build is mislukt. Probeer het opnieuw vanuit instellingen.', 'alert');
+        }
+    });
+}
+

package/src/config.ts

@@ -0,0 +1,130 @@
+/**
+ * Plugin Deprecated - Auto Setup
+ * Automatically creates API routes in the client app
+ */
+
+import { writeFileSync, mkdirSync, existsSync } from 'fs';
+import { join } from 'path';
+
+/**
+ * Ensure the deprecated API route is set up in the client app
+ */
+/**
+ * @deprecated Routes are now handled by the unified /api/[pluginId]/[...path]/route.ts
+ * This function is kept for backwards compatibility but does nothing
+ */
+export function ensureDepRoutes() {
+    // Routes are now handled by the unified /api/[pluginId]/[...path]/route.ts
+    // No need to generate individual routes anymore
+    return;
+    try {
+        // Find the host app directory (where next.config.ts is)
+        let appDir = process.cwd();
+        const possiblePaths = [
+            appDir,
+            join(appDir, '..'),
+            join(appDir, '..', '..'),
+        ];
+
+        for (const basePath of possiblePaths) {
+            const configPath = join(basePath, 'next.config.ts');
+            if (existsSync(configPath)) {
+                appDir = basePath;
+                break;
+            }
+        }
+
+        const apiDir = join(appDir, 'src', 'app', 'api');
+        const pluginDepApiDir = join(apiDir, 'plugin-dep', '[...path]');
+        const pluginDepApiPath = join(pluginDepApiDir, 'route.ts');
+
+        // Check if route already exists
+        if (existsSync(pluginDepApiPath)) {
+            const fs = require('fs');
+            const existingContent = fs.readFileSync(pluginDepApiPath, 'utf8');
+            if (existingContent.includes('@jhits/plugin-dep') || existingContent.includes('plugin-dep')) {
+                // Already set up, skip
+                return;
+            }
+        }
+
+        // Create plugin-dep API catch-all route
+        mkdirSync(pluginDepApiDir, { recursive: true });
+        writeFileSync(pluginDepApiPath, `// Auto-generated by @jhits/plugin-dep - Deprecated API Plugin
+// This route is automatically created for the deprecated API plugin
+import { NextRequest } from 'next/server';
+import { handleDepApi } from '@jhits/plugin-dep';
+import clientPromise from '@/lib/mongodb';
+import { authOptions } from '@jhits/dashboard/lib/auth';
+import { join } from 'path';
+
+export const dynamic = 'force-dynamic';
+
+async function getConfig() {
+    return {
+        mongoClient: clientPromise,
+        jwtSecret: process.env.JWT_SECRET || 'secret',
+        authOptions,
+        baseUrl: process.env.NEXT_PUBLIC_BASE_URL,
+        githubWebhookSecret: process.env.GITHUB_WEBHOOK_SECRET,
+        deploymentPaths: {
+            flagPath: process.env.DEPLOYMENT_FLAG_PATH || '/home/pi/botanics/update-pending.json',
+            scriptPath: process.env.DEPLOYMENT_SCRIPT_PATH || '/home/pi/botanics/scripts/update.sh',
+        },
+        localesDir: process.env.LOCALES_DIR || join(process.cwd(), 'data/locales'),
+        uploadsDir: process.env.UPLOADS_DIR || join(process.cwd(), 'data/uploads'),
+    };
+}
+
+export async function GET(
+    req: NextRequest,
+    { params }: { params: Promise<{ path: string[] }> }
+) {
+    const { path } = await params;
+    const config = await getConfig();
+    return handleDepApi(req, path, config);
+}
+
+export async function POST(
+    req: NextRequest,
+    { params }: { params: Promise<{ path: string[] }> }
+) {
+    const { path } = await params;
+    const config = await getConfig();
+    return handleDepApi(req, path, config);
+}
+
+export async function PUT(
+    req: NextRequest,
+    { params }: { params: Promise<{ path: string[] }> }
+) {
+    const { path } = await params;
+    const config = await getConfig();
+    return handleDepApi(req, path, config);
+}
+
+export async function PATCH(
+    req: NextRequest,
+    { params }: { params: Promise<{ path: string[] }> }
+) {
+    const { path } = await params;
+    const config = await getConfig();
+    return handleDepApi(req, path, config);
+}
+
+export async function DELETE(
+    req: NextRequest,
+    { params }: { params: Promise<{ path: string[] }> }
+) {
+    const { path } = await params;
+    const config = await getConfig();
+    return handleDepApi(req, path, config);
+}
+`);
+
+    } catch (error) {
+        // Ignore errors - route might already exist or app structure is different
+        console.warn('[plugin-dep] Could not ensure deprecated routes:', error);
+    }
+}
+

package/src/index.server.ts

@@ -0,0 +1,20 @@
+import 'server-only';
+
+/**
+ * Plugin Deprecated - Server-Only Entry Point
+ * Re-exports server-side API handlers and business logic
+ * 
+ * Note: This file is server-only (no 'use server' needed - that's only for Server Actions)
+ */
+
+// Export router (main API handler)
+export { handleDepApi as handleApi } from './router';
+
+// Export actions (business logic)
+export * as actions from './actions';
+
+// Export types
+export * from './types';
+
+// Note: Config functions are server-only and not exported to avoid client-side import errors
+// They are deprecated anyway since routes are now handled by the unified route system

package/src/router.ts

@@ -0,0 +1,391 @@
+'use server';
+
+/**
+ * Plugin Deprecated - Router
+ * Framework-agnostic router that routes API requests to business logic actions
+ * 
+ * SERVER-ONLY: This module must never be imported by client code
+ */
+
+import 'server-only';
+
+import { NextRequest, NextResponse } from 'next/server';
+import { DepApiConfig } from './types';
+import * as actions from './actions';
+import { verifyToken } from './utils/auth';
+import crypto from 'crypto';
+
+/**
+ * Handle deprecated API requests
+ * Routes requests to appropriate action handlers based on path and method
+ */
+export async function handleDepApi(
+    req: NextRequest,
+    path: string[],
+    config: DepApiConfig
+): Promise<NextResponse> {
+    const method = req.method;
+    const route = path[0] || '';
+
+    try {
+        // ====================================================================
+        // AUTH ROUTES
+        // ====================================================================
+        if (route === 'me') {
+            if (method === 'GET') {
+                let session: any = null;
+                if (config.authOptions) {
+                    const { getServerSession } = await import('next-auth');
+                    session = await getServerSession(config.authOptions);
+                }
+                const result = await actions.getMe(config, session);
+                return NextResponse.json(result);
+            }
+        }
+
+        // ====================================================================
+        // FEEDBACK ROUTES
+        // ====================================================================
+        else if (route === 'feedback') {
+            if (path[1]) {
+                // /api/plugin-dep/feedback/[id]
+                const id = path[1];
+                if (method === 'PATCH') {
+                    const body = await req.json();
+                    const result = await actions.updateFeedback(config, id, body);
+                    return NextResponse.json(result);
+                } else if (method === 'DELETE') {
+                    const result = await actions.deleteFeedback(config, id);
+                    return NextResponse.json(result);
+                }
+            } else {
+                // /api/plugin-dep/feedback
+                if (method === 'GET') {
+                    const result = await actions.listFeedback(config);
+                    return NextResponse.json(result);
+                } else if (method === 'POST') {
+                    const body = await req.json();
+                    const cookies = await req.cookies;
+                    const token = cookies.get('auth_token')?.value;
+                    let userId: string | undefined;
+                    if (token) {
+                        const payload = verifyToken(token, config.jwtSecret);
+                        if (payload && typeof payload !== 'string') {
+                            userId = payload.id;
+                        }
+                    }
+                    const result = await actions.createFeedback(config, body, userId);
+                    return NextResponse.json(result);
+                }
+            }
+        }
+
+        // ====================================================================
+        // SETTINGS ROUTES
+        // ====================================================================
+        else if (route === 'settings') {
+            if (path[1] === 'maintenance') {
+                // /api/plugin-dep/settings/maintenance
+                if (method === 'GET') {
+                    const result = await actions.getMaintenanceMode(config);
+                    return NextResponse.json(result);
+                } else if (method === 'POST') {
+                    const body = await req.json();
+                    const result = await actions.setMaintenanceMode(config, body.active);
+                    return NextResponse.json(result);
+                }
+            } else {
+                // /api/plugin-dep/settings
+                if (method === 'GET') {
+                    const result = await actions.getSettings(config);
+                    return NextResponse.json(result);
+                } else if (method === 'POST') {
+                    const body = await req.json();
+                    const result = await actions.updateSettings(config, body);
+                    return NextResponse.json(result);
+                }
+            }
+        }
+
+        // ====================================================================
+        // USER ROUTES
+        // ====================================================================
+        else if (route === 'users') {
+            if (path[1]) {
+                // /api/plugin-dep/users/[id]
+                const id = path[1];
+                if (method === 'PATCH') {
+                    const body = await req.json();
+                    const result = await actions.updateUser(config, id, body);
+                    return NextResponse.json(result);
+                } else if (method === 'DELETE') {
+                    const result = await actions.deleteUser(config, id);
+                    return NextResponse.json(result);
+                }
+            } else {
+                // /api/plugin-dep/users
+                if (method === 'GET') {
+                    const result = await actions.listUsers(config);
+                    return NextResponse.json(result);
+                } else if (method === 'POST') {
+                    const body = await req.json();
+                    const result = await actions.createUser(config, body);
+                    return NextResponse.json(result);
+                }
+            }
+        }
+
+        // ====================================================================
+        // NEWSLETTER ROUTES
+        // ====================================================================
+        else if (route === 'newsletter') {
+            if (path[1] === 'subscribers') {
+                if (path[2]) {
+                    // /api/plugin-dep/newsletter/subscribers/[user]
+                    const email = decodeURIComponent(path[2]).toLowerCase();
+                    if (method === 'GET') {
+                        const result = await actions.getSubscriber(config, email);
+                        return NextResponse.json(result);
+                    } else if (method === 'DELETE') {
+                        const result = await actions.deleteSubscriber(config, email);
+                        return NextResponse.json(result);
+                    }
+                } else {
+                    // /api/plugin-dep/newsletter/subscribers
+                    if (method === 'GET') {
+                        const result = await actions.listSubscribers(config);
+                        return NextResponse.json(result);
+                    } else if (method === 'POST') {
+                        const body = await req.json();
+                        const headers = await req.headers;
+                        const host = headers.get('host') || undefined;
+                        const result = await actions.subscribeNewsletter(config, body, host);
+                        return NextResponse.json(result, { status: 201 });
+                    }
+                }
+            } else if (path[1] === 'settings') {
+                // /api/plugin-dep/newsletter/settings
+                if (method === 'GET') {
+                    const result = await actions.getNewsletterSettings(config);
+                    return NextResponse.json(result);
+                } else if (method === 'POST') {
+                    const body = await req.json();
+                    const result = await actions.updateNewsletterSettings(config, body);
+                    return NextResponse.json(result);
+                }
+            }
+        }
+
+        // ====================================================================
+        // NOTIFICATIONS ROUTES
+        // ====================================================================
+        else if (route === 'notifications') {
+            if (path[1] === 'stream') {
+                // /api/plugin-dep/notifications/stream
+                if (method === 'GET') {
+                    return handleNotificationStream(req, config);
+                }
+            } else if (path[1] === 'action') {
+                // /api/plugin-dep/notifications/action
+                if (method === 'POST') {
+                    const body = await req.json();
+                    const cookies = await req.cookies;
+                    const token = cookies.get('auth_token')?.value;
+                    if (!token) {
+                        return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+                    }
+                    const payload = verifyToken(token, config.jwtSecret);
+                    if (!payload || typeof payload === 'string') {
+                        return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+                    }
+                    const result = await actions.updateNotification(config, body, payload.id);
+                    return NextResponse.json(result);
+                }
+            }
+        }
+
+        // ====================================================================
+        // TRANSLATION ROUTES
+        // ====================================================================
+        else if (route === 'save-translation') {
+            if (method === 'POST') {
+                const body = await req.json();
+                const result = await actions.saveTranslation(config, body);
+                return NextResponse.json(result);
+            }
+        }
+
+        // ====================================================================
+        // STATS ROUTES
+        // ====================================================================
+        else if (route === 'stats') {
+            if (path[1] === 'storage') {
+                // /api/plugin-dep/stats/storage
+                if (method === 'GET') {
+                    const result = await actions.getStorageStats(config);
+                    return NextResponse.json(result);
+                }
+            }
+        } else if (route === 'media') {
+            if (path[1] === 'stats') {
+                // /api/plugin-dep/media/stats
+                if (method === 'GET') {
+                    const result = await actions.getMediaStats(config);
+                    return NextResponse.json(result);
+                }
+            }
+        }
+
+        // ====================================================================
+        // VERSION ROUTES
+        // ====================================================================
+        else if (route === 'version') {
+            if (method === 'GET') {
+                const result = await actions.getVersion();
+                return NextResponse.json(result);
+            }
+        }
+
+        // ====================================================================
+        // GITHUB DEPLOYMENT ROUTES
+        // ====================================================================
+        else if (route === 'github') {
+            if (path[1] === 'deploy') {
+                // /api/plugin-dep/github/deploy
+                if (method === 'GET') {
+                    const result = await actions.getDeploymentStatus(config);
+                    return NextResponse.json(result);
+                } else if (method === 'POST') {
+                    const signature = req.headers.get('x-hub-signature-256') || '';
+                    let payload: any = null;
+                    if (signature !== 'manual') {
+                        const rawBody = await req.text();
+                        const secret = config.githubWebhookSecret;
+                        if (!secret) {
+                            return NextResponse.json({ error: 'Server configuration error' }, { status: 500 });
+                        }
+                        const hmac = crypto.createHmac('sha256', secret);
+                        const digest = 'sha256=' + hmac.update(rawBody).digest('hex');
+                        if (signature !== digest) {
+                            return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+                        }
+                        payload = rawBody.startsWith('payload=')
+                            ? JSON.parse(decodeURIComponent(rawBody.substring(8)))
+                            : JSON.parse(rawBody);
+                    }
+                    const result = await actions.triggerDeployment(config, signature, payload);
+                    return NextResponse.json(result);
+                }
+            }
+        }
+
+        // Method not allowed
+        return NextResponse.json(
+            { error: `Method ${method} not allowed for route: ${route || '/'}` },
+            { status: 405 }
+        );
+    } catch (error: any) {
+        console.error('[DepApiRouter] Error:', error);
+        const status = error.message?.includes('not found') ? 404
+            : error.message?.includes('Unauthorized') ? 401
+            : error.message?.includes('already') ? 409
+            : error.message?.includes('too short') ? 400
+            : 500;
+        return NextResponse.json(
+            { error: error.message || 'Internal server error' },
+            { status }
+        );
+    }
+}
+
+/**
+ * Handle Server-Sent Events stream for notifications
+ */
+async function handleNotificationStream(
+    req: NextRequest,
+    config: DepApiConfig
+): Promise<NextResponse> {
+    const encoder = new TextEncoder();
+    const cookies = await req.cookies;
+    const token = cookies.get('auth_token')?.value;
+
+    let userRole = 'guest';
+    let currentUserId: string | null = null;
+
+    if (token) {
+        try {
+            const payload = verifyToken(token, config.jwtSecret);
+            if (payload && typeof payload !== 'string') {
+                userRole = payload.role || 'guest';
+                currentUserId = payload.id;
+            }
+        } catch (e) {
+            console.error('Token verification failed in stream');
+        }
+    }
+
+    let changeStream: any;
+
+    const stream = new ReadableStream({
+        async start(controller) {
+            try {
+                const client = await config.mongoClient;
+                const db = client.db();
+                const collection = db.collection('notifications');
+
+                const streamData = await actions.getNotificationStream(config, userRole, currentUserId);
+
+                // Send history
+                streamData.history.forEach((notif) => {
+                    controller.enqueue(encoder.encode(`data: ${JSON.stringify(notif)}\n\n`));
+                });
+
+                // Send connection status
+                controller.enqueue(encoder.encode(`data: ${JSON.stringify({ status: 'connected', role: userRole })}\n\n`));
+
+                // Watch for changes
+                changeStream = collection.watch(streamData.pipeline, { fullDocument: 'updateLookup' });
+
+                changeStream.on('change', (change: any) => {
+                    if (change.operationType === 'insert') {
+                        const data = `data: ${JSON.stringify(change.fullDocument)}\n\n`;
+                        controller.enqueue(encoder.encode(data));
+                    }
+                });
+
+                const keepAlive = setInterval(() => {
+                    try {
+                        controller.enqueue(encoder.encode(': keep-alive\n\n'));
+                    } catch {
+                        clearInterval(keepAlive);
+                    }
+                }, 20000);
+
+                changeStream.on('error', (err: any) => {
+                    console.error('Mongo Stream Error:', err);
+                    clearInterval(keepAlive);
+                    if (changeStream) changeStream.close();
+                });
+            } catch (err) {
+                console.error('Stream Start Error:', err);
+                controller.error(err);
+            }
+        },
+        cancel() {
+            if (changeStream) {
+                changeStream.close();
+                console.log(`Stream connection closed for role: ${userRole}`);
+            }
+        },
+    });
+
+    return new NextResponse(stream, {
+        headers: {
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache, no-transform',
+            Connection: 'keep-alive',
+            'X-Accel-Buffering': 'no',
+        },
+    });
+}
+

package/src/types.ts

@@ -0,0 +1,50 @@
+/**
+ * Plugin Deprecated - Types
+ * Type definitions for deprecated client API routes
+ */
+
+import { MongoClient } from 'mongodb';
+import { NextRequest } from 'next/server';
+
+export interface DepApiConfig {
+    /** MongoDB client promise */
+    mongoClient: Promise<MongoClient>;
+    /** JWT secret for token verification */
+    jwtSecret: string;
+    /** NextAuth auth options (for session-based auth) */
+    authOptions?: any;
+    /** Base URL for email links */
+    baseUrl?: string;
+    /** GitHub webhook secret */
+    githubWebhookSecret?: string;
+    /** Paths for deployment scripts */
+    deploymentPaths?: {
+        flagPath: string;
+        scriptPath: string;
+    };
+    /** Locales directory path */
+    localesDir?: string;
+    /** Uploads directory path */
+    uploadsDir?: string;
+}
+
+export interface ApiRequest {
+    method: string;
+    url: string;
+    body?: any;
+    headers: Headers;
+    cookies?: Map<string, string>;
+}
+
+export interface ApiResponse {
+    status: number;
+    body: any;
+    headers?: Record<string, string>;
+}
+
+export type ApiHandler = (
+    req: ApiRequest,
+    config: DepApiConfig,
+    params?: Record<string, string>
+) => Promise<ApiResponse>;
+

package/src/utils/auth.ts

@@ -0,0 +1,20 @@
+/**
+ * Auth utilities for plugin-dep
+ */
+
+import jwt from 'jsonwebtoken';
+
+export interface AuthPayload {
+    id: string;
+    email: string;
+    role: string;
+}
+
+export function verifyToken(token: string, secret: string): AuthPayload | null {
+    try {
+        return jwt.verify(token, secret) as AuthPayload;
+    } catch {
+        return null;
+    }
+}
+