@base44-preview/cli 0.1.5-pr.576.161be22 → 0.1.5-pr.576.3ff0d46

package/dist/assets/backend-runtime/base44-runtime.ts

@@ -3,54 +3,60 @@
  *
  * Deployed backend functions import this module by its bare specifier
  * (`import { secrets } from "base44:runtime"`). No such module exists on a
- * developer machine, so `deno.json` maps the specifier onto this file and
+ * developer machine, so `import-map.json` maps the specifier onto this file and
  * `base44 dev` hands that import map to the Deno subprocess.
  *
- * The surface mirrors production; the deliberate differences are called out on
- * each export below.
+ * Like the deployed module, this is only a delegator: it holds no state and
+ * reads no environment. Everything is served by the `globalThis.Base44` bridge
+ * that the host installs before loading the function — `main.ts` locally, the
+ * generated Worker entry when deployed. Keeping the two the same shape means a
+ * change to what a secret *is* only touches the host, never this file.
  */
 
+/** Contract the host installs on `globalThis.Base44`. */
+export interface Base44Bridge {
+  waitUntil(promise: Promise<unknown>): void;
+  secrets: { get(name: string): string | undefined };
+}
+
+function bridge(): Base44Bridge {
+  const installed = (globalThis as { Base44?: Base44Bridge }).Base44;
+  if (!installed) {
+    throw new Error(
+      'base44:runtime was imported without a Base44 function host. It is only available inside a backend function — "base44 dev" installs the bridge before loading your code.',
+    );
+  }
+  return installed;
+}
+
 /**
  * App secrets.
  *
- * Deployed, these are read from the Worker env binding of the current request.
- * Locally they come from the environment `base44 dev` was started with —
- * values stored with `base44 secrets set` are deliberately not fetched, so a
- * production secret is never copied onto a developer machine. Export the
- * variable in your shell to exercise a function that reads it.
+ * Deployed, these come from the Worker env binding of the current request.
+ * Locally the host reads them from the environment `base44 dev` was started
+ * with, so a production secret is never copied onto a developer machine —
+ * export the variable in your shell to exercise a function that reads it.
  *
  * Returns `undefined` for an unset name rather than throwing, matching the
- * deployed signature. Code that needs a secret should construct inside the
+ * deployed signature. Code needing a secret should construct inside the
  * handler: at module scope a client built from `undefined` throws during boot,
  * where no try/catch is reached and nothing is logged.
  */
 export const secrets: { get(name: string): string | undefined } = {
   get(name: string): string | undefined {
-    return Deno.env.get(name);
+    return bridge().secrets.get(name);
   },
 };
 
-// Holds a strong reference to in-flight work so a floating promise cannot be
-// collected before it settles.
-const pending = new Set<Promise<unknown>>();
-
 /**
  * Continue work after the response has been sent.
  *
  * Deployed, this rides `ctx.waitUntil` to extend the invocation until the
- * promise settles. Locally the function is a long-lived server process, so
- * there is nothing to hold open; the promise is tracked only so a rejection is
- * reported against the function instead of surfacing as an unhandled
- * rejection. Returns the same promise so it composes, as in production.
+ * promise settles. Locally the function is a long-lived server process, so the
+ * host has nothing to hold open and only reports rejections. Returns the same
+ * promise either way, so it composes.
  */
 export function waitUntil<T>(promise: Promise<T>): Promise<T> {
-  const tracked = Promise.resolve(promise)
-    .catch((error: unknown) => {
-      console.error("[base44:runtime] waitUntil task failed:", error);
-    })
-    .finally(() => {
-      pending.delete(tracked);
-    });
-  pending.add(tracked);
+  bridge().waitUntil(promise);
   return promise;
 }

package/dist/assets/backend-runtime/main.ts

@@ -20,6 +20,8 @@
 // Make this file a module for top-level await support
 export {};
 
+import type { Base44Bridge } from "./base44-runtime.ts";
+
 const functionPath = Deno.env.get("FUNCTION_PATH");
 const port = parseInt(Deno.env.get("FUNCTION_PORT") || "8000", 10);
 const functionName = Deno.env.get("FUNCTION_NAME") || "unknown";
@@ -81,6 +83,37 @@ Object.defineProperty(Deno, "serve", {
   configurable: true,
 });
 
+// Local stand-in for the bridge the deployed Worker entry installs. It must be
+// in place before the function is imported, because module-scope code may read
+// a secret. Deployed, secrets come from the request's Worker env binding and
+// `waitUntil` rides `ctx.waitUntil`; locally secrets come from this process's
+// environment and the server is long-lived, so there is nothing to hold open —
+// in-flight work is only tracked so a rejection is reported against the
+// function instead of surfacing as an unhandled rejection.
+const inFlight = new Set<Promise<unknown>>();
+
+const base44Bridge: Base44Bridge = {
+  secrets: {
+    get: (name: string) => Deno.env.get(name),
+  },
+  waitUntil: (promise: Promise<unknown>) => {
+    const tracked = Promise.resolve(promise)
+      .catch((error: unknown) => {
+        console.error(`[${functionName}] waitUntil task failed:`, error);
+      })
+      .finally(() => {
+        inFlight.delete(tracked);
+      });
+    inFlight.add(tracked);
+  },
+};
+
+Object.defineProperty(globalThis, "Base44", {
+  value: base44Bridge,
+  writable: false,
+  configurable: true,
+});
+
 type FetchHandler = (req: Request) => Response | Promise<Response>;
 
 /**