backup

src/app.module.ts

@@ -10,6 +10,7 @@ import { RedisModule } from 'nestjs-redis';
 import { ParseBodyMiddleware } from './commons/middleware/parse-body.middleware';
 import { BullModule } from '@nestjs/bull';
 import { PubSubModule } from './commons/pub-sub/pub-sub.module';
+import { ArticlesModule } from './articles/articles.module';
 
 @Module({
   imports: [
@@ -72,6 +73,7 @@ import { PubSubModule } from './commons/pub-sub/pub-sub.module';
       }),
       inject: [ConfigService],
     }),
+    ArticlesModule,
   ],
   controllers: [AppController],
   providers: [AppService, AppResolver],

src/articles/articles.module.ts

@@ -0,0 +1,11 @@
+import { Module } from '@nestjs/common';
+import { ArticlesService } from './articles.service';
+import { ArticlesResolver } from './articles.resolver';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { Article } from './entities/article.entity';
+
+@Module({
+  imports: [TypeOrmModule.forFeature([Article])],
+  providers: [ArticlesResolver, ArticlesService],
+})
+export class ArticlesModule {}

src/articles/articles.resolver.spec.ts

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

src/articles/articles.resolver.ts

@@ -0,0 +1,42 @@
+import { Resolver, Query, Mutation, Args, Int } from '@nestjs/graphql';
+import { ArticlesService } from './articles.service';
+import { Article } from './entities/article.entity';
+import { CreateArticleInput } from './dto/create-article.input';
+import { UpdateArticleInput } from './dto/update-article.input';
+
+@Resolver(() => Article)
+export class ArticlesResolver {
+  constructor(private readonly articlesService: ArticlesService) {}
+
+  @Mutation(() => Article)
+  createArticle(
+    @Args('createArticleInput') createArticleInput: CreateArticleInput,
+  ) {
+    return this.articlesService.create(createArticleInput);
+  }
+
+  @Query(() => [Article], { name: 'articles' })
+  findAll() {
+    return this.articlesService.findAll();
+  }
+
+  @Query(() => Article, { name: 'article' })
+  findOne(@Args('id', { type: () => String }) id: string) {
+    return this.articlesService.findOne(id);
+  }
+
+  @Mutation(() => Article)
+  updateArticle(
+    @Args('updateArticleInput') updateArticleInput: UpdateArticleInput,
+  ) {
+    return this.articlesService.update(
+      updateArticleInput.id,
+      updateArticleInput,
+    );
+  }
+
+  @Mutation(() => Article)
+  removeArticle(@Args('id', { type: () => String }) id: string) {
+    return this.articlesService.remove(id);
+  }
+}

src/articles/articles.service.spec.ts

@@ -0,0 +1,27 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { getRepositoryToken } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import { ArticlesService } from './articles.service';
+import { Article } from './entities/article.entity';
+
+describe('ArticlesService', () => {
+  let service: ArticlesService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        ArticlesService,
+        {
+          provide: getRepositoryToken(Article),
+          useValue: new Repository(),
+        },
+      ],
+    }).compile();
+
+    service = module.get<ArticlesService>(ArticlesService);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+});

src/articles/articles.service.ts

@@ -0,0 +1,38 @@
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import { BaseDbService } from '../commons/services/base-db.service';
+import { CreateArticleInput } from './dto/create-article.input';
+import { UpdateArticleInput } from './dto/update-article.input';
+import { Article } from './entities/article.entity';
+
+@Injectable()
+export class ArticlesService extends BaseDbService<Article> {
+  readonly uniqueFields: Array<keyof Article> = ['title'];
+  constructor(
+    @InjectRepository(Article)
+    readonly repository: Repository<Article>,
+  ) {
+    super(repository);
+  }
+  async create(createArticleInput: CreateArticleInput) {
+    await this.isDuplicateEntity(createArticleInput);
+    return await this.repository.save(
+      this.repository.create(createArticleInput),
+    );
+  }
+
+  async findAll() {
+    return await this.repository.find();
+  }
+
+  async update(id: string, updateArticleInput: UpdateArticleInput) {
+    await this.isDuplicateEntityForUpdate(id, updateArticleInput);
+    return await this.repository.update(id, updateArticleInput);
+  }
+
+  async remove(id: string) {
+    await this.canRemove([id]);
+    return await this.repository.softDelete({ id });
+  }
+}

src/articles/dto/create-article.input.ts

@@ -0,0 +1,20 @@
+import { InputType } from '@nestjs/graphql';
+import { IsDate, IsOptional, IsString, Length } from 'class-validator';
+
+@InputType()
+export class CreateArticleInput {
+  @IsString()
+  @Length(1, 100)
+  title: string;
+
+  @IsString()
+  @Length(2, 100000)
+  content: string;
+
+  @IsOptional()
+  @IsDate()
+  publishedAt?: Date;
+
+  @IsString({ each: true })
+  tags: string[];
+}

src/articles/dto/update-article.input.ts

@@ -0,0 +1,8 @@
+import { CreateArticleInput } from './create-article.input';
+import { InputType, Field, Int, PartialType } from '@nestjs/graphql';
+
+@InputType()
+export class UpdateArticleInput extends PartialType(CreateArticleInput) {
+  @Field(() => Int)
+  id: string;
+}

src/articles/entities/article.entity.ts

@@ -0,0 +1,20 @@
+import { ObjectType } from '@nestjs/graphql';
+import { Column, Entity, Index } from 'typeorm';
+import { AppBaseEntity } from '../../commons/entities/app-base-entity';
+
+@Entity()
+@ObjectType()
+export class Article extends AppBaseEntity {
+  @Column()
+  title: string;
+
+  @Column({ type: 'text' })
+  content: string;
+
+  @Index()
+  @Column({ nullable: true })
+  publishedAt?: Date;
+
+  @Column({ type: 'varchar', array: true })
+  tags: string[];
+}

src/commons/services/base-db.service.ts

@@ -112,7 +112,7 @@ export class BaseDbService<Entity extends AppBaseEntity> extends TypeormHelper {
     }
   }
 
-  async canYouRemoveWithIds(ids: string[]): Promise<void> {
+  async canRemove(ids: string[]): Promise<void> {
     return;
   }