[backend-api] Add connection.service.ts

backend-api/.prettierrc

@@ -1,7 +1,7 @@
 {
   "parser": "typescript",
   "singleQuote": true,
-  "printWidth": 125,
+  "printWidth": 100,
   "tabWidth": 2,
   "useTabs": false,
   "semi": true,

backend-api/src/database/connection/connection.service.spec.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { ConnectionService } from './connection.service';
+
+describe('ConnectionService', () => {
+  let service: ConnectionService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [ConnectionService],
+    }).compile();
+
+    service = module.get<ConnectionService>(ConnectionService);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+});

backend-api/src/database/connection/connection.service.ts

@@ -0,0 +1,32 @@
+import { Injectable } from '@nestjs/common';
+import { CreateDatabaseDto } from '../dto/create-database.dto';
+import { QueryExecuteDto } from '../dto/query-execute.dto';
+import { KnexOptions } from '@nestjsplus/knex';
+
+const Knex = require('knex');
+const knexConnections = new Map<string, any>();
+
+@Injectable()
+export class ConnectionService {
+  addKnex(name: string, options: KnexOptions) {
+    if (!this.hasKnex(name)) {
+      knexConnections.set(name, new Knex(options));
+    }
+  }
+
+  removeKnex(name: string) {
+    knexConnections.delete(name);
+  }
+
+  hasKnex(name: string): boolean {
+    return knexConnections.has(name);
+  }
+
+  getKnex(name: string) {
+    return knexConnections.get(name);
+  }
+
+  async testConnection(createDatabaseDto: CreateDatabaseDto) {}
+
+  async executeQuery(queryExecuteDto: QueryExecuteDto) {}
+}

backend-api/src/database/database.controller.ts

@@ -3,10 +3,14 @@ import { DatabaseService } from './database.service';
 import { CreateDatabaseDto } from './dto/create-database.dto';
 import { UpdateDatabaseDto } from './dto/update-database.dto';
 import { QueryExecuteDto } from './dto/query-execute.dto';
+import { ConnectionService } from './connection/connection.service';
 
 @Controller('database')
 export class DatabaseController {
-  constructor(private readonly databaseService: DatabaseService) {}
+  constructor(
+    private readonly databaseService: DatabaseService,
+    private readonly connectionService: ConnectionService,
+  ) {}
 
   @Post()
   create(@Body() createDatabaseDto: CreateDatabaseDto) {
@@ -15,12 +19,12 @@ export class DatabaseController {
 
   @Post('test')
   testConnection(@Body() createDatabaseDto: CreateDatabaseDto) {
-    return this.databaseService.testConnection(createDatabaseDto);
+    return this.connectionService.testConnection(createDatabaseDto);
   }
 
   @Post('execute')
   executeQuery(@Body() queryExecuteDto: QueryExecuteDto) {
-    return this.databaseService.executeQuery(queryExecuteDto);
+    return this.connectionService.executeQuery(queryExecuteDto);
   }
 
   @Get()

backend-api/src/database/database.module.ts

@@ -3,10 +3,11 @@ import { DatabaseService } from './database.service';
 import { DatabaseController } from './database.controller';
 import { TypeOrmModule } from '@nestjs/typeorm';
 import { Database } from './entities/database.entity';
+import { ConnectionService } from './connection/connection.service';
 
 @Module({
   imports: [TypeOrmModule.forFeature([Database])],
   controllers: [DatabaseController],
-  providers: [DatabaseService],
+  providers: [DatabaseService, ConnectionService],
 })
 export class DatabaseModule {}

backend-api/src/database/database.service.ts

@@ -4,7 +4,6 @@ import { UpdateDatabaseDto } from './dto/update-database.dto';
 import { InjectRepository } from '@nestjs/typeorm';
 import { Database } from './entities/database.entity';
 import { Repository } from 'typeorm';
-import { QueryExecuteDto } from './dto/query-execute.dto';
 
 @Injectable()
 export class DatabaseService {
@@ -19,10 +18,6 @@ export class DatabaseService {
     return await this.databaseRepository.save(database);
   }
 
-  async testConnection(createDatabaseDto: CreateDatabaseDto) {}
-
-  async executeQuery(queryExecuteDto: QueryExecuteDto) {}
-
   async findAll(): Promise<Database[]> {
     return await this.databaseRepository.find();
   }