drizzle-auto 1.1.23 → 1.1.25

package/index.js

@@ -1,185 +1,176 @@
 #!/usr/bin/env node
 
 /**
- * 🌟 Drizzle-Auto v2 - Termux/Next.js Friendly
- * 🔹 Strict config: drizzle.config.js / ts / mjs / cjs
- * 🔹 Skips watcher on postinstall
- * 🔹 Full error handling
+ * 🍵 Drizzle-Auto v2.1 - Fail-Fast Edition
+ * 🔹 Strictly catches WebSocket/Neon ENOTFOUND errors
+ * 🔹 Stops immediately on any failure
+ * 🔹 Debounced watcher to prevent race conditions
  */
 
-const { exec, spawn } = require("child_process");
+const { spawn } = require("child_process");
 const path = require("path");
 const fs = require("fs");
 
-// Optional: support TS configs
-try { require("ts-node").register({ transpileOnly: true }); } catch(e){}
+// Optional TS support for config parsing
+try { require("ts-node").register({ transpileOnly: true }); } catch (e) {}
 
-// ---------------------- COLORS ----------------------
+// ---------------------- COLORS & UI ----------------------
 const T = {
   reset: "\x1b[0m",
   bold: "\x1b[1m",
   cyan: "\x1b[38;5;51m",
-  pink: "\x1b[38;5;201m",
   lime: "\x1b[38;5;118m",
   yellow: "\x1b[38;5;226m",
   red: "\x1b[38;5;196m",
   gray: "\x1b[38;5;244m",
 };
 
-// ---------------------- SPINNER ----------------------
-const frames = ["⠋","⠙","⠹","⠸","⠼","⠴","⠦","⠧","⠇","⠏"];
+const frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
 let spinIdx = 0, spinInterval;
 
-function startLoading(msg){
+function startLoading(msg) {
   stopLoading();
-  spinInterval = setInterval(()=>{
+  spinInterval = setInterval(() => {
     process.stdout.write(`\r${T.cyan}${frames[spinIdx++ % frames.length]}${T.reset} ${T.bold}${msg}${T.reset} `);
   }, 80);
 }
 
-function stopLoading(){
-  if(spinInterval){
+function stopLoading() {
+  if (spinInterval) {
     clearInterval(spinInterval);
     spinInterval = null;
     process.stdout.write("\r\x1b[K");
   }
 }
 
-// ---------------------- INJECT "tea" SCRIPT ----------------------
-const PKG = path.join(process.cwd(), "package.json");
+// ---------------------- UTILS ----------------------
+const PKG_PATH = path.join(process.cwd(), "package.json");
 function injectScript() {
-  if (!fs.existsSync(PKG)) return;
-  const pkg = JSON.parse(fs.readFileSync(PKG, "utf8"));
-  pkg.scripts ||= {};
-  if (!pkg.scripts.tea) {
-    pkg.scripts.tea = "drizzle-auto";
-    console.log(`${T.lime}🍵 Script added → npm/yarn/pnpm run tea${T.reset}`);
-    fs.writeFileSync(PKG, JSON.stringify(pkg, null, 2));
-  }
-}
-injectScript();
-
-// ---------------------- STRICT CONFIG DETECTION ----------------------
-function findDrizzleConfig(root){
-  const allowed = [
-    "drizzle.config.js",
-    "drizzle.config.ts",
-    "drizzle.config.mjs",
-    "drizzle.config.cjs"
-  ];
-  const files = [];
-  function walk(dir){
-    fs.readdirSync(dir,{withFileTypes:true}).forEach(file=>{
-      const full = path.join(dir,file.name);
-      if(file.isDirectory() && !/node_modules|\.git|\.next|dist/.test(file.name)) walk(full);
-      else if(file.isFile() && allowed.includes(file.name)) files.push(full);
-    });
-  }
-  walk(root);
-  return files;
-}
-
-// ---------------------- VALIDATE SCHEMA ----------------------
-function validateSchema(){
-  const configs = findDrizzleConfig(process.cwd());
-  if(configs.length === 0) 
-    return { ok:false, msg:"Missing strict drizzle.config.js / ts / mjs / cjs" };
-
-  for(const cfg of configs){
-    try {
-      let schemaPath;
-      const mod = require(cfg);
-      schemaPath = mod.default?.schema || mod.schema;
-
-      if(!schemaPath) continue;
-
-      const schemaFull = path.resolve(path.dirname(cfg), schemaPath);
-      if(!fs.existsSync(schemaFull))
-        return { ok:false, msg:`Schema not found: ${schemaPath} in ${cfg}` };
-
-    } catch(e){
-      return { ok:false, msg:`Config parse error in ${cfg}: ${e.message}` };
+  if (!fs.existsSync(PKG_PATH)) return;
+  try {
+    const pkg = JSON.parse(fs.readFileSync(PKG_PATH, "utf8"));
+    pkg.scripts ||= {};
+    if (!pkg.scripts.tea) {
+      pkg.scripts.tea = "drizzle-auto";
+      fs.writeFileSync(PKG_PATH, JSON.stringify(pkg, null, 2));
+      console.log(`${T.lime}🍵 Script added → npm run tea${T.reset}`);
     }
-  }
-
-  return { ok:true, config:configs };
+  } catch (e) {}
 }
 
-// ---------------------- RUN SHELL COMMAND ----------------------
-function runCommand(cmd, label){
+// ---------------------- COMMAND RUNNER (STRICT) ----------------------
+function runCommand(cmd, label) {
   return new Promise((resolve, reject) => {
     startLoading(label);
-    const child = spawn(cmd, { shell: true, stdio: "inherit" });
-    child.on("close", code => {
+    
+    // We pipe stderr to catch hidden WebSocket/Neon errors that don't trigger exit codes
+    const child = spawn(cmd, { shell: true, stdio: ["inherit", "inherit", "pipe"] });
+    let errorOutput = "";
+
+    child.stderr.on("data", (data) => {
+      const str = data.toString();
+      errorOutput += str;
+      process.stderr.write(str); // Still show the error to the user
+    });
+
+    child.on("close", (code) => {
       stopLoading();
-      if(code !== 0) reject(new Error(`${label} failed with exit code ${code}`));
-      else resolve();
+      
+      // Strict failure check: 
+      // 1. Non-zero exit code
+      // 2. Presence of "ErrorEvent" or "ENOTFOUND" in stderr (Neon driver specific)
+      const hasDriverError = /ErrorEvent|ENOTFOUND|failed to connect/i.test(errorOutput);
+
+      if (code !== 0 || hasDriverError) {
+        reject(new Error(`${label} failed execution.`));
+      } else {
+        resolve();
+      }
     });
-    child.on("error", err => {
+
+    child.on("error", (err) => {
       stopLoading();
-      reject(new Error(`${label} failed: ${err.message}`));
+      reject(err);
     });
   });
 }
 
 // ---------------------- ENGINE ----------------------
-let running = false;
-async function triggerEngine(){
-  if(running) return;
-  running = true;
-
-  const audit = validateSchema();
-  if(!audit.ok){
-    console.log(`${T.red}${T.bold}👾 CRITICAL FAILURE:${T.reset} ${audit.msg}`);
-    running = false;
-    return;
-  }
+let isRunning = false;
+let isBroken = false;
 
-  const steps = [
-    {name:"Integrity Check", cmd:"drizzle-kit check"},
-    {name:"Generate Migration", cmd:"drizzle-kit generate"},
-    {name:"Push Database", cmd:"drizzle-kit push"}
-  ];
+async function triggerEngine() {
+  if (isRunning) return;
+  isRunning = true;
 
   try {
-    for(const step of steps){
+    const steps = [
+      { name: "Integrity Check", cmd: "npx drizzle-kit check" },
+      { name: "Generate Migration", cmd: "npx drizzle-kit generate" },
+      { name: "Push Database", cmd: "npx drizzle-kit push" }
+    ];
+
+    for (const step of steps) {
       await runCommand(step.cmd, step.name);
     }
-    console.log(`${T.lime}${T.bold}🎉 All steps successful!${T.reset}`);
-  } catch(err){
-    console.log(`${T.red}🚨 ERROR: ${err.message}${T.reset}`);
-  }
 
-  running = false;
+    console.log(`\n${T.lime}${T.bold}🎉 SUCCESS: Database synced.${T.reset}\n`);
+    isBroken = false;
+  } catch (err) {
+    isBroken = true;
+    console.log(`\n${T.red}${T.bold}🚨 CRITICAL STOP:${T.reset} ${err.message}`);
+    console.log(`${T.yellow}Execution paused. Fix the error and save any file to retry.${T.reset}\n`);
+    
+    if (process.argv.includes('--postinstall')) {
+      process.exit(1);
+    }
+  } finally {
+    isRunning = false;
+  }
 }
 
-// ---------------------- WATCHER ----------------------
+// ---------------------- MAIN / WATCHER ----------------------
+injectScript();
+
 const skipWatcher = process.argv.includes('--postinstall');
 
-if(!skipWatcher){
-  const configsExist = findDrizzleConfig(process.cwd()).length > 0;
-  if(configsExist){
-    triggerEngine();
+if (skipWatcher) {
+  triggerEngine();
+} else {
+  triggerEngine();
 
+  try {
     const chokidar = require("chokidar");
-    chokidar.watch(".",{
-      ignored:[/node_modules/,/\.git/,/\.next|dist/],
-      ignoreInitial:true,
-      usePolling:true,
-      interval:300
-    }).on("all", (e,f) => triggerEngine());
-  } else {
-    console.log(`${T.yellow}⚠ No strict drizzle.config found. Watcher disabled.${T.reset}`);
+    let debounceTimer;
+
+    const watcher = chokidar.watch(".", {
+      ignored: [/node_modules/, /\.git/, /\.next/, /dist/, /out/],
+      ignoreInitial: true,
+      usePolling: true,
+      interval: 300
+    });
+
+    watcher.on("all", (event, path) => {
+      clearTimeout(debounceTimer);
+      debounceTimer = setTimeout(() => {
+        if (isBroken) console.log(`${T.cyan}🔄 Change detected in ${path}. Retrying...${T.reset}`);
+        triggerEngine();
+      }, 500);
+    });
+
+    console.log(`${T.gray}👀 Watching for schema changes...${T.reset}`);
+  } catch (e) {
+    console.log(`${T.yellow}⚠ Chokidar not found. Watch mode disabled.${T.reset}`);
   }
 }
 
-// ---------------------- GLOBAL ERROR HANDLING ----------------------
-process.on("uncaughtException", err=>{
-  console.log(`${T.red}${T.bold}🛡️ ERROR:${T.reset} ${err.message}`);
-  running = false;
+// ---------------------- GLOBAL ERROR CATCH ----------------------
+process.on("uncaughtException", (err) => {
+  console.log(`\n${T.red}${T.bold}🛡️ UNCAUGHT ERROR:${T.reset} ${err.message}`);
+  process.exit(1);
 });
 
-process.on("SIGINT", ()=>{
-  console.log(`${T.yellow}Shutting down Drizzle-Auto...${T.reset}`);
+process.on("SIGINT", () => {
+  console.log(`\n${T.yellow}Shutting down Drizzle-Auto...${T.reset}`);
   process.exit(0);
-});
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "drizzle-auto",
-  "version": "1.1.23",
+  "version": "1.1.25",
   "description": "",
   "license": "ISC",
   "author": "pavel ahmmed hridoy",