drizzle-auto 1.1.24 → 1.1.26

package/index.js

@@ -1,187 +1,191 @@
 #!/usr/bin/env node
 
 /**
- * 🌟 Drizzle-Auto v2 - Fail-Fast Version
- * 🔹 Stops immediately on any error
- * 🔹 Strict config: drizzle.config.js / ts / mjs / cjs
- * 🔹 Watcher disabled on --postinstall
- * 🔹 Full error catching
+ * 🍵 Drizzle-Auto v2.3 - Flexible Config + Fail-Fast
+ * 🔹 Detects any drizzle.config.{js,ts,mjs,cjs,mts} automatically
+ * 🔹 Stops immediately if config or schema missing
+ * 🔹 Beginner-friendly logs
  */
 
 const { spawn } = require("child_process");
 const path = require("path");
 const fs = require("fs");
 
-// Optional TS support
+// TS support
 try { require("ts-node").register({ transpileOnly: true }); } catch(e){}
 
-// ---------------------- COLORS ----------------------
+// ---------------- COLORS ----------------
 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 ----------------------
+let spinInterval;
 const frames = ["⠋","⠙","⠹","⠸","⠼","⠴","⠦","⠧","⠇","⠏"];
-let spinIdx = 0, spinInterval;
+let spinIdx = 0;
 
 function startLoading(msg){
   stopLoading();
   spinInterval = setInterval(()=>{
     process.stdout.write(`\r${T.cyan}${frames[spinIdx++ % frames.length]}${T.reset} ${T.bold}${msg}${T.reset} `);
-  }, 80);
+  },80);
 }
 
 function stopLoading(){
   if(spinInterval){
     clearInterval(spinInterval);
-    spinInterval = null;
+    spinInterval=null;
     process.stdout.write("\r\x1b[K");
   }
 }
 
-// ---------------------- INJECT "tea" SCRIPT ----------------------
-const PKG = 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));
-  }
+// ---------------- ADD "tea" SCRIPT ----------------
+const PKG = path.join(process.cwd(),"package.json");
+function addTeaScript(){
+  if(!fs.existsSync(PKG)) return;
+  try{
+    const pkg = JSON.parse(fs.readFileSync(PKG,"utf8"));
+    pkg.scripts ||= {};
+    if(!pkg.scripts.tea){
+      pkg.scripts.tea = "drizzle-auto";
+      fs.writeFileSync(PKG, JSON.stringify(pkg,null,2));
+      console.log(`${T.lime}🍵 Added script → npm run tea${T.reset}`);
+    }
+  } catch(e){}
 }
-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);
-    });
+
+// ---------------- FIND ANY DRIZZLE CONFIG ----------------
+function findConfig(){
+  const allowedExts = ["js","ts","mjs","cjs","mts"];
+  const rootFiles = fs.readdirSync(process.cwd());
+  for(const file of rootFiles){
+    const match = file.match(/^drizzle\.config\.(.+)$/i);
+    if(match && allowedExts.includes(match[1])) return path.join(process.cwd(),file);
   }
-  walk(root);
-  return files;
+  return null;
 }
 
-// ---------------------- 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}` };
+// ---------------- CHECK SCHEMA ----------------
+function checkSchema(configPath){
+  try{
+    const cfg = require(configPath);
+    const schemaPath = cfg.default?.schema || cfg.schema;
+    if(!schemaPath){
+      console.log(`${T.yellow}⚠ Warning: schema not defined in ${path.basename(configPath)}${T.reset}`);
+      return true; // optional
+    }
+    const fullSchema = path.resolve(path.dirname(configPath), schemaPath);
+    if(!fs.existsSync(fullSchema)){
+      console.log(`${T.red}❌ ERROR: Schema file missing → ${fullSchema}${T.reset}`);
+      process.exit(1);
     }
+    return true;
+  } catch(e){
+    console.log(`${T.red}❌ ERROR: Cannot read config → ${e.message}${T.reset}`);
+    process.exit(1);
   }
-
-  return { ok:true, config:configs };
 }
 
-// ---------------------- RUN SHELL COMMAND ----------------------
-function runCommand(cmd, label){
-  return new Promise((resolve, reject) => {
+// ---------------- RUN SHELL COMMAND ----------------
+function runCommand(cmd,label){
+  return new Promise((resolve,reject)=>{
     startLoading(label);
-    const child = spawn(cmd, { shell: true, stdio: "inherit" });
-    child.on("close", code => {
+    const child = spawn(cmd,{shell:true,stdio:["inherit","inherit","pipe"]});
+    let stderrData = "";
+    child.stderr.on("data", d=>{
+      stderrData += d.toString();
+      process.stderr.write(d);
+    });
+    child.on("close", code=>{
       stopLoading();
-      if(code !== 0) reject(new Error(`${label} failed with exit code ${code}`));
+      const hasError = code!==0 || /ErrorEvent|ENOTFOUND|failed to connect/i.test(stderrData);
+      if(hasError) reject(new Error(`${label} failed!`));
       else resolve();
     });
-    child.on("error", err => {
+    child.on("error", err=>{
       stopLoading();
-      reject(new Error(`${label} failed: ${err.message}`));
+      reject(err);
     });
   });
 }
 
-// ---------------------- ENGINE ----------------------
-let running = false;
+// ---------------- ENGINE ----------------
+let isRunning=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;
-    process.exit(1); // <- stop immediately
+  if(isRunning) return;
+  isRunning=true;
+
+  const configPath = findConfig();
+  if(!configPath){
+    console.log(`${T.red}❌ ERROR: No drizzle config found!${T.reset}`);
+    console.log(`${T.yellow}Expected one of: drizzle.config.js/ts/mjs/cjs/mts${T.reset}`);
+    process.exit(1);
   }
 
+  checkSchema(configPath);
+
   const steps = [
-    {name:"Integrity Check", cmd:"drizzle-kit check"},
-    {name:"Generate Migration", cmd:"drizzle-kit generate"},
-    {name:"Push Database", cmd:"drizzle-kit push"}
+    {name:"Integrity Check", cmd:"npx drizzle-kit check"},
+    {name:"Generate Migration", cmd:"npx drizzle-kit generate"},
+    {name:"Push Database", cmd:"npx drizzle-kit push"}
   ];
 
-  try {
+  try{
     for(const step of steps){
-      await runCommand(step.cmd, step.name);
+      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}`);
-    process.exit(1); // <- stop immediately on any error
+    console.log(`\n${T.lime}🎉 SUCCESS: All steps finished.${T.reset}\n`);
+  } catch(e){
+    console.log(`\n${T.red}🚨 CRITICAL STOP: ${e.message}${T.reset}`);
+    process.exit(1);
+  } finally{
+    isRunning=false;
   }
-
-  running = false;
 }
 
-// ---------------------- WATCHER ----------------------
-const skipWatcher = process.argv.includes('--postinstall');
+// ---------------- MAIN ----------------
+addTeaScript();
 
-if(!skipWatcher){
-  const configsExist = findDrizzleConfig(process.cwd()).length > 0;
-  if(configsExist){
-    triggerEngine();
+const skipWatcher = process.argv.includes("--postinstall");
 
+if(skipWatcher){
+  triggerEngine();
+}else{
+  triggerEngine();
+
+  try{
     const chokidar = require("chokidar");
+    let timer;
     chokidar.watch(".",{
-      ignored:[/node_modules/,/\.git/,/\.next|dist/],
+      ignored:[/node_modules/,/\.git/,/\.next/,/dist/,/out/],
       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}`);
+    }).on("all",(e,f)=>{
+      clearTimeout(timer);
+      timer=setTimeout(()=>{
+        console.log(`${T.gray}🔄 Change detected, re-running...${T.reset}`);
+        triggerEngine();
+      },500);
+    });
+    console.log(`${T.gray}👀 Watching for changes in config/schema...${T.reset}`);
+  } catch(e){
+    console.log(`${T.yellow}⚠ Chokidar not installed. Watch mode disabled.${T.reset}`);
   }
 }
 
-// ---------------------- GLOBAL ERROR HANDLING ----------------------
-process.on("uncaughtException", err=>{
-  console.log(`${T.red}${T.bold}🛡️ UNCAUGHT ERROR:${T.reset} ${err.message}`);
-  process.exit(1); // <- stop immediately
+// ---------------- GLOBAL ERROR CATCH ----------------
+process.on("uncaughtException",err=>{
+  console.log(`${T.red}🛡️ UNCAUGHT ERROR: ${err.message}${T.reset}`);
+  process.exit(1);
 });
 
-process.on("SIGINT", ()=>{
+process.on("SIGINT",()=>{
   console.log(`${T.yellow}Shutting down Drizzle-Auto...${T.reset}`);
   process.exit(0);
 });

package/package.json

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