@withpotter/lib 0.13.0-next.101

package/dist/auth-context.js

@@ -0,0 +1,732 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import {
+  createContext,
+  useContext,
+  useState,
+  useEffect,
+  useCallback
+} from "react";
+import {
+  getApiUrl,
+  apiFetch,
+  accountsApi,
+  tenantApi
+} from "./api";
+import { removeLegacyToken } from "./stored-token";
+import { resetPostHogIdentity } from "@withpotter/components/analytics";
+import { uploadImage } from "@withpotter/lib/media-service";
+import { endSession } from "@withpotter/lib/end-session";
+import {
+  pickWorkspace,
+  readJoinedWorkspace,
+  clearJoinedWorkspace
+} from "./active-workspace";
+const AuthContext = createContext(void 0);
+const DEV_OPEN_ACCESS = process.env.NODE_ENV === "development" && process.env.NEXT_PUBLIC_DEV_OPEN_ACCESS === "1";
+function persistActiveWorkspace(workspace) {
+  if (!workspace) {
+    localStorage.removeItem("currentWorkspace");
+    localStorage.removeItem("pb_current_tenant");
+    localStorage.removeItem("tenant");
+    return;
+  }
+  const { slug } = workspace.tenant;
+  localStorage.setItem("currentWorkspace", slug);
+  localStorage.setItem("pb_current_tenant", slug);
+  localStorage.setItem("tenant", JSON.stringify(workspace.tenant));
+  localStorage.setItem("pb_last_workspace", slug);
+}
+function readPreferredSlug() {
+  return localStorage.getItem("currentWorkspace") || localStorage.getItem("pb_last_workspace") || localStorage.getItem("pb_current_tenant");
+}
+function resolveActiveWorkspace(workspaces, authoritative) {
+  const joinedTenantId = readJoinedWorkspace();
+  const picked = pickWorkspace(workspaces, {
+    joinedTenantId,
+    preferredSlug: readPreferredSlug()
+  });
+  if (joinedTenantId && (authoritative || picked?.tenant.id === joinedTenantId)) {
+    clearJoinedWorkspace();
+  }
+  return picked;
+}
+function persistWorkspaceList(workspaces) {
+  localStorage.setItem(
+    "workspaces",
+    JSON.stringify(workspaces.map((w) => w.tenant.slug))
+  );
+  localStorage.setItem("pb_workspaces_cache", JSON.stringify(workspaces));
+}
+function clearStoredAuth() {
+  localStorage.removeItem("pb_token");
+  localStorage.removeItem("pb_user");
+  localStorage.removeItem("pb_account_id");
+  localStorage.removeItem("userEmail");
+  localStorage.removeItem("organizationId");
+  persistActiveWorkspace(null);
+}
+function readCachedWorkspace() {
+  try {
+    const raw = localStorage.getItem("pb_workspaces_cache");
+    if (!raw) return null;
+    const cached = JSON.parse(raw);
+    if (!Array.isArray(cached) || cached.length === 0) return null;
+    const match = pickWorkspace(cached, {
+      joinedTenantId: readJoinedWorkspace(),
+      preferredSlug: readPreferredSlug()
+    }) ?? cached[0];
+    return match?.tenant?.slug && match.tenant.id !== match.tenant.slug ? match : null;
+  } catch {
+    return null;
+  }
+}
+function AuthProvider({ children }) {
+  const [user, setUser] = useState(null);
+  const [loading, setLoading] = useState(true);
+  const [connectionError, setConnectionError] = useState(false);
+  const fetchTenant = useCallback(
+    async (slug) => {
+      try {
+        const res = await fetch(`${getApiUrl()}/tenants/${slug}`, {
+          credentials: "include"
+        });
+        if (!res.ok) return null;
+        const data = await res.json();
+        return {
+          id: data.id,
+          slug: data.slug,
+          businessName: data.businessName,
+          // Synthesize businessLogo from settings.logo.url (GET /tenants/:slug returns raw entity without businessLogo)
+          businessLogo: data.businessLogo || data.settings?.logo?.url || void 0,
+          contactEmail: data.contactEmail || data.email,
+          contactPhone: data.contactPhone || data.phone,
+          templateId: data.templateId || "luxe-fashion-01",
+          customDomain: data.customDomain || void 0,
+          status: data.status,
+          settings: data.settings,
+          organizationId: data.organizationId
+        };
+      } catch {
+        return null;
+      }
+    },
+    []
+  );
+  const loadWorkspaces = useCallback(async () => {
+    try {
+      const res = await fetch(`${getApiUrl()}/team/my-tenants`, {
+        credentials: "include"
+      });
+      if (res.status === 401 || res.status === 403) {
+        if (process.env.NODE_ENV === "development") {
+          console.warn(
+            "Auth expired (status",
+            res.status,
+            "), redirecting to login"
+          );
+        }
+        clearStoredAuth();
+        if (typeof window !== "undefined") {
+          window.location.href = "/login";
+        }
+        throw new Error("AUTH_EXPIRED");
+      }
+      if (res.ok) {
+        const apiTenants = await res.json();
+        const liveTenants = apiTenants.filter(
+          (t) => (t.tenant?.status ?? "active") !== "deleted"
+        );
+        const workspaces = liveTenants.map((t) => ({
+          tenant: {
+            id: t.tenant?.id || t.tenantId,
+            slug: t.tenant?.slug || t.tenantSlug,
+            businessName: t.tenant?.businessName || t.tenantName,
+            businessLogo: t.tenant?.businessLogo || void 0,
+            contactEmail: t.tenant?.contactEmail || void 0,
+            contactPhone: t.tenant?.contactPhone || void 0,
+            customDomain: t.tenant?.customDomain || void 0,
+            templateId: t.templateId || "luxe-fashion-01",
+            status: t.tenant?.status || "active",
+            // What kind of business this is. The switcher labels every row
+            // with it so four workspaces are four distinguishable things, and
+            // dropping it here was why they all read as a bare name.
+            industryKey: t.tenant?.industryKey ?? null,
+            settings: t.tenant?.settings || void 0,
+            organizationId: t.organizationId || void 0
+          },
+          role: t.role,
+          permissions: t.permissions
+        }));
+        if (workspaces.length > 0) {
+          persistWorkspaceList(workspaces);
+        }
+        return { workspaces, fromApi: true };
+      }
+      if (process.env.NODE_ENV === "development") {
+        console.warn("API returned error status:", res.status);
+      }
+      try {
+        const cachedRaw = localStorage.getItem("pb_workspaces_cache");
+        if (cachedRaw) {
+          const cachedWorkspaces = JSON.parse(cachedRaw);
+          if (cachedWorkspaces.length > 0) {
+            return { workspaces: cachedWorkspaces, fromApi: false };
+          }
+        }
+      } catch {
+      }
+      const cachedSlugs = JSON.parse(
+        localStorage.getItem("workspaces") || "[]"
+      );
+      if (cachedSlugs.length > 0) {
+        const cachedWorkspaces = cachedSlugs.map((slug) => ({
+          tenant: {
+            id: slug,
+            slug,
+            businessName: slug,
+            templateId: "luxe-fashion-01",
+            status: "active"
+          },
+          role: "owner"
+        }));
+        return { workspaces: cachedWorkspaces, fromApi: false };
+      }
+      return { workspaces: [], fromApi: false };
+    } catch (error) {
+      if (process.env.NODE_ENV === "development") {
+        console.warn("Failed to fetch workspaces from API:", error);
+      }
+      return { workspaces: [], fromApi: false };
+    }
+  }, []);
+  useEffect(() => {
+    const checkAuth = async () => {
+      if (DEV_OPEN_ACCESS) {
+        const slug = process.env.NEXT_PUBLIC_DEV_TENANT || "demo";
+        const tenant = {
+          id: slug,
+          slug,
+          businessName: "Dev Business",
+          templateId: "luxe-fashion-01",
+          status: "active"
+        };
+        const workspace = { tenant, role: "owner" };
+        setUser({
+          id: "dev-user",
+          email: "dev@local",
+          name: "Dev",
+          emailVerified: true,
+          mfaEnabled: false,
+          organizationId: "",
+          workspaces: [workspace],
+          currentWorkspace: workspace
+        });
+        setLoading(false);
+        return;
+      }
+      removeLegacyToken();
+      const pbUser = localStorage.getItem("pb_user");
+      const storedOrgId = localStorage.getItem("organizationId");
+      if (!pbUser) {
+        clearStoredAuth();
+        setLoading(false);
+        return;
+      }
+      let userData = null;
+      try {
+        userData = JSON.parse(pbUser);
+      } catch {
+        if (process.env.NODE_ENV === "development") {
+          console.warn("Invalid user data, clearing auth state");
+        }
+        clearStoredAuth();
+        setLoading(false);
+        return;
+      }
+      if (!userData?.email) {
+        if (process.env.NODE_ENV === "development") {
+          console.warn("No email in user data, clearing auth state");
+        }
+        clearStoredAuth();
+        setLoading(false);
+        return;
+      }
+      const cachedWorkspace = readCachedWorkspace();
+      if (cachedWorkspace && !cancelled) {
+        setUser({
+          id: userData.id,
+          email: userData.email,
+          name: userData.name || userData.email.split("@")[0],
+          avatarUrl: userData.avatarUrl || void 0,
+          phone: userData.phone ?? null,
+          emailVerified: userData.emailVerified ?? false,
+          mfaEnabled: userData.mfaEnabled ?? false,
+          organizationId: storedOrgId || userData?.organizationId || cachedWorkspace.tenant.organizationId || "",
+          workspaces: [cachedWorkspace],
+          currentWorkspace: cachedWorkspace
+        });
+        setLoading(false);
+      }
+      try {
+        const freshAccount = await apiFetch("/accounts/me");
+        if (freshAccount) {
+          userData = freshAccount;
+          localStorage.setItem("pb_user", JSON.stringify(freshAccount));
+        }
+      } catch {
+      }
+      let result;
+      try {
+        result = await loadWorkspaces();
+      } catch (e) {
+        if (e instanceof Error && e.message === "AUTH_EXPIRED") return;
+        throw e;
+      }
+      if (cancelled) return;
+      const workspaces = result.workspaces;
+      setConnectionError(!result.fromApi && workspaces.length === 0);
+      const signupTenantSlug = localStorage.getItem("pb_current_tenant");
+      let currentWorkspace = resolveActiveWorkspace(workspaces, result.fromApi);
+      if (workspaces.length === 0 && signupTenantSlug) {
+        const signupTenant = await fetchTenant(signupTenantSlug);
+        if (signupTenant) {
+          currentWorkspace = { tenant: signupTenant, role: "owner" };
+          workspaces.push(currentWorkspace);
+          persistWorkspaceList(workspaces);
+        }
+      }
+      if (currentWorkspace) persistActiveWorkspace(currentWorkspace);
+      const userOrgId = storedOrgId || userData?.organizationId || currentWorkspace?.tenant?.organizationId;
+      setUser({
+        id: userData.id,
+        email: userData.email,
+        name: userData.name || userData.email.split("@")[0],
+        avatarUrl: userData.avatarUrl || void 0,
+        phone: userData.phone ?? null,
+        emailVerified: userData.emailVerified ?? false,
+        mfaEnabled: userData.mfaEnabled ?? false,
+        organizationId: userOrgId ?? "",
+        workspaces,
+        currentWorkspace
+      });
+      setLoading(false);
+    };
+    let cancelled = false;
+    checkAuth();
+    return () => {
+      cancelled = true;
+    };
+  }, [fetchTenant, loadWorkspaces]);
+  const establishSession = async (data, method = "email", connection) => {
+    const { account, tenants, organizationId } = data;
+    const workspaces = [];
+    for (const t of tenants || []) {
+      workspaces.push({
+        tenant: {
+          id: t.id,
+          slug: t.slug,
+          businessName: t.name,
+          businessLogo: t.businessLogo || t.settings?.logo?.url || void 0,
+          contactEmail: t.contactEmail || void 0,
+          contactPhone: t.contactPhone || void 0,
+          customDomain: t.customDomain || void 0,
+          templateId: t.templateId || "luxe-fashion-01",
+          status: t.status || "active",
+          settings: t.settings || void 0,
+          organizationId: t.organizationId || void 0
+        },
+        role: t.role,
+        permissions: t.permissions
+      });
+    }
+    const signupTenantSlug = localStorage.getItem("pb_current_tenant");
+    let currentWorkspace = resolveActiveWorkspace(workspaces, true);
+    if (!currentWorkspace && signupTenantSlug) {
+      const signupTenant = await fetchTenant(signupTenantSlug);
+      if (signupTenant) {
+        currentWorkspace = { tenant: signupTenant, role: "owner" };
+        workspaces.push(currentWorkspace);
+      }
+    }
+    const userOrgId = organizationId || tenants?.[0]?.organizationId || currentWorkspace?.tenant?.organizationId || null;
+    localStorage.setItem("pb_account_id", account.id);
+    localStorage.setItem("pb_user", JSON.stringify(account));
+    localStorage.setItem("userEmail", account.email);
+    persistWorkspaceList(workspaces);
+    if (userOrgId) {
+      localStorage.setItem("organizationId", userOrgId);
+    }
+    persistActiveWorkspace(currentWorkspace);
+    try {
+      localStorage.setItem(
+        "pb_last_account",
+        JSON.stringify({
+          email: account.email,
+          name: account.name || account.email.split("@")[0],
+          avatarUrl: account.avatarUrl || void 0,
+          businessName: currentWorkspace?.tenant.businessName || tenants?.[0]?.name || void 0,
+          method,
+          connection: method === "connection" ? connection : void 0
+        })
+      );
+    } catch {
+    }
+    setUser({
+      id: account.id,
+      email: account.email,
+      name: account.name || account.email.split("@")[0],
+      avatarUrl: account.avatarUrl || void 0,
+      phone: account.phone ?? null,
+      emailVerified: account.emailVerified ?? false,
+      mfaEnabled: account.mfaEnabled ?? false,
+      organizationId: userOrgId ?? "",
+      workspaces,
+      currentWorkspace
+    });
+  };
+  const login = async (email, password) => {
+    setLoading(true);
+    try {
+      const res = await fetch(`${getApiUrl()}/accounts/login`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ email, password }),
+        credentials: "include"
+        // Required to receive and send cookies
+      });
+      if (!res.ok) {
+        const error = await res.json().catch(() => ({ message: "Login failed" }));
+        throw new Error(error.message || "Invalid email or password");
+      }
+      const data = await res.json();
+      await establishSession(data);
+    } finally {
+      setLoading(false);
+    }
+  };
+  const loginWithGoogle = async (payload) => {
+    setLoading(true);
+    try {
+      await establishSession(payload, "google");
+    } finally {
+      setLoading(false);
+    }
+  };
+  const loginWithCode = async (payload, method = "email", connection) => {
+    setLoading(true);
+    try {
+      await establishSession(payload, method, connection);
+    } finally {
+      setLoading(false);
+    }
+  };
+  const logout = async () => {
+    resetPostHogIdentity();
+    await endSession();
+    setUser(null);
+  };
+  const switchWorkspace = useCallback(
+    async (tenantSlug) => {
+      if (!user) return;
+      const workspace = user.workspaces.find(
+        (w) => w.tenant.slug === tenantSlug
+      );
+      if (workspace) {
+        persistActiveWorkspace(workspace);
+        try {
+          const prev = JSON.parse(
+            localStorage.getItem("pb_last_account") || "{}"
+          );
+          if (prev.email) {
+            localStorage.setItem(
+              "pb_last_account",
+              JSON.stringify({
+                ...prev,
+                businessName: workspace.tenant.businessName
+              })
+            );
+          }
+        } catch {
+        }
+        setUser(
+          (prev) => prev ? { ...prev, currentWorkspace: workspace } : null
+        );
+      }
+    },
+    [user]
+  );
+  const createWorkspace = useCallback(
+    async (input) => {
+      const {
+        businessName,
+        templateId,
+        currency,
+        intents,
+        isSolo,
+        category,
+        salesChannel,
+        address,
+        phone,
+        country,
+        logoFile
+      } = input;
+      const slug = input.slug || businessName.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, "");
+      let organizationId = user?.organizationId || "";
+      if (!organizationId) {
+        const orgs = await accountsApi.getMyOrganizations();
+        if (!orgs || orgs.length === 0) {
+          throw new Error("No organization found. Please sign up first.");
+        }
+        organizationId = orgs[0].id;
+        localStorage.setItem("organizationId", organizationId);
+        setUser((prev) => prev ? { ...prev, organizationId } : null);
+      }
+      const result = await apiFetch(
+        "/onboarding/provision",
+        {
+          method: "POST",
+          body: JSON.stringify({
+            organizationId,
+            businessName,
+            slug,
+            // Only sent when the merchant actually chose a look. Omitted, the
+            // API derives it from `intents` against the templates table it
+            // owns; named, an unknown id is rejected rather than replaced.
+            ...templateId && { templateId },
+            ...category && { category },
+            ...intents?.length && { intents },
+            ...isSolo != null && { isSolo },
+            ...currency && { currency },
+            // phone is part of the provision contract — the usecase stores it
+            // canonically on tenant.phone AND settings.phone, so send it here
+            // rather than patching settings after (which would land it in the
+            // wrong place and nothing would read it).
+            ...phone?.trim() && { phone: phone.trim() }
+          })
+        }
+      );
+      let tenant = result.tenant;
+      persistActiveWorkspace({ tenant, role: "owner" });
+      let logoUrl;
+      if (logoFile) {
+        try {
+          const uploaded = await uploadImage(logoFile);
+          logoUrl = uploaded.url;
+        } catch {
+        }
+      }
+      const settingsPatch = {};
+      if (salesChannel) settingsPatch.salesChannel = salesChannel;
+      if (intents?.length) settingsPatch.selectedIntents = intents;
+      if (country) settingsPatch.country = country;
+      if (address?.trim()) settingsPatch.contact = { address: address.trim() };
+      if (logoUrl) settingsPatch.logo = { url: logoUrl };
+      if (Object.keys(settingsPatch).length > 0) {
+        try {
+          await tenantApi.updateSettings(slug, settingsPatch);
+          tenant = {
+            ...tenant,
+            businessLogo: logoUrl ?? tenant.businessLogo,
+            settings: { ...tenant.settings ?? {}, ...settingsPatch }
+          };
+        } catch {
+        }
+      }
+      const workspace = { tenant, role: "owner" };
+      const updatedWorkspaces = [...user?.workspaces || [], workspace];
+      persistWorkspaceList(updatedWorkspaces);
+      setUser(
+        (prev) => prev ? {
+          ...prev,
+          workspaces: updatedWorkspaces,
+          currentWorkspace: workspace
+        } : null
+      );
+      persistActiveWorkspace(workspace);
+      return tenant;
+    },
+    [user]
+  );
+  const duplicateWorkspace = useCallback(
+    async (tenantId, businessName) => {
+      const result = await apiFetch(
+        `/onboarding/${tenantId}/duplicate`,
+        {
+          method: "POST",
+          body: JSON.stringify({ businessName })
+        }
+      );
+      const tenant = result.tenant;
+      const workspace = { tenant, role: "owner" };
+      const updatedWorkspaces = [...user?.workspaces || [], workspace];
+      persistWorkspaceList(updatedWorkspaces);
+      setUser(
+        (prev) => prev ? {
+          ...prev,
+          workspaces: updatedWorkspaces,
+          currentWorkspace: workspace
+        } : null
+      );
+      persistActiveWorkspace(workspace);
+      return tenant;
+    },
+    [user]
+  );
+  const deleteWorkspace = useCallback(
+    (tenantSlug) => {
+      const remaining = (user?.workspaces || []).filter(
+        (w) => w.tenant.slug !== tenantSlug
+      );
+      const next = remaining[0] || null;
+      persistActiveWorkspace(next);
+      if (next) {
+        persistWorkspaceList(remaining);
+      } else {
+        localStorage.removeItem("workspaces");
+        localStorage.removeItem("pb_workspaces_cache");
+      }
+      setUser(
+        (prev) => prev ? {
+          ...prev,
+          workspaces: remaining,
+          currentWorkspace: next
+        } : null
+      );
+    },
+    [user?.workspaces]
+  );
+  const refreshUser = useCallback(async () => {
+    if (!user) return;
+    try {
+      let userData = null;
+      {
+        try {
+          const freshAccount = await apiFetch(
+            "/accounts/me"
+          );
+          if (freshAccount) {
+            userData = freshAccount;
+            localStorage.setItem("pb_user", JSON.stringify(freshAccount));
+          }
+        } catch (err) {
+          const status = err?.status;
+          if (status === 401 || status === 403 || status === 404) {
+            clearStoredAuth();
+            if (typeof window !== "undefined") window.location.href = "/login";
+            return;
+          }
+          const pbUser = localStorage.getItem("pb_user");
+          if (pbUser) userData = JSON.parse(pbUser);
+        }
+      }
+      if (!userData) return;
+      const result = await loadWorkspaces();
+      const workspaces = result.workspaces;
+      const currentWorkspace = resolveActiveWorkspace(
+        workspaces,
+        result.fromApi
+      );
+      if (currentWorkspace) persistActiveWorkspace(currentWorkspace);
+      const storedOrgId = localStorage.getItem("organizationId");
+      const orgId = storedOrgId || currentWorkspace?.tenant?.organizationId || user.organizationId;
+      setUser(
+        (prev) => prev ? {
+          ...prev,
+          name: userData?.name || prev.name,
+          email: userData?.email || prev.email,
+          avatarUrl: userData?.avatarUrl || prev.avatarUrl,
+          // Absent from an older API response: keep what we had.
+          phone: userData && "phone" in userData ? userData.phone ?? null : prev.phone,
+          emailVerified: userData?.emailVerified ?? prev.emailVerified,
+          mfaEnabled: userData?.mfaEnabled ?? prev.mfaEnabled,
+          workspaces,
+          currentWorkspace,
+          organizationId: orgId
+        } : null
+      );
+    } catch {
+    }
+  }, [user, loadWorkspaces]);
+  const refreshTenant = useCallback(async () => {
+    const currentSlug = user?.currentWorkspace?.tenant?.slug;
+    const currentWorkspace = user?.currentWorkspace;
+    const workspaces = user?.workspaces;
+    if (!currentSlug || !currentWorkspace || !workspaces) return;
+    const freshTenant = await fetchTenant(currentSlug);
+    if (freshTenant) {
+      const updatedWorkspace = { ...currentWorkspace, tenant: freshTenant };
+      const updatedWorkspaces = workspaces.map(
+        (w) => w.tenant.slug === freshTenant.slug ? updatedWorkspace : w
+      );
+      persistActiveWorkspace(updatedWorkspace);
+      setUser(
+        (prev) => prev ? {
+          ...prev,
+          workspaces: updatedWorkspaces,
+          currentWorkspace: updatedWorkspace
+        } : null
+      );
+    }
+  }, [user?.currentWorkspace, user?.workspaces, fetchTenant]);
+  const retryConnection = useCallback(async () => {
+    setLoading(true);
+    setConnectionError(false);
+    const result = await loadWorkspaces();
+    const workspaces = result.workspaces;
+    if (result.fromApi && workspaces.length > 0) {
+      const currentWorkspace = resolveActiveWorkspace(workspaces, true);
+      persistActiveWorkspace(currentWorkspace);
+      setUser(
+        (prev) => prev ? {
+          ...prev,
+          workspaces,
+          currentWorkspace
+        } : null
+      );
+    } else if (!result.fromApi) {
+      setConnectionError(true);
+    }
+    setLoading(false);
+  }, [loadWorkspaces]);
+  return /* @__PURE__ */ jsx(
+    AuthContext.Provider,
+    {
+      value: {
+        user,
+        tenant: user?.currentWorkspace?.tenant ?? null,
+        workspaces: user?.workspaces ?? [],
+        loading,
+        connectionError,
+        retryConnection,
+        login,
+        loginWithGoogle,
+        loginWithCode,
+        logout,
+        refreshTenant,
+        refreshUser,
+        switchWorkspace,
+        createWorkspace,
+        duplicateWorkspace,
+        deleteWorkspace
+      },
+      children
+    }
+  );
+}
+function useAuth() {
+  const context = useContext(AuthContext);
+  if (context === void 0) {
+    throw new Error("useAuth must be used within an AuthProvider");
+  }
+  return context;
+}
+function useOptionalTenant() {
+  return useContext(AuthContext)?.tenant ?? null;
+}
+export {
+  AuthProvider,
+  useAuth,
+  useOptionalTenant
+};
+//# sourceMappingURL=auth-context.js.map