sproutboat 0.6.1 → 0.8.0

package/src/update-check.ts

@@ -28,7 +28,7 @@ function cachePath(): string {
 }
 
 /** Numeric x.y.z compare; a trailing `-tag` (prerelease) sorts before its release. */
-function isNewer(latest: string, current: string): boolean {
+export function isNewer(latest: string, current: string): boolean {
   const parts = (v: string) =>
     v
       .split("-")[0]

package/src/wrap.ts

@@ -13,10 +13,41 @@
  *  imported — callers do `readFile(preludePath, "utf8")`. */
 export const preludePath = new URL("./native-fetch-prelude.js", import.meta.url);
 
+/**
+ * #15 — the two transports the prelude can be built with.
+ *
+ * Both define `__sbCall(reqJson) -> replyJson` and nothing else; every binding
+ * shim above that line is identical, which is what lets one conformance suite
+ * hold both honest. `broker` talks to the per-deployment broker over loopback
+ * (deployed, dev, phase-0 standalone); `embedded` compiles SQLite into the
+ * sprout and needs no second process at all.
+ */
+export type Transport = "broker" | "embedded";
+export const transportPath = (transport: Transport): URL =>
+  new URL(transport === "embedded" ? "./transport-embedded.js" : "./transport-broker.js", import.meta.url);
+
+/** Where the prelude expects its transport spliced in. */
+export const TRANSPORT_MARKER =
+  "// TRANSPORT: wrap.ts splices one of transport-broker.js / transport-embedded.js here.";
+
 // The server honours $PORT at runtime (patches/porffor-render.patch); this baked
 // value is only a fallback for a directly-run binary.
 const DEFAULT_PORT = 8080;
 
+/**
+ * What an artifact with no `compatibilityDate` means. Artifacts built before
+ * the field existed keep the semantics of that day forever, because the binary
+ * is immutable and `rollback` can reactivate it at any time.
+ *
+ * How to use it: when a runtime behaviour has to change in a way that would
+ * break a deployed handler, don't change it unconditionally — gate it in the
+ * prelude on `__sbCompat >= "YYYY-MM-DD"` (ISO dates compare correctly as
+ * strings) and document the flip date. Old binaries carry their old date and
+ * keep the old behaviour; a project opts in by moving `compatibility_date` in
+ * its `sproutboat.jsonc` and rebuilding.
+ */
+export const BASELINE_COMPATIBILITY_DATE = "2026-08-26";
+
 /**
  * Binding names a project declares. `do` maps a binding name to a Durable Object
  * class name; `crons` are schedule expressions with no name.
@@ -30,6 +61,9 @@ export type Bindings = {
   queues: string[];
   analytics: string[];
   do: Array<{ binding: string; className: string }>;
+  /** #48 — worker-to-worker: binding name -> the project it calls. The hostname
+   *  it resolves to is a runtime input, not part of the artifact. */
+  services: Array<{ binding: string; service: string }>;
   crons: string[];
   /** Static-asset binding name for `env.<NAME>.fetch(request)`; `""` when assets are edge-only. */
   assets: string;
@@ -44,6 +78,7 @@ export const EMPTY_BINDINGS: Bindings = {
   queues: [],
   analytics: [],
   do: [],
+  services: [],
   crons: [],
   assets: "",
 };
@@ -58,6 +93,7 @@ function hasBindings(b: Bindings): boolean {
     b.queues.length > 0 ||
     b.analytics.length > 0 ||
     b.do.length > 0 ||
+    b.services.length > 0 ||
     b.assets !== ""
   );
 }
@@ -127,6 +163,10 @@ export function wrapNativeFetchHandler(
   vars: Record<string, string> = {},
   bindings: Bindings = EMPTY_BINDINGS,
   port: number = DEFAULT_PORT,
+  compatibilityDate: string = BASELINE_COMPATIBILITY_DATE,
+  appName: string = "app",
+  /** #15 — assets baked into the module for a binary that has no files beside it. */
+  assets?: { manifest: unknown; files: Record<string, string> },
 ): string {
   const neutralised = neutraliseExports(source);
   if (neutralised === null || !/\bfetch\s*\(/.test(source)) {
@@ -134,15 +174,28 @@ export function wrapNativeFetchHandler(
   }
 
   const env = `const env = ${JSON.stringify(vars)};\nglobalThis.env = env;\n`;
+  // Baked, not a binding: the date belongs to the artifact, and a handler must
+  // not be able to change the semantics it was compiled against at runtime.
+  const compat =
+    `globalThis.__sbCompat = ${JSON.stringify(compatibilityDate)};\n` +
+    // #15 — the embedded transport derives its default data directory from this.
+    `globalThis.__sbAppName = ${JSON.stringify(appName)};\n` +
+    // #15 — and enforces the outbound allowlist itself, with no broker to do it.
+    `globalThis.__sbOutbound = ${JSON.stringify(bindings.outbound)};\n` +
+    (assets ? `globalThis.__sbAssets = ${JSON.stringify(assets)};\n` : "");
   const wire = hasBindings(bindings) ? `__sbInstallBindings(env, ${JSON.stringify(bindings)});\n` : "";
   const registerDO = bindings.do.length
     ? `__sbRegisterDO({ ${bindings.do.map((d) => `${d.className}: ${d.className}`).join(", ")} });\n`
     : "";
+  // Cron / queue / alarm timers, for a transport that has no broker to deliver
+  // them. The broker transport defines this as a no-op, so the emitted module
+  // is the same either way.
+  const triggers = hasBindings(bindings) ? `__sbStartLocalTriggers(__sbHandlers, ${JSON.stringify(bindings)});\n` : "";
 
   return (
-    `${prelude}\n${env}${wire}` +
+    `${prelude}\n${compat}${env}${wire}` +
     `${neutralised}\n` +
-    `${registerDO}` +
+    `${registerDO}${triggers}` +
     `export default {\n  port: ${port},\n  fetch(request) { return __sbEntry(__sbHandlers, request); }\n};\n`
   );
 }
@@ -182,6 +235,14 @@ export function readBindingsFromEnv(): Bindings {
   const parsed: VarsJson = JSON.parse(raw);
   if (!isVarsObject(parsed)) throw new Error("SPROUTBOAT_BINDINGS_JSON must be a JSON object");
   const strings = (v: VarsJson): string[] => (Array.isArray(v) ? v.filter(isVarsString) : []);
+  const services: Array<{ binding: string; service: string }> = [];
+  if (Array.isArray(parsed.services)) {
+    for (const entry of parsed.services) {
+      if (isVarsObject(entry) && isVarsString(entry.binding) && isVarsString(entry.service)) {
+        services.push({ binding: entry.binding, service: entry.service });
+      }
+    }
+  }
   const dos: Array<{ binding: string; className: string }> = [];
   if (Array.isArray(parsed.do)) {
     for (const entry of parsed.do) {
@@ -199,6 +260,7 @@ export function readBindingsFromEnv(): Bindings {
     queues: strings(parsed.queues),
     analytics: strings(parsed.analytics),
     do: dos,
+    services,
     crons: strings(parsed.crons),
     assets: isVarsString(parsed.assets) ? parsed.assets : "",
   };