datasette-ts 0.0.2 → 0.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "datasette-ts",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "private": false,
   "type": "module",
   "bin": {

package/scripts/build.mjs

@@ -23,6 +23,14 @@ await build({
   platform: "node",
   format: "esm",
   target: ["node24"],
+  banner: {
+    js: [
+      "#!/usr/bin/env node",
+      'import { createRequire } from "node:module";',
+      "const require = createRequire(import.meta.url);",
+      "",
+    ].join("\n"),
+  },
   external: sharedExternals,
 });
 

package/scripts/cloudflare-deploy-helpers.mjs

@@ -1,8 +1,11 @@
-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";
 
@@ -10,13 +13,15 @@ export 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(() => undefined);
+  }
 
   return outputPath;
 }
@@ -158,48 +163,90 @@ function escapeIdentifier(name) {
   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}\n`)) {
+    await once(stream, "drain");
   }
-  return output.join("\n");
 }
 
 async function hashFile(filePath) {