@jhits/dashboard 0.0.1

package/src/config.ts

@@ -0,0 +1,230 @@
+// packages/jhits-dashboard/src/config.ts
+import type { NextConfig } from "next";
+import { writeFileSync, mkdirSync, existsSync, readFileSync } from "fs";
+import { join } from "path";
+
+/**
+ * Automatically creates a catch-all route that handles dashboard routes
+ * This runs at build time when withJhitsDashboard() is called
+ * No dashboard folder needed - routes are handled via catch-all at [locale] level
+ */
+async function ensureDashboardRoutes() {
+    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 localeDir = join(appDir, 'src', 'app', '[locale]');
+        const catchAllDir = join(localeDir, '[...path]');
+        const catchAllPath = join(catchAllDir, 'page.tsx');
+
+        // Check if catch-all already exists
+        if (existsSync(catchAllPath)) {
+            // Read existing file and check if it already handles dashboard
+            const fs = await import('fs');
+            const existingContent = fs.readFileSync(catchAllPath, 'utf8');
+            if (existingContent.includes('@jhits/dashboard') || existingContent.includes('DashboardRouter')) {
+                // Already set up, skip
+                return;
+            }
+            // If it exists but doesn't handle dashboard, we need to modify it
+            // Read the file and prepend dashboard handling
+            const dashboardHandler = `
+    // Dashboard route handling (auto-added by @jhits/dashboard)
+    if (path.length > 0 && path[0] === 'dashboard') {
+        const { DashboardRouter, DashboardRouterLayout } = await import('@jhits/dashboard');
+        const dashboardPath = path.slice(1);
+        return (
+            <DashboardRouterLayout>
+                <DashboardRouter path={dashboardPath} params={Promise.resolve({ locale: resolvedParams.locale })} />
+            </DashboardRouterLayout>
+        );
+    }
+`;
+            // Insert dashboard handling at the beginning of the function body
+            const modifiedContent = existingContent.replace(
+                /(export default async function \w+\([^)]+\) \{[\s\S]*?const resolvedParams = await props\.params;[\s\S]*?const path = resolvedParams\.path \|\| \[\];)/,
+                `$1${dashboardHandler}`
+            );
+
+            if (modifiedContent !== existingContent) {
+                fs.writeFileSync(catchAllPath, modifiedContent);
+            } else {
+                // If replacement didn't work, append at a safe location
+                const safeInsertPoint = existingContent.indexOf('const path = resolvedParams.path');
+                if (safeInsertPoint > -1) {
+                    const before = existingContent.substring(0, safeInsertPoint);
+                    const after = existingContent.substring(safeInsertPoint);
+                    const newContent = before + dashboardHandler.trim() + '\n    ' + after;
+                    fs.writeFileSync(catchAllPath, newContent);
+                }
+            }
+            return;
+        }
+
+        // Create new catch-all route that handles dashboard routes
+        mkdirSync(catchAllDir, { recursive: true });
+        writeFileSync(catchAllPath, `// Auto-generated by @jhits/dashboard - do not edit manually
+export { default } from '@jhits/dashboard/catch-all';
+`);
+    } catch (error) {
+        // Silently fail - routes might already exist or be manually created
+    }
+}
+
+/**
+ * Dynamically find all @jhits/* packages from package.json
+ * Reads dependencies and devDependencies to build transpilePackages list
+ * 
+ * This function finds the app's package.json by looking for next.config.ts
+ * in the same directory, ensuring we read from the correct location in monorepos
+ */
+function findJhitsPackages(): string[] {
+    try {
+        // Find the app directory (where next.config.ts is located)
+        const appDir = process.cwd();
+        const possiblePaths = [
+            appDir,
+            join(appDir, '..'),
+            join(appDir, '..', '..'),
+        ];
+
+        let packageJsonPath: string | null = null;
+
+        for (const basePath of possiblePaths) {
+            const configPath = join(basePath, 'next.config.ts');
+            const pkgPath = join(basePath, 'package.json');
+            if (existsSync(configPath) && existsSync(pkgPath)) {
+                packageJsonPath = pkgPath;
+                break;
+            }
+        }
+
+        // Fallback to process.cwd() if we can't find next.config.ts
+        if (!packageJsonPath) {
+            packageJsonPath = join(process.cwd(), 'package.json');
+        }
+
+        if (!existsSync(packageJsonPath)) {
+            // Fallback to wildcard if package.json not found
+            return ['@jhits'];
+        }
+
+        // Use readFileSync instead of require() to avoid module resolution issues
+        const packageJsonContent = readFileSync(packageJsonPath, 'utf-8');
+        const packageJson = JSON.parse(packageJsonContent);
+
+        const allDeps = {
+            ...(packageJson.dependencies || {}),
+            ...(packageJson.devDependencies || {}),
+        };
+
+        // Filter for packages starting with @jhits/
+        const jhitsPackages = Object.keys(allDeps).filter(
+            (pkg) => pkg.startsWith('@jhits/')
+        );
+
+        // Always include the base @jhits pattern for any other packages
+        return jhitsPackages.length > 0 ? jhitsPackages : ['@jhits'];
+    } catch (error) {
+        // Fallback to wildcard on any error
+        console.warn('[withJhitsDashboard] Could not read package.json, using @jhits wildcard');
+        return ['@jhits'];
+    }
+}
+
+/**
+ * JHITS Dashboard Plugin Configuration
+ * 
+ * Usage:
+ *   import { withJhitsDashboard } from '@jhits/dashboard/config';
+ *   export default withJhitsDashboard(nextConfig);
+ * 
+ * This automatically sets up all dashboard routes - no manual setup needed!
+ */
+export function withJhitsDashboard(nextConfig: NextConfig = {}): NextConfig {
+    // Auto-create dashboard routes at build time
+    // NOTE: User management routes are now handled by plugin-users via the unified plugin router
+    // No need to auto-generate /api/users routes anymore
+    if (typeof window === 'undefined') {
+        try {
+            ensureDashboardRoutes();
+            // ensureUserManagementRoutes(); // Disabled - routes are handled by plugin-users via plugin router
+        } catch (error) {
+            // Ignore errors - routes might already exist
+        }
+    }
+
+    return {
+        ...nextConfig,
+
+        // 1. AUTO-TRANSPILE: Dynamically find all @jhits/* packages from package.json
+        // This ensures Turbopack knows exactly which workspace folders to link
+        transpilePackages: [
+            ...(nextConfig.transpilePackages || []),
+            ...findJhitsPackages()
+        ],
+
+        experimental: {
+            ...nextConfig.experimental,
+            // 2. MONOREPO RESOLUTION: This is the secret sauce. 
+            // It allows Next.js to follow symlinks in the pnpm workspace 
+            // even if they aren't explicitly listed.
+            externalDir: true,
+        },
+
+        // Exclude server-only third-party packages from client bundles
+        // Note: @jhits/* packages should NOT be here - they're in transpilePackages instead
+        // Adding them here would conflict with transpilePackages in Turbopack
+        serverExternalPackages: [
+            ...(nextConfig.serverExternalPackages || []),
+            'mongodb',
+            'bcrypt',
+            'bcryptjs',
+            'jsonwebtoken',
+            'nodemailer'
+        ],
+
+        webpack: (config, { isServer }) => {
+            // Ensure Node.js modules are not bundled for client
+            if (!isServer) {
+                config.resolve.fallback = {
+                    ...config.resolve.fallback,
+                    fs: false,
+                    path: false,
+                    'fs/promises': false,
+                    child_process: false,
+                    net: false,
+                    tls: false,
+                    crypto: false,
+                };
+
+                // Prevent server-only plugins from being bundled into client
+                // plugin-dep is server-only and should never be imported by client code
+                config.externals = config.externals || [];
+                if (Array.isArray(config.externals)) {
+                    config.externals.push('@jhits/plugin-dep');
+                } else if (typeof config.externals === 'object') {
+                    config.externals['@jhits/plugin-dep'] = '@jhits/plugin-dep';
+                }
+            }
+            return config;
+        },
+
+        // Routes are automatically created and managed by the plugin
+        // The dashboard folder is completely transparent - you never need to touch it
+        // Just use withJhitsDashboard() and everything works!
+    };
+}

package/src/i18n/navigation.ts

@@ -0,0 +1,7 @@
+import { createNavigation } from 'next-intl/navigation';
+import { routing } from './routing';
+
+// Lightweight wrappers around Next.js' navigation
+// APIs that consider the routing configuration
+export const { Link, redirect, usePathname, useRouter, getPathname } = createNavigation(routing);
+

package/src/i18n/request.ts

@@ -0,0 +1,41 @@
+import { getRequestConfig } from 'next-intl/server';
+import { routing } from './routing';
+import { PLATFORM_MODULES } from '../lib/modules-config';
+
+export default getRequestConfig(async ({ requestLocale }) => {
+    let locale = await requestLocale;
+
+    if (!locale || !routing.locales.includes(locale as "en" | "nl" | "sv")) {
+        locale = routing.defaultLocale;
+    }
+
+    // 1. LOAD COMMON (Must-have)
+    const common = (await import(`../assets/locales/${locale}/common.json`)).default;
+
+    // 2. LOAD MODULES (Optional/Modular)
+    const moduleMessages: Record<string, Record<string, string>> = {};
+
+    // We map through our registry and try to fetch the JSON for each
+    await Promise.all(
+        PLATFORM_MODULES.map(async (mod) => {
+            try {
+                // We use a template string that is specific enough for Webpack to follow
+                const modFile = await import(`../assets/locales/${locale}/${mod.namespace}.json`);
+                moduleMessages[mod.namespace] = modFile.default;
+            } catch (e) {
+                // If the file doesn't exist, we just provide an empty object
+                // This prevents the "Module Not Found" crash
+                moduleMessages[mod.namespace] = {};
+                console.info(`Optional module [${mod.namespace}] not found for locale [${locale}]`);
+            }
+        })
+    );
+
+    return {
+        locale,
+        messages: {
+            common,
+            ...moduleMessages // Spreads all optional modules into the root
+        }
+    };
+});

package/src/i18n/routing.ts

@@ -0,0 +1,35 @@
+import { defineRouting } from 'next-intl/routing';
+import { createNavigation } from 'next-intl/navigation';
+import { PLATFORM_MODULES } from '../lib/modules-config';
+
+// 1. Transform the modules array into the format next-intl expects
+const dynamicPathnames: Record<string, Record<string, string>> = {
+    '/': {
+        en: '/',
+        nl: '/',
+        sv: '/'
+    },
+    '/login': {
+        en: '/login',
+        nl: '/login',
+        sv: '/login'
+    },
+};
+
+PLATFORM_MODULES.forEach((mod) => {
+    dynamicPathnames[mod.path] = {
+        en: mod.aliases.en,
+        nl: mod.aliases.nl || mod.aliases.en, // Fallback to English
+        sv: mod.aliases.sv || mod.aliases.en
+    };
+});
+
+// 2. Define routing using the dynamic object
+export const routing = defineRouting({
+    locales: ['en', 'nl', 'sv'],
+    defaultLocale: 'en',
+    localePrefix: 'never',
+    pathnames: dynamicPathnames
+});
+
+export const { Link, redirect, usePathname, useRouter } = createNavigation(routing);

package/src/i18n/translations.ts

@@ -0,0 +1,20 @@
+// Export function to load dashboard translations
+// This allows host apps to merge dashboard translations into their own messages
+
+export async function getDashboardMessages(locale: string): Promise<Record<string, Record<string, string>>> {
+    try {
+        // Load dashboard common translations
+        const common = (await import(`../assets/locales/${locale}/common.json`)).default;
+        
+        // Return translations in the format expected by next-intl
+        // The common object contains dashboard, sidebar, etc. keys
+        // This will be merged into the host app's common namespace
+        return {
+            common
+        };
+    } catch (error) {
+        console.warn(`Dashboard translations not found for locale: ${locale}`, error);
+        return {};
+    }
+}
+

package/src/index.tsx

@@ -0,0 +1,69 @@
+// Main export file for the dashboard plugin
+// This exports all the dashboard components and pages that can be used by host apps
+
+// Router components - inlined to avoid module resolution issues
+import DashboardLayout from './app/[locale]/dashboard/layout';
+import DashboardHome from './app/[locale]/dashboard/page';
+import DashboardPreferences from './app/[locale]/dashboard/preferences/page';
+import DashboardProfile from './app/[locale]/dashboard/profile/page';
+import DashboardPluginRoute from './app/[locale]/dashboard/[...pluginRoute]/page';
+
+export async function DashboardRouter({ 
+    path, 
+    params 
+}: { 
+    path: string[];
+    params: Promise<{ locale: string }>;
+}) {
+    const resolvedParams = await params;
+    const locale = resolvedParams.locale;
+    
+    // Get the actual route (first segment of path)
+    const route = path.length === 0 ? 'home' : path[0];
+    
+    // Handle different dashboard routes
+    switch (route) {
+        case 'preferences':
+            return <DashboardPreferences />;
+        case 'profile':
+            return <DashboardProfile />;
+        case 'home':
+        case '':
+            return <DashboardHome />;
+        default:
+            // This is a plugin route - pass the full path as pluginRoute
+            return <DashboardPluginRoute params={Promise.resolve({ 
+                locale, 
+                pluginRoute: path 
+            })} />;
+    }
+}
+
+// Layout wrapper
+export function DashboardRouterLayout({ children }: { children: React.ReactNode }) {
+    return <DashboardLayout>{children}</DashboardLayout>;
+}
+
+// Components (for advanced usage)
+export { default as Sidebar } from './components/dashboard/Sidebar';
+export { default as Topbar } from './components/dashboard/Topbar';
+export { PluginNotFound } from './components/PluginNotFound';
+export { Providers, AuthGuard } from './components/Providers';
+
+// Plugin system
+export { PluginRegistry } from './lib/plugin-registry';
+export { PLATFORM_MODULES } from './lib/modules-config';
+
+// Config
+export { withJhitsDashboard } from './config';
+
+// Translations
+export { getDashboardMessages } from './i18n/translations';
+
+// Catch-all route handler (for client app integration)
+export { default as DashboardCatchAll } from './components/DashboardCatchAll';
+
+// Website context (for accessing website info in dashboard components)
+export { WebsiteProvider, useWebsite } from './lib/website-context';
+export type { WebsiteInfo } from './lib/website-context';
+

package/src/lib/auth.ts

@@ -0,0 +1,159 @@
+import { NextAuthOptions, Session } from "next-auth";
+import CredentialsProvider from "next-auth/providers/credentials";
+import clientPromise from "./mongodb";
+import bcrypt from "bcrypt";
+
+export const authOptions: NextAuthOptions = {
+    providers: [
+        CredentialsProvider({
+            name: "Credentials",
+            credentials: {
+                email: { label: "Email", type: "email" },
+                password: { label: "Password", type: "password" }
+            },
+            async authorize(credentials, req) {
+                if (!credentials?.email || !credentials?.password) return null;
+
+                const client = await clientPromise;
+                const db = client.db();
+
+                const user = await db.collection("users").findOne({
+                    email: credentials.email
+                });
+
+                if (!user) return null;
+
+                const isPasswordValid = await bcrypt.compare(
+                    credentials.password,
+                    user.password
+                );
+
+                if (!isPasswordValid) return null;
+
+                // --- LOG ACTIVITY ---
+                const userAgent = req?.headers?.["user-agent"] || "Unknown";
+                const ip = req?.headers?.["x-forwarded-for"] || "127.0.0.1";
+
+                await db.collection("user_activities").updateOne(
+                    { userId: user._id.toString(), userAgent: userAgent },
+                    {
+                        $set: {
+                            userId: user._id.toString(),
+                            userAgent,
+                            ip,
+                            lastActive: new Date()
+                        }
+                    },
+                    { upsert: true }
+                );
+
+                // Return object becomes the initial 'user' in the JWT callback
+                return {
+                    id: user._id.toString(),
+                    email: user.email,
+                    name: user.name,
+                    role: user.role || "user",
+                    image: user.image || null
+                };
+            }
+        })
+    ],
+    callbacks: {
+        async jwt({ token, user, trigger, session }) {
+            // 1. INITIAL LOGIN: Transfer data from 'user' (from authorize) to 'token'
+            if (user) {
+                token.id = user.id;
+                token.role = (user as unknown as { role: string }).role;
+                token.image = user.image;
+
+                // Capture User Agent on the server side to stick it into the JWT
+                if (typeof window === 'undefined') {
+                    const { headers } = await import('next/headers');
+                    const headersList = await headers();
+                    token.userAgent = headersList.get("user-agent");
+                }
+            }
+
+            // 2. CLIENT-SIDE UPDATE: When you call update({ user: { image: '...' } })
+            if (trigger === "update" && session?.user) {
+                if (session.user.name) token.name = session.user.name;
+                if (session.user.email) token.email = session.user.email;
+                if (session.user.role) token.role = session.user.role;
+
+                // This is the specific fix for your Topbar image
+                if (session.user.image !== undefined) {
+                    token.image = session.user.image;
+                }
+            }
+
+            return token;
+        },
+
+        async session({ session, token }) {
+            try {
+                // --- SECURITY CHECK: DATABASE VALIDATION ---
+                // This runs every time the session is checked.
+                const client = await clientPromise;
+                const db = client.db();
+
+                const activeSession = await db.collection("user_activities").findOne({
+                    userId: token.id as string,
+                    userAgent: token.userAgent as string
+                });
+
+                // If the record was deleted (revoked from Profile page), log them out
+                if (!activeSession) {
+                    return null as unknown as Session;
+                }
+
+                // 3. MAP TOKEN TO SESSION: Make data available in useSession()
+                if (session.user) {
+                    (session.user as unknown as { id: string }).id = token.id as string;
+                    (session.user as unknown as { role: string }).role = token.role as string;
+                    session.user.name = token.name as string;
+                    session.user.email = token.email as string;
+                    session.user.image = token.image as string | null; // Topbar UI reads this
+                }
+
+                return session;
+            } catch (error) {
+                // If there's any error (including JWT decryption failures), return null to invalidate session
+                console.error("Session callback error:", error);
+                return null as unknown as Session;
+            }
+        }
+    },
+    session: {
+        strategy: "jwt",
+        maxAge: 30 * 24 * 60 * 60, // 30 Days
+    },
+    pages: {
+        signIn: '/login'
+    },
+    secret: (() => {
+        const secret = process.env.NEXTAUTH_SECRET;
+        if (!secret) {
+            console.warn('[NextAuth] Warning: NEXTAUTH_SECRET is not set. Using fallback secret. This should be set in production!');
+            return 'fallback-secret-change-in-production-' + Date.now();
+        }
+        return secret;
+    })(),
+    debug: process.env.NODE_ENV === 'development',
+    // Custom logger to suppress JWT decryption errors (happens with old/invalid session cookies)
+    logger: {
+        error: (code: string, metadata: Error | { [key: string]: unknown; error: Error }) => {
+            // Suppress JWT_SESSION_ERROR for decryption failures (old/invalid cookies)
+            if (code === 'JWT_SESSION_ERROR') {
+                const errorMessage = metadata instanceof Error 
+                    ? metadata.message 
+                    : (metadata as { message?: string })?.message || '';
+                if (errorMessage.includes('decryption')) {
+                    // Silently ignore - user will need to log in again
+                    return;
+                }
+            }
+            // Log all other errors
+            console.error(`[next-auth][error][${code}]`, metadata);
+        }
+    }
+};

package/src/lib/db.ts

@@ -0,0 +1,11 @@
+// apps/dashboard/lib/db.ts
+
+// Mock implementation - Replace with your actual database call (Prisma, Drizzle, Supabase, etc.)
+export async function getSiteConfig(siteId: string) {
+    // In a real app: return await db.siteConfigs.findUnique({ where: { siteId } });
+    return {
+        siteId,
+        // This list determines what actually "renders" in the catch-all route
+        installedPlugins: ["blog-system", "analytics-pro"],
+    };
+}

package/src/lib/get-website-info.ts

@@ -0,0 +1,78 @@
+import { headers } from 'next/headers';
+import type { WebsiteInfo } from './website-context';
+import clientPromise from './mongodb';
+
+/**
+ * Gets website information from the host app
+ * This function reads from headers set by the host app's middleware
+ * Host apps should set x-site-name and x-site-tagline headers in their middleware
+ * Also fetches logo information from the client app's settings
+ */
+export async function getWebsiteInfo(locale: string): Promise<WebsiteInfo> {
+    try {
+        const headersList = await headers();
+        const host = headersList.get('host') || '';
+        const protocol = headersList.get('x-forwarded-proto') || 
+                        (process.env.NODE_ENV === 'production' ? 'https' : 'http');
+        
+        // Get website info from headers (set by host app's middleware)
+        const siteName = headersList.get('x-site-name') || 
+                        process.env.NEXT_PUBLIC_SITE_NAME || 
+                        'Website';
+        const siteTagline = headersList.get('x-site-tagline') || 
+                           process.env.NEXT_PUBLIC_SITE_TAGLINE || 
+                           '';
+        
+        // Construct the base URL for the website home page
+        const baseUrl = `${protocol}://${host}`;
+        const homeUrl = locale === 'en' ? baseUrl : `${baseUrl}/${locale}`;
+        
+        // Try to fetch logo from client app's settings
+        let logo: { light: string; dark: string } | undefined;
+        try {
+            const client = await clientPromise;
+            const db = client.db();
+            const settings = await db.collection("settings").findOne({ identifier: "site_config" });
+            
+            if (settings) {
+                // Check if logo paths are stored in settings
+                // Common patterns: LogoIcon.svg, LogoIcon-inverted.svg, or custom paths
+                // Also check for common logo file names used in client apps
+                const logoLight = settings.logoLight || 
+                                 settings.logo?.light || 
+                                 '/LogoIcon.svg';
+                const logoDark = settings.logoDark || 
+                                settings.logo?.dark || 
+                                '/LogoIcon-inverted.svg';
+                
+                // Only set logo if at least one path exists
+                if (logoLight || logoDark) {
+                    logo = {
+                        light: logoLight || logoDark || '/LogoIcon.svg', // Fallback to dark if light not found
+                        dark: logoDark || logoLight || '/LogoIcon-inverted.svg' // Fallback to light if dark not found
+                    };
+                }
+            }
+        } catch (dbError) {
+            // If database fetch fails, continue without logo
+            console.warn('Failed to fetch logo from settings:', dbError);
+        }
+        
+        return {
+            name: siteName,
+            tagline: siteTagline,
+            homeUrl: homeUrl,
+            locale,
+            logo
+        };
+    } catch (error) {
+        // Fallback
+        return {
+            name: 'Website',
+            tagline: '',
+            homeUrl: `/${locale}`,
+            locale
+        };
+    }
+}
+