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

refactor(resources): update getRoot

Author: ycdzj

src/api-key/api-key.service.ts

@@ -206,7 +206,9 @@ export class APIKeyService {
 
   async info(apiKey: APIKey): Promise<APIKeyInfoDto> {
     // Get the namespace
-    const namespace = await this.namespacesService.get(apiKey.namespaceId);
+    const namespace = await this.namespacesService.getNamespace(
+      apiKey.namespaceId,
+    );
 
     // Get the user
     const user = await this.userService.find(apiKey.userId);

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

@@ -1,7 +1,7 @@
 import { Expose } from 'class-transformer';
 import { ResourceMetaDto } from 'omniboxd/resources/dto/resource-meta.dto';
 
-export class ListChildrenRespDto extends ResourceMetaDto {
+export class ChildrenMetaDto extends ResourceMetaDto {
   @Expose({ name: 'has_children' })
   hasChildren: boolean;
 

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

@@ -6,7 +6,6 @@ import {
   IsOptional,
   IsNotEmpty,
 } from 'class-validator';
-import { UpdateResourceReqDto } from 'omniboxd/resources/dto/update-resource-req.dto';
 import { ResourceType } from 'omniboxd/resources/entities/resource.entity';
 
 export class UpdateResourceDto {
@@ -39,14 +38,4 @@ export class UpdateResourceDto {
   @IsObject()
   @IsOptional()
   attrs?: Record<string, any>;
-
-  toUpdateReq(): UpdateResourceReqDto {
-    const updateReq = new UpdateResourceReqDto();
-    updateReq.name = this.name;
-    updateReq.parentId = this.parentId;
-    updateReq.tagIds = this.tag_ids ? this.tag_ids : undefined;
-    updateReq.content = this.content;
-    updateReq.attrs = this.attrs;
-    return updateReq;
-  }
 }

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

@@ -18,7 +18,7 @@ import {
 import { UserId } from 'omniboxd/decorators/user-id.decorator';
 import { Request } from 'express';
 import { ResourceMetaDto } from 'omniboxd/resources/dto/resource-meta.dto';
-import { ListChildrenRespDto } from './dto/list-children-resp.dto';
+import { ChildrenMetaDto } from './dto/list-children-resp.dto';
 
 @Controller('api/v1/namespaces/:namespaceId/resources')
 export class NamespaceResourcesController {
@@ -92,7 +92,7 @@ export class NamespaceResourcesController {
     @UserId() userId: string,
     @Param('namespaceId') namespaceId: string,
     @Param('resourceId') resourceId: string,
-  ): Promise<ListChildrenRespDto[]> {
+  ): Promise<ChildrenMetaDto[]> {
     return this.namespaceResourcesService.listChildren(
       namespaceId,
       resourceId,
@@ -107,12 +107,12 @@ export class NamespaceResourcesController {
     @Param('resourceId') resourceId: string,
     @Param('targetId') targetId: string,
   ) {
-    return await this.namespaceResourcesService.move({
-      userId: req.user!.id,
+    return await this.namespaceResourcesService.move(
       namespaceId,
       resourceId,
+      req.user!.id,
       targetId,
-    });
+    );
   }
 
   @Get('search')

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

@@ -40,7 +40,7 @@ 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';
+import { ChildrenMetaDto } from './dto/list-children-resp.dto';
 
 const TASK_PRIORITY = 5;
 
@@ -128,28 +128,6 @@ 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 [];
@@ -186,6 +164,12 @@ export class NamespaceResourcesService {
     data: CreateResourceDto,
     manager?: EntityManager,
   ) {
+    if (!manager) {
+      return await this.dataSource.transaction(async (manager) => {
+        return await this.create(userId, data, manager);
+      });
+    }
+
     const ok = await this.permissionsService.userHasPermission(
       data.namespaceId,
       data.parentId,
@@ -198,49 +182,14 @@ export class NamespaceResourcesService {
       throw new ForbiddenException('Not authorized to create resource.');
     }
 
-    const transaction = async (manager: EntityManager) => {
-      const repo = manager.getRepository(Resource);
-      const parentResource = await repo.findOne({
-        where: {
-          id: data.parentId,
-          namespaceId: data.namespaceId,
-        },
-      });
-      if (!parentResource) {
-        throw new BadRequestException('Parent resource not exists.');
-      }
-      if (data.namespaceId && parentResource.namespaceId !== data.namespaceId) {
-        throw new BadRequestException(
-          "Parent resource's namespace & space must match the resource's.",
-        );
-      }
-
-      // Use provided tag_ids directly
-      const tagIds = data.tag_ids || [];
-
-      const resource = repo.create({
+    return await this.resourcesService.createResource(
+      {
         ...data,
         userId,
-        namespaceId: data.namespaceId,
-        parentId: parentResource.id,
-        tagIds: tagIds.length > 0 ? tagIds : undefined,
-      });
-      const savedResource = await repo.save(resource);
-      await this.wizardTaskService.createIndexTask(
-        TASK_PRIORITY,
-        userId,
-        savedResource,
-        manager.getRepository(Task),
-      );
-      return savedResource;
-    };
-
-    if (manager) {
-      return await transaction(manager);
-    }
-    return await this.dataSource.transaction(async (manager) => {
-      return await transaction(manager);
-    });
+        tagIds: data.tag_ids,
+      },
+      manager,
+    );
   }
 
   async duplicate(userId: string, resourceId: string) {
@@ -370,33 +319,26 @@ export class NamespaceResourcesService {
       : resourcesWithTags;
   }
 
-  async move({ namespaceId, resourceId, targetId, userId }) {
-    const resourceHasPermission =
-      await this.permissionsService.userHasPermission(
-        namespaceId,
-        resourceId,
-        userId,
-      );
-    if (!resourceHasPermission) {
+  async move(
+    namespaceId: string,
+    resourceId: string,
+    userId: string,
+    targetId: string,
+  ) {
+    const ok = await this.permissionsService.userHasPermission(
+      namespaceId,
+      resourceId,
+      userId,
+    );
+    if (!ok) {
       throw new ForbiddenException('Not authorized');
     }
-    const resource = await this.resourceRepository.findOneByOrFail({
-      id: resourceId,
-    });
-
-    // Validate that the target resource exists
-    const targetResource = await this.resourceRepository.findOne({
-      where: { namespaceId, id: targetId },
-    });
-    if (!targetResource) {
-      throw new NotFoundException('Target resource not found');
-    }
-
-    const newResource = this.resourceRepository.create({
-      ...resource,
-      parentId: targetId,
-    });
-    await this.resourceRepository.save(newResource);
+    await this.resourcesService.updateResource(
+      namespaceId,
+      resourceId,
+      userId,
+      { parentId: targetId },
+    );
   }
 
   async search({ namespaceId, excludeResourceId, name, userId }) {
@@ -470,10 +412,9 @@ export class NamespaceResourcesService {
     if (permission === ResourcePermission.NO_ACCESS) {
       return [];
     }
-    const children = await this.resourcesService.getSubResources(
-      namespaceId,
+    const children = await this.resourcesService.getSubResources(namespaceId, [
       parents[0].id,
-    );
+    ]);
     const filteredChildren: ResourceMetaDto[] = [];
     for (const child of children) {
       const permission = await this.permissionsService.getCurrentPermission(
@@ -492,26 +433,47 @@ export class NamespaceResourcesService {
     namespaceId: string,
     resourceId: string,
     userId: string,
-  ): Promise<ListChildrenRespDto[]> {
+  ): Promise<ChildrenMetaDto[]> {
     const parents = await this.resourcesService.getParentResourcesOrFail(
       namespaceId,
       resourceId,
     );
-    const children = await this.getSubResourcesByParents(
+    const children = await this.resourcesService.getSubResources(namespaceId, [
+      resourceId,
+    ]);
+    const subChildren = await this.resourcesService.getSubResources(
+      namespaceId,
+      children.map((child) => child.id),
+    );
+    const resources = [...parents, ...children, ...subChildren];
+    const permissionMap = await this.permissionsService.getCurrentPermissions(
       namespaceId,
-      parents,
       userId,
+      resources,
     );
-    const resps: ListChildrenRespDto[] = [];
+
+    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;
+      }
+      hasChildrenMap.set(subChild.parentId, true);
+    }
+
+    const childrenDtos: ChildrenMetaDto[] = [];
     for (const child of children) {
-      const hasChildren = await this.hasChildren(
-        namespaceId,
-        [child, ...parents],
-        userId,
-      );
-      resps.push(new ListChildrenRespDto(child, hasChildren));
+      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 resps;
+    return childrenDtos;
   }
 
   async getSpaceType(
@@ -586,12 +548,17 @@ export class NamespaceResourcesService {
     return resource;
   }
 
-  async update(userId: string, id: string, data: UpdateResourceDto) {
+  async update(userId: string, resourceId: string, data: UpdateResourceDto) {
     await this.resourcesService.updateResource(
       data.namespaceId,
-      id,
+      resourceId,
       userId,
-      data.toUpdateReq(),
+      {
+        name: data.name,
+        tagIds: data.tag_ids,
+        content: data.content,
+        attrs: data.attrs,
+      },
     );
   }
 
@@ -792,22 +759,6 @@ export class NamespaceResourcesService {
     return { fileStream, resource };
   }
 
-  async createFolder(
-    namespaceId: string,
-    parentId: string | null,
-    userId: string | null,
-    manager: EntityManager,
-  ) {
-    return await manager.save(
-      manager.create(Resource, {
-        resourceType: ResourceType.FOLDER,
-        namespaceId,
-        parentId,
-        userId,
-      }),
-    );
-  }
-
   async listAllUserAccessibleResources(
     namespaceId: string,
     userId: string,

src/namespaces/namespaces.controller.ts

@@ -23,7 +23,7 @@ export class NamespacesController {
 
   @Get(':namespaceId')
   async get(@Param('namespaceId') namespaceId: string) {
-    return await this.namespacesService.get(namespaceId);
+    return await this.namespacesService.getNamespace(namespaceId);
   }
 
   @Get(':namespaceId/members')

src/namespaces/namespaces.module.ts

@@ -8,6 +8,7 @@ import { Namespace } from './entities/namespace.entity';
 import { NamespaceMember } from './entities/namespace-member.entity';
 import { NamespaceResourcesModule } from 'omniboxd/namespace-resources/namespace-resources.module';
 import { PermissionsModule } from 'omniboxd/permissions/permissions.module';
+import { ResourcesModule } from 'omniboxd/resources/resources.module';
 
 @Module({
   exports: [NamespacesService],
@@ -16,6 +17,7 @@ import { PermissionsModule } from 'omniboxd/permissions/permissions.module';
   imports: [
     UserModule,
     NamespaceResourcesModule,
+    ResourcesModule,
     PermissionsModule,
     TypeOrmModule.forFeature([Resource]),
     TypeOrmModule.forFeature([Namespace]),