create-jen-app 1.0.0 → 1.2.1

package/templates/static/lib/db/drivers/jdb.js

@@ -0,0 +1,59 @@
+/*
+ * 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 { JDBEngine } from "../../jdb";
+export class JDBDriver {
+    engine;
+    constructor(config) {
+        const jdbConfig = config.jdb || {
+            root: "./data",
+            inMemory: false,
+        };
+        this.engine = new JDBEngine(jdbConfig);
+    }
+    async connect() {
+        await this.engine.connect();
+    }
+    async disconnect() {
+        await this.engine.disconnect();
+    }
+    async query(q) {
+        if (typeof q === "string") {
+            throw new Error("Raw string queries not supported in JDB directly. Use object syntax.");
+        }
+        if ("sql" in q) {
+            throw new Error("SQL queries not supported in JDB driver.");
+        }
+        const query = q;
+        const coll = this.engine.collection(query.find);
+        return await coll.find(query.where || {}, query.options);
+    }
+    async create(collection, data) {
+        return await this.engine.collection(collection).insert(data);
+    }
+    async update(collection, filter, update) {
+        return await this.engine
+            .collection(collection)
+            .update(filter, update, true);
+    }
+    async delete(collection, filter) {
+        return await this.engine.collection(collection).delete(filter, true);
+    }
+    async count(collection, filter) {
+        return await this.engine.collection(collection).count(filter);
+    }
+}

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

@@ -0,0 +1,18 @@
+import { IDBDriver, DBConfig, UnifiedQuery } from "../types";
+import { Filter, Update } from "../../jdb/types";
+/**
+  * Validate and register allowed table/collection names for security
+  */
+export declare function registerAllowedTable(tableName: string): void;
+export declare class SQLDriver implements IDBDriver {
+    private executor;
+    constructor(config: DBConfig);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    query<T = any>(q: UnifiedQuery<T>): Promise<T[]>;
+    private translateQuery;
+    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>;
+}

package/templates/static/lib/db/drivers/sql.js

@@ -0,0 +1,182 @@
+/*
+ * 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/>.
+ */
+// Whitelist of allowed identifiers (table/column names) - must be explicitly allowed
+const ALLOWED_IDENTIFIERS = new Set();
+/**
+  * Safely quote SQL identifier to prevent injection
+  * Only accepts alphanumeric, underscore, dollar sign
+  * Note: Hyphen is NOT allowed as it can cause confusion with operators
+  */
+function quoteIdentifier(id) {
+    if (!id || !/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(id)) {
+        throw new Error(`Invalid SQL identifier: ${id}. Only alphanumeric, underscore, and dollar sign allowed. Must start with letter, underscore, or dollar.`);
+    }
+    return `\`${id}\``; // Use backticks for MySQL, adjust for other databases
+}
+/**
+  * Validate and register allowed table/collection names for security
+  */
+export function registerAllowedTable(tableName) {
+    if (/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(tableName)) {
+        ALLOWED_IDENTIFIERS.add(tableName);
+    }
+    else {
+        throw new Error(`Invalid table name: ${tableName}. Must start with letter, underscore, or dollar. Only alphanumeric, underscore, and dollar allowed.`);
+    }
+}
+/**
+ * Check if table is in allowed list
+ */
+function isTableAllowed(tableName) {
+    return ALLOWED_IDENTIFIERS.has(tableName);
+}
+/**
+ * Validate integer value (for LIMIT/OFFSET)
+ */
+function validateInteger(value) {
+    const num = parseInt(value, 10);
+    if (isNaN(num) || num < 0) {
+        throw new Error(`Invalid integer value: ${value}`);
+    }
+    return num;
+}
+export class SQLDriver {
+    executor;
+    constructor(config) {
+        if (typeof config.connection === "function") {
+            this.executor = config.connection;
+        }
+        else if (config.connection && config.connection.query) {
+            // Support objects like Pool or Client from pg/mysql
+            this.executor = (sql, params) => config.connection.query(sql, params);
+        }
+        else {
+            // Default stub that warns if no connection provided, or we could try to load a default
+            this.executor = async () => {
+                throw new Error("No SQL connection provided to SQLDriver");
+            };
+        }
+    }
+    async connect() {
+        // Connection management usually handled by the pool passed in, but we can add logic here if needed
+    }
+    async disconnect() {
+        // No-op or close pool
+    }
+    async query(q) {
+        if (typeof q === "string") {
+            return this.executor(q, []);
+        }
+        if ("sql" in q) {
+            return this.executor(q.sql, q.params || []);
+        }
+        // Convert NoSQL style to SQL (Basic translation)
+        const query = q;
+        const { sql, params } = this.translateQuery(query);
+        return this.executor(sql, params);
+    }
+    translateQuery(q) {
+        // Security: Validate table name
+        if (!isTableAllowed(q.find)) {
+            throw new Error(`Table '${q.find}' not registered. Call registerAllowedTable() first.`);
+        }
+        let sql = `SELECT * FROM ${quoteIdentifier(q.find)}`;
+        const params = [];
+        if (q.where && Object.keys(q.where).length > 0) {
+            const conditions = [];
+            const whereRecord = q.where;
+            for (const key in whereRecord) {
+                // Security: Validate column name
+                if (!/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key)) {
+                    throw new Error(`Invalid column name: ${key}. Must start with letter, underscore, or dollar. Only alphanumeric, underscore, and dollar allowed.`);
+                }
+                // Safely access where property
+                const val = whereRecord[key];
+                conditions.push(`${quoteIdentifier(key)} = ?`);
+                params.push(val);
+            }
+            sql += ` WHERE ${conditions.join(" AND ")}`;
+        }
+        if (q.options?.limit) {
+            // Security: Validate limit is a positive integer
+            const limit = validateInteger(q.options.limit);
+            sql += ` LIMIT ${limit}`;
+        }
+        if (q.options?.skip) {
+            // Security: Validate offset is a non-negative integer
+            const skip = validateInteger(q.options.skip);
+            sql += ` OFFSET ${skip}`;
+        }
+        return { sql, params };
+    }
+    async create(collection, data) {
+        // Security: Validate table name
+        if (!isTableAllowed(collection)) {
+            throw new Error(`Table '${collection}' not registered. Call registerAllowedTable() first.`);
+        }
+        const keys = Object.keys(data);
+        // Security: Validate all column names
+        for (const key of keys) {
+            if (!/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key)) {
+                throw new Error(`Invalid column name: ${key}. Must start with letter, underscore, or dollar. Only alphanumeric, underscore, and dollar allowed.`);
+            }
+        }
+        const placeholders = keys.map(() => "?").join(",");
+        const quotedKeys = keys.map((k) => quoteIdentifier(k)).join(",");
+        const sql = `INSERT INTO ${quoteIdentifier(collection)} (${quotedKeys}) VALUES (${placeholders})`;
+        const params = keys.map((k) => data[k]);
+        await this.executor(sql, params);
+        // Retrieve generic - this might need adjustment per driver for "returning" support
+        return data;
+    }
+    async update(collection, filter, update) {
+        // Basic implementation requiring WHERE clause
+        // This is complex to map generic Mongo-style updates to SQL without a robust builder
+        throw new Error("Complex update translation not implemented for Generic SQL Driver yet. Use raw SQL.");
+    }
+    async delete(collection, filter) {
+        // Security: Validate table name
+        if (!isTableAllowed(collection)) {
+            throw new Error(`Table '${collection}' not registered. Call registerAllowedTable() first.`);
+        }
+        // Validate that filter is not empty to prevent accidental full table delete
+        if (!filter || Object.keys(filter).length === 0) {
+            throw new Error("Delete requires at least one filter condition. Use truncate or raw SQL for full table deletion.");
+        }
+        const { sql, params } = this.translateQuery({
+            find: collection,
+            where: filter,
+        });
+        const deleteSql = sql.replace("SELECT \\*", "DELETE");
+        await this.executor(deleteSql, params);
+        return 1; // Unknown count without driver specific result
+    }
+    async count(collection, filter) {
+        // Security: Validate table name
+        if (!isTableAllowed(collection)) {
+            throw new Error(`Table '${collection}' not registered. Call registerAllowedTable() first.`);
+        }
+        const { sql, params } = this.translateQuery({
+            find: collection,
+            where: filter,
+        });
+        const countSql = sql.replace("SELECT *", "SELECT COUNT(*) as count");
+        const res = await this.executor(countSql, params);
+        return res[0]?.count || 0;
+    }
+}

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

@@ -0,0 +1,19 @@
+import { DBConfig, UnifiedQuery } from "./types";
+import { Filter, Update } from "../jdb/types";
+export * from "./types";
+export * from "./drivers/jdb";
+export * from "./drivers/sql";
+export declare class DB {
+    private driver;
+    private config;
+    constructor(config: DBConfig);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    query<T = any>(q: UnifiedQuery<T> | string, params?: any[]): Promise<T[]>;
+    find<T = any>(collection: string, filter?: Filter<T>, options?: any): Promise<T[]>;
+    findOne<T = any>(collection: string, filter: Filter<T>): Promise<T | null>;
+    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>;
+}

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

@@ -0,0 +1,65 @@
+/*
+ * 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 { DBConnector } from "./connector";
+export * from "./types";
+export * from "./drivers/jdb";
+export * from "./drivers/sql";
+export class DB {
+    driver;
+    config;
+    constructor(config) {
+        this.config = config;
+        this.driver = DBConnector.create(config);
+    }
+    async connect() {
+        await this.driver.connect();
+    }
+    async disconnect() {
+        await this.driver.disconnect();
+    }
+    async query(q, params) {
+        if (typeof q === "string") {
+            return this.driver.query({ sql: q, params });
+        }
+        return this.driver.query(q);
+    }
+    // Fluent API Shortcuts
+    find(collection, filter, options) {
+        return this.driver.query({ find: collection, where: filter, options });
+    }
+    async findOne(collection, filter) {
+        const res = await this.driver.query({
+            find: collection,
+            where: filter,
+            options: { limit: 1 },
+        });
+        return res[0] || null;
+    }
+    create(collection, data) {
+        return this.driver.create(collection, data);
+    }
+    update(collection, filter, update) {
+        return this.driver.update(collection, filter, update);
+    }
+    delete(collection, filter) {
+        return this.driver.delete(collection, filter);
+    }
+    count(collection, filter) {
+        return this.driver.count(collection, filter);
+    }
+}

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

@@ -0,0 +1,29 @@
+import { Filter, Update, QueryOptions } from "../jdb/types";
+export type DBType = "jdb" | "sqlite" | "mysql" | "postgres";
+export interface DBConfig {
+    type: DBType;
+    connection?: any;
+    jdb?: {
+        root: string;
+        inMemory?: boolean;
+    };
+}
+export type FindQuery<T = any> = {
+    find: string;
+    where?: Filter<T>;
+    options?: QueryOptions;
+};
+export type SQLQuery = {
+    sql: string;
+    params?: any[];
+};
+export type UnifiedQuery<T = any> = FindQuery<T> | SQLQuery | string;
+export interface IDBDriver {
+    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>;
+}

package/templates/static/lib/db/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/graphql/index.d.ts

@@ -0,0 +1 @@
+export declare function runQuery(query: string, variables?: any): Promise<void>;

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

@@ -0,0 +1,22 @@
+/*
+ * 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/>.
+ */
+// GraphQL utilities - external GraphQL library not included
+// Users should implement with their own graphql library (e.g., npm install graphql)
+export async function runQuery(query, variables) {
+    throw new Error("GraphQL implementation requires external library. Install: npm install graphql");
+}

package/templates/static/lib/graphql/resolvers.d.ts

@@ -0,0 +1,17 @@
+interface User {
+    id: string;
+    name: string;
+    email: string;
+}
+export declare const resolvers: {
+    users: () => User[];
+    createUser: ({ name, email }: {
+        name: string;
+        email: string;
+    }) => {
+        id: string;
+        name: string;
+        email: string;
+    };
+};
+export {};

package/templates/static/lib/graphql/resolvers.js

@@ -0,0 +1,26 @@
+/*
+ * 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/>.
+ */
+const users = [];
+export const resolvers = {
+    users: () => users,
+    createUser: ({ name, email }) => {
+        const user = { id: (users.length + 1).toString(), name, email };
+        users.push(user);
+        return user;
+    },
+};

package/templates/static/lib/graphql/schema.d.ts

@@ -0,0 +1 @@
+export declare const schema: null;

package/templates/static/lib/graphql/schema.js

@@ -0,0 +1,20 @@
+/*
+ * 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/>.
+ */
+// GraphQL schema - external GraphQL library not included
+// Users should implement with their own graphql library (e.g., npm install graphql)
+export const schema = null;

package/templates/static/lib/i18n/en.json

@@ -0,0 +1,4 @@
+{
+    "hello": "Hello",
+    "welcome": "Welcome"
+}

package/templates/static/lib/i18n/es.json

@@ -0,0 +1,4 @@
+{
+    "hello": "Hola",
+    "welcome": "Bienvenido"
+}

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

@@ -0,0 +1,8 @@
+type Locale = "en" | "es";
+export declare class I18n {
+    private locale;
+    constructor(defaultLocale?: Locale);
+    setLocale(locale: Locale): void;
+    t(key: string): string;
+}
+export {};

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

@@ -0,0 +1,32 @@
+/*
+ * 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 en from "./en.json";
+import es from "./es.json";
+const translations = { en, es };
+export class I18n {
+    locale;
+    constructor(defaultLocale = "en") {
+        this.locale = defaultLocale;
+    }
+    setLocale(locale) {
+        this.locale = locale;
+    }
+    t(key) {
+        return translations[this.locale][key] || key;
+    }
+}

package/templates/static/lib/import/jen-import.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Universal module importer for Vue, Svelte, and regular JS/TS
+ *
+ * @example
+ * const Button = await jen.import("./components/Button.vue");
+ * const Card = await jen.import("./ui/Card.svelte");
+ * const Utils = await jen.import("./utils.ts");
+ */
+export declare function jenImport(specifier: string, opts?: {
+    baseDir?: string;
+    cache?: boolean;
+    forceRecompile?: boolean;
+}): Promise<any>;
+/**
+ * Clear import cache for a specific file
+ */
+export declare function invalidateImportCache(specifier: string): void;
+/**
+ * Clear all import caches
+ */
+export declare function clearImportCache(): void;
+/**
+ * Export as global jen.import if needed
+ */
+export declare const jen: {
+    import: typeof jenImport;
+};