@ai-matrx/messaging 0.11.8 → 0.12.0

package/dist/react.js

@@ -1449,6 +1449,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";
@@ -1485,8 +1624,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 } : {}
@@ -1523,6 +1669,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);
@@ -1546,17 +1695,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,
@@ -1573,7 +1724,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;
@@ -1587,12 +1738,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,
@@ -1609,6 +1761,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()
@@ -1629,7 +1782,7 @@ function createMessagingRepository(options) {
           participants: [],
           unread_count: 0
         },
-        identity.userId,
+        me,
         org
       );
       return summary.conversation;
@@ -1673,6 +1826,7 @@ function createMessagingRepository(options) {
     },
     async getOrCreateDirectConversation(otherUserId) {
       const operation = "getOrCreateDirectConversation";
+      const me = await actingUser(operation);
       const id = await withSessionRetry(
         operation,
         () => rpc(
@@ -1681,7 +1835,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
           },
@@ -1695,13 +1849,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);
@@ -1709,14 +1864,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);
@@ -1724,11 +1879,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",
@@ -1750,10 +1906,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");
@@ -1761,47 +1918,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) {
@@ -1856,22 +2019,69 @@ function defaultDiagnostics(event) {
   else if (event.level === "warn") console.warn(line);
   else console.info(line);
 }
+function useSessionUserId(client, onDiagnostic) {
+  const diagnosticRef = useRef(onDiagnostic);
+  diagnosticRef.current = onDiagnostic;
+  const identity = useMemo(() => {
+    if (client == null) return null;
+    return createSessionIdentity({
+      client,
+      onDiagnostic: (event) => {
+        (diagnosticRef.current ?? defaultDiagnostics)(event);
+      }
+    });
+  }, [client]);
+  useEffect(() => {
+    if (identity === null) return void 0;
+    return () => {
+      identity.dispose();
+    };
+  }, [identity]);
+  const snapshot = 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 = useRef(false);
+  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 = useIsRealtimeProviderMounted();
-  if (hostProvidesRealtime) return /* @__PURE__ */ jsx(MessagingRuntime, { ...props });
+  const runtime = /* @__PURE__ */ jsx(
+    MessagingRuntime,
+    {
+      ...props,
+      sessionUserId: userId,
+      sessionIdentity: session.identity
+    }
+  );
+  if (hostProvidesRealtime) return runtime;
   return /* @__PURE__ */ jsx(
     RealtimeProvider,
     {
       client: ready ? client : null,
       actorId: userId ?? void 0,
-      children: /* @__PURE__ */ jsx(MessagingRuntime, { ...props })
+      children: runtime
     }
   );
 }
 function MessagingRuntime(props) {
-  const { client, userId, organizationId, children } = props;
+  const { client, sessionUserId: userId, sessionIdentity, organizationId, children } = props;
   const manager = useRealtimeManager();
   const diagnosticRef = useRef(props.onDiagnostic);
   diagnosticRef.current = props.onDiagnostic;
@@ -1886,9 +2096,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 = useMemo(() => {
-    if (!ready || manager === null) return null;
+    if (!ready || manager === null || sessionIdentity === null || userId === null) return null;
     const identity = {
       userId,
       organizationId
@@ -1902,7 +2112,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.
@@ -1932,7 +2145,7 @@ function MessagingRuntime(props) {
       }
     });
     return built;
-  }, [ready, manager, userId, organizationId]);
+  }, [ready, manager, sessionIdentity, userId, organizationId]);
   useEffect(() => {
     if (engine === null) return void 0;
     void engine.start().catch((error) => {
@@ -3333,6 +3546,7 @@ export {
   RPCS,
   ReferenceCard,
   ReplyIcon,
+  SERVER_SESSION_IDENTITY,
   SearchIcon,
   SendIcon,
   SparklesIcon,
@@ -3354,6 +3568,7 @@ export {
   createMessagingStore,
   createOutbox,
   createReadCache,
+  createSessionIdentity,
   createWebOutboxStorage,
   effectiveActorKey,
   extractReferences,