nest-knexjs 0.0.3 → 0.0.7

package/tests/app-multi-database/app/post/post.service.ts

@@ -0,0 +1,64 @@
+import { HttpException, HttpStatus, Injectable } from '@nestjs/common';
+import { CreatePostDto } from './dto/create-post.dto';
+import { UpdatePostDto } from './dto/update-post.dto';
+import { NotFoundException } from '@nestjs/common';
+import { Knex } from 'knex';
+import { InjectConnection } from '../../../../lib';
+
+@Injectable()
+export class PostService {
+  constructor(
+    @InjectConnection('db2Connection')
+    private knexConnection: Knex,
+  ) {}
+
+  async create(createPostDto: CreatePostDto) {
+    try {
+      const post = await this.knexConnection.table('posts').insert({
+        title: createPostDto.title,
+        description: createPostDto.description,
+      });
+
+      return post;
+    } catch (err) {
+      throw new HttpException(err, HttpStatus.BAD_REQUEST);
+    }
+  }
+
+  async findAll() {
+    const posts = await this.knexConnection.table('posts');
+    return { posts };
+  }
+
+  async findOne(id: number) {
+    if (!id) {
+      throw new NotFoundException('Post ID does not exist');
+    }
+    const posts = await this.knexConnection.table('posts').where('id', id);
+    return { posts };
+  }
+
+  async update(id: number, updatePostDto: UpdatePostDto) {
+    try {
+      const posts = await this.knexConnection
+        .table('posts')
+        .where('id', id)
+        .update({
+          title: updatePostDto.title,
+          description: updatePostDto.description,
+        });
+
+      return { posts };
+    } catch (err) {
+      throw new HttpException(err, HttpStatus.BAD_REQUEST);
+    }
+  }
+
+  async remove(id: number) {
+    if (!id) {
+      throw new NotFoundException('Post ID does not exist');
+    }
+    const post = await this.knexConnection.table('posts').where('id', id).del();
+    return { post };
+  }
+}

package/tests/app-multi-database/app/users/dto/create-user.dto.ts

@@ -0,0 +1,4 @@
+export class CreateUserDto {
+  firstName: string;
+  lastName: string;
+}

package/tests/app-multi-database/app/users/dto/update-user.dto.ts

@@ -0,0 +1,4 @@
+export class UpdateUserDto {
+    firstName: string;  
+    lastName: string;
+}

package/tests/app-multi-database/app/users/entities/user.entity.ts

@@ -0,0 +1,5 @@
+export class User {
+  id: number;
+  firstName: string;
+  lastName: string;
+}

package/tests/app-multi-database/app/users/users.controller.ts

@@ -0,0 +1,42 @@
+import {
+  Controller,
+  Get,
+  Post,
+  Body,
+  Put,
+  Param,
+  Delete,
+} from '@nestjs/common';
+import { UsersService } from './users.service';
+import { CreateUserDto } from './dto/create-user.dto';
+import { UpdateUserDto } from './dto/update-user.dto';
+
+@Controller('users')
+export class UsersController {
+  constructor(private readonly usersService: UsersService) {}
+
+  @Post()
+  create(@Body() createUserDto: CreateUserDto) {
+    return this.usersService.create(createUserDto);
+  }
+
+  @Get()
+  findAll() {
+    return this.usersService.findAll();
+  }
+
+  @Get(':id')
+  findOne(@Param('id') id: string) {
+    return this.usersService.findOne(+id);
+  }
+
+  @Put(':id')
+  update(@Param('id') id: string, @Body() updateUserDto: UpdateUserDto) {
+    return this.usersService.update(+id, updateUserDto);
+  }
+
+  @Delete(':id')
+  remove(@Param('id') id: string) {
+    return this.usersService.remove(+id);
+  }
+}

package/tests/app-multi-database/app/users/users.module.ts

@@ -0,0 +1,9 @@
+import { Module } from '@nestjs/common';
+import { UsersService } from './users.service';
+import { UsersController } from './users.controller';
+
+@Module({
+  controllers: [UsersController],
+  providers: [UsersService]
+})
+export class UsersModule {}

package/tests/app-multi-database/app/users/users.service.spec.ts

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

package/tests/app-multi-database/app/users/users.service.ts

@@ -0,0 +1,71 @@
+import {
+  HttpException,
+  HttpStatus,
+  Injectable,
+  NotFoundException,
+} from '@nestjs/common';
+import { Knex } from 'knex';
+import { InjectConnection } from '../../../../lib';
+import { CreateUserDto } from './dto/create-user.dto';
+import { UpdateUserDto } from './dto/update-user.dto';
+
+@Injectable()
+export class UsersService {
+  constructor(
+    @InjectConnection('db1Connection')
+    private knexConnection: Knex,
+  ) {}
+
+  async findAll() {
+    const users = await this.knexConnection.table('users');
+    return { users };
+  }
+
+  async create(createUserDto: CreateUserDto) {
+    try {
+      const users = await this.knexConnection.table('users').insert({
+        firstName: createUserDto.firstName,
+        lastName: createUserDto.lastName,
+      });
+
+      return { users };
+    } catch (err) {
+      throw new HttpException(err, HttpStatus.BAD_REQUEST);
+    }
+  }
+
+  async findOne(id: number) {
+    if (!id) {
+      throw new NotFoundException('User ID does not exist');
+    }
+    const users = await this.knexConnection.table('users').where('id', id);
+    return { users };
+  }
+
+  async update(id: number, updateUserDto: UpdateUserDto) {
+    try {
+      const users = await this.knexConnection
+        .table('users')
+        .where('id', id)
+        .update({
+          firstName: updateUserDto.firstName,
+          lastName: updateUserDto.lastName,
+        });
+
+      return { users };
+    } catch (err) {
+      throw new HttpException(err, HttpStatus.BAD_REQUEST);
+    }
+  }
+
+  async remove(id: number) {
+    if (!id) {
+      throw new NotFoundException('User ID does not exist');
+    }
+    const users = await this.knexConnection
+      .table('users')
+      .where('id', id)
+      .del();
+    return { users };
+  }
+}

package/tests/app-multi-database/docker-compose.yml

@@ -0,0 +1,21 @@
+version: "3"
+
+services:
+  db1:
+     image: mysql:5
+     restart: always
+     environment:
+       MYSQL_ROOT_USER: root
+       MYSQL_ROOT_PASSWORD: root
+       MYSQL_DATABASE: test1
+     ports:
+       - "3306:3306"
+  db2:
+     image: mysql:5
+     restart: always
+     environment:
+       MYSQL_ROOT_USER: root
+       MYSQL_ROOT_PASSWORD: root
+       MYSQL_DATABASE: test2
+     ports:
+       - "3307:3306"

package/tests/app-multi-database/knexfile.js

@@ -0,0 +1,34 @@
+module.exports = {
+  development: {
+    client: 'mysql',
+    version: '5.7',
+    connection: {
+      name: 'db1Connection',
+      host: '127.0.0.1',
+      user: 'root',
+      port: 3306,
+      password: 'root',
+      database: 'test1',
+    },
+    migrations: {
+      directory: './migrations/users',
+      tableName: '20210808150144_users',
+    },
+  },
+  developmentOne: {
+    client: 'mysql',
+    version: '5.7',
+    connection: {
+      name: 'db2Connection',
+      host: '127.0.0.1',
+      user: 'root',
+      port: 3307,
+      password: 'root',
+      database: 'test2',
+    },
+    migrations: {
+      directory: './migrations/posts',
+      tableName: '20210902093735_posts',
+    },
+  },
+};

package/tests/app-multi-database/migrations/posts/20210902093735_posts.js

@@ -0,0 +1,11 @@
+exports.up = function (knex) {
+  return knex.schema.createTable('posts', function (table) {
+    table.increments('id').primary();
+    table.string('title', 255).notNullable();
+    table.string('description', 255).notNullable();
+  });
+};
+
+exports.down = function (knex) {
+  return knex.schema.dropTable('posts');
+};

package/tests/app-multi-database/migrations/users/20210808150144_users.js

@@ -0,0 +1,11 @@
+exports.up = function (knex) {
+  return knex.schema.createTable('users', function (table) {
+    table.increments('id').primary();
+    table.string('firstName', 255).notNullable();
+    table.string('lastName', 255).notNullable();
+  });
+};
+
+exports.down = function (knex) {
+  return knex.schema.dropTable('users');
+};

package/tests/app-multi-database/seeds/posts.js

@@ -0,0 +1,24 @@
+exports.seed = function (knex) {
+    return knex('posts')
+      .del()
+      .then(function () {
+        return knex('posts').insert([
+          {
+            id: 1,
+            title: 'title #1',
+            description: 'description #1',
+          },
+          {
+            id: 2,
+            title: 'title #2',
+            description: 'description #2',
+          },
+          {
+            id: 3,
+            title: 'title #3',
+            description: 'description #3',
+          },
+        ]);
+      });
+  };
+  

package/tests/app-multi-database/seeds/users.js

@@ -0,0 +1,23 @@
+exports.seed = function (knex) {
+  return knex('users')
+    .del()
+    .then(function () {
+      return knex('users').insert([
+        {
+          id: 1,
+          firstName: 'firstName #1',
+          lastName: 'lastName #1',
+        },
+        {
+          id: 2,
+          firstName: 'firstName #2',
+          lastName: 'lastName #2',
+        },
+        {
+          id: 3,
+          firstName: 'firstName #3',
+          lastName: 'lastName #3',
+        },
+      ]);
+    });
+};

package/tests/posts.e2e-spec.ts

@@ -0,0 +1,130 @@
+import { INestApplication, HttpStatus } from '@nestjs/common';
+import { TestingModule, Test } from '@nestjs/testing';
+import { UsersModule } from './app-multi-database/app/users/users.module';
+import { KnexModule } from '../lib';
+import * as request from 'supertest';
+import { PostModule } from './app-multi-database/app/post/post.module';
+
+describe('[Feature] Posts - /posts', () => {
+  let app: INestApplication;
+
+  beforeAll(async () => {
+    const moduleFixture: TestingModule = await Test.createTestingModule({
+      imports: [
+        KnexModule.forRootAsync(
+          {
+            useFactory: () => ({
+              config: {
+                client: 'mysql',
+                version: '5.7',
+                useNullAsDefault: true,
+                connection: {
+                  host: '127.0.0.1',
+                  user: 'root',
+                  port: 3307,
+                  password: 'root',
+                  database: 'test2',
+                },
+                pool: {
+                  min: 2,
+                  max: 10,
+                },
+              },
+            }),
+          },
+          'db2Connection',
+        ),
+        UsersModule,
+        PostModule,
+      ],
+    }).compile();
+
+    app = moduleFixture.createNestApplication();
+    await app.init();
+  });
+
+  it('Create [POST /]', () => {
+    return request(app.getHttpServer())
+      .post('/posts')
+      .expect(HttpStatus.CREATED)
+      .set('Accept', 'application/json')
+      .send({
+        title: 'title #1',
+        description: 'description #1',
+      })
+      .then((res) => {
+        res.body;
+      });
+  });
+
+  it('Get all [GET /]', () => {
+    return request(app.getHttpServer())
+      .get('/posts')
+      .expect(HttpStatus.OK)
+      .set('Accept', 'application/json')
+      .then(({ body }) => {
+        expect(body['users']).toEqual([
+          {
+            id: 1,
+            title: 'title #1',
+            description: 'description #1',
+          },
+          {
+            id: 2,
+            title: 'title #1',
+            description: 'description #1',
+          },
+          {
+            id: 3,
+            title: 'title #1',
+            description: 'description #1',
+          },
+          {
+            id: 4,
+            title: 'title #1',
+            description: 'description #1',
+          },
+        ]);
+      });
+  });
+
+  it('Get one [GET /:id]', () => {
+    return request(app.getHttpServer())
+      .get('/posts/2')
+      .expect(HttpStatus.OK)
+      .set('Accept', 'application/json')
+      .then(({ body }) => {
+        expect(body['users']).toEqual([
+          {
+            id: 2,
+            title: 'title #1',
+            description: 'description #1',
+          },
+        ]);
+      });
+  });
+
+  it('Update one [PUT /:id]', () => {
+    return request(app.getHttpServer())
+      .put('/posts/2')
+      .expect(HttpStatus.OK)
+      .send({
+        title: 'title update',
+        description: 'description update',
+      })
+      .then((res) => {
+        res.body;
+      });
+  });
+
+  it('Delete one [DELETE /:id]', () => {
+    return request(app.getHttpServer())
+      .delete('/posts/1')
+      .set('Accept', 'application/json')
+      .expect(HttpStatus.OK);
+  });
+
+  afterAll(async () => {
+    await app.close();
+  });
+});

package/tests/user.e2e-spec.ts

@@ -0,0 +1,119 @@
+import { INestApplication, HttpStatus } from '@nestjs/common';
+import { TestingModule, Test } from '@nestjs/testing';
+import { UsersModule } from './app-knex/app/users/users.module';
+import { KnexModule } from '../lib';
+import * as request from 'supertest';
+
+describe('[Feature] User - /user', () => {
+  let app: INestApplication;
+
+  beforeAll(async () => {
+    const moduleFixture: TestingModule = await Test.createTestingModule({
+      imports: [
+        UsersModule,
+        KnexModule.forRoot({
+          config: {
+            client: 'mysql',
+            version: '5.7',
+            useNullAsDefault: true,
+            connection: {
+              host: '127.0.0.1',
+              user: 'root',
+              port: 3308,
+              password: 'root',
+              database: 'test',
+            },
+          },
+        }),
+      ],
+    }).compile();
+
+    app = moduleFixture.createNestApplication();
+    await app.init();
+  });
+
+  it('Create [POST /]', () => {
+    return request(app.getHttpServer())
+      .post('/user')
+      .expect(HttpStatus.CREATED)
+      .set('Accept', 'application/json')
+      .send({
+        firstName: 'firstName',
+        lastName: 'lastName',
+      })
+      .then((res) => {
+        res.body;
+      });
+  });
+
+  it('Get all [GET /]', () => {
+    return request(app.getHttpServer())
+      .get('/user')
+      .expect(HttpStatus.OK)
+      .set('Accept', 'application/json')
+      .then(({ body }) => {
+        expect(body['users']).toEqual([
+          {
+            id: 1,
+            firstName: 'firstName #1',
+            lastName: 'lastName #1',
+          },
+          {
+            id: 2,
+            firstName: 'firstName #1',
+            lastName: 'lastName #1',
+          },
+          {
+            id: 3,
+            firstName: 'firstName #1',
+            lastName: 'lastName #1',
+          },
+          {
+            id: 4,
+            firstName: 'firstName',
+            lastName: 'lastName',
+          },
+        ]);
+      });
+  });
+
+  it('Get one [GET /:id]', () => {
+    return request(app.getHttpServer())
+      .get('/user/2')
+      .expect(HttpStatus.OK)
+      .set('Accept', 'application/json')
+      .then(({ body }) => {
+        expect(body['users']).toEqual([
+          {
+            id: 2,
+            firstName: 'firstName #1',
+            lastName: 'lastName #1',
+          },
+        ]);
+      });
+  });
+
+  it('Update one [PUT /:id]', () => {
+    return request(app.getHttpServer())
+      .put('/user/2')
+      .expect(HttpStatus.OK)
+      .send({
+        firstName: 'firstName update',
+        lastName: 'lastName update',
+      })
+      .then((res) => {
+        res.body;
+      });
+  });
+
+  it('Delete one [DELETE /:id]', () => {
+    return request(app.getHttpServer())
+      .delete('/user/1')
+      .set('Accept', 'application/json')
+      .expect(HttpStatus.OK);
+  });
+
+  afterAll(async () => {
+    await app.close();
+  });
+});