lakebed 0.0.18 → 0.0.20

package/src/client.d.ts

@@ -53,11 +53,49 @@ export type SignInWithGoogleProps = Omit<JSX.ButtonHTMLAttributes<HTMLButtonElem
     children?: ComponentChildren;
   };
 
+export type LakebedLocation = {
+  pathname: string;
+  search: string;
+  hash: string;
+  href: string;
+};
+
+export type NavigateOptions = {
+  replace?: boolean;
+};
+
+export type RouterProps = {
+  children?: ComponentChildren;
+};
+
+export type RoutesProps = {
+  children?: ComponentChildren;
+};
+
+export type RouteProps = {
+  path: string;
+  element: ComponentChildren;
+};
+
+export type LinkProps = Omit<JSX.AnchorHTMLAttributes<HTMLAnchorElement>, "href"> & {
+  to: string;
+  replace?: boolean;
+  children?: ComponentChildren;
+};
+
 export function useAuth(): Auth;
 export function signInWithGoogle(options?: SignInWithGoogleOptions): Promise<SignInWithGoogleResult>;
 export function signOut(): void;
 export function getIdentity(): Identity;
 export function decodeIdentityClaims(idToken?: string): IdentityClaims | null;
 export function SignInWithGoogle(props?: SignInWithGoogleProps): JSX.Element;
+export function Router(props?: RouterProps): JSX.Element;
+export function Routes(props?: RoutesProps): JSX.Element | null;
+export function Route(props: RouteProps): JSX.Element | null;
+export function Link(props: LinkProps): JSX.Element;
+export function navigate(to: string, options?: NavigateOptions): void;
+export function useLocation(): LakebedLocation;
+export function useNavigate(): (to: string, options?: NavigateOptions) => void;
+export function useParams<TParams = Record<string, string | undefined>>(): TParams;
 export function useQuery<T>(name: string): T;
 export function useMutation<TArgs extends unknown[], TResult>(name: string): (...args: TArgs) => Promise<TResult>;

package/src/client.js

@@ -1,5 +1,5 @@
-import { h } from "preact";
-import { useEffect, useState } from "preact/hooks";
+import { createContext, h, toChildArray } from "preact";
+import { useContext, useEffect, useState } from "preact/hooks";
 
 const DEFAULT_SHOO_BASE_URL = "https://shoo.dev";
 const AUTH_STORAGE_KEY = "lakebed_identity";
@@ -23,6 +23,14 @@ let authInitialized = false;
 let authResumeStarted = false;
 let refreshRequested = false;
 
+const RouterContext = createContext(null);
+const RouteContext = createContext({ params: {} });
+
+function normalizeBasePathValue(value) {
+  const clean = String(value ?? "").replace(/\/+$/g, "");
+  return clean === "/" ? "" : clean;
+}
+
 function toGuestName(name) {
   return (
     String(name ?? "local")
@@ -144,7 +152,7 @@ function send(message) {
 }
 
 function basePath() {
-  return window.__LAKEBED_BASE_PATH__ ?? "";
+  return normalizeBasePathValue(window.__LAKEBED_BASE_PATH__ ?? "");
 }
 
 function authConfig() {
@@ -159,6 +167,214 @@ function currentRoute() {
   return `${window.location.pathname}${window.location.search}${window.location.hash}`;
 }
 
+function appPathnameFromBrowserPathname(pathname) {
+  const base = basePath();
+  if (!base) {
+    return pathname || "/";
+  }
+
+  if (pathname === base) {
+    return "/";
+  }
+
+  if (pathname.startsWith(`${base}/`)) {
+    return pathname.slice(base.length) || "/";
+  }
+
+  return pathname || "/";
+}
+
+function currentAppLocation() {
+  if (typeof window === "undefined") {
+    return { hash: "", href: "/", pathname: "/", search: "" };
+  }
+
+  const pathname = appPathnameFromBrowserPathname(window.location.pathname);
+  const search = window.location.search;
+  const hash = window.location.hash;
+  return {
+    hash,
+    href: `${pathname}${search}${hash}`,
+    pathname,
+    search
+  };
+}
+
+function isExternalHref(value) {
+  return /^[a-zA-Z][a-zA-Z\d+.-]*:/.test(value) || value.startsWith("//");
+}
+
+function browserHrefForAppHref(appHref) {
+  const url = new URL(appHref, "http://lakebed.local/");
+  const base = basePath();
+  const pathname = base ? `${base}${url.pathname === "/" ? "/" : url.pathname}` : url.pathname;
+  return `${pathname}${url.search}${url.hash}`;
+}
+
+function hrefForRoute(to) {
+  const value = String(to ?? "");
+  if (!value) {
+    return browserHrefForAppHref(currentAppLocation().href);
+  }
+
+  if (isExternalHref(value)) {
+    return value;
+  }
+
+  const current = currentAppLocation();
+  const resolved = new URL(value, `http://lakebed.local${current.href}`);
+  return browserHrefForAppHref(`${resolved.pathname}${resolved.search}${resolved.hash}`);
+}
+
+function emitLocationChange() {
+  window.dispatchEvent(new Event("lakebed:locationchange"));
+}
+
+export function navigate(to, options = {}) {
+  const href = hrefForRoute(to);
+  const parsed = new URL(href, window.location.href);
+
+  if (parsed.origin !== window.location.origin) {
+    window.location.assign(parsed.toString());
+    return;
+  }
+
+  const next = `${parsed.pathname}${parsed.search}${parsed.hash}`;
+  const current = `${window.location.pathname}${window.location.search}${window.location.hash}`;
+  if (next === current) {
+    return;
+  }
+
+  if (options.replace) {
+    window.history.replaceState({}, "", next);
+  } else {
+    window.history.pushState({}, "", next);
+  }
+  emitLocationChange();
+}
+
+function useBrowserLocation() {
+  const [location, setLocation] = useState(currentAppLocation);
+
+  useEffect(() => {
+    function updateLocation() {
+      setLocation(currentAppLocation());
+    }
+
+    window.addEventListener("popstate", updateLocation);
+    window.addEventListener("lakebed:locationchange", updateLocation);
+    return () => {
+      window.removeEventListener("popstate", updateLocation);
+      window.removeEventListener("lakebed:locationchange", updateLocation);
+    };
+  }, []);
+
+  return location;
+}
+
+function normalizeMatchPath(path) {
+  const value = String(path ?? "/").trim();
+  if (value === "*" || value === "/*") {
+    return "*";
+  }
+
+  const withSlash = value.startsWith("/") ? value : `/${value}`;
+  return withSlash.length > 1 ? withSlash.replace(/\/+$/g, "") : "/";
+}
+
+function pathSegments(path) {
+  const normalized = normalizeMatchPath(path);
+  if (normalized === "*" || normalized === "/") {
+    return [];
+  }
+
+  return normalized.replace(/^\/+|\/+$/g, "").split("/");
+}
+
+function decodeRouteSegment(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+
+function matchRoutePath(pattern, pathname) {
+  const normalizedPattern = normalizeMatchPath(pattern);
+  if (normalizedPattern === "*") {
+    return { params: {} };
+  }
+
+  const patternSegments = pathSegments(normalizedPattern);
+  const pathnameSegments = pathSegments(pathname);
+  const params = {};
+
+  for (let index = 0; index < patternSegments.length; index += 1) {
+    const patternSegment = patternSegments[index];
+    const pathnameSegment = pathnameSegments[index];
+
+    if (patternSegment === "*") {
+      params["*"] = pathnameSegments.slice(index).map(decodeRouteSegment).join("/");
+      return { params };
+    }
+
+    if (pathnameSegment === undefined) {
+      return null;
+    }
+
+    if (patternSegment.startsWith(":")) {
+      const name = patternSegment.slice(1);
+      if (!name) {
+        return null;
+      }
+      params[name] = decodeRouteSegment(pathnameSegment);
+      continue;
+    }
+
+    if (patternSegment !== pathnameSegment) {
+      return null;
+    }
+  }
+
+  if (patternSegments.length !== pathnameSegments.length) {
+    return null;
+  }
+
+  return { params };
+}
+
+function routeChildren(children) {
+  const routes = [];
+  for (const child of toChildArray(children)) {
+    if (!child || typeof child !== "object") {
+      continue;
+    }
+
+    if (child.props?.path !== undefined) {
+      routes.push(child);
+      continue;
+    }
+
+    if (child.props?.children !== undefined) {
+      routes.push(...routeChildren(child.props.children));
+    }
+  }
+  return routes;
+}
+
+function shouldHandleLinkClick(event, target) {
+  return (
+    !event.defaultPrevented &&
+    event.button === 0 &&
+    !event.altKey &&
+    !event.ctrlKey &&
+    !event.metaKey &&
+    !event.shiftKey &&
+    (!target || target === "_self") &&
+    !event.currentTarget?.hasAttribute("download")
+  );
+}
+
 function normalizeReturnTo(value) {
   if (!value) {
     return null;
@@ -746,6 +962,72 @@ export function SignInWithGoogle({
   );
 }
 
+export function Router({ children } = {}) {
+  const location = useBrowserLocation();
+  return h(RouterContext.Provider, { value: { location, navigate } }, children);
+}
+
+export function Routes({ children } = {}) {
+  const location = useLocation();
+  const routes = routeChildren(children);
+  for (const route of routes) {
+    const match = matchRoutePath(route.props.path, location.pathname);
+    if (!match) {
+      continue;
+    }
+
+    return h(RouteContext.Provider, { value: match }, route.props.element ?? null);
+  }
+
+  return null;
+}
+
+export function Route() {
+  return null;
+}
+
+export function Link({ children, onClick, replace = false, target, to, ...props } = {}) {
+  const href = hrefForRoute(to);
+  return h(
+    "a",
+    {
+      ...props,
+      href,
+      onClick: (event) => {
+        onClick?.(event);
+        if (!shouldHandleLinkClick(event, target)) {
+          return;
+        }
+
+        const parsed = new URL(href, window.location.href);
+        if (parsed.origin !== window.location.origin) {
+          return;
+        }
+
+        event.preventDefault();
+        navigate(to, { replace });
+      },
+      target
+    },
+    children
+  );
+}
+
+export function useLocation() {
+  const context = useContext(RouterContext);
+  const fallback = useBrowserLocation();
+  return context?.location ?? fallback;
+}
+
+export function useNavigate() {
+  const context = useContext(RouterContext);
+  return context?.navigate ?? navigate;
+}
+
+export function useParams() {
+  return useContext(RouteContext).params;
+}
+
 export function useQuery(name) {
   const [value, setValue] = useState(queryValues.get(name) ?? []);
 

package/src/server.d.ts

@@ -49,11 +49,60 @@ export type ServerContext = {
   log: LogContext;
 };
 
+export type EndpointRoute = {
+  method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "OPTIONS" | "HEAD" | (string & {});
+  path: `/${string}`;
+};
+
+export type EndpointHeaders = {
+  get(name: string): string | null;
+  has(name: string): boolean;
+  entries(): IterableIterator<[string, string]>;
+};
+
+export type EndpointRequest = {
+  method: string;
+  path: string;
+  url: string;
+  headers: EndpointHeaders;
+  query: URLSearchParams;
+  text(): Promise<string>;
+  json<T = unknown>(): Promise<T>;
+  bytes(): Promise<Uint8Array>;
+};
+
+export type EndpointResponse = {
+  kind: "response";
+  status: number;
+  headers?: Record<string, string>;
+  body?: string | Uint8Array | ArrayBuffer;
+};
+
+export type EndpointResponseOptions = {
+  status?: number;
+  headers?: Record<string, string>;
+};
+
+export type EndpointDefinition<TResult = EndpointResponse | string | unknown | void> = {
+  kind: "endpoint";
+  method: string;
+  path: string;
+  handler: (ctx: ServerContext, req: EndpointRequest) => TResult | Promise<TResult>;
+};
+
 export function capsule<T>(definition: T): T;
 export function query<T>(handler: (ctx: ServerContext) => T): (ctx: ServerContext) => T;
 export function mutation<TArgs extends unknown[], TResult>(
   handler: (ctx: ServerContext, ...args: TArgs) => TResult
 ): (ctx: ServerContext, ...args: TArgs) => TResult;
+export function endpoint<TResult>(
+  route: EndpointRoute,
+  handler: (ctx: ServerContext, req: EndpointRequest) => TResult | Promise<TResult>
+): EndpointDefinition<TResult>;
+export function json(value: unknown, options?: EndpointResponseOptions): EndpointResponse;
+export function text(value: unknown, options?: EndpointResponseOptions): EndpointResponse;
+export function empty(options?: EndpointResponseOptions): EndpointResponse;
+export function redirect(url: string, options?: EndpointResponseOptions): EndpointResponse;
 export function table(fields: Record<string, Field<unknown>>): TableDefinition;
 export function string(): Field<string>;
 export function boolean(): Field<boolean>;

package/src/server.js

@@ -10,6 +10,59 @@ export function mutation(handler) {
   return handler;
 }
 
+export function endpoint(route, handler) {
+  return {
+    handler,
+    kind: "endpoint",
+    method: String(route?.method ?? "").toUpperCase(),
+    path: String(route?.path ?? "")
+  };
+}
+
+function response(body, { headers = {}, status = 200 } = {}) {
+  return {
+    body,
+    headers,
+    kind: "response",
+    status
+  };
+}
+
+export function json(value, options = {}) {
+  return response(JSON.stringify(value ?? null), {
+    ...options,
+    headers: {
+      "Content-Type": "application/json; charset=utf-8",
+      ...(options.headers ?? {})
+    }
+  });
+}
+
+export function text(value, options = {}) {
+  return response(String(value ?? ""), {
+    ...options,
+    headers: {
+      "Content-Type": "text/plain; charset=utf-8",
+      ...(options.headers ?? {})
+    }
+  });
+}
+
+export function empty(options = {}) {
+  return response("", { status: 204, ...options });
+}
+
+export function redirect(url, options = {}) {
+  return response("", {
+    status: 302,
+    ...options,
+    headers: {
+      Location: String(url),
+      ...(options.headers ?? {})
+    }
+  });
+}
+
 function field(kind) {
   return {
     kind,

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.20";