datasette-ts 0.0.5 → 0.0.7

package/dist/cli.js

@@ -23687,10 +23687,12 @@ 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`);
+  const log = typeof options.log === "function" ? options.log : null;
+  const progressIntervalMs = typeof options.progressIntervalMs === "number" && Number.isFinite(options.progressIntervalMs) ? options.progressIntervalMs : 5e3;
   await mkdir(options.outputDir, { recursive: true });
-  await dumpSqliteToFile(options.dbFile, rawPath);
+  await dumpSqliteToFile(options.dbFile, rawPath, { log, progressIntervalMs });
   try {
-    await normalizeDumpFile(rawPath, outputPath);
+    await normalizeDumpFile(rawPath, outputPath, { log });
   } finally {
     await unlink(rawPath).catch(() => void 0);
   }
@@ -23816,9 +23818,12 @@ function escapeIdentifier(name) {
   const escaped = String(name).replace(/"/g, '""');
   return `"${escaped}"`;
 }
-async function normalizeDumpFile(inputPath, outputPath) {
+async function normalizeDumpFile(inputPath, outputPath, { log } = {}) {
   const tablesInOrder = [];
   const viewsInOrder = [];
+  if (log) {
+    log(`Normalizing D1 import SQL: ${outputPath}`);
+  }
   await forEachLine(inputPath, (line) => {
     const tableMatch = line.match(/^CREATE TABLE\s+("?[^"]+"?)/i);
     if (tableMatch) {
@@ -23848,8 +23853,15 @@ async function normalizeDumpFile(inputPath, outputPath) {
   });
   outputStream.end();
   await once(outputStream, "finish");
+  if (log) {
+    const { size } = await stat(outputPath);
+    log(`D1 import SQL ready (${formatBytes(size)})`);
+  }
 }
-async function dumpSqliteToFile(dbFile, outputPath) {
+async function dumpSqliteToFile(dbFile, outputPath, { log, progressIntervalMs } = {}) {
+  if (log) {
+    log(`Dumping SQLite database via sqlite3 .dump`);
+  }
   const child = spawn("sqlite3", [dbFile, ".dump"], {
     stdio: ["ignore", "pipe", "pipe"]
   });
@@ -23870,13 +23882,22 @@ async function dumpSqliteToFile(dbFile, outputPath) {
     stdout.destroy(error);
     outputStream.destroy(error);
   });
-  await pipeline(stdout, outputStream);
+  const stopProgress = log ? startProgressLogger(outputPath, log, progressIntervalMs) : () => void 0;
+  try {
+    await pipeline(stdout, outputStream);
+  } finally {
+    stopProgress();
+  }
   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);
   }
+  if (log) {
+    const { size } = await stat(outputPath);
+    log(`SQLite dump completed (${formatBytes(size)})`);
+  }
 }
 async function forEachLine(filePath, handler) {
   const stream = createReadStream(filePath, { encoding: "utf8" });
@@ -23896,6 +23917,28 @@ async function writeLine(stream, line) {
     await once(stream, "drain");
   }
 }
+function startProgressLogger(filePath, log, intervalMs) {
+  const interval = setInterval(() => {
+    void stat(filePath).then((info) => {
+      log(`Dump size: ${formatBytes(info.size)}`);
+    }).catch(() => void 0);
+  }, intervalMs);
+  return () => clearInterval(interval);
+}
+function formatBytes(bytes) {
+  if (!Number.isFinite(bytes) || bytes < 0) {
+    return "0 B";
+  }
+  const units = ["B", "KB", "MB", "GB", "TB"];
+  let value = bytes;
+  let index = 0;
+  while (value >= 1024 && index < units.length - 1) {
+    value /= 1024;
+    index += 1;
+  }
+  const rounded = index === 0 ? value.toFixed(0) : value.toFixed(1);
+  return `${rounded} ${units[index]}`;
+}
 async function hashFile(filePath) {
   return new Promise((resolve2, reject) => {
     const hash = createHash("sha256");
@@ -23975,20 +24018,32 @@ function normalizeLibsqlRows(result) {
 // src/cli/deploy-cloudflare.ts
 var DEFAULT_IMPORTS_DIR = ".datasette-ts/imports";
 async function runCloudflareDeploy(args) {
+  const startedAt = Date.now();
+  logStep("Starting Cloudflare deploy");
   const options = parseDeployArgs(args);
+  logStep(`Database: ${options.dbFile}`);
+  logStep(`Worker: ${options.workerName}`);
+  logStep(`D1: ${options.d1Name}`);
   await assertFileExists(options.dbFile, "SQLite database");
   const packageRoot = await resolvePackageRoot();
+  logStep(`Package root: ${packageRoot}`);
   const workerEntrypoint = await resolveWorkerEntrypoint(packageRoot);
+  logStep(`Worker entrypoint: ${workerEntrypoint}`);
   const assetsPath = join(packageRoot, "public");
   await assertFileExists(assetsPath, "assets directory");
+  logStep("Initializing Alchemy app");
   const app = await alchemy(options.workerName);
   let importFile;
   try {
+    logStep("Exporting SQLite for D1 import");
     importFile = await dumpSqliteForD1({
       dbFile: options.dbFile,
       outputDir: options.importsDir,
-      outputName: options.d1Name
+      outputName: options.d1Name,
+      log: logStep,
+      progressIntervalMs: 5e3
     });
+    logStep(`D1 import file: ${importFile}`);
   } catch (error) {
     if (isSqliteCliMissing(error)) {
       throw new Error(
@@ -23997,14 +24052,21 @@ async function runCloudflareDeploy(args) {
     }
     throw error;
   }
+  logStep("Loading schema");
   const schema = await loadSchemaFromFile(options.dbFile);
-  const inspectData = options.precomputeInspect ? await loadInspectDataFromFile(options.dbFile, options.dbName) : null;
+  let inspectData = null;
+  if (options.precomputeInspect) {
+    logStep("Precomputing inspect data");
+    inspectData = await loadInspectDataFromFile(options.dbFile, options.dbName);
+  }
+  logStep("Creating D1 database");
   const db = await D1Database(`d1-${options.d1Name}`, {
     name: options.d1Name,
     importFiles: [importFile],
     profile: options.profile,
     adopt: true
   });
+  logStep("Configuring static assets");
   const staticAssets = await Assets({
     path: assetsPath
   });
@@ -24017,6 +24079,7 @@ async function runCloudflareDeploy(args) {
   if (inspectData) {
     bindings.DATASETTE_INSPECT_DATA = JSON.stringify(inspectData);
   }
+  logStep("Deploying worker");
   const worker = await Worker(`worker-${options.workerName}`, {
     entrypoint: workerEntrypoint,
     compatibilityFlags: ["nodejs_compat"],
@@ -24028,7 +24091,9 @@ async function runCloudflareDeploy(args) {
     adopt: true
   });
   console.log(`Worker deployed at: ${worker.url}`);
+  logStep("Finalizing Alchemy app");
   await app.finalize();
+  logStep(`Done in ${formatDuration(Date.now() - startedAt)}`);
 }
 function parseDeployArgs(args) {
   const positional = [];
@@ -24206,6 +24271,16 @@ function isSqliteCliMissing(error) {
   }
   return "code" in error && error.code === "ENOENT";
 }
+function logStep(message) {
+  console.log(`[datasette-ts] ${message}`);
+}
+function formatDuration(ms) {
+  if (ms < 1e3) {
+    return `${ms}ms`;
+  }
+  const seconds = (ms / 1e3).toFixed(1);
+  return `${seconds}s`;
+}
 
 // src/cli/serve.ts
 init_registry();
@@ -24507,10 +24582,16 @@ function parseNamedArg2(arg, nextValue) {
 }
 
 // src/cli.ts
-void main().catch((error) => {
+var keepAlive = setInterval(() => {
+}, 1e3);
+var mainPromise = main();
+mainPromise.catch((error) => {
   console.error(error);
   process.exitCode = 1;
 });
+mainPromise.finally(() => {
+  clearInterval(keepAlive);
+});
 async function main() {
   const args = process.argv.slice(2);
   const [command, subcommand] = args;