tss-stack 1.3.0 → 1.3.1

package/bin/cli.js

@@ -243,8 +243,15 @@ async function promptTableCount() {
     ]);
 }
 
+// ============================================================
+// ONLY THE CHANGED FUNCTION — drop this into your cli.js
+// replacing the existing promptTable() function.
+// Everything else in cli.js stays exactly the same.
+// ============================================================
+
 async function promptTable(index) {
-    return inquirer.prompt([
+    // ── Step A: basic table info ─────────────────────────────
+    const base = await inquirer.prompt([
         {
             name: "name",
             message: `Table ${index + 1} name (snake_case, e.g. spare_parts):`,
@@ -268,7 +275,6 @@ async function promptTable(index) {
             ],
             validate: (value) => (value.length > 0 ? true : "Select at least one operation."),
         },
-        // STEP 1 — per-table report opt-in
         {
             name: "reports",
             type: "confirm",
@@ -276,6 +282,74 @@ async function promptTable(index) {
             default: true,
         },
     ]);
+
+    // ── Step B: FK prompts — only for fields ending in _id ───
+    // Detect candidate FK fields automatically so the user
+    // doesn't have to think about it — just confirm or skip.
+    const fkFields = base.fields.filter((f) => f.endsWith("_id"));
+    const foreignKeys = [];
+
+    for (const field of fkFields) {
+        // Guess the referenced table name from the field name:
+        // spare_part_id  →  spare_parts  (strip _id, pluralise naively)
+        const guessedTable = field.replace(/_id$/, "") + "s";
+
+        logger.info(
+            `\n  ${COLORS.yellow}[FK]${COLORS.reset} "${field}" looks like a foreign key.`
+        );
+
+        const fkAnswer = await inquirer.prompt([
+            {
+                name: "confirm",
+                type: "confirm",
+                message: `  Add a FOREIGN KEY constraint for "${field}"?`,
+                default: true,
+            },
+        ]);
+
+        if (!fkAnswer.confirm) continue;
+
+        const fkDetails = await inquirer.prompt([
+            {
+                name: "refTable",
+                message: `  References which table?`,
+                default: guessedTable,
+                validate: validateTableName,
+            },
+            {
+                name: "refColumn",
+                message: `  References which column in that table?`,
+                default: "id",
+                validate: (v) =>
+                    /^[a-z][a-z0-9_]*$/.test(v)
+                        ? true
+                        : "Use lowercase snake_case.",
+            },
+            {
+                name: "onDelete",
+                type: "list",
+                message: `  ON DELETE behaviour:`,
+                // CASCADE  — delete child rows when parent is deleted
+                // SET NULL — set the FK column to NULL (column must allow NULL)
+                // RESTRICT — block parent deletion if children exist (safest default)
+                choices: [
+                    { name: "RESTRICT  (block deletion of referenced row)", value: "RESTRICT" },
+                    { name: "CASCADE   (delete this row too)", value: "CASCADE" },
+                    { name: "SET NULL  (set column to NULL)", value: "SET NULL" },
+                ],
+                default: "RESTRICT",
+            },
+        ]);
+
+        foreignKeys.push({
+            field,                          // e.g. spare_part_id
+            refTable: fkDetails.refTable,   // e.g. spare_parts
+            refColumn: fkDetails.refColumn, // e.g. id
+            onDelete: fkDetails.onDelete,   // e.g. RESTRICT
+        });
+    }
+
+    return { ...base, foreignKeys };
 }
 
 async function promptFeatures() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tss-stack",
-  "version": "1.3.0",
+  "version": "1.3.1",
   "description": "Interactive full-stack Node.js + React + MySQL project generator",
   "bin": {
     "tss-stack": "bin/cli.js"

package/src/generators/database.js

@@ -3,9 +3,78 @@ 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
@@ -16,6 +85,16 @@ 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,
@@ -27,26 +106,64 @@ USE ${escapeSqlIdentifier(dbName)};
 `;
     }
 
-    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 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) {
-            sql += `  ${escapeSqlIdentifier(field)} ${inferSqlType(field)} NOT NULL,\n`;
+            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,
-  updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
-);
+        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");
+    const outputPath = path.join(
+        targetDir,
+        "backend-project",
+        "config",
+        "database.sql"
+    );
+
     await fs.outputFile(outputPath, sql);
     console.log("  [✓] database.sql");
 }
 
-module.exports = { generateDatabase };
+module.exports = { generateDatabase };