@fayz-ai/admin 0.10.0

package/dist/chunk-TNTZHUL6.js

@@ -0,0 +1,817 @@
+import { createClient } from '@supabase/supabase-js';
+import { setGlobalSupabaseClient } from '@fayz-ai/core';
+
+// src/data/client.ts
+var _client = null;
+function createFayzSupabaseClient(url, anonKey) {
+  if (_client) return _client;
+  if (!url || !anonKey) {
+    throw new Error(
+      "[@fayz-ai/admin] Supabase URL and anon key are required. Pass supabaseUrl and supabaseAnonKey to createFayzApp."
+    );
+  }
+  _client = createClient(url, anonKey, {
+    auth: { autoRefreshToken: true, persistSession: true }
+  });
+  setGlobalSupabaseClient(_client);
+  return _client;
+}
+function getFayzSupabaseClient() {
+  if (!_client) {
+    throw new Error(
+      "[@fayz-ai/admin] Supabase client not initialised. Call createFayzApp with supabaseUrl and supabaseAnonKey first."
+    );
+  }
+  return _client;
+}
+function getFayzSupabaseClientOptional() {
+  return _client;
+}
+
+// src/org/team-rows.ts
+var capitalize = (s) => s ? s.charAt(0).toUpperCase() + s.slice(1) : s;
+function loginName(profile, session) {
+  const candidates = [profile?.full_name, session?.fullName, profile?.email, session?.email];
+  for (const candidate of candidates) {
+    const value = candidate?.trim();
+    if (value) return value.includes("@") ? value.split("@")[0] : value;
+  }
+  return "";
+}
+function buildTeamRows(people, members, profiles, currentUser) {
+  const personIds = new Set(people.map((p) => p.id));
+  const byPerson = /* @__PURE__ */ new Map();
+  const unlinked = [];
+  for (const m of members) {
+    if (m.person_id && personIds.has(m.person_id)) byPerson.set(m.person_id, m);
+    else unlinked.push(m);
+  }
+  const profileById = new Map(profiles.map((p) => [p.id, p]));
+  const toMembership = (m) => ({
+    memberId: m.id,
+    userId: m.user_id,
+    profileId: m.role ?? "",
+    profileName: capitalize(m.role ?? ""),
+    joinedAt: m.created_at ?? void 0
+  });
+  const loginRows = unlinked.map((m) => {
+    const profile = profileById.get(m.user_id);
+    const session = currentUser && currentUser.id === m.user_id ? currentUser : void 0;
+    return {
+      name: loginName(profile, session),
+      email: profile?.email ?? session?.email ?? void 0,
+      avatarUrl: profile?.avatar_url ?? void 0,
+      isActive: true,
+      membership: toMembership(m)
+    };
+  });
+  const personRows = people.map((p) => {
+    const m = byPerson.get(p.id);
+    return {
+      personId: p.id,
+      name: p.name ?? "",
+      kind: p.kind ?? void 0,
+      email: p.email ?? void 0,
+      avatarUrl: p.avatar_url ?? void 0,
+      isActive: p.is_active ?? true,
+      membership: m ? toMembership(m) : void 0
+    };
+  });
+  return [...loginRows, ...personRows];
+}
+
+// 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 capitalize2(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: capitalize2(row["role"]),
+    user: {
+      id: row["user_id"],
+      email: profile["email"] ?? "",
+      fullName: profile["full_name"] ?? "",
+      avatarUrl: profile["avatar_url"] ?? void 0
+    },
+    // tenant_members has no `joined_at` column — it's `created_at`.
+    joinedAt: row["joined_at"] ?? row["created_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: capitalize2(row["role"]),
+    invitedBy: row["invited_by"],
+    token: row["token"],
+    status: row["status"] ?? "pending",
+    createdAt: row["created_at"],
+    expiresAt: row["expires_at"]
+  };
+}
+var DB_ACTION = {
+  read: "read",
+  create: "create",
+  edit: "update",
+  write: "create",
+  manage: "manage",
+  delete: "delete"
+};
+function slugifyRole(name) {
+  return name.toLowerCase().normalize("NFD").replace(/[\u0300-\u036f]/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "role";
+}
+var DEFAULT_ROLES = [
+  { id: "owner", name: "Owner" },
+  { id: "admin", name: "Admin" },
+  { id: "manager", name: "Manager" },
+  { id: "staff", name: "Staff" },
+  { id: "viewer", name: "Viewer" }
+];
+var SYSTEM_PERMISSION_MAP = {
+  "team.read": "manage_team",
+  "team.invite": "manage_team",
+  "team.manage": "manage_team",
+  "team.manage_roles": "manage_permissions",
+  "billing.read": "manage_billing",
+  "billing.manage": "manage_billing",
+  "settings.read": "manage_settings",
+  "settings.update": "manage_settings"
+};
+var ALL_SYSTEM_PERMISSIONS = ["manage_team", "manage_billing", "manage_settings", "manage_permissions"];
+function buildPermissionProfiles(roles, 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 r of roles) {
+    rolePermMap.set(r.id, /* @__PURE__ */ new Set());
+  }
+  if (rolePermMap.has("owner")) {
+    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: "create",
+    update: "edit",
+    manage: "edit",
+    delete: "delete",
+    configure: "edit",
+    invite: "create"
+  };
+  return roles.map(({ id: role, name, description, isSystem }) => {
+    const permIds = rolePermMap.get(role);
+    const features = {};
+    for (const permId of permIds) {
+      const dotIdx = permId.lastIndexOf(".");
+      if (dotIdx <= 0) 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);
+      }
+    }
+    const systemPermissions = [];
+    const source = role === "owner" ? ALL_SYSTEM_PERMISSIONS : [...permIds].map((id) => SYSTEM_PERMISSION_MAP[id]);
+    for (const sp of source) {
+      if (sp && !systemPermissions.includes(sp)) systemPermissions.push(sp);
+    }
+    return {
+      id: role,
+      name: name || capitalize2(role),
+      description,
+      isSystem: isSystem ?? true,
+      systemPermissions,
+      grants: features
+    };
+  });
+}
+function createSupabaseOrgAdapter(config) {
+  const roles = config?.roles && config.roles.length > 0 ? config.roles : DEFAULT_ROLES;
+  const authAdapter = config?.authAdapter;
+  const originBase = config?.siteUrl?.replace(/\/+$/, "") ?? (typeof window !== "undefined" ? window.location.origin : void 0);
+  const inviteRedirectTo = originBase ? `${originBase}/` : void 0;
+  function supabase() {
+    return getFayzSupabaseClient();
+  }
+  function core() {
+    return supabase();
+  }
+  return {
+    async acceptPendingInvites() {
+      const { data, error } = await supabase().rpc("accept_pending_invitations");
+      if (error) {
+        console.warn("[org] accept_pending_invitations failed:", error.message);
+        return 0;
+      }
+      return typeof data === "number" ? data : 0;
+    },
+    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: capitalize2(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 });
+      });
+    },
+    // Person-first team list: people of `personKinds` are the roster and
+    // `tenant_members` (login + role) is the overlay linked by person_id — plus
+    // every membership that links to no listed person, so an account with access
+    // is never missing from its own Team screen. See buildTeamRows.
+    async listTeam(orgId, personKinds) {
+      if (!personKinds || personKinds.length === 0) return [];
+      const [peopleResult, membersResult] = await Promise.all([
+        core().from("people").select("id, name, kind, email, avatar_url, is_active").eq("tenant_id", orgId).in("kind", personKinds),
+        core().from("tenant_members").select("id, user_id, role, person_id, created_at").eq("tenant_id", orgId)
+      ]);
+      if (peopleResult.error) throw peopleResult.error;
+      const people = peopleResult.data ?? [];
+      const members = membersResult.data ?? [];
+      const userIds = members.map((m) => m.user_id).filter(Boolean);
+      const [profilesResult, sessionResult] = await Promise.all([
+        userIds.length > 0 ? core().from("profiles").select("id, full_name, avatar_url, email").in("id", userIds) : Promise.resolve({ data: [] }),
+        core().auth.getSession()
+      ]);
+      const sessionUser = sessionResult?.data?.session?.user;
+      const currentUser = sessionUser ? {
+        id: sessionUser.id,
+        email: sessionUser.email,
+        fullName: sessionUser.user_metadata?.["full_name"] ?? void 0
+      } : null;
+      return buildTeamRows(people, members, profilesResult.data ?? [], currentUser);
+    },
+    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, customResult] = 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),
+        // Custom roles the tenant created by duplicating a system role. Tolerate a
+        // missing table (pre-seed) — just show the system roles in that case.
+        core().from("tenant_roles").select("key, name, description").eq("tenant_id", orgId)
+      ]);
+      if (permsResult.error) throw permsResult.error;
+      if (rolePermsResult.error) throw rolePermsResult.error;
+      if (overridesResult.error) throw overridesResult.error;
+      const systemRoles = roles.map((r) => ({ ...r, isSystem: true }));
+      const customRoles = customResult.error ? [] : (customResult.data ?? []).map((r) => ({
+        id: r.key,
+        name: r.name,
+        description: r.description ?? void 0,
+        isSystem: false
+      }));
+      return buildPermissionProfiles(
+        [...systemRoles, ...customRoles],
+        permsResult.data ?? [],
+        rolePermsResult.data ?? [],
+        overridesResult.data ?? []
+      );
+    },
+    async createProfile(orgId, profile) {
+      const existing = new Set(
+        ((await core().from("tenant_roles").select("key").eq("tenant_id", orgId)).data ?? []).map((r) => r.key)
+      );
+      let key = slugifyRole(profile.name);
+      if (existing.has(key) || roles.some((r) => r.id === key)) {
+        let n = 2;
+        while (existing.has(`${key}-${n}`) || roles.some((r) => r.id === `${key}-${n}`)) n++;
+        key = `${key}-${n}`;
+      }
+      const insertRole = await core().from("tenant_roles").insert({ tenant_id: orgId, key, name: profile.name, description: profile.description ?? null });
+      if (insertRole.error) throw insertRole.error;
+      const overrides = Object.entries(profile.grants ?? {}).flatMap(
+        ([category, actions]) => actions.map((action) => ({
+          tenant_id: orgId,
+          role: key,
+          permission_id: `${category}.${DB_ACTION[action] ?? action}`,
+          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);
+      return profiles.find((p) => p.id === key) ?? {
+        id: key,
+        name: profile.name,
+        description: profile.description,
+        isSystem: false,
+        systemPermissions: profile.systemPermissions ?? [],
+        grants: profile.grants ?? {}
+      };
+    },
+    async updateProfile(orgId, profileId, data) {
+      if (data.name !== void 0 || data.description !== void 0) {
+        const patch = {};
+        if (data.name !== void 0) patch.name = data.name;
+        if (data.description !== void 0) patch.description = data.description ?? null;
+        const { error } = await core().from("tenant_roles").update(patch).eq("tenant_id", orgId).eq("key", profileId);
+        if (error) throw error;
+      }
+      if (data.grants) {
+        await core().from("tenant_role_overrides").delete().eq("tenant_id", orgId).eq("role", profileId);
+        const overrides = Object.entries(data.grants).flatMap(
+          ([category, actions]) => actions.map((action) => ({
+            tenant_id: orgId,
+            role: profileId,
+            permission_id: `${category}.${DB_ACTION[action] ?? action}`,
+            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) {
+      const found = await core().from("tenant_roles").select("key").eq("tenant_id", orgId).eq("key", profileId).maybeSingle();
+      if (found.error) throw found.error;
+      if (!found.data) throw new Error("System roles cannot be deleted.");
+      await core().from("tenant_role_overrides").delete().eq("tenant_id", orgId).eq("role", profileId);
+      const { error } = await core().from("tenant_roles").delete().eq("tenant_id", orgId).eq("key", profileId);
+      if (error) throw error;
+    },
+    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;
+      await authAdapter?.inviteUser?.(email, {
+        redirectTo: inviteRedirectTo,
+        data: { tenant_id: orgId, role: profileId, invited_by: invitedBy }
+      });
+      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;
+      await Promise.all(
+        emails.map(
+          (email) => authAdapter?.inviteUser?.(email, {
+            redirectTo: inviteRedirectTo,
+            data: { tenant_id: orgId, role: profileId, invited_by: invitedBy }
+          })
+        )
+      );
+      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;
+      const row = data;
+      await authAdapter?.inviteUser?.(row.email, {
+        redirectTo: inviteRedirectTo,
+        data: { tenant_id: orgId, role: row.role, invited_by: row.invited_by }
+      });
+      return mapInviteRow(row);
+    },
+    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()
+      };
+    }
+  };
+}
+
+export { createFayzSupabaseClient, createMockOrgAdapter, createSupabaseOrgAdapter, getFayzSupabaseClient, getFayzSupabaseClientOptional };
+//# sourceMappingURL=chunk-TNTZHUL6.js.map
+//# sourceMappingURL=chunk-TNTZHUL6.js.map