@pylo/react 0.7.0 → 0.9.0

package/dist/chunk-SBMMJYJT.js

@@ -1,346 +0,0 @@
-// src/provider.tsx
-import {
-  createContext,
-  useContext,
-  useEffect,
-  useMemo,
-  useRef,
-  useSyncExternalStore
-} from "react";
-import { useQuery, useQueryClient } from "@tanstack/react-query";
-import { createPyloClient, resolveEndpoint } from "@pylo/core";
-import { ME_QUERY } from "@pylo/auth";
-
-// src/session/store.ts
-import {
-  graphqlRequest,
-  hasErrors,
-  extractErrorMessage,
-  isUnauthorizedError,
-  shouldRefreshToken,
-  LOGIN_MUTATION,
-  REFRESH_TOKEN_MUTATION
-} from "@pylo/auth";
-function createSessionStore(options) {
-  var _a;
-  const prefix = (_a = options.keyPrefix) != null ? _a : "pylo";
-  const AUTH_KEY = `${prefix}.auth_token`;
-  const REFRESH_KEY = `${prefix}.refresh_token`;
-  let state = { status: "loading", token: null };
-  let refreshToken = null;
-  let inFlight = null;
-  let ready = null;
-  const listeners = /* @__PURE__ */ new Set();
-  function setState(next) {
-    state = next;
-    for (const listener of listeners) listener();
-  }
-  async function persist(auth, refresh2) {
-    refreshToken = refresh2;
-    await options.storage.setItem(AUTH_KEY, auth);
-    await options.storage.setItem(REFRESH_KEY, refresh2);
-    setState({ status: "signedIn", token: auth });
-  }
-  async function clear() {
-    var _a2;
-    refreshToken = null;
-    await options.storage.removeItem(AUTH_KEY);
-    await options.storage.removeItem(REFRESH_KEY);
-    setState({ status: "signedOut", token: null });
-    (_a2 = options.onSignOut) == null ? void 0 : _a2.call(options);
-  }
-  async function runRefresh() {
-    await init();
-    if (!refreshToken) {
-      await clear();
-      return null;
-    }
-    const response = await graphqlRequest(
-      options.endpoint,
-      REFRESH_TOKEN_MUTATION,
-      { input: { refresh_token: refreshToken } }
-    );
-    if (hasErrors(response) || !response.data) {
-      if (isUnauthorizedError(response)) {
-        await clear();
-        return null;
-      }
-      return state.token;
-    }
-    const { auth_token, refresh_token } = response.data.refreshToken.data;
-    await persist(auth_token, refresh_token);
-    return auth_token;
-  }
-  function init() {
-    ready != null ? ready : ready = (async () => {
-      try {
-        const [auth, stored] = await Promise.all([
-          options.storage.getItem(AUTH_KEY),
-          options.storage.getItem(REFRESH_KEY)
-        ]);
-        refreshToken = stored;
-        setState(
-          auth ? { status: "signedIn", token: auth } : { status: "signedOut", token: null }
-        );
-      } catch {
-        refreshToken = null;
-        setState({ status: "signedOut", token: null });
-      }
-    })();
-    return ready;
-  }
-  function refresh() {
-    inFlight != null ? inFlight : inFlight = runRefresh().finally(() => {
-      inFlight = null;
-    });
-    return inFlight;
-  }
-  return {
-    getState: () => state,
-    subscribe(listener) {
-      listeners.add(listener);
-      return () => void listeners.delete(listener);
-    },
-    init,
-    async getToken() {
-      await init();
-      if (!state.token) return null;
-      if (shouldRefreshToken(state.token)) return refresh();
-      return state.token;
-    },
-    refresh,
-    async login(email, password) {
-      var _a2, _b;
-      const response = await graphqlRequest(
-        options.endpoint,
-        LOGIN_MUTATION,
-        {
-          input: {
-            email,
-            password,
-            ...options.appId !== void 0 ? { pylo_app_id: options.appId } : {}
-          }
-        }
-      );
-      if (hasErrors(response)) {
-        return {
-          success: false,
-          error: {
-            code: "INVALID_CREDENTIALS",
-            message: (_a2 = extractErrorMessage(response.errors)) != null ? _a2 : "Login failed"
-          }
-        };
-      }
-      if (!response.data) {
-        return {
-          success: false,
-          error: { code: "SERVER_ERROR", message: "No data returned" }
-        };
-      }
-      const { auth_token, refresh_token } = response.data.login.data;
-      await persist(auth_token, refresh_token);
-      (_b = options.onSignIn) == null ? void 0 : _b.call(options);
-      return { success: true, authToken: auth_token, refreshToken: refresh_token };
-    },
-    logout: clear
-  };
-}
-
-// src/session/storage.ts
-function createMemoryStorage() {
-  const store = /* @__PURE__ */ new Map();
-  return {
-    getItem: async (key) => {
-      var _a;
-      return (_a = store.get(key)) != null ? _a : null;
-    },
-    setItem: async (key, value) => void store.set(key, value),
-    removeItem: async (key) => void store.delete(key)
-  };
-}
-function createLocalStorageAdapter() {
-  let web;
-  try {
-    web = globalThis.localStorage;
-  } catch {
-    web = void 0;
-  }
-  if (!web) return createMemoryStorage();
-  const fallback = createMemoryStorage();
-  return {
-    getItem: async (key) => {
-      try {
-        const value = web.getItem(key);
-        if (value !== null) return value;
-      } catch {
-      }
-      return fallback.getItem(key);
-    },
-    setItem: async (key, value) => {
-      try {
-        web.setItem(key, value);
-      } catch {
-        await fallback.setItem(key, value);
-      }
-    },
-    removeItem: async (key) => {
-      try {
-        web.removeItem(key);
-      } catch {
-      }
-      await fallback.removeItem(key);
-    }
-  };
-}
-
-// src/transport.ts
-import {
-  graphqlRequest as graphqlRequest2,
-  hasErrors as hasErrors2,
-  extractErrorMessage as extractErrorMessage2,
-  isUnauthorizedError as isUnauthorizedError2
-} from "@pylo/auth";
-import { PyloError } from "@pylo/core";
-function createDirectTransport(options) {
-  function send(query, variables, headers, token) {
-    return graphqlRequest2(
-      options.endpoint,
-      query,
-      variables,
-      {
-        ...token !== null ? { token } : {},
-        ...headers !== void 0 ? { headers } : {}
-      }
-    );
-  }
-  return async (query, variables, headers) => {
-    var _a;
-    let response = await send(query, variables, headers, await options.getToken());
-    if (isUnauthorizedError2(response) && options.onUnauthorized) {
-      const token = await options.onUnauthorized();
-      if (token !== null) {
-        response = await send(query, variables, headers, token);
-      }
-    }
-    if (hasErrors2(response)) {
-      throw new PyloError(
-        (_a = extractErrorMessage2(response.errors)) != null ? _a : "GraphQL request failed",
-        response.errors
-      );
-    }
-    if (!response.data) {
-      throw new PyloError("No data returned from GraphQL request");
-    }
-    return response.data;
-  };
-}
-
-// src/provider.tsx
-import { jsx } from "react/jsx-runtime";
-var PyloContext = createContext(null);
-function usePyloContext() {
-  const value = useContext(PyloContext);
-  if (!value) {
-    throw new Error("usePylo* must be used inside <PyloProvider>");
-  }
-  return value;
-}
-var SIGNED_OUT = { status: "signedOut", token: null };
-var NO_OP = () => () => {
-};
-function PyloProvider(props) {
-  var _a;
-  const queryClient = useQueryClient();
-  const endpoint = resolveEndpoint(props.endpoint);
-  const storeRef = useRef(null);
-  if (storeRef.current === null && !props.getToken) {
-    storeRef.current = createSessionStore({
-      endpoint,
-      storage: (_a = props.storage) != null ? _a : createLocalStorageAdapter(),
-      ...props.appId !== void 0 ? { appId: props.appId } : {},
-      ...props.keyPrefix !== void 0 ? { keyPrefix: props.keyPrefix } : {},
-      onSignOut: () => queryClient.clear(),
-      onSignIn: () => void queryClient.invalidateQueries({ queryKey: ["pylo"] })
-    });
-  }
-  const store = storeRef.current;
-  const state = useSyncExternalStore(
-    store ? store.subscribe : NO_OP,
-    store ? store.getState : () => SIGNED_OUT,
-    store ? store.getState : () => SIGNED_OUT
-  );
-  useEffect(() => {
-    void (store == null ? void 0 : store.init());
-  }, [store]);
-  const getTokenProp = props.getToken;
-  const getTokenRef = useRef(getTokenProp);
-  getTokenRef.current = getTokenProp;
-  const isEscapeHatch = getTokenProp !== void 0;
-  const value = useMemo(() => {
-    const getToken = isEscapeHatch ? () => getTokenRef.current() : () => store.getToken();
-    const transport = createDirectTransport({
-      endpoint,
-      getToken,
-      ...store ? { onUnauthorized: () => store.refresh() } : {}
-    });
-    return { transport, endpoint, state, store, getToken };
-  }, [endpoint, state, store, isEscapeHatch]);
-  return /* @__PURE__ */ jsx(PyloContext.Provider, { value, children: props.children });
-}
-function usePyloTransport() {
-  return usePyloContext().transport;
-}
-function usePyloClient() {
-  const { endpoint, getToken } = usePyloContext();
-  return useMemo(
-    () => createPyloClient({
-      endpoint,
-      auth: async () => {
-        const token = await getToken();
-        return token !== null ? { token } : {};
-      }
-    }),
-    [endpoint, getToken]
-  );
-}
-function usePyloAuth() {
-  const { state, store, transport, getToken } = usePyloContext();
-  const isSignedIn = state.status === "signedIn";
-  const me = useQuery({
-    queryKey: ["pylo", "me"],
-    queryFn: async () => {
-      const data = await transport(ME_QUERY, {});
-      return data.me.current_user.data;
-    },
-    enabled: isSignedIn
-  });
-  return {
-    isLoading: state.status === "loading" || isSignedIn && me.isLoading,
-    isSignedIn,
-    user: me.data,
-    login: async (email, password) => {
-      if (!store) {
-        throw new Error("login is unavailable when PyloProvider is given getToken");
-      }
-      return store.login(email, password);
-    },
-    logout: async () => {
-      if (!store) {
-        throw new Error("logout is unavailable when PyloProvider is given getToken");
-      }
-      await store.logout();
-    },
-    getToken
-  };
-}
-
-export {
-  createSessionStore,
-  createMemoryStorage,
-  createLocalStorageAdapter,
-  createDirectTransport,
-  PyloProvider,
-  usePyloTransport,
-  usePyloClient,
-  usePyloAuth
-};