feat(workspace-manager): added get directory api (#68)

Co-authored-by: Tom Zohar <60091317+Tcodrz@users.noreply.github.com>

Author: tomzo42

apps/cli-daemon/src/app/app.module.ts

@@ -5,10 +5,11 @@ import { AppService } from './app.service';
 import { GeneratorsModule } from './generators/generators.module';
 import { SessionService } from './session/session.service';
 import { WorkspaceModule } from './workspace/workspace.module';
+import { WorkspaceManagerModule } from './workspace-manager/workspace-manager.module';
 
 @Global()
 @Module({
-  imports: [WorkspaceModule, GeneratorsModule],
+  imports: [WorkspaceModule, GeneratorsModule, WorkspaceManagerModule],
   controllers: [AppController],
   providers: [AppService, SessionService],
   exports: [SessionService],

apps/cli-daemon/src/app/workspace-manager/dto/directory.dto.ts

@@ -0,0 +1,18 @@
+import { IsBoolean, IsOptional, IsString } from 'class-validator';
+
+export class DirectoryDto {
+  @IsString()
+  name: string;
+
+  @IsBoolean()
+  isNG: boolean;
+
+  @IsOptional()
+  isFavorite: boolean;
+
+  constructor(name: string, isNG = false, isFavorite = false) {
+    this.name = name;
+    this.isNG = isNG;
+    this.isFavorite = isFavorite;
+  }
+}

apps/cli-daemon/src/app/workspace-manager/entities/exception-messages.ts

@@ -0,0 +1 @@
+export const NOT_VALID_PATH_EXCEPTION = 'Not a valid path';

apps/cli-daemon/src/app/workspace-manager/entities/index.ts

@@ -0,0 +1 @@
+export * from './exception-messages';

apps/cli-daemon/src/app/workspace-manager/workspace-manager.controller.spec.ts

@@ -0,0 +1,54 @@
+import { InternalServerErrorException } from '@nestjs/common';
+import { Test, TestingModule } from '@nestjs/testing';
+
+import { WorkspaceManagerController } from './workspace-manager.controller';
+import { WorkspaceManagerService } from './workspace-manager.service';
+
+type WorkspaceManagerServiceMock = Record<
+  keyof WorkspaceManagerService,
+  jest.Mock
+>;
+const workspaceManagerMock: WorkspaceManagerServiceMock = {
+  getDirectoriesInPath: jest.fn(),
+};
+
+describe('WorkspaceManagerController', () => {
+  let controller: WorkspaceManagerController;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [WorkspaceManagerController],
+      providers: [
+        { provide: WorkspaceManagerService, useValue: workspaceManagerMock },
+      ],
+    }).compile();
+
+    controller = module.get<WorkspaceManagerController>(
+      WorkspaceManagerController
+    );
+  });
+
+  it('should be defined', () => {
+    expect(controller).toBeDefined();
+  });
+
+  describe('getDirectory', () => {
+    it('should call workspaceManagerService.getDirectoriesInPath', async () => {
+      await controller.getDirectory('abc');
+      expect(workspaceManagerMock.getDirectoriesInPath).toHaveBeenCalledWith(
+        'abc'
+      );
+    });
+
+    it('should throw InternalServerErrorException when workspaceManagerService.getDirectoriesInPath throws error', async () => {
+      workspaceManagerMock.getDirectoriesInPath.mockImplementationOnce(() => {
+        throw new Error();
+      });
+      try {
+        await controller.getDirectory('');
+      } catch (err) {
+        expect(err).toEqual(new InternalServerErrorException());
+      }
+    });
+  });
+});

apps/cli-daemon/src/app/workspace-manager/workspace-manager.controller.ts

@@ -0,0 +1,27 @@
+import {
+  Controller,
+  Get,
+  InternalServerErrorException,
+  Query,
+} from '@nestjs/common';
+
+import { DirectoryDto } from './dto/directory.dto';
+import { WorkspaceManagerService } from './workspace-manager.service';
+
+@Controller('workspace-manager')
+export class WorkspaceManagerController {
+  constructor(
+    private readonly workspaceManagerService: WorkspaceManagerService
+  ) {}
+
+  @Get('dir')
+  public async getDirectory(
+    @Query('path') path: string
+  ): Promise<DirectoryDto[]> {
+    try {
+      return this.workspaceManagerService.getDirectoriesInPath(path);
+    } catch (err) {
+      throw new InternalServerErrorException();
+    }
+  }
+}

apps/cli-daemon/src/app/workspace-manager/workspace-manager.module.ts

@@ -0,0 +1,10 @@
+import { Module } from '@nestjs/common';
+
+import { WorkspaceManagerController } from './workspace-manager.controller';
+import { WorkspaceManagerService } from './workspace-manager.service';
+
+@Module({
+  controllers: [WorkspaceManagerController],
+  providers: [WorkspaceManagerService],
+})
+export class WorkspaceManagerModule {}

apps/cli-daemon/src/app/workspace-manager/workspace-manager.service.spec.ts

@@ -0,0 +1,83 @@
+import { Dirent } from 'fs';
+import fs from 'fs/promises';
+
+import { BadRequestException } from '@nestjs/common';
+import { Test, TestingModule } from '@nestjs/testing';
+
+import { SessionService } from '../session/session.service';
+
+import { DirectoryDto } from './dto/directory.dto';
+import { NOT_VALID_PATH_EXCEPTION } from './entities';
+import { WorkspaceManagerService } from './workspace-manager.service';
+
+jest.mock('fs/promises', () => ({
+  readdir: jest.fn().mockImplementation(
+    (path: string) =>
+      new Promise((resolve, reject) => {
+        if (path === 'error path') reject('invalid');
+        resolve(mockDirectory);
+      })
+  ),
+}));
+
+const mockDirectory: Partial<Dirent>[] = [
+  { name: 'a', isDirectory: () => true },
+  { name: 'b', isDirectory: () => false },
+];
+
+type SessionServiceMock = Partial<Record<keyof SessionService, jest.Mock>>;
+
+describe('WorkspaceManagerService', () => {
+  let service: WorkspaceManagerService;
+  let sessionServiceMock: SessionServiceMock;
+
+  beforeEach(async () => {
+    sessionServiceMock = {
+      cwd: jest.fn().mockReturnValue('users/home')(),
+    };
+
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        WorkspaceManagerService,
+        { provide: SessionService, useValue: sessionServiceMock },
+      ],
+    }).compile();
+
+    service = module.get<WorkspaceManagerService>(WorkspaceManagerService);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+
+  describe('getDirectoriesInPath', () => {
+    it('should call fs.readdir', () => {
+      service.getDirectoriesInPath('mock path');
+      expect(fs.readdir).toHaveBeenCalledWith('mock path', {
+        withFileTypes: true,
+      });
+    });
+
+    it('should return list of directories from a provided path', async () => {
+      const directories = await service.getDirectoriesInPath('mock path');
+      expect(directories).toEqual([new DirectoryDto('a', false)]);
+    });
+
+    it('should call readdir with root path when not provided a path', async () => {
+      await service.getDirectoriesInPath();
+      expect(fs.readdir).toHaveBeenCalledWith('users/home', {
+        withFileTypes: true,
+      });
+    });
+
+    it('should throw BadRequestException when called with invalid path', async () => {
+      try {
+        await service.getDirectoriesInPath('error path');
+      } catch (err) {
+        expect(err).toEqual(
+          new BadRequestException(`${NOT_VALID_PATH_EXCEPTION}: error path`)
+        );
+      }
+    });
+  });
+});

apps/cli-daemon/src/app/workspace-manager/workspace-manager.service.ts

@@ -0,0 +1,55 @@
+import fs from 'fs/promises';
+
+import { NodeJsSyncHost } from '@angular-devkit/core/node';
+import { createWorkspaceHost } from '@angular-devkit/core/src/workspace';
+import { readWorkspace as devKitReadWorkspace } from '@angular-devkit/core/src/workspace/core';
+import { BadRequestException, Injectable } from '@nestjs/common';
+
+import { SessionService } from '../session/session.service';
+
+import { DirectoryDto } from './dto/directory.dto';
+import { NOT_VALID_PATH_EXCEPTION } from './entities';
+
+@Injectable()
+export class WorkspaceManagerService {
+  constructor(private sessionService: SessionService) {}
+
+  public async getDirectoriesInPath(
+    path: string = this.sessionService.cwd
+  ): Promise<DirectoryDto[]> {
+    try {
+      const filesAndDirectories = await fs.readdir(path, {
+        withFileTypes: true,
+      });
+      return Promise.all(
+        filesAndDirectories
+          .filter((fileOrFolder) => fileOrFolder.isDirectory())
+          .map(
+            async (directory) =>
+              new DirectoryDto(
+                directory.name,
+                await this.isAngularWorkspace(directory.name, path)
+              )
+          )
+      );
+    } catch (e) {
+      throw new BadRequestException(`${NOT_VALID_PATH_EXCEPTION}: ${path}`);
+    }
+  }
+
+  private async isAngularWorkspace(
+    directoryName: string,
+    path: string
+  ): Promise<boolean> {
+    const fullPath = `${path}/${directoryName}`;
+    try {
+      const workspace = await devKitReadWorkspace(
+        fullPath,
+        createWorkspaceHost(new NodeJsSyncHost())
+      );
+      return !!workspace;
+    } catch (e) {
+      return false;
+    }
+  }
+}