@drzl/cli 0.1.0 → 0.3.0

package/dist/cli.cjs

@@ -24,14 +24,20 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/cli.ts
-var import_commander = require("commander");
+var import_analyzer = require("@drzl/analyzer");
+var import_generator_orpc = require("@drzl/generator-orpc");
 var import_chalk = __toESM(require("chalk"), 1);
-var import_ora = __toESM(require("ora"), 1);
+var import_chokidar = __toESM(require("chokidar"), 1);
 var import_cli_progress = __toESM(require("cli-progress"), 1);
+var import_commander = require("commander");
+var path2 = __toESM(require("path"), 1);
+var import_ora = __toESM(require("ora"), 1);
 
 // src/config.ts
+var fs = __toESM(require("fs"), 1);
+var import_node_module = require("module");
+var path = __toESM(require("path"), 1);
 var import_zod = require("zod");
-var import_meta = {};
 var NamingSchema = import_zod.z.object({
   routerSuffix: import_zod.z.string().default("Router"),
   procedureCase: import_zod.z.enum(["camel", "kebab", "snake"]).default("camel")
@@ -55,7 +61,7 @@ var GeneratorSchema = import_zod.z.object({
   dataAccess: import_zod.z.enum(["stub", "drizzle"]).default("stub").optional(),
   dbImportPath: import_zod.z.string().optional(),
   schemaImportPath: import_zod.z.string().optional(),
-  // zod generator specific options
+  // zod/valibot/arktype generator specific options
   schemaSuffix: import_zod.z.string().optional(),
   fileSuffix: import_zod.z.string().optional(),
   // orpc validation sharing
@@ -68,14 +74,15 @@ var GeneratorSchema = import_zod.z.object({
   // template options
   templateOptions: import_zod.z.record(import_zod.z.string(), import_zod.z.any()).optional()
 });
+var AnalyzerSchema = import_zod.z.object({
+  includeRelations: import_zod.z.boolean().default(true),
+  validateConstraints: import_zod.z.boolean().default(true),
+  includeHeuristicRelations: import_zod.z.boolean().default(false)
+});
 var ConfigSchema = import_zod.z.object({
   schema: import_zod.z.string(),
   outDir: import_zod.z.string().default("src/api"),
-  analyzer: import_zod.z.object({
-    includeRelations: import_zod.z.boolean().default(true),
-    validateConstraints: import_zod.z.boolean().default(true),
-    includeHeuristicRelations: import_zod.z.boolean().default(false)
-  }).default({
+  analyzer: AnalyzerSchema.default({
     includeRelations: true,
     validateConstraints: true,
     includeHeuristicRelations: false
@@ -83,55 +90,99 @@ var ConfigSchema = import_zod.z.object({
   generators: import_zod.z.array(GeneratorSchema).min(1).default([{ kind: "orpc" }])
 });
 async function loadConfig(customPath) {
-  const path = await import("path");
-  const fs = await import("fs/promises");
-  const candidates = customPath ? [customPath] : ["drzl.config.ts", "drzl.config.mjs", "drzl.config.js"];
+  const fsp = await import("fs/promises");
+  const candidates = customPath ? [customPath] : [
+    "drzl.config.ts",
+    "drzl.config.mjs",
+    "drzl.config.js",
+    "drzl.config.cjs",
+    "drzl.config.json"
+  ];
   for (const c of candidates) {
     const p = path.resolve(process.cwd(), c);
     try {
-      await fs.access(p);
+      await fsp.access(p);
     } catch {
       continue;
     }
-    if (/\.json$/i.test(p)) {
-      try {
-        const content = await fs.readFile(p, "utf8");
-        const raw = JSON.parse(content);
-        const parsed = ConfigSchema.parse(raw);
-        return parsed;
-      } catch (e2) {
-        throw new Error(`Failed to load config from ${p}: ${String(e2)}`);
-      }
+    const ext = path.extname(p).toLowerCase();
+    if (ext === ".json") {
+      const raw2 = JSON.parse(await fsp.readFile(p, "utf8"));
+      return ConfigSchema.parse(raw2);
     }
+    const { createJiti } = await import("jiti");
+    const stat = await fsp.stat(p);
+    const base = typeof __filename !== "undefined" ? __filename : path.join(process.cwd(), "index.js");
+    const jiti = createJiti(base, {
+      moduleCache: false,
+      // re-evaluate each time
+      fsCache: true,
+      // keep transform cache
+      cacheVersion: String(stat.mtimeMs),
+      // bump on edit
+      interopDefault: true,
+      tryNative: false
+      // <— prevent native import of .ts
+      // debug: true,
+    });
+    const mod = await jiti.import(p);
+    const raw = mod?.default ?? mod;
+    return ConfigSchema.parse(raw);
+  }
+  return null;
+}
+function computeGeneratorOutputDirs(cfg, cwd = process.cwd()) {
+  const abs = (p) => path.resolve(cwd, p);
+  const dirs = /* @__PURE__ */ new Set();
+  dirs.add(abs(cfg.outDir));
+  for (const g of cfg.generators) {
+    if (g.kind === "service") dirs.add(abs(g.path ?? "src/services"));
+    if (g.kind === "zod") dirs.add(abs(g.path ?? "src/validators/zod"));
+    if (g.kind === "valibot") dirs.add(abs(g.path ?? "src/validators/valibot"));
+    if (g.kind === "arktype") dirs.add(abs(g.path ?? "src/validators/arktype"));
+  }
+  return [...dirs];
+}
+function resolveTemplateDirsSync(cfg, cwd = process.cwd()) {
+  const results = [];
+  const req = (0, import_node_module.createRequire)(
+    typeof __filename !== "undefined" ? __filename : path.join(process.cwd(), "index.js")
+  );
+  for (const g of cfg.generators) {
+    const t = g.template;
+    if (!t || t === "standard" || t === "minimal") continue;
+    let pkgDir = null;
     try {
-      const { createJiti } = await import("jiti");
-      const jit = createJiti(import_meta.url);
-      const mod = await jit.import(p);
-      const raw = mod && typeof mod === "object" && "default" in mod ? mod.default : mod;
-      const parsed = ConfigSchema.safeParse(raw);
-      if (!parsed.success) {
-        throw new Error(parsed.error.message);
-      }
-      return parsed.data;
-    } catch (e) {
-      console.error(`jiti failed to load ${p}:`, e);
-      try {
-        const content = await fs.readFile(p, "utf8");
-        const raw = JSON.parse(content);
-        const parsed = ConfigSchema.parse(raw);
-        return parsed;
-      } catch (e2) {
-        throw new Error(`Failed to load config from ${p}: ${String(e2)}`);
-      }
+      const pkg = req.resolve(`${t}/package.json`, { paths: [cwd] });
+      pkgDir = path.dirname(pkg);
+    } catch {
+    }
+    if (pkgDir) {
+      results.push(pkgDir);
+      continue;
+    }
+    if (/[./\\]/.test(t)) {
+      const abs = path.resolve(cwd, t);
+      if (fs.existsSync(abs)) results.push(abs);
     }
   }
-  return null;
+  return Array.from(new Set(results));
+}
+function computeWatchTargets(cfg, cwd = process.cwd()) {
+  const abs = (p) => path.resolve(cwd, p);
+  const schemaAbs = abs(cfg.schema);
+  const targets = /* @__PURE__ */ new Set([
+    path.join(path.dirname(schemaAbs), "**/*.{ts,tsx,js}"),
+    abs("drzl.config.ts"),
+    abs("drzl.config.js"),
+    abs("drzl.config.mjs"),
+    abs("drzl.config.cjs")
+  ]);
+  for (const t of resolveTemplateDirsSync(cfg, cwd)) targets.add(t);
+  return [...targets];
 }
 
 // src/cli.ts
-var import_analyzer = require("@drzl/analyzer");
-var import_generator_orpc = require("@drzl/generator-orpc");
-var import_chokidar = __toESM(require("chokidar"), 1);
 var program = new import_commander.Command();
 program.name("drzl").description("DRZL - Drizzle Developer Toolkit").version("0.0.1");
 program.command("analyze").argument("<schema>", "path to drizzle schema (TS)").option("--relations", "include relations", true).option("--validate", "validate constraints", true).option("--out <file>", "write analysis JSON to file").option("--json", "print JSON to stdout (overrides --out)", false).action(async (schema, opts) => {
@@ -148,8 +199,8 @@ program.command("analyze").argument("<schema>", "path to drizzle schema (TS)").o
     if (opts.json) {
       console.log(json);
     } else if (opts.out) {
-      const fs = await import("fs/promises");
-      await fs.writeFile(opts.out, json, "utf8");
+      const fs2 = await import("fs/promises");
+      await fs2.writeFile(opts.out, json, "utf8");
       spinner?.succeed(import_chalk.default.green(`Analysis written to ${opts.out} in ${ms}ms`));
     } else {
       spinner?.succeed(import_chalk.default.green(`Analyzed in ${ms}ms`));
@@ -338,21 +389,84 @@ program.command("generate:orpc").argument("<schema>", "path to drizzle schema (T
     process.exit(1);
   }
 });
-program.command("watch").description("Watch schema and regenerate on changes").option("-c, --config <path>", "path to drzl.config").option("--pipeline <name>", "all | analyze | generate-orpc", "all").option("--debounce <ms>", "debounce ms", "200").option("--json", "emit JSON logs", false).action(async (opts) => {
-  const cfg = await loadConfig(opts.config);
+program.command("watch").description("Watch schema and regenerate on changes").option("-c, --config <path>", "path to drzl.config").option("--pipeline <name>", "all | analyze | generate-orpc", "all").option("--debounce <ms>", "debounce ms", "200").option("--json", "emit JSON logs", false).option("--poll", "force polling (helps WSL/Docker/remote FS)", false).action(async (opts) => {
+  let cfg = await loadConfig(opts.config);
   if (!cfg) {
     console.error(import_chalk.default.red("No config found. Create drzl.config.ts or pass --config."));
     process.exit(2);
     return;
   }
+  const abs = (p) => path2.resolve(process.cwd(), p);
+  const isInside = (child, parent) => {
+    const rel = path2.relative(parent, child);
+    return !!rel && !rel.startsWith("..") && !path2.isAbsolute(rel);
+  };
+  const ignoredOutDirs = new Set(computeGeneratorOutputDirs(cfg).map(abs));
+  const currentTargets = new Set(computeWatchTargets(cfg).map(abs));
+  const syncWatcherTargets = (watcher2, next) => {
+    const add = [];
+    const del = [];
+    for (const p of next) if (!currentTargets.has(p)) add.push(p);
+    for (const p of currentTargets) if (!next.has(p)) del.push(p);
+    if (add.length) watcher2.add(add);
+    if (del.length) watcher2.unwatch(del);
+    currentTargets.clear();
+    next.forEach((p) => currentTargets.add(p));
+  };
+  const rebuildIgnoreDirsFrom = (cfgNow) => {
+    ignoredOutDirs.clear();
+    for (const d of computeGeneratorOutputDirs(cfgNow)) ignoredOutDirs.add(abs(d));
+  };
+  const ignoredFn = (p) => {
+    const full = abs(p);
+    for (const dir of ignoredOutDirs) {
+      if (full === dir || isInside(full, dir)) return true;
+    }
+    return false;
+  };
+  const watcher = import_chokidar.default.watch(Array.from(currentTargets), {
+    ignoreInitial: true,
+    awaitWriteFinish: { stabilityThreshold: 400, pollInterval: 50 },
+    usePolling: !!opts.poll,
+    ignored: ignoredFn
+  });
+  const logTrigger = (type, file) => {
+    if (opts.json) console.log(JSON.stringify({ event: "trigger", type, file }));
+  };
+  watcher.on("add", (p) => {
+    logTrigger("add", p);
+    trigger(p);
+  }).on("change", (p) => {
+    logTrigger("change", p);
+    trigger(p);
+  }).on("unlink", (p) => {
+    logTrigger("unlink", p);
+    trigger(p);
+  });
   let lastFiles = [];
   const run = async () => {
     try {
+      const reloaded = await loadConfig(opts.config);
+      if (!reloaded) throw new Error("Config disappeared during watch.");
+      cfg = reloaded;
+      rebuildIgnoreDirsFrom(cfg);
+      const nextTargets = new Set(computeWatchTargets(cfg).map(abs));
+      syncWatcherTargets(watcher, nextTargets);
       if (!opts.json) console.clear();
+      if (opts.json) {
+        console.log(
+          JSON.stringify({
+            event: "watch_config_applied",
+            targets: Array.from(currentTargets),
+            ignored: Array.from(ignoredOutDirs)
+          })
+        );
+      }
       const analyzer = new import_analyzer.SchemaAnalyzer(cfg.schema);
       const analysis = await analyzer.analyze({
         includeRelations: cfg.analyzer.includeRelations,
-        validateConstraints: cfg.analyzer.validateConstraints
+        validateConstraints: cfg.analyzer.validateConstraints,
+        includeHeuristicRelations: cfg.analyzer.includeHeuristicRelations
       });
       if (opts.pipeline === "analyze") {
         if (opts.json) {
@@ -370,62 +484,174 @@ program.command("watch").description("Watch schema and regenerate on changes").o
       }
       const newFiles = [];
       for (const g of cfg.generators) {
-        if (g.kind === "orpc" && (opts.pipeline === "all" || opts.pipeline === "generate-orpc")) {
+        if (opts.pipeline !== "all" && !(opts.pipeline === "generate-orpc" && g.kind === "orpc")) {
+          continue;
+        }
+        if (g.kind === "orpc") {
           const gen = new import_generator_orpc.ORPCGenerator(analysis);
           const { files } = await gen.generate({
             outputDir: cfg.outDir,
             template: g.template,
             includeRelations: g.includeRelations,
-            naming: g.naming
+            naming: g.naming,
+            outputHeader: g.outputHeader,
+            format: g.format,
+            templateOptions: g.templateOptions,
+            validation: g.validation
           });
-          if (opts.json) {
-            console.log(JSON.stringify({ event: "generate_complete", kind: g.kind, files }));
-          } else {
-            console.log(
-              import_chalk.default.green(`Generated (${g.kind}):`),
+          opts.json ? console.log(JSON.stringify({ event: "generate_complete", kind: g.kind, files })) : console.log(
+            import_chalk.default.green(`Generated (${g.kind}):`),
+            files.map((f) => import_chalk.default.cyan(f)).join(", ")
+          );
+          newFiles.push(...files);
+        } else if (g.kind === "service") {
+          try {
+            const { ServiceGenerator } = await import("@drzl/generator-service");
+            const gen = new ServiceGenerator(analysis);
+            const target = g.path ?? "src/services";
+            const files = await gen.generate({
+              outDir: target,
+              outputHeader: g.outputHeader,
+              format: g.format,
+              dataAccess: g.dataAccess,
+              dbImportPath: g.dbImportPath,
+              schemaImportPath: g.schemaImportPath
+            });
+            opts.json ? console.log(JSON.stringify({ event: "generate_complete", kind: g.kind, files })) : console.log(
+              import_chalk.default.green(`Generated (service): ${files.length} files`),
               files.map((f) => import_chalk.default.cyan(f)).join(", ")
             );
+            newFiles.push(...files);
+          } catch (e) {
+            console.error(
+              import_chalk.default.red("Service generator missing."),
+              import_chalk.default.yellow("\nInstall with: npm install @drzl/generator-service")
+            );
+            console.error(import_chalk.default.gray("Error details:"), e?.message ?? e);
+            return;
+          }
+        } else if (g.kind === "zod") {
+          try {
+            const { ZodGenerator } = await import("@drzl/generator-zod");
+            const gen = new ZodGenerator(analysis);
+            const target = g.path ?? "src/validators/zod";
+            const files = await gen.generate({
+              outDir: target,
+              outputHeader: g.outputHeader,
+              format: g.format,
+              schemaSuffix: g.schemaSuffix,
+              fileSuffix: g.fileSuffix
+            });
+            opts.json ? console.log(JSON.stringify({ event: "generate_complete", kind: g.kind, files })) : console.log(
+              import_chalk.default.green(`Generated (zod): ${files.length} files`),
+              files.map((f) => import_chalk.default.cyan(f)).join(", ")
+            );
+            newFiles.push(...files);
+          } catch (e) {
+            console.error(
+              import_chalk.default.red("Zod generator missing."),
+              import_chalk.default.yellow("\nInstall with: npm install @drzl/generator-zod")
+            );
+            console.error(import_chalk.default.gray("Error details:"), e?.message ?? e);
+            return;
+          }
+        } else if (g.kind === "valibot") {
+          try {
+            const { ValibotGenerator } = await import("@drzl/generator-valibot");
+            const gen = new ValibotGenerator(analysis);
+            const target = g.path ?? "src/validators/valibot";
+            const files = await gen.generate({
+              outDir: target,
+              outputHeader: g.outputHeader,
+              format: g.format,
+              schemaSuffix: g.schemaSuffix,
+              fileSuffix: g.fileSuffix
+            });
+            opts.json ? console.log(JSON.stringify({ event: "generate_complete", kind: g.kind, files })) : console.log(
+              import_chalk.default.green(`Generated (valibot): ${files.length} files`),
+              files.map((f) => import_chalk.default.cyan(f)).join(", ")
+            );
+            newFiles.push(...files);
+          } catch (e) {
+            console.error(
+              import_chalk.default.red("Valibot generator missing."),
+              import_chalk.default.yellow("\nInstall with: npm install @drzl/generator-valibot")
+            );
+            console.error(import_chalk.default.gray("Error details:"), e?.message ?? e);
+            return;
+          }
+        } else if (g.kind === "arktype") {
+          try {
+            const { ArkTypeGenerator } = await import("@drzl/generator-arktype");
+            const gen = new ArkTypeGenerator(analysis);
+            const target = g.path ?? "src/validators/arktype";
+            const files = await gen.generate({
+              outDir: target,
+              outputHeader: g.outputHeader,
+              format: g.format,
+              schemaSuffix: g.schemaSuffix,
+              fileSuffix: g.fileSuffix
+            });
+            opts.json ? console.log(JSON.stringify({ event: "generate_complete", kind: g.kind, files })) : console.log(
+              import_chalk.default.green(`Generated (arktype): ${files.length} files`),
+              files.map((f) => import_chalk.default.cyan(f)).join(", ")
+            );
+            newFiles.push(...files);
+          } catch (e) {
+            console.error(
+              import_chalk.default.red("ArkType generator missing."),
+              import_chalk.default.yellow("\nInstall with: npm install @drzl/generator-arktype")
+            );
+            console.error(import_chalk.default.gray("Error details:"), e?.message ?? e);
+            return;
           }
-          newFiles.push(...files);
         }
       }
       const added = newFiles.filter((f) => !lastFiles.includes(f));
       const removed = lastFiles.filter((f) => !newFiles.includes(f));
-      if (opts.json) {
-        console.log(JSON.stringify({ event: "diff", added, removed }));
-      } else {
+      opts.json ? console.log(JSON.stringify({ event: "diff", added, removed })) : (() => {
         if (added.length) console.log(import_chalk.default.blue(`Added: ${added.join(", ")}`));
         if (removed.length) console.log(import_chalk.default.yellow(`Removed: ${removed.join(", ")}`));
-      }
+      })();
       lastFiles = newFiles;
     } catch (e) {
-      if (opts.json)
-        console.log(JSON.stringify({ event: "error", message: String(e?.message ?? e) }));
-      else console.error(import_chalk.default.red("Watch pipeline failed:"), e?.message ?? e);
+      opts.json ? console.log(JSON.stringify({ event: "error", message: String(e?.message ?? e) })) : console.error(import_chalk.default.red("Watch pipeline failed:"), e?.message ?? e);
     }
   };
   const debounced = Number(opts.debounce) || 200;
   let timer = null;
   const trigger = (file) => {
-    if (file && file.startsWith(cfg.outDir)) return;
-    clearTimeout(timer);
+    if (file) {
+      const full = abs(file);
+      for (const dir of ignoredOutDirs) {
+        if (full === dir || isInside(full, dir)) return;
+      }
+    }
+    if (timer) clearTimeout(timer);
     timer = setTimeout(run, debounced);
   };
-  console.log(import_chalk.default.gray("Watching for changes..."));
-  const watchSet = /* @__PURE__ */ new Set([cfg.schema]);
-  for (const g of cfg.generators) {
-    if (g.template && g.template !== "standard" && g.template !== "minimal") {
-      watchSet.add(g.template);
-    }
+  if (opts.json) {
+    console.log(
+      JSON.stringify({
+        event: "watching",
+        targets: Array.from(currentTargets),
+        ignored: Array.from(ignoredOutDirs)
+      })
+    );
+  } else {
+    console.log(
+      import_chalk.default.gray(
+        "Watching:\n  " + Array.from(currentTargets).map((p) => path2.relative(process.cwd(), p)).join("\n  ")
+      )
+    );
   }
-  watchSet.add(cfg.outDir);
-  import_chokidar.default.watch(Array.from(watchSet), { ignoreInitial: true }).on("add", (p) => trigger(p)).on("change", (p) => trigger(p)).on("unlink", (p) => trigger(p));
+  watcher.on("add", (p) => trigger(p)).on("change", (p) => trigger(p)).on("unlink", (p) => trigger(p)).on("error", (err) => console.error(import_chalk.default.red("Watcher error:"), err));
   await run();
 });
 program.command("init").description("Scaffold a drzl.config.ts").option("-y, --yes", "accept defaults").action(async (_opts) => {
-  const fs = await import("fs/promises");
-  const path = await import("path");
-  const target = path.resolve(process.cwd(), "drzl.config.ts");
+  const fs2 = await import("fs/promises");
+  const path3 = await import("path");
+  const target = path3.resolve(process.cwd(), "drzl.config.ts");
   const template = `export default {
   schema: 'src/db/schema.ts',
   outDir: 'src/api',
@@ -436,7 +662,7 @@ program.command("init").description("Scaffold a drzl.config.ts").option("-y, --y
 } as const
 `;
   try {
-    await fs.writeFile(target, template, { flag: "wx" });
+    await fs2.writeFile(target, template, { flag: "wx" });
     console.log(import_chalk.default.green(`Created ${target}`));
   } catch (e) {
     console.error(import_chalk.default.red("Init failed:"), e?.message ?? e);