create-jen-app 1.2.2 → 1.2.4

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

@@ -1,182 +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
-  */
+ * 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
+  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
-  */
+ * 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.`);
-    }
+  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);
+  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;
+  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");
-            };
-        }
+  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 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, []);
     }
-    async disconnect() {
-        // No-op or close pool
+    if ("sql" in q) {
+      return this.executor(q.sql, q.params || []);
     }
-    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);
+    // 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.`,
+      );
     }
-    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.`,
+          );
         }
-        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 };
+        // Safely access where property
+        const val = whereRecord[key];
+        conditions.push(`${quoteIdentifier(key)} = ?`);
+        params.push(val);
+      }
+      sql += ` WHERE ${conditions.join(" AND ")}`;
     }
-    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;
+    if (q.options?.limit) {
+      // Security: Validate limit is a positive integer
+      const limit = validateInteger(q.options.limit);
+      sql += ` LIMIT ${limit}`;
     }
-    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.");
+    if (q.options?.skip) {
+      // Security: Validate offset is a non-negative integer
+      const skip = validateInteger(q.options.skip);
+      sql += ` OFFSET ${skip}`;
     }
-    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
+    return { sql, params };
+  }
+  async create(collection, data) {
+    // Security: Validate table name
+    if (!isTableAllowed(collection)) {
+      throw new Error(
+        `Table '${collection}' not registered. Call registerAllowedTable() first.`,
+      );
     }
-    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;
+    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.js

@@ -1,65 +1,48 @@
-/*
- * 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);
-    }
+  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.js

@@ -1,18 +1 @@
-/*
- * 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/devtools/component-tree.js

@@ -0,0 +1,106 @@
+/*
+ * This file is part of Jen.js.
+ * Copyright (C) 2026 oopsio
+ */
+export class ComponentTreeManager {
+  components = new Map();
+  tree = [];
+  eventBus;
+  constructor(eventBus) {
+    this.eventBus = eventBus;
+  }
+  addComponent(component) {
+    this.components.set(component.id, component);
+    // Add to root tree if no parent
+    if (!component.parent) {
+      this.tree.push(component);
+    }
+    this.eventBus.emit("component:added", component);
+  }
+  getComponentById(id) {
+    return this.components.get(id);
+  }
+  getTree() {
+    return this.tree;
+  }
+  getNextComponent(current) {
+    if (current.children && current.children.length > 0) {
+      return current.children[0];
+    }
+    let node = current;
+    while (node) {
+      if (node.parent) {
+        const siblings = node.parent.children;
+        const index = siblings.indexOf(node);
+        if (index < siblings.length - 1) {
+          return siblings[index + 1];
+        }
+      } else {
+        // Check root level siblings
+        const index = this.tree.indexOf(node);
+        if (index < this.tree.length - 1) {
+          return this.tree[index + 1];
+        }
+      }
+      node = node.parent;
+    }
+    return null;
+  }
+  getPreviousComponent(current) {
+    if (current.parent) {
+      const siblings = current.parent.children;
+      const index = siblings.indexOf(current);
+      if (index > 0) {
+        const prev = siblings[index - 1];
+        return prev.children && prev.children.length > 0
+          ? this.getLastDescendant(prev)
+          : prev;
+      }
+      return current.parent;
+    }
+    const index = this.tree.indexOf(current);
+    if (index > 0) {
+      const prev = this.tree[index - 1];
+      return prev.children && prev.children.length > 0
+        ? this.getLastDescendant(prev)
+        : prev;
+    }
+    return null;
+  }
+  getLastDescendant(node) {
+    if (!node.children || node.children.length === 0) {
+      return node;
+    }
+    return this.getLastDescendant(node.children[node.children.length - 1]);
+  }
+  removeComponent(id) {
+    const component = this.components.get(id);
+    if (!component) return;
+    if (component.parent) {
+      const index = component.parent.children.indexOf(component);
+      if (index > -1) {
+        component.parent.children.splice(index, 1);
+      }
+    } else {
+      const index = this.tree.indexOf(component);
+      if (index > -1) {
+        this.tree.splice(index, 1);
+      }
+    }
+    this.components.delete(id);
+    this.eventBus.emit("component:removed", id);
+  }
+  updateComponent(id, updates) {
+    const component = this.components.get(id);
+    if (!component) return;
+    Object.assign(component, updates);
+    this.eventBus.emit("component:updated", component);
+  }
+  clear() {
+    this.components.clear();
+    this.tree = [];
+  }
+  getAllComponents() {
+    return Array.from(this.components.values());
+  }
+}