add: getOrCreateUser

__tests__/grpc/user.service.test.ts

@@ -6,7 +6,7 @@ import { UserService } from '../../generated'
 import { ServiceClientConstructor } from '@grpc/grpc-js/build/src/make-client'
 import { GrpcClient } from '../../src/grpc/type'
 import { Status } from '@grpc/grpc-js/build/src/constants'
-import { createUserUseCase } from '../../src/usecase/createUser'
+import { getOrCreateUserUseCase } from '../../src/usecase/getOrCreateUser'
 import { mocked } from 'ts-jest/utils'
 import { v4 } from 'uuid'
 import { addAuthenticationUseCase } from '../../src/usecase/addAuthentication'
@@ -22,7 +22,7 @@ const pkg = grpc.loadPackageDefinition(def)
 const ClientConstructor = pkg.UserService as ServiceClientConstructor
 let client: GrpcClient<UserService>
 
-jest.mock('../../src/usecase/createUser')
+jest.mock('../../src/usecase/getOrCreateUser')
 jest.mock('../../src/usecase/addAuthentication')
 jest.mock('../../src/usecase/getUser')
 
@@ -37,21 +37,21 @@ beforeAll(async () => {
 describe('createUser', () => {
   test('success', (done) => {
     const id = v4()
-    mocked(createUserUseCase).mockImplementation(async () => ({
+    mocked(getOrCreateUserUseCase).mockImplementation(async () => ({
       id,
     }))
-    client.createUser({}, (err, res) => {
+    client.getOrCreateUser({}, (err, res) => {
       expect(err).toBeNull()
       expect(res?.id).toEqual(id)
       done()
     })
   })
 
   test('unexpected error', (done) => {
-    mocked(createUserUseCase).mockImplementation(() => {
+    mocked(getOrCreateUserUseCase).mockImplementation(() => {
       throw new Error('Unexpected Error')
     })
-    client.createUser({}, (err, res) => {
+    client.getOrCreateUser({}, (err, res) => {
       expect(err?.code).toEqual(Status.UNKNOWN)
       done()
     })

__tests__/usecase/getOrCreateUser.test.ts

@@ -0,0 +1,34 @@
+import { connectDatabase, disconnectDatabase } from '../../src/database'
+import { Provider } from '../../src/database/model/userAuthentications'
+import { getOrCreateUserUseCase } from '../../src/usecase/getOrCreateUser'
+import { clearDB } from '../_cleardb'
+
+beforeAll(async () => {
+  await connectDatabase()
+  await clearDB()
+})
+
+let userId = ''
+test('初回作成', async () => {
+  const res = await getOrCreateUserUseCase(
+    Provider.Google,
+    '100000000000000000'
+  )
+  userId = res.id
+  return expect(res).toEqual(
+    expect.objectContaining({
+      id: expect.any(String),
+    })
+  )
+})
+
+test('get user', () =>
+  expect(
+    getOrCreateUserUseCase(Provider.Google, '100000000000000000')
+  ).resolves.toEqual(
+    expect.objectContaining({
+      id: userId,
+    })
+  ))
+
+afterAll(disconnectDatabase)

protos/UserService.proto

@@ -1,7 +1,7 @@
 syntax="proto3";
 
 service UserService {
-  rpc CreateUser(CreateUserRequest) returns (CreateUserResponse);
+  rpc GetOrCreateUser(GetOrCreateUserRequest) returns (GetOrCreateUserResponse);
   rpc AddAuthentication(AddAuthenticationRequest) returns (AddAuthenticationResponse);
   rpc GetUser(GetUserRequest) returns (GetUserResponse);
 }
@@ -17,9 +17,12 @@ message Authentication {
   string socialId = 2;
 }
 
-message CreateUserRequest {}
+message GetOrCreateUserRequest {
+  Provider provider = 1;
+  string socialId = 2;
+}
 
-message CreateUserResponse {
+message GetOrCreateUserResponse {
   string id = 1;
 }
 

src/database/model/user.ts

@@ -11,7 +11,7 @@ export class User {
   })
   id!: string
 
-  @OneToMany((type) => UserAuthentication, (auth) => auth.userId, {
+  @OneToMany((type) => UserAuthentication, (auth) => auth.user, {
     cascade: true,
   })
   authentications!: UserAuthentication[]

src/database/model/userAuthentications.ts

@@ -18,7 +18,7 @@ export class UserAuthentication {
   id!: number
 
   @ManyToOne((type) => User, (user) => user.id)
-  userId!: string
+  user!: User
 
   @Column({
     name: 'provider',

src/grpc/user.service.ts

@@ -1,20 +1,23 @@
 import {
   AddAuthenticationResponse,
-  CreateUserResponse,
+  GetOrCreateUserResponse,
   GetUserResponse,
   UserService,
 } from '../../generated'
 import { addAuthenticationUseCase } from '../usecase/addAuthentication'
-import { createUserUseCase } from '../usecase/createUser'
+import { getOrCreateUserUseCase } from '../usecase/getOrCreateUser'
 import { getUserUseCase } from '../usecase/getUser'
 import { toGrpcError } from './converter'
 import { GrpcServer } from './type'
 
 export const userService: GrpcServer<UserService> = {
-  async createUser(_, callback) {
+  async getOrCreateUser({ request }, callback) {
     try {
-      const res = await createUserUseCase()
-      callback(null, CreateUserResponse.create({ ...res }))
+      const res = await getOrCreateUserUseCase(
+        request.provider,
+        request.socialId
+      )
+      callback(null, GetOrCreateUserResponse.create({ ...res }))
     } catch (e) {
       callback(toGrpcError(e))
     }

src/usecase/addAuthentication.ts

@@ -16,11 +16,12 @@ export async function addAuthenticationUseCase(
     throw new NotFoundError('指定されたユーザーが見つかりません')
 
   const authRepo = getConnection().getRepository(UserAuthentication)
-  if (await authRepo.findOne({ userId: id, provider }))
+  if (await authRepo.findOne({ provider, user: { id } }))
     throw new AlreadyExistError('認証情報が既に登録されています')
-  const auth = new UserAuthentication()
-  auth.provider = provider
-  auth.userId = id
-  auth.socialId = socialId
-  await authRepo.save(auth)
+
+  await authRepo.save({
+    provider,
+    socialId,
+    user: { id },
+  })
 }

src/usecase/getOrCreateUser.ts

@@ -0,0 +1,23 @@
+import { getConnection, getRepository } from 'typeorm'
+import { v4 } from 'uuid'
+import { User } from '../database/model/user'
+import {
+  Provider,
+  UserAuthentication,
+} from '../database/model/userAuthentications'
+
+export async function getOrCreateUserUseCase(
+  provider: Provider,
+  socialId: string
+): Promise<{ id: string }> {
+  const auth = await getRepository(UserAuthentication).findOne({
+    where: { provider, socialId },
+    relations: ['user'],
+  })
+  if (auth) return getRepository(User).findOneOrFail({ id: auth.user.id })
+  else
+    return getRepository(User).save({
+      id: v4(),
+      authentications: [{ socialId, provider }],
+    })
+}