@tuturuuu/utils 0.13.0 → 0.15.1

package/src/workspace-user-link.test.ts

@@ -0,0 +1,53 @@
+import type { TypedSupabaseClient } from '@tuturuuu/supabase/types';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const mocks = vi.hoisted(() => ({
+  createAdminClient: vi.fn(),
+  createClient: vi.fn(),
+  verifyWorkspaceMembershipType: vi.fn(),
+}));
+
+vi.mock('@tuturuuu/supabase/next/server', () => ({
+  createAdminClient: mocks.createAdminClient,
+  createClient: mocks.createClient,
+}));
+vi.mock('./workspace-helper', () => ({
+  verifyWorkspaceMembershipType: mocks.verifyWorkspaceMembershipType,
+}));
+
+import { getWorkspaceUserLinkForUser } from './workspace-user-link';
+
+describe('getWorkspaceUserLinkForUser', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('uses an injected authorization client for satellite actors', async () => {
+    const link = {
+      created_at: '2026-07-13T00:00:00.000Z',
+      platform_user_id: 'platform-user-1',
+      virtual_user_id: 'virtual-user-1',
+      ws_id: 'workspace-1',
+    };
+    const maybeSingle = vi.fn().mockResolvedValue({ data: link, error: null });
+    const limit = vi.fn(() => ({ maybeSingle }));
+    const secondEq = vi.fn(() => ({ limit }));
+    const firstEq = vi.fn(() => ({ eq: secondEq }));
+    const select = vi.fn(() => ({ eq: firstEq }));
+    const authorizationClient = {
+      from: vi.fn(() => ({ select })),
+    } as unknown as TypedSupabaseClient;
+
+    await expect(
+      getWorkspaceUserLinkForUser('workspace-1', 'platform-user-1', {
+        authorizationClient,
+      })
+    ).resolves.toEqual(link);
+
+    expect(authorizationClient.from).toHaveBeenCalledWith(
+      'workspace_user_linked_users'
+    );
+    expect(mocks.createClient).not.toHaveBeenCalled();
+    expect(mocks.createAdminClient).not.toHaveBeenCalled();
+  });
+});

package/src/workspace-user-link.ts

@@ -0,0 +1,122 @@
+import {
+  createAdminClient,
+  createClient,
+} from '@tuturuuu/supabase/next/server';
+import type { TypedSupabaseClient } from '@tuturuuu/supabase/types';
+import type { WorkspaceUser } from '@tuturuuu/types/primitives/WorkspaceUser';
+import { resolveWorkspaceId } from './constants';
+import { verifyWorkspaceMembershipType } from './workspace-helper';
+
+export interface WorkspaceUserLink {
+  platform_user_id: string;
+  virtual_user_id: string;
+  ws_id: string;
+  created_at: string;
+  workspace_users?: WorkspaceUser;
+}
+
+const LINK_SELECT =
+  'platform_user_id, virtual_user_id, ws_id, created_at, workspace_users!virtual_user_id(*)';
+
+type LinkRow = {
+  platform_user_id: string;
+  virtual_user_id: string;
+  ws_id: string;
+  created_at: string;
+  workspace_users?: unknown;
+};
+
+function toLink(row: LinkRow): WorkspaceUserLink {
+  const linkedData = row.workspace_users;
+  return {
+    platform_user_id: row.platform_user_id,
+    virtual_user_id: row.virtual_user_id,
+    ws_id: row.ws_id,
+    created_at: row.created_at,
+    ...(linkedData ? { workspace_users: linkedData as WorkspaceUser } : {}),
+  };
+}
+
+/**
+ * Resolves the workspace-user link for an EXPLICIT platform user id.
+ *
+ * `getCurrentWorkspaceUser` (user-helper) resolves the actor from Supabase auth
+ * and then delegates here. Satellite apps must not do that: they resolve the
+ * actor from Tuturuuu app-session auth (`getSatelliteAppSessionUser`) and pass
+ * the id in, which is why this lives outside `user-helper` — the internal-app-auth
+ * guard forbids registered apps from importing that module.
+ */
+export async function getWorkspaceUserLinkForUser(
+  wsId: string,
+  userId: string,
+  options: {
+    authorizationClient?: TypedSupabaseClient;
+    autoRepair?: boolean;
+  } = {}
+): Promise<WorkspaceUserLink | null> {
+  const { authorizationClient, autoRepair = true } = options;
+  if (!userId) return null;
+
+  const supabase = authorizationClient ?? (await createClient());
+  const resolvedWsId = resolveWorkspaceId(wsId);
+
+  const { data: workspaceUser } = await supabase
+    .from('workspace_user_linked_users')
+    .select(LINK_SELECT)
+    .eq('platform_user_id', userId)
+    .eq('ws_id', resolvedWsId)
+    .limit(1)
+    .maybeSingle();
+
+  if (workspaceUser) return toLink(workspaceUser as LinkRow);
+
+  if (!autoRepair) return null;
+
+  const membership = await verifyWorkspaceMembershipType({
+    wsId: resolvedWsId,
+    userId,
+    supabase,
+    requiredType: 'MEMBER',
+  });
+
+  if (!membership.ok) return null;
+
+  try {
+    const sbAdmin = await createAdminClient();
+    // Note: ensure_workspace_user_link is defined in migration 20260112060000.
+    // IMPORTANT: must use .bind() to preserve the Supabase client's `this` context.
+    const rpc = sbAdmin.rpc.bind(sbAdmin) as unknown as (
+      fn: string,
+      args: Record<string, unknown>
+    ) => Promise<{ error: Error | null }>;
+    const { error: repairError } = await rpc('ensure_workspace_user_link', {
+      target_user_id: userId,
+      target_ws_id: resolvedWsId,
+    });
+
+    if (repairError) {
+      console.error(
+        '[getWorkspaceUserLinkForUser] Failed to auto-repair workspace user link:',
+        repairError
+      );
+      return null;
+    }
+
+    const { data: repairedUser } = await supabase
+      .from('workspace_user_linked_users')
+      .select(LINK_SELECT)
+      .eq('platform_user_id', userId)
+      .eq('ws_id', resolvedWsId)
+      .limit(1)
+      .maybeSingle();
+
+    if (repairedUser) return toLink(repairedUser as LinkRow);
+  } catch (err) {
+    console.error(
+      '[getWorkspaceUserLinkForUser] Error during auto-repair:',
+      err
+    );
+  }
+
+  return null;
+}

package/src/yjs-helper.ts

@@ -1,5 +1,5 @@
 import type { JSONContent } from '@tiptap/react';
-import { Node as ProseMirrorNode, type Schema } from 'prosemirror-model';
+import type { Schema } from 'prosemirror-model';
 import * as Y from 'yjs';
 
 const PROSEMIRROR_FRAGMENT_NAME = 'prosemirror';
@@ -179,7 +179,7 @@ function validateJsonContent(
     return jsonContent;
   }
 
-  return ProseMirrorNode.fromJSON(schema, jsonContent).toJSON() as JSONContent;
+  return schema.nodeFromJSON(jsonContent).toJSON() as JSONContent;
 }
 
 export function convertJsonContentToYjsState(