@korajs/cli 0.1.6 → 0.1.8

package/dist/bin.cjs

@@ -146,17 +146,32 @@ async function findSchemaFile(projectRoot) {
   }
   return null;
 }
-async function resolveProjectBinary(projectRoot, binaryName) {
-  const binDir = (0, import_node_path.join)(projectRoot, "node_modules", ".bin");
-  const candidates = process.platform === "win32" ? [(0, import_node_path.join)(binDir, `${binaryName}.cmd`), (0, import_node_path.join)(binDir, binaryName)] : [(0, import_node_path.join)(binDir, binaryName)];
-  for (const candidate of candidates) {
-    try {
-      await (0, import_promises.access)(candidate);
-      return candidate;
-    } catch {
-    }
+async function hasTsxInstalled(projectRoot) {
+  try {
+    await (0, import_promises.access)((0, import_node_path.join)(projectRoot, "node_modules", "tsx", "package.json"));
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function resolveProjectBinaryEntryPoint(projectRoot, packageName, binaryName) {
+  const pkgJsonPath = (0, import_node_path.join)(projectRoot, "node_modules", packageName, "package.json");
+  try {
+    const content = await (0, import_promises.readFile)(pkgJsonPath, "utf-8");
+    const pkg = JSON.parse(content);
+    let binPath;
+    if (typeof pkg.bin === "string") {
+      binPath = pkg.bin;
+    } else if (typeof pkg.bin === "object" && pkg.bin !== null) {
+      binPath = pkg.bin[binaryName];
+    }
+    if (!binPath) return null;
+    const fullPath = (0, import_node_path.join)(projectRoot, "node_modules", packageName, binPath);
+    await (0, import_promises.access)(fullPath);
+    return fullPath;
+  } catch {
+    return null;
   }
-  return null;
 }
 function isKoraProject(pkg) {
   if (typeof pkg !== "object" || pkg === null) return false;
@@ -473,8 +488,8 @@ function resolveKoraVersion() {
 
 // src/commands/dev/dev-command.ts
 var import_promises4 = require("fs/promises");
-var import_node_path5 = require("path");
 var import_node_path6 = require("path");
+var import_node_path7 = require("path");
 var import_citty2 = require("citty");
 
 // src/commands/dev/kora-config.ts
@@ -513,14 +528,17 @@ async function findKoraConfigFile(projectRoot) {
   return null;
 }
 async function loadTypeScriptConfig(configPath, projectRoot) {
-  const tsxBinary = await resolveProjectBinary(projectRoot, "tsx");
-  if (!tsxBinary) {
+  if (!await hasTsxInstalled(projectRoot)) {
     throw new Error(
       `Found TypeScript config at ${configPath}, but "tsx" is not installed in this project. Install tsx or use kora.config.js.`
     );
   }
   const script = "const configPath = process.argv[process.argv.length - 1];import('node:url').then(u => import(u.pathToFileURL(configPath).href)).then(mod => { const v = mod.default ?? mod; process.stdout.write(JSON.stringify(v)) }).catch(e => { process.stderr.write(String(e)); process.exit(1) })";
-  const output = await runCommand(tsxBinary, ["--eval", script, configPath], projectRoot);
+  const output = await runCommand(
+    process.execPath,
+    ["--import", "tsx", "--eval", script, configPath],
+    projectRoot
+  );
   try {
     return JSON.parse(output);
   } catch {
@@ -532,8 +550,7 @@ async function runCommand(command, args, cwd) {
     const child = (0, import_node_child_process3.spawn)(command, args, {
       cwd,
       stdio: ["ignore", "pipe", "pipe"],
-      env: process.env,
-      shell: process.platform === "win32"
+      env: process.env
     });
     let stdout = "";
     let stderr = "";
@@ -574,9 +591,7 @@ var ProcessManager = class {
     const options = {
       cwd: config.cwd,
       env: { ...process.env, ...config.env },
-      stdio: ["ignore", "pipe", "pipe"],
-      // On Windows, .cmd shims require shell to execute
-      shell: process.platform === "win32"
+      stdio: ["ignore", "pipe", "pipe"]
     };
     const child = (0, import_node_child_process4.spawn)(config.command, config.args, options);
     let resolveExit;
@@ -658,6 +673,7 @@ function delay(ms) {
 // src/commands/dev/schema-watcher.ts
 var import_node_child_process5 = require("child_process");
 var import_node_fs3 = require("fs");
+var import_node_path5 = require("path");
 var SchemaWatcher = class {
   constructor(config) {
     this.config = config;
@@ -685,16 +701,10 @@ var SchemaWatcher = class {
     this.watcher = null;
   }
   async regenerate() {
-    const koraBinary = await resolveProjectBinary(this.config.projectRoot, "kora");
-    if (!koraBinary) {
-      throw new Error('Could not find project binary "kora" in node_modules/.bin.');
-    }
-    const tsxBinary = await resolveProjectBinary(this.config.projectRoot, "tsx");
-    if (!tsxBinary) {
-      process.stderr.write('[kora] Could not find "tsx" binary. Falling back to node.\n');
-    }
-    const command = tsxBinary ?? process.execPath;
-    const args = [koraBinary, "generate", "types", "--schema", this.config.schemaPath];
+    const koraBinJs = (0, import_node_path5.join)(this.config.projectRoot, "node_modules", "@korajs", "cli", "dist", "bin.js");
+    const hasTsx = await hasTsxInstalled(this.config.projectRoot);
+    const command = process.execPath;
+    const args = hasTsx ? ["--import", "tsx", koraBinJs, "generate", "types", "--schema", this.config.schemaPath] : [koraBinJs, "generate", "types", "--schema", this.config.schemaPath];
     await spawnCommand(command, args, this.config.projectRoot);
     this.config.onRegenerate?.();
   }
@@ -715,8 +725,7 @@ async function spawnCommand(command, args, cwd) {
     const child = (0, import_node_child_process5.spawn)(command, args, {
       cwd,
       stdio: ["ignore", "pipe", "pipe"],
-      env: process.env,
-      shell: process.platform === "win32"
+      env: process.env
     });
     child.stdout?.on("data", (chunk) => {
       writePrefixedLines(chunk, false);
@@ -789,25 +798,25 @@ var devCommand = (0, import_citty2.defineCommand)({
     const configSyncEnabled = config?.dev?.sync === void 0 || config.dev.sync === true || typeof config.dev.sync === "object" && config.dev.sync.enabled !== false;
     const configWatchEnabled = config?.dev?.watch === void 0 || config.dev.watch === true || typeof config.dev.watch === "object" && config.dev.watch.enabled !== false;
     const watchDebounceMs = typeof config?.dev?.watch === "object" && typeof config.dev.watch.debounceMs === "number" ? config.dev.watch.debounceMs : 300;
-    const viteBinary = await resolveProjectBinary(projectRoot, "vite");
-    if (!viteBinary) {
-      throw new DevServerError("vite", (0, import_node_path5.join)(projectRoot, "node_modules", ".bin", "vite"));
+    const viteEntryPoint = await resolveProjectBinaryEntryPoint(projectRoot, "vite", "vite");
+    if (!viteEntryPoint) {
+      throw new DevServerError("vite", (0, import_node_path6.join)(projectRoot, "node_modules", ".bin", "vite"));
     }
     const syncServerFile = await findSyncServerFile(projectRoot);
     let managedSyncStore = normalizeManagedSyncStore(config, projectRoot);
     const postgresEnvRequested = isPostgresEnvRequested(config);
     const syncAllowed = args["no-sync"] !== true && configSyncEnabled;
     let shouldStartSync = syncAllowed && (syncServerFile !== null || managedSyncStore !== null);
-    let syncBinary = null;
+    let hasTsx = false;
     if (shouldStartSync && syncServerFile !== null) {
-      syncBinary = await resolveProjectBinary(projectRoot, "tsx");
-      if (!syncBinary) {
-        logger.warn('Sync server detected, but local "tsx" binary was not found. Skipping sync.');
+      hasTsx = await hasTsxInstalled(projectRoot);
+      if (!hasTsx) {
+        logger.warn('Sync server detected, but "tsx" is not installed. Skipping sync.');
       }
     }
     if (shouldStartSync && syncServerFile === null && managedSyncStore) {
       const hasServerPackage = await fileExists(
-        (0, import_node_path5.join)(projectRoot, "node_modules", "@korajs", "server", "package.json")
+        (0, import_node_path6.join)(projectRoot, "node_modules", "@korajs", "server", "package.json")
       );
       if (!hasServerPackage) {
         logger.warn(
@@ -824,7 +833,7 @@ var devCommand = (0, import_citty2.defineCommand)({
     }
     let configuredSchemaPath = null;
     if (typeof config?.schema === "string") {
-      const candidate = (0, import_node_path6.resolve)(projectRoot, config.schema);
+      const candidate = (0, import_node_path7.resolve)(projectRoot, config.schema);
       if (await fileExists(candidate)) {
         configuredSchemaPath = candidate;
       } else {
@@ -864,7 +873,7 @@ var devCommand = (0, import_citty2.defineCommand)({
     logger.info("Starting development environment:");
     logger.blank();
     logger.step(`  Vite dev server on port ${vitePort}`);
-    if (shouldStartSync && syncBinary && syncServerFile) {
+    if (shouldStartSync && hasTsx && syncServerFile) {
       logger.step(`  Sync server on port ${syncPort}`);
     } else if (shouldStartSync && syncServerFile === null && managedSyncStore !== null) {
       logger.step(`  Managed sync server on port ${syncPort} (${managedSyncStore.type})`);
@@ -883,16 +892,16 @@ var devCommand = (0, import_citty2.defineCommand)({
     logger.blank();
     processManager.spawn({
       label: "vite",
-      command: viteBinary,
-      args: ["--port", String(vitePort)],
+      command: process.execPath,
+      args: [viteEntryPoint, "--port", String(vitePort)],
       cwd: projectRoot,
       onExit: onManagedProcessExit
     });
-    if (shouldStartSync && syncBinary && syncServerFile) {
+    if (shouldStartSync && hasTsx && syncServerFile) {
       processManager.spawn({
         label: "sync",
-        command: syncBinary,
-        args: [syncServerFile],
+        command: process.execPath,
+        args: ["--import", "tsx", syncServerFile],
         cwd: projectRoot,
         env: {
           PORT: String(syncPort),
@@ -936,7 +945,7 @@ var devCommand = (0, import_citty2.defineCommand)({
   }
 });
 async function findSyncServerFile(projectRoot) {
-  const candidates = [(0, import_node_path5.join)(projectRoot, "server.ts"), (0, import_node_path5.join)(projectRoot, "server.js")];
+  const candidates = [(0, import_node_path6.join)(projectRoot, "server.ts"), (0, import_node_path6.join)(projectRoot, "server.js")];
   for (const candidate of candidates) {
     try {
       await (0, import_promises4.access)(candidate);
@@ -960,7 +969,7 @@ function normalizeManagedSyncStore(config, projectRoot) {
   const store = sync.store;
   if (store === void 0) return { type: "memory" };
   if (store === "memory") return { type: "memory" };
-  if (store === "sqlite") return { type: "sqlite", filename: (0, import_node_path5.join)(projectRoot, "kora-sync.db") };
+  if (store === "sqlite") return { type: "sqlite", filename: (0, import_node_path6.join)(projectRoot, "kora-sync.db") };
   if (store === "postgres") {
     const connectionString = process.env.DATABASE_URL;
     if (!connectionString) return null;
@@ -969,7 +978,7 @@ function normalizeManagedSyncStore(config, projectRoot) {
   if (typeof store === "object" && store !== null) {
     if (store.type === "memory") return { type: "memory" };
     if (store.type === "sqlite") {
-      const filename = typeof store.filename === "string" && store.filename.length > 0 ? (0, import_node_path6.resolve)(projectRoot, store.filename) : (0, import_node_path5.join)(projectRoot, "kora-sync.db");
+      const filename = typeof store.filename === "string" && store.filename.length > 0 ? (0, import_node_path7.resolve)(projectRoot, store.filename) : (0, import_node_path6.join)(projectRoot, "kora-sync.db");
       return { type: "sqlite", filename };
     }
     if (store.type === "postgres" && typeof store.connectionString === "string") {
@@ -1033,7 +1042,7 @@ await new Promise(() => {});
 
 // src/commands/generate/generate-command.ts
 var import_promises5 = require("fs/promises");
-var import_node_path7 = require("path");
+var import_node_path8 = require("path");
 var import_citty3 = require("citty");
 
 // src/commands/generate/type-generator.ts
@@ -1164,7 +1173,7 @@ var generateCommand = (0, import_citty3.defineCommand)({
         }
         let schemaPath;
         if (args.schema && typeof args.schema === "string") {
-          schemaPath = (0, import_node_path7.resolve)(args.schema);
+          schemaPath = (0, import_node_path8.resolve)(args.schema);
         } else {
           const found = await findSchemaFile(projectRoot);
           if (!found) {
@@ -1187,8 +1196,8 @@ var generateCommand = (0, import_citty3.defineCommand)({
         }
         const output = generateTypes(schema);
         const outputFile = typeof args.output === "string" ? args.output : "kora/generated/types.ts";
-        const outputPath = (0, import_node_path7.resolve)(projectRoot, outputFile);
-        await (0, import_promises5.mkdir)((0, import_node_path7.dirname)(outputPath), { recursive: true });
+        const outputPath = (0, import_node_path8.resolve)(projectRoot, outputFile);
+        await (0, import_promises5.mkdir)((0, import_node_path8.dirname)(outputPath), { recursive: true });
         await (0, import_promises5.writeFile)(outputPath, output, "utf-8");
         logger.success(`Generated types at ${outputPath}`);
       }
@@ -1210,7 +1219,7 @@ function isSchemaDefinition(value) {
 
 // src/commands/migrate/migrate-command.ts
 var import_promises6 = require("fs/promises");
-var import_node_path9 = require("path");
+var import_node_path10 = require("path");
 var import_citty4 = require("citty");
 
 // src/commands/migrate/migration-generator.ts
@@ -1780,10 +1789,10 @@ async function loadPostgresModule() {
 
 // src/commands/migrate/schema-loader.ts
 var import_node_child_process6 = require("child_process");
-var import_node_path8 = require("path");
+var import_node_path9 = require("path");
 var import_node_url4 = require("url");
 async function loadSchemaDefinition(schemaPath, projectRoot) {
-  const ext = (0, import_node_path8.extname)(schemaPath);
+  const ext = (0, import_node_path9.extname)(schemaPath);
   const moduleValue = ext === ".ts" || ext === ".mts" || ext === ".cts" ? await loadTypeScriptModule(schemaPath, projectRoot) : await import(`${(0, import_node_url4.pathToFileURL)(schemaPath).href}?t=${Date.now()}-${Math.random()}`);
   return extractSchema2(moduleValue);
 }
@@ -1804,14 +1813,17 @@ function isSchemaDefinition2(value) {
   return typeof object.version === "number" && typeof object.collections === "object" && object.collections !== null && typeof object.relations === "object" && object.relations !== null;
 }
 async function loadTypeScriptModule(schemaPath, projectRoot) {
-  const tsxBinary = await resolveProjectBinary(projectRoot, "tsx");
-  if (!tsxBinary) {
+  if (!await hasTsxInstalled(projectRoot)) {
     throw new Error(
       `Schema file is TypeScript (${schemaPath}) but local "tsx" was not found. Install tsx in the project.`
     );
   }
   const script = "const modulePath = process.argv[process.argv.length - 1];import('node:url').then(u => import(u.pathToFileURL(modulePath).href)).then(mod => { const v = mod.default ?? mod; process.stdout.write(JSON.stringify(v)) }).catch(e => { process.stderr.write(String(e)); process.exit(1) })";
-  const output = await runCommand2(tsxBinary, ["--eval", script, schemaPath], projectRoot);
+  const output = await runCommand2(
+    process.execPath,
+    ["--import", "tsx", "--eval", script, schemaPath],
+    projectRoot
+  );
   try {
     return JSON.parse(output);
   } catch {
@@ -1823,8 +1835,7 @@ async function runCommand2(command, args, cwd) {
     const child = (0, import_node_child_process6.spawn)(command, args, {
       cwd,
       stdio: ["ignore", "pipe", "pipe"],
-      env: process.env,
-      shell: process.platform === "win32"
+      env: process.env
     });
     let stdout = "";
     let stderr = "";
@@ -1894,12 +1905,12 @@ var migrateCommand = (0, import_citty4.defineCommand)({
       throw new InvalidProjectError(process.cwd());
     }
     const config = await loadKoraConfig(projectRoot);
-    const resolvedSchemaPath = typeof args.schema === "string" ? (0, import_node_path9.resolve)(projectRoot, args.schema) : typeof config?.schema === "string" ? (0, import_node_path9.resolve)(projectRoot, config.schema) : await findSchemaFile(projectRoot);
+    const resolvedSchemaPath = typeof args.schema === "string" ? (0, import_node_path10.resolve)(projectRoot, args.schema) : typeof config?.schema === "string" ? (0, import_node_path10.resolve)(projectRoot, config.schema) : await findSchemaFile(projectRoot);
     if (!resolvedSchemaPath) {
       throw new SchemaNotFoundError(["src/schema.ts", "schema.ts", "src/schema.js", "schema.js"]);
     }
     const currentSchema = await loadSchemaDefinition(resolvedSchemaPath, projectRoot);
-    const snapshotFile = (0, import_node_path9.join)(projectRoot, SNAPSHOT_PATH);
+    const snapshotFile = (0, import_node_path10.join)(projectRoot, SNAPSHOT_PATH);
     const previousSchema = await readSchemaSnapshot(snapshotFile);
     if (!previousSchema) {
       if (args["dry-run"] === true) {
@@ -1912,7 +1923,7 @@ var migrateCommand = (0, import_citty4.defineCommand)({
       return;
     }
     const diff = diffSchemas(previousSchema, currentSchema);
-    const outputDir = typeof args["output-dir"] === "string" ? (0, import_node_path9.resolve)(projectRoot, args["output-dir"]) : (0, import_node_path9.resolve)(projectRoot, MIGRATIONS_DIR);
+    const outputDir = typeof args["output-dir"] === "string" ? (0, import_node_path10.resolve)(projectRoot, args["output-dir"]) : (0, import_node_path10.resolve)(projectRoot, MIGRATIONS_DIR);
     if (!diff.hasChanges) {
       logger.success("No schema changes detected.");
       if (args.apply === true) {
@@ -2016,7 +2027,7 @@ function isInteractiveTerminal() {
   return process.stdin.isTTY === true && process.stdout.isTTY === true;
 }
 async function writeSchemaSnapshot(path, schema) {
-  await (0, import_promises6.mkdir)((0, import_node_path9.dirname)(path), { recursive: true });
+  await (0, import_promises6.mkdir)((0, import_node_path10.dirname)(path), { recursive: true });
   await (0, import_promises6.writeFile)(path, `${JSON.stringify(schema, null, 2)}
 `, "utf-8");
 }
@@ -2024,7 +2035,7 @@ async function writeMigrationFile(outputDir, fromVersion, toVersion, generated)
   const existing = await (0, import_promises6.readdir)(outputDir).catch(() => []);
   const sequence = existing.filter((file) => /^\d{3}-/.test(file)).length + 1;
   const filename = `${String(sequence).padStart(3, "0")}-v${fromVersion}-to-v${toVersion}.ts`;
-  const path = (0, import_node_path9.join)(outputDir, filename);
+  const path = (0, import_node_path10.join)(outputDir, filename);
   const migrationId = filename.replace(/\.ts$/, "");
   const fileContent = [
     `export const up = ${JSON.stringify(generated.up, null, 2)} as const`,
@@ -2037,7 +2048,7 @@ async function writeMigrationFile(outputDir, fromVersion, toVersion, generated)
     ""
   ].join("\n");
   await (0, import_promises6.writeFile)(path, fileContent, "utf-8");
-  await writeMigrationManifest((0, import_node_path9.join)(outputDir, `${migrationId}.json`), {
+  await writeMigrationManifest((0, import_node_path10.join)(outputDir, `${migrationId}.json`), {
     id: migrationId,
     fromVersion,
     toVersion,
@@ -2058,13 +2069,13 @@ async function listMigrationManifests(outputDir) {
   const manifests = [];
   for (const file of migrationFiles) {
     const id = file.replace(/\.ts$/, "");
-    const manifestPath = (0, import_node_path9.join)(outputDir, `${id}.json`);
+    const manifestPath = (0, import_node_path10.join)(outputDir, `${id}.json`);
     const jsonManifest = await readMigrationManifest(manifestPath);
     if (jsonManifest) {
       manifests.push({ ...jsonManifest, id });
       continue;
     }
-    const migrationPath = (0, import_node_path9.join)(outputDir, file);
+    const migrationPath = (0, import_node_path10.join)(outputDir, file);
     const sourceManifest = await readMigrationManifestFromSource(migrationPath, id);
     manifests.push(sourceManifest);
   }
@@ -2140,18 +2151,18 @@ function parseLiteralExport(source, exportName) {
 }
 function resolveSqliteApplyPath(dbArg, projectRoot, config) {
   if (typeof dbArg === "string") {
-    return (0, import_node_path9.resolve)(projectRoot, dbArg);
+    return (0, import_node_path10.resolve)(projectRoot, dbArg);
   }
   const sync = config?.dev?.sync;
   if (typeof sync === "object" && sync !== null) {
     if (sync.store === "sqlite") {
-      return (0, import_node_path9.join)(projectRoot, "kora-sync.db");
+      return (0, import_node_path10.join)(projectRoot, "kora-sync.db");
     }
     if (typeof sync.store === "object" && sync.store !== null && sync.store.type === "sqlite") {
       if (typeof sync.store.filename === "string" && sync.store.filename.length > 0) {
-        return (0, import_node_path9.resolve)(projectRoot, sync.store.filename);
+        return (0, import_node_path10.resolve)(projectRoot, sync.store.filename);
       }
-      return (0, import_node_path9.join)(projectRoot, "kora-sync.db");
+      return (0, import_node_path10.join)(projectRoot, "kora-sync.db");
     }
   }
   return void 0;