lakebed 0.0.18 → 0.0.19

package/src/source-runtime-worker.js

@@ -312,6 +312,103 @@ function createBrokeredResponse(response) {
   };
 }
 
+function endpointBodyToBase64(body) {
+  if (body === undefined || body === null) {
+    return "";
+  }
+  if (typeof body === "string") {
+    return nodeBuffer.from(body, "utf8").toString("base64");
+  }
+  if (body instanceof ArrayBuffer) {
+    return nodeBuffer.from(body).toString("base64");
+  }
+  if (ArrayBuffer.isView(body)) {
+    return nodeBuffer.from(body.buffer, body.byteOffset, body.byteLength).toString("base64");
+  }
+  return nodeBuffer.from(JSON.stringify(body ?? null), "utf8").toString("base64");
+}
+
+function endpointStatus(status, fallback = 200) {
+  const parsed = Number(status);
+  return Number.isInteger(parsed) && parsed >= 100 && parsed <= 599 ? parsed : fallback;
+}
+
+async function normalizeEndpointResponse(result) {
+  if (result === undefined || result === null) {
+    return { bodyBase64: "", headers: {}, status: 204 };
+  }
+
+  if (
+    result &&
+    typeof result === "object" &&
+    result.kind !== "response" &&
+    typeof result.arrayBuffer === "function" &&
+    typeof result.status === "number"
+  ) {
+    const body = nodeBuffer.from(await result.arrayBuffer());
+    return {
+      bodyBase64: body.toString("base64"),
+      headers: headersToObject(result.headers),
+      status: endpointStatus(result.status)
+    };
+  }
+
+  if (isPlainObject(result) && result.kind === "response") {
+    return {
+      bodyBase64: endpointBodyToBase64(result.body),
+      headers: headersToObject(result.headers),
+      status: endpointStatus(result.status)
+    };
+  }
+
+  if (typeof result === "string") {
+    return {
+      bodyBase64: endpointBodyToBase64(result),
+      headers: { "Content-Type": "text/plain; charset=utf-8" },
+      status: 200
+    };
+  }
+
+  return {
+    bodyBase64: endpointBodyToBase64(result),
+    headers: { "Content-Type": "application/json; charset=utf-8" },
+    status: 200
+  };
+}
+
+function createEndpointRequest(request) {
+  const url = new URL(request.url ?? request.path ?? "/", "http://lakebed.local");
+  const body = nodeBuffer.from(request.bodyBase64 ?? "", "base64");
+  const headers = new Map(Object.entries(headersToObject(request.headers)).map(([key, value]) => [key.toLowerCase(), String(value)]));
+
+  return {
+    headers: {
+      entries() {
+        return headers.entries();
+      },
+      get(name) {
+        return headers.get(String(name).toLowerCase()) ?? null;
+      },
+      has(name) {
+        return headers.has(String(name).toLowerCase());
+      }
+    },
+    method: String(request.method ?? "GET").toUpperCase(),
+    path: request.path ?? url.pathname,
+    query: new URLSearchParams(url.searchParams),
+    url: url.href,
+    async bytes() {
+      return new Uint8Array(body);
+    },
+    async json() {
+      return JSON.parse(body.toString("utf8"));
+    },
+    async text() {
+      return body.toString("utf8");
+    }
+  };
+}
+
 function brokeredFetch(input, init = {}) {
   if (!allowBrokeredFetch) {
     return Promise.reject(new Error("Outbound fetch is disabled for anonymous deploys."));
@@ -389,7 +486,8 @@ function sendError(error) {
   sendToParent?.({
     error: {
       message: error instanceof Error ? error.message : String(error),
-      name: error instanceof Error ? error.name : "Error"
+      name: error instanceof Error ? error.name : "Error",
+      stack: error instanceof Error ? error.stack : undefined
     },
     ok: false,
     type: "source-runtime.result"
@@ -429,6 +527,21 @@ async function runSource(request) {
     return;
   }
 
+  if (request.op === "endpoint") {
+    const definition = app.endpoints?.[request.name];
+    const handler = definition?.handler ?? definition;
+    if (typeof handler !== "function") {
+      throw new Error(`Unknown endpoint: ${request.name}`);
+    }
+    const result = await handler(source.ctx, createEndpointRequest(request.endpointRequest ?? {}));
+    const response = await normalizeEndpointResponse(result);
+    sendResult({
+      operations: jsonSafe(source.operations),
+      response: jsonSafe(response)
+    });
+    return;
+  }
+
   throw new Error(`Unsupported source operation: ${request.op}`);
 }
 

package/src/source-runtime.js

@@ -493,6 +493,9 @@ async function brokeredFetch(request, options) {
 function workerError(payload) {
   const error = new Error(payload?.message ?? "Source runtime failed.");
   error.name = payload?.name ?? "SourceRuntimeError";
+  if (payload?.stack) {
+    error.stack = payload.stack;
+  }
   return error;
 }
 
@@ -557,6 +560,29 @@ export class ChildProcessSourceRuntime {
     }, mutationTransactionOptions(limits));
   }
 
+  async executeEndpoint({ artifact, auth, deployId, limits = DEFAULT_ANONYMOUS_LIMITS, name, request, state }) {
+    return state.transaction(deployId, async (tx) => {
+      const snapshot = await snapshotSourceState({ artifact, deployId, state: tx });
+      const response = await this.runWorker({
+        allowFetch: artifact.deployTarget === "claimed-source",
+        artifact,
+        auth,
+        endpointRequest: request,
+        env: snapshot.env,
+        name,
+        op: "endpoint",
+        rows: snapshot.rows
+      });
+      await applySourceOperations({
+        artifact,
+        deployId,
+        operations: response.operations ?? [],
+        tx
+      });
+      return response.response ?? { bodyBase64: "", headers: {}, status: 204 };
+    }, mutationTransactionOptions(limits));
+  }
+
   runWorker(request) {
     return new Promise((resolveRun, rejectRun) => {
       const child = fork(this.workerPath, [], {
@@ -603,6 +629,7 @@ export class ChildProcessSourceRuntime {
           if (message.ok) {
             finish(resolveRun, {
               operations: message.operations,
+              response: message.response,
               result: message.result
             });
           } else {

package/src/version.js

@@ -1 +1 @@
-export const LAKEBED_VERSION = "0.0.18";
+export const LAKEBED_VERSION = "0.0.19";