Merge pull request #164 from import-ai/refactor/resources

refactor(resources): update listChildren

Author: LucienShui

src/app/app.module.ts

@@ -1,4 +1,5 @@
 import {
+  ClassSerializerInterceptor,
   DynamicModule,
   MiddlewareConsumer,
   Module,
@@ -54,13 +55,17 @@ export class AppModule implements NestModule {
       module: AppModule,
       controllers: [AppController],
       providers: [
+        {
+          provide: APP_PIPE,
+          useClass: ValidationPipe,
+        },
         {
           provide: APP_INTERCEPTOR,
           useClass: SnakeCaseInterceptor,
         },
         {
-          provide: APP_PIPE,
-          useClass: ValidationPipe,
+          provide: APP_INTERCEPTOR,
+          useClass: ClassSerializerInterceptor,
         },
       ],
       imports: [

src/namespace-resources/dto/list-children-resp.dto.ts

@@ -0,0 +1,13 @@
+import { Expose } from 'class-transformer';
+import { ResourceMetaDto } from 'omniboxd/resources/dto/resource-meta.dto';
+
+export class ListChildrenRespDto extends ResourceMetaDto {
+  @Expose({ name: 'has_children' })
+  hasChildren: boolean;
+
+  constructor(resourceMeta: ResourceMetaDto, hasChildren: boolean) {
+    super();
+    Object.assign(this, resourceMeta);
+    this.hasChildren = hasChildren;
+  }
+}

src/namespace-resources/dto/resource.dto.ts

@@ -1,4 +1,5 @@
 import { ResourcePermission } from 'omniboxd/permissions/resource-permission.enum';
+import { ResourceMetaDto } from 'omniboxd/resources/dto/resource-meta.dto';
 import {
   Resource,
   ResourceType,
@@ -10,30 +11,6 @@ export enum SpaceType {
   TEAM = 'teamspace',
 }
 
-export class ResourceMetaDto {
-  id: string;
-  parent_id: string | null;
-  name: string;
-  resource_type: string;
-  attrs: Record<string, any>;
-  tags: TagDto[];
-  created_at: string;
-  updated_at: string;
-
-  static fromEntity(resource: Resource, tags: TagDto[] = []) {
-    const dto = new ResourceMetaDto();
-    dto.id = resource.id;
-    dto.parent_id = resource.parentId;
-    dto.name = resource.name;
-    dto.resource_type = resource.resourceType;
-    dto.attrs = resource.attrs;
-    dto.tags = tags;
-    dto.created_at = resource.createdAt.toISOString();
-    dto.updated_at = resource.updatedAt.toISOString();
-    return dto;
-  }
-}
-
 export class ResourceDto {
   id: string;
   namespace_id: string;

src/namespace-resources/namespace-resources.controller.ts

@@ -17,7 +17,8 @@ import {
 } from '@nestjs/common';
 import { UserId } from 'omniboxd/decorators/user-id.decorator';
 import { Request } from 'express';
-import { ResourceMetaDto } from 'omniboxd/namespace-resources/dto/resource.dto';
+import { ResourceMetaDto } from 'omniboxd/resources/dto/resource-meta.dto';
+import { ListChildrenRespDto } from './dto/list-children-resp.dto';
 
 @Controller('api/v1/namespaces/:namespaceId/resources')
 export class NamespaceResourcesController {
@@ -91,7 +92,7 @@ export class NamespaceResourcesController {
     @UserId() userId: string,
     @Param('namespaceId') namespaceId: string,
     @Param('resourceId') resourceId: string,
-  ): Promise<ResourceMetaDto[]> {
+  ): Promise<ListChildrenRespDto[]> {
     return this.namespaceResourcesService.listChildren(
       namespaceId,
       resourceId,

src/namespace-resources/namespace-resources.e2e-spec.ts

@@ -676,17 +676,6 @@ describe('ResourcesController (e2e)', () => {
       );
       expect(childResource).toBeDefined();
       expect(childResource.name).toBe('Child Resource for List');
-      expect(childResource.attrs).toEqual(childAttrs);
-
-      // Check for required timestamp fields
-      expect(childResource).toHaveProperty('created_at');
-      expect(childResource).toHaveProperty('updated_at');
-      expect(childResource.created_at).toMatch(
-        /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/,
-      );
-      expect(childResource.updated_at).toMatch(
-        /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/,
-      );
     });
 
     it('should return empty array for resource with no children', async () => {
@@ -836,7 +825,6 @@ describe('ResourcesController (e2e)', () => {
       );
       expect(foundResource).toBeDefined();
       expect(foundResource.name).toBe('Searchable Document');
-      expect(foundResource.attrs).toEqual(searchAttrs);
     });
 
     it('should search resources by partial name and validate attrs match source', async () => {
@@ -852,7 +840,6 @@ describe('ResourcesController (e2e)', () => {
         (r: any) => r.id === searchableResourceId,
       );
       expect(foundResource).toBeDefined();
-      expect(foundResource.attrs).toEqual(searchAttrs);
     });
 
     it('should return empty array for non-matching search', async () => {
@@ -1070,7 +1057,6 @@ describe('ResourcesController (e2e)', () => {
         (r: any) => r.id === testResourceId,
       );
       expect(foundResource).toBeDefined();
-      expect(foundResource.attrs).toEqual(complexAttrs);
     });
 
     it('should preserve attrs in search endpoint', async () => {
@@ -1085,7 +1071,6 @@ describe('ResourcesController (e2e)', () => {
         (r: any) => r.id === testResourceId,
       );
       expect(foundResource).toBeDefined();
-      expect(foundResource.attrs).toEqual(complexAttrs);
     });
 
     it('should preserve attrs after update', async () => {

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

@@ -33,12 +33,14 @@ 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 { Response } from 'express';
-import { ResourceDto, ResourceMetaDto, SpaceType } from './dto/resource.dto';
+import { ResourceDto, SpaceType } from './dto/resource.dto';
 import { Namespace } from 'omniboxd/namespaces/entities/namespace.entity';
 import { TagService } from 'omniboxd/tag/tag.service';
 import { TagDto } from 'omniboxd/tag/dto/tag.dto';
 import { ResourceAttachmentsService } from 'omniboxd/resource-attachments/resource-attachments.service';
 import { ResourcesService } from 'omniboxd/resources/resources.service';
+import { ResourceMetaDto } from 'omniboxd/resources/dto/resource-meta.dto';
+import { ListChildrenRespDto } from './dto/list-children-resp.dto';
 
 const TASK_PRIORITY = 5;
 
@@ -128,6 +130,28 @@ export class NamespaceResourcesService {
     return resources.map((resource) => resource.id);
   }
 
+  private async hasChildren(
+    namespaceId: string,
+    parents: ResourceMetaDto[],
+    userId: string,
+  ): Promise<boolean> {
+    const children = await this.resourcesService.getSubResources(
+      namespaceId,
+      parents[0].id,
+    );
+    for (const child of children) {
+      const permission = await this.permissionsService.getCurrentPermission(
+        namespaceId,
+        [child, ...parents],
+        userId,
+      );
+      if (permission !== ResourcePermission.NO_ACCESS) {
+        return true;
+      }
+    }
+    return false;
+  }
+
   async findByIds(namespaceId: string, ids: Array<string>) {
     if (ids.length <= 0) {
       return [];
@@ -384,13 +408,17 @@ export class NamespaceResourcesService {
     };
     // Self and child exclusions
     if (excludeResourceId) {
-      const resourceChildren = await this.getAllSubResources(
+      const resourceChildren = await this.getSubResourcesByUser(
         namespaceId,
         excludeResourceId,
-        '',
-        true,
+        userId,
+      );
+      where.id = Not(
+        In([
+          excludeResourceId,
+          ...resourceChildren.map((children) => children.id),
+        ]),
       );
-      where.id = Not(In(resourceChildren.map((children) => children.id)));
     }
     if (name) {
       where.name = Like(`%${name}%`);
@@ -406,90 +434,84 @@ export class NamespaceResourcesService {
       userId,
       resources,
     );
-
-    // Load tags for filtered resources
-    const tagsMap = await this.getTagsForResources(
-      namespaceId,
-      filteredResources,
-    );
-
-    return filteredResources.map((res) =>
-      ResourceMetaDto.fromEntity(res, tagsMap.get(res.id) || []),
-    );
-  }
-
-  async getAllSubResources(
-    namespaceId: string,
-    parentId: string,
-    userId?: string,
-    includeRoot: boolean = false,
-  ): Promise<Resource[]> {
-    let resources: Resource[] = [await this.get(parentId)];
-    for (const res of resources) {
-      const subResources: Resource[] = await this.query(namespaceId, res.id);
-      resources.push(...subResources);
-    }
-    resources = includeRoot ? resources : resources.slice(1);
-    return userId
-      ? await this.permissionFilter(namespaceId, userId, resources)
-      : resources;
+    return filteredResources.map((res) => ResourceMetaDto.fromEntity(res));
   }
 
-  async listChildren(
+  async getSubResourcesByUser(
     namespaceId: string,
     resourceId: string,
     userId: string,
   ): Promise<ResourceMetaDto[]> {
-    const parentResources = await this.resourcesService.getParentResources(
+    const parents = await this.resourcesService.getParentResources(
       namespaceId,
       resourceId,
     );
+    const children = await this.getSubResourcesByParents(
+      namespaceId,
+      parents,
+      userId,
+    );
+    return children;
+  }
+
+  async getSubResourcesByParents(
+    namespaceId: string,
+    parents: ResourceMetaDto[],
+    userId: string,
+  ): Promise<ResourceMetaDto[]> {
+    if (!parents) {
+      return [];
+    }
     const permission = await this.permissionsService.getCurrentPermission(
       namespaceId,
-      parentResources,
+      parents,
       userId,
     );
     if (permission === ResourcePermission.NO_ACCESS) {
       return [];
     }
-
-    const children = await this.resourceRepository.find({
-      select: [
-        'id',
-        'name',
-        'parentId',
-        'resourceType',
-        'attrs',
-        'tagIds',
-        'createdAt',
-        'updatedAt',
-      ],
-      where: {
-        namespaceId,
-        parentId: resourceId,
-      },
-    });
-
-    const filteredChildren: Resource[] = [];
+    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, ...parentResources],
+        [child, ...parents],
         userId,
       );
       if (permission !== ResourcePermission.NO_ACCESS) {
         filteredChildren.push(child);
       }
     }
-    // Load tags for filtered children
-    const tagsMap = await this.getTagsForResources(
+    return filteredChildren;
+  }
+
+  async listChildren(
+    namespaceId: string,
+    resourceId: string,
+    userId: string,
+  ): Promise<ListChildrenRespDto[]> {
+    const parents = await this.resourcesService.getParentResources(
       namespaceId,
-      filteredChildren,
+      resourceId,
     );
-
-    return filteredChildren.map((r) =>
-      ResourceMetaDto.fromEntity(r, tagsMap.get(r.id) || []),
+    const children = await this.getSubResourcesByParents(
+      namespaceId,
+      parents,
+      userId,
     );
+    const resps: ListChildrenRespDto[] = [];
+    for (const child of children) {
+      const hasChildren = await this.hasChildren(
+        namespaceId,
+        [child, ...parents],
+        userId,
+      );
+      resps.push(new ListChildrenRespDto(child, hasChildren));
+    }
+    return resps;
   }
 
   async getSpaceType(
@@ -528,24 +550,20 @@ export class NamespaceResourcesService {
       : resourceId;
     const spaceType = await this.getSpaceType(namespaceId, rootResourceId);
 
+    const resourceMeta = ResourceMetaDto.fromEntity(resource);
     const curPermission = await this.permissionsService.getCurrentPermission(
       namespaceId,
-      [resource, ...parentResources],
+      [resourceMeta, ...parentResources],
       userId,
     );
 
     if (curPermission === ResourcePermission.NO_ACCESS) {
       throw new ForbiddenException('Not authorized');
     }
 
-    // Load tags for resource and path
-    const allResources = [resource, ...parentResources];
-    const tagsMap = await this.getTagsForResources(namespaceId, allResources);
-
-    const path = [resource, ...parentResources]
-      .map((r) => ResourceMetaDto.fromEntity(r, tagsMap.get(r.id) || []))
-      .reverse();
-
+    // Load tags of the resource
+    const tagsMap = await this.getTagsForResources(namespaceId, [resource]);
+    const path = [resourceMeta, ...parentResources].reverse();
     return ResourceDto.fromEntity(
       resource,
       curPermission,