@noya-app/noya-api-client-react 0.1.46 → 0.1.48

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@noya-app/noya-api-client-react",
-  "version": "0.1.46",
+  "version": "0.1.48",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
@@ -10,7 +10,7 @@
   },
   "dependencies": {
     "@legendapp/state": "^2.1.1",
-    "@noya-app/noya-api": "0.1.46",
+    "@noya-app/noya-api": "0.1.48",
     "@noya-app/noya-utils": "0.1.9",
     "@noya-app/observable": "0.1.12",
     "@noya-app/observable-store": "0.1.2",

package/src/react/hooks.ts

@@ -214,6 +214,45 @@ export function useNoyaWorkspaces() {
   return workspaces;
 }
 
+export type WorkspaceMemberInfo = {
+  userId: string;
+  name: string | null;
+  email: string | null;
+  image: string | null;
+  role: "OWNER" | "ADMIN" | "MEMBER";
+};
+
+/**
+ * Hook to get workspace members for a specific workspace.
+ * Returns the members array and a lookup map for easy access by userId.
+ */
+export function useNoyaWorkspaceMembers(workspaceId: string): {
+  members: WorkspaceMemberInfo[];
+  membersById: Map<string, WorkspaceMemberInfo>;
+  loading: boolean;
+} {
+  const { workspaces, loading } = useNoyaWorkspaces();
+
+  return useMemo(() => {
+    const workspace = workspaces.find((w) => w.id === workspaceId);
+    const members: WorkspaceMemberInfo[] =
+      workspace?.members.map((m) => ({
+        userId: m.userId,
+        name: m.user.name,
+        email: m.user.email,
+        image: m.user.image,
+        role: m.role,
+      })) ?? [];
+
+    const membersById = new Map<string, WorkspaceMemberInfo>();
+    for (const member of members) {
+      membersById.set(member.userId, member);
+    }
+
+    return { members, membersById, loading };
+  }, [workspaces, workspaceId, loading]);
+}
+
 export function useNoyaMultiplayerRoomToken(fileId: string) {
   const client = useNoyaClientOrFallback();
   const multiplayerRoomToken = useObservable(
@@ -298,3 +337,169 @@ export function useNoyaTemplates() {
     loading: loading === "fetching",
   };
 }
+
+export type WorkspaceRole = "OWNER" | "ADMIN" | "MEMBER";
+
+export type WorkspaceAccessInfo = {
+  isMember: boolean;
+  role: WorkspaceRole | null;
+  isOwner: boolean;
+  isAdmin: boolean;
+  workspaceId: string;
+  loading: boolean;
+};
+
+/**
+ * Get workspace membership and role information for the current user.
+ * Returns workspace access details including membership status and role.
+ */
+export function useWorkspaceAccess(workspaceId: string): WorkspaceAccessInfo {
+  const session = useNoyaSession();
+  const { workspaces, loading } = useNoyaWorkspaces();
+
+  return useMemo(() => {
+    const userId = session?.user?.id;
+    const workspace = workspaces.find((w) => w.id === workspaceId);
+
+    if (!workspace || !userId) {
+      return {
+        isMember: false,
+        role: null,
+        isOwner: false,
+        isAdmin: false,
+        workspaceId,
+        loading,
+      };
+    }
+
+    const member = workspace.members.find((m) => m.userId === userId);
+    const role = member?.role ?? null;
+
+    return {
+      isMember: !!member,
+      role,
+      isOwner: role === "OWNER",
+      isAdmin: role === "OWNER" || role === "ADMIN",
+      workspaceId,
+      loading,
+    };
+  }, [session?.user?.id, workspaces, workspaceId, loading]);
+}
+
+export type FileAccessSource = "owner" | "workspace" | "public" | "none";
+
+export type FileAccessInfo = {
+  isOwner: boolean;
+  canView: boolean;
+  canEdit: boolean;
+  accessSource: FileAccessSource;
+  loading: boolean;
+};
+
+type FileWithAccess = {
+  user?: { id: string } | null;
+  access?: NoyaAPI.FileAccess;
+  workspaceAccess?: NoyaAPI.FileAccess;
+  workspaceId?: string;
+};
+
+/**
+ * Get file access permissions for the current user.
+ * Considers ownership, workspace membership, and public access settings.
+ */
+export function useFileAccess(
+  file: FileWithAccess | null | undefined
+): FileAccessInfo {
+  const session = useNoyaSession();
+  const { workspaces, loading: workspacesLoading } = useNoyaWorkspaces();
+
+  return useMemo(() => {
+    const userId = session?.user?.id;
+
+    // Default: no access
+    const noAccess: FileAccessInfo = {
+      isOwner: false,
+      canView: false,
+      canEdit: false,
+      accessSource: "none",
+      loading: workspacesLoading,
+    };
+
+    if (!file) return noAccess;
+
+    // Check if user is the file owner
+    const isOwner = !!(userId && file.user?.id === userId);
+
+    if (isOwner) {
+      return {
+        isOwner: true,
+        canView: true,
+        canEdit: true,
+        accessSource: "owner",
+        loading: false,
+      };
+    }
+
+    // Check workspace access if user is a workspace member
+    if (file.workspaceId && userId) {
+      const workspace = workspaces.find((w) => w.id === file.workspaceId);
+      const isMember = workspace?.members.some((m) => m.userId === userId);
+
+      if (isMember) {
+        const workspaceAccess = file.workspaceAccess ?? "private";
+        if (workspaceAccess === "write") {
+          return {
+            isOwner: false,
+            canView: true,
+            canEdit: true,
+            accessSource: "workspace",
+            loading: false,
+          };
+        }
+        if (workspaceAccess === "read") {
+          return {
+            isOwner: false,
+            canView: true,
+            canEdit: false,
+            accessSource: "workspace",
+            loading: false,
+          };
+        }
+      }
+    }
+
+    // Check public access
+    const publicAccess = file.access ?? "private";
+    if (publicAccess === "write") {
+      return {
+        isOwner: false,
+        canView: true,
+        canEdit: true,
+        accessSource: "public",
+        loading: false,
+      };
+    }
+    if (publicAccess === "read") {
+      return {
+        isOwner: false,
+        canView: true,
+        canEdit: false,
+        accessSource: "public",
+        loading: false,
+      };
+    }
+
+    return noAccess;
+  }, [session?.user?.id, file, workspaces, workspacesLoading]);
+}
+
+export function useIsFileOwner(
+  file: { user?: { id: string } | null } | null | undefined
+): boolean {
+  const session = useNoyaSession();
+
+  return useMemo(() => {
+    if (!file || !session?.user?.id) return false;
+    return file.user?.id === session.user.id;
+  }, [file, session?.user?.id]);
+}