@palbase/web 1.0.0

package/dist/react/index.cjs

@@ -0,0 +1,649 @@
+"use strict";
+"use client";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/react/index.tsx
+var react_exports = {};
+__export(react_exports, {
+  useChannel: () => useChannel,
+  useFlag: () => useFlag,
+  useFlags: () => useFlags,
+  useSession: () => useSession,
+  useUser: () => useUser
+});
+module.exports = __toCommonJS(react_exports);
+var import_react = require("react");
+
+// ../core/dist/index.js
+var CACHE_TTL_MS = 5 * 60 * 1e3;
+var PalbaseError = class extends Error {
+  code;
+  status;
+  details;
+  constructor(code, message, status, details) {
+    super(message);
+    this.name = "PalbaseError";
+    this.code = code;
+    this.status = status;
+    this.details = details;
+  }
+};
+
+// src/errors.ts
+var BackendError = class _BackendError extends Error {
+  kind;
+  code;
+  status;
+  requestId;
+  fields;
+  retryAfter;
+  data;
+  constructor(kind, params) {
+    super(params.message);
+    this.name = "BackendError";
+    this.kind = kind;
+    this.code = params.code;
+    this.status = params.status ?? 0;
+    this.requestId = params.requestId;
+    this.fields = params.fields;
+    this.retryAfter = params.retryAfter;
+    this.data = params.data;
+  }
+  static notConfigured() {
+    return new _BackendError("notConfigured", {
+      code: "not_configured",
+      message: "Palbe is not configured. Run 'palbase web link' in your project and make sure palbe.gen.ts is imported once at app startup."
+    });
+  }
+};
+function isFieldErrorArray(value) {
+  return Array.isArray(value) && value.length > 0 && value.every(
+    (v) => typeof v === "object" && v !== null && typeof v.field === "string" && typeof v.message === "string"
+  );
+}
+function pickField(value, key) {
+  if (typeof value === "object" && value !== null) {
+    return value[key];
+  }
+  return void 0;
+}
+function pickNumber(value, key) {
+  const n = pickField(value, key);
+  return typeof n === "number" ? n : void 0;
+}
+function pickString(value, key) {
+  const s = pickField(value, key);
+  return typeof s === "string" ? s : void 0;
+}
+function fromPalbaseError(err) {
+  const base = {
+    code: err.code,
+    message: err.message,
+    status: err.status,
+    requestId: pickString(err.details, "request_id"),
+    data: pickField(err.details, "data")
+  };
+  if (err.code === "network_error") return new BackendError("network", base);
+  if (err.status === 401) return new BackendError("unauthorized", base);
+  if (err.status === 429)
+    return new BackendError("rateLimited", {
+      ...base,
+      retryAfter: pickNumber(err.details, "retry_after")
+    });
+  const nested = pickField(err.details, "details");
+  if (err.status === 400 && isFieldErrorArray(nested))
+    return new BackendError("validation", { ...base, fields: nested });
+  return new BackendError("server", base);
+}
+function fromEnvelope(status, body) {
+  const code = pickString(body, "error") ?? "http_error";
+  const message = pickString(body, "error_description") ?? `HTTP ${status}`;
+  const requestId = pickString(body, "request_id");
+  const details = pickField(body, "details");
+  const params = {
+    code,
+    message,
+    status,
+    requestId,
+    data: pickField(body, "data")
+  };
+  if (status === 401) return new BackendError("unauthorized", params);
+  if (status === 429)
+    return new BackendError("rateLimited", {
+      ...params,
+      // Real 429 wire body has TOP-LEVEL retry_after; nested details is a fallback.
+      retryAfter: pickNumber(body, "retry_after") ?? pickNumber(details, "retry_after")
+    });
+  if (status === 400 && isFieldErrorArray(details))
+    return new BackendError("validation", { ...params, fields: details });
+  return new BackendError("server", params);
+}
+function isBackendError(e) {
+  return e instanceof BackendError || typeof e === "object" && e !== null && e.name === "BackendError" && typeof e.kind === "string";
+}
+function asPalbaseError(e) {
+  if (e instanceof PalbaseError) return e;
+  if (e instanceof Error && e.name === "PalbaseError") return e;
+  return null;
+}
+function unwrap(res) {
+  if (res.error) throw fromPalbaseError(res.error);
+  return res.data;
+}
+
+// src/request.ts
+var MUTATING = /* @__PURE__ */ new Set(["POST", "PUT", "PATCH", "DELETE"]);
+async function palbeRequest(rt, method, path, spec = {}) {
+  const headers = { ...spec.headers };
+  const callerHasKey = Object.keys(headers).some((k) => k.toLowerCase() === "idempotency-key");
+  if (MUTATING.has(method) && !callerHasKey) {
+    headers["Idempotency-Key"] = crypto.randomUUID();
+  }
+  const attempt = async () => {
+    try {
+      return await rt.http.request(method, path, {
+        body: spec.body,
+        headers,
+        signal: spec.signal
+      });
+    } catch (e) {
+      const pe = asPalbaseError(e);
+      throw pe ? fromPalbaseError(pe) : e;
+    }
+  };
+  let res = await attempt();
+  if (res.error?.status === 401 && rt.tokenManager.getRefreshToken() && rt.tokenManager.refreshFunction) {
+    try {
+      await rt.tokenManager.refreshSession();
+    } catch (refreshErr) {
+      const pe = asPalbaseError(refreshErr);
+      const status = pe?.status ?? 0;
+      if (status === 400 || status === 401 || status === 403) {
+        rt.tokenManager.clearSession();
+        throw fromPalbaseError(res.error);
+      }
+      throw pe ? fromPalbaseError(pe) : refreshErr;
+    }
+    res = await attempt();
+  }
+  return unwrap(res);
+}
+
+// src/state.ts
+var STATE_KEY = /* @__PURE__ */ Symbol.for("palbe.state.v1");
+function palbeState() {
+  const g = globalThis;
+  let state = g[STATE_KEY];
+  if (!state) {
+    state = { runtime: null, registry: {}, nsCache: {}, configuredListeners: /* @__PURE__ */ new Set() };
+    g[STATE_KEY] = state;
+  }
+  return state;
+}
+
+// src/namespaces.ts
+function isDescriptor(node) {
+  return typeof node.path === "string" && typeof node.method === "string";
+}
+function getRegistry() {
+  return palbeState().registry;
+}
+function serializeQuery(input) {
+  if (input === void 0 || input === null) return "";
+  const entries = Object.entries(input).filter(([, v]) => v !== void 0 && v !== null).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
+  if (entries.length === 0) return "";
+  const parts = entries.map(([k, v]) => {
+    if (typeof v !== "string" && typeof v !== "number" && typeof v !== "boolean") {
+      throw new BackendError("validation", {
+        code: "invalid_query_value",
+        message: `Query parameter '${k}' must be a string, number, or boolean.`
+      });
+    }
+    return `${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`;
+  });
+  return `?${parts.join("&")}`;
+}
+async function invokeDescriptor(rt, d, args) {
+  const params = d.pathParams ?? [];
+  let path = d.path;
+  for (let i = 0; i < params.length; i++) {
+    const v = args[i];
+    if (typeof v !== "string" && typeof v !== "number") {
+      throw new BackendError("validation", {
+        code: "missing_path_param",
+        message: `${d.path}: path parameter '${params[i]}' must be a string or number`
+      });
+    }
+    path = path.replace(`{${params[i]}}`, encodeURIComponent(String(v)));
+  }
+  if (d.input === "none" && args.length > params.length + 1) {
+    throw new BackendError("validation", {
+      code: "unexpected_argument",
+      message: `${d.path}: endpoint takes no input \u2014 pass only path params and options`
+    });
+  }
+  const input = d.input === "none" ? void 0 : args[params.length];
+  const optionsSlot = d.input === "none" ? params.length : params.length + 1;
+  const options = args[optionsSlot];
+  let body;
+  if (d.input === "query") {
+    path += serializeQuery(input);
+  } else if (d.input !== "none") {
+    if (d.method === "GET") {
+      if (input !== void 0) {
+        throw new BackendError("validation", {
+          code: "unsupported_get_input",
+          message: `${d.path}: GET endpoints take no body input`
+        });
+      }
+    } else {
+      body = input;
+    }
+  }
+  try {
+    return await palbeRequest(rt, d.method, path, {
+      body,
+      headers: options?.headers,
+      signal: options?.signal
+    });
+  } catch (e) {
+    if (d.errors && isBackendError(e)) {
+      const lift = d.errors[e.code];
+      if (lift) throw lift(e);
+    }
+    throw e;
+  }
+}
+function materialize(node, resolveRt) {
+  if (isDescriptor(node)) {
+    return async (...args) => invokeDescriptor(resolveRt(), node, args);
+  }
+  const out = {};
+  for (const [key, child] of Object.entries(node)) {
+    out[key] = materialize(child, resolveRt);
+  }
+  return out;
+}
+function getNamespace(name) {
+  const state = palbeState();
+  const cached = state.nsCache[name];
+  if (cached !== void 0) return cached;
+  const node = state.registry[name];
+  if (node === void 0) return void 0;
+  const ns = materialize(node, getRuntime);
+  state.nsCache[name] = ns;
+  return ns;
+}
+
+// src/version.ts
+var VERSION = "1.0.0";
+
+// src/call.ts
+async function callEndpoint(resolveRt, name, input, options) {
+  if (!name || name === "/") {
+    throw new BackendError("validation", {
+      code: "invalid_endpoint_name",
+      message: 'Endpoint name must be a non-empty path like "todos/create"'
+    });
+  }
+  const rt = resolveRt();
+  const path = name.startsWith("/") ? name : `/${name}`;
+  return palbeRequest(rt, "POST", path, {
+    body: input,
+    headers: options?.headers,
+    signal: options?.signal
+  });
+}
+
+// src/upload.ts
+function abortError() {
+  return new BackendError("network", { code: "aborted", message: "Upload aborted" });
+}
+function checkConstraints(options) {
+  const c = options.constraints;
+  if (!c) return;
+  if (c.maxSize !== void 0 && options.file.size > c.maxSize) {
+    const message = `File size ${options.file.size} exceeds max ${c.maxSize} bytes`;
+    throw new BackendError("validation", {
+      code: "file_too_large",
+      message,
+      fields: [{ field: "file", message }]
+    });
+  }
+  const effType = options.contentType ?? options.file.type;
+  if (c.allowedTypes && c.allowedTypes.length > 0 && !c.allowedTypes.includes(effType)) {
+    const message = `File type '${effType}' is not allowed`;
+    throw new BackendError("validation", {
+      code: "file_type_not_allowed",
+      message,
+      fields: [{ field: "file", message }]
+    });
+  }
+}
+async function buildHeaders(rt, extra) {
+  if (rt.tokenManager.isExpired() && rt.tokenManager.getRefreshToken() && rt.tokenManager.refreshFunction) {
+    try {
+      await rt.tokenManager.refreshSession();
+    } catch (e) {
+      const pe = asPalbaseError(e);
+      const status = pe?.status ?? 0;
+      if (status === 400 || status === 401 || status === 403) {
+        rt.tokenManager.clearSession();
+      } else {
+        throw pe ? fromPalbaseError(pe) : e;
+      }
+    }
+  }
+  const headers = {
+    apikey: rt.config.apiKey,
+    "X-Client-Info": `palbe-web/${VERSION}`,
+    ...rt.config.headers
+  };
+  const token = rt.tokenManager.getAccessToken();
+  if (token) headers.Authorization = `Bearer ${token}`;
+  const callerHasKey = Object.keys(extra ?? {}).some((k) => k.toLowerCase() === "idempotency-key");
+  if (!callerHasKey) headers["Idempotency-Key"] = crypto.randomUUID();
+  return { ...headers, ...extra };
+}
+function buildForm(options) {
+  const form = new FormData();
+  for (const [k, v] of Object.entries(options.fields ?? {})) form.append(k, v);
+  const file = options.contentType && options.file.type !== options.contentType ? new Blob([options.file], { type: options.contentType }) : options.file;
+  const filename = options.filename ?? (typeof File !== "undefined" && options.file instanceof File ? options.file.name : "file");
+  form.append("file", file, filename);
+  return form;
+}
+function decode(status, text) {
+  let body;
+  try {
+    body = text === "" ? null : JSON.parse(text);
+  } catch {
+    if (status >= 200 && status < 300) {
+      throw new BackendError("decode", {
+        code: "decode_error",
+        message: "Invalid JSON in response",
+        status
+      });
+    }
+    body = text;
+  }
+  if (status < 200 || status >= 300) throw fromEnvelope(status, body);
+  return body;
+}
+function uploadViaXHR(url, form, headers, options) {
+  return new Promise((resolve, reject) => {
+    if (options.signal?.aborted) {
+      reject(abortError());
+      return;
+    }
+    const xhr = new XMLHttpRequest();
+    xhr.open("POST", url);
+    for (const [k, v] of Object.entries(headers)) xhr.setRequestHeader(k, v);
+    xhr.upload.onprogress = (e) => {
+      if (!e.lengthComputable) return;
+      options.onProgress?.({ sent: e.loaded, total: e.total });
+    };
+    const onAbort = () => xhr.abort();
+    const cleanup = () => options.signal?.removeEventListener("abort", onAbort);
+    xhr.onload = () => {
+      cleanup();
+      try {
+        resolve(decode(xhr.status, xhr.responseText));
+      } catch (err) {
+        reject(err);
+      }
+    };
+    xhr.onerror = () => {
+      cleanup();
+      reject(new BackendError("network", { code: "network_error", message: "Upload failed" }));
+    };
+    xhr.onabort = () => {
+      cleanup();
+      reject(abortError());
+    };
+    options.signal?.addEventListener("abort", onAbort, { once: true });
+    xhr.send(form);
+  });
+}
+async function uploadViaFetch(url, form, headers, options) {
+  let res;
+  try {
+    res = await fetch(url, { method: "POST", body: form, headers, signal: options.signal });
+  } catch (e) {
+    if (e instanceof Error && e.name === "AbortError") throw abortError();
+    throw new BackendError("network", {
+      code: "network_error",
+      message: e instanceof Error ? e.message : "Upload failed"
+    });
+  }
+  return decode(res.status, await res.text());
+}
+async function uploadEndpoint(resolveRt, name, options) {
+  const rt = resolveRt();
+  checkConstraints(options);
+  const path = name.startsWith("/") ? name : `/${name}`;
+  const url = `${rt.config.url}${path}`;
+  const headers = await buildHeaders(rt, options.headers);
+  const form = buildForm(options);
+  const useXHR = options.onProgress !== void 0 && typeof XMLHttpRequest !== "undefined";
+  return useXHR ? uploadViaXHR(url, form, headers, options) : uploadViaFetch(url, form, headers, options);
+}
+
+// src/pb.ts
+function createClientProxy(resolveRt, nsAccessor) {
+  const base = {
+    call(name, input, options) {
+      return callEndpoint(resolveRt, name, input, options);
+    },
+    upload(name, options) {
+      return uploadEndpoint(resolveRt, name, options);
+    },
+    get auth() {
+      return resolveRt().auth;
+    },
+    get flags() {
+      return resolveRt().flags;
+    },
+    get realtime() {
+      return resolveRt().realtime;
+    },
+    get analytics() {
+      return resolveRt().analytics;
+    }
+  };
+  return new Proxy(base, {
+    get(target, prop, receiver) {
+      if (prop in target) return Reflect.get(target, prop, receiver);
+      if (prop === "then") return void 0;
+      if (typeof prop === "string") {
+        const ns = nsAccessor(prop);
+        if (ns !== void 0) return ns;
+      }
+      return void 0;
+    },
+    has(target, prop) {
+      if (prop in target) return true;
+      return typeof prop === "string" && prop !== "then" && getRegistry()[prop] !== void 0;
+    }
+  });
+}
+var pb = createClientProxy(getRuntime, getNamespace);
+
+// src/internal.ts
+function onConfigured(cb) {
+  const state = palbeState();
+  state.configuredListeners.add(cb);
+  return () => state.configuredListeners.delete(cb);
+}
+function getRuntime() {
+  const rt = palbeState().runtime;
+  if (!rt) throw BackendError.notConfigured();
+  return rt;
+}
+
+// src/react/index.tsx
+var EMPTY_FLAGS = Object.freeze({});
+var SIGNED_OUT = Object.freeze({ signedIn: false, user: null });
+function subscribeWithConfig(getFacadeListener) {
+  return (onStoreChange) => {
+    let currentFacadeUnsub = null;
+    function attachFacade() {
+      currentFacadeUnsub?.();
+      try {
+        currentFacadeUnsub = getFacadeListener(onStoreChange);
+      } catch {
+        currentFacadeUnsub = null;
+      }
+    }
+    const offConfigured = onConfigured(() => {
+      attachFacade();
+      onStoreChange();
+    });
+    attachFacade();
+    return () => {
+      offConfigured();
+      currentFacadeUnsub?.();
+      currentFacadeUnsub = null;
+    };
+  };
+}
+function useUser() {
+  return (0, import_react.useSyncExternalStore)(subscribeUserWithConfig, getUserSnapshot, getNullUser);
+}
+var subscribeUserWithConfig = subscribeWithConfig((onStoreChange) => {
+  const offState = pb.auth.onAuthStateChange(onStoreChange);
+  const offUser = pb.auth.onUserChange(onStoreChange);
+  return () => {
+    offState();
+    offUser();
+  };
+});
+function getUserSnapshot() {
+  try {
+    return pb.auth.currentUser;
+  } catch {
+    return null;
+  }
+}
+function getNullUser() {
+  return null;
+}
+function useSession() {
+  const lastRef = (0, import_react.useRef)(SIGNED_OUT);
+  const getSnapshot = (0, import_react.useCallback)(() => {
+    const next = readSession();
+    const prev = lastRef.current;
+    if (prev.signedIn === next.signedIn && prev.user === next.user) {
+      return prev;
+    }
+    lastRef.current = next;
+    return next;
+  }, []);
+  return (0, import_react.useSyncExternalStore)(subscribeSessionWithConfig, getSnapshot, getSignedOut);
+}
+var subscribeSessionWithConfig = subscribeWithConfig(
+  (onStoreChange) => pb.auth.onAuthStateChange(onStoreChange)
+);
+function readSession() {
+  try {
+    const user = pb.auth.currentUser;
+    const signedIn = pb.auth.isSignedIn;
+    if (!signedIn && user === null) return SIGNED_OUT;
+    return { signedIn, user };
+  } catch {
+    return SIGNED_OUT;
+  }
+}
+function getSignedOut() {
+  return SIGNED_OUT;
+}
+function useFlag(key, fallback) {
+  const subscribe = (0, import_react.useCallback)(
+    subscribeWithConfig((onStoreChange) => pb.flags.subscribeKey(key, onStoreChange)),
+    [key]
+  );
+  const lastRef = (0, import_react.useRef)(fallback);
+  const getSnapshot = (0, import_react.useCallback)(() => {
+    let next;
+    try {
+      const value = pb.flags.get(key);
+      next = value === void 0 ? fallback : value;
+    } catch {
+      next = fallback;
+    }
+    if (!Object.is(next, lastRef.current)) {
+      lastRef.current = next;
+    }
+    return lastRef.current;
+  }, [key, fallback]);
+  return (0, import_react.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
+}
+function useFlags() {
+  return (0, import_react.useSyncExternalStore)(subscribeFlagsWithConfig, getFlagsSnapshot, getEmptyFlags);
+}
+var subscribeFlagsWithConfig = subscribeWithConfig(
+  (onStoreChange) => pb.flags.onChange(onStoreChange)
+);
+function getFlagsSnapshot() {
+  try {
+    return pb.flags.all();
+  } catch {
+    return EMPTY_FLAGS;
+  }
+}
+function getEmptyFlags() {
+  return EMPTY_FLAGS;
+}
+function useChannel(name, event, handler) {
+  const handlerRef = (0, import_react.useRef)(handler);
+  (0, import_react.useEffect)(() => {
+    handlerRef.current = handler;
+  });
+  const [status, setStatus] = (0, import_react.useState)("idle");
+  const [configEpoch, setConfigEpoch] = (0, import_react.useState)(0);
+  (0, import_react.useEffect)(() => {
+    return onConfigured(() => setConfigEpoch((n) => n + 1));
+  }, []);
+  (0, import_react.useEffect)(() => {
+    let channel;
+    try {
+      channel = pb.realtime.channel(name);
+    } catch {
+      setStatus("unavailable");
+      return;
+    }
+    const sub = channel.on(event, (payload) => handlerRef.current(payload));
+    setStatus(pb.realtime.status.state);
+    const offStatus = pb.realtime.status.onChange((snapshot) => setStatus(snapshot.state));
+    return () => {
+      offStatus();
+      sub.cancel();
+    };
+  }, [name, event, configEpoch]);
+  return { status };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useChannel,
+  useFlag,
+  useFlags,
+  useSession,
+  useUser
+});
+//# sourceMappingURL=index.cjs.map