@jhits/dashboard 0.0.1

package/src/lib/modules-config.ts

@@ -0,0 +1,68 @@
+// src/lib/modules-config.ts
+import { BarChart3, Newspaper, Globe, Users, Mail, type LucideIcon } from 'lucide-react';
+
+export interface Module {
+    id: string;
+    namespace: string;
+    path: string;
+    aliases: Record<string, string>;
+    icon: LucideIcon;
+}
+
+export const PLATFORM_MODULES: Module[] = [
+    {
+        id: 'users',
+        namespace: 'users',
+        path: '/dashboard/users',
+        icon: Users,
+        aliases: {
+            en: '/dashboard/users',
+            nl: '/dashboard/gebruikers',
+            sv: '/dashboard/användare'
+        }
+    },
+    {
+        id: 'website',
+        namespace: 'website',
+        path: '/dashboard/website',
+        icon: Globe,
+        aliases: {
+            en: '/dashboard/site-settings',
+            nl: '/dashboard/website-instellingen',
+            sv: '/dashboard/webbplatsinstallningar'
+        }
+    },
+    {
+        id: 'blog',
+        namespace: 'blog',
+        path: '/dashboard/blog',
+        icon: Newspaper,
+        aliases: {
+            en: '/dashboard/content-manager',
+            nl: '/dashboard/blog-beheer',
+            sv: '/dashboard/blogghantering'
+        }
+    },
+    {
+        id: 'newsletter',
+        namespace: 'newsletter',
+        path: '/dashboard/newsletter',
+        icon: Mail,
+        aliases: {
+            en: '/dashboard/newsletter',
+            nl: '/dashboard/nieuwsbrief',
+            sv: '/dashboard/nyhetsbrev'
+        }
+    },
+    {
+        id: 'stats',
+        namespace: 'stats',
+        path: '/dashboard/stats',
+        icon: BarChart3,
+        aliases: {
+            en: '/dashboard/statistics',
+            nl: '/dashboard/statistieken',
+            sv: '/dashboard/statistik'
+        }
+    }
+];

package/src/lib/mongodb.ts

@@ -0,0 +1,32 @@
+import { MongoClient } from 'mongodb';
+
+// Support both DATABASE_URL (dashboard) and MONGODB_URI (client app)
+const uri = process.env.DATABASE_URL || process.env.MONGODB_URI;
+
+if (!uri) {
+    throw new Error('Invalid/Missing environment variable: "DATABASE_URL" or "MONGODB_URI"');
+}
+const options = {};
+
+let client: MongoClient;
+let clientPromise: Promise<MongoClient>;
+
+if (process.env.NODE_ENV === 'development') {
+    // In development mode, use a global variable so the value
+    // is preserved across module reloads caused by HMR.
+    const globalWithMongo = global as typeof globalThis & {
+        _mongoClientPromise?: Promise<MongoClient>;
+    };
+
+    if (!globalWithMongo._mongoClientPromise) {
+        client = new MongoClient(uri, options);
+        globalWithMongo._mongoClientPromise = client.connect();
+    }
+    clientPromise = globalWithMongo._mongoClientPromise;
+} else {
+    // In production mode, it's best to not use a global variable.
+    client = new MongoClient(uri, options);
+    clientPromise = client.connect();
+}
+
+export default clientPromise;

package/src/lib/plugin-registry.tsx

@@ -0,0 +1,77 @@
+// packages/jhits-dashboard/src/lib/plugin-registry.tsx
+'use client';
+
+import dynamic from 'next/dynamic';
+import pluginData from "../assets/plugins.json";
+import { PluginProps, PluginManifest } from "../types/plugin";
+
+// Type the imported JSON safely
+const library = pluginData as PluginManifest[];
+
+// Cache for resolved components to avoid recreating them
+const componentCache = new Map<string, React.ComponentType<PluginProps>>();
+
+// Dynamic plugin loader factory
+// This creates a loader function that dynamically imports plugins based on the JSON configuration
+// Plugins are loaded from @jhits/{repoName} where repoName comes from plugins.json
+function createDynamicPluginLoader(repoName: string): () => Promise<React.ComponentType<PluginProps>> {
+    return async () => {
+        try {
+            // Dynamically import the plugin package
+            // The package name follows the pattern: @jhits/{repoName}
+            const pluginModule = await import(`@jhits/${repoName}`);
+            // Return the default export or Index export
+            return pluginModule.default || pluginModule.Index;
+        } catch (error) {
+            console.error(`Failed to load plugin "${repoName}":`, error);
+            throw new Error(`Plugin "${repoName}" could not be loaded. Make sure it's installed and the package name matches @jhits/${repoName}`);
+        }
+    };
+}
+
+export const PluginRegistry = {
+    // Returns the static data from JSON
+    getDefinition: (prefix: string): PluginManifest | undefined => {
+        return library.find(p => p.routePrefix === prefix);
+    },
+
+    // Resolves the actual React Component with caching
+    // Dynamically loads plugins based on the JSON configuration
+    // No hardcoded plugin list - everything comes from plugins.json
+    resolveComponent: (repoName: string) => {
+        // Check cache first
+        if (componentCache.has(repoName)) {
+            return componentCache.get(repoName)!;
+        }
+
+        // Verify the plugin exists in the JSON configuration
+        const pluginManifest = library.find(p => p.repo === repoName);
+        if (!pluginManifest) {
+            throw new Error(
+                `Plugin "${repoName}" not found in plugins.json. ` +
+                `Available plugins: ${library.map(p => `${p.repo} (${p.id})`).join(', ')}`
+            );
+        }
+
+        if (!pluginManifest.enabled) {
+            throw new Error(`Plugin "${repoName}" is disabled in plugins.json`);
+        }
+
+        // Create dynamic loader for this plugin
+        const loader = createDynamicPluginLoader(repoName);
+
+        // Create and cache the component using dynamic import
+        const Component = dynamic<PluginProps>(
+            loader,
+            {
+                loading: () => <div className="p-10 animate-pulse font-black uppercase">Mounting_Module...</div>,
+                ssr: false
+            }
+        );
+
+        componentCache.set(repoName, Component);
+        return Component;
+    },
+
+    getAll: () => library
+};

package/src/lib/website-context.tsx

@@ -0,0 +1,39 @@
+'use client';
+
+import { createContext, useContext, ReactNode } from 'react';
+
+export interface WebsiteInfo {
+    name: string;
+    tagline?: string;
+    homeUrl: string; // Base URL to navigate back to the main site
+    locale?: string;
+    logo?: {
+        light: string; // Path to light mode logo
+        dark: string; // Path to dark mode logo
+    };
+}
+
+const WebsiteContext = createContext<WebsiteInfo | null>(null);
+
+export function WebsiteProvider({ children, website }: { children: ReactNode; website: WebsiteInfo }) {
+    return (
+        <WebsiteContext.Provider value={website}>
+            {children}
+        </WebsiteContext.Provider>
+    );
+}
+
+export function useWebsite() {
+    const context = useContext(WebsiteContext);
+    if (!context) {
+        // Fallback values if context is not provided
+        return {
+            name: 'Website',
+            tagline: '',
+            homeUrl: '/',
+            locale: 'en'
+        };
+    }
+    return context;
+}
+

package/src/proxy.ts

@@ -0,0 +1,55 @@
+// src/middleware.ts
+import { NextResponse } from 'next/server';
+import type { NextRequest } from 'next/server';
+import { getToken } from "next-auth/jwt";
+import createIntlMiddleware from 'next-intl/middleware';
+import { routing } from './i18n/routing';
+
+// 1. Initialize the Internationalization middleware
+const handleI18nRouting = createIntlMiddleware(routing);
+
+export default async function middleware(req: NextRequest) {
+    const { pathname } = req.nextUrl;
+
+    // 2. Run i18n middleware first (handles /en, /nl, /sv prefixes)
+    const response = handleI18nRouting(req);
+
+    // 3. Auth Logic
+    const token = await getToken({ req });
+    const isAuth = !!token;
+
+    // Check if we are on a login page (any language version like /en/login)
+    const isAuthPage = pathname.match(/\/(en|nl|sv)\/login$/) || pathname === '/login';
+
+    // Check if we are on a protected dashboard route
+    const isDashboardPage = pathname.includes('/stats') ||
+        pathname.includes('/blog') ||
+        pathname.includes('/dashboard');
+
+    // Logic A: Already logged in? Redirect away from Login to Stats
+    if (isAuthPage) {
+        if (isAuth) {
+            return NextResponse.redirect(new URL('/dashboard', req.url)); // Default to /en/stats or detect locale
+        }
+        return response;
+    }
+
+    // Logic B: Not logged in? Redirect from Dashboard to Login
+    if (isDashboardPage && !isAuth) {
+        let from = pathname;
+        if (req.nextUrl.search) from += req.nextUrl.search;
+
+        // We redirect to the /login page, preserving the current locale if possible
+        const locale = pathname.split('/')[1] || 'en';
+        return NextResponse.redirect(
+            new URL(`/${locale}/login?from=${encodeURIComponent(from)}`, req.url)
+        );
+    }
+
+    return response;
+}
+
+export const config = {
+    // Match all routes except static files and API
+    matcher: ['/((?!api|_next|_static|_vercel|[\\w-]+\\.\\w+).*)']
+};

package/src/router.tsx

@@ -0,0 +1,45 @@
+// Main router component that handles all dashboard routes
+// This is the single entry point that the host app uses
+
+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>;
+}
+

package/src/routes.tsx

@@ -0,0 +1,3 @@
+// Legacy exports - use router.tsx instead
+export { DashboardRouter, DashboardRouterLayout } from './router';
+

package/src/server.ts

@@ -0,0 +1,8 @@
+/**
+ * Server-only exports for @jhits/dashboard
+ * These exports should only be used in server-side code (API routes, server components)
+ */
+
+export { handleDashboardApi, createNextRequestFromRequest } from './api/masterRouter';
+export { handlePluginApi, type PluginRouterConfig } from './api/pluginRouter';
+

package/src/types/plugin.ts

@@ -0,0 +1,24 @@
+// types/plugin.ts
+
+// This represents what is in your JSON file
+export interface PluginManifest {
+    id: string;
+    repo: string;
+    routePrefix: string;
+    name: string;
+    version: string;
+    enabled: boolean;
+}
+
+export interface PluginProps {
+    subPath: string[];
+    siteId: string;
+    locale: string;
+}
+
+// This represents the actual loaded code
+export interface SitePlugin extends PluginManifest {
+    MainRouter: React.ComponentType<PluginProps>;
+    HeaderComponent?: React.ComponentType;
+    SettingsPanel?: React.ComponentType;
+}

package/src/types/preferences.ts

@@ -0,0 +1,13 @@
+export interface UserPreferences {
+    theme: 'light' | 'dark' | 'system';
+    language: string;
+    dashboardView: 'grid' | 'list';
+    notifications: {
+        marketing: boolean;
+        security: boolean;
+    };
+    privacy: {
+        stealthMode: boolean;
+        publicSearch: boolean;
+    };
+}