@ai-matrx/messaging 0.11.8 → 0.12.0

package/dist/react.cjs

@@ -52,6 +52,7 @@ __export(react_exports, {
   RPCS: () => RPCS,
   ReferenceCard: () => ReferenceCard,
   ReplyIcon: () => ReplyIcon,
+  SERVER_SESSION_IDENTITY: () => SERVER_SESSION_IDENTITY,
   SearchIcon: () => SearchIcon,
   SendIcon: () => SendIcon,
   SparklesIcon: () => SparklesIcon,
@@ -73,6 +74,7 @@ __export(react_exports, {
   createMessagingStore: () => createMessagingStore,
   createOutbox: () => createOutbox,
   createReadCache: () => createReadCache,
+  createSessionIdentity: () => createSessionIdentity,
   createWebOutboxStorage: () => createWebOutboxStorage,
   effectiveActorKey: () => effectiveActorKey,
   extractReferences: () => extractReferences,
@@ -1544,6 +1546,145 @@ function createReadCache(options) {
   };
 }
 
+// src/core/session-identity.ts
+var RESOLVING = Object.freeze({
+  state: "resolving",
+  userId: null
+});
+var SERVER_SESSION_IDENTITY = RESOLVING;
+function authOf(client) {
+  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 userIdOf(session) {
+  const id = session?.user?.id;
+  return typeof id === "string" && id.length > 0 ? asUserId(id) : null;
+}
+var NO_AUTH_SOURCE = {
+  message: "Messaging cannot tell who is signed in: the Supabase client it was given has no auth session source.",
+  remedy: "Pass your app's browser Supabase client \u2014 the same client it signs in with \u2014 to <MessagingProvider client={...}> or createMessagingRepository({ client }). Messaging reads the acting user from that client's session; there is no prop or option for a user id, on purpose (DD-241)."
+};
+function createSessionIdentity(options) {
+  const { client, onDiagnostic } = options;
+  const listeners = /* @__PURE__ */ new Set();
+  let current = RESOLVING;
+  let disposed = false;
+  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", ...NO_AUTH_SOURCE });
+    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: `Messaging could not read the signed-in session: ${String(
+          error?.message ?? error
+        )}`,
+        remedy: "Messages stay unavailable on this device until the session can be read. Reload the page; if it persists, sign in again."
+      });
+      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 {
+      }
+    }
+  };
+}
+function actingUserIdOf(identity) {
+  return new Promise((resolve, reject) => {
+    const settle = () => {
+      const snapshot = identity.snapshot();
+      if (snapshot.state !== "resolved") return false;
+      if (snapshot.userId === null) {
+        reject(identity.hasAuthSource ? noSignedInUserError() : noAuthSourceError());
+        return true;
+      }
+      resolve(snapshot.userId);
+      return true;
+    };
+    if (settle()) return;
+    const unsubscribe = identity.subscribe(() => {
+      if (settle()) unsubscribe();
+    });
+  });
+}
+function noSignedInUserError() {
+  return new MessagingError(
+    "session-unavailable",
+    "Messaging has no signed-in user: the Supabase client's session names nobody.",
+    "Sign in, then try again. Messaging takes the acting user from the session of the client it was given \u2014 never from an id handed in by the caller (DD-241), because a handed-in id goes stale the moment the auth cookie rotates and lands on the wire as sender_id and created_by."
+  );
+}
+function noAuthSourceError() {
+  return new MessagingError(
+    "misconfigured",
+    NO_AUTH_SOURCE.message,
+    NO_AUTH_SOURCE.remedy
+  );
+}
+async function readActingUserId(client) {
+  const auth = authOf(client);
+  if (auth === null) throw noAuthSourceError();
+  let session;
+  try {
+    const result = await auth.getSession();
+    session = result?.data?.session;
+  } catch (error) {
+    throw new MessagingError(
+      "session-unavailable",
+      `Messaging could not read the signed-in session: ${String(
+        error?.message ?? error
+      )}`,
+      "Reload the page and try again; if it persists, sign in again.",
+      error
+    );
+  }
+  const userId = userIdOf(session);
+  if (userId === null) throw noSignedInUserError();
+  return userId;
+}
+
 // src/core/repository.ts
 var MESSAGING_SCHEMA = "communication";
 var MESSAGING_RPC_SCHEMA = "public";
@@ -1580,8 +1721,15 @@ function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, jittered));
 }
 function createMessagingRepository(options) {
-  const { identity } = options;
-  const org = requireOrg(identity.organizationId, "createMessagingRepository");
+  const org = requireOrg(options.organizationId, "createMessagingRepository");
+  const handedIn = options.identity;
+  if (handedIn !== void 0 && handedIn !== null && handedIn.userId !== void 0) {
+    options.onDiagnostic?.(
+      "createMessagingRepository({ identity: { userId } }) is ignored: since 0.12.0 messaging reads the acting user from the session of the client it was given (DD-241). Remove the option and pass { client, organizationId } \u2014 a handed-in id goes stale the moment the auth cookie rotates, and it lands on the wire as sender_id and created_by."
+    );
+  }
+  const sessionIdentity = options.sessionIdentity;
+  const actingUserId = () => sessionIdentity !== void 0 ? actingUserIdOf(sessionIdentity) : readActingUserId(options.client);
   const userCache = createReadCache({
     ttlMs: options.userTtlMs ?? 5 * 6e4,
     ...options.now !== void 0 ? { now: options.now } : {}
@@ -1618,6 +1766,9 @@ function createMessagingRepository(options) {
       }
     }
   }
+  function actingUser(operation) {
+    return withSessionRetry(operation, () => actingUserId());
+  }
   async function rpc(fn, args, operation) {
     const { data, error } = await rpcDb().rpc(fn, args);
     if (error !== null) throw normalizeMessagingError(error, operation);
@@ -1641,17 +1792,19 @@ function createMessagingRepository(options) {
     return found;
   }
   const repository = {
-    identity,
+    organizationId: org,
+    actingUserId,
     async listConversations(args = {}) {
       const limit = args.limit ?? 30;
       const archived = args.archived ?? DEFAULT_MESSAGING_ARCHIVE_FILTER;
       const operation = "listConversations";
+      const me = await actingUser(operation);
       const rows = await withSessionRetry(
         operation,
         () => rpc(
           RPCS.conversationsWithDetails,
           {
-            p_user_id: identity.userId,
+            p_user_id: me,
             p_limit: limit + 1,
             p_before_sort_at: args.cursor?.beforeSortAt ?? null,
             p_before_conversation_id: args.cursor?.beforeConversationId ?? null,
@@ -1668,7 +1821,7 @@ function createMessagingRepository(options) {
         throw invalidResponse(operation, `${RPCS.conversationsWithDetails} did not return rows`);
       }
       const projected = (rows ?? []).map(
-        (row) => projectConversationSummary(row, identity.userId, org)
+        (row) => projectConversationSummary(row, me, org)
       );
       const hasMore = projected.length > limit;
       const items = hasMore ? projected.slice(0, limit) : projected;
@@ -1682,12 +1835,13 @@ function createMessagingRepository(options) {
     async countArchivedConversations(args = {}) {
       const limit = args.limit ?? 100;
       const operation = "countArchivedConversations";
+      const me = await actingUser(operation);
       const rows = await withSessionRetry(
         operation,
         () => rpc(
           RPCS.conversationsWithDetails,
           {
-            p_user_id: identity.userId,
+            p_user_id: me,
             p_limit: limit + 1,
             p_before_sort_at: null,
             p_before_conversation_id: null,
@@ -1704,6 +1858,7 @@ function createMessagingRepository(options) {
     },
     async getConversation(id) {
       const operation = "getConversation";
+      const me = await actingUser(operation);
       const { data, error } = await withSessionRetry(
         operation,
         async () => db().from(TABLES.conversations).select(CONVERSATION_COLUMNS).eq("id", id).single()
@@ -1724,7 +1879,7 @@ function createMessagingRepository(options) {
           participants: [],
           unread_count: 0
         },
-        identity.userId,
+        me,
         org
       );
       return summary.conversation;
@@ -1768,6 +1923,7 @@ function createMessagingRepository(options) {
     },
     async getOrCreateDirectConversation(otherUserId) {
       const operation = "getOrCreateDirectConversation";
+      const me = await actingUser(operation);
       const id = await withSessionRetry(
         operation,
         () => rpc(
@@ -1776,7 +1932,7 @@ function createMessagingRepository(options) {
             // The RPC's own guard requires an `authenticated` caller to pass
             // THEMSELVES as user1; passing them in the other slot is a denial,
             // not a preference.
-            p_user1_id: identity.userId,
+            p_user1_id: me,
             p_user2_id: otherUserId,
             p_organization_id: org
           },
@@ -1790,13 +1946,14 @@ function createMessagingRepository(options) {
     },
     async createGroupConversation({ name, memberIds }) {
       const operation = "createGroupConversation";
+      const me = await actingUser(operation);
       const { data, error } = await withSessionRetry(
         operation,
         async () => db().from(TABLES.conversations).insert({
           type: "group",
           group_name: name,
           organization_id: org,
-          created_by: identity.userId
+          created_by: me
         }).select("id").single()
       );
       if (error !== null) throw normalizeMessagingError(error, operation);
@@ -1804,14 +1961,14 @@ function createMessagingRepository(options) {
       if (typeof conversationId !== "string") {
         throw invalidResponse(operation, "insert returned no conversation id");
       }
-      const members = [.../* @__PURE__ */ new Set([identity.userId, ...memberIds])];
+      const members = [.../* @__PURE__ */ new Set([me, ...memberIds])];
       const { error: memberError } = await db().from(TABLES.participants).insert(
         members.map((userId) => ({
           conversation_id: conversationId,
           user_id: userId,
-          role: userId === identity.userId ? "owner" : "member",
+          role: userId === me ? "owner" : "member",
           organization_id: org,
-          created_by: identity.userId
+          created_by: me
         }))
       );
       if (memberError !== null) throw normalizeMessagingError(memberError, operation);
@@ -1819,11 +1976,12 @@ function createMessagingRepository(options) {
     },
     async insertMessage(draft, clientMessageId) {
       const operation = "insertMessage";
+      const me = await actingUser(operation);
       const { data, error } = await db().from(TABLES.messages).insert({
         conversation_id: draft.conversationId,
-        sender_id: identity.userId,
+        sender_id: me,
         organization_id: org,
-        created_by: identity.userId,
+        created_by: me,
         content: draft.content,
         message_type: draft.kind ?? "text",
         status: "sent",
@@ -1845,10 +2003,11 @@ function createMessagingRepository(options) {
     },
     async editMessage(id, content) {
       const operation = "editMessage";
+      const me = await actingUser(operation);
       const { data, error } = await db().from(TABLES.messages).update({
         content,
         edited_at: (/* @__PURE__ */ new Date()).toISOString(),
-        updated_by: identity.userId
+        updated_by: me
       }).eq("id", id).select(MESSAGE_COLUMNS).single();
       if (error !== null) throw normalizeMessagingError(error, operation);
       if (data === null) throw invalidResponse(operation, "update returned no row");
@@ -1856,47 +2015,53 @@ function createMessagingRepository(options) {
     },
     async deleteMessage(id, forEveryone) {
       const operation = "deleteMessage";
+      const me = await actingUser(operation);
       const { error } = await db().from(TABLES.messages).update({
         deleted_at: (/* @__PURE__ */ new Date()).toISOString(),
         deleted_for_everyone: forEveryone,
-        updated_by: identity.userId
+        updated_by: me
       }).eq("id", id);
       if (error !== null) throw normalizeMessagingError(error, operation);
     },
     async markRead(conversationId, at) {
       const operation = "markRead";
-      const { error } = await db().from(TABLES.participants).update({ last_read_at: at ?? (/* @__PURE__ */ new Date()).toISOString(), updated_by: identity.userId }).eq("conversation_id", conversationId).eq("user_id", identity.userId);
+      const me = await actingUser(operation);
+      const { error } = await db().from(TABLES.participants).update({ last_read_at: at ?? (/* @__PURE__ */ new Date()).toISOString(), updated_by: me }).eq("conversation_id", conversationId).eq("user_id", me);
       if (error !== null) throw normalizeMessagingError(error, operation);
     },
     async setConversationFlags(conversationId, flags) {
       const operation = "setConversationFlags";
-      const patch = { updated_by: identity.userId };
+      const me = await actingUser(operation);
+      const patch = { updated_by: me };
       if (flags.isMuted !== void 0) patch["is_muted"] = flags.isMuted;
       if (flags.isArchived !== void 0) patch["is_archived"] = flags.isArchived;
-      const { error } = await db().from(TABLES.participants).update(patch).eq("conversation_id", conversationId).eq("user_id", identity.userId);
+      const { error } = await db().from(TABLES.participants).update(patch).eq("conversation_id", conversationId).eq("user_id", me);
       if (error !== null) throw normalizeMessagingError(error, operation);
     },
     async addMembers(conversationId, memberIds) {
       const operation = "addMembers";
+      const me = await actingUser(operation);
       const { error } = await db().from(TABLES.participants).insert(
         memberIds.map((userId) => ({
           conversation_id: conversationId,
           user_id: userId,
           role: "member",
           organization_id: org,
-          created_by: identity.userId
+          created_by: me
         }))
       );
       if (error !== null) throw normalizeMessagingError(error, operation);
     },
     async removeMember(conversationId, memberId) {
       const operation = "removeMember";
-      const { error } = await db().from(TABLES.participants).update({ deleted_at: (/* @__PURE__ */ new Date()).toISOString(), updated_by: identity.userId }).eq("conversation_id", conversationId).eq("user_id", memberId);
+      const me = await actingUser(operation);
+      const { error } = await db().from(TABLES.participants).update({ deleted_at: (/* @__PURE__ */ new Date()).toISOString(), updated_by: me }).eq("conversation_id", conversationId).eq("user_id", memberId);
       if (error !== null) throw normalizeMessagingError(error, operation);
     },
     async setMemberRole(conversationId, memberId, role) {
       const operation = "setMemberRole";
-      const { error } = await db().from(TABLES.participants).update({ role, updated_by: identity.userId }).eq("conversation_id", conversationId).eq("user_id", memberId);
+      const me = await actingUser(operation);
+      const { error } = await db().from(TABLES.participants).update({ role, updated_by: me }).eq("conversation_id", conversationId).eq("user_id", memberId);
       if (error !== null) throw normalizeMessagingError(error, operation);
     },
     getUser(userId) {
@@ -1951,22 +2116,69 @@ function defaultDiagnostics(event) {
   else if (event.level === "warn") console.warn(line);
   else console.info(line);
 }
+function useSessionUserId(client, onDiagnostic) {
+  const diagnosticRef = (0, import_react.useRef)(onDiagnostic);
+  diagnosticRef.current = onDiagnostic;
+  const identity = (0, import_react.useMemo)(() => {
+    if (client == null) return null;
+    return createSessionIdentity({
+      client,
+      onDiagnostic: (event) => {
+        (diagnosticRef.current ?? defaultDiagnostics)(event);
+      }
+    });
+  }, [client]);
+  (0, import_react.useEffect)(() => {
+    if (identity === null) return void 0;
+    return () => {
+      identity.dispose();
+    };
+  }, [identity]);
+  const snapshot = (0, import_react.useSyncExternalStore)(
+    (listener) => identity === null ? () => void 0 : identity.subscribe(listener),
+    () => identity?.snapshot() ?? SERVER_SESSION_IDENTITY,
+    () => SERVER_SESSION_IDENTITY
+  );
+  return { identity, snapshot };
+}
 function MessagingProvider(props) {
-  const { client, userId, organizationId } = props;
-  const ready = client != null && typeof userId === "string" && userId.length > 0 && typeof organizationId === "string" && organizationId.length > 0;
+  const { client, organizationId } = props;
+  const strayUserId = props.userId;
+  const reportedStray = (0, import_react.useRef)(false);
+  (0, import_react.useEffect)(() => {
+    if (typeof strayUserId !== "string" || strayUserId.length === 0) return;
+    if (reportedStray.current) return;
+    reportedStray.current = true;
+    (props.onDiagnostic ?? defaultDiagnostics)({
+      level: "error",
+      message: "<MessagingProvider userId> is ignored: since 0.12.0 messaging reads the acting user from the Supabase client's own session (DD-241).",
+      remedy: "Delete the userId prop. A copy of a user id goes stale the moment the auth cookie rotates, and in messaging it lands on the wire as sender_id and created_by \u2014 so it writes rows attributed to somebody the tab cannot prove it is."
+    });
+  }, [strayUserId]);
+  const session = useSessionUserId(client, props.onDiagnostic);
+  const userId = session.snapshot.userId;
+  const ready = client != null && userId !== null && typeof organizationId === "string" && organizationId.length > 0;
   const hostProvidesRealtime = (0, import_react2.useIsRealtimeProviderMounted)();
-  if (hostProvidesRealtime) return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(MessagingRuntime, { ...props });
+  const runtime = /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    MessagingRuntime,
+    {
+      ...props,
+      sessionUserId: userId,
+      sessionIdentity: session.identity
+    }
+  );
+  if (hostProvidesRealtime) return runtime;
   return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
     import_react2.RealtimeProvider,
     {
       client: ready ? client : null,
       actorId: userId ?? void 0,
-      children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(MessagingRuntime, { ...props })
+      children: runtime
     }
   );
 }
 function MessagingRuntime(props) {
-  const { client, userId, organizationId, children } = props;
+  const { client, sessionUserId: userId, sessionIdentity, organizationId, children } = props;
   const manager = (0, import_react2.useRealtimeManager)();
   const diagnosticRef = (0, import_react.useRef)(props.onDiagnostic);
   diagnosticRef.current = props.onDiagnostic;
@@ -1981,9 +2193,9 @@ function MessagingRuntime(props) {
       actionRegistry.register(handler);
     });
   }, [actionRegistry, handlers]);
-  const ready = client != null && manager !== null && typeof userId === "string" && userId.length > 0 && typeof organizationId === "string" && organizationId.length > 0;
+  const ready = client != null && manager !== null && sessionIdentity !== null && userId !== null && typeof organizationId === "string" && organizationId.length > 0;
   const engine = (0, import_react.useMemo)(() => {
-    if (!ready || manager === null) return null;
+    if (!ready || manager === null || sessionIdentity === null || userId === null) return null;
     const identity = {
       userId,
       organizationId
@@ -1997,7 +2209,10 @@ function MessagingRuntime(props) {
       // supabase-shape.ts); everything below this line works against the rich
       // contract, which `supabase-shape.test.ts` proves a real client honors.
       client,
-      identity,
+      organizationId,
+      // THE SAME READER the render loop above uses. Two readers would be two
+      // answers during the tick an account switch takes.
+      sessionIdentity,
       // An automatic heal ANNOUNCES itself: a lock collision the package
       // re-ran is a warning in the host's diagnostics, never a banner on the
       // inbox and never silence.
@@ -2027,7 +2242,7 @@ function MessagingRuntime(props) {
       }
     });
     return built;
-  }, [ready, manager, userId, organizationId]);
+  }, [ready, manager, sessionIdentity, userId, organizationId]);
   (0, import_react.useEffect)(() => {
     if (engine === null) return void 0;
     void engine.start().catch((error) => {