Merge pull request #209 from import-ai/refactor/namespaces

refactor(namespaces): add getAllSubResourcesByUser

Author: ycdzj

src/namespace-resources/namespace-resources.service.ts

@@ -27,7 +27,10 @@ import { MinioService } from 'omniboxd/minio/minio.service';
 import { WizardTaskService } from 'omniboxd/tasks/wizard-task.service';
 import { PermissionsService } from 'omniboxd/permissions/permissions.service';
 import { PrivateSearchResourceDto } from 'omniboxd/wizard/dto/agent-request.dto';
-import { ResourcePermission } from 'omniboxd/permissions/resource-permission.enum';
+import {
+  comparePermission,
+  ResourcePermission,
+} from 'omniboxd/permissions/resource-permission.enum';
 import { Response } from 'express';
 import { ResourceDto, SpaceType } from './dto/resource.dto';
 import { Namespace } from 'omniboxd/namespaces/entities/namespace.entity';
@@ -401,40 +404,49 @@ export class NamespaceResourcesService {
       namespaceId,
       resourceId,
     );
-    return await this.getSubResourcesByParents(namespaceId, parents, userId);
+    const subResources = await this.resourcesService.getSubResources(
+      namespaceId,
+      [resourceId],
+    );
+    const permissionMap = await this.permissionsService.getCurrentPermissions(
+      userId,
+      namespaceId,
+      [...parents, ...subResources],
+    );
+    return subResources.filter((res) => {
+      const permission = permissionMap.get(res.id);
+      return (
+        permission &&
+        comparePermission(permission, ResourcePermission.CAN_VIEW) >= 0
+      );
+    });
   }
 
-  async getSubResourcesByParents(
-    namespaceId: string,
-    parents: ResourceMetaDto[],
+  async getAllSubResourcesByUser(
     userId: string,
+    namespaceId: string,
+    resourceId: string,
   ): Promise<ResourceMetaDto[]> {
-    if (!parents) {
-      return [];
-    }
-    const permission = await this.permissionsService.getCurrentPermission(
+    const parents = await this.resourcesService.getParentResourcesOrFail(
       namespaceId,
-      parents,
+      resourceId,
+    );
+    const allSubResources = await this.resourcesService.getAllSubResources(
+      namespaceId,
+      [resourceId],
+    );
+    const permissionMap = await this.permissionsService.getCurrentPermissions(
       userId,
+      namespaceId,
+      [...parents, ...allSubResources],
     );
-    if (permission === ResourcePermission.NO_ACCESS) {
-      return [];
-    }
-    const children = await this.resourcesService.getSubResources(namespaceId, [
-      parents[0].id,
-    ]);
-    const filteredChildren: ResourceMetaDto[] = [];
-    for (const child of children) {
-      const permission = await this.permissionsService.getCurrentPermission(
-        namespaceId,
-        [child, ...parents],
-        userId,
+    return allSubResources.filter((res) => {
+      const permission = permissionMap.get(res.id);
+      return (
+        permission &&
+        comparePermission(permission, ResourcePermission.CAN_VIEW) >= 0
       );
-      if (permission !== ResourcePermission.NO_ACCESS) {
-        filteredChildren.push(child);
-      }
-    }
-    return filteredChildren;
+    });
   }
 
   async listChildren(
@@ -446,42 +458,45 @@ export class NamespaceResourcesService {
       namespaceId,
       resourceId,
     );
-    const children = await this.resourcesService.getSubResources(namespaceId, [
+    let children = await this.resourcesService.getSubResources(namespaceId, [
       resourceId,
     ]);
-    const subChildren = await this.resourcesService.getSubResources(
+    let subChildren = await this.resourcesService.getSubResources(
       namespaceId,
       children.map((child) => child.id),
     );
-    const resources = [...parents, ...children, ...subChildren];
     const permissionMap = await this.permissionsService.getCurrentPermissions(
       userId,
       namespaceId,
-      resources,
+      [...parents, ...children, ...subChildren],
     );
 
+    children = children.filter((res) => {
+      const permission = permissionMap.get(res.id);
+      return (
+        permission &&
+        comparePermission(permission, ResourcePermission.CAN_VIEW) >= 0
+      );
+    });
+
+    subChildren = subChildren.filter((res) => {
+      const permission = permissionMap.get(res.id);
+      return (
+        permission &&
+        comparePermission(permission, ResourcePermission.CAN_VIEW) >= 0
+      );
+    });
+
     const hasChildrenMap = new Map<string, boolean>();
-    for (const subChild of subChildren) {
-      if (!subChild.parentId) {
-        continue;
-      }
-      const permission = permissionMap.get(subChild.id);
-      if (!permission || permission === ResourcePermission.NO_ACCESS) {
-        continue;
+    for (const resource of subChildren) {
+      if (resource.parentId) {
+        hasChildrenMap.set(resource.parentId, true);
       }
-      hasChildrenMap.set(subChild.parentId, true);
     }
 
-    const childrenDtos: ChildrenMetaDto[] = [];
-    for (const child of children) {
-      const permission = permissionMap.get(child.id);
-      if (!permission || permission === ResourcePermission.NO_ACCESS) {
-        continue;
-      }
-      const hasChildren = hasChildrenMap.get(child.id) || false;
-      childrenDtos.push(new ChildrenMetaDto(child, hasChildren));
-    }
-    return childrenDtos;
+    return children.map(
+      (res) => new ChildrenMetaDto(res, !!hasChildrenMap.get(res.id)),
+    );
   }
 
   async getSpaceType(

src/resources/resources.service.ts

@@ -82,6 +82,9 @@ export class ResourcesService {
     return resource;
   }
 
+  /**
+   * Return the parents of a resource, including the resource itself.
+   */
   async getParentResources(
     namespaceId: string,
     resourceId: string | null,
@@ -134,17 +137,22 @@ export class ResourcesService {
 
   async getAllSubResources(
     namespaceId: string,
-    resourceId: string,
+    parentIds: string[],
   ): Promise<ResourceMetaDto[]> {
-    const children = await this.getSubResources(namespaceId, [resourceId]);
-    const allResources: ResourceMetaDto[] = [...children];
-
-    for (const child of children) {
-      const subResources = await this.getAllSubResources(namespaceId, child.id);
-      allResources.push(...subResources);
+    const resourcesMap: Map<string, ResourceMetaDto> = new Map();
+    while (parentIds.length > 0) {
+      const resources = await this.getSubResources(namespaceId, parentIds);
+      for (const resource of resources) {
+        if (resourcesMap.has(resource.id)) {
+          throw new UnprocessableEntityException(
+            'Cycle detected in the resource tree',
+          );
+        }
+        resourcesMap.set(resource.id, resource);
+      }
+      parentIds = resources.map((r) => r.id);
     }
-
-    return allResources;
+    return [...resourcesMap.values()];
   }
 
   async getAllResources(namespaceId: string): Promise<ResourceMetaDto[]> {
@@ -239,15 +247,7 @@ export class ResourcesService {
     }
 
     if (props.parentId) {
-      // Check if the parent belongs to the same namespace
-      await this.getResourceMetaOrFail(
-        namespaceId,
-        props.parentId,
-        entityManager,
-      );
-
-      // Check if there are any cycles
-      const parents = await this.getParentResources(
+      const parents = await this.getParentResourcesOrFail(
         namespaceId,
         props.parentId,
         entityManager,

src/shared-resources/shared-resources.service.ts

@@ -78,10 +78,9 @@ export class SharedResourcesService {
     }
 
     const subResources = share.allResources
-      ? await this.resourcesService.getAllSubResources(
-          share.namespaceId,
+      ? await this.resourcesService.getAllSubResources(share.namespaceId, [
           rootResource.id,
-        )
+        ])
       : [];
 
     const allResources = [

src/wizard/stream.service.ts

@@ -239,7 +239,7 @@ export class StreamService {
     for (const resource of resources) {
       if (resource.type === 'folder') {
         const resources =
-          await this.namespaceResourcesService.getSubResourcesByUser(
+          await this.namespaceResourcesService.getAllSubResourcesByUser(
             userId,
             namespaceId,
             resource.id,