@leisuresaas/react 0.1.0

package/src/app-config.ts

@@ -0,0 +1,82 @@
+import { LeisureSaasHttpError } from "./errors";
+import { applyPublishableKeyHeaders } from "./publishable-key";
+
+export type PublicAppConfigRequestContext = {
+  gatewayUrl: string;
+  publishableKey: string;
+  origin: string;
+  locale?: string;
+};
+
+export type AppConfigResponse = {
+  platform: string;
+  policy: {
+    min_supported_version: string;
+    latest_version: string;
+    store_url: string;
+    release_notes?: string;
+    update_message?: string;
+  };
+  links: {
+    support_url: string;
+    terms_url: string;
+    privacy_url: string;
+  };
+  supported_locales: string[];
+  default_locale: string;
+  client?: { app_version?: string; app_build?: string };
+  update: { required: boolean; recommended: boolean; reason: string };
+};
+
+function trimSlash(url: string): string {
+  return url.replace(/\/$/, "");
+}
+
+/** Public app config. Web callers use links and locales; store update fields are for apps. */
+export async function getPublicAppConfig(
+  ctx: PublicAppConfigRequestContext,
+  input: { appVersion?: string; locale?: string; fresh?: boolean } = {},
+): Promise<AppConfigResponse> {
+  const headers: Record<string, string> = {
+    Accept: "application/json",
+    "X-Client-Platform": "web",
+    "X-App-Version": (input.appVersion ?? "0.0.0").trim(),
+  };
+  applyPublishableKeyHeaders(headers, ctx.publishableKey);
+  const locale = input.locale?.trim() || ctx.locale?.trim();
+  if (locale) {
+    headers["Accept-Language"] = locale;
+  }
+  if (ctx.origin.trim()) {
+    headers.Origin = ctx.origin.trim();
+  }
+  if (input.fresh) {
+    headers["Cache-Control"] = "no-cache";
+  }
+
+  let url = `${trimSlash(ctx.gatewayUrl)}/v1/public/app-config/`;
+  if (input.fresh) {
+    url += "?fresh=1";
+  }
+  const res = await fetch(url, { method: "GET", headers });
+  const text = await res.text();
+  if (!res.ok) {
+    throw new LeisureSaasHttpError(res.status, text.trim());
+  }
+  const body = JSON.parse(text) as AppConfigResponse;
+  const links = body.links ?? { support_url: "", terms_url: "", privacy_url: "" };
+  const supported = Array.isArray(body.supported_locales)
+    ? body.supported_locales.map((x) => String(x ?? "").trim()).filter(Boolean)
+    : [];
+  const defaultLocale = String(body.default_locale ?? "").trim() || "en";
+  return {
+    ...body,
+    links: {
+      support_url: String(links.support_url ?? "").trim(),
+      terms_url: String(links.terms_url ?? "").trim(),
+      privacy_url: String(links.privacy_url ?? "").trim(),
+    },
+    supported_locales: supported.length > 0 ? supported : ["en"],
+    default_locale: defaultLocale,
+  };
+}

package/src/auth-provider.tsx

@@ -0,0 +1,90 @@
+"use client";
+
+import { createContext, useCallback, useContext, useEffect, useMemo, useState, type ReactNode } from "react";
+
+import {
+  loginProductAccount,
+  logoutProductAccount,
+  refreshProductSession,
+  registerProductAccount,
+  type ProductAuthTokens,
+  type PublicAuthContext,
+} from "./auth";
+import { accessNeedsRefresh } from "./oauth";
+
+const STORAGE_KEY = "leisuresaas_product_session";
+
+type ProductAuthState = {
+  tokens: ProductAuthTokens | null;
+  ready: boolean;
+  login: (input: { email: string; password: string }) => Promise<void>;
+  register: (input: { email: string; password: string; name?: string }) => Promise<{ verificationRequired: boolean }>;
+  logout: () => Promise<void>;
+};
+
+const ProductAuthContext = createContext<ProductAuthState | null>(null);
+
+function readStored(): ProductAuthTokens | null {
+  if (typeof sessionStorage === "undefined") return null;
+  const raw = sessionStorage.getItem(STORAGE_KEY);
+  if (!raw) return null;
+  try {
+    return JSON.parse(raw) as ProductAuthTokens;
+  } catch {
+    return null;
+  }
+}
+
+export function ProductAuthProvider({ context, children }: { context: PublicAuthContext; children: ReactNode }) {
+  const [tokens, setTokens] = useState<ProductAuthTokens | null>(null);
+  const [ready, setReady] = useState(false);
+
+  const persist = useCallback((next: ProductAuthTokens | null) => {
+    setTokens(next);
+    if (typeof sessionStorage === "undefined") return;
+    if (!next) sessionStorage.removeItem(STORAGE_KEY);
+    else sessionStorage.setItem(STORAGE_KEY, JSON.stringify(next));
+  }, []);
+
+  useEffect(() => {
+    const stored = readStored();
+    if (!stored?.accessToken) {
+      setReady(true);
+      return;
+    }
+    if (!accessNeedsRefresh(stored.accessToken) || !stored.refreshToken) {
+      setTokens(stored);
+      setReady(true);
+      return;
+    }
+    void refreshProductSession(context, stored.refreshToken)
+      .then((next) => persist(next))
+      .catch(() => persist(null))
+      .finally(() => setReady(true));
+  }, [context, persist]);
+
+  const value = useMemo<ProductAuthState>(() => ({
+    tokens,
+    ready,
+    login: async (input) => {
+      persist(await loginProductAccount(context, input));
+    },
+    register: async (input) => registerProductAccount(context, input),
+    logout: async () => {
+      if (tokens?.accessToken) {
+        await logoutProductAccount(context, tokens.accessToken, tokens.refreshToken).catch(() => undefined);
+      }
+      persist(null);
+    },
+  }), [tokens, ready, context, persist]);
+
+  return <ProductAuthContext.Provider value={value}>{children}</ProductAuthContext.Provider>;
+}
+
+export function useProductAuth(): ProductAuthState {
+  const ctx = useContext(ProductAuthContext);
+  if (!ctx) {
+    throw new Error("useProductAuth must be used within ProductAuthProvider");
+  }
+  return ctx;
+}

package/src/auth.ts

@@ -0,0 +1,175 @@
+import { LeisureSaasHttpError } from "./errors";
+import { applyPublishableKeyHeaders } from "./publishable-key";
+
+/** Browser product-account calls. Platform is always web; pass the site origin. */
+export type PublicAuthContext = {
+  gatewayUrl: string;
+  publishableKey: string;
+  origin: string;
+};
+
+export type ProductAuthTokens = {
+  accessToken: string;
+  refreshToken: string;
+  accessExpiresAtUnix: number;
+  refreshExpiresAtUnix: number;
+  userId: string;
+  tenantId: string;
+};
+
+type TokenJSON = {
+  access_token?: string;
+  refresh_token?: string;
+  access_expires_at_unix?: number;
+  refresh_expires_at_unix?: number;
+  user_id?: string;
+  tenant_id?: string;
+};
+
+function trimSlash(url: string): string {
+  return url.replace(/\/$/, "");
+}
+
+function authHeaders(ctx: PublicAuthContext, accessToken?: string): Record<string, string> {
+  const headers: Record<string, string> = {
+    Accept: "application/json",
+    "Content-Type": "application/json",
+    "X-Client-Platform": "web",
+  };
+  applyPublishableKeyHeaders(headers, ctx.publishableKey);
+  if (ctx.origin.trim()) {
+    headers.Origin = ctx.origin.trim();
+  }
+  if (accessToken?.trim()) {
+    headers.Authorization = `Bearer ${accessToken.trim()}`;
+  }
+  return headers;
+}
+
+async function publicAuthRequest<T>(
+  ctx: PublicAuthContext,
+  path: string,
+  body?: unknown,
+  accessToken?: string,
+): Promise<T> {
+  const url = `${trimSlash(ctx.gatewayUrl)}/v1/public/auth${path}`;
+  const res = await fetch(url, {
+    method: "POST",
+    headers: authHeaders(ctx, accessToken),
+    body: body === undefined ? undefined : JSON.stringify(body),
+  });
+  const text = await res.text();
+  if (!res.ok) {
+    throw new LeisureSaasHttpError(res.status, text.trim());
+  }
+  if (!text) {
+    return {} as T;
+  }
+  return JSON.parse(text) as T;
+}
+
+function tokensFromJSON(data: TokenJSON): ProductAuthTokens {
+  const accessToken = data.access_token?.trim() ?? "";
+  if (!accessToken) {
+    throw new LeisureSaasHttpError(502, "missing access_token");
+  }
+  return {
+    accessToken,
+    refreshToken: data.refresh_token?.trim() ?? "",
+    accessExpiresAtUnix: data.access_expires_at_unix ?? 0,
+    refreshExpiresAtUnix: data.refresh_expires_at_unix ?? 0,
+    userId: data.user_id?.trim() ?? "",
+    tenantId: data.tenant_id?.trim() ?? "",
+  };
+}
+
+export async function registerProductAccount(
+  ctx: PublicAuthContext,
+  input: { email: string; password: string; name?: string; locale?: string },
+): Promise<{ verificationRequired: boolean }> {
+  const resp = await publicAuthRequest<{ verification_required?: boolean }>(ctx, "/register", {
+    email: input.email, password: input.password, name: input.name ?? "", locale: input.locale ?? "",
+  });
+  return { verificationRequired: resp.verification_required !== false };
+}
+
+export async function loginProductAccount(
+  ctx: PublicAuthContext,
+  input: { email: string; password: string; locale?: string },
+): Promise<ProductAuthTokens> {
+  const resp = await publicAuthRequest<TokenJSON>(ctx, "/login", {
+    email: input.email, password: input.password, locale: input.locale ?? "",
+  });
+  return tokensFromJSON(resp);
+}
+
+export async function refreshProductSession(ctx: PublicAuthContext, refreshToken: string): Promise<ProductAuthTokens> {
+  const resp = await publicAuthRequest<TokenJSON>(ctx, "/refresh", { refresh_token: refreshToken });
+  return tokensFromJSON(resp);
+}
+
+export async function requestProductPasswordReset(
+  ctx: PublicAuthContext,
+  input: { email: string; locale?: string },
+): Promise<void> {
+  await publicAuthRequest(ctx, "/password-reset", { email: input.email, locale: input.locale ?? "" });
+}
+
+export async function requestProductEmailVerification(
+  ctx: PublicAuthContext,
+  input: { email: string; locale?: string },
+): Promise<void> {
+  await publicAuthRequest(ctx, "/email-verification", { email: input.email, locale: input.locale ?? "" });
+}
+
+export async function changeProductPassword(
+  ctx: PublicAuthContext,
+  accessToken: string,
+  input: { currentPassword: string; newPassword: string },
+): Promise<void> {
+  await publicAuthRequest(ctx, "/password", {
+    current_password: input.currentPassword, new_password: input.newPassword,
+  }, accessToken);
+}
+
+export async function logoutProductAccount(
+  ctx: PublicAuthContext,
+  accessToken: string,
+  refreshToken?: string,
+): Promise<void> {
+  await publicAuthRequest(ctx, "/logout", { refresh_token: refreshToken ?? "" }, accessToken);
+}
+
+export async function deleteProductAccount(ctx: PublicAuthContext, accessToken: string): Promise<void> {
+  await publicAuthRequest(ctx, "/account/delete", {}, accessToken);
+}
+
+export async function startPlatformAuthorize(
+  ctx: PublicAuthContext,
+  input: { redirectUri: string; codeChallenge: string; state?: string },
+): Promise<string> {
+  const resp = await publicAuthRequest<{ authorization_url?: string }>(ctx, "/authorize", {
+    redirect_uri: input.redirectUri,
+    code_challenge: input.codeChallenge,
+    state: input.state ?? "",
+  });
+  const url = resp.authorization_url?.trim() ?? "";
+  if (!url) {
+    throw new LeisureSaasHttpError(502, "missing authorization_url");
+  }
+  return url;
+}
+
+export async function bindPlatformAccount(
+  ctx: PublicAuthContext,
+  accessToken: string,
+  input: { code: string; codeVerifier: string; redirectUri: string },
+): Promise<void> {
+  await publicAuthRequest(ctx, "/bind", {
+    code: input.code, code_verifier: input.codeVerifier, redirect_uri: input.redirectUri,
+  }, accessToken);
+}
+
+export async function unbindPlatformAccount(ctx: PublicAuthContext, accessToken: string): Promise<void> {
+  await publicAuthRequest(ctx, "/unbind", {}, accessToken);
+}

package/src/drive-types.ts

@@ -0,0 +1,49 @@
+export type FsNode = {
+  id: string;
+  product_id: string;
+  tenant_id: string;
+  owner_subject: string;
+  parent_id: string;
+  name: string;
+  kind: "folder" | "file" | string;
+  object_id: string;
+  content_type: string;
+  size: number;
+  status: "uploading" | "active" | string;
+  created_at_unix: number;
+  updated_at_unix: number;
+};
+
+export type FsUploadSessionResult = {
+  node: FsNode;
+  upload_url: string;
+  upload_headers?: Record<string, string>;
+  expires_unix: number;
+  expires_at: string;
+};
+
+export type FsContentURLResult = {
+  signed_url: string;
+  expires_unix: number;
+  expires_at: string;
+  intent: string;
+};
+
+export type FsContentURLIntent = "preview" | "download" | "";
+
+export type UploadProgress = {
+  loaded: number;
+  total: number;
+  ratio: number;
+  phase?: "put" | "storing" | "finishing" | "done";
+};
+
+export type FsStorageUsage = {
+  product_id: string;
+  tenant_id: string;
+  metric_key: string;
+  bytes_used: number;
+  objects_used: number;
+  bytes_limit: number;
+  bytes_remaining: number | null;
+};

package/src/drive.ts

@@ -0,0 +1,258 @@
+import { LeisureSaasHttpError } from "./errors";
+import { applyPublishableKeyHeaders } from "./publishable-key";
+import type {
+  FsContentURLIntent,
+  FsContentURLResult,
+  FsNode,
+  FsStorageUsage,
+  FsUploadSessionResult,
+  UploadProgress,
+} from "./drive-types";
+
+export type {
+  FsContentURLIntent,
+  FsContentURLResult,
+  FsNode,
+  FsStorageUsage,
+  FsUploadSessionResult,
+  UploadProgress,
+} from "./drive-types";
+
+export const DRIVE_UPLOAD_MAX_AUTO_PUT_BYTES = 20 * 1024 * 1024;
+
+export type DriveRequestContext = {
+  gatewayUrl: string;
+  publishableKey: string;
+  accessToken: string;
+  origin: string;
+};
+
+export type UploadProgressHandler = (progress: UploadProgress) => void;
+
+function trimSlash(url: string): string {
+  return url.replace(/\/$/, "");
+}
+
+function driveHeaders(ctx: DriveRequestContext): Record<string, string> {
+  const token = ctx.accessToken.trim();
+  if (!token) {
+    throw new LeisureSaasHttpError(401, "accessToken is required for Drive User Plane");
+  }
+  const headers: Record<string, string> = {
+    Accept: "application/json",
+    Authorization: `Bearer ${token}`,
+    "X-Client-Platform": "web",
+  };
+  applyPublishableKeyHeaders(headers, ctx.publishableKey);
+  if (ctx.origin.trim()) {
+    headers.Origin = ctx.origin.trim();
+  }
+  return headers;
+}
+
+async function driveRequest<T>(
+  ctx: DriveRequestContext,
+  method: "GET" | "POST" | "PATCH" | "DELETE",
+  path: string,
+  body?: unknown,
+): Promise<T> {
+  const base = `${trimSlash(ctx.gatewayUrl)}/v1/user/storage`;
+  const url = `${base}${path.startsWith("/") ? path : `/${path}`}`;
+  const headers = driveHeaders(ctx);
+  let payload: string | undefined;
+  if (body !== undefined) {
+    headers["Content-Type"] = "application/json";
+    payload = JSON.stringify(body);
+  }
+  const res = await fetch(url, { method, headers, body: payload });
+  const text = await res.text();
+  if (!res.ok) {
+    throw new LeisureSaasHttpError(res.status, text.trim());
+  }
+  if (res.status === 204 || !text) {
+    return {} as T;
+  }
+  return JSON.parse(text) as T;
+}
+
+export async function listFsNodes(ctx: DriveRequestContext, parentId = ""): Promise<FsNode[]> {
+  const q = parentId.trim() ? `?parent_id=${encodeURIComponent(parentId.trim())}` : "";
+  const resp = await driveRequest<{ nodes?: FsNode[] }>(ctx, "GET", `/fs/nodes${q}`);
+  return resp.nodes ?? [];
+}
+
+export async function getFsStorageUsage(ctx: DriveRequestContext): Promise<FsStorageUsage> {
+  return driveRequest<FsStorageUsage>(ctx, "GET", "/usage");
+}
+
+export async function getFsNode(ctx: DriveRequestContext, id: string): Promise<FsNode> {
+  const nodeId = id.trim();
+  if (!nodeId) throw new LeisureSaasHttpError(400, "id is required");
+  return driveRequest<FsNode>(ctx, "GET", `/fs/nodes/${encodeURIComponent(nodeId)}`);
+}
+
+export async function createFsFolder(
+  ctx: DriveRequestContext,
+  input: { name: string; parentId?: string },
+): Promise<FsNode> {
+  const body: Record<string, string> = { name: input.name };
+  if (input.parentId?.trim()) body.parent_id = input.parentId.trim();
+  return driveRequest<FsNode>(ctx, "POST", "/fs/folders", body);
+}
+
+export async function renameFsNode(ctx: DriveRequestContext, id: string, name: string): Promise<FsNode> {
+  const nodeId = id.trim();
+  if (!nodeId) throw new LeisureSaasHttpError(400, "id is required");
+  return driveRequest<FsNode>(ctx, "PATCH", `/fs/nodes/${encodeURIComponent(nodeId)}`, { name });
+}
+
+export async function moveFsNode(ctx: DriveRequestContext, id: string, parentId = ""): Promise<FsNode> {
+  const nodeId = id.trim();
+  if (!nodeId) throw new LeisureSaasHttpError(400, "id is required");
+  const body: Record<string, string> = {};
+  if (parentId.trim()) body.parent_id = parentId.trim();
+  return driveRequest<FsNode>(ctx, "POST", `/fs/nodes/${encodeURIComponent(nodeId)}/move`, body);
+}
+
+export async function deleteFsNode(ctx: DriveRequestContext, id: string, recursive = false): Promise<void> {
+  const nodeId = id.trim();
+  if (!nodeId) throw new LeisureSaasHttpError(400, "id is required");
+  let path = `/fs/nodes/${encodeURIComponent(nodeId)}`;
+  if (recursive) path += "?recursive=true";
+  await driveRequest(ctx, "DELETE", path);
+}
+
+export async function createFsUploadSession(
+  ctx: DriveRequestContext,
+  input: { name: string; contentType: string; size: number; parentId?: string },
+): Promise<FsUploadSessionResult> {
+  const body: Record<string, unknown> = {
+    name: input.name,
+    content_type: input.contentType,
+    size: input.size,
+  };
+  if (input.parentId?.trim()) body.parent_id = input.parentId.trim();
+  return driveRequest<FsUploadSessionResult>(ctx, "POST", "/fs/files/upload-session", body);
+}
+
+export async function finishFsUploadSession(ctx: DriveRequestContext, nodeId: string): Promise<FsNode> {
+  const id = nodeId.trim();
+  if (!id) throw new LeisureSaasHttpError(400, "node id is required");
+  return driveRequest<FsNode>(ctx, "POST", `/fs/files/upload-session/${encodeURIComponent(id)}/finish`, {});
+}
+
+export async function createFsContentURL(
+  ctx: DriveRequestContext,
+  id: string,
+  input?: { intent?: FsContentURLIntent; ttlSeconds?: number },
+): Promise<FsContentURLResult> {
+  const nodeId = id.trim();
+  if (!nodeId) throw new LeisureSaasHttpError(400, "id is required");
+  const body: Record<string, unknown> = {};
+  if (input?.intent) body.intent = input.intent;
+  if (input?.ttlSeconds && input.ttlSeconds > 0) body.ttl_seconds = input.ttlSeconds;
+  return driveRequest<FsContentURLResult>(ctx, "POST", `/fs/nodes/${encodeURIComponent(nodeId)}/content-url`, body);
+}
+
+function asUploadBody(body: ArrayBuffer | Blob | Uint8Array): BodyInit {
+  if (body instanceof Uint8Array) return body as unknown as BodyInit;
+  if (typeof ArrayBuffer !== "undefined" && body instanceof ArrayBuffer) {
+    return new Uint8Array(body) as unknown as BodyInit;
+  }
+  return body as BodyInit;
+}
+
+export async function putFsUploadURL(
+  uploadURL: string,
+  uploadHeaders: Record<string, string> | undefined,
+  contentType: string,
+  body: ArrayBuffer | Blob | Uint8Array,
+  opts?: { size?: number; onProgress?: UploadProgressHandler },
+): Promise<void> {
+  const headers: Record<string, string> = { ...(uploadHeaders ?? {}) };
+  if (!headers["Content-Type"] && !headers["content-type"] && contentType) {
+    headers["Content-Type"] = contentType;
+  }
+  let total = opts?.size ?? 0;
+  if (total <= 0) {
+    if (typeof Blob !== "undefined" && body instanceof Blob) total = body.size;
+    else if (body instanceof Uint8Array) total = body.byteLength;
+    else if (typeof ArrayBuffer !== "undefined" && body instanceof ArrayBuffer) total = body.byteLength;
+  }
+
+  const report = (loaded: number, phase: UploadProgress["phase"]) => {
+    if (!opts?.onProgress) return;
+    const t = total > 0 ? total : 0;
+    const ratio = t > 0 ? Math.min(1, Math.max(0, loaded / t)) : 0;
+    opts.onProgress({ loaded, total: t, ratio, phase });
+  };
+
+  if (opts?.onProgress && typeof XMLHttpRequest !== "undefined") {
+    await new Promise<void>((resolve, reject) => {
+      const xhr = new XMLHttpRequest();
+      xhr.open("PUT", uploadURL);
+      for (const [k, v] of Object.entries(headers)) {
+        if (v) xhr.setRequestHeader(k, v);
+      }
+      xhr.upload.onprogress = (ev) => report(ev.loaded, "put");
+      xhr.upload.onload = () => report(total > 0 ? total : 1, "storing");
+      xhr.onload = () => {
+        if (xhr.status >= 200 && xhr.status < 300) {
+          report(total > 0 ? total : 1, "storing");
+          resolve();
+          return;
+        }
+        reject(new LeisureSaasHttpError(xhr.status, (xhr.responseText || "upload PUT failed").trim()));
+      };
+      xhr.onerror = () => reject(new LeisureSaasHttpError(0, "upload PUT network error"));
+      xhr.onabort = () => reject(new LeisureSaasHttpError(0, "upload PUT aborted"));
+      report(0, "put");
+      xhr.send(asUploadBody(body) as XMLHttpRequestBodyInit);
+    });
+    return;
+  }
+
+  report(0, "put");
+  const res = await fetch(uploadURL, { method: "PUT", headers, body: asUploadBody(body), redirect: "manual" });
+  if (res.type === "opaqueredirect" || (res.status >= 300 && res.status < 400)) {
+    throw new LeisureSaasHttpError(res.status || 0, "upload PUT redirected");
+  }
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new LeisureSaasHttpError(res.status, text.trim() || "upload PUT failed");
+  }
+  report(total > 0 ? total : 1, "storing");
+}
+
+export async function uploadFsFile(
+  ctx: DriveRequestContext,
+  input: {
+    name: string;
+    contentType: string;
+    size: number;
+    body: ArrayBuffer | Blob | Uint8Array;
+    parentId?: string;
+    onProgress?: UploadProgressHandler;
+  },
+): Promise<FsNode> {
+  if (input.size <= 0) {
+    throw new LeisureSaasHttpError(400, "size must be positive");
+  }
+  if (input.size > DRIVE_UPLOAD_MAX_AUTO_PUT_BYTES) {
+    throw new LeisureSaasHttpError(400, `body exceeds max auto-PUT size (${DRIVE_UPLOAD_MAX_AUTO_PUT_BYTES} bytes)`);
+  }
+  const sess = await createFsUploadSession(ctx, {
+    name: input.name,
+    contentType: input.contentType,
+    size: input.size,
+    parentId: input.parentId,
+  });
+  await putFsUploadURL(sess.upload_url, sess.upload_headers, input.contentType, input.body, {
+    size: input.size,
+    onProgress: input.onProgress,
+  });
+  input.onProgress?.({ loaded: input.size, total: input.size, ratio: 1, phase: "finishing" });
+  const node = await finishFsUploadSession(ctx, sess.node.id);
+  input.onProgress?.({ loaded: input.size, total: input.size, ratio: 1, phase: "done" });
+  return node;
+}

package/src/errors.ts

@@ -0,0 +1,11 @@
+export class LeisureSaasHttpError extends Error {
+  readonly statusCode: number;
+  readonly body: string;
+
+  constructor(statusCode: number, body: string) {
+    super(body || `HTTP ${statusCode}`);
+    this.name = "LeisureSaasHttpError";
+    this.statusCode = statusCode;
+    this.body = body;
+  }
+}

package/src/gateway-url.ts

@@ -0,0 +1,6 @@
+/**
+ * Platform API base for Public Ads / App Config / Auth (not a Hosted UI login host).
+ */
+export function resolveGatewayUrlFromEnv(env: Record<string, string | undefined> = process.env): string {
+  return env.NEXT_PUBLIC_GATEWAY_URL?.trim() || "";
+}