@ai-matrx/auth 0.0.0 → 0.1.1

package/dist/organizations.js

@@ -0,0 +1,366 @@
+// src/organization-ladder.ts
+function resolveActiveOrganization(input) {
+  const { memberships } = input;
+  if (memberships.length === 0) return null;
+  const member = (id) => id ? memberships.find((m) => m.id === id) ?? null : null;
+  const held = member(input.held);
+  if (held) return { organization: held, rung: "held" };
+  const last = member(input.account?.lastActiveOrganizationId);
+  if (last) return { organization: last, rung: "last-active" };
+  const startup = member(input.account?.startupOrganizationId);
+  if (startup) return { organization: startup, rung: "startup" };
+  const first = input.first && member(input.first.id) || oldestMembership(memberships);
+  return first ? { organization: first, rung: "first" } : null;
+}
+async function resolveActiveOrganizationLazily(input) {
+  const { memberships } = input;
+  if (memberships.length === 0) return null;
+  const quick = resolveActiveOrganization({ memberships, held: input.held ?? null, account: null, first: null });
+  if (quick?.rung === "held") return quick;
+  const account = await input.readAccount();
+  const named = resolveActiveOrganization({ memberships, held: null, account, first: null });
+  if (named && named.rung !== "first") return named;
+  const first = input.first ? await input.first() : null;
+  return resolveActiveOrganization({ memberships, held: null, account: null, first });
+}
+function oldestMembership(memberships) {
+  let best = null;
+  for (const m of memberships) {
+    if (!best) best = m;
+    else if (m.joinedAt && (!best.joinedAt || m.joinedAt < best.joinedAt)) best = m;
+  }
+  return best;
+}
+function orderOrganizations(organizations, favouriteIds) {
+  const favourites = new Set(favouriteIds);
+  const rank = (o) => favourites.has(o.id) ? 0 : o.isOwn ? 1 : 2;
+  return [...organizations].sort((a, b) => rank(a) - rank(b));
+}
+function organizationMatches(org, query) {
+  const q = query.trim().toLowerCase();
+  if (!q) return true;
+  if (org.name.toLowerCase().includes(q)) return true;
+  const abbreviation = org.abbreviation?.trim().toLowerCase();
+  return !!abbreviation && abbreviation.includes(q);
+}
+var MEMBERSHIP_PAGE = 500;
+var ID_CHUNK = 100;
+async function readMemberships(db, userId) {
+  const memberships = [];
+  for (let from = 0; ; from += MEMBERSHIP_PAGE) {
+    const { data, error } = await db.rpc("mbr_for_user", { p_container_type: "organization" }).order("id", { ascending: true }).range(from, from + MEMBERSHIP_PAGE - 1);
+    if (error) throw new Error(`Your organizations could not be read: ${error.message}`);
+    const page = Array.isArray(data) ? data : [];
+    memberships.push(...page);
+    if (page.length < MEMBERSHIP_PAGE) break;
+  }
+  const active = /* @__PURE__ */ new Map();
+  for (const m of memberships) {
+    if (m.status !== "active") continue;
+    const seen = active.get(m.container_id);
+    if (!seen || m.created_at < seen.created_at) active.set(m.container_id, m);
+  }
+  const ids = [...active.keys()];
+  if (ids.length === 0) return [];
+  const rows = [];
+  for (let i = 0; i < ids.length; i += ID_CHUNK) {
+    const { data, error } = await db.schema("iam").from("organizations").select("id, name, slug, abbreviation, logo_url, created_by, settings, archived_at").in("id", ids.slice(i, i + ID_CHUNK));
+    if (error) throw new Error(`Your organizations could not be read: ${error.message}`);
+    rows.push(...data ?? []);
+  }
+  return rows.filter((r) => !r.archived_at).map((r) => {
+    const m = active.get(r.id);
+    const settings = r.settings && typeof r.settings === "object" ? r.settings : {};
+    return {
+      id: r.id,
+      name: r.name?.trim() || "Untitled organization",
+      slug: r.slug ?? null,
+      abbreviation: r.abbreviation?.trim() || null,
+      logoUrl: r.logo_url?.trim() || null,
+      role: m?.role ?? "member",
+      isOwn: !!r.created_by && r.created_by === userId,
+      isTestFixture: settings["test_fixture"] === true,
+      joinedAt: m?.created_at ?? ""
+    };
+  }).sort((a, b) => a.name.localeCompare(b.name));
+}
+function toAccountOrganizationChoices(row) {
+  return {
+    lastActiveOrganizationId: row?.last_active_organization_id ?? null,
+    startupOrganizationId: row?.startup_organization_id ?? null
+  };
+}
+async function readAccountOrganizationChoices(db, userId) {
+  const { data, error } = await db.schema("users").from("user_preferences").select("last_active_organization_id, startup_organization_id").eq("user_id", userId).maybeSingle();
+  if (error) throw new Error(`The account's organization read failed: ${error.message}`);
+  return toAccountOrganizationChoices(data);
+}
+async function writeLastActiveOrganization(db, organizationId) {
+  const { error } = await db.schema("users").rpc("set_last_active_organization", { p_organization_id: organizationId });
+  if (error) throw new Error(error.message);
+}
+async function writeStartupOrganization(db, organizationId) {
+  const { error } = await db.schema("users").rpc("set_startup_organization", { p_organization_id: organizationId });
+  if (error) throw new Error(error.message);
+}
+var ORGANIZATION_ENTITY_TYPE = "organization";
+async function readOrganizationFavourites(db) {
+  const { data, error } = await db.rpc("ues_list", { p_kind: "favorite" });
+  if (error) throw new Error(`Your favourite organizations could not be read: ${error.message}`);
+  return (Array.isArray(data) ? data : []).filter((r) => r.entity_type === ORGANIZATION_ENTITY_TYPE && r.is_favorite).map((r) => r.entity_id);
+}
+async function setOrganizationFavourite(db, organizationId, favourite) {
+  const { error } = await db.rpc("ues_set", { p_entity_type: ORGANIZATION_ENTITY_TYPE, p_entity_id: organizationId, p_is_favorite: favourite });
+  if (error) throw new Error(error.message);
+}
+function classifyOrganizationRefusal(status, body) {
+  const detail = body && typeof body === "object" ? body["detail"] ?? body : null;
+  const admission = detail && typeof detail === "object" ? detail["organization_admission"] : null;
+  if (status === 400 && (admission === "denied" || admission === "unknown" || admission === "archived")) return "lapsed";
+  if (status === 503 && admission === "unverifiable") return "retry";
+  return null;
+}
+
+// src/session.ts
+var SignInError = class extends Error {
+  door;
+  status;
+  code;
+  constructor(door, message, status, code) {
+    super(`${door}: ${message}`);
+    this.name = "SignInError";
+    this.door = door;
+    if (status !== void 0) this.status = status;
+    if (code !== void 0) this.code = code;
+  }
+};
+function check(door, data, error) {
+  if (error) throw new SignInError(door, error.message, error.status, error.code);
+  return data;
+}
+async function getPerson(client) {
+  const { data, error } = await client.auth.getUser();
+  if (error && (error.name === "AuthSessionMissingError" || error.status === 401)) return null;
+  return check("getPerson", data, error).user;
+}
+function onSessionChange(client, cb) {
+  const { data } = client.auth.onAuthStateChange(cb);
+  return () => data.subscription.unsubscribe();
+}
+
+// src/active-organization.ts
+var NoActiveOrganizationError = class extends Error {
+  constructor(reason, detail) {
+    super(
+      reason === "signed-out" ? "No organization: nobody is signed in." : reason === "no-memberships" ? "No organization: this account is not an active member of any organization." : `No organization: your organizations could not be checked${detail ? ` (${detail})` : ""}.`
+    );
+    this.reason = reason;
+    this.name = "NoActiveOrganizationError";
+  }
+  reason;
+};
+var NotAMemberError = class extends Error {
+  constructor(organizationId) {
+    super(`You are not an active member of organization ${organizationId}.`);
+    this.organizationId = organizationId;
+    this.name = "NotAMemberError";
+  }
+  organizationId;
+};
+var HELD_KEY = "ai-matrx.auth.active-organization";
+function storageHeldOrganization(storage, key = HELD_KEY) {
+  return {
+    read(userId) {
+      try {
+        const raw = storage.getItem(key);
+        if (!raw) return null;
+        const parsed = JSON.parse(raw);
+        return parsed.userId === userId && typeof parsed.organizationId === "string" ? parsed.organizationId : null;
+      } catch {
+        return null;
+      }
+    },
+    write(userId, organizationId) {
+      storage.setItem(key, JSON.stringify({ userId, organizationId }));
+    },
+    clear() {
+      storage.removeItem(key);
+    }
+  };
+}
+function memoryHeldOrganization() {
+  let held = null;
+  return {
+    read: (userId) => held && held.userId === userId ? held.organizationId : null,
+    write: (userId, organizationId) => {
+      held = { userId, organizationId };
+    },
+    clear: () => {
+      held = null;
+    }
+  };
+}
+function defaultHeld() {
+  const session = globalThis.sessionStorage;
+  return session ? storageHeldOrganization(session) : memoryHeldOrganization();
+}
+var IDLE = Object.freeze({
+  status: "idle",
+  userId: null,
+  organizationId: null,
+  organization: null,
+  memberships: Object.freeze([]),
+  rung: null,
+  error: null
+});
+function createActiveOrganization(options) {
+  const { client } = options;
+  const held = options.held ?? defaultHeld();
+  const listeners = /* @__PURE__ */ new Set();
+  let current = IDLE;
+  let inflight = null;
+  let generation = 0;
+  let waiters = [];
+  let disposed = false;
+  const publish = (next) => {
+    current = Object.freeze(next);
+    if (current.status !== "resolving" && current.status !== "idle") {
+      const ready = waiters;
+      waiters = [];
+      for (const w of ready) w();
+    }
+    for (const l of [...listeners]) l();
+  };
+  const run = async (gen) => {
+    publish({ ...current, status: "resolving", error: null });
+    try {
+      const person = await getPerson(client);
+      if (gen !== generation) return current;
+      if (!person) {
+        publish({ ...IDLE, status: "none", error: "signed-out" });
+        return current;
+      }
+      const memberships = await readMemberships(client, person.id);
+      if (gen !== generation) return current;
+      const linked = options.linked?.() ?? null;
+      const heldId = (linked && memberships.some((m) => m.id === linked) ? linked : null) ?? await held.read(person.id);
+      const resolved = await resolveActiveOrganizationLazily({
+        memberships,
+        held: heldId,
+        readAccount: () => readAccountOrganizationChoices(client, person.id)
+      });
+      if (gen !== generation) return current;
+      if (!resolved) {
+        publish({ ...IDLE, status: "none", userId: person.id, error: "no-memberships" });
+        return current;
+      }
+      await held.write(person.id, resolved.organization.id);
+      publish({
+        status: "ready",
+        userId: person.id,
+        organizationId: resolved.organization.id,
+        organization: resolved.organization,
+        memberships,
+        rung: resolved.rung,
+        error: null
+      });
+      return current;
+    } catch (e) {
+      if (gen !== generation) return current;
+      publish({ ...current, status: "error", error: e?.message ?? String(e) });
+      return current;
+    }
+  };
+  const load = () => {
+    if (disposed) return Promise.resolve(current);
+    generation += 1;
+    inflight = run(generation).finally(() => {
+      inflight = null;
+    });
+    return inflight;
+  };
+  const stopSession = onSessionChange(client, (event, session) => {
+    if (event === "SIGNED_OUT" || !session) {
+      generation += 1;
+      void held.clear();
+      publish({ ...IDLE, status: "none", error: "signed-out" });
+      return;
+    }
+    const userId = session.user?.id ?? null;
+    if (event === "SIGNED_IN" && userId !== current.userId) void load();
+  });
+  const settled = async () => {
+    if (current.status === "idle") return load();
+    if (current.status === "resolving") {
+      await new Promise((resolve) => waiters.push(resolve));
+    }
+    return current;
+  };
+  const api = {
+    snapshot: () => current,
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    load,
+    current: () => current.status === "ready" ? current.organizationId : null,
+    async ensureOrgId(recordOrganizationId) {
+      if (recordOrganizationId) return recordOrganizationId;
+      const snap = await settled();
+      if (snap.status === "ready" && snap.organizationId) return snap.organizationId;
+      if (snap.status === "error") throw new NoActiveOrganizationError("unreadable", snap.error ?? void 0);
+      throw new NoActiveOrganizationError(snap.error === "signed-out" ? "signed-out" : "no-memberships");
+    },
+    async switchTo(organizationId) {
+      const snap = await settled();
+      const organization = snap.memberships.find((m) => m.id === organizationId);
+      if (!organization || !snap.userId) throw new NotAMemberError(organizationId);
+      generation += 1;
+      await held.write(snap.userId, organizationId);
+      publish({ ...snap, status: "ready", organizationId, organization, rung: "switched", error: null });
+      await writeLastActiveOrganization(client, organizationId);
+    },
+    async handleRefusal(status, body) {
+      const kind = classifyOrganizationRefusal(status, body);
+      if (kind === "lapsed") {
+        if (current.userId) await held.clear();
+        await load();
+      }
+      return kind;
+    },
+    dispose() {
+      disposed = true;
+      generation += 1;
+      stopSession();
+      listeners.clear();
+      const pending = waiters;
+      waiters = [];
+      for (const w of pending) w();
+    }
+  };
+  if (options.autoLoad ?? true) void load();
+  return api;
+}
+export {
+  NoActiveOrganizationError,
+  NotAMemberError,
+  ORGANIZATION_ENTITY_TYPE,
+  classifyOrganizationRefusal,
+  createActiveOrganization,
+  memoryHeldOrganization,
+  oldestMembership,
+  orderOrganizations,
+  organizationMatches,
+  readAccountOrganizationChoices,
+  readMemberships,
+  readOrganizationFavourites,
+  resolveActiveOrganization,
+  resolveActiveOrganizationLazily,
+  setOrganizationFavourite,
+  storageHeldOrganization,
+  toAccountOrganizationChoices,
+  writeLastActiveOrganization,
+  writeStartupOrganization
+};

package/dist/react.cjs

@@ -0,0 +1,206 @@
+"use client";
+"use strict";
+"use client";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/react.ts
+var react_exports = {};
+__export(react_exports, {
+  useActiveOrganization: () => useActiveOrganization,
+  useSession: () => useSession,
+  useSessionIdentity: () => useSessionIdentity
+});
+module.exports = __toCommonJS(react_exports);
+var import_react = require("react");
+
+// src/session.ts
+var SignInError = class extends Error {
+  door;
+  status;
+  code;
+  constructor(door, message, status, code) {
+    super(`${door}: ${message}`);
+    this.name = "SignInError";
+    this.door = door;
+    if (status !== void 0) this.status = status;
+    if (code !== void 0) this.code = code;
+  }
+};
+function check(door, data, error) {
+  if (error) throw new SignInError(door, error.message, error.status, error.code);
+  return data;
+}
+async function getSession(client) {
+  const { data, error } = await client.auth.getSession();
+  return check("getSession", data, error).session;
+}
+function onSessionChange(client, cb) {
+  const { data } = client.auth.onAuthStateChange(cb);
+  return () => data.subscription.unsubscribe();
+}
+
+// src/session-identity.ts
+var RESOLVING = Object.freeze({
+  state: "resolving",
+  userId: null
+});
+var SERVER_SESSION_IDENTITY = RESOLVING;
+function authOf(client) {
+  if (client === null || typeof client !== "object" && typeof client !== "function") return null;
+  const candidate = client.auth;
+  if (candidate === null || typeof candidate !== "object") return null;
+  const auth = candidate;
+  if (typeof auth.getSession !== "function") return null;
+  if (typeof auth.onAuthStateChange !== "function") return null;
+  return auth;
+}
+function sessionUserId(session) {
+  const id = session?.user?.id;
+  return typeof id === "string" && id.length > 0 ? id : null;
+}
+function noAuthSourceMessage(words) {
+  return {
+    message: `${words.product} cannot tell who is signed in: the Supabase client it was given has no auth session source.`,
+    remedy: words.noAuthSourceRemedy
+  };
+}
+function unreadableSessionMessage(words, error) {
+  return `${words.product} could not read the signed-in session: ${String(
+    error?.message ?? error
+  )}`;
+}
+function createSessionIdentity(options) {
+  const { client, onDiagnostic, words } = options;
+  const brand = options.toUserId ?? ((id) => id);
+  const listeners = /* @__PURE__ */ new Set();
+  let current = RESOLVING;
+  let disposed = false;
+  const userIdOf = (session) => {
+    const id = sessionUserId(session);
+    return id === null ? null : brand(id);
+  };
+  const publish = (state, userId) => {
+    if (disposed) return;
+    if (current.state === state && current.userId === userId) return;
+    current = Object.freeze({ state, userId });
+    for (const listener of [...listeners]) listener();
+  };
+  const subscribeOnly = (hasAuthSource) => ({
+    hasAuthSource,
+    snapshot: () => current,
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    dispose: () => {
+      disposed = true;
+      listeners.clear();
+    }
+  });
+  const auth = authOf(client);
+  if (auth === null) {
+    onDiagnostic?.({ level: "error", ...noAuthSourceMessage(words) });
+    current = Object.freeze({ state: "resolved", userId: null });
+    return subscribeOnly(false);
+  }
+  void (async () => {
+    try {
+      const result = await auth.getSession();
+      publish("resolved", userIdOf(result?.data?.session));
+    } catch (error) {
+      onDiagnostic?.({
+        level: "warn",
+        message: unreadableSessionMessage(words, error),
+        remedy: words.unreadableRemedy
+      });
+      publish("resolved", null);
+    }
+  })();
+  const subscription = auth.onAuthStateChange((_event, session) => {
+    publish("resolved", userIdOf(session));
+  });
+  const base = subscribeOnly(true);
+  return {
+    hasAuthSource: true,
+    snapshot: base.snapshot,
+    subscribe: base.subscribe,
+    dispose: () => {
+      base.dispose();
+      try {
+        subscription.data.subscription.unsubscribe();
+      } catch {
+      }
+    }
+  };
+}
+
+// src/react.ts
+var RESOLVING2 = Object.freeze({ status: "resolving", session: null, person: null, error: null });
+function useSession(client) {
+  const [state, setState] = (0, import_react.useState)(RESOLVING2);
+  (0, import_react.useEffect)(() => {
+    let alive = true;
+    const apply = (session) => {
+      if (!alive) return;
+      setState(
+        session ? { status: "signed-in", session, person: session.user, error: null } : { status: "signed-out", session: null, person: null, error: null }
+      );
+    };
+    getSession(client).then(apply, (e) => {
+      if (alive) setState({ status: "error", session: null, person: null, error: e?.message ?? String(e) });
+    });
+    const stop = onSessionChange(client, (_event, session) => apply(session));
+    return () => {
+      alive = false;
+      stop();
+    };
+  }, [client]);
+  return state;
+}
+var SERVER_ACTIVE = Object.freeze({
+  status: "idle",
+  userId: null,
+  organizationId: null,
+  organization: null,
+  memberships: Object.freeze([]),
+  rung: null,
+  error: null
+});
+function useActiveOrganization(store) {
+  return (0, import_react.useSyncExternalStore)(store.subscribe, store.snapshot, () => SERVER_ACTIVE);
+}
+var NO_IDENTITY = {
+  subscribe: () => () => {
+  },
+  snapshot: () => SERVER_SESSION_IDENTITY
+};
+function useSessionIdentity(options) {
+  const latest = (0, import_react.useRef)(options);
+  latest.current = options;
+  const [identity, setIdentity] = (0, import_react.useState)(null);
+  (0, import_react.useEffect)(() => {
+    const made = createSessionIdentity(latest.current);
+    setIdentity(made);
+    return () => made.dispose();
+  }, [options.client]);
+  const source = identity ?? NO_IDENTITY;
+  return (0, import_react.useSyncExternalStore)(source.subscribe, source.snapshot, () => SERVER_SESSION_IDENTITY);
+}