tss-stack 1.2.3 → 1.3.1

package/src/generators/database.js

@@ -1,55 +1,169 @@
-const fs = require("fs-extra");
-const path = require("path");
-
-const { toPascal, escapeSqlIdentifier, inferSqlType } = require("./utils");
-
-async function generateDatabase(config) {
-    const { dbName, tables, needsAuth, targetDir } = config;
-
-    let sql = `-- ======================================================
--- Database: ${dbName}
--- Generated automatically
--- ======================================================
-
-CREATE DATABASE IF NOT EXISTS ${escapeSqlIdentifier(dbName)};
-USE ${escapeSqlIdentifier(dbName)};
-
-`;
-
-    if (needsAuth) {
-        sql += `CREATE TABLE IF NOT EXISTS users (
-  id INT AUTO_INCREMENT PRIMARY KEY,
-  username VARCHAR(100) NOT NULL UNIQUE,
-  password VARCHAR(255) NOT NULL,
-  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-);
-
-`;
-    }
-
-    for (const table of tables) {
-        sql += `-- ${toPascal(table.name)} table
-CREATE TABLE IF NOT EXISTS ${escapeSqlIdentifier(table.name)} (
-  id INT AUTO_INCREMENT PRIMARY KEY,
-`;
-
-        for (const field of table.fields) {
-            sql += `  ${escapeSqlIdentifier(field)} ${inferSqlType(field)} NOT NULL,
-`;
-        }
-
-        sql += `  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-  updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
-);
-
-`;
-    }
-
-    const outputPath = path.join(targetDir, "backend-project", "config", "database.sql");
-    await fs.outputFile(outputPath, sql);
-    console.log("  [✓] database.sql");
-}
-
-module.exports = {
-    generateDatabase,
-};
+const fs = require("fs-extra");
+const path = require("path");
+
+const { toPascal, escapeSqlIdentifier, inferSqlType } = require("./utils");
+
+/* ==========================================================================
+   TOPOLOGICAL SORT
+   Ensures tables are created in the right order so that a FOREIGN KEY
+   never references a table that hasn't been created yet.
+
+   Example: stock_in references spare_parts
+   → spare_parts must appear before stock_in in the SQL file
+
+   Algorithm: Kahn's algorithm (BFS-based topological sort)
+   If a cycle is detected (table A references B which references A),
+   we fall back to the original order and add a warning comment.
+========================================================================== */
+
+function sortTablesByDependency(tables) {
+    // Build a map of tableName → table object for quick lookup
+    const tableMap = new Map(tables.map((t) => [t.name, t]));
+
+    // in-degree = number of tables this table depends on
+    const inDegree = new Map(tables.map((t) => [t.name, 0]));
+
+    // adjacency list: if A depends on B, then B → [A, ...]
+    const dependents = new Map(tables.map((t) => [t.name, []]));
+
+    for (const table of tables) {
+        const fks = table.foreignKeys || [];
+        for (const fk of fks) {
+            // Only count dependencies on tables we know about
+            if (!tableMap.has(fk.refTable)) continue;
+            // Ignore self-references (table referencing itself)
+            if (fk.refTable === table.name) continue;
+
+            inDegree.set(table.name, (inDegree.get(table.name) || 0) + 1);
+            dependents.get(fk.refTable).push(table.name);
+        }
+    }
+
+    // Start with tables that have no dependencies
+    const queue = tables
+        .filter((t) => inDegree.get(t.name) === 0)
+        .map((t) => t.name);
+
+    const sorted = [];
+
+    while (queue.length > 0) {
+        const current = queue.shift();
+        sorted.push(tableMap.get(current));
+
+        for (const dependent of dependents.get(current) || []) {
+            const newDegree = inDegree.get(dependent) - 1;
+            inDegree.set(dependent, newDegree);
+            if (newDegree === 0) queue.push(dependent);
+        }
+    }
+
+    // If not all tables were sorted, a cycle exists — fall back to original order
+    if (sorted.length !== tables.length) {
+        return { tables, hasCycle: true };
+    }
+
+    return { tables: sorted, hasCycle: false };
+}
+
+/* ==========================================================================
+   GENERATE DATABASE SQL
+========================================================================== */
+
+async function generateDatabase(config) {
+    const { dbName, tables, needsAuth, targetDir } = config;
+
+    // Sort tables so referenced tables are created first
+    const { tables: sortedTables, hasCycle } = sortTablesByDependency(tables);
+
+    let sql = `-- ======================================================
+-- Database: ${dbName}
+-- Generated automatically
+-- ======================================================
+
+CREATE DATABASE IF NOT EXISTS ${escapeSqlIdentifier(dbName)};
+USE ${escapeSqlIdentifier(dbName)};
+
+`;
+
+    if (hasCycle) {
+        sql += `-- WARNING: A circular foreign key reference was detected.
+-- Tables are in their original order. You may need to adjust
+-- the CREATE TABLE statements manually.
+
+`;
+    }
+
+    // users table always first when auth is enabled,
+    // since other tables may FK to it
+    if (needsAuth) {
+        sql += `CREATE TABLE IF NOT EXISTS users (
+  id INT AUTO_INCREMENT PRIMARY KEY,
+  username VARCHAR(100) NOT NULL UNIQUE,
+  password VARCHAR(255) NOT NULL,
+  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+`;
+    }
+
+    for (const table of sortedTables) {
+        const fks = table.foreignKeys || [];
+
+        sql += `-- ${toPascal(table.name)} table\n`;
+        sql += `CREATE TABLE IF NOT EXISTS ${escapeSqlIdentifier(table.name)} (\n`;
+        sql += `  id INT AUTO_INCREMENT PRIMARY KEY,\n`;
+
+        // ── Column definitions ─────────────────────────────────────────────
+        for (const field of table.fields) {
+            const sqlType = inferSqlType(field);
+
+            // If this field is a FK, it must allow NULL only when ON DELETE SET NULL
+            // is chosen. Otherwise keep NOT NULL.
+            const fk = fks.find((f) => f.field === field);
+            const nullable = fk && fk.onDelete === "SET NULL" ? "NULL" : "NOT NULL";
+
+            sql += `  ${escapeSqlIdentifier(field)} ${sqlType} ${nullable},\n`;
+        }
+
+        sql += `  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,\n`;
+        sql += `  updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP`;
+
+        // ── FOREIGN KEY constraints ────────────────────────────────────────
+        // Written as inline table constraints after all columns.
+        // Format:
+        //   CONSTRAINT fk_<table>_<field>
+        //     FOREIGN KEY (<field>)
+        //     REFERENCES <refTable> (<refColumn>)
+        //     ON DELETE <behaviour>
+        if (fks.length > 0) {
+            sql += `,\n`;
+
+            fks.forEach((fk, i) => {
+                const constraintName = `fk_${table.name}_${fk.field}`;
+                const isLast = i === fks.length - 1;
+
+                sql += `  CONSTRAINT ${escapeSqlIdentifier(constraintName)}\n`;
+                sql += `    FOREIGN KEY (${escapeSqlIdentifier(fk.field)})\n`;
+                sql += `    REFERENCES ${escapeSqlIdentifier(fk.refTable)} (${escapeSqlIdentifier(fk.refColumn)})\n`;
+                sql += `    ON DELETE ${fk.onDelete}`;
+                sql += isLast ? "\n" : ",\n";
+            });
+        } else {
+            sql += `\n`;
+        }
+
+        sql += `);\n\n`;
+    }
+
+    const outputPath = path.join(
+        targetDir,
+        "backend-project",
+        "config",
+        "database.sql"
+    );
+
+    await fs.outputFile(outputPath, sql);
+    console.log("  [✓] database.sql");
+}
+
+module.exports = { generateDatabase };