@base44/functions-compiler 0.1.0

package/lib/src/actor-compat.d.ts

@@ -0,0 +1,24 @@
+/**
+ * The FOLDER is the actor's identity: an entry at base44/actors/<Name>/entry.ts
+ * IS an actor named <Name> — no source inspection. The generated DO wrapper
+ * re-exports the entry's DEFAULT export under the folder name, so the user's
+ * class name is cosmetic (a missing default export fails the esbuild compile).
+ * A generated prelude installs the shared request-scoped runtime before the
+ * user module is evaluated.
+ */
+export interface ActorCompat {
+    /** New entry filename (the generated DO wrapper). */
+    entry: string;
+    /** Files dict with the generated DO wrapper added (user source unchanged). */
+    files: Record<string, string>;
+    /** PascalCase class name, e.g. "GameRoom". */
+    handlerName: string;
+    /** Exported DO class name, same as handlerName. */
+    doClassName: string;
+}
+/**
+ * If the entry is a canonical actor path (the folder is the identity), return
+ * a bundle input with the partyserver DO entry wrapper generated. Returns
+ * `null` for normal (non-realtime) functions.
+ */
+export declare function applyActorCompat(entry: string, files: Record<string, string>): ActorCompat | null;

package/lib/src/actor-compat.js

@@ -0,0 +1,302 @@
+/**
+ * The FOLDER is the actor's identity: an entry at base44/actors/<Name>/entry.ts
+ * IS an actor named <Name> — no source inspection. The generated DO wrapper
+ * re-exports the entry's DEFAULT export under the folder name, so the user's
+ * class name is cosmetic (a missing default export fails the esbuild compile).
+ * A generated prelude installs the shared request-scoped runtime before the
+ * user module is evaluated.
+ */
+import { RUNTIME_CONTEXT_SPECIFIER } from "./esbuild/runtime-context-virtual.js";
+import { assertNoReservedFilenames, CONSOLE_PATCH, SHIM_FILENAME, workerRuntimeFiles, } from "./worker-entry.js";
+const ACTOR_ENTRY_FILENAME = "__base44_actor_entry.mjs";
+const ACTOR_PRELUDE_FILENAME = "__base44_actor_prelude.mjs";
+const ACTOR_AUTH_FILENAME = "__base44_actor_auth.mjs";
+const ACTORS_PREFIX = "base44/actors/";
+const ENTRY_SUFFIX = "/entry.ts";
+/** The actor (folder) name for a canonical entry path, else null. */
+function actorNameFromEntry(entry) {
+    if (!entry.startsWith(ACTORS_PREFIX) || !entry.endsWith(ENTRY_SUFFIX))
+        return null;
+    const name = entry.slice(ACTORS_PREFIX.length, -ENTRY_SUFFIX.length);
+    return name && !name.includes("/") ? name : null;
+}
+/**
+ * If the entry is a canonical actor path (the folder is the identity), return
+ * a bundle input with the partyserver DO entry wrapper generated. Returns
+ * `null` for normal (non-realtime) functions.
+ */
+export function applyActorCompat(entry, files) {
+    const actorName = actorNameFromEntry(entry);
+    // Key presence, not truthiness: an EMPTY canonical entry is still an actor —
+    // falling through would deploy a plain HTTP Worker under the actor identity.
+    // The wrapper's default-export import fails the bundle loudly instead.
+    if (!actorName || files[entry] === undefined)
+        return null;
+    // Actor bundles bypass prepareFunction(), so enforce the same complete
+    // generated-filename reservation before adding the wrapper and runtime shim.
+    assertNoReservedFilenames(files);
+    if (ACTOR_PRELUDE_FILENAME in files) {
+        throw new Error(`Reserved filename "${ACTOR_PRELUDE_FILENAME}" in actor bundle — ` +
+            "it is generated by the bundler. Rename the file.");
+    }
+    if (ACTOR_AUTH_FILENAME in files) {
+        throw new Error(`Reserved filename "${ACTOR_AUTH_FILENAME}" in actor bundle — ` +
+            "it is generated by the bundler. Rename the file.");
+    }
+    const handlerName = actorName;
+    const doClassName = handlerName;
+    const prelude = buildPrelude();
+    const entryWrapper = buildEntryWrapper(doClassName, entry);
+    return {
+        entry: ACTOR_ENTRY_FILENAME,
+        files: {
+            ...files,
+            ...workerRuntimeFiles(),
+            [ACTOR_AUTH_FILENAME]: buildActorAuth(),
+            [ACTOR_PRELUDE_FILENAME]: prelude,
+            [ACTOR_ENTRY_FILENAME]: entryWrapper,
+        },
+        handlerName,
+        doClassName,
+    };
+}
+function buildActorAuth() {
+    return `// Auto-generated by the base44 bundler. Do not edit.
+const TOKEN_HEADER = "X-Base44-Actor-Token";
+const IDENTITY_HEADER = "X-Base44-Actor-Identity";
+const CLOCK_SKEW_SECONDS = 30;
+const TOKEN_TTL_SECONDS = 300;
+
+const decodeSegment = (segment) => {
+  const normalized = segment.replace(/-/g, "+").replace(/_/g, "/");
+  const padded = normalized + "=".repeat((4 - normalized.length % 4) % 4);
+  const binary = atob(padded);
+  return new Uint8Array([...binary].map((character) => character.charCodeAt(0)));
+};
+
+const decodeJsonSegment = (segment) =>
+  JSON.parse(new TextDecoder().decode(decodeSegment(segment)));
+
+const unauthorized = () => ({
+  ok: false,
+  response: new Response("Unauthorized", { status: 401 }),
+});
+
+const validPrincipal = (principal) => {
+  if (principal === null || typeof principal !== "object" || Array.isArray(principal)) return false;
+  if (principal.type === "authenticated") {
+    return typeof principal.userId === "string" && principal.userId.length > 0 && principal.userId.length <= 128;
+  }
+  if (principal.type === "anonymous") {
+    return typeof principal.anonymousId === "string" && principal.anonymousId.length > 0 && principal.anonymousId.length <= 128;
+  }
+  return false;
+};
+
+export async function verifyActorConnection(request, env, actorName, room) {
+  const publicKey = env.BASE44_ACTOR_PUBLIC_KEY;
+  const scriptId = env.BASE44_ACTOR_SCRIPT_ID;
+  const token = request.headers.get(TOKEN_HEADER) ?? new URL(request.url).searchParams.get("token");
+  if (
+    typeof publicKey !== "string" || !publicKey ||
+    typeof scriptId !== "string" || !scriptId ||
+    typeof token !== "string" || token.length > 4096
+  ) return unauthorized();
+
+  const parts = token.split(".");
+  if (parts.length !== 3) return unauthorized();
+  try {
+    const header = decodeJsonSegment(parts[0]);
+    const claims = decodeJsonSegment(parts[1]);
+    if (header?.alg !== "EdDSA" || (header.typ !== undefined && header.typ !== "JWT")) {
+      return unauthorized();
+    }
+    const key = await crypto.subtle.importKey(
+      "raw",
+      decodeSegment(publicKey),
+      { name: "Ed25519" },
+      false,
+      ["verify"],
+    );
+    const validSignature = await crypto.subtle.verify(
+      { name: "Ed25519" },
+      key,
+      decodeSegment(parts[2]),
+      new TextEncoder().encode(parts[0] + "." + parts[1]),
+    );
+    if (!validSignature) return unauthorized();
+
+    const now = Math.floor(Date.now() / 1000);
+    const times = [claims.iat, claims.nbf, claims.exp];
+    if (!times.every(Number.isInteger)) return unauthorized();
+    if (
+      claims.iss !== "base44" ||
+      claims.aud !== "base44-actor-connect" ||
+      claims.purpose !== "actor-connect" ||
+      claims.v !== 1 ||
+      typeof claims.jti !== "string" || !claims.jti || claims.jti.length > 64 ||
+      claims.iat > now + CLOCK_SKEW_SECONDS ||
+      claims.nbf > now + CLOCK_SKEW_SECONDS ||
+      claims.exp < now - CLOCK_SKEW_SECONDS ||
+      claims.exp <= claims.iat || claims.exp - claims.iat > TOKEN_TTL_SECONDS ||
+      claims.app_id !== env.BASE44_APP_ID ||
+      claims.actor_name !== actorName ||
+      claims.actor_script_id !== scriptId ||
+      claims.room !== room ||
+      claims.connection_id !== new URL(request.url).searchParams.get("_pk") ||
+      claims.runtime_mode !== (env.BASE44_FUNCTIONS_VERSION === "prod" ? "prod" : "preview") ||
+      !validPrincipal(claims.principal)
+    ) return unauthorized();
+
+    return {
+      ok: true,
+      identity: Object.freeze({ ...claims.principal }),
+      runtimeMode: claims.runtime_mode,
+    };
+  } catch {
+    return unauthorized();
+  }
+}
+
+export function authorizedActorRequest(request, identity, actorName, room, runtimeMode) {
+  const url = new URL(request.url);
+  url.searchParams.delete("token");
+  url.pathname = "/parties/" + encodeURIComponent(actorName) + "/" + encodeURIComponent(room);
+  const headers = new Headers(request.headers);
+  headers.delete(TOKEN_HEADER);
+  headers.set(IDENTITY_HEADER, JSON.stringify(identity));
+  headers.set("base44-functions-version", runtimeMode === "prod" ? "prod" : "preview");
+  return new Request(new Request(url.toString(), request), { headers });
+}
+`;
+}
+function buildPrelude() {
+    return `// Auto-generated by the base44 bundler. Do not edit.
+import { currentWorkerRuntimeContext as _b44Context } from ${JSON.stringify(RUNTIME_CONTEXT_SPECIFIER)};
+import { installStaticEgressFetch } from "./${SHIM_FILENAME}";
+
+${CONSOLE_PATCH}
+installStaticEgressFetch();
+`;
+}
+function buildEntryWrapper(doClassName, userEntry) {
+    const userImport = `./${userEntry.replace(/^\.\//, "")}`;
+    // ponytail: skip routePartykitRequest (uses Object.entries(env) which doesn't enumerate
+    // DO namespace bindings in WfP dispatch context). Access env["ChatRoom"] directly instead.
+    return `// Auto-generated by the base44 bundler. Do not edit.
+// The prelude is intentionally the first dependency: it installs the fetch
+// shim before the user module evaluates while this static default import keeps
+// missing-default actors as bundle-time errors.
+import "./${ACTOR_PRELUDE_FILENAME}";
+import Base44UserActor from ${JSON.stringify(userImport)};
+import { runWithWorkerEnvironment as _b44Run } from ${JSON.stringify(RUNTIME_CONTEXT_SPECIFIER)};
+import { authorizedActorRequest as _b44AuthorizedActorRequest, verifyActorConnection as _b44VerifyActorConnection } from "./${ACTOR_AUTH_FILENAME}";
+
+const _b44ActorState = new WeakMap();
+const _b44RunWithActorEnvironment = (ctx, env, runtimeEnv, callback) => _b44Run({
+  env: runtimeEnv,
+  secrets: env,
+  workerEnv: env,
+  waitUntil: (promise) => ctx.waitUntil(promise),
+}, callback);
+const _b44ConstructActor = (ctx, env, newTarget) => _b44RunWithActorEnvironment(
+  ctx,
+  env,
+  "prod",
+  () => {
+    // A derived constructor may return an explicitly constructed instance.
+    // This keeps the user's constructor and class-field initializers inside the
+    // request-scoped Worker environment without changing the exported subclass.
+    const actor = Reflect.construct(Base44UserActor, [ctx, env], newTarget);
+    _b44ActorState.set(actor, { ctx, env, runtimeEnv: null });
+    return actor;
+  },
+);
+const _b44RunActor = (actor, request, callback) => {
+  const state = _b44ActorState.get(actor);
+  const runtimeEnv = request
+    ? ((request.headers.get("base44-functions-version") ?? "") === "prod" ? "prod" : "preview")
+    : (state.runtimeEnv ?? "prod");
+  state.runtimeEnv = runtimeEnv;
+  return _b44RunWithActorEnvironment(state.ctx, state.env, runtimeEnv, callback);
+};
+
+export class ${doClassName} extends Base44UserActor {
+  // Read by the shim's service-token exchange: the assertion's actor_name claim
+  // selects the verification key on the platform side. A static (not .name) so
+  // minification can't change it.
+  static _b44ActorName = ${JSON.stringify(doClassName)};
+
+  constructor(ctx, env) {
+    return _b44ConstructActor(ctx, env, new.target);
+  }
+
+  fetch(request) {
+    return _b44RunActor(this, request, () => super.fetch(request));
+  }
+
+  onConnect(...args) {
+    return _b44RunActor(this, null, () => super.onConnect(...args));
+  }
+
+  onMessage(...args) {
+    return _b44RunActor(this, null, () => super.onMessage(...args));
+  }
+
+  onClose(...args) {
+    return _b44RunActor(this, null, () => super.onClose(...args));
+  }
+
+  onAlarm(...args) {
+    return _b44RunActor(this, null, () => super.onAlarm(...args));
+  }
+
+  onStart(...args) {
+    return _b44RunActor(this, null, () => super.onStart(...args));
+  }
+
+  onError(...args) {
+    return _b44RunActor(this, null, () => super.onError(...args));
+  }
+}
+export default {
+  async fetch(request, env, ctx) {
+    const url = new URL(request.url);
+    const parts = url.pathname.split("/");
+    const direct = parts[1] === "rooms" && parts.length === 3;
+    const legacy = parts[1] === "parties" && parts.length === 4;
+    if (direct || legacy) {
+      // Decode the room: the token was verified against the decoded instance id,
+      // so an escaped room must map to the same Durable Object.
+      const namespace = direct ? "${doClassName}" : parts[2];
+      const encodedRoom = direct ? parts[2] : parts[3];
+      let room;
+      try { room = decodeURIComponent(encodedRoom); } catch { return new Response("Invalid room", { status: 400 }); }
+      let actorRequest = request;
+      if (direct || typeof env.BASE44_ACTOR_PUBLIC_KEY === "string") {
+        const verification = await _b44VerifyActorConnection(request, env, "${doClassName}", room);
+        if (!verification.ok) return verification.response;
+        actorRequest = _b44AuthorizedActorRequest(
+          request,
+          verification.identity,
+          "${doClassName}",
+          room,
+          verification.runtimeMode,
+        );
+      }
+      const doNs = env["${doClassName}"];
+      if (doNs && typeof doNs.idFromName === "function") {
+        const stub = doNs.get(doNs.idFromName(room));
+        const req = new Request(actorRequest);
+        req.headers.set("x-partykit-room", room);
+        req.headers.set("x-partykit-namespace", namespace);
+        return stub.fetch(req);
+      }
+      return new Response("DO binding not found", { status: 503 });
+    }
+    return new Response("Not found", { status: 404 });
+  },
+};
+`;
+}
+//# sourceMappingURL=actor-compat.js.map

package/lib/src/actor-compat.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"actor-compat.js","sourceRoot":"","sources":["../../src/actor-compat.ts"],"names":[],"mappings":"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"}

package/lib/src/bundler.d.ts

@@ -0,0 +1,51 @@
+import type { BundleAppRequest, BundleRequest } from "./contracts.js";
+import { type BundleErrorItem } from "./errors.js";
+import { type AppFunctionEntry } from "./worker-entry.js";
+export type { BundleErrorItem };
+export type BundleErrorStage = "deno_compat" | "esbuild";
+export type BundleResponse = {
+    ok: true;
+    module: string;
+    main_module: string;
+    warnings: string[];
+    handler_name?: string;
+    do_class_name?: string;
+} | {
+    ok: false;
+    stage: BundleErrorStage;
+    errors: BundleErrorItem[];
+};
+export type AppFunctionStatus = {
+    name: string;
+    ok: true;
+} | {
+    name: string;
+    ok: false;
+    errors: BundleErrorItem[];
+};
+export type BundleAppResponse = {
+    ok: true;
+    module: string;
+    main_module: string;
+    functions: AppFunctionStatus[];
+} | {
+    ok: false;
+    module: null;
+    functions: AppFunctionStatus[];
+};
+export declare function bundle(req: BundleRequest): Promise<BundleResponse>;
+export declare function bundleApp(req: BundleAppRequest): Promise<BundleAppResponse>;
+export interface AppErrorClassification {
+    byIndex: Map<number, BundleErrorItem[]>;
+    unattributable: BundleErrorItem[];
+}
+/** Map each combined-build error to the function whose `fn_<index>/` subtree it
+ *  came from, stripping that prefix so the user sees their own path. Errors with
+ *  no `fn_<index>/` prefix (a shared dep deep in node_modules, or no location)
+ *  can't be pinned to one function. */
+export declare function classifyAppErrors(errors: BundleErrorItem[]): AppErrorClassification;
+/** Does this function's source import one of the packages the assembly errors
+ *  originate from, at (or possibly at) the failing major? A specifier pinned to
+ *  a different major is exonerated — its copy of the package is the one that
+ *  works; an unpinned specifier stays blamed. */
+export declare function importsConflictingPackage(entry: AppFunctionEntry, errors: BundleErrorItem[]): boolean;