castle-web-sdk 0.4.5 → 0.4.7

package/src/transport.ts

@@ -1,169 +0,0 @@
-// Deck-side command-poster. The SDK never makes API calls or holds the auth
-// token; every privileged operation becomes a `command` posted to the outer
-// runtime (host), which validates it, stamps trusted context, runs the call
-// with its own auth, and replies. Three host channels:
-//   - mobile  → window.ReactNativeWebView.postMessage; host pushes responses
-//               back by calling window.__castleSdkHost.receive(...)
-//   - web     → window.parent.postMessage; responses via 'message' events
-//   - local   → the castle-web serve dev server, over runtime.ts's websocket
-// Error reconstruction is uniform here so callers always get a CastleError.
-
-import {
-  CASTLE_SDK_PROTOCOL,
-  isResponseEnvelope,
-  type CommandName,
-  type CommandParams,
-  type CommandResponseEnvelope,
-  type CommandResult,
-  type SerializedCommandError,
-} from "./commands";
-import { getCastleEmbed } from "./context";
-import { CastleError } from "./errors";
-import { sendLocalCommand } from "./runtime";
-
-const REQUEST_TIMEOUT_MS = 15000;
-
-// Interactive platform commands hold the screen while the player interacts with
-// a host-native sheet (e.g. a pass purchase), so the flat data-command timeout
-// is wrong for them: they get NO timeout and resolve only when the host replies.
-const INTERACTIVE_COMMANDS: ReadonlySet<CommandName> = new Set<CommandName>([
-  "pass.offer",
-]);
-
-type PostChannel = "mobile" | "web";
-
-interface PendingCommand {
-  resolve: (env: CommandResponseEnvelope) => void;
-  reject: (error: Error) => void;
-  timeout?: ReturnType<typeof setTimeout>;
-}
-
-interface ReactNativeWebViewBridge {
-  postMessage: (message: string) => void;
-}
-
-declare global {
-  interface Window {
-    ReactNativeWebView?: ReactNativeWebViewBridge;
-    __castleSdkHost?: { receive: (message: unknown) => void };
-  }
-}
-
-let nextRequestId = 1;
-const pending = new Map<string, PendingCommand>();
-let listenersInstalled = false;
-
-export async function hostRequest<C extends CommandName>(
-  command: C,
-  params: CommandParams[C],
-): Promise<CommandResult[C]> {
-  try {
-    const channel = resolveChannel();
-    const env =
-      channel === "local"
-        ? await sendLocalCommand(command, params)
-        : await postCommand(channel, command, params);
-    return interpretResponse(command, env) as CommandResult[C];
-  } catch (error) {
-    // Honor the SDK contract that every thrown error is a CastleError. Errors
-    // surfaced by the host (interpretResponse) are already CastleErrors; this
-    // wraps transport-level failures (host timeout / unreachable / dev server
-    // disconnected) that would otherwise be plain Errors.
-    if (error instanceof CastleError) throw error;
-    throw new CastleError({
-      code: "CASTLE_HOST_UNAVAILABLE",
-      message:
-        error instanceof Error
-          ? error.message
-          : `Castle host did not handle ${command}.`,
-      operation: command,
-    });
-  }
-}
-
-// Exposed so capability modules (e.g. passes) can tell whether the current host
-// has its own UI surface over the deck. "mobile"/"web" hosts render their own
-// purchase/upsell UI; the "local" dev server has none, so the SDK itself shows
-// a minimal in-page notice there.
-export function getCommandChannel(): PostChannel | "local" {
-  return resolveChannel();
-}
-
-function resolveChannel(): PostChannel | "local" {
-  if (typeof window === "undefined") return "local";
-  if (window.ReactNativeWebView) return "mobile";
-  const host = getCastleEmbed()?.host;
-  if (host === "web") return "web";
-  if (host === "dev") return "local";
-  // Fallback: an iframe with a parent is the web player; otherwise assume the
-  // local dev server (top-level page served by `castle-web serve`).
-  return window.parent && window.parent !== window ? "web" : "local";
-}
-
-function postCommand<C extends CommandName>(
-  channel: PostChannel,
-  command: C,
-  params: CommandParams[C],
-): Promise<CommandResponseEnvelope> {
-  installResponseListener();
-  const requestId = `csdk_${nextRequestId++}`;
-  return new Promise<CommandResponseEnvelope>((resolve, reject) => {
-    const timeout = INTERACTIVE_COMMANDS.has(command)
-      ? undefined
-      : setTimeout(() => {
-          pending.delete(requestId);
-          reject(new Error(`Castle host did not respond to ${command}.`));
-        }, REQUEST_TIMEOUT_MS);
-    pending.set(requestId, { resolve, reject, timeout });
-    sendEnvelope(channel, { castleSdk: CASTLE_SDK_PROTOCOL, requestId, command, params });
-  });
-}
-
-function sendEnvelope(channel: PostChannel, envelope: unknown): void {
-  const json = JSON.stringify(envelope);
-  if (channel === "mobile") {
-    window.ReactNativeWebView?.postMessage(json);
-  } else {
-    window.parent.postMessage(envelope, "*");
-  }
-}
-
-// The mobile host can't dispatch a DOM 'message' event, so it calls this global
-// directly with the parsed envelope. The web host posts a 'message' event.
-function installResponseListener(): void {
-  if (listenersInstalled || typeof window === "undefined") return;
-  listenersInstalled = true;
-  window.__castleSdkHost = { receive: (message) => settle(message) };
-  window.addEventListener("message", (event: MessageEvent) => {
-    settle(event.data);
-  });
-}
-
-function settle(message: unknown): void {
-  if (!isResponseEnvelope(message)) return;
-  const entry = pending.get(message.requestId);
-  if (!entry) return;
-  if (entry.timeout) clearTimeout(entry.timeout);
-  pending.delete(message.requestId);
-  entry.resolve(message);
-}
-
-function interpretResponse(
-  command: CommandName,
-  env: CommandResponseEnvelope,
-): unknown {
-  if (env.ok) return env.data;
-  throw fromSerializedError(env.error, command);
-}
-
-function fromSerializedError(
-  error: SerializedCommandError | undefined,
-  command: CommandName,
-): CastleError {
-  return new CastleError({
-    code: error?.code ?? "CASTLE_HOST_ERROR",
-    message: error?.message ?? `Castle command ${command} failed.`,
-    operation: error?.command ?? command,
-    extensions: error?.extensions,
-  });
-}

package/src/types.ts

@@ -1,7 +0,0 @@
-export type Json =
-  | null
-  | boolean
-  | number
-  | string
-  | Json[]
-  | { [key: string]: Json };

package/src/user.ts

@@ -1,58 +0,0 @@
-import { CastleError } from "./errors";
-import { hostRequest } from "./transport";
-
-export interface CastleUser {
-  userId: string;
-  username: string;
-  isActive: boolean;
-}
-
-export interface CastleUserApi {
-  getCurrent(): Promise<CastleUser>;
-}
-
-let currentUser: CastleUser | null = null;
-let currentUserPromise: Promise<CastleUser> | null = null;
-
-export const User: CastleUserApi = {
-  getCurrent,
-};
-
-async function getCurrent(): Promise<CastleUser> {
-  if (currentUser) return currentUser;
-  currentUserPromise ??= fetchCurrentUser().then((user) => {
-    currentUser = user;
-    return user;
-  });
-  return currentUserPromise;
-}
-
-async function fetchCurrentUser(): Promise<CastleUser> {
-  const operation = "User.getCurrent";
-  const { user } = await hostRequest("user.getCurrent", {});
-  if (!user) {
-    throw new CastleError({
-      code: "LOGIN_REQUIRED",
-      message: "Log in to Castle before using User.getCurrent().",
-      operation,
-    });
-  }
-  return {
-    userId: requiredString(user.userId, "user.userId", operation),
-    username: requiredString(user.username, "user.username", operation),
-    isActive: true,
-  };
-}
-
-function requiredString(
-  value: string | null | undefined,
-  field: string,
-  operation: string,
-): string {
-  if (typeof value === "string" && value.length > 0) return value;
-  throw new CastleError({
-    code: "GRAPHQL_BAD_DATA",
-    message: `Castle response did not include ${field}.`,
-    operation,
-  });
-}