@singlebase/core 0.1.0

package/dist/index.js

@@ -0,0 +1,604 @@
+class g extends Error {
+  constructor(t, r) {
+    super(t.message), this.name = "SinglebaseError", this.status = t.status, this.type = t.type, this.code = t.message, this.details = t.details, this.traceId = t.trace_id ?? null, this.cause = r;
+  }
+  static fromNetworkError(t) {
+    return new g(
+      {
+        type: "NETWORK_ERROR",
+        status: 0,
+        message: "NETWORK_ERROR"
+      },
+      t
+    );
+  }
+}
+const L = {
+  INVALID_PAYLOAD: "highlight_invalid_fields",
+  INVALID_CREDENTIALS: "generic_credentials_message",
+  CODE_REQUIRED: "reveal_code_input",
+  INVALID_TOKEN: "expired_or_invalid_code_message",
+  INVALID_ID_TOKEN: "attempt_refresh_or_signout",
+  INVALID_BEARER_TOKEN: "attempt_refresh_or_signout",
+  INVALID_SESSION: "clear_session_and_ask_signin",
+  INVALID_TOKEN_AUDIENCE: "clear_session_config_error",
+  REQUIRE_PASSWORD_CHANGE: "route_to_recovery_or_invite",
+  INVALID_PASSWORD: "show_password_requirements",
+  MISSING_PROFILE_DATA: "require_changed_field",
+  AUTH_RATE_LIMITED: "disable_retry_show_rate_limited",
+  AUTH_DISABLED: "render_auth_unavailable",
+  EMAIL_PROVIDER_DISABLED: "hide_email_forms",
+  EMAIL_SIGNUP_DISABLED: "hide_signup",
+  OAUTH_DISABLED: "hide_oauth",
+  OAUTH_SIGNUP_DISABLED: "remove_oauth_from_signup",
+  INVALID_OAUTH_PROVIDER: "refresh_settings_hide_provider",
+  INVALID_NONCE: "restart_oauth_new_nonce",
+  SIGN_IN_TO_LINK_PROVIDER: "ask_signin_then_link",
+  AUTHENTICATION_REQUIRED: "route_to_signin",
+  UNAUTHORIZED_DOMAIN: "show_integrator_config_error"
+};
+function z(e) {
+  return L[e] ?? "unknown";
+}
+function k(e) {
+  return e === "localhost" || e === "127.0.0.1" || e === "0.0.0.0";
+}
+const p = "https://v1.singlebase.io/api";
+function C(e) {
+  if (e.baseUrl === void 0) return p;
+  if (e.baseUrl === null || String(e.baseUrl).trim() === "")
+    throw new Error(
+      `SinglebaseOptions.baseUrl cannot be null or empty. Omit it to use ${p}.`
+    );
+  return String(e.baseUrl).trim().replace(/\/+$/, "");
+}
+function P(e) {
+  var n;
+  const t = C(e);
+  B(t);
+  const r = (n = e.urlAccessKey) == null ? void 0 : n.trim();
+  return r ? `${t}/${encodeURIComponent(r)}` : t;
+}
+function B(e) {
+  let t;
+  try {
+    t = new URL(e);
+  } catch {
+    throw new Error(`SinglebaseOptions.baseUrl is not a valid URL: ${e}`);
+  }
+  if (t.protocol !== "https:" && !k(t.hostname))
+    throw new Error(
+      `SinglebaseOptions.baseUrl must use HTTPS outside of localhost/127.0.0.1/0.0.0.0 (got ${t.protocol})`
+    );
+}
+async function m(e, t, r, n = {}) {
+  const s = P(e), o = { operation: t, payload: r };
+  n.options && (o.options = n.options);
+  const a = {
+    "Content-Type": "application/json",
+    "X-API-Key": e.apiKey
+  };
+  n.token && (a.Authorization = `Bearer ${n.token}`);
+  const i = e.fetch ?? globalThis.fetch;
+  let c;
+  try {
+    c = await i(s, {
+      method: "POST",
+      headers: a,
+      body: JSON.stringify(o),
+      signal: n.signal
+    });
+  } catch (h) {
+    throw g.fromNetworkError(h);
+  }
+  let f;
+  try {
+    f = await c.json();
+  } catch (h) {
+    throw g.fromNetworkError(h);
+  }
+  if ("error" in f)
+    throw new g(f.error);
+  return f.data;
+}
+const j = /* @__PURE__ */ new Set(["INVALID_ID_TOKEN", "INVALID_BEARER_TOKEN"]);
+class X {
+  constructor(t) {
+    this.options = t, this.bridge = null, this.provider = null;
+  }
+  /** Registers the session owner (the auth client) as the token source. */
+  setAuthBridge(t) {
+    this.bridge = t;
+  }
+  /** Registers a factory that builds+hydrates the token source on first need. */
+  setAuthProvider(t) {
+    this.provider = t;
+  }
+  async resolveBridge() {
+    return this.bridge ? this.bridge : this.provider ? (this.bridge = await this.provider(), this.bridge) : null;
+  }
+  /**
+   * Sends one operation. Injects the session bearer unless told otherwise,
+   * and on a stale-token error refreshes once and retries the call exactly
+   * once — never looping.
+   */
+  async dispatch(t, { bearer: r, signal: n } = {}) {
+    const s = r !== void 0, o = s ? null : await this.resolveBridge(), a = s ? r : (o == null ? void 0 : o.getToken()) ?? null, i = { token: a, signal: n, options: t.options };
+    try {
+      return await m(
+        this.options,
+        t.operation,
+        t.payload ?? {},
+        i
+      );
+    } catch (c) {
+      const f = c instanceof g ? c.code : "";
+      if (!(!s && a !== null && o !== null && j.has(f))) throw c;
+      const A = await o.refresh();
+      if (!A) throw c;
+      return m(
+        this.options,
+        t.operation,
+        t.payload ?? {},
+        { ...i, token: A }
+      );
+    }
+  }
+}
+const K = "singlebase-auth", V = 1, l = "session", E = "wrapping-key", d = "session";
+function I() {
+  let e = null;
+  return {
+    get: () => e,
+    set: (t) => {
+      e = t;
+    },
+    clear: () => {
+      e = null;
+    }
+  };
+}
+function R(e, t) {
+  return {
+    get: () => {
+      var n;
+      const r = (n = e()) == null ? void 0 : n.getItem(t);
+      if (!r) return null;
+      try {
+        return JSON.parse(r);
+      } catch {
+        return null;
+      }
+    },
+    set: (r) => {
+      var n;
+      (n = e()) == null || n.setItem(t, JSON.stringify(r));
+    },
+    clear: () => {
+      var r;
+      (r = e()) == null || r.removeItem(t);
+    }
+  };
+}
+function ee(e = "singlebase-auth-session") {
+  return R(() => globalThis.localStorage, e);
+}
+function M(e = "singlebase-auth-session") {
+  return R(() => globalThis.sessionStorage, e);
+}
+function b(e) {
+  return new Promise((t, r) => {
+    e.onsuccess = () => t(e.result), e.onerror = () => r(e.error);
+  });
+}
+function w() {
+  return new Promise((e, t) => {
+    const r = globalThis.indexedDB.open(K, V);
+    r.onupgradeneeded = () => {
+      r.result.objectStoreNames.contains(l) || r.result.createObjectStore(l);
+    }, r.onsuccess = () => e(r.result), r.onerror = () => t(r.error), r.onblocked = () => t(new Error("indexedDB open blocked"));
+  });
+}
+async function S(e) {
+  const t = await w();
+  try {
+    const r = t.transaction(l, "readonly");
+    return await b(r.objectStore(l).get(e));
+  } finally {
+    t.close();
+  }
+}
+async function T(e, t) {
+  const r = await w();
+  try {
+    const n = r.transaction(l, "readwrite");
+    await b(n.objectStore(l).put(t, e));
+  } finally {
+    r.close();
+  }
+}
+async function D(e) {
+  const t = await w();
+  try {
+    const r = t.transaction(l, "readwrite");
+    await b(r.objectStore(l).delete(e));
+  } finally {
+    t.close();
+  }
+}
+function H() {
+  return typeof globalThis.indexedDB < "u" && typeof globalThis.crypto < "u" && typeof globalThis.crypto.subtle < "u";
+}
+function G() {
+  let e = null;
+  async function t() {
+    return e || (e = (async () => {
+      const r = await S(E);
+      if (r) return r;
+      const n = await globalThis.crypto.subtle.generateKey(
+        { name: "AES-GCM", length: 256 },
+        // non-extractable: crypto.subtle can use it, JS can never read it
+        !1,
+        ["encrypt", "decrypt"]
+      );
+      return await T(E, n), n;
+    })().catch((r) => {
+      throw e = null, r;
+    })), e;
+  }
+  return {
+    async get() {
+      const r = await S(d);
+      if (!r) return null;
+      try {
+        const n = await t(), s = await globalThis.crypto.subtle.decrypt(
+          { name: "AES-GCM", iv: r.iv },
+          n,
+          r.data
+        );
+        return JSON.parse(new TextDecoder().decode(s));
+      } catch {
+        return await D(d).catch(() => {
+        }), null;
+      }
+    },
+    async set(r) {
+      const n = await t(), s = globalThis.crypto.getRandomValues(new Uint8Array(12)), o = await globalThis.crypto.subtle.encrypt(
+        { name: "AES-GCM", iv: s },
+        n,
+        new TextEncoder().encode(JSON.stringify(r))
+      );
+      await T(d, { iv: s, data: o });
+    },
+    async clear() {
+      await D(d).catch(() => {
+      });
+    }
+  };
+}
+function te() {
+  let e = null, t = !1;
+  async function r() {
+    if (e) return e;
+    if (!t) {
+      if (t = !0, H()) {
+        const n = G();
+        try {
+          return await n.get(), e = n, e;
+        } catch {
+        }
+      }
+      e = typeof globalThis.sessionStorage < "u" ? M() : I();
+    }
+    return e ?? I();
+  }
+  return {
+    async get() {
+      try {
+        return await (await r()).get();
+      } catch {
+        return null;
+      }
+    },
+    async set(n) {
+      try {
+        await (await r()).set(n);
+      } catch {
+      }
+    },
+    async clear() {
+      try {
+        await (await r()).clear();
+      } catch {
+      }
+    }
+  };
+}
+class re {
+  constructor() {
+    this.listeners = /* @__PURE__ */ new Map();
+  }
+  on(t, r) {
+    let n = this.listeners.get(t);
+    return n || (n = /* @__PURE__ */ new Set(), this.listeners.set(t, n)), n.add(r), () => n.delete(r);
+  }
+  emit(t, r) {
+    const n = this.listeners.get(t);
+    if (n)
+      for (const s of n) s(r);
+  }
+}
+const ne = [
+  "theme",
+  "density",
+  "fieldStyle",
+  "layout",
+  "oauthPlacement",
+  "stepped",
+  "logoUrl",
+  "logoText",
+  "brandLine",
+  "brandFoot",
+  "signInTitle",
+  "branding",
+  "initialScreen",
+  "noAccountView",
+  "redirectUrl",
+  "tosUrl",
+  "privacyUrl",
+  "nonceStorageKey",
+  "authEnabled",
+  "allowEmailSignin",
+  "allowEmailSignup",
+  "allowEmailOtp",
+  "allowOauth",
+  "allowAccountCreation",
+  "inviteEmail",
+  "inviteOrg",
+  "inviteCode"
+];
+function se(e) {
+  return e.replace(/[A-Z]/g, (t) => "-" + t.toLowerCase());
+}
+const x = [
+  "$eq",
+  "$ne",
+  "$in",
+  "$nin",
+  "$gt",
+  "$gte",
+  "$lt",
+  "$lte",
+  "$elemMatch"
+], v = new Set(x);
+function J(e) {
+  if (e === null || typeof e != "object" || Array.isArray(e)) return !1;
+  const t = Object.keys(e);
+  return t.length > 0 && t.every((r) => v.has(r));
+}
+function W(e, t) {
+  let r = e;
+  for (const n of t.split(".")) {
+    if (r == null || typeof r != "object") return;
+    r = r[n];
+  }
+  return r;
+}
+function u(e, t) {
+  if (e === t) return !0;
+  if (Array.isArray(e) && Array.isArray(t))
+    return e.length === t.length && e.every((r, n) => u(r, t[n]));
+  if (e && t && typeof e == "object" && typeof t == "object") {
+    const r = Object.keys(e), n = Object.keys(t);
+    return r.length === n.length && r.every(
+      (s) => u(e[s], t[s])
+    );
+  }
+  return !1;
+}
+function q(e, t) {
+  return typeof e == "number" && typeof t == "number" ? Number.isNaN(e) || Number.isNaN(t) ? null : e - t : typeof e == "string" && typeof t == "string" ? e < t ? -1 : e > t ? 1 : 0 : e instanceof Date && t instanceof Date ? e.getTime() - t.getTime() : null;
+}
+function U(e, t, r) {
+  switch (e) {
+    case "$eq":
+      return u(t, r);
+    case "$ne":
+      return !u(t, r);
+    case "$in":
+      return Array.isArray(r) ? Array.isArray(t) ? t.some((n) => r.some((s) => u(n, s))) : r.some((n) => u(t, n)) : !1;
+    case "$nin":
+      return Array.isArray(r) ? !U("$in", t, r) : !1;
+    case "$gt":
+    case "$gte":
+    case "$lt":
+    case "$lte": {
+      const n = q(t, r);
+      return n === null ? !1 : e === "$gt" ? n > 0 : e === "$gte" ? n >= 0 : e === "$lt" ? n < 0 : n <= 0;
+    }
+    case "$elemMatch":
+      return Array.isArray(t) ? t.some((n) => $(n, r)) : !1;
+    default:
+      return !1;
+  }
+}
+function $(e, t) {
+  return J(t) ? Object.entries(t).every(
+    ([r, n]) => U(r, e, n)
+  ) : u(e, t);
+}
+function oe(e, t) {
+  if (!t) return !0;
+  const r = Object.entries(t);
+  return r.length === 0 ? !0 : e == null ? !1 : r.every(([n, s]) => $(W(e, n), s));
+}
+function ie(e) {
+  if (e == null) return [];
+  if (typeof e != "object" || Array.isArray(e))
+    return ["predicate must be an object"];
+  const t = [];
+  for (const [r, n] of Object.entries(e)) {
+    if (r.startsWith("$")) {
+      t.push(`"${r}": top-level operators are not supported; use a field name`);
+      continue;
+    }
+    if (n === null || typeof n != "object" || Array.isArray(n)) continue;
+    const s = Object.keys(n), o = s.filter((a) => a.startsWith("$"));
+    if (o.length === 0) {
+      t.push(
+        `"${r}": nested objects are not supported; use dot notation, e.g. "${r}.field"`
+      );
+      continue;
+    }
+    o.length !== s.length && t.push(`"${r}": cannot mix operators with plain keys`);
+    for (const a of o)
+      v.has(a) || t.push(`"${r}": unsupported operator "${a}"`);
+  }
+  return t;
+}
+const y = () => {
+};
+function F() {
+  return { post: y, subscribe: () => y, close: y };
+}
+function Y() {
+  const e = globalThis.crypto;
+  return e && "randomUUID" in e ? e.randomUUID() : Math.random().toString(36).slice(2) + Date.now().toString(36);
+}
+function ae(e) {
+  const t = Y(), r = globalThis.BroadcastChannel;
+  if (r) {
+    let n;
+    try {
+      n = new r(e);
+    } catch {
+      return O(e, t);
+    }
+    return {
+      post(s) {
+        try {
+          n.postMessage({ signal: s, from: t, at: Date.now() });
+        } catch {
+        }
+      },
+      subscribe(s) {
+        const o = (a) => {
+          const i = a.data;
+          !i || typeof i != "object" || i.from !== t && (i.signal !== "session-changed" && i.signal !== "signout" || s(i));
+        };
+        return n.addEventListener("message", o), () => n.removeEventListener("message", o);
+      },
+      close() {
+        try {
+          n.close();
+        } catch {
+        }
+      }
+    };
+  }
+  return O(e, t);
+}
+function O(e, t) {
+  const r = Q();
+  if (!r) return F();
+  const n = `${e}:signal`;
+  return {
+    post(s) {
+      try {
+        r.setItem(n, JSON.stringify({ signal: s, from: t, at: Date.now() }));
+      } catch {
+      }
+    },
+    subscribe(s) {
+      var a;
+      const o = (i) => {
+        if (!(i.key !== n || !i.newValue))
+          try {
+            const c = JSON.parse(i.newValue);
+            if (c.from === t || c.signal !== "session-changed" && c.signal !== "signout") return;
+            s(c);
+          } catch {
+          }
+      };
+      return (a = globalThis.addEventListener) == null || a.call(globalThis, "storage", o), () => {
+        var i;
+        return (i = globalThis.removeEventListener) == null ? void 0 : i.call(globalThis, "storage", o);
+      };
+    },
+    close: y
+  };
+}
+function Q() {
+  try {
+    const e = globalThis.localStorage;
+    if (!e) return null;
+    const t = "__singlebase_probe__";
+    return e.setItem(t, "1"), e.removeItem(t), e;
+  } catch {
+    return null;
+  }
+}
+const N = Symbol.for("singlebase.client.registry");
+function _() {
+  const e = globalThis;
+  let t = e[N];
+  return t || (t = { instances: /* @__PURE__ */ new Map(), default: null }, e[N] = t), t;
+}
+function Z(e) {
+  return [
+    e.baseUrl ?? p,
+    e.urlAccessKey ?? "",
+    e.apiKey,
+    e.audience ?? "web"
+  ].join("|");
+}
+function ce(e, t) {
+  const r = _(), n = Z(e), s = r.instances.get(n);
+  if (s) return s;
+  const o = t();
+  return r.instances.set(n, o), r.default || (r.default = o), o;
+}
+function le() {
+  return _().default;
+}
+function ue(e) {
+  _().default = e;
+}
+function fe(e) {
+  const t = _();
+  for (const [r, n] of t.instances)
+    n === e && t.instances.delete(r);
+  t.default === e && (t.default = t.instances.values().next().value ?? null);
+}
+export {
+  ne as AUTHUI_PROP_KEYS,
+  p as DEFAULT_BASE_URL,
+  re as EventEmitter,
+  x as OPERATORS,
+  X as RpcDispatcher,
+  g as SinglebaseAuthError,
+  g as SinglebaseError,
+  B as assertSecureBaseUrl,
+  se as authUIAttributeFor,
+  H as canUseCryptoStorage,
+  Z as clientKey,
+  ae as crossTabChannel,
+  te as defaultStorage,
+  P as endpointFor,
+  le as getDefaultClient,
+  W as getPath,
+  G as indexedDbCryptoStorage,
+  ee as localStorageAdapter,
+  z as mapErrorToHint,
+  oe as matchesPredicate,
+  I as memoryStorage,
+  F as noopCrossTabChannel,
+  m as request,
+  C as resolveBaseUrl,
+  ce as resolveClient,
+  M as sessionStorageAdapter,
+  ue as setDefaultClient,
+  fe as unregisterClient,
+  ie as validatePredicate
+};
+//# sourceMappingURL=index.js.map