@weirdscience/based-client 0.4.1 → 0.6.1

package/dist/core.cjs

@@ -0,0 +1,376 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// src/core.ts
+var exports_core = {};
+__export(exports_core, {
+  createClient: () => createClient,
+  BasedError: () => BasedError
+});
+module.exports = __toCommonJS(exports_core);
+
+// src/types.ts
+class BasedError extends Error {
+  code;
+  status;
+  details;
+  constructor(code, message, status, details) {
+    super(message);
+    this.name = "BasedError";
+    this.code = code;
+    this.status = status;
+    this.details = details;
+  }
+}
+
+// src/client.ts
+var DEFAULT_STORAGE_KEY = "based.session";
+function defaultStorage() {
+  if (typeof globalThis === "undefined")
+    return null;
+  const ls = globalThis.localStorage;
+  if (!ls || typeof ls.getItem !== "function")
+    return null;
+  return {
+    getItem: (k) => ls.getItem(k),
+    setItem: (k, v) => ls.setItem(k, v),
+    removeItem: (k) => ls.removeItem(k)
+  };
+}
+function createClient(options) {
+  const { url, anonKey } = options;
+  const baseUrl = url.replace(/\/$/, "");
+  const storage = options.storage === false ? null : options.storage ?? defaultStorage();
+  const storageKey = options.storageKey ?? DEFAULT_STORAGE_KEY;
+  let state = {
+    user: null,
+    accessToken: null,
+    refreshToken: null,
+    isLoading: !!storage
+  };
+  const listeners = new Set;
+  function notify() {
+    for (const listener of listeners)
+      listener();
+  }
+  function subscribe(listener) {
+    listeners.add(listener);
+    return () => listeners.delete(listener);
+  }
+  function getState() {
+    return state;
+  }
+  function onAuthStateChange(callback) {
+    return subscribe(() => callback(state));
+  }
+  async function persist() {
+    if (!storage)
+      return;
+    const snapshot = {
+      user: state.user,
+      accessToken: state.accessToken,
+      refreshToken: state.refreshToken
+    };
+    if (!snapshot.refreshToken) {
+      await storage.removeItem(storageKey);
+      return;
+    }
+    await storage.setItem(storageKey, JSON.stringify(snapshot));
+  }
+  function setState(next) {
+    state = { ...state, ...next };
+    notify();
+    persist().catch(() => {});
+  }
+  const readyPromise = (async () => {
+    if (!storage) {
+      setState({ isLoading: false });
+      return;
+    }
+    try {
+      const raw = await storage.getItem(storageKey);
+      if (!raw) {
+        setState({ isLoading: false });
+        return;
+      }
+      const stored = JSON.parse(raw);
+      if (!stored.refreshToken) {
+        setState({ isLoading: false });
+        return;
+      }
+      state = {
+        user: stored.user,
+        accessToken: stored.accessToken,
+        refreshToken: stored.refreshToken,
+        isLoading: true
+      };
+      notify();
+      const user = await getUser();
+      if (!user) {
+        const refreshed = await refreshSession();
+        if (refreshed) {
+          await getUser();
+        }
+      }
+    } catch {
+      try {
+        await storage.removeItem(storageKey);
+      } catch {}
+    } finally {
+      setState({ isLoading: false });
+    }
+  })();
+  function ready() {
+    return readyPromise;
+  }
+  async function fetchWithAuth(path, init = {}) {
+    const headers = new Headers(init.headers);
+    if (state.accessToken) {
+      headers.set("Authorization", `Bearer ${state.accessToken}`);
+    } else {
+      headers.set("apikey", anonKey);
+    }
+    if (!headers.has("Content-Type") && init.body) {
+      headers.set("Content-Type", "application/json");
+    }
+    const tokenAtRequest = state.accessToken;
+    let res = await fetch(`${baseUrl}${path}`, { ...init, headers });
+    if (res.status === 401 && state.refreshToken) {
+      const alreadyRefreshed = state.accessToken !== tokenAtRequest;
+      const refreshed = alreadyRefreshed ? true : await refreshSession();
+      if (refreshed && state.accessToken) {
+        headers.set("Authorization", `Bearer ${state.accessToken}`);
+        res = await fetch(`${baseUrl}${path}`, { ...init, headers });
+      }
+    }
+    return res;
+  }
+  async function authError(res, fallback) {
+    const json = await res.json().catch(() => null);
+    return new BasedError(json?.error?.code ?? "AUTH_ERROR", json?.error?.message || fallback, res.status, json?.error?.details);
+  }
+  async function signUp(email, password) {
+    const res = await fetch(`${baseUrl}/auth/signup`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ email, password })
+    });
+    if (!res.ok) {
+      throw await authError(res, "Sign up failed");
+    }
+    const { data } = await res.json();
+    setState({
+      user: data.user,
+      accessToken: data.accessToken,
+      refreshToken: data.refreshToken,
+      isLoading: false
+    });
+    return data.user;
+  }
+  async function signIn(email, password) {
+    const res = await fetch(`${baseUrl}/auth/signin`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ email, password })
+    });
+    if (!res.ok) {
+      throw await authError(res, "Sign in failed");
+    }
+    const { data } = await res.json();
+    setState({
+      user: data.user,
+      accessToken: data.accessToken,
+      refreshToken: data.refreshToken,
+      isLoading: false
+    });
+    return data.user;
+  }
+  async function signOut() {
+    if (state.accessToken) {
+      try {
+        await fetch(`${baseUrl}/auth/signout`, {
+          method: "POST",
+          headers: { Authorization: `Bearer ${state.accessToken}` }
+        });
+      } catch {}
+    }
+    setState({ user: null, accessToken: null, refreshToken: null, isLoading: false });
+  }
+  let refreshInFlight = null;
+  function refreshSession() {
+    if (!refreshInFlight) {
+      refreshInFlight = doRefresh().finally(() => {
+        refreshInFlight = null;
+      });
+    }
+    return refreshInFlight;
+  }
+  async function doRefresh() {
+    if (!state.refreshToken)
+      return false;
+    try {
+      const res = await fetch(`${baseUrl}/auth/refresh`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ refreshToken: state.refreshToken })
+      });
+      if (!res.ok) {
+        setState({ user: null, accessToken: null, refreshToken: null, isLoading: false });
+        return false;
+      }
+      const { data } = await res.json();
+      setState({
+        accessToken: data.accessToken,
+        refreshToken: data.refreshToken
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async function getUser() {
+    if (!state.accessToken)
+      return null;
+    try {
+      const res = await fetch(`${baseUrl}/auth/me`, {
+        headers: { Authorization: `Bearer ${state.accessToken}` }
+      });
+      if (!res.ok) {
+        if (res.status === 401) {
+          setState({ user: null });
+        }
+        return null;
+      }
+      const { data } = await res.json();
+      const user = { id: data.id, email: data.email, role: data.role };
+      setState({ user });
+      return user;
+    } catch {
+      return null;
+    }
+  }
+  async function parseOrThrow(res, fallbackCode) {
+    let json = {};
+    try {
+      json = await res.json();
+    } catch {}
+    if (!res.ok) {
+      const err = json.error;
+      throw new BasedError(err?.code || fallbackCode, err?.message || `Request failed with status ${res.status}`, res.status, err?.details);
+    }
+    return json;
+  }
+  function from(table) {
+    const basePath = `/api/${table}`;
+    return {
+      async select(opts) {
+        const params = new URLSearchParams;
+        if (opts?.limit !== undefined)
+          params.set("limit", String(opts.limit));
+        if (opts?.offset !== undefined)
+          params.set("offset", String(opts.offset));
+        if (opts?.order !== undefined)
+          params.set("order", opts.order);
+        if (opts?.filter) {
+          for (const [key, value] of Object.entries(opts.filter)) {
+            if (value !== undefined)
+              params.set(key, String(value));
+          }
+        }
+        const query = params.toString();
+        const res = await fetchWithAuth(`${basePath}${query ? `?${query}` : ""}`);
+        const json = await parseOrThrow(res, "SELECT_FAILED");
+        return { data: json.data, total: json.total ?? json.data.length };
+      },
+      async get(id) {
+        const res = await fetchWithAuth(`${basePath}/${encodeURIComponent(id)}`);
+        if (res.status === 404)
+          return null;
+        const json = await parseOrThrow(res, "GET_FAILED");
+        return json.data;
+      },
+      async insert(data) {
+        const res = await fetchWithAuth(basePath, {
+          method: "POST",
+          body: JSON.stringify(data)
+        });
+        const json = await parseOrThrow(res, "INSERT_FAILED");
+        return json.data;
+      },
+      async update(id, data) {
+        const body = { ...data };
+        delete body.id;
+        const res = await fetchWithAuth(`${basePath}/${encodeURIComponent(id)}`, {
+          method: "PUT",
+          body: JSON.stringify(body)
+        });
+        const json = await parseOrThrow(res, "UPDATE_FAILED");
+        return json.data;
+      },
+      async upsert(data) {
+        const body = { ...data };
+        const id = body.id;
+        if (!id) {
+          throw new BasedError("MISSING_ID", "upsert() requires `data.id`. Use insert() to let the server generate one.", 400);
+        }
+        delete body.id;
+        const res = await fetchWithAuth(`${basePath}/${encodeURIComponent(id)}`, {
+          method: "PUT",
+          body: JSON.stringify(body)
+        });
+        const json = await parseOrThrow(res, "UPSERT_FAILED");
+        return json.data;
+      },
+      async delete(id) {
+        const res = await fetchWithAuth(`${basePath}/${encodeURIComponent(id)}`, {
+          method: "DELETE"
+        });
+        await parseOrThrow(res, "DELETE_FAILED");
+        return { deleted: true };
+      }
+    };
+  }
+  return {
+    auth: { signUp, signIn, signOut, refreshSession, getUser, onAuthStateChange },
+    fetch: fetchWithAuth,
+    from,
+    subscribe,
+    getState,
+    ready
+  };
+}

package/dist/core.d.ts

@@ -0,0 +1,4 @@
+export { createClient } from "./client";
+export { BasedError } from "./types";
+export type { BasedClient, BasedClientOptions, BasedTable, ListResult, StorageAdapter, AuthUser, AuthState, QueryOptions, DefaultTables, } from "./types";
+//# sourceMappingURL=core.d.ts.map

package/dist/core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../src/core.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AACxC,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAErC,YAAY,EACV,WAAW,EACX,kBAAkB,EAClB,UAAU,EACV,UAAU,EACV,cAAc,EACd,QAAQ,EACR,SAAS,EACT,YAAY,EACZ,aAAa,GACd,MAAM,SAAS,CAAC"}

package/dist/core.js

@@ -0,0 +1,334 @@
+// src/types.ts
+class BasedError extends Error {
+  code;
+  status;
+  details;
+  constructor(code, message, status, details) {
+    super(message);
+    this.name = "BasedError";
+    this.code = code;
+    this.status = status;
+    this.details = details;
+  }
+}
+
+// src/client.ts
+var DEFAULT_STORAGE_KEY = "based.session";
+function defaultStorage() {
+  if (typeof globalThis === "undefined")
+    return null;
+  const ls = globalThis.localStorage;
+  if (!ls || typeof ls.getItem !== "function")
+    return null;
+  return {
+    getItem: (k) => ls.getItem(k),
+    setItem: (k, v) => ls.setItem(k, v),
+    removeItem: (k) => ls.removeItem(k)
+  };
+}
+function createClient(options) {
+  const { url, anonKey } = options;
+  const baseUrl = url.replace(/\/$/, "");
+  const storage = options.storage === false ? null : options.storage ?? defaultStorage();
+  const storageKey = options.storageKey ?? DEFAULT_STORAGE_KEY;
+  let state = {
+    user: null,
+    accessToken: null,
+    refreshToken: null,
+    isLoading: !!storage
+  };
+  const listeners = new Set;
+  function notify() {
+    for (const listener of listeners)
+      listener();
+  }
+  function subscribe(listener) {
+    listeners.add(listener);
+    return () => listeners.delete(listener);
+  }
+  function getState() {
+    return state;
+  }
+  function onAuthStateChange(callback) {
+    return subscribe(() => callback(state));
+  }
+  async function persist() {
+    if (!storage)
+      return;
+    const snapshot = {
+      user: state.user,
+      accessToken: state.accessToken,
+      refreshToken: state.refreshToken
+    };
+    if (!snapshot.refreshToken) {
+      await storage.removeItem(storageKey);
+      return;
+    }
+    await storage.setItem(storageKey, JSON.stringify(snapshot));
+  }
+  function setState(next) {
+    state = { ...state, ...next };
+    notify();
+    persist().catch(() => {});
+  }
+  const readyPromise = (async () => {
+    if (!storage) {
+      setState({ isLoading: false });
+      return;
+    }
+    try {
+      const raw = await storage.getItem(storageKey);
+      if (!raw) {
+        setState({ isLoading: false });
+        return;
+      }
+      const stored = JSON.parse(raw);
+      if (!stored.refreshToken) {
+        setState({ isLoading: false });
+        return;
+      }
+      state = {
+        user: stored.user,
+        accessToken: stored.accessToken,
+        refreshToken: stored.refreshToken,
+        isLoading: true
+      };
+      notify();
+      const user = await getUser();
+      if (!user) {
+        const refreshed = await refreshSession();
+        if (refreshed) {
+          await getUser();
+        }
+      }
+    } catch {
+      try {
+        await storage.removeItem(storageKey);
+      } catch {}
+    } finally {
+      setState({ isLoading: false });
+    }
+  })();
+  function ready() {
+    return readyPromise;
+  }
+  async function fetchWithAuth(path, init = {}) {
+    const headers = new Headers(init.headers);
+    if (state.accessToken) {
+      headers.set("Authorization", `Bearer ${state.accessToken}`);
+    } else {
+      headers.set("apikey", anonKey);
+    }
+    if (!headers.has("Content-Type") && init.body) {
+      headers.set("Content-Type", "application/json");
+    }
+    const tokenAtRequest = state.accessToken;
+    let res = await fetch(`${baseUrl}${path}`, { ...init, headers });
+    if (res.status === 401 && state.refreshToken) {
+      const alreadyRefreshed = state.accessToken !== tokenAtRequest;
+      const refreshed = alreadyRefreshed ? true : await refreshSession();
+      if (refreshed && state.accessToken) {
+        headers.set("Authorization", `Bearer ${state.accessToken}`);
+        res = await fetch(`${baseUrl}${path}`, { ...init, headers });
+      }
+    }
+    return res;
+  }
+  async function authError(res, fallback) {
+    const json = await res.json().catch(() => null);
+    return new BasedError(json?.error?.code ?? "AUTH_ERROR", json?.error?.message || fallback, res.status, json?.error?.details);
+  }
+  async function signUp(email, password) {
+    const res = await fetch(`${baseUrl}/auth/signup`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ email, password })
+    });
+    if (!res.ok) {
+      throw await authError(res, "Sign up failed");
+    }
+    const { data } = await res.json();
+    setState({
+      user: data.user,
+      accessToken: data.accessToken,
+      refreshToken: data.refreshToken,
+      isLoading: false
+    });
+    return data.user;
+  }
+  async function signIn(email, password) {
+    const res = await fetch(`${baseUrl}/auth/signin`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ email, password })
+    });
+    if (!res.ok) {
+      throw await authError(res, "Sign in failed");
+    }
+    const { data } = await res.json();
+    setState({
+      user: data.user,
+      accessToken: data.accessToken,
+      refreshToken: data.refreshToken,
+      isLoading: false
+    });
+    return data.user;
+  }
+  async function signOut() {
+    if (state.accessToken) {
+      try {
+        await fetch(`${baseUrl}/auth/signout`, {
+          method: "POST",
+          headers: { Authorization: `Bearer ${state.accessToken}` }
+        });
+      } catch {}
+    }
+    setState({ user: null, accessToken: null, refreshToken: null, isLoading: false });
+  }
+  let refreshInFlight = null;
+  function refreshSession() {
+    if (!refreshInFlight) {
+      refreshInFlight = doRefresh().finally(() => {
+        refreshInFlight = null;
+      });
+    }
+    return refreshInFlight;
+  }
+  async function doRefresh() {
+    if (!state.refreshToken)
+      return false;
+    try {
+      const res = await fetch(`${baseUrl}/auth/refresh`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ refreshToken: state.refreshToken })
+      });
+      if (!res.ok) {
+        setState({ user: null, accessToken: null, refreshToken: null, isLoading: false });
+        return false;
+      }
+      const { data } = await res.json();
+      setState({
+        accessToken: data.accessToken,
+        refreshToken: data.refreshToken
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async function getUser() {
+    if (!state.accessToken)
+      return null;
+    try {
+      const res = await fetch(`${baseUrl}/auth/me`, {
+        headers: { Authorization: `Bearer ${state.accessToken}` }
+      });
+      if (!res.ok) {
+        if (res.status === 401) {
+          setState({ user: null });
+        }
+        return null;
+      }
+      const { data } = await res.json();
+      const user = { id: data.id, email: data.email, role: data.role };
+      setState({ user });
+      return user;
+    } catch {
+      return null;
+    }
+  }
+  async function parseOrThrow(res, fallbackCode) {
+    let json = {};
+    try {
+      json = await res.json();
+    } catch {}
+    if (!res.ok) {
+      const err = json.error;
+      throw new BasedError(err?.code || fallbackCode, err?.message || `Request failed with status ${res.status}`, res.status, err?.details);
+    }
+    return json;
+  }
+  function from(table) {
+    const basePath = `/api/${table}`;
+    return {
+      async select(opts) {
+        const params = new URLSearchParams;
+        if (opts?.limit !== undefined)
+          params.set("limit", String(opts.limit));
+        if (opts?.offset !== undefined)
+          params.set("offset", String(opts.offset));
+        if (opts?.order !== undefined)
+          params.set("order", opts.order);
+        if (opts?.filter) {
+          for (const [key, value] of Object.entries(opts.filter)) {
+            if (value !== undefined)
+              params.set(key, String(value));
+          }
+        }
+        const query = params.toString();
+        const res = await fetchWithAuth(`${basePath}${query ? `?${query}` : ""}`);
+        const json = await parseOrThrow(res, "SELECT_FAILED");
+        return { data: json.data, total: json.total ?? json.data.length };
+      },
+      async get(id) {
+        const res = await fetchWithAuth(`${basePath}/${encodeURIComponent(id)}`);
+        if (res.status === 404)
+          return null;
+        const json = await parseOrThrow(res, "GET_FAILED");
+        return json.data;
+      },
+      async insert(data) {
+        const res = await fetchWithAuth(basePath, {
+          method: "POST",
+          body: JSON.stringify(data)
+        });
+        const json = await parseOrThrow(res, "INSERT_FAILED");
+        return json.data;
+      },
+      async update(id, data) {
+        const body = { ...data };
+        delete body.id;
+        const res = await fetchWithAuth(`${basePath}/${encodeURIComponent(id)}`, {
+          method: "PUT",
+          body: JSON.stringify(body)
+        });
+        const json = await parseOrThrow(res, "UPDATE_FAILED");
+        return json.data;
+      },
+      async upsert(data) {
+        const body = { ...data };
+        const id = body.id;
+        if (!id) {
+          throw new BasedError("MISSING_ID", "upsert() requires `data.id`. Use insert() to let the server generate one.", 400);
+        }
+        delete body.id;
+        const res = await fetchWithAuth(`${basePath}/${encodeURIComponent(id)}`, {
+          method: "PUT",
+          body: JSON.stringify(body)
+        });
+        const json = await parseOrThrow(res, "UPSERT_FAILED");
+        return json.data;
+      },
+      async delete(id) {
+        const res = await fetchWithAuth(`${basePath}/${encodeURIComponent(id)}`, {
+          method: "DELETE"
+        });
+        await parseOrThrow(res, "DELETE_FAILED");
+        return { deleted: true };
+      }
+    };
+  }
+  return {
+    auth: { signUp, signIn, signOut, refreshSession, getUser, onAuthStateChange },
+    fetch: fetchWithAuth,
+    from,
+    subscribe,
+    getState,
+    ready
+  };
+}
+export {
+  createClient,
+  BasedError
+};