datasette-ts 0.0.9 → 0.0.11

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";
@@ -24018,6 +24018,7 @@ 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");
@@ -24061,27 +24062,38 @@ async function runCloudflareDeploy(args) {
   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 {
-    logStep(
-      `Schema JSON is ${formatBytes2(schemaSize)}; skipping text binding and using runtime introspection.`
-    );
+    embedSchema = true;
+    logStep(`Schema JSON is ${formatBytes2(schemaSize)}; embedding in worker bundle.`);
   }
+  let inspectJson = null;
   let inspectBinding = null;
+  let embedInspect = false;
   if (inspectData) {
-    const inspectJson = JSON.stringify(inspectData);
+    inspectJson = JSON.stringify(inspectData);
     const inspectSize = byteLength(inspectJson);
     if (inspectSize <= MAX_TEXT_BINDING_BYTES) {
       inspectBinding = inspectJson;
     } else {
-      logStep(
-        `Inspect data is ${formatBytes2(inspectSize)}; skipping text binding.`
-      );
+      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,
@@ -24106,7 +24118,8 @@ async function runCloudflareDeploy(args) {
   }
   logStep("Deploying worker");
   const worker = await Worker(`worker-${options.workerName}`, {
-    entrypoint: workerEntrypoint,
+    name: options.workerName,
+    entrypoint: finalWorkerEntrypoint,
     compatibilityFlags: ["nodejs_compat"],
     bundle: {
       external: ["bun:sqlite"]
@@ -24326,10 +24339,45 @@ function formatBytes2(bytes) {
   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
@@ -24502,7 +24550,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}