datasette-ts 0.0.8 → 0.0.10

package/dist/cli.js

@@ -23666,8 +23666,8 @@ var init_node4 = __esm({
 });
 
 // src/cli/deploy-cloudflare.ts
-import { stat as stat2 } from "node:fs/promises";
-import { dirname, extname, join, resolve } from "node:path";
+import { mkdir as mkdir2, stat as stat2, writeFile } from "node:fs/promises";
+import { dirname, extname, join, relative, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import alchemy from "alchemy";
 import { Assets, D1Database, Worker } from "alchemy/cloudflare";
@@ -24017,6 +24017,8 @@ function normalizeLibsqlRows(result) {
 
 // src/cli/deploy-cloudflare.ts
 var DEFAULT_IMPORTS_DIR = ".datasette-ts/imports";
+var MAX_TEXT_BINDING_BYTES = 5 * 1024;
+var WORKER_OVERRIDE_DIR = "worker";
 async function runCloudflareDeploy(args) {
   const startedAt = Date.now();
   logStep("Starting Cloudflare deploy");
@@ -24057,8 +24059,41 @@ async function runCloudflareDeploy(args) {
     logStep("Precomputing inspect data");
     inspectData = await loadInspectDataFromFile(options.dbFile, options.dbName);
   }
+  const schemaJson = JSON.stringify({ [options.dbName]: schema });
+  const schemaSize = byteLength(schemaJson);
+  let schemaBinding = null;
+  let embedSchema = false;
+  if (schemaSize <= MAX_TEXT_BINDING_BYTES) {
+    schemaBinding = schemaJson;
+  } else {
+    embedSchema = true;
+    logStep(`Schema JSON is ${formatBytes2(schemaSize)}; embedding in worker bundle.`);
+  }
+  let inspectJson = null;
+  let inspectBinding = null;
+  let embedInspect = false;
+  if (inspectData) {
+    inspectJson = JSON.stringify(inspectData);
+    const inspectSize = byteLength(inspectJson);
+    if (inspectSize <= MAX_TEXT_BINDING_BYTES) {
+      inspectBinding = inspectJson;
+    } else {
+      embedInspect = true;
+      logStep(`Inspect data is ${formatBytes2(inspectSize)}; embedding in worker bundle.`);
+    }
+  }
   logStep("Initializing Alchemy app");
   const app = await alchemy(options.workerName);
+  let finalWorkerEntrypoint = workerEntrypoint;
+  if (embedSchema || embedInspect) {
+    finalWorkerEntrypoint = await createEmbeddedWorkerEntrypoint({
+      baseEntrypoint: workerEntrypoint,
+      outputDir: options.importsDir,
+      schemaJson: embedSchema ? schemaJson : null,
+      inspectJson: embedInspect ? inspectJson : null,
+      log: logStep
+    });
+  }
   logStep("Creating D1 database");
   const db = await D1Database(`d1-${options.d1Name}`, {
     name: options.d1Name,
@@ -24073,15 +24108,17 @@ async function runCloudflareDeploy(args) {
   const bindings = {
     DATASETTE_DB: db,
     ASSETS: staticAssets,
-    DATASETTE_DB_NAME: options.dbName,
-    DATASETTE_SCHEMA: JSON.stringify({ [options.dbName]: schema })
+    DATASETTE_DB_NAME: options.dbName
   };
-  if (inspectData) {
-    bindings.DATASETTE_INSPECT_DATA = JSON.stringify(inspectData);
+  if (schemaBinding) {
+    bindings.DATASETTE_SCHEMA = schemaBinding;
+  }
+  if (inspectBinding) {
+    bindings.DATASETTE_INSPECT_DATA = inspectBinding;
   }
   logStep("Deploying worker");
   const worker = await Worker(`worker-${options.workerName}`, {
-    entrypoint: workerEntrypoint,
+    entrypoint: finalWorkerEntrypoint,
     compatibilityFlags: ["nodejs_compat"],
     bundle: {
       external: ["bun:sqlite"]
@@ -24281,10 +24318,65 @@ function formatDuration(ms) {
   const seconds = (ms / 1e3).toFixed(1);
   return `${seconds}s`;
 }
+function byteLength(value) {
+  if (typeof Buffer !== "undefined") {
+    return Buffer.byteLength(value, "utf8");
+  }
+  return new TextEncoder().encode(value).length;
+}
+function formatBytes2(bytes) {
+  if (!Number.isFinite(bytes) || bytes < 0) {
+    return "0 B";
+  }
+  const units = ["B", "KB", "MB", "GB"];
+  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 createEmbeddedWorkerEntrypoint(options) {
+  const workerDir = join(options.outputDir, WORKER_OVERRIDE_DIR);
+  await mkdir2(workerDir, { recursive: true });
+  const entrypointPath = join(workerDir, "embedded-worker.js");
+  const relativeEntrypoint = toPosixPath(relative(workerDir, options.baseEntrypoint));
+  const entrypointImport = relativeEntrypoint.startsWith(".") ? relativeEntrypoint : `./${relativeEntrypoint}`;
+  const schemaLiteral = options.schemaJson ? JSON.stringify(options.schemaJson) : "null";
+  const inspectLiteral = options.inspectJson ? JSON.stringify(options.inspectJson) : "null";
+  const contents = [
+    `import worker from ${JSON.stringify(entrypointImport)};`,
+    `const EMBEDDED_SCHEMA = ${schemaLiteral};`,
+    `const EMBEDDED_INSPECT = ${inspectLiteral};`,
+    "",
+    "export default {",
+    "  fetch(request, env, ctx) {",
+    "    let nextEnv = env;",
+    "    if (EMBEDDED_SCHEMA || EMBEDDED_INSPECT) {",
+    "      nextEnv = {",
+    "        ...env,",
+    "        ...(EMBEDDED_SCHEMA ? { DATASETTE_SCHEMA: EMBEDDED_SCHEMA } : {}),",
+    "        ...(EMBEDDED_INSPECT ? { DATASETTE_INSPECT_DATA: EMBEDDED_INSPECT } : {}),",
+    "      };",
+    "    }",
+    "    return worker.fetch(request, nextEnv, ctx);",
+    "  },",
+    "};",
+    ""
+  ].join("\n");
+  await writeFile(entrypointPath, contents, "utf8");
+  options.log(`Embedded worker entrypoint: ${entrypointPath}`);
+  return entrypointPath;
+}
+function toPosixPath(value) {
+  return value.replace(/\\/g, "/");
+}
 
 // src/cli/serve.ts
 init_registry();
-import { stat as stat5, writeFile } from "node:fs/promises";
+import { stat as stat5, writeFile as writeFile2 } from "node:fs/promises";
 import { join as join2 } from "node:path";
 
 // src/core/inspect.ts
@@ -24457,7 +24549,7 @@ async function runInspectCommand(args) {
   const data = await inspectDatabases(databasePaths);
   const json = JSON.stringify(data, null, 2);
   if (inspectFile) {
-    await writeFile(inspectFile, json, "utf8");
+    await writeFile2(inspectFile, json, "utf8");
     return;
   }
   process.stdout.write(`${json}