create-jen-app 1.0.0 → 1.2.1

package/templates/static/lib/core/config.d.ts

@@ -0,0 +1,53 @@
+export type RenderMode = "ssr" | "ssg" | "isr" | "ppr";
+export type FrameworkConfig = {
+    siteDir: string;
+    distDir: string;
+    routes: {
+        fileExtensions: string[];
+        routeFilePattern: RegExp;
+        enableIndexFallback: boolean;
+    };
+    rendering: {
+        defaultMode: RenderMode;
+        defaultRevalidateSeconds: number;
+    };
+    inject: {
+        head: string[];
+        bodyEnd: string[];
+    };
+    css: {
+        globalScss: string;
+        criticalBudget?: number;
+        extractCritical?: boolean;
+    };
+    assets: {
+        publicDir: string;
+        cacheControl: string;
+        hashLength?: number;
+    };
+    server: {
+        port: number;
+        hostname: string;
+    };
+    build?: {
+        minifyHtml?: boolean;
+        minifyCss?: boolean;
+        minifyJs?: boolean;
+        hashAssets?: boolean;
+        generateManifest?: boolean;
+        generateSitemap?: boolean;
+        cacheDir?: string;
+        incrementalBuild?: boolean;
+        sourceMap?: boolean;
+    };
+    dev?: {
+        enableSSR?: boolean;
+        liveReload?: boolean;
+        port?: number;
+    };
+    seo?: {
+        generateRobotsTxt?: boolean;
+        generateSitemap?: boolean;
+        sitemapBaseUrl?: string;
+    };
+};

package/templates/static/lib/core/config.js

@@ -0,0 +1,18 @@
+/*
+ * This file is part of Jen.js.
+ * Copyright (C) 2026 oopsio
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+export {};

package/templates/static/lib/core/http.d.ts

@@ -0,0 +1,3 @@
+import type { IncomingMessage } from "node:http";
+export declare function parseCookies(req: IncomingMessage): Record<string, string>;
+export declare function headersToObject(headers: IncomingMessage["headers"]): Record<string, string>;

package/templates/static/lib/core/http.js

@@ -0,0 +1,42 @@
+/*
+ * This file is part of Jen.js.
+ * Copyright (C) 2026 oopsio
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+export function parseCookies(req) {
+    const cookie = req.headers.cookie;
+    if (!cookie)
+        return {};
+    const out = {};
+    for (const part of cookie.split(";")) {
+        const [k, ...rest] = part.trim().split("=");
+        const trimmedName = k.trim();
+        const trimmedValue = rest.join("=").trim();
+        if (trimmedName && trimmedValue) {
+            out[trimmedName] = decodeURIComponent(trimmedValue);
+        }
+    }
+    return out;
+}
+export function headersToObject(headers) {
+    const out = {};
+    for (const [k, v] of Object.entries(headers)) {
+        if (Array.isArray(v))
+            out[k] = v.join(", ");
+        else if (typeof v === "string")
+            out[k] = v;
+    }
+    return out;
+}

package/templates/static/lib/core/middleware-hooks.d.ts

@@ -0,0 +1,46 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+/**
+ * Route middleware context. Available to middleware functions.
+ */
+export interface RouteMiddlewareContext {
+    req: IncomingMessage;
+    res: ServerResponse;
+    url: URL;
+    params: Record<string, string>;
+    query: Record<string, string>;
+    headers: Record<string, string>;
+    cookies: Record<string, string>;
+    data?: Record<string, any>;
+    status: (code: number) => RouteMiddlewareContext;
+    setHeader: (key: string, value: string) => RouteMiddlewareContext;
+    redirect: (url: string, statusCode?: number) => never;
+    json: (data: any, statusCode?: number) => never;
+}
+/**
+ * Route middleware function signature.
+ * Return undefined/void to continue to next middleware/page.
+ * Call ctx.redirect() or ctx.json() to short-circuit.
+ */
+export type RouteMiddleware = (ctx: RouteMiddlewareContext) => Promise<void> | void;
+/**
+ * Note: Route module types (middleware, hydrate fields) are defined in core/types.ts
+ * This module just provides the middleware execution primitives.
+ */
+/**
+ * Create middleware context from request.
+ * Called by server before rendering route.
+ */
+export declare function createRouteMiddlewareContext(opts: {
+    req: IncomingMessage;
+    res: ServerResponse;
+    url: URL;
+    params: Record<string, string>;
+    query: Record<string, string>;
+    headers: Record<string, string>;
+    cookies: Record<string, string>;
+}): RouteMiddlewareContext;
+/**
+ * Execute route middlewares in sequence.
+ * If any middleware calls redirect() or json(), it throws and stops execution.
+ */
+export declare function executeRouteMiddleware(middlewares: RouteMiddleware[], ctx: RouteMiddlewareContext): Promise<void>;

package/templates/static/lib/core/middleware-hooks.js

@@ -0,0 +1,69 @@
+/*
+ * This file is part of Jen.js.
+ * Copyright (C) 2026 oopsio
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+/**
+ * Note: Route module types (middleware, hydrate fields) are defined in core/types.ts
+ * This module just provides the middleware execution primitives.
+ */
+/**
+ * Create middleware context from request.
+ * Called by server before rendering route.
+ */
+export function createRouteMiddlewareContext(opts) {
+    const ctx = {
+        ...opts,
+        data: {},
+        status: function (code) {
+            this.res.statusCode = code;
+            return this;
+        },
+        setHeader: function (key, value) {
+            this.res.setHeader(key, value);
+            return this;
+        },
+        redirect: function (url, statusCode = 302) {
+            this.res.statusCode = statusCode;
+            this.res.setHeader("location", url);
+            this.res.end();
+            throw new Error("__REDIRECT__");
+        },
+        json: function (data, statusCode = 200) {
+            this.res.statusCode = statusCode;
+            this.res.setHeader("content-type", "application/json; charset=utf-8");
+            this.res.end(JSON.stringify(data));
+            throw new Error("__JSON__");
+        },
+    };
+    return ctx;
+}
+/**
+ * Execute route middlewares in sequence.
+ * If any middleware calls redirect() or json(), it throws and stops execution.
+ */
+export async function executeRouteMiddleware(middlewares, ctx) {
+    for (const mw of middlewares) {
+        try {
+            await mw(ctx);
+        }
+        catch (err) {
+            if (err.message === "__REDIRECT__" || err.message === "__JSON__") {
+                throw err;
+            }
+            throw err;
+        }
+    }
+}

package/templates/static/lib/core/paths.d.ts

@@ -0,0 +1,6 @@
+export declare function resolveSitePath(config: {
+    siteDir: string;
+}, ...p: string[]): string;
+export declare function resolveDistPath(config: {
+    distDir: string;
+}, ...p: string[]): string;

package/templates/static/lib/core/paths.js

@@ -0,0 +1,24 @@
+/*
+ * This file is part of Jen.js.
+ * Copyright (C) 2026 oopsio
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import { join } from "node:path";
+export function resolveSitePath(config, ...p) {
+    return join(process.cwd(), config.siteDir, ...p);
+}
+export function resolveDistPath(config, ...p) {
+    return join(process.cwd(), config.distDir, ...p);
+}

package/templates/static/lib/core/routes/match.d.ts

@@ -0,0 +1,6 @@
+import type { RouteEntry } from "./scan.js";
+export type MatchResult = {
+    route: RouteEntry;
+    params: Record<string, string>;
+};
+export declare function matchRoute(routes: RouteEntry[], pathname: string): MatchResult | null;

package/templates/static/lib/core/routes/match.js

@@ -0,0 +1,31 @@
+/*
+ * This file is part of Jen.js.
+ * Copyright (C) 2026 oopsio
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+export function matchRoute(routes, pathname) {
+    for (const r of routes) {
+        const re = new RegExp(r.pattern);
+        const m = pathname.match(re);
+        if (!m)
+            continue;
+        const params = {};
+        for (let i = 0; i < r.paramNames.length; i++) {
+            params[r.paramNames[i]] = decodeURIComponent(m[i + 1] ?? "");
+        }
+        return { route: r, params };
+    }
+    return null;
+}

package/templates/static/lib/core/routes/scan.d.ts

@@ -0,0 +1,9 @@
+import type { FrameworkConfig } from "../config.js";
+export type RouteEntry = {
+    id: string;
+    filePath: string;
+    urlPath: string;
+    pattern: string;
+    paramNames: string[];
+};
+export declare function scanRoutes(config: FrameworkConfig): RouteEntry[];

package/templates/static/lib/core/routes/scan.js

@@ -0,0 +1,148 @@
+/*
+ * This file is part of Jen.js.
+ * Copyright (C) 2026 oopsio
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import { readdirSync, statSync } from "node:fs";
+import { join, relative, sep } from "node:path";
+function walk(dir) {
+    const out = [];
+    for (const name of readdirSync(dir)) {
+        const p = join(dir, name);
+        const st = statSync(p);
+        if (st.isDirectory())
+            out.push(...walk(p));
+        else
+            out.push(p);
+    }
+    return out;
+}
+function normalizeSlashes(p) {
+    return p.split(sep).join("/");
+}
+function escapeRegex(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function segmentToRegex(seg, paramNames) {
+    // (id) => ([^/]+)
+    // (...rest) => (.*)
+    if (seg.startsWith("...")) {
+        const name = seg.slice(3);
+        paramNames.push(name);
+        return "(.*)";
+    }
+    paramNames.push(seg);
+    return "([^/]+)";
+}
+function buildRoutePattern(urlPath) {
+    // Convert /user/:id into regex
+    // We store urlPath with placeholders already replaced during scan
+    const parts = urlPath.split("/").filter(Boolean);
+    const paramNames = [];
+    const regexParts = parts.map((p) => {
+        if (p.startsWith(":")) {
+            paramNames.push(p.slice(1));
+            return "([^/]+)";
+        }
+        if (p.startsWith("*")) {
+            paramNames.push(p.slice(1));
+            return "(.*)";
+        }
+        return escapeRegex(p);
+    });
+    const src = "^/" + regexParts.join("/") + "/?$";
+    return { src, paramNames };
+}
+export function scanRoutes(config) {
+    const siteRoot = join(process.cwd(), config.siteDir);
+    const files = walk(siteRoot);
+    const routes = [];
+    for (const abs of files) {
+        const rel = normalizeSlashes(relative(siteRoot, abs));
+        const extMatch = config.routes.fileExtensions.some((ext) => rel.endsWith(ext));
+        if (!extMatch)
+            continue;
+        const base = rel.split("/").pop();
+        const m = base.match(config.routes.routeFilePattern);
+        if (!m)
+            continue;
+        const name = m[1]; // inside ( )
+        const relDir = rel.split("/").slice(0, -1).join("/");
+        // name parsing:
+        // home => /
+        // about => /about
+        // id => /:id
+        // ...rest => /*rest
+        let routeSeg = name;
+        let urlSeg = "";
+        if (routeSeg === "home")
+            urlSeg = "";
+        else if (routeSeg.startsWith("..."))
+            urlSeg = "*" + routeSeg.slice(3);
+        else
+            urlSeg = routeSeg;
+        // build url path
+        let url = "/" + (relDir ? relDir + "/" : "") + urlSeg;
+        url = url.replaceAll("//", "/");
+        // Dynamic route segment detection:
+        // Routes are determined by the filename within parentheses
+        // - (home).tsx => / (root) or /{dir}/ (in subdirectory)
+        // - ($paramName).tsx => /:paramName (dynamic param, requires $ prefix)
+        // - (...restName).tsx => /*restName (catch-all, requires ... prefix)
+        // - Any other (name).tsx => /name (literal segment)
+        const rawName = name;
+        // Handle special prefixes for dynamic routing
+        if (rawName.startsWith("$") && !rawName.startsWith("...")) {
+            // ($paramName) syntax for dynamic parameters
+            const param = rawName.slice(1);
+            if (!/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(param)) {
+                throw new Error(`Invalid parameter name: ${param} in route file ${rel}`);
+            }
+            url = "/" + (relDir ? relDir + "/" : "") + ":" + param;
+            url = url.replaceAll("//", "/");
+        }
+        else if (rawName.startsWith("...")) {
+            // (...restName) syntax for catch-all routes
+            const restName = rawName.slice(3);
+            if (!/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(restName)) {
+                throw new Error(`Invalid rest parameter name: ${restName} in route file ${rel}`);
+            }
+            url = "/" + (relDir ? relDir + "/" : "") + "*" + restName;
+            url = url.replaceAll("//", "/");
+        }
+        else if (rawName === "home") {
+            // (home) is special - becomes root of its directory
+            url = relDir === "" ? "/" : "/" + relDir;
+        }
+        // else: (anything else) treated as literal segment
+        const { src, paramNames } = buildRoutePattern(url);
+        routes.push({
+            id: rel.replaceAll("/", "_"),
+            filePath: abs,
+            urlPath: url,
+            pattern: src,
+            paramNames,
+        });
+    }
+    routes.sort((a, b) => {
+        // more specific first
+        const aDyn = a.urlPath.includes(":") || a.urlPath.includes("*");
+        const bDyn = b.urlPath.includes(":") || b.urlPath.includes("*");
+        if (aDyn !== bDyn)
+            return aDyn ? 1 : -1;
+        return a.urlPath.localeCompare(b.urlPath);
+    });
+    return routes;
+}

package/templates/static/lib/core/types.d.ts

@@ -0,0 +1,18 @@
+import type { RenderMode } from "./config.js";
+export type RouteModule = {
+    mode?: RenderMode;
+    revalidateSeconds?: number;
+    hydrate?: boolean;
+    middleware?: any;
+    loader?: (ctx: LoaderContext) => Promise<any> | any;
+    Head?: (props: any) => any;
+    default: (props: any) => any;
+};
+export type LoaderContext = {
+    url: URL;
+    params: Record<string, string>;
+    query: Record<string, string>;
+    headers: Record<string, string>;
+    cookies: Record<string, string>;
+    data?: Record<string, any>;
+};

package/templates/static/lib/core/types.js

@@ -0,0 +1,18 @@
+/*
+ * This file is part of Jen.js.
+ * Copyright (C) 2026 oopsio
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+export {};

package/templates/static/lib/css/compiler.d.ts

@@ -0,0 +1,20 @@
+export interface CompileOptions {
+    inputPath: string;
+    outputPath?: string;
+    minified?: boolean;
+    sourceMap?: boolean;
+    watch?: boolean;
+}
+export interface CompileResult {
+    css: string;
+    sourceMap?: string;
+    error?: string;
+}
+export declare class ScssCompiler {
+    compile(options: CompileOptions): CompileResult;
+    compileString(scss: string, options?: {
+        minified?: boolean;
+    }): CompileResult;
+    compileGlob(pattern: string, outputDir: string, minified?: boolean): number;
+}
+export declare function createScssCompiler(): ScssCompiler;

package/templates/static/lib/css/compiler.js

@@ -0,0 +1,87 @@
+/*
+ * This file is part of Jen.js.
+ * Copyright (C) 2026 oopsio
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import { compile, compileString } from "sass";
+import { globSync } from "glob";
+import { writeFileSync, existsSync, mkdirSync } from "node:fs";
+import { dirname, join, relative } from "node:path";
+import { log } from "../shared/log.js";
+export class ScssCompiler {
+    compile(options) {
+        const { inputPath, outputPath, minified = false, sourceMap = false, } = options;
+        try {
+            if (!existsSync(inputPath)) {
+                return { css: "", error: `File not found: ${inputPath}` };
+            }
+            const result = compile(inputPath, {
+                style: minified ? "compressed" : "expanded",
+                sourceMap,
+            });
+            if (outputPath) {
+                mkdirSync(dirname(outputPath), { recursive: true });
+                writeFileSync(outputPath, result.css);
+                if (result.sourceMap && sourceMap) {
+                    writeFileSync(outputPath + ".map", JSON.stringify(result.sourceMap));
+                }
+                log.info(`[SCSS] ✓ ${relative(process.cwd(), inputPath)} → ${relative(process.cwd(), outputPath)}`);
+            }
+            return {
+                css: result.css,
+                sourceMap: result.sourceMap
+                    ? JSON.stringify(result.sourceMap)
+                    : undefined,
+            };
+        }
+        catch (err) {
+            const message = err.message || String(err);
+            log.error(`[SCSS] ✗ ${inputPath}: ${message}`);
+            return { css: "", error: message };
+        }
+    }
+    compileString(scss, options) {
+        try {
+            const result = compileString(scss, {
+                style: options?.minified ? "compressed" : "expanded",
+            });
+            return { css: result.css };
+        }
+        catch (err) {
+            const message = err.message || String(err);
+            log.error(`[SCSS] ✗ Inline compilation error: ${message}`);
+            return { css: "", error: message };
+        }
+    }
+    compileGlob(pattern, outputDir, minified = false) {
+        const files = globSync(pattern);
+        let count = 0;
+        files.forEach((file) => {
+            const rel = relative(outputDir, file);
+            const output = join(outputDir, rel.replace(/\.scss$/, ".css"));
+            const result = this.compile({
+                inputPath: file,
+                outputPath: output,
+                minified,
+            });
+            if (!result.error)
+                count++;
+        });
+        return count;
+    }
+}
+export function createScssCompiler() {
+    return new ScssCompiler();
+}

package/templates/static/lib/db/connector.d.ts

@@ -0,0 +1,4 @@
+import { DBConfig, IDBDriver } from "./types";
+export declare class DBConnector {
+    static create(config: DBConfig): IDBDriver;
+}

package/templates/static/lib/db/connector.js

@@ -0,0 +1,33 @@
+/*
+ * This file is part of Jen.js.
+ * Copyright (C) 2026 oopsio
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import { JDBDriver } from "./drivers/jdb";
+import { SQLDriver } from "./drivers/sql";
+export class DBConnector {
+    static create(config) {
+        switch (config.type) {
+            case "jdb":
+                return new JDBDriver(config);
+            case "sqlite":
+            case "postgres":
+            case "mysql":
+                return new SQLDriver(config);
+            default:
+                throw new Error(`Unsupported DB type: ${config.type}`);
+        }
+    }
+}

package/templates/static/lib/db/drivers/jdb.d.ts

@@ -0,0 +1,13 @@
+import { IDBDriver, DBConfig, UnifiedQuery } from "../types";
+import { Filter, Update } from "../../jdb/types";
+export declare class JDBDriver implements IDBDriver {
+    private engine;
+    constructor(config: DBConfig);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    query<T = any>(q: UnifiedQuery<T>): Promise<T[]>;
+    create<T = any>(collection: string, data: any): Promise<T>;
+    update<T = any>(collection: string, filter: Filter<T>, update: Update<T>): Promise<number>;
+    delete<T = any>(collection: string, filter: Filter<T>): Promise<number>;
+    count<T = any>(collection: string, filter: Filter<T>): Promise<number>;
+}