datasette-ts 0.0.1

package/scripts/cloudflare-deploy-helpers.mjs

@@ -0,0 +1,289 @@
+import { execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { createReadStream } from "node:fs";
+import { mkdir, stat, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { createClient } from "@libsql/client";
+
+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`);
+
+  await mkdir(options.outputDir, { recursive: true });
+  const rawDump = execFileSync("sqlite3", [options.dbFile, ".dump"], {
+    encoding: "utf8",
+  });
+  const cleaned = normalizeDump(rawDump);
+  await writeFile(outputPath, cleaned);
+
+  return outputPath;
+}
+
+export async function loadSchemaFromFile(dbFile) {
+  const db = createReadonlyClient(dbFile);
+  try {
+    return await introspectDatabase(db);
+  } finally {
+    db.close();
+  }
+}
+
+export async function loadInspectDataFromFile(dbFile, databaseName) {
+  const stats = await stat(dbFile);
+  const hash = await hashFile(dbFile);
+  const tables = await countTables(dbFile);
+  return {
+    [databaseName]: {
+      hash,
+      size: stats.size,
+      file: path.basename(dbFile),
+      tables,
+    },
+  };
+}
+
+async function introspectDatabase(db) {
+  const rows = await executeRows(
+    db,
+    "select name, type, sql from sqlite_master where type in ('table', 'view') order by name",
+  );
+  const tables = {};
+
+  for (const row of rows) {
+    const name = asString(row.name);
+    if (name.startsWith("sqlite_")) {
+      continue;
+    }
+    const type = asString(row.type);
+    const sql = asNullableString(row.sql);
+    const virtual = type === "table" && isVirtualTable(sql);
+    const infoType = type === "view" ? "view" : virtual ? "virtual" : "table";
+    const columns = await tableColumns(db, name);
+    const foreignKeys = await tableForeignKeys(db, name);
+    const primaryKeys = columns
+      .filter((column) => column.primaryKey)
+      .sort((a, b) => a.primaryKeyIndex - b.primaryKeyIndex)
+      .map((column) => column.name);
+    const isFts = isFtsTable(sql);
+
+    tables[name] = {
+      name,
+      type: infoType,
+      sql,
+      columns,
+      primaryKeys,
+      foreignKeys,
+      isFts,
+    };
+  }
+
+  return { tables };
+}
+
+async function tableColumns(db, tableName) {
+  const rows = await executeRows(db, `pragma table_info(${escapeIdentifier(tableName)})`);
+  return rows.map((row) => ({
+    name: asString(row.name),
+    type: asString(row.type),
+    notNull: asNumber(row.notnull) === 1,
+    defaultValue: asNullableString(row.dflt_value),
+    primaryKey: asNumber(row.pk) > 0,
+    primaryKeyIndex: asNumber(row.pk),
+  }));
+}
+
+async function tableForeignKeys(db, tableName) {
+  const rows = await executeRows(db, `pragma foreign_key_list(${escapeIdentifier(tableName)})`);
+  return rows.map((row) => ({
+    table: asString(row.table),
+    from: asString(row.from),
+    to: asString(row.to),
+    onUpdate: asString(row.on_update),
+    onDelete: asString(row.on_delete),
+    match: asString(row.match),
+    seq: asNumber(row.seq),
+    id: asNumber(row.id),
+  }));
+}
+
+function asString(value, fallback = "") {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (value == null) {
+    return fallback;
+  }
+  return String(value);
+}
+
+function asNumber(value, fallback = 0) {
+  if (typeof value === "number") {
+    return value;
+  }
+  if (typeof value === "string" && value.trim() !== "") {
+    const parsed = Number(value);
+    return Number.isNaN(parsed) ? fallback : parsed;
+  }
+  return fallback;
+}
+
+function asNullableString(value) {
+  if (value == null) {
+    return null;
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  return String(value);
+}
+
+function isVirtualTable(sql) {
+  if (!sql) {
+    return false;
+  }
+  return /create\s+virtual\s+table/i.test(sql);
+}
+
+function isFtsTable(sql) {
+  if (!sql) {
+    return false;
+  }
+  return /using\s+fts/i.test(sql);
+}
+
+function escapeIdentifier(name) {
+  const escaped = String(name).replace(/"/g, '""');
+  return `"${escaped}"`;
+}
+
+function normalizeDump(rawDump) {
+  const lines = rawDump.split("\n");
+  const output = [];
+  const tablesInOrder = [];
+  const viewsInOrder = [];
+  for (const line of lines) {
+    const tableMatch = line.match(/^CREATE TABLE\s+("?[^"]+"?)/i);
+    if (tableMatch) {
+      tablesInOrder.push(tableMatch[1].replace(/\s*\($/, ""));
+      continue;
+    }
+    const viewMatch = line.match(/^CREATE VIEW\s+("?[^"]+"?)/i);
+    if (viewMatch) {
+      viewsInOrder.push(viewMatch[1].replace(/\s*\($/, ""));
+    }
+  }
+  for (const viewName of viewsInOrder.reverse()) {
+    output.push(`DROP VIEW IF EXISTS ${viewName};`);
+  }
+  for (const tableName of tablesInOrder.reverse()) {
+    output.push(`DROP TABLE IF EXISTS ${tableName};`);
+  }
+  for (const line of lines) {
+    if (line === "BEGIN TRANSACTION;" || line === "COMMIT;") {
+      continue;
+    }
+    if (line.startsWith("PRAGMA foreign_keys=")) {
+      continue;
+    }
+    const tableMatch = line.match(/^CREATE TABLE\s+("?[^"]+"?)/i);
+    if (tableMatch) {
+      output.push(line);
+      continue;
+    }
+    const viewMatch = line.match(/^CREATE VIEW\s+("?[^"]+"?)/i);
+    if (viewMatch) {
+      output.push(line);
+      continue;
+    }
+    output.push(line);
+  }
+  return output.join("\n");
+}
+
+async function hashFile(filePath) {
+  return new Promise((resolve, reject) => {
+    const hash = createHash("sha256");
+    const stream = createReadStream(filePath, { highWaterMark: 1024 * 1024 });
+    stream.on("data", (chunk) => hash.update(chunk));
+    stream.on("error", reject);
+    stream.on("end", () => resolve(hash.digest("hex")));
+  });
+}
+
+async function countTables(dbFile) {
+  const db = createReadonlyClient(dbFile);
+  try {
+    const rows = await executeRows(db, "select name from sqlite_master where type = 'table'");
+    const tables = {};
+    for (const row of rows) {
+      const tableName = asString(row.name);
+      try {
+        const countRows = await executeRows(
+          db,
+          `select count(*) as count from ${escapeIdentifier(tableName)}`,
+        );
+        const countRow = countRows[0];
+        const countValue = countRow?.count;
+        const count = typeof countValue === "number" ? countValue : Number(countValue ?? 0);
+        tables[tableName] = { count: Number.isNaN(count) ? 0 : count };
+      } catch {
+        tables[tableName] = { count: 0 };
+      }
+    }
+    return tables;
+  } finally {
+    db.close();
+  }
+}
+
+function createReadonlyClient(dbFile) {
+  const fileUrl = pathToFileURL(dbFile);
+  return createClient({ url: fileUrl.toString() });
+}
+
+async function executeRows(db, sql, args = []) {
+  const result = await db.execute({ sql, args });
+  return normalizeLibsqlRows(result);
+}
+
+function normalizeLibsqlRows(result) {
+  const rows = Array.isArray(result?.rows) ? result.rows : [];
+  if (!rows.length) {
+    return [];
+  }
+
+  const firstRow = rows[0];
+  if (firstRow && typeof firstRow === "object" && !Array.isArray(firstRow)) {
+    return rows;
+  }
+
+  const columns = Array.isArray(result?.columns)
+    ? result.columns.map((column) => {
+        if (typeof column === "string") {
+          return column;
+        }
+        if (column && typeof column === "object" && "name" in column) {
+          return String(column.name ?? "");
+        }
+        return "";
+      })
+    : [];
+
+  if (!columns.length) {
+    return [];
+  }
+
+  return rows.map((row) => {
+    const values = Array.isArray(row) ? row : [];
+    const mapped = {};
+    for (let index = 0; index < columns.length; index += 1) {
+      const column = columns[index];
+      if (column) {
+        mapped[column] = values[index];
+      }
+    }
+    return mapped;
+  });
+}