@fayz-ai/saas 0.1.6

package/dist/chunk-QGMDVLLW.cjs

@@ -0,0 +1,816 @@
+'use strict';
+
+var supabaseJs = require('@supabase/supabase-js');
+var core = require('@fayz-ai/core');
+var zustand = require('zustand');
+var React = require('react');
+var auth = require('@fayz-ai/auth');
+var jsxRuntime = require('react/jsx-runtime');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespace(React);
+
+// src/supabase/client.ts
+var CORE_SCHEMA = "saas_core";
+var _client = null;
+function createFayzSupabaseClient(url, anonKey) {
+  if (_client) return _client;
+  if (!url || !anonKey) {
+    throw new Error(
+      "[@fayz-ai/saas] Supabase URL and anon key are required. Pass supabaseUrl and supabaseAnonKey to createFayzApp."
+    );
+  }
+  _client = supabaseJs.createClient(url, anonKey, {
+    auth: { autoRefreshToken: true, persistSession: true }
+  });
+  core.setGlobalSupabaseClient(_client);
+  return _client;
+}
+function getFayzSupabaseClient() {
+  if (!_client) {
+    throw new Error(
+      "[@fayz-ai/saas] Supabase client not initialised. Call createFayzApp with supabaseUrl and supabaseAnonKey first."
+    );
+  }
+  return _client;
+}
+function getFayzSupabaseClientOptional() {
+  return _client;
+}
+function getCoreSchemaClient() {
+  return getFayzSupabaseClient().schema(CORE_SCHEMA);
+}
+
+// src/org/adapters/supabase.ts
+var inflightRequests = /* @__PURE__ */ new Map();
+function dedup(key, fn) {
+  const existing = inflightRequests.get(key);
+  if (existing) return existing;
+  const promise = fn().finally(() => {
+    inflightRequests.delete(key);
+  });
+  inflightRequests.set(key, promise);
+  return promise;
+}
+function slugify(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+function capitalize(s) {
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+function mapTenantToOrg(row) {
+  return {
+    id: row["id"],
+    name: row["name"],
+    slug: row["slug"],
+    logoUrl: row["logo_url"] ?? void 0,
+    verticalId: row["vertical_id"] ?? void 0,
+    plan: row["plan"] ?? void 0,
+    settings: row["settings"] ?? void 0,
+    createdAt: row["created_at"],
+    updatedAt: row["updated_at"]
+  };
+}
+function mapMemberRow(row) {
+  const profile = row["profile"] ?? {};
+  return {
+    id: row["id"],
+    userId: row["user_id"],
+    orgId: row["tenant_id"],
+    profileId: row["role"],
+    profileName: capitalize(row["role"]),
+    user: {
+      id: row["user_id"],
+      email: profile["email"] ?? "",
+      fullName: profile["full_name"] ?? "",
+      avatarUrl: profile["avatar_url"] ?? void 0
+    },
+    joinedAt: row["joined_at"]
+  };
+}
+function mapLocationRow(row) {
+  return {
+    id: row["id"],
+    tenantId: row["tenant_id"],
+    name: row["name"],
+    address: row["address"] ?? void 0,
+    city: row["city"] ?? void 0,
+    state: row["state"] ?? void 0,
+    country: row["country"] ?? void 0,
+    phone: row["phone"] ?? void 0,
+    isHeadquarters: row["is_headquarters"] ?? false,
+    isActive: row["is_active"] ?? true,
+    createdAt: row["created_at"],
+    updatedAt: row["updated_at"]
+  };
+}
+function mapInviteRow(row) {
+  return {
+    id: row["id"],
+    orgId: row["tenant_id"],
+    email: row["email"],
+    profileId: row["role"],
+    profileName: capitalize(row["role"]),
+    invitedBy: row["invited_by"],
+    token: row["token"],
+    status: row["status"] ?? "pending",
+    createdAt: row["created_at"],
+    expiresAt: row["expires_at"]
+  };
+}
+var SYSTEM_ROLES = ["owner", "admin", "manager", "staff", "viewer"];
+function buildPermissionProfiles(permissions, rolePerms, overrides) {
+  const overrideMap = /* @__PURE__ */ new Map();
+  for (const o of overrides) {
+    overrideMap.set(`${o.role}:${o.permission_id}`, o.granted);
+  }
+  const rolePermMap = /* @__PURE__ */ new Map();
+  for (const role of SYSTEM_ROLES) {
+    rolePermMap.set(role, /* @__PURE__ */ new Set());
+  }
+  for (const p of permissions) {
+    rolePermMap.get("owner").add(p.id);
+  }
+  for (const rp of rolePerms) {
+    rolePermMap.get(rp.role)?.add(rp.permission_id);
+  }
+  for (const [key, granted] of overrideMap) {
+    const colonIdx = key.indexOf(":");
+    const role = key.slice(0, colonIdx);
+    const permId = key.slice(colonIdx + 1);
+    const perms = rolePermMap.get(role);
+    if (!perms) continue;
+    if (granted) {
+      perms.add(permId);
+    } else {
+      perms.delete(permId);
+    }
+  }
+  const actionMap = {
+    read: "read",
+    create: "write",
+    update: "write",
+    manage: "manage",
+    delete: "delete",
+    configure: "manage",
+    invite: "write"
+  };
+  return SYSTEM_ROLES.map((role) => {
+    const permIds = rolePermMap.get(role);
+    const features = {};
+    for (const permId of permIds) {
+      const dotIdx = permId.indexOf(".");
+      if (dotIdx === -1) continue;
+      const category = permId.slice(0, dotIdx);
+      const action = permId.slice(dotIdx + 1);
+      const mappedAction = actionMap[action];
+      if (!mappedAction) continue;
+      if (!features[category]) features[category] = [];
+      if (!features[category].includes(mappedAction)) {
+        features[category].push(mappedAction);
+      }
+    }
+    return {
+      id: role,
+      name: capitalize(role),
+      isSystem: true,
+      grants: features
+    };
+  });
+}
+function createSupabaseOrgAdapter(config) {
+  const schema = config?.coreSchema ?? CORE_SCHEMA;
+  function supabase() {
+    return getFayzSupabaseClient();
+  }
+  function core() {
+    return supabase().schema(schema);
+  }
+  return {
+    async listUserOrgs(userId) {
+      return dedup(`listUserOrgs:${userId}`, async () => {
+        const { data, error } = await core().from("tenant_members").select("tenant_id, role, tenant:tenants(id, name, slug, logo_url)").eq("user_id", userId);
+        if (error) throw error;
+        return (data ?? []).map((row) => ({
+          orgId: row["tenant_id"],
+          orgName: row["tenant"]?.["name"] ?? "",
+          orgSlug: row["tenant"]?.["slug"] ?? "",
+          orgLogoUrl: row["tenant"]?.["logo_url"] ?? void 0,
+          profileId: row["role"],
+          profileName: capitalize(row["role"])
+        }));
+      });
+    },
+    async getOrg(orgId) {
+      const { data, error } = await core().from("tenants").select("*").eq("id", orgId).single();
+      if (error) throw error;
+      return mapTenantToOrg(data);
+    },
+    async createOrg(name, userId, options) {
+      const { data: tenant, error } = await supabase().rpc("create_tenant_with_owner", {
+        p_name: name,
+        p_slug: slugify(name),
+        p_user_id: userId,
+        p_vertical_id: options?.verticalId ?? null,
+        p_plan: "free",
+        p_settings: {
+          timezone: options?.timezone ?? "America/Sao_Paulo",
+          currency: options?.currency ?? "BRL",
+          locale: options?.locale ?? "pt-BR",
+          teamSize: options?.teamSize ?? void 0,
+          branding: {}
+        }
+      });
+      if (error) throw error;
+      return mapTenantToOrg(tenant);
+    },
+    async updateOrg(orgId, updates) {
+      const row = {};
+      if (updates.name !== void 0) row["name"] = updates.name;
+      if (updates.slug !== void 0) row["slug"] = updates.slug;
+      if (updates.logoUrl !== void 0) row["logo_url"] = updates.logoUrl;
+      if (updates.verticalId !== void 0) row["vertical_id"] = updates.verticalId;
+      if (updates.plan !== void 0) row["plan"] = updates.plan;
+      if (updates.settings !== void 0) row["settings"] = updates.settings;
+      const { data, error } = await core().from("tenants").update(row).eq("id", orgId).select().single();
+      if (error) throw error;
+      return mapTenantToOrg(data);
+    },
+    async listMembers(orgId) {
+      const { data, error } = await core().from("tenant_members").select("*").eq("tenant_id", orgId);
+      if (error) throw error;
+      const userIds = (data ?? []).map((m) => m["user_id"]);
+      const { data: profiles } = userIds.length > 0 ? await core().from("profiles").select("id, full_name, avatar_url, email").in("id", userIds) : { data: [] };
+      const profileMap = new Map(
+        (profiles ?? []).map((p) => [p["id"], p])
+      );
+      return (data ?? []).map((row) => {
+        const profile = profileMap.get(row["user_id"]) ?? {};
+        return mapMemberRow({ ...row, profile });
+      });
+    },
+    async updateMemberProfile(orgId, memberId, profileId) {
+      const { error } = await core().from("tenant_members").update({ role: profileId }).eq("id", memberId).eq("tenant_id", orgId);
+      if (error) throw error;
+    },
+    async removeMember(orgId, memberId) {
+      const { error } = await core().from("tenant_members").delete().eq("id", memberId).eq("tenant_id", orgId);
+      if (error) throw error;
+    },
+    async listProfiles(orgId) {
+      const [permsResult, rolePermsResult, overridesResult] = await Promise.all([
+        core().from("permissions").select("id, category"),
+        core().from("role_permissions").select("role, permission_id"),
+        core().from("tenant_role_overrides").select("role, permission_id, granted").eq("tenant_id", orgId)
+      ]);
+      if (permsResult.error) throw permsResult.error;
+      if (rolePermsResult.error) throw rolePermsResult.error;
+      if (overridesResult.error) throw overridesResult.error;
+      return buildPermissionProfiles(
+        permsResult.data ?? [],
+        rolePermsResult.data ?? [],
+        overridesResult.data ?? []
+      );
+    },
+    async createProfile(_orgId, _profile) {
+      throw new Error(
+        "Custom roles are not supported. Roles are system-defined (owner, admin, manager, staff, viewer)."
+      );
+    },
+    async updateProfile(orgId, profileId, data) {
+      if (data.grants) {
+        await core().from("tenant_role_overrides").delete().eq("tenant_id", orgId).eq("role", profileId);
+        const overrides = [];
+        for (const [category, actions] of Object.entries(data.grants)) {
+          for (const action of actions) {
+            const dbActionMap = {
+              read: "read",
+              write: "create",
+              manage: "manage",
+              delete: "delete"
+            };
+            const dbAction = dbActionMap[action] ?? action;
+            overrides.push({
+              tenant_id: orgId,
+              role: profileId,
+              permission_id: `${category}.${dbAction}`,
+              granted: true
+            });
+          }
+        }
+        if (overrides.length > 0) {
+          const { error } = await core().from("tenant_role_overrides").insert(overrides);
+          if (error) throw error;
+        }
+      }
+      const profiles = await this.listProfiles(orgId);
+      const updated = profiles.find((p) => p.id === profileId);
+      if (!updated) throw new Error(`Profile not found: ${profileId}`);
+      return updated;
+    },
+    async deleteProfile(_orgId, _profileId) {
+      throw new Error("System roles cannot be deleted.");
+    },
+    async listInvites(orgId) {
+      const { data, error } = await core().from("invitations").select("*").eq("tenant_id", orgId).order("created_at", { ascending: false });
+      if (error) throw error;
+      return (data ?? []).map(mapInviteRow);
+    },
+    async createInvite(orgId, email, profileId, invitedBy) {
+      const { data, error } = await core().from("invitations").insert({
+        tenant_id: orgId,
+        email,
+        role: profileId,
+        invited_by: invitedBy
+      }).select().single();
+      if (error) throw error;
+      return mapInviteRow(data);
+    },
+    async bulkInvite(orgId, emails, profileId, invitedBy) {
+      const rows = emails.map((email) => ({
+        tenant_id: orgId,
+        email,
+        role: profileId,
+        invited_by: invitedBy
+      }));
+      const { data, error } = await core().from("invitations").insert(rows).select();
+      if (error) throw error;
+      return (data ?? []).map(mapInviteRow);
+    },
+    async revokeInvite(orgId, inviteId) {
+      const { error } = await core().from("invitations").update({ status: "revoked" }).eq("id", inviteId).eq("tenant_id", orgId);
+      if (error) throw error;
+    },
+    async resendInvite(orgId, inviteId) {
+      const { data, error } = await core().from("invitations").update({
+        status: "pending",
+        expires_at: new Date(Date.now() + 7 * 24 * 60 * 60 * 1e3).toISOString()
+      }).eq("id", inviteId).eq("tenant_id", orgId).select().single();
+      if (error) throw error;
+      return mapInviteRow(data);
+    },
+    async listLocations(orgId) {
+      const { data, error } = await core().from("locations").select("*").eq("tenant_id", orgId).order("is_headquarters", { ascending: false }).order("name");
+      if (error) throw error;
+      return (data ?? []).map(mapLocationRow);
+    },
+    async createLocation(orgId, input) {
+      const { data, error } = await core().from("locations").insert({
+        tenant_id: orgId,
+        name: input.name,
+        address: input.address ?? null,
+        city: input.city ?? null,
+        state: input.state ?? null,
+        country: input.country ?? "BR",
+        phone: input.phone ?? null,
+        is_headquarters: input.isHeadquarters ?? false
+      }).select().single();
+      if (error) throw error;
+      return mapLocationRow(data);
+    }
+  };
+}
+
+// src/org/adapters/mock.ts
+var STORAGE_KEY = "fayz:mock-orgs";
+function getStored() {
+  try {
+    if (typeof localStorage === "undefined") return empty();
+    const raw = localStorage.getItem(STORAGE_KEY);
+    if (raw) return JSON.parse(raw);
+  } catch {
+  }
+  return empty();
+}
+function empty() {
+  return { orgs: [], members: [], profiles: {}, invites: {}, userOrgMap: {} };
+}
+function setStored(data) {
+  try {
+    if (typeof localStorage === "undefined") return;
+    localStorage.setItem(STORAGE_KEY, JSON.stringify(data));
+  } catch {
+  }
+}
+function slugify2(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+function createMockOrgAdapter(defaultProfiles) {
+  function seedOrgForUser(userId, userName) {
+    const data = getStored();
+    if (data.userOrgMap[userId]?.length) return data;
+    const orgId = crypto.randomUUID();
+    const memberId = crypto.randomUUID();
+    const firstProfile = defaultProfiles?.[0];
+    const org = {
+      id: orgId,
+      name: "My Organization",
+      slug: "my-organization",
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const member = {
+      id: memberId,
+      userId,
+      orgId,
+      profileId: firstProfile?.id ?? "owner",
+      profileName: firstProfile?.name ?? "Owner",
+      user: {
+        id: userId,
+        email: "user@example.com",
+        fullName: "Current User"
+      },
+      joinedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    data.orgs.push(org);
+    data.members.push(member);
+    data.userOrgMap[userId] = [orgId];
+    if (defaultProfiles) {
+      data.profiles[orgId] = [...defaultProfiles];
+    }
+    data.invites[orgId] = [];
+    setStored(data);
+    return data;
+  }
+  return {
+    async listUserOrgs(userId) {
+      const data = seedOrgForUser(userId);
+      const orgIds = data.userOrgMap[userId] ?? [];
+      return orgIds.map((orgId) => {
+        const org = data.orgs.find((o) => o.id === orgId);
+        const member = data.members.find((m) => m.orgId === orgId && m.userId === userId);
+        return {
+          orgId,
+          orgName: org.name,
+          orgSlug: org.slug,
+          orgLogoUrl: org.logoUrl,
+          profileId: member?.profileId ?? "owner",
+          profileName: member?.profileName ?? "Owner"
+        };
+      });
+    },
+    async getOrg(orgId) {
+      const data = getStored();
+      const org = data.orgs.find((o) => o.id === orgId);
+      if (!org) throw new Error(`Org not found: ${orgId}`);
+      return org;
+    },
+    async createOrg(name, userId, options) {
+      const data = getStored();
+      const orgId = crypto.randomUUID();
+      const firstProfile = defaultProfiles?.[0];
+      const org = {
+        id: orgId,
+        name,
+        slug: slugify2(name),
+        verticalId: options?.verticalId,
+        plan: "free",
+        settings: {
+          timezone: options?.timezone ?? "America/Sao_Paulo",
+          currency: options?.currency ?? "BRL",
+          locale: options?.locale ?? "pt-BR"
+        },
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      const member = {
+        id: crypto.randomUUID(),
+        userId,
+        orgId,
+        profileId: firstProfile?.id ?? "owner",
+        profileName: firstProfile?.name ?? "Owner",
+        user: {
+          id: userId,
+          email: "user@example.com",
+          fullName: "Current User"
+        },
+        joinedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      data.orgs.push(org);
+      data.members.push(member);
+      if (!data.userOrgMap[userId]) data.userOrgMap[userId] = [];
+      data.userOrgMap[userId].push(orgId);
+      if (defaultProfiles) {
+        data.profiles[orgId] = [...defaultProfiles];
+      }
+      data.invites[orgId] = [];
+      setStored(data);
+      return org;
+    },
+    async updateOrg(orgId, updates) {
+      const data = getStored();
+      const idx = data.orgs.findIndex((o) => o.id === orgId);
+      if (idx === -1) throw new Error(`Org not found: ${orgId}`);
+      data.orgs[idx] = { ...data.orgs[idx], ...updates, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+      setStored(data);
+      return data.orgs[idx];
+    },
+    async listMembers(orgId) {
+      const data = getStored();
+      return data.members.filter((m) => m.orgId === orgId);
+    },
+    async updateMemberProfile(orgId, memberId, profileId) {
+      const data = getStored();
+      const member = data.members.find((m) => m.id === memberId && m.orgId === orgId);
+      if (!member) throw new Error(`Member not found: ${memberId}`);
+      const profiles = data.profiles[orgId] ?? [];
+      const profile = profiles.find((p) => p.id === profileId);
+      member.profileId = profileId;
+      member.profileName = profile?.name ?? profileId;
+      setStored(data);
+    },
+    async removeMember(orgId, memberId) {
+      const data = getStored();
+      const memberIdx = data.members.findIndex((m) => m.id === memberId && m.orgId === orgId);
+      if (memberIdx === -1) return;
+      const member = data.members[memberIdx];
+      data.members.splice(memberIdx, 1);
+      const userOrgs = data.userOrgMap[member.userId];
+      if (userOrgs) {
+        const orgIdx = userOrgs.indexOf(orgId);
+        if (orgIdx !== -1) userOrgs.splice(orgIdx, 1);
+      }
+      setStored(data);
+    },
+    async listProfiles(orgId) {
+      const data = getStored();
+      return data.profiles[orgId] ?? defaultProfiles ?? [];
+    },
+    async createProfile(orgId, profile) {
+      const data = getStored();
+      const newProfile = {
+        ...profile,
+        id: crypto.randomUUID(),
+        isSystem: false
+      };
+      if (!data.profiles[orgId]) {
+        data.profiles[orgId] = defaultProfiles ? [...defaultProfiles] : [];
+      }
+      data.profiles[orgId].push(newProfile);
+      setStored(data);
+      return newProfile;
+    },
+    async updateProfile(orgId, profileId, updates) {
+      const data = getStored();
+      const profiles = data.profiles[orgId] ?? [];
+      const idx = profiles.findIndex((p) => p.id === profileId);
+      if (idx === -1) throw new Error(`Profile not found: ${profileId}`);
+      profiles[idx] = { ...profiles[idx], ...updates };
+      data.profiles[orgId] = profiles;
+      setStored(data);
+      return profiles[idx];
+    },
+    async deleteProfile(orgId, profileId) {
+      const data = getStored();
+      const profiles = data.profiles[orgId] ?? [];
+      const profile = profiles.find((p) => p.id === profileId);
+      if (profile?.isSystem) throw new Error("Cannot delete system profile");
+      data.profiles[orgId] = profiles.filter((p) => p.id !== profileId);
+      setStored(data);
+    },
+    async listInvites(orgId) {
+      const data = getStored();
+      return data.invites[orgId] ?? [];
+    },
+    async createInvite(orgId, email, profileId, invitedBy) {
+      const data = getStored();
+      const profiles = data.profiles[orgId] ?? defaultProfiles ?? [];
+      const profile = profiles.find((p) => p.id === profileId);
+      const invite = {
+        id: crypto.randomUUID(),
+        orgId,
+        email,
+        profileId,
+        profileName: profile?.name ?? profileId,
+        invitedBy,
+        token: crypto.randomUUID(),
+        status: "pending",
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        expiresAt: new Date(Date.now() + 7 * 24 * 60 * 60 * 1e3).toISOString()
+      };
+      if (!data.invites[orgId]) data.invites[orgId] = [];
+      data.invites[orgId].push(invite);
+      setStored(data);
+      return invite;
+    },
+    async bulkInvite(orgId, emails, profileId, invitedBy) {
+      const results = [];
+      for (const email of emails) {
+        results.push(await this.createInvite(orgId, email, profileId, invitedBy));
+      }
+      return results;
+    },
+    async revokeInvite(orgId, inviteId) {
+      const data = getStored();
+      const invites = data.invites[orgId] ?? [];
+      const invite = invites.find((i) => i.id === inviteId);
+      if (invite) {
+        invite.status = "expired";
+        setStored(data);
+      }
+    },
+    async resendInvite(orgId, inviteId) {
+      const data = getStored();
+      const invites = data.invites[orgId] ?? [];
+      const invite = invites.find((i) => i.id === inviteId);
+      if (!invite) throw new Error(`Invite not found: ${inviteId}`);
+      invite.expiresAt = new Date(Date.now() + 7 * 24 * 60 * 60 * 1e3).toISOString();
+      invite.status = "pending";
+      setStored(data);
+      return invite;
+    },
+    async listLocations(_orgId) {
+      return [];
+    },
+    async createLocation(orgId, input) {
+      return {
+        id: crypto.randomUUID(),
+        tenantId: orgId,
+        name: input.name,
+        address: input.address,
+        city: input.city,
+        state: input.state,
+        country: input.country ?? "BR",
+        phone: input.phone,
+        isHeadquarters: input.isHeadquarters ?? false,
+        isActive: true,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    }
+  };
+}
+var STORAGE_KEY2 = "fayz:current-org";
+function getPersistedOrgId() {
+  try {
+    if (typeof localStorage === "undefined") return null;
+    return localStorage.getItem(STORAGE_KEY2);
+  } catch {
+    return null;
+  }
+}
+function persistOrgId(orgId) {
+  try {
+    if (typeof localStorage === "undefined") return;
+    if (orgId) {
+      localStorage.setItem(STORAGE_KEY2, orgId);
+    } else {
+      localStorage.removeItem(STORAGE_KEY2);
+    }
+  } catch {
+  }
+}
+var useOrganizationStore = zustand.create((set) => ({
+  currentOrg: null,
+  userOrgs: [],
+  members: [],
+  loading: false,
+  setCurrentOrg: (org) => {
+    core.setActiveTenantId(org?.id);
+    persistOrgId(org?.id ?? null);
+    set({ currentOrg: org });
+  },
+  setUserOrgs: (orgs) => set({ userOrgs: orgs }),
+  setMembers: (members) => set({ members }),
+  setLoading: (loading) => set({ loading }),
+  reset: () => {
+    core.setActiveTenantId(void 0);
+    persistOrgId(null);
+    set({ currentOrg: null, userOrgs: [], members: [], loading: false });
+  }
+}));
+var OrgAdapterContext = React__namespace.createContext(null);
+function useOrgAdapter() {
+  const adapter = React__namespace.useContext(OrgAdapterContext);
+  if (!adapter) {
+    throw new Error("useOrgAdapter must be used within an <OrgProvider>");
+  }
+  return adapter;
+}
+function useOrgAdapterOptional() {
+  return React__namespace.useContext(OrgAdapterContext);
+}
+var TenantContext = React__namespace.createContext(null);
+function useTenant() {
+  const ctx = React__namespace.useContext(TenantContext);
+  if (!ctx) {
+    throw new Error("useTenant must be used inside <OrgProvider>");
+  }
+  return ctx;
+}
+function useTenantOptional() {
+  return React__namespace.useContext(TenantContext);
+}
+function OrgProvider({ adapter, autoCreate = false, children }) {
+  const { user } = auth.useAuthStore();
+  const { currentOrg, userOrgs, loading, setCurrentOrg, setUserOrgs, setLoading, reset } = useOrganizationStore();
+  const adapterRef = React__namespace.useRef(adapter);
+  adapterRef.current = adapter;
+  React__namespace.useEffect(() => {
+    if (!user) {
+      reset();
+      return;
+    }
+    let cancelled = false;
+    async function loadOrgs() {
+      setLoading(true);
+      try {
+        const memberships = await adapterRef.current.listUserOrgs(user.id);
+        if (cancelled) return;
+        setUserOrgs(memberships);
+        if (memberships.length === 0 && autoCreate) {
+          const newOrg = await adapterRef.current.createOrg(
+            user.fullName ? `${user.fullName}'s Organization` : "My Organization",
+            user.id
+          );
+          if (!cancelled) {
+            setUserOrgs([
+              {
+                orgId: newOrg.id,
+                orgName: newOrg.name,
+                orgSlug: newOrg.slug,
+                profileId: "owner",
+                profileName: "Owner"
+              }
+            ]);
+            setCurrentOrg(newOrg);
+          }
+          return;
+        }
+        const persistedId = getPersistedOrgId();
+        const target = memberships.find((m) => m.orgId === persistedId) ?? memberships[0];
+        if (target && !cancelled) {
+          const org = await adapterRef.current.getOrg(target.orgId);
+          if (!cancelled) setCurrentOrg(org);
+        }
+      } finally {
+        if (!cancelled) setLoading(false);
+      }
+    }
+    void loadOrgs();
+    return () => {
+      cancelled = true;
+    };
+  }, [user?.id]);
+  async function switchOrg(orgId) {
+    setLoading(true);
+    try {
+      const org = await adapterRef.current.getOrg(orgId);
+      setCurrentOrg(org);
+    } finally {
+      setLoading(false);
+    }
+  }
+  async function refreshOrg() {
+    if (!currentOrg) return;
+    setLoading(true);
+    try {
+      const org = await adapterRef.current.getOrg(currentOrg.id);
+      setCurrentOrg(org);
+    } finally {
+      setLoading(false);
+    }
+  }
+  const tenantValue = {
+    org: currentOrg,
+    userOrgs,
+    loading,
+    switchOrg,
+    refreshOrg
+  };
+  return /* @__PURE__ */ jsxRuntime.jsx(OrgAdapterContext.Provider, { value: adapter, children: /* @__PURE__ */ jsxRuntime.jsx(TenantContext.Provider, { value: tenantValue, children }) });
+}
+
+exports.CORE_SCHEMA = CORE_SCHEMA;
+exports.OrgProvider = OrgProvider;
+exports.createFayzSupabaseClient = createFayzSupabaseClient;
+exports.createMockOrgAdapter = createMockOrgAdapter;
+exports.createSupabaseOrgAdapter = createSupabaseOrgAdapter;
+exports.getCoreSchemaClient = getCoreSchemaClient;
+exports.getFayzSupabaseClient = getFayzSupabaseClient;
+exports.getFayzSupabaseClientOptional = getFayzSupabaseClientOptional;
+exports.getPersistedOrgId = getPersistedOrgId;
+exports.useOrgAdapter = useOrgAdapter;
+exports.useOrgAdapterOptional = useOrgAdapterOptional;
+exports.useOrganizationStore = useOrganizationStore;
+exports.useTenant = useTenant;
+exports.useTenantOptional = useTenantOptional;
+//# sourceMappingURL=chunk-QGMDVLLW.cjs.map
+//# sourceMappingURL=chunk-QGMDVLLW.cjs.map