datasette-ts 0.0.3 → 0.0.5

package/dist/cli.js

@@ -23673,22 +23673,27 @@ import alchemy from "alchemy";
 import { Assets, D1Database, Worker } from "alchemy/cloudflare";
 
 // scripts/cloudflare-deploy-helpers.mjs
-import { execFileSync } from "node:child_process";
+import { spawn } from "node:child_process";
 import { createHash } from "node:crypto";
-import { createReadStream } from "node:fs";
-import { mkdir, stat, writeFile } from "node:fs/promises";
+import { createReadStream, createWriteStream } from "node:fs";
+import { mkdir, stat, unlink } from "node:fs/promises";
+import { once } from "node:events";
 import path from "node:path";
+import { createInterface } from "node:readline";
+import { pipeline } from "node:stream/promises";
 import { pathToFileURL } from "node:url";
 import { createClient } from "@libsql/client";
 async function dumpSqliteForD1(options) {
   const baseName = options.outputName ?? path.basename(options.dbFile, path.extname(options.dbFile));
   const outputPath = path.join(options.outputDir, `${baseName}.sql`);
+  const rawPath = path.join(options.outputDir, `${baseName}.raw.sql`);
   await mkdir(options.outputDir, { recursive: true });
-  const rawDump = execFileSync("sqlite3", [options.dbFile, ".dump"], {
-    encoding: "utf8"
-  });
-  const cleaned = normalizeDump(rawDump);
-  await writeFile(outputPath, cleaned);
+  await dumpSqliteToFile(options.dbFile, rawPath);
+  try {
+    await normalizeDumpFile(rawPath, outputPath);
+  } finally {
+    await unlink(rawPath).catch(() => void 0);
+  }
   return outputPath;
 }
 async function loadSchemaFromFile(dbFile) {
@@ -23811,48 +23816,85 @@ function escapeIdentifier(name) {
   const escaped = String(name).replace(/"/g, '""');
   return `"${escaped}"`;
 }
-function normalizeDump(rawDump) {
-  const lines = rawDump.split("\n");
-  const output = [];
+async function normalizeDumpFile(inputPath, outputPath) {
   const tablesInOrder = [];
   const viewsInOrder = [];
-  for (const line of lines) {
+  await forEachLine(inputPath, (line) => {
     const tableMatch = line.match(/^CREATE TABLE\s+("?[^"]+"?)/i);
     if (tableMatch) {
       tablesInOrder.push(tableMatch[1].replace(/\s*\($/, ""));
-      continue;
+      return;
     }
     const viewMatch = line.match(/^CREATE VIEW\s+("?[^"]+"?)/i);
     if (viewMatch) {
       viewsInOrder.push(viewMatch[1].replace(/\s*\($/, ""));
     }
-  }
+  });
+  const outputStream = createWriteStream(outputPath, { encoding: "utf8" });
   for (const viewName of viewsInOrder.reverse()) {
-    output.push(`DROP VIEW IF EXISTS ${viewName};`);
+    await writeLine(outputStream, `DROP VIEW IF EXISTS ${viewName};`);
   }
   for (const tableName of tablesInOrder.reverse()) {
-    output.push(`DROP TABLE IF EXISTS ${tableName};`);
+    await writeLine(outputStream, `DROP TABLE IF EXISTS ${tableName};`);
   }
-  for (const line of lines) {
+  await forEachLine(inputPath, async (line) => {
     if (line === "BEGIN TRANSACTION;" || line === "COMMIT;") {
-      continue;
+      return;
     }
     if (line.startsWith("PRAGMA foreign_keys=")) {
-      continue;
-    }
-    const tableMatch = line.match(/^CREATE TABLE\s+("?[^"]+"?)/i);
-    if (tableMatch) {
-      output.push(line);
-      continue;
+      return;
     }
-    const viewMatch = line.match(/^CREATE VIEW\s+("?[^"]+"?)/i);
-    if (viewMatch) {
-      output.push(line);
-      continue;
+    await writeLine(outputStream, line);
+  });
+  outputStream.end();
+  await once(outputStream, "finish");
+}
+async function dumpSqliteToFile(dbFile, outputPath) {
+  const child = spawn("sqlite3", [dbFile, ".dump"], {
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  let stderr = "";
+  if (child.stderr) {
+    child.stderr.setEncoding("utf8");
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk;
+    });
+  }
+  const stdout = child.stdout;
+  if (!stdout) {
+    const [error] = await once(child, "error");
+    throw error ?? new Error("sqlite3 stdout is unavailable.");
+  }
+  const outputStream = createWriteStream(outputPath, { encoding: "utf8" });
+  child.once("error", (error) => {
+    stdout.destroy(error);
+    outputStream.destroy(error);
+  });
+  await pipeline(stdout, outputStream);
+  const [code, signal] = await once(child, "close");
+  if (code !== 0) {
+    const suffix = signal ? ` (signal ${signal})` : "";
+    const message = stderr.trim() || `sqlite3 exited with code ${code ?? "unknown"}${suffix}`;
+    throw new Error(message);
+  }
+}
+async function forEachLine(filePath, handler) {
+  const stream = createReadStream(filePath, { encoding: "utf8" });
+  const rl = createInterface({ input: stream, crlfDelay: Infinity });
+  try {
+    for await (const line of rl) {
+      await handler(line);
     }
-    output.push(line);
+  } finally {
+    rl.close();
+    stream.close();
+  }
+}
+async function writeLine(stream, line) {
+  if (!stream.write(`${line}
+`)) {
+    await once(stream, "drain");
   }
-  return output.join("\n");
 }
 async function hashFile(filePath) {
   return new Promise((resolve2, reject) => {
@@ -24167,7 +24209,7 @@ function isSqliteCliMissing(error) {
 
 // src/cli/serve.ts
 init_registry();
-import { stat as stat5, writeFile as writeFile2 } from "node:fs/promises";
+import { stat as stat5, writeFile } from "node:fs/promises";
 import { join as join2 } from "node:path";
 
 // src/core/inspect.ts
@@ -24340,7 +24382,7 @@ async function runInspectCommand(args) {
   const data = await inspectDatabases(databasePaths);
   const json = JSON.stringify(data, null, 2);
   if (inspectFile) {
-    await writeFile2(inspectFile, json, "utf8");
+    await writeFile(inspectFile, json, "utf8");
     return;
   }
   process.stdout.write(`${json}
@@ -24465,12 +24507,10 @@ function parseNamedArg2(arg, nextValue) {
 }
 
 // src/cli.ts
-try {
-  await main();
-} catch (error) {
+void main().catch((error) => {
   console.error(error);
   process.exitCode = 1;
-}
+});
 async function main() {
   const args = process.argv.slice(2);
   const [command, subcommand] = args;