@nuraly/lumenjs 0.1.3 → 0.2.0

package/dist/auth/types.d.ts

@@ -0,0 +1,156 @@
+export interface OIDCProvider {
+    type: 'oidc';
+    name: string;
+    issuer: string;
+    clientId: string;
+    clientSecret?: string;
+    scopes?: string[];
+}
+export interface NativeProvider {
+    type: 'native';
+    name: string;
+    /** Minimum password length. Default: 8 */
+    minPasswordLength?: number;
+    /** Allow user registration. Default: true */
+    allowRegistration?: boolean;
+    /** Require email verification before login. Default: false */
+    requireEmailVerification?: boolean;
+}
+/** Auth event types for hooks (email sending, logging, etc.) */
+export type AuthEvent = {
+    type: 'verification-email';
+    email: string;
+    token: string;
+    url: string;
+} | {
+    type: 'password-reset';
+    email: string;
+    token: string;
+    url: string;
+} | {
+    type: 'password-changed';
+    email: string;
+    userId: string;
+};
+export type AuthProvider = OIDCProvider | NativeProvider;
+export interface AuthConfig {
+    /** Single provider (legacy) or array of providers */
+    provider?: {
+        issuer: string;
+        clientId: string;
+        clientSecret?: string;
+        scopes?: string[];
+    };
+    /** Multi-provider config (preferred) */
+    providers?: AuthProvider[];
+    session: {
+        secret: string;
+        cookieName?: string;
+        maxAge?: number;
+        secure?: boolean;
+    };
+    routes?: {
+        login?: string;
+        loginPage?: string;
+        callback?: string;
+        logout?: string;
+        signup?: string;
+        postLogin?: string;
+        postLogout?: string;
+        me?: string;
+    };
+    guards?: {
+        defaultAuth?: boolean;
+    };
+    permissions?: {
+        enabled?: boolean;
+        defaultOwnerGrants?: string[];
+    };
+    token?: {
+        enabled?: boolean;
+        /** Access token TTL in seconds. Default: 900 (15 min) */
+        accessTokenTTL?: number;
+        /** Refresh token TTL in seconds. Default: 604800 (7 days) */
+        refreshTokenTTL?: number;
+    };
+    /** Hook called for auth events (send verification emails, password reset emails, etc.) */
+    onEvent?: (event: AuthEvent) => void | Promise<void>;
+}
+export interface ResolvedAuthConfig {
+    providers: AuthProvider[];
+    session: {
+        secret: string;
+        cookieName: string;
+        maxAge: number;
+        secure: boolean;
+    };
+    routes: {
+        login: string;
+        loginPage: string;
+        callback: string;
+        logout: string;
+        signup: string;
+        postLogin: string;
+        postLogout: string;
+    };
+    guards: {
+        defaultAuth: boolean;
+    };
+    permissions: {
+        enabled: boolean;
+        defaultOwnerGrants: string[];
+    };
+    token: {
+        enabled: boolean;
+        accessTokenTTL: number;
+        refreshTokenTTL: number;
+    };
+    onEvent?: (event: AuthEvent) => void | Promise<void>;
+}
+export interface TokenResponse {
+    accessToken: string;
+    refreshToken: string;
+    expiresIn: number;
+    tokenType: 'Bearer';
+    user: AuthUser;
+}
+export interface AuthUser {
+    sub: string;
+    email?: string;
+    name?: string;
+    preferred_username?: string;
+    roles: string[];
+    /** Which provider authenticated this user */
+    provider?: string;
+    [key: string]: unknown;
+}
+export interface SessionData {
+    accessToken: string;
+    refreshToken?: string;
+    idToken?: string;
+    expiresAt: number;
+    user: AuthUser;
+    /** Which provider created this session */
+    provider?: string;
+    /** Epoch seconds when session was created — used for logout-all invalidation */
+    createdAt?: number;
+}
+export interface NkAuth {
+    user: AuthUser;
+    session: SessionData;
+}
+export interface OIDCMetadata {
+    authorization_endpoint: string;
+    token_endpoint: string;
+    userinfo_endpoint: string;
+    end_session_endpoint?: string;
+    jwks_uri: string;
+    issuer: string;
+}
+export interface TokenSet {
+    access_token: string;
+    refresh_token?: string;
+    id_token?: string;
+    expires_in: number;
+    token_type: string;
+}

package/dist/auth/types.js

@@ -0,0 +1,2 @@
+// ── Provider Configs ──────────────────────────────────────────────
+export {};

package/dist/build/build-client.d.ts

@@ -0,0 +1,15 @@
+import { type UserConfig, type Plugin } from 'vite';
+export interface BuildClientOptions {
+    projectDir: string;
+    clientDir: string;
+    title: string;
+    integrations: string[];
+    prefetchStrategy: 'hover' | 'viewport' | 'none';
+    publicDir: string;
+    shared: {
+        resolve: UserConfig['resolve'];
+        esbuild: UserConfig['esbuild'];
+        plugins: Plugin[];
+    };
+}
+export declare function buildClient(opts: BuildClientOptions): Promise<void>;

package/dist/build/build-client.js

@@ -0,0 +1,45 @@
+import { build as viteBuild } from 'vite';
+import path from 'path';
+import fs from 'fs';
+import { generateIndexHtml } from '../dev-server/index-html.js';
+export async function buildClient(opts) {
+    const { projectDir, clientDir, title, integrations, prefetchStrategy, publicDir, shared } = opts;
+    console.log('[LumenJS] Building client bundle...');
+    // Read optional head.html for blocking scripts (e.g. theme initialization)
+    const headHtmlPath = path.join(projectDir, 'head.html');
+    const headContent = fs.existsSync(headHtmlPath) ? fs.readFileSync(headHtmlPath, 'utf-8') : undefined;
+    // Generate index.html as build entry
+    const indexHtml = generateIndexHtml({ title, editorMode: false, integrations, prefetch: prefetchStrategy, headContent });
+    const tempIndexPath = path.join(projectDir, '__nk_build_index.html');
+    fs.writeFileSync(tempIndexPath, indexHtml);
+    try {
+        await viteBuild({
+            root: projectDir,
+            publicDir: fs.existsSync(publicDir) ? publicDir : undefined,
+            resolve: shared.resolve,
+            plugins: shared.plugins,
+            esbuild: shared.esbuild,
+            build: {
+                outDir: clientDir,
+                emptyOutDir: true,
+                rollupOptions: {
+                    input: tempIndexPath,
+                    external: ['mermaid', 'monaco-editor', 'monacopilot', '@lumenjs/db', '@lumenjs/permissions', '@lumenjs/storage'],
+                },
+            },
+            logLevel: 'warn',
+        });
+    }
+    finally {
+        // Clean up temp file
+        if (fs.existsSync(tempIndexPath)) {
+            fs.unlinkSync(tempIndexPath);
+        }
+    }
+    // Rename the built HTML file from __nk_build_index.html to index.html
+    const builtHtmlPath = path.join(clientDir, '__nk_build_index.html');
+    const finalHtmlPath = path.join(clientDir, 'index.html');
+    if (fs.existsSync(builtHtmlPath)) {
+        fs.renameSync(builtHtmlPath, finalHtmlPath);
+    }
+}

package/dist/build/build-prerender.d.ts

@@ -0,0 +1,11 @@
+import type { BuildManifest } from '../shared/types.js';
+import type { PageEntry, LayoutEntry } from './scan.js';
+export interface PrerenderOptions {
+    serverDir: string;
+    clientDir: string;
+    pagesDir: string;
+    pageEntries: PageEntry[];
+    layoutEntries: LayoutEntry[];
+    manifest: BuildManifest;
+}
+export declare function prerenderPages(opts: PrerenderOptions): Promise<void>;

package/dist/build/build-prerender.js

@@ -0,0 +1,159 @@
+import path from 'path';
+import fs from 'fs';
+import { pathToFileURL } from 'url';
+import { filePathToTagName, stripOuterLitMarkers, dirToLayoutTagName, isRedirectResponse, patchLoaderDataSpread } from '../shared/utils.js';
+import { installDomShims } from '../shared/dom-shims.js';
+import { getLayoutDirsForPage } from './scan.js';
+export async function prerenderPages(opts) {
+    const { serverDir, clientDir, pagesDir, pageEntries, layoutEntries, manifest } = opts;
+    const prerenderEntries = pageEntries.filter(e => e.prerender);
+    if (prerenderEntries.length === 0)
+        return;
+    console.log(`[LumenJS] Pre-rendering ${prerenderEntries.length} page(s)...`);
+    // Load SSR runtime (installs global DOM shims)
+    const ssrRuntimePath = pathToFileURL(path.join(serverDir, 'ssr-runtime.js')).href;
+    const ssrRuntime = await import(ssrRuntimePath);
+    const { render, html, unsafeStatic } = ssrRuntime;
+    // Install additional DOM shims
+    installDomShims();
+    // Read the built index.html shell
+    const indexHtmlShell = fs.readFileSync(path.join(clientDir, 'index.html'), 'utf-8');
+    let prerenderCount = 0;
+    for (const page of prerenderEntries) {
+        // Resolve server module path (Rollup sanitizes brackets in filenames)
+        let modulePath = path.join(serverDir, `pages/${page.name}.js`);
+        if (!fs.existsSync(modulePath)) {
+            modulePath = path.join(serverDir, `pages/${page.name}.js`.replace(/\[/g, '_').replace(/\]/g, '_'));
+        }
+        if (!fs.existsSync(modulePath)) {
+            console.warn(`  Skipping ${page.routePath}: server module not found`);
+            continue;
+        }
+        const mod = await import(pathToFileURL(modulePath).href);
+        // Determine paths to pre-render
+        const isDynamic = page.routePath.includes(':');
+        let pathsToRender = [];
+        if (isDynamic) {
+            // Dynamic route — call prerenderPaths() for param combinations
+            if (typeof mod.prerenderPaths === 'function') {
+                const paramsList = await mod.prerenderPaths();
+                for (const params of paramsList) {
+                    // Build pathname from route pattern and params
+                    let pathname = page.routePath;
+                    for (const [key, value] of Object.entries(params)) {
+                        // Handle both :param and :...param (catch-all) patterns
+                        pathname = pathname.replace(`:...${key}`, value).replace(`:${key}`, value);
+                    }
+                    pathsToRender.push({ pathname, params: params });
+                }
+            }
+            else {
+                console.warn(`  Skipping ${page.routePath}: dynamic route without prerenderPaths()`);
+                continue;
+            }
+        }
+        else {
+            // Static route — render once
+            pathsToRender.push({ pathname: page.routePath, params: {} });
+        }
+        for (const { pathname, params } of pathsToRender) {
+            // Run loader if present
+            let loaderData = undefined;
+            if (mod.loader && typeof mod.loader === 'function') {
+                loaderData = await mod.loader({ params, query: {}, url: pathname, headers: {} });
+                if (isRedirectResponse(loaderData)) {
+                    console.warn(`  Skipping ${pathname}: loader returned redirect`);
+                    continue;
+                }
+            }
+            // Get tag name
+            const relPath = path.relative(pagesDir, page.filePath).replace(/\\/g, '/');
+            const tagName = filePathToTagName(relPath);
+            // Load and render layout chain
+            const routeLayouts = getLayoutDirsForPage(page.filePath, pagesDir, layoutEntries);
+            const layoutModules = [];
+            const layoutsData = [];
+            for (const dir of routeLayouts) {
+                const layout = layoutEntries.find(l => l.dir === dir);
+                if (!layout)
+                    continue;
+                let layoutLoaderData = undefined;
+                if (layout.hasLoader) {
+                    const manifestLayout = manifest.layouts.find(l => l.dir === dir);
+                    if (manifestLayout?.module) {
+                        const layoutModPath = path.join(serverDir, manifestLayout.module);
+                        if (fs.existsSync(layoutModPath)) {
+                            const layoutMod = await import(pathToFileURL(layoutModPath).href);
+                            if (layoutMod.loader && typeof layoutMod.loader === 'function') {
+                                layoutLoaderData = await layoutMod.loader({ params: {}, query: {}, url: pathname, headers: {} });
+                                if (isRedirectResponse(layoutLoaderData))
+                                    continue;
+                            }
+                        }
+                    }
+                }
+                const layoutTagName = dirToLayoutTagName(dir);
+                layoutModules.push({ tagName: layoutTagName, loaderData: layoutLoaderData });
+                layoutsData.push({ loaderPath: dir, data: layoutLoaderData });
+            }
+            // Patch element classes to spread loaderData
+            for (const lm of layoutModules) {
+                patchLoaderDataSpread(lm.tagName);
+            }
+            patchLoaderDataSpread(tagName);
+            // SSR render page
+            const pageTag = unsafeStatic(tagName);
+            const pageTemplate = html `<${pageTag} .loaderData=${loaderData}></${pageTag}>`;
+            let ssrHtml = '';
+            for (const chunk of render(pageTemplate)) {
+                ssrHtml += typeof chunk === 'string' ? chunk : String(chunk);
+            }
+            ssrHtml = stripOuterLitMarkers(ssrHtml);
+            // Wrap in layout chain (inside-out, deepest first)
+            for (let i = layoutModules.length - 1; i >= 0; i--) {
+                const lTag = unsafeStatic(layoutModules[i].tagName);
+                const lData = layoutModules[i].loaderData;
+                const lTemplate = html `<${lTag} .loaderData=${lData}></${lTag}>`;
+                let lHtml = '';
+                for (const chunk of render(lTemplate)) {
+                    lHtml += typeof chunk === 'string' ? chunk : String(chunk);
+                }
+                if (i > 0) {
+                    lHtml = stripOuterLitMarkers(lHtml);
+                }
+                const closingTag = `</${layoutModules[i].tagName}>`;
+                const closingIdx = lHtml.lastIndexOf(closingTag);
+                if (closingIdx !== -1) {
+                    ssrHtml = lHtml.slice(0, closingIdx) + ssrHtml + lHtml.slice(closingIdx);
+                }
+                else {
+                    ssrHtml = lHtml + ssrHtml;
+                }
+            }
+            // Build SSR data script
+            const ssrDataObj = layoutsData.length > 0
+                ? { page: loaderData, layouts: layoutsData }
+                : loaderData;
+            const loaderDataScript = ssrDataObj !== undefined
+                ? `<script type="application/json" id="__nk_ssr_data__">${JSON.stringify(ssrDataObj).replace(/</g, '\\u003c')}</script>`
+                : '';
+            const hydrateScript = `<script type="module">import '@lit-labs/ssr-client/lit-element-hydrate-support.js';</script>`;
+            // Build final HTML from the shell
+            let htmlOut = indexHtmlShell;
+            htmlOut = htmlOut.replace('<script type="module"', `${hydrateScript}\n  <script type="module"`);
+            htmlOut = htmlOut.replace(/<nk-app><\/nk-app>/, `${loaderDataScript}<nk-app data-nk-ssr><div id="nk-router-outlet">${ssrHtml}</div></nk-app>`);
+            // Write pre-rendered HTML file
+            const outPath = pathname === '/'
+                ? path.join(clientDir, 'index.html')
+                : path.join(clientDir, pathname, 'index.html');
+            // Don't overwrite the root index.html for non-root pages
+            if (pathname !== '/') {
+                fs.mkdirSync(path.dirname(outPath), { recursive: true });
+            }
+            fs.writeFileSync(outPath, htmlOut);
+            prerenderCount++;
+            console.log(`  Pre-rendered: ${pathname}`);
+        }
+    }
+    console.log(`[LumenJS] Pre-rendered ${prerenderCount} page(s).`);
+}

package/dist/build/build-server.d.ts

@@ -0,0 +1,18 @@
+import { type UserConfig, type Plugin } from 'vite';
+import type { PageEntry, LayoutEntry, ApiEntry, MiddlewareEntry } from './scan.js';
+export interface BuildServerOptions {
+    projectDir: string;
+    serverDir: string;
+    pageEntries: PageEntry[];
+    layoutEntries: LayoutEntry[];
+    apiEntries: ApiEntry[];
+    middlewareEntries: MiddlewareEntry[];
+    hasAuthConfig: boolean;
+    authConfigPath: string;
+    shared: {
+        resolve: UserConfig['resolve'];
+        esbuild: UserConfig['esbuild'];
+        plugins: Plugin[];
+    };
+}
+export declare function buildServer(opts: BuildServerOptions): Promise<void>;

package/dist/build/build-server.js

@@ -0,0 +1,107 @@
+import { build as viteBuild } from 'vite';
+import path from 'path';
+import fs from 'fs';
+export async function buildServer(opts) {
+    const { projectDir, serverDir, pageEntries, layoutEntries, apiEntries, middlewareEntries, hasAuthConfig, authConfigPath, shared } = opts;
+    console.log('[LumenJS] Building server bundle...');
+    // Collect server entry points (pages with loaders + layouts with loaders + API routes)
+    const serverEntries = {};
+    for (const entry of pageEntries) {
+        if (entry.hasLoader || entry.hasSubscribe || entry.prerender) {
+            serverEntries[`pages/${entry.name}`] = entry.filePath;
+        }
+    }
+    for (const entry of layoutEntries) {
+        if (entry.hasLoader || entry.hasSubscribe) {
+            const entryName = entry.dir ? `layouts/${entry.dir}/_layout` : 'layouts/_layout';
+            serverEntries[entryName] = entry.filePath;
+        }
+    }
+    for (const entry of apiEntries) {
+        serverEntries[`api/${entry.name}`] = entry.filePath;
+    }
+    for (const entry of middlewareEntries) {
+        const entryName = entry.dir ? `middleware/${entry.dir}/_middleware` : 'middleware/_middleware';
+        serverEntries[entryName] = entry.filePath;
+    }
+    if (hasAuthConfig) {
+        serverEntries['auth-config'] = authConfigPath;
+    }
+    // If data/seed.ts exists, include it in the server bundle for prod seed support
+    const seedPath = path.join(projectDir, 'data', 'seed.ts');
+    if (fs.existsSync(seedPath)) {
+        serverEntries['seed'] = seedPath;
+    }
+    // Create SSR runtime entry — bundles @lit-labs/ssr alongside Lit so all
+    // server modules share one Lit instance (avoids _$EM mismatches).
+    const ssrEntryPath = path.join(projectDir, '__nk_ssr_entry.js');
+    const hasPageLoaders = pageEntries.some(e => e.hasLoader);
+    const hasLayoutLoaders = layoutEntries.some(e => e.hasLoader);
+    const hasPrerenderPages = pageEntries.some(e => e.prerender);
+    if (hasPageLoaders || hasLayoutLoaders || hasPrerenderPages) {
+        fs.writeFileSync(ssrEntryPath, [
+            "import '@lit-labs/ssr/lib/install-global-dom-shim.js';",
+            "export { render } from '@lit-labs/ssr';",
+            "export { html, unsafeStatic } from 'lit/static-html.js';",
+        ].join('\n'));
+        serverEntries['ssr-runtime'] = ssrEntryPath;
+    }
+    try {
+        if (Object.keys(serverEntries).length > 0) {
+            await viteBuild({
+                root: projectDir,
+                resolve: shared.resolve,
+                plugins: shared.plugins,
+                esbuild: shared.esbuild,
+                build: {
+                    outDir: serverDir,
+                    emptyOutDir: true,
+                    ssr: true,
+                    rollupOptions: {
+                        input: serverEntries,
+                        output: {
+                            format: 'esm',
+                            entryFileNames: '[name].js',
+                            chunkFileNames: 'assets/[name]-[hash].js',
+                            manualChunks(id) {
+                                // Force all Lit packages into a single shared chunk so SSR runtime
+                                // and page modules use the exact same Lit class instances.
+                                if (id.includes('/node_modules/lit/') ||
+                                    id.includes('/node_modules/lit-html/') ||
+                                    id.includes('/node_modules/lit-element/') ||
+                                    id.includes('/node_modules/@lit/reactive-element/')) {
+                                    return 'lit-shared';
+                                }
+                            },
+                        },
+                        external: [
+                            /^node:/,
+                            'os', 'fs', 'path', 'url', 'util', 'crypto', 'http', 'https', 'net',
+                            'stream', 'zlib', 'events', 'buffer', 'querystring', 'child_process',
+                            'worker_threads', 'cluster', 'dns', 'tls', 'assert', 'constants',
+                            // Native addons — must not be bundled, loaded from node_modules at runtime
+                            'better-sqlite3',
+                            // AWS SDK — optional peer dep, keep as runtime import so app can provide it
+                            '@aws-sdk/client-s3',
+                            '@aws-sdk/s3-request-presigner',
+                            /^@aws-sdk\//,
+                            /^@smithy\//,
+                        ],
+                    },
+                },
+                logLevel: 'warn',
+                ssr: {
+                    noExternal: true,
+                },
+            });
+        }
+        else {
+            fs.mkdirSync(serverDir, { recursive: true });
+        }
+    }
+    finally {
+        if (fs.existsSync(ssrEntryPath)) {
+            fs.unlinkSync(ssrEntryPath);
+        }
+    }
+}