create-jen-app 0.1.0

package/templates/static/lib/jdb/engine.js

@@ -0,0 +1,176 @@
+/*
+ * 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 path from "path";
+import { ensureDir, readJSON, writeJSON, generateId, matchFilter, applyUpdate, } from "./utils";
+class JDBCollection {
+    name;
+    dir;
+    inMemory;
+    file;
+    data = [];
+    loaded = false;
+    saving = false;
+    queueSave = false;
+    constructor(name, dir, inMemory) {
+        this.name = name;
+        this.dir = dir;
+        this.inMemory = inMemory;
+        this.file = path.join(dir, `${name}.jdb`);
+    }
+    async load() {
+        if (this.loaded)
+            return;
+        if (!this.inMemory) {
+            await ensureDir(this.dir);
+            const content = await readJSON(this.file);
+            this.data = content || [];
+        }
+        this.loaded = true;
+    }
+    async save() {
+        if (this.inMemory)
+            return;
+        if (this.saving) {
+            this.queueSave = true;
+            return;
+        }
+        this.saving = true;
+        try {
+            await writeJSON(this.file, this.data);
+        }
+        finally {
+            this.saving = false;
+            if (this.queueSave) {
+                this.queueSave = false;
+                this.save();
+            }
+        }
+    }
+    async insert(doc) {
+        await this.load();
+        const now = Date.now();
+        const newDoc = {
+            _id: doc._id || generateId(),
+            _created: now,
+            _updated: now,
+            ...doc,
+        };
+        this.data.push(newDoc);
+        this.save();
+        return newDoc;
+    }
+    async insertMany(docs) {
+        await this.load();
+        const now = Date.now();
+        const newDocs = docs.map((doc) => ({
+            _id: doc._id || generateId(),
+            _created: now,
+            _updated: now,
+            ...doc,
+        }));
+        this.data.push(...newDocs);
+        this.save();
+        return newDocs;
+    }
+    async findOne(filter) {
+        await this.load();
+        return this.data.find((doc) => matchFilter(doc, filter)) || null;
+    }
+    async find(filter, options) {
+        await this.load();
+        let result = this.data.filter((doc) => matchFilter(doc, filter));
+        if (options?.sort) {
+            const sortKeys = Object.keys(options.sort);
+            result.sort((a, b) => {
+                for (const key of sortKeys) {
+                    const dir = options.sort[key];
+                    if (a[key] < b[key])
+                        return -1 * dir;
+                    if (a[key] > b[key])
+                        return 1 * dir;
+                }
+                return 0;
+            });
+        }
+        if (options?.skip) {
+            result = result.slice(options.skip);
+        }
+        if (options?.limit) {
+            result = result.slice(0, options.limit);
+        }
+        return result;
+    }
+    async update(filter, update, multi = false) {
+        await this.load();
+        let count = 0;
+        for (const doc of this.data) {
+            if (matchFilter(doc, filter)) {
+                applyUpdate(doc, update);
+                count++;
+                if (!multi)
+                    break;
+            }
+        }
+        if (count > 0)
+            this.save();
+        return count;
+    }
+    async delete(filter, multi = false) {
+        await this.load();
+        const originalLen = this.data.length;
+        if (!multi) {
+            const index = this.data.findIndex((doc) => matchFilter(doc, filter));
+            if (index !== -1) {
+                this.data.splice(index, 1);
+                this.save();
+                return 1;
+            }
+            return 0;
+        }
+        else {
+            this.data = this.data.filter((doc) => !matchFilter(doc, filter));
+            const deleted = originalLen - this.data.length;
+            if (deleted > 0)
+                this.save();
+            return deleted;
+        }
+    }
+    async count(filter) {
+        await this.load();
+        return this.data.filter((doc) => matchFilter(doc, filter)).length;
+    }
+}
+export class JDBEngine {
+    config;
+    collections = new Map();
+    constructor(config) {
+        this.config = config;
+    }
+    async connect() {
+        await ensureDir(this.config.root);
+    }
+    async disconnect() {
+        // No-op for file based, maybe ensure all saves are flushed
+    }
+    collection(name) {
+        if (!this.collections.has(name)) {
+            this.collections.set(name, new JDBCollection(name, this.config.root, !!this.config.inMemory));
+        }
+        return this.collections.get(name);
+    }
+}

package/templates/static/lib/jdb/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./types";
+export { JDBEngine } from "./engine";

package/templates/static/lib/jdb/index.js

@@ -0,0 +1,19 @@
+/*
+ * 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 * from "./types";
+export { JDBEngine } from "./engine";

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

@@ -0,0 +1,46 @@
+export type JDBConfig = {
+    root: string;
+    inMemory?: boolean;
+};
+export type Document = Record<string, any> & {
+    _id: string;
+    _created: number;
+    _updated: number;
+};
+export type FilterOperator = "$eq" | "$ne" | "$gt" | "$gte" | "$lt" | "$lte" | "$in" | "$nin" | "$regex";
+export type Filter<T = any> = {
+    [K in keyof T]?: T[K] | {
+        [op in FilterOperator]?: any;
+    };
+} & {
+    $or?: Filter<T>[];
+    $and?: Filter<T>[];
+};
+export type UpdateOperator = "$set" | "$unset" | "$inc" | "$push" | "$pull";
+export type Update<T = any> = {
+    [op in UpdateOperator]?: Partial<T> | Record<string, any>;
+};
+export type QueryOptions = {
+    limit?: number;
+    skip?: number;
+    sort?: Record<string, 1 | -1>;
+};
+export interface IDatabaseEngine {
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    collection(name: string): ICollection;
+}
+export interface ICollection<T extends Document = Document> {
+    name: string;
+    insert(doc: Omit<T, "_id" | "_created" | "_updated"> & {
+        _id?: string;
+    }): Promise<T>;
+    insertMany(docs: (Omit<T, "_id" | "_created" | "_updated"> & {
+        _id?: string;
+    })[]): Promise<T[]>;
+    findOne(filter: Filter<T>): Promise<T | null>;
+    find(filter: Filter<T>, options?: QueryOptions): Promise<T[]>;
+    update(filter: Filter<T>, update: Update<T>, multi?: boolean): Promise<number>;
+    delete(filter: Filter<T>, multi?: boolean): Promise<number>;
+    count(filter: Filter<T>): Promise<number>;
+}

package/templates/static/lib/jdb/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/jdb/utils.d.ts

@@ -0,0 +1,6 @@
+export declare function ensureDir(dir: string): Promise<void>;
+export declare function readJSON<T>(file: string): Promise<T | null>;
+export declare function writeJSON(file: string, data: any): Promise<void>;
+export declare function generateId(): string;
+export declare function matchFilter(doc: any, filter: any): boolean;
+export declare function applyUpdate(doc: any, update: any): void;

package/templates/static/lib/jdb/utils.js

@@ -0,0 +1,141 @@
+/*
+ * 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 fs from "fs/promises";
+import crypto from "crypto";
+export async function ensureDir(dir) {
+    try {
+        await fs.access(dir);
+    }
+    catch {
+        await fs.mkdir(dir, { recursive: true });
+    }
+}
+export async function readJSON(file) {
+    try {
+        const data = await fs.readFile(file, "utf-8");
+        return JSON.parse(data);
+    }
+    catch (e) {
+        if (e.code === "ENOENT")
+            return null;
+        throw e;
+    }
+}
+export async function writeJSON(file, data) {
+    const tempFile = `${file}.tmp`;
+    await fs.writeFile(tempFile, JSON.stringify(data, null, 2));
+    await fs.rename(tempFile, file);
+}
+export function generateId() {
+    return crypto.randomUUID();
+}
+export function matchFilter(doc, filter) {
+    for (const key in filter) {
+        if (key === "$or") {
+            if (!filter.$or.some((f) => matchFilter(doc, f)))
+                return false;
+            continue;
+        }
+        if (key === "$and") {
+            if (!filter.$and.every((f) => matchFilter(doc, f)))
+                return false;
+            continue;
+        }
+        const val = doc[key];
+        const cond = filter[key];
+        if (typeof cond === "object" && cond !== null && !Array.isArray(cond)) {
+            for (const op in cond) {
+                const target = cond[op];
+                switch (op) {
+                    case "$eq":
+                        if (val !== target)
+                            return false;
+                        break;
+                    case "$ne":
+                        if (val === target)
+                            return false;
+                        break;
+                    case "$gt":
+                        if (!(val > target))
+                            return false;
+                        break;
+                    case "$gte":
+                        if (!(val >= target))
+                            return false;
+                        break;
+                    case "$lt":
+                        if (!(val < target))
+                            return false;
+                        break;
+                    case "$lte":
+                        if (!(val <= target))
+                            return false;
+                        break;
+                    case "$in":
+                        if (!target.includes(val))
+                            return false;
+                        break;
+                    case "$nin":
+                        if (target.includes(val))
+                            return false;
+                        break;
+                    case "$regex":
+                        if (!new RegExp(target).test(val))
+                            return false;
+                        break;
+                }
+            }
+        }
+        else {
+            if (val !== cond)
+                return false;
+        }
+    }
+    return true;
+}
+export function applyUpdate(doc, update) {
+    const now = Date.now();
+    doc._updated = now;
+    for (const op in update) {
+        const fields = update[op];
+        for (const key in fields) {
+            const val = fields[key];
+            switch (op) {
+                case "$set":
+                    doc[key] = val;
+                    break;
+                case "$unset":
+                    delete doc[key];
+                    break;
+                case "$inc":
+                    doc[key] = (doc[key] || 0) + val;
+                    break;
+                case "$push":
+                    if (!Array.isArray(doc[key]))
+                        doc[key] = [];
+                    doc[key].push(val);
+                    break;
+                case "$pull":
+                    if (Array.isArray(doc[key])) {
+                        doc[key] = doc[key].filter((item) => item !== val);
+                    }
+                    break;
+            }
+        }
+    }
+}

package/templates/static/lib/middleware/builtins/body-parser.d.ts

@@ -0,0 +1 @@
+export function bodyParser(ctx: any, next: any): Promise<any>;

package/templates/static/lib/middleware/builtins/body-parser.js

@@ -0,0 +1,55 @@
+/*
+ * 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 async function bodyParser(ctx, next) {
+    if (ctx.req.method === "GET" || ctx.req.method === "HEAD") {
+        return next();
+    }
+    const chunks = [];
+    await new Promise((resolve, reject) => {
+        ctx.req.on("data", (chunk) => chunks.push(chunk));
+        ctx.req.on("end", () => {
+            const data = Buffer.concat(chunks).toString();
+            const contentType = ctx.req.headers["content-type"] || "";
+            try {
+                if (contentType.includes("application/json")) {
+                    if (!data || data.trim() === "") {
+                        ctx.body = {};
+                    }
+                    else {
+                        ctx.body = JSON.parse(data);
+                    }
+                }
+                else if (contentType.includes("application/x-www-form-urlencoded")) {
+                    ctx.body = new URLSearchParams(data);
+                }
+                else {
+                    ctx.body = data;
+                }
+            }
+            catch (e) {
+                const error = e instanceof Error ? e.message : String(e);
+                console.error("Body parser error:", error);
+                ctx.parseError = error;
+                ctx.body = data; // Raw string on failure
+            }
+            resolve();
+        });
+        ctx.req.on("error", reject);
+    });
+    await next();
+}

package/templates/static/lib/middleware/builtins/cors.d.ts

@@ -0,0 +1,13 @@
+/**
+ * CORS middleware with security defaults
+ * Prevents insecure origin sharing with credentials
+ */
+interface CORSOptions {
+    origin?: string | string[] | ((origin: string) => boolean) | "*";
+    methods?: string[];
+    allowedHeaders?: string[];
+    credentials?: boolean;
+    maxAge?: number;
+}
+export declare function cors(options?: CORSOptions): (ctx: any, next: () => Promise<void>) => Promise<void>;
+export {};

package/templates/static/lib/middleware/builtins/cors.js

@@ -0,0 +1,67 @@
+/*
+ * 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 cors(options = {}) {
+    const defaults = {
+        origin: ["http://localhost:3000", "http://localhost:5173"],
+        methods: ["GET", "HEAD", "PUT", "PATCH", "POST", "DELETE"],
+        allowedHeaders: ["Content-Type", "Authorization"],
+        credentials: false, // Changed: credentials should be false with CORS by default for security
+        maxAge: 86400,
+    };
+    const opts = { ...defaults, ...options };
+    return async (ctx, next) => {
+        const origin = ctx.req.headers.origin;
+        // Validate origin against whitelist
+        let allowOrigin = false;
+        if (Array.isArray(opts.origin)) {
+            allowOrigin = origin && opts.origin.includes(origin);
+        }
+        else if (typeof opts.origin === "function") {
+            allowOrigin = origin && opts.origin(origin);
+        }
+        else if (opts.origin === "*") {
+            // DANGEROUS: only use with credentials: false
+            if (opts.credentials) {
+                console.warn("SECURITY WARNING: CORS origin '*' with credentials=true is insecure. Origin set to empty.");
+                allowOrigin = false;
+            }
+            else {
+                allowOrigin = true;
+            }
+        }
+        else if (opts.origin === origin) {
+            allowOrigin = true;
+        }
+        if (allowOrigin && origin) {
+            ctx.response.header("Access-Control-Allow-Origin", origin);
+        }
+        if (opts.credentials) {
+            ctx.response.header("Access-Control-Allow-Credentials", "true");
+        }
+        if (ctx.req.method === "OPTIONS") {
+            ctx.response.header("Access-Control-Allow-Methods", opts.methods?.join(","));
+            ctx.response.header("Access-Control-Allow-Headers", opts.allowedHeaders?.join(","));
+            if (opts.maxAge) {
+                ctx.response.header("Access-Control-Max-Age", opts.maxAge);
+            }
+            ctx.response.status(204).send();
+            return;
+        }
+        await next();
+    };
+}

package/templates/static/lib/middleware/builtins/logger.d.ts

@@ -0,0 +1 @@
+export function logger(ctx: any, next: any): Promise<void>;

package/templates/static/lib/middleware/builtins/logger.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 { log } from "../../shared/log.js";
+export async function logger(ctx, next) {
+    const start = performance.now();
+    // Log request
+    const method = ctx.req.method;
+    const url = ctx.url.pathname;
+    const id = ctx.state.requestId ? `[${ctx.state.requestId}]` : "";
+    log.info(`${id} -> ${method} ${url}`);
+    try {
+        await next();
+    }
+    finally {
+        const ms = (performance.now() - start).toFixed(2);
+        log.info(`${id} <- ${method} ${url} ${ctx.res.statusCode} (${ms}ms)`);
+    }
+}

package/templates/static/lib/middleware/builtins/rate-limit.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Rate limiting middleware
+ * Protects against brute force and DDoS attacks
+ */
+export function rateLimit(options?: {}): (ctx: any, next: any) => Promise<void>;

package/templates/static/lib/middleware/builtins/rate-limit.js

@@ -0,0 +1,76 @@
+/*
+ * 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/>.
+ */
+/**
+ * Rate limiting middleware
+ * Protects against brute force and DDoS attacks
+ */
+export function rateLimit(options = {}) {
+    const defaults = {
+        windowMs: 15 * 60 * 1000, // 15 minutes
+        max: 100, // 100 requests per window
+        message: "Too many requests, please try again later.",
+        statusCode: 429,
+    };
+    const opts = { ...defaults, ...options };
+    const hits = new Map();
+    // Cleanup old records every minute to prevent memory leak
+    const cleanupInterval = setInterval(() => {
+        const now = Date.now();
+        for (const [key, record] of hits.entries()) {
+            if (now > record.resetTime) {
+                hits.delete(key);
+            }
+        }
+    }, 60 * 1000);
+    return async (ctx, next) => {
+        // Get IP address - check for X-Forwarded-For header (proxy)
+        let ip = ctx.req.headers["x-forwarded-for"];
+        if (typeof ip === "string") {
+            ip = ip.split(",")[0].trim(); // Get first IP if multiple
+        }
+        else {
+            ip = ctx.req.socket.remoteAddress || "unknown";
+        }
+        const now = Date.now();
+        let record = hits.get(ip);
+        if (!record || now > record.resetTime) {
+            record = {
+                count: 0,
+                resetTime: now + opts.windowMs,
+                firstRequest: now,
+            };
+            hits.set(ip, record);
+        }
+        record.count++;
+        const remaining = opts.max - record.count;
+        // Set rate limit headers (similar to GitHub API)
+        ctx.response.header("RateLimit-Limit", opts.max);
+        ctx.response.header("RateLimit-Remaining", Math.max(0, remaining));
+        ctx.response.header("RateLimit-Reset", Math.ceil(record.resetTime / 1000));
+        if (record.count > opts.max) {
+            const retryAfter = Math.ceil((record.resetTime - now) / 1000);
+            ctx.response.header("Retry-After", retryAfter);
+            ctx.response.status(opts.statusCode).json({
+                error: opts.message,
+                retryAfter,
+            });
+            return;
+        }
+        await next();
+    };
+}

package/templates/static/lib/middleware/builtins/request-id.d.ts

@@ -0,0 +1 @@
+export function requestId(ctx: any, next: any): Promise<void>;