リレーションとは、データベース内の複数のテーブル間で関係を構築することを指します。これにより、複数のテーブルから関連データを一度に取得しやすくなります。

この記事では、1対1、1対多、多対多のリレーションを設定し、実際にデータを取得する手順を例を交えて紹介します。

SupabaseはPostgreSQLをベースにしているため、リレーション機能をサポートしています。これにより、データの結合や集約が容易に行え、効率的なデータ操作が可能になります。

今回使用するテーブル構成

• users テーブル
• id
• username
• profile_id
• profiles テーブル
• id
• name
• posts テーブル
• id
• user_id
• title
• user_roles テーブル
• user_id
• role_id
• roles テーブル
• id
• role_name

外部キーを設定する

Supabaseでリレーションを設定するには、データベーステーブルの定義において適切な外部キー（foreign key）制約を追加する必要があります。

以下のようにusersテーブルにprofile_idカラムを追加し、これをprofilesテーブルのidカラムに関連付けることで、リレーションを貼ることができます。

CREATE TABLE users (
  id SERIAL PRIMARY KEY,
  username VARCHAR(255)
);


CREATE TABLE posts (
  id SERIAL PRIMARY KEY,
  title VARCHAR(255),
  user_id INTEGER,
  FOREIGN KEY (user_id) REFERENCES users (id)
);

こんな感じで、他のテーブルにも外部キーを貼っていきます。

実際にリレーションを使ってデータを取得する

1対1のリレーション

users と profiles のリレーションを取得する例です。

const { data, error } = await supabase
  .from('users')
  .select(`
    id,
    username,
    profiles (
      id,
      name
    )
  `)


if (error) {
  console.error('Error fetching users with profiles:', error)
} else {
  console.log('Users with profiles:', data)
}

レスポンス例

[
  {
    "id": 1,
    "username": "user1",
    "profiles": {
      "id": 1,
      "name": "Profile 1"
    }
  },
  {
    "id": 2,
    "username": "user2",
    "profiles": {
      "id": 2,
      "name": "Profile 2"
    }
  }
]

1対多のリレーション

users と posts のリレーションを取得する例です。

const { data, error } = await supabase
  .from('users')
  .select(`
    id,
    username,
    posts (
      id,
      title
    )
  `)


if (error) {
  console.error('Error fetching users with posts:', error)
} else {
  console.log('Users with posts:', data)
}

レスポンス例

[
  {
    "id": 1,
    "username": "user1",
    "posts": [
      {
        "id": 1,
        "title": "Post 1"
      },
      {
        "id": 2,
        "title": "Post 2"
      }
    ]
  },
  {
    "id": 2,
    "username": "user2",
    "posts": [
      {
        "id": 3,
        "title": "Post 3"
      }
    ]
  }
]

多対多のリレーション

users と roles の多対多のリレーションを user_roles テーブルを通じて取得する例です。

const { data, error } = await supabase
  .from('users')
  .select(`
    id,
    username,
    user_roles (
      roles (
        id,
        role_name
      )
    )
  `)


if (error) {
  console.error('Error fetching users with roles:', error)
} else {
  console.log('Users with roles:', data)
}

レスポンス例

[
  {
    "id": 1,
    "username": "user1",
    "user_roles": [
      {
        "roles": {
          "id": 1,
          "role_name": "Admin"
        }
      },
      {
        "roles": {
          "id": 2,
          "role_name": "User"
        }
      }
    ]
  },
  {
    "id": 2,
    "username": "user2",
    "user_roles": [
      {
        "roles": {
          "id": 2,
          "role_name": "User"
        }
      }
    ]
  }
]

複数のリレーションの組み合わせ

複数のリレーションを組み合わせてデータを取得することも可能で、users、profiles、postsを同時に取得する場合は以下のようになります。

const { data, error } = await supabase
  .from('users')
  .select(`
    id,
    username,
    profiles (
      id,
      name
    ),
    posts (
      id,
      title
    )
  `)


if (error) {
  console.error('Error fetching users with profiles and posts:', error)
} else {
  console.log('Users with profiles and posts:', data)
}

レスポンス例

[
  {
    "id": 1,
    "username": "user1",
    "profiles": {
      "id": 1,
      "name": "Profile 1"
    },
    "posts": [
      {
        "id": 1,
        "title": "Post 1"
      },
      {
        "id": 2,
        "title": "Post 2"
      }
    ]
  },
  {
    "id": 2,
    "username": "user2",
    "profiles": {
      "id": 2,
      "name": "Profile 2"
    },
    "posts": [
      {
        "id": 3,
        "title": "Post 3"
      }
    ]
  }
]

INNER JOINとLEFT JOINで取得する場合

SupabaseはPostgreSQLを基盤としているため、PostgreSQLでサポートされているJOINの種類を利用できます。

INNER JOIN

INNER JOINは、両方のテーブルに共通するデータのみを取得します。

const { data, error } = await supabase
  .from('users')
  .select(`
    id,
    username,
    profiles!inner (
      id,
      name
    )
  `)


if (error) {
  console.error('Error fetching users with profiles:', error)
} else {
  console.log('Users with profiles:', data)
}

LEFT JOIN

LEFT JOINは、左側のテーブルのすべてのデータと、右側のテーブルに一致するデータを取得します。一致しない場合、右側のテーブルのデータはNULLになります。

const { data, error } = await supabase
  .from('users')
  .select(`
    id,
    username,
    profiles!left (
      id,
      name
    )
  `)


if (error) {
  console.error('Error fetching users with profiles:', error)
} else {
  console.log('Users with profiles:', data)
}

おわりに

リレーションを利用することで、複数のテーブルにまたがる複雑なデータを効率的に扱うことができます。

Supabaseの柔軟なクエリ機能を活用することで、INNER JOINやLEFT JOINなどの様々なJOINを使ってデータを取得することもできます。

TypeScriptとSupabaseを使ってリレーションを設定し、データを取得する方法について個人的な備忘録としても兼ねて紹介しました。

ドメインのstaticメソッドをmockする方法

Interface & Adapter層のGatewayでエンティティをドメインに変換する際に、ドメインの

Driverからデータを取得して、ドメインに変換するメソッドをテストする場合はこんな感じになります。

・NewsGateway.ts

async getNews(): Promise<News> {
  const newsEntity = await this.newsDriver.getNews();
  return this.convertNews(newsEntity)
}

・NewsGateway.test.ts

 ...

describe('getNews', () => {
  it('ニュース一覧を取得することができる', async () => {
    const newsEntity = mock<NewsEntity[]>()
    const news = mock<News>()
      
    const getNewsMock = jest.fn()
    when(getNewsMock).calledWith().defaultReturnValue(newsEntity)
    newsDriver.getNews = getNewsMock

    const convertNewsMock = jest.fn()
    when(convertNewsMock).calledWith(newsEntity).defaultReturnValue(news)
    newsGateway['convertNews'] = convertNewsMock

    const actual = await newsGateway.getNews()

    expect(actual).toEqual(news)
    expect(newsDriver.getNews).nthCalledWith(1)
    expect(newsGateway['convertNews']).nthCalledWith(1, newsEntity)
  })
})

 ...

convertNewsの単体テストにおいて、Newsドメインにファクトリメソッドであるfromメソッドをmockする方法がわかりました。

private convertNews(newsEntity: NewsEntity[]): News {
  const news = News.from(newsEntity)

  return news
}

...

describe('convertNews', () => {
  it('ニュースドメインに変換することができる', async () => {
    const newsEntity = mock<NewsEntity[]>()
    const news= mock<News>()
    const from = jest.spyOn(News, 'from')
      .mockImplementation((_: NewsEntity[]): News => {
          return news;
      })

    const actual = newsGateway['convertNews'](newsEntity)

    expect(actual).toEqual(news)
    expect(from).toBeCalled()
  })
})

...

まずspyOnでNewsドメインのfromメソッドをmockします。mockImplementation() 関数の引数は、以下のようになっています。

• 第1引数：モックするメソッドの引数型
• 第2引数：モックするメソッドの戻り値型
• 第3引数：モックするメソッドの処理本体

この場合、第1引数は NewsEntity[] 型、第2引数はNews型、第3引数はNews型のオブジェクトを返す処理です。つまり、from() メソッドにNewsEntity[]型のエンティティを渡すと、常にnewsを返すように設定しています。

convertNewsはprivateメソッドなので、newsEntityを引数rにnewsGateway[‘convertNews’]の形で呼び出します。

あとは結果が正しいかと、mockしたfromメソッドが呼び出されたかを確認しています。

UseCase層でGoogle認証のロジックを実装する

流れとしてはFirebase AuthenticationでGoogle認証した後、DBにユーザー情報を問い合わせます。

ユーザー情報がなかったら新規登録としてユーザ登録します。ユーザーログイン認証完了後はmypageに遷移し、認証情報をstateに登録します。

async signInWithGoogle(auth: Auth) {
  const userWithGoogle: CredentialUser = await this.authGateway.signInWithGoogle(auth)
  const userAccount: UserAccount | null = await this.userGateway.getUserByUid(userWithGoogle.uid)

  if (userAccount) {
    this.toastPresenter.successToast(MESSAGES.AUTH.LOGIN_SUCCESS)
  } else {
    await this.userGateway.createUser(userWithGoogle)
    this.toastPresenter.successToast(MESSAGES.AUTH.REGISTER_SUCCESS)
  }
  await this.storeAuthState(userWithGoogle.uid)
  this.navigationPresenter.navigateTo('/mypage')
} catch(error: Error) {
  console.error('signInWithGoogle error: ', error);
  this.toastPresenter.errorToast(`${MESSAGES.UNEXPECTED_ERROR}: ${error.message}`)
}

private async storeAuthState(uid: string) {
  const authAccount = await this.userGateway.getUserByUid(uid)
  this.authPresenter.storeAuth(authAccount!)
}ち

ちなみにUseCaseのUTはこんな感じになりました。あと登録パターンなどのシナリオがいくつかあるといった感じです。

Clean Architecutureをベースにレイヤリングしているので、テストは書きやすかったです。

it('Google認証でログインすることができる', async () => {
  const auth = mock<Auth>();
    
  const signInWithGoogleMock = jest.fn()
  when(signInWithGoogleMock).calledWith(auth).mockReturnValueOnce(credentialUser)
  authGateway.signInWithGoogle = signInWithGoogleMock

  const getUserByUidMock = jest.fn()
  when(getUserByUidMock).calledWith(credentialUser.uid).mockReturnValueOnce(userAccount)
  userGateway.getUserByUid = getUserByUidMock

  const successToastMock = jest.fn()
  when(successToastMock).calledWith(MESSAGES.AUTH.LOGIN_SUCCESS)
  toastPresenter.successToast = successToastMock

  const navigateToMock = jest.fn()
  when(navigateToMock).calledWith('/mypage')
  navigationPresenter.navigateTo = navigateToMock

  await authUsecase.signInWithGoogle(auth);

  expect(authGateway.signInWithGoogle).nthCalledWith(1, auth);
  expect(userGateway.getUserByUid).nthCalledWith(1, credentialUser.uid);
  expect(toastPresenter.successToast).nthCalledWith(1, MESSAGES.AUTH.LOGIN_SUCCESS);
});

GatewayでDomainに変換する

UseCaseのthis.authGateway.signInWithGoogle(auth)でFirebase AuthenticationにGoogle認証しているところをピックアップして、Gatewayの実装を取り上げます。

Gatewayとしては、DriverでサードパーティであるFirebase Authenticationを呼び出した返り値を、このアプリケーション内のコアとなるDomainに変換してUseCaseに返します。

つまり、Gatewayが外部とアプリケーションの境界部分を担っている感じです。今回は、CredentialUserというDomainに変換して、UseCaseに返しています。

async signInWithGoogle(auth: Auth): Promise<CredentialUser> {
  const userCredentialWithGoogle = await this.authDriver.signInWithGoogle(auth)
  return {
    uid: userCredentialWithGoogle.user.uid,
    displayName: userCredentialWithGoogle.user.displayName,
    email: userCredentialWithGoogle.user.email,
    photoURL: userCredentialWithGoogle.user.photoURL,
  } as CredentialUser
}

Driverで実際にGoogle認証する

実際にGoogle認証するのはこのDriverになります。DriverではGoogleAuthProvider()からsignInWithPopup()を呼び出し、認証した結果を返します。

本来はDriverで使用するエンティティを用意して、その型に詰めてからGatewayに返してあげる方が、アプリケーションとサードパーティとの切り分けができてより良い気もしますが、一旦ここではそのままGatewayに返しています。

async signInWithGoogle(auth: Auth): Promise<UserCredential> {
  const provider = new GoogleAuthProvider()
  const userCredentialWithGoogle = await signInWithPopup(auth, provider)
  return userCredentialWithGoogle
}

すんごいざっくりですが、メモ的な感じでまとめました。

公式ドキュメント：https://v3.nuxtjs.org/

Nuxt3でどう変わった

Nuxt3になったことで、JSX/TSXやSCSSの対応、APIサーバー作成などの機能がデフォルトで含まれています。Nuxt2もセットアップなしで開発を始められるフレームワークでしたが、TypeScriptやSCSSで書く場合は別途追加する必要がありました。

Nuxt3によってそれらが内包され素早いフロント開発に着手できるようになりました。

※ JSXはJavaScripでHTMLっぽいのが書けるようJavaScriptを拡張したものです。TSXはJSXのTypeScript版です。

サーバー起動とホットリロードが早い

Nuxt3は開発時のビルドツールにViteが採用されています。そのため開発時のサーバー起動とHMRが早くなりました。

これは実際に使ってみて早さを実感しており、これだけでもNuxt3に乗り換える価値がありそうです。

Composition APIの採用

Composition APIは関数ベースでコンポーネントを実装する機能です。関数ベースであるため機能の再利用性を高める役割を持っています。

Vueでの新しい書き方としてプラグインでVue 2にも先行提供されていたComposition APIはNuxt3では標準採用されています。

従来の記法であるOptions APIと比較してTypeScriptの相性がいいことが挙げられます。 Options APIにTypeScript を導入しても thisやdataなどのoptionsの定義が複雑であるため、型定義が難しかったのですが、Composition APIを使用することで型推論でき開発が効率的になりました。

状態管理としてuseStateとpiniaが追加

Vue3ではVuexに代わってuseStateとpiniaが推奨されています。

Nuxt 2では主要機能の1つとして組み込まれていたVuexですが、グローバルな状態管理ストアにアプリが依存するリスクやTypeScript、単体テストとの相性の悪さなどがVuexが推奨されなくなった背景とされています。

Nuxt3でプロジェクトを作成する

Nuxt3 からは create-nuxt-app の代わりにNuxt CLIでNuxtプロジェクトを作成します。

npx create-nuxt-appによる質問がなくなったため、すぐにプロジェクトを作成できます。Nuxt3ではTypeScriptはデフォルトになっており、TypeScriptファーストなフレームワークになりました。

$ npx nuxi init sample-nuxt3-app

Nuxt3では生成されるファイルが.tsで作られていることがわかります。

.gitignore
README.md
app.vue
nuxt.config.ts
package-lock.json
package.json
tsconfig.json

JSX・TSXを使うなら

JSX・TSXを使う場合は、tsconfig.jsonにcompilerOptionsを追記することが使用することができるようになります。

{
  // https://v3.nuxtjs.org/concepts/typescript
  "extends": "./.nuxt/tsconfig.json",
  + "compilerOptions": {
  +   "jsx": "preserve"
  + }
}

TypeScriptの型システム

型は、コードの品質と読みやすさを高めることができます。

また、型はリファクタリングをする際の開発スピードを高め、型があることによって、コードを書いている時点でエラーに気づくことができます。開発中に早い段階でエラーに気づけるのは大きなメリットです。

暗黙的な型推論

型推論とは、TypeScriptがソースコードを解析し、そのコードの流れから変数や関数などの型を推測してくれる仕組みのことです。

TypeScriptは型を推論することによって、不明確なコードに対しエラーを表示してくれます。

明示的な型指定

TypeScriptは型を推論しますが、型推論の結果が正しくない場合や正確でない場合は、開発者が、明示的にコード上で、型を指定する(型アノテーションを書く)ことができます。

型アノテーションを書くことによって、開発者にとってのドキュメントにもなります。

TypeScriptの型の深堀り

型エイリアス

指定した型に別名を設定することができます。エイリアスという名の通り、新しい型というよりかは既にある型に別の名前をつけているといった感じです。

type 新型名 = 型名

type name = string
type age = number

type person = [name, age]

const taro: person = ['taro', 20]

リテラル型

リテラルというのは直接ソースコードに書かれる値のことです。以下のようにokだけしか値がない型が作れます。

type ok = ‘ok’

条件型(Conditional Types)

複数の型を許容する新しい型エイリアスが作成できます。

type 型名 = 型1 | 型2 | …

リテラル型と条件型を組み合わせることで、複数の値のいずれかを許容するenumのような働きをする型が作れます。

type msg = ‘hello’ | ‘bye’

ユーティリティ型

変数のさまざまな性質を付加する特殊な型が用意されており、これらをユーティリティ型といいます。以下のようなユーティリティ型があります。

Partial<T>

• Partial<T>はTの全てのプロパティをOptional(任意)のプロパティにしてくれる

Required<T>

• Required<T>はTの全てのプロパティを必須のプロパティにしてくれる

Readonly<T>

• Readonly<T>はTの全てのプロパティをreadonlyのプロパティにしてくれる

他のユーティリティ型などは以下を参照してください。

https://qiita.com/k-penguin-sato/items/e2791d7a57e96f6144e5

総称型(ジェネリクス)

総称型は値の型を特定せずに使用するための仕組みです。

<T>というのが、ここで使われている総称型の指定です。総称型は<>の中に抽象的な型を表す名前を指定します。このTは別にTでなくても良いが、TypeScriptではTから始まるアルファベットを使う習慣があるそうです。

複数の総称型を指定したい場合は<T, U, V…>という具合でカンマ区切りで記述します。

function 関数 <T> (引数) : 戻り値

ジェネリクスでUnitテストで使うmockを作ると以下のように書けそうです。

function mock<T>(): T {
  return ({} as unknown) as T
}

TypeScriptのクラスの深堀り

インターフェース

インターフェースはオブジェクト構造を記述するための仕組みです。インターフェースではオブジェクトに用意するプロパティやメソッドを用意できます。

ただあくまでインターフェースは構造の定義をするもので、そのまま使ってオブジェクトを作ることはできません。

interface 名前 {
  プロパティ: 型
  メソッド(引数): 型
  …
}

インターフェースの実装

用意されたインターフェースは、クラスに指定することで利用されます。クラス名の後にimplementsというキーワードを付けます。

このようにimplementsするとそのクラスでは組み込まれたインターフェースに用意されているプロパティやメソッドを全て用意しなければならないです。

つまりインターフェースはクラスにプロパティやメソッドの実装を保証するものです。

class 名前 implementes インターフェース

クリーンアーキテクチャで考えると、Portレイヤーにインターフェースを定義し、Gatewayレイヤーで実装する感じになりそうです。

interface SamplePort {
  find(): Promise<number>
}

export class SampleGateway implements SamplePort {
  async find(): Promise<number> {
    …
  }

}

インターフェースの継承

インターフェースを定義するときに「extends インターフェース」と指定することで、既にあるインターフェースを継承した新たなインターフェースを作成できます。

継承して作られたインターフェースはimplementesする際に継承もとのインターフェースに用意されているプロパティやメソッドまで含めて全て実装する必要があります。

抽象クラス

インターフェースと似たような働きをするものに抽象クラスがあります。抽象クラスは具体的な処理を持たない抽象的な存在としてのクラスです。

クラス定義の冒頭にabstractを付けることで抽象クラスになります。またメソッドもabstractをつけることで抽象メソッドになります。

abstract class クラス名 {
  abstract メソッド(): 型
  …
}

抽象クラスとインターフェースの違い

抽象クラスとインターフェースはかなり似ています。ほぼimplementesするかextendsするかの違いですが、それでも以下のような違いがあります。

他にクラスを継承する必要があるか

もし他のクラスを継承するのであれば、抽象クラスは使えません。extendsで継承できるのは1つのクラスのみであるため、抽象クラスと他のクラスを同時に継承できません。

プロパティを義務付けるか

抽象クラスは基本的にメソッドを定義するものです。抽象プロパティはないため実装クラスに必ずプロパティを用意させたければインターフェースを使う必要があります。

静的メンバー

基本的にプロパティやメソッドはインスタンスを作成して利用するという共通点があります。クラスは基本的にインスタンスを作って利用するものであるため当然とも言えます。

ただ場合によってはインスタンスが必要ないクラスもあります。こうした場合クラスのプロパティやメソッドを静的メンバーとして用意することで、クラスから直接使えるようにできます。

この静的メンバーは「static」というキーワードを使って作成します。

static プロパティ: 型
static メソッド(引数): 型

パラメータプロパティ

読み取りのみのプロパティを扱う場合、パラメータプロパティと呼ばれる機能を使う方法があります。

パラメータプロパティはコンストラクタの引数をそのままプロパティとして扱えるようにする機能です。コンストラクタにreadonlyを指定したプロパティを用意するとそれは「変更不可のプロパティ」として使えるようになります。

class People {
  constructor(
    readonly name: string
  ) {}
}

【Typescript】Clean Architecture + DDDでAPIを実装してみた

Typescript + ​​Clean Architecture + DDDで…

mintaku-blog.net

Jestを導入する

本来ならTDD的にテストを書いてから実装するのですが、元々の目的がClean Architecture + DDDのAPIをつくるのが目的だったため、後からテストを導入することになりました。

APIはTypescriptで実装されているため、Jestを導入しました。また前回同様、本記事ではメンバー関連を中心に取り扱います。APIしか作ってないのでE2EはなくUnitテストのみです。

型のモックの実現

テストにおいて型のモックは型を抽象化するジェネリックを使って実現します。特に実値で書く必要のない値に関してはモックを使用しています。

export function mock<T>(): T {
  return ({} as unknown) as T
}

Domainのテスト

ドメインのテストを書いていきます。

バリデーションやドメインへの変換処理などをテストしていきます。誕生日から年齢を取得するドメインメソッドのテストは現在日から取得しているため1年経つとテストが落ちるようになってしまうのが悩みどころです。上手い具合にテストできればいいのですが。。

・Member.spec.ts

import { Member, MemberBirthday, MemberGender, MemberId, MemberName, MemberProfile } from '../Member'
import { MemberRelation, MemberRelationAttribute } from '../MemberRelation'
import { DepartmentId } from '../Department'
import { PostId } from '../Post'
import { EmploymentStatusId } from '../EmploymentStatus'

describe('MemberDomain', () => {
  describe('MemberName #isMaxSize', () => {
    test('メンバー名の上限文字数チェックfalse', async () => {
      const memberName = new MemberName('test')
      expect(memberName.isMaxSize()).toEqual(false)
    })
    test('メンバー名の上限文字数チェックtrue', async () => {
      const memberName = new MemberName('testtesttesttesttesttesttesttest')
      expect(memberName.isMaxSize()).toEqual(true)
    })
  })

  describe('MemberBirthday #getAge', () => {
    test('誕生日から年齢を取得', async () => {
      const memberBirthday = new MemberBirthday(new Date('2000/12/10'))
      expect(memberBirthday.getAge()).toEqual(21)
    })
  })

  describe('MemberGender #getName', () => {
    test('GenderIdから性別名を取得', async () => {
      const memberGender = new MemberGender(1)
      expect(memberGender.getName()).toEqual('男性')
    })
  })

  describe('MemberRelationAttribute #update', () => {
    test('更新用のMemberRelationドメインに変換する', async () => {
      const memberId = new MemberId(1)
      const memberRelationAttribute = new MemberRelationAttribute(
        new MemberProfile(
          new MemberName('test'),
          new MemberBirthday(new Date('1900/8/29')),
          new MemberGender(1)
        ),
        new DepartmentId(1),
        new PostId(1),
        new EmploymentStatusId(1)
      )
      const expected = new MemberRelation(
        new Member(
          new MemberId(1),
          new MemberProfile(
            new MemberName('test'),
            new MemberBirthday(new Date('1900/8/29')),
            new MemberGender(1)
          )
        ),
        new DepartmentId(1),
        new PostId(1),
        new EmploymentStatusId(1)
      )
      expect(memberRelationAttribute.update(memberId)).toEqual(expected)
    })
  })
  
  describe('MemberRelation #from', () => {
    test('MemberRelationドメインに変換する', async () => {
      const id = 1
      const name = 'test'
      const birthday = new Date('2000/12/10')
      const gender = 1
      const departmentId = 1
      const postId = 1
      const employmentStatusId = 1

      const expected = new MemberRelation(
        new Member(
          new MemberId(1),
          new MemberProfile(
            new MemberName('test'),
            new MemberBirthday(new Date('2000/12/10')),
            new MemberGender(1)
          )
        ),
        new DepartmentId(1),
        new PostId(1),
        new EmploymentStatusId(1)
      )
      expect(MemberRelation.from(
        id,
        name,
        birthday,
        gender,
        departmentId,
        postId,
        employmentStatusId
      )).toEqual(expected)
    })
  })
})

UseCaseのテスト

次にUseCaseのテストを書いていきます。

MemberPortをモックし、メソッドが呼び出されたら返却されるレスポンスを定義して返してあげるようにします。レスポンスデータはモックできるものはモックし、登録系などバリデーションするものは実値で書いてます。

・MemberUseCase.spec.ts

import { MemberPort } from '../../port/MemberPort'
import { MemberUseCase } from '../MemberUseCase'
import "reflect-metadata"
import { mock } from './helper'
import { when } from 'jest-when'
import { MemberRelation, MemberRelationAttribute, MemberRelations } from '../../domain/MemberRelation'
import { Member, MemberId, MemberProfile } from '../../domain/Member'
import { MemberName } from '../../domain/Member'
import { MemberBirthday } from '../../domain/Member'
import { MemberGender } from '../../domain/Member'
import { DepartmentId } from '../../domain/Department'
import { PostId } from '../../domain/Post'
import { EmploymentStatusId } from '../../domain/EmploymentStatus'
import { PaymentAmount, PaymentDate, PaymentType, Remark, SalaryAttribute } from '../../domain/Salary'

const memberPort = mock<MemberPort>()

describe('MemberUseCase', () => {
  describe('find', () => {
    test('memberIdから1人のメンバーを取得する', async () => {
      const memberId = mock<MemberId>()
      const expected = mock<MemberRelation>()

      const memberFindFn = jest.fn()
      when(memberFindFn).calledWith(memberId).mockReturnValue(expected)
      memberPort.find = memberFindFn

      const target = new MemberUseCase(memberPort)
      const result = await target.find(memberId)

      expect(memberFindFn).toHaveBeenCalledTimes(1)
      expect(result).toEqual(expected)
    })
  })

  describe('findAll', () => {
    test('全てのメンバーを取得する', async () => {
      const expected = mock<MemberRelations>()

      const memberFindAllFn = jest.fn()
      when(memberFindAllFn).mockReturnValue(expected)
      memberPort.findAll = memberFindAllFn

      const target = new MemberUseCase(memberPort)
      const result = await target.findAll()

      expect(memberFindAllFn).toHaveBeenCalledTimes(1)
      expect(result).toEqual(expected)
    })
  })

  describe('create', () => {
    test('メンバーを新規登録する', async () => {
      const member = new MemberRelationAttribute(
        new MemberProfile(
          new MemberName('test'),
          new MemberBirthday(new Date()),
          new MemberGender(1)
        ),
        new DepartmentId(1),
        new PostId(1),
        new EmploymentStatusId(1)
      )

      const memberCreateFn = jest.fn()
      memberPort.create = memberCreateFn

      const target = new MemberUseCase(memberPort)

      await target.create(member)

      expect(memberCreateFn).toHaveBeenCalledTimes(1)
    })
  })

  describe('createSalary', () => {
    test('メンバーの給与情報を登録する', async () => {
      const memberId = mock<MemberId>()
      const salary = new SalaryAttribute(
        new PaymentAmount(10000),
        new PaymentType('bonus'),
        new Remark('test'),
        new PaymentDate(new Date())
      )

      const memberCreateSalaryFn = jest.fn()
      memberPort.createSalary = memberCreateSalaryFn

      const target = new MemberUseCase(memberPort)
      await target.createSalary(salary, memberId)

      expect(memberCreateSalaryFn).toHaveBeenCalledTimes(1)
    })
  })

  describe('update', () => {
    test('メンバーを更新する', async () => {
      const memberId = mock<MemberId>()
      const targetMember = new MemberRelation(
        new Member(
          new MemberId(1),
          new MemberProfile(
            new MemberName('test'),
            new MemberBirthday(new Date()),
            new MemberGender(1)
          )
        ),
        new DepartmentId(1),
        new PostId(1),
        new EmploymentStatusId(1)
      )

      const updateMember = new MemberRelation(
        new Member(
          new MemberId(1),
          new MemberProfile(
            new MemberName('test'),
            new MemberBirthday(new Date()),
            new MemberGender(1)
          )
        ),
        new DepartmentId(1),
        new PostId(1),
        new EmploymentStatusId(1)
      )

      const memberRelationAttribute = new MemberRelationAttribute(
        new MemberProfile(
          new MemberName('test'),
          new MemberBirthday(new Date()),
          new MemberGender(1)
        ),
        new DepartmentId(1),
        new PostId(1),
        new EmploymentStatusId(1)
      )

      const memberUpdateFn = jest.fn()
      memberPort.update = memberUpdateFn

      const memberRelationAttributeUpdateFn = jest.spyOn(memberRelationAttribute, "update")

      when(memberPort.find).calledWith(memberId).mockResolvedValue(targetMember)
      when(memberRelationAttributeUpdateFn).calledWith(targetMember.member.id).mockReturnValue(updateMember)
      when(memberPort.update).calledWith(updateMember)

      const target = new MemberUseCase(memberPort)
      
      await target.update(memberId, memberRelationAttribute)

      expect(memberUpdateFn).toHaveBeenCalledTimes(1)
    })
  })

  describe('delete', () => {
    test('メンバーを削除する', async () => {
      const memberId = mock<MemberId>()
      const memberDeleteFn = jest.fn()
      memberPort.delete = memberDeleteFn

      const target = new MemberUseCase(memberPort)
      await target.delete(memberId)

      expect(memberDeleteFn).toHaveBeenCalledTimes(1)
    })
  })
})

Gateway・Controllerのテスト

Gateway・Controllerのテストを書いていきます。これらのレイヤら主に変換処理を行うためテストが長くなりがちです。

やっていることはシンプルでGatewayだったらUseCaseから受け取ったドメインをDriver用にプリミティブなオブジェクトに変換して渡してあげ、Driverから受け取ったレスポンスデータをドメインに詰め直す処理をしています。テストとしてはそれらがちゃんと期待しているデータに変換され期待しているメソッドが呼び出されているかをアサートしています。

privateなメソッドに関してはtarget[“hoge”](fuga)のようにアクセスしてテストを行っています。

・MemberGateway.spec.ts

import { mock } from './helper'
import { when } from 'jest-when'
import { MemberDriver, MemberEntity } from '../../driver/MemberDriver'
import { MemberGateway } from '../MemberGateway'
import { Member, MemberBirthday, MemberGender, MemberId, MemberName, MemberProfile } from '../../domain/Member'
import { MemberRelation, MemberRelationAttribute, MemberRelations } from '../../domain/MemberRelation'
import { DepartmentId } from '../../domain/Department'
import { PostId } from '../../domain/Post'
import { EmploymentStatusId } from '../../domain/EmploymentStatus'
import { PaymentAmount, PaymentDate, PaymentType, Remark, SalaryAttribute } from '../../domain/Salary'
const memberDriver = mock<MemberDriver>()

describe('MemberGateway', () => {
  describe('find', () => {
    test('memberIdから1人のメンバーをDriverから取得してDomainに変換する', async () => {
      const memberId = new MemberId(1)
      const memberEntity: MemberEntity = {
        member: {
          id: 1,
          name: 'test',
          birthday: new Date("1900/8/29"),
          gender: 1
        },
        departmentId: 1,
        postId: 1,
        employmentStatusId: 1
      }
      const expected = new MemberRelation(
        new Member(
          new MemberId(1),
          new MemberProfile(
            new MemberName('test'),
            new MemberBirthday(new Date("1900/8/29")),
            new MemberGender(1)
          )
        ),
        new DepartmentId(1),
        new PostId(1),
        new EmploymentStatusId(1)
      )

      const target = new MemberGateway(memberDriver)

      const memberFindFn = jest.fn()
      memberDriver.find = memberFindFn
      const convertMemberValueFn = jest.fn()
      target['convertMemberValue'] = convertMemberValueFn

      when(memberFindFn).calledWith(1).mockResolvedValue(memberEntity)
      when(convertMemberValueFn).calledWith(memberEntity).mockResolvedValue(expected)

      const result = await target.find(memberId)

      expect(memberFindFn).toHaveBeenCalledTimes(1)
      expect(convertMemberValueFn).toHaveBeenCalledTimes(1)
      expect(result).toEqual(expected)
    })
  })

  describe('findAll', () => {
    test('Driverから全てのメンバーを取得しDomainに変換する', async () => {
      const memberEntity: MemberEntity[] = [
        {
          member: {
            id: 1,
            name: 'test1',
            birthday: new Date("1900/8/29"),
            gender: 1
          },
          departmentId: 1,
          postId: 1,
          employmentStatusId: 1
        },
        {
          member: {
            id: 2,
            name: 'test2',
            birthday: new Date("1900/8/29"),
            gender: 2
          },
          departmentId: 2,
          postId: 2,
          employmentStatusId: 2
        }
      ]
      const expected = new MemberRelations(
        [
          new MemberRelation(
            new Member(
              new MemberId(1),
              new MemberProfile(
                new MemberName('test1'),
                new MemberBirthday(new Date("1900/8/29")),
                new MemberGender(1)
              )
            ),
            new DepartmentId(1),
            new PostId(1),
            new EmploymentStatusId(1)
          ),
          new MemberRelation(
            new Member(
              new MemberId(2),
              new MemberProfile(
                new MemberName('test2'),
                new MemberBirthday(new Date("1900/8/29")),
                new MemberGender(2)
              )
            ),
            new DepartmentId(2),
            new PostId(2),
            new EmploymentStatusId(2)
          )
        ]
      )

      const target = new MemberGateway(memberDriver)

      const memberFindAllFn = jest.fn()
      memberDriver.findAll = memberFindAllFn
      when(memberFindAllFn).calledWith().mockResolvedValue(memberEntity)

      const result = await target.findAll()

      expect(memberFindAllFn).toHaveBeenCalledTimes(1)
      expect(result).toEqual(expected)
    })
  })

  describe('create', () => {
    test('メンバーを登録する', async () => {
      const member = new MemberRelationAttribute(
        new MemberProfile(
          new MemberName('test'),
          new MemberBirthday(new Date("1900/8/29")),
          new MemberGender(1)
        ),
        new DepartmentId(1),
        new PostId(1),
        new EmploymentStatusId(1)
      )
      const target = new MemberGateway(memberDriver)

      const memberCreateFn = jest.fn()
      memberDriver.create = memberCreateFn

      await target.create(member)

      expect(memberCreateFn).toHaveBeenCalledTimes(1)
    })
  })

  describe('createSalary', () => {
    test('メンバーの給与情報を登録する', async () => {
      const memberId = new MemberId(1)
      const salary = new SalaryAttribute(
        new PaymentAmount(10000),
        new PaymentType('bonus'),
        new Remark('test'),
        new PaymentDate(new Date())
      )
      const target = new MemberGateway(memberDriver)

      const memberCreateSalaryFn = jest.fn()
      memberDriver.createSalary = memberCreateSalaryFn

      await target.createSalary(salary, memberId)

      expect(memberCreateSalaryFn).toHaveBeenCalledTimes(1)
    })
  })

  describe('update', () => {
    test('メンバーを更新する', async () => {
      const member = new MemberRelation(
        new Member(
          new MemberId(1),
          new MemberProfile(
            new MemberName('test1'),
            new MemberBirthday(new Date("1900/8/29")),
            new MemberGender(1)
          )
        ),
        new DepartmentId(1),
        new PostId(1),
        new EmploymentStatusId(1)
      )
      const target = new MemberGateway(memberDriver)

      const memberUpdateFn = jest.fn()
      memberDriver.update = memberUpdateFn

      await target.update(member)

      expect(memberUpdateFn).toHaveBeenCalledTimes(1)
    })
  })

  describe('delete', () => {
    test('メンバーを削除する', async () => {
      const memberId = new MemberId(1)
      const target = new MemberGateway(memberDriver)

      const memberDeleteFn = jest.fn()
      memberDriver.delete = memberDeleteFn

      await target.delete(memberId)

      expect(memberDeleteFn).toHaveBeenCalledTimes(1)
    })
  })

  describe('convertMemberValue', () => {
    test('MemberValueドメインに変換する', async () => {
      const member: MemberEntity = {
        member: {
          id: 1,
          name: 'test',
          birthday: new Date("1900/8/29"),
          gender: 1
        },
        departmentId: 1,
        postId: 1,
        employmentStatusId: 1
      }

      const expected = new MemberRelation(
        new Member(
          new MemberId(1),
          new MemberProfile(
            new MemberName('test'),
            new MemberBirthday(new Date("1900/8/29")),
            new MemberGender(1)
          )
        ),
        new DepartmentId(1),
        new PostId(1),
        new EmploymentStatusId(1)
      )
      
      const target = new MemberGateway(memberDriver)
      const result = await target["convertMemberValue"](member)

      expect(result).toEqual(expected)
    })
  })
})

・MemberController.spec.ts

import { mock } from './helper'
import { when } from 'jest-when'
import { Member, MemberBirthday, MemberGender, MemberId, MemberName, MemberProfile } from '../../domain/Member'
import { MemberRelation, MemberRelationAttribute, MemberRelations } from '../../domain/MemberRelation'
import { DepartmentId } from '../../domain/Department'
import { PostId } from '../../domain/Post'
import { EmploymentStatusId } from '../../domain/EmploymentStatus'
import { MemberUseCase } from '../../usecases/MemberUseCase'
import { CreateMemberParams, CreateMemberSalaryParams, MemberController, UpdateMemberParams } from '../MemberController'
import { SalaryUseCase } from '../../usecases/SalaryUseCase'
import { MemberSalary } from '../../domain/MemberSalary'
import { PaymentAmount, PaymentDate, PaymentType, Remark, Salaries, Salary, SalaryAttribute, SalaryId } from '../../domain/Salary'
const memberUseCase = mock<MemberUseCase>()
const salaryUseCase = mock<SalaryUseCase>()

describe('MemberController', () => {
  describe('findMember', () => {
    test('memberIdから1人のメンバーを取得する', async () => {
      const id = 1
      const memberId = new MemberId(id)
      const memberRelation = new MemberRelation(
        new Member(
          new MemberId(1),
          new MemberProfile(
            new MemberName('test1'),
            new MemberBirthday(new Date('1900/8/29')),
            new MemberGender(1)
          )
        ),
        new DepartmentId(1),
        new PostId(1),
        new EmploymentStatusId(1)
      )
      const expected = {
        id: 1,
        name: 'test1',
        birthday: new Date('1900/8/29'),
        age: 121,
        gender: '男性',
        department_id: 1,
        post_id: 1,
        employment_status_id: 1
      }


      const memberFindFn = jest.fn()
      memberUseCase.find = memberFindFn

      const target = new MemberController(memberUseCase, salaryUseCase)
      const serializeMemberForDetailFn = jest.fn()
      target['serializeMemberForDetail'] = serializeMemberForDetailFn

      when(memberFindFn).calledWith(memberId).mockResolvedValue(memberRelation)
      when(serializeMemberForDetailFn).calledWith(memberRelation).mockResolvedValue(expected)

      const result = await target.findMember(id)

      expect(memberFindFn).toHaveBeenCalledTimes(1)
      expect(serializeMemberForDetailFn).toHaveBeenCalledTimes(1)
      expect(result).toEqual(expected)
    })
  })

  describe('findMemberSalaries', () => {
    test('memberIdから1人のメンバーの給与情報を取得する', async () => {
      const id = 1
      const memberId = new MemberId(id)
      const memberSalary = new MemberSalary(
        new Member(
          new MemberId(1),
          new MemberProfile(
            new MemberName('test'),
            new MemberBirthday(new Date()),
            new MemberGender(1)
          )
        ),
        new Salaries(
          [
            new Salary(
              new SalaryId(1),
              new SalaryAttribute(
                new PaymentAmount(10000),
                new PaymentType('salary'),
                new Remark('remark1'),
                new PaymentDate(new Date('2001/2/29'))
              )
            ),
            new Salary(
              new SalaryId(2),
              new SalaryAttribute(
                new PaymentAmount(20000),
                new PaymentType('bonus'),
                new Remark('remark2'),
                new PaymentDate(new Date('2001/2/29'))
              )
            )
          ] 
        )
      )

      const expected = {
        member_id: 1,
        member_name: 'test',
        salaries: 
          [
            {
              id: 1,
              payment_amount: 10000,
              payment_type: 'salary',
              remark: 'remark1',
              payment_date: new Date('2001/2/29'),
            },
            {
              id: 2,
              payment_amount: 20000,
              payment_type: 'bonus',
              remark: 'remark2',
              payment_date: new Date('2001/2/29'),
            }
          ]
      }

      const target = new MemberController(memberUseCase, salaryUseCase)
      const memberFindMemberSalariesFn = jest.fn()
      salaryUseCase.findByMemberId = memberFindMemberSalariesFn

      const serializeMemberSalariesFn = jest.fn()
      target['serializeMemberSalaries'] = serializeMemberSalariesFn

      when(memberFindMemberSalariesFn).calledWith(memberId).mockResolvedValue(memberSalary)
      when(serializeMemberSalariesFn).calledWith(memberSalary).mockResolvedValue(expected)

      const result = await target.findMemberSalaries(id)

      expect(memberFindMemberSalariesFn).toHaveBeenCalledTimes(1)
      expect(serializeMemberSalariesFn).toHaveBeenCalledTimes(1)
      expect(result).toEqual(expected)
    })
  })

  describe('findAllMembers', () => {
    test('メンバー全員を取得する', async () => {
      const memberRelations = new MemberRelations(
        [
          new MemberRelation(
            new Member(
              new MemberId(1),
              new MemberProfile(
                new MemberName('test1'),
                new MemberBirthday(new Date('1900/8/29')),
                new MemberGender(1)
              )
            ),
            new DepartmentId(1),
            new PostId(1),
            new EmploymentStatusId(1)
          ),
          new MemberRelation(
            new Member(
              new MemberId(2),
              new MemberProfile(
                new MemberName('test2'),
                new MemberBirthday(new Date('1900/8/29')),
                new MemberGender(1)
              )
            ),
            new DepartmentId(2),
            new PostId(2),
            new EmploymentStatusId(2)
          )
        ]
      )
      const expected = [
        {
          name: 'test1',
          department_id: 1,
          post_id: 1,
          employment_status_id: 1
        },
        {
          name: 'test2',
          department_id: 2,
          post_id: 2,
          employment_status_id: 2
        }
      ]

      const target = new MemberController(memberUseCase, salaryUseCase)

      const memberFindAllMembersFn = jest.fn()
      memberUseCase.findAll = memberFindAllMembersFn
      const serializeMemberForListFn = jest.fn()
      target['serializeMemberForList'] = serializeMemberForListFn

      when(memberFindAllMembersFn).calledWith().mockResolvedValue(memberRelations)
      when(serializeMemberForListFn).calledWith(memberRelations).mockResolvedValue(expected)

      const result = await target.findAllMembers()

      expect(memberFindAllMembersFn).toHaveBeenCalledTimes(1)
      expect(serializeMemberForListFn).toHaveBeenCalledTimes(1)
      expect(result).toEqual(expected)
    })
  })

  describe('createMember', () => {
    test('メンバーを登録する', async () => {
      const createParams = mock<CreateMemberParams>()
      const createMember = mock<MemberRelationAttribute>()

      const memberCreateFn = jest.fn()
      when(memberCreateFn).calledWith(createMember)
      memberUseCase.create = memberCreateFn

      const target = new MemberController(memberUseCase, salaryUseCase)
      await target.createMember(createParams)

      expect(memberCreateFn).toHaveBeenCalledTimes(1)
    })
  })

  describe('createMemberSalary', () => {
    test('メンバーの給与を更新する', async () => {
      const createSalaryParams = mock<CreateMemberSalaryParams>()
      const createSalary = mock<SalaryAttribute>()
      const memberId = mock<MemberId>()

      const createMemberSalaryFn = jest.fn()
      when(createMemberSalaryFn).calledWith(createSalary, memberId)
      memberUseCase.createSalary = createMemberSalaryFn

      const target = new MemberController(memberUseCase, salaryUseCase)
      await target.createMemberSalary(createSalaryParams)

      expect(createMemberSalaryFn).toHaveBeenCalledTimes(1)
    })
  })

  describe('updateMember', () => {
    test('メンバーを更新する', async () => {
      const id = mock<number>()
      const memberId = mock<MemberId>()

      const deleteMemberFn = jest.fn()
      when(deleteMemberFn).calledWith(memberId)
      memberUseCase.delete = deleteMemberFn

      const target = new MemberController(memberUseCase, salaryUseCase)
      await target.deleteMember(id)

      expect(deleteMemberFn).toHaveBeenCalledTimes(1)
    })
  })

  describe('deleteMember', () => {
    test('メンバーを削除する', async () => {
      const id = mock<number>()
      const updateMemberParams = mock<UpdateMemberParams>()
      const updateMember = mock<MemberRelationAttribute>()
      const memberId = mock<MemberId>()

      const updateMemberFn = jest.fn()
      when(updateMemberFn).calledWith(memberId, updateMember)
      memberUseCase.update = updateMemberFn

      const target = new MemberController(memberUseCase, salaryUseCase)
      await target.updateMember(id, updateMemberParams)

      expect(updateMemberFn).toHaveBeenCalledTimes(1)
    })
  })

  describe('serializeMemberForList', () => {
    test('メンバー一覧用にドメインをオブジェクトに変換する', async () => {
      const members = new MemberRelations(
        [
          new MemberRelation(
            new Member(
              new MemberId(1),
              new MemberProfile(
                new MemberName('test1'),
                new MemberBirthday(new Date('1900/8/29')),
                new MemberGender(1)
              )
            ),
            new DepartmentId(1),
            new PostId(1),
            new EmploymentStatusId(1)
          ),
          new MemberRelation(
            new Member(
              new MemberId(2),
              new MemberProfile(
                new MemberName('test2'),
                new MemberBirthday(new Date('1900/8/29')),
                new MemberGender(2)
              )
            ),
            new DepartmentId(1),
            new PostId(1),
            new EmploymentStatusId(1)
          )
        ]
      )

      const expected = [
        {
          name: 'test1',
          department_id: 1,
          post_id: 1,
          employment_status_id: 1
        },
        {
          name: 'test2',
          department_id: 1,
          post_id: 1,
          employment_status_id: 1
        }
      ]

      const target = new MemberController(memberUseCase, salaryUseCase)
      const result = await target["serializeMemberForList"](members)

      expect(result).toEqual(expected)
    })
  })

  describe('serializeMemberForDetail', () => {
    test('メンバー詳細用にドメインをオブジェクトに変換する', async () => {
      const member = new MemberRelation(
        new Member(
          new MemberId(1),
          new MemberProfile(
            new MemberName('test1'),
            new MemberBirthday(new Date('1900/8/29')),
            new MemberGender(1)
          )
        ),
        new DepartmentId(1),
        new PostId(1),
        new EmploymentStatusId(1)
      )

      const expected = {
        id: 1,
        name: 'test1',
        birthday: new Date('1900/8/29'),
        age: 121,
        gender: '男性',
        department_id: 1,
        post_id: 1,
        employment_status_id: 1
      }

      const target = new MemberController(memberUseCase, salaryUseCase)
      const result = await target["serializeMemberForDetail"](member)

      expect(result).toEqual(expected)
    })
  })

  describe('serializeMemberSalaries', () => {
    test('メンバー給与情報用にドメインをオブジェクトに変換する', async () => {
      const memberSalary = new MemberSalary(
        new Member(
          new MemberId(1),
          new MemberProfile(
            new MemberName('test'),
            new MemberBirthday(new Date()),
            new MemberGender(1)
          )
        ),
        new Salaries(
          [
            new Salary(
              new SalaryId(1),
              new SalaryAttribute(
                new PaymentAmount(10000),
                new PaymentType('salary'),
                new Remark('remark1'),
                new PaymentDate(new Date('2001/2/29'))
              )
            ),
            new Salary(
              new SalaryId(2),
              new SalaryAttribute(
                new PaymentAmount(20000),
                new PaymentType('bonus'),
                new Remark('remark2'),
                new PaymentDate(new Date('2001/2/29'))
              )
            )
          ] 
        )
      )

      const expected = {
        member_id: 1,
        member_name: 'test',
        salaries: [
          {
            id: 1,
            payment_amount: 10000,
            payment_type: 'salary',
            remark: 'remark1',
            payment_date: new Date('2001/2/29')
          },
          {
            id: 2,
            payment_amount: 20000,
            payment_type: 'bonus',
            remark: 'remark2',
            payment_date: new Date('2001/2/29')
          }
        ]
      }

      const target = new MemberController(memberUseCase, salaryUseCase)
      const result = await target["serializeMemberSalaries"](memberSalary)

      expect(result).toEqual(expected)
    })
  })
})

テスト実行

最後にテスト実行していきます。テストが通ると以下のようにpassedにカウントされます。

$ npm run test

PASS src/domain/tests/Member.spec.ts
PASS src/usecases/tests/MemberUseCase.spec.ts
PASS src/controller/tests/MemberController.spec.ts
PASS src/gateway/tests/MemberGateway.spec.ts

Test Suites: 4 passed, 4 total
Tests: 29 passed, 29 total
Snapshots: 0 total
Time: 2.212 s, es

ソフトウェア要件の理解

今回は簡単なメンバー管理システムとして作っていきました。まずソフトウェア要件としてどんなものがあるか挙げていきます。

このように要件を挙げていくことで曖昧な要件から明確な仕様へと発展させていきます。本来なら開発するソフトウェアに詳しい人からヒアリングするのですが、今回は個人開発なので自分で挙げていきました。

• メンバーを管理するシステム
• メンバーは1つの部署に所属し、役職が付いている
• メンバーの基本情報(名前、性別、生年月日など)を入力して登録する
• メンバーの情報は更新や削除ができる
• メンバー一覧や詳細を見ることができる
• 部署一覧と所属しているメンバーの人数を見ることができる
• 役職一覧と役職ごとのメンバーの人数を見ることができる
• メンバーにはそれぞれ雇用形態がある
• 雇用形態一覧と雇用形態ごとのメンバーの人数を見ることができる
• メンバーの給与情報を登録・削除できる
• 給与情報一覧を見ることができる

ユースケース図の作成

ソフトウェア要件を挙げたらユースケース図を作っていきます。このソフトウェアで何ができるのかをユーザー目線で表現します。

今回は管理者のみ使う想定となっており、主にメンバー管理に関するユースケースが想定されます(認証系は省略しています)。

エンティティの抽出

ソフトウェア要件やユースケース図が作成できたら、モデリング(エンティティの抽出)していきます。今回は以下のエンティティ候補が抽出されました。またユビキタス言語として用語を統一させておきます。

その後、モデリングの流れとしてエンティティを識別する属性・振る舞いやバリデーションの検討などがありますが、割愛します。

Typescript + Clean Architecture + DDDでAPIを開発する

本記事ではメンバー関連の一連の処理を中心に取り扱います。Clean Architectureの中心部分から説明していきます。

Enterprise Business Rules

Enterprise Business Rulesではアプリケーション全体の最重要ビジネスルールをカプセル化したドメインを格納しています。

まず先程定義したMemberエンティティをドメインのエンティティとしてどう定義していく考えていきます。

Memberの情報として必要なデータを値オブジェクトとして定義し、それらをまとめたMemberProfileという値オブジェクトを作成します。このMemberProfileにはMember自身の情報のみ持つようにしています。

次にMemberProfileに一意の識別子であるMemberIdをもっとMemberというエンティティを作成しました。

次にMember自身の情報として持っていないが、役職や部署などMemberに関連づけられたデータを持ったMemberRelationというエンティティとMemberの識別子を持っていないMemberRelationAttributeという値オブジェクトを作成しました。

MemberRalationエンティティのstaticなfromメソッドはプリミティブなオブジェクトからエンティティに変換する際に使われます。

Memberに関連する値オブジェクトとエンティティを作成したらそれらの振る舞いとバリデーションを実装していきます。

・Member.ts

import { FCC } from './Fcc'

export class MemberProfile {
  constructor(
    readonly name: MemberName,
    readonly birthday: MemberBirthday,
    readonly gender: MemberGender
  ) {}
}

export class Member {
  constructor(
    readonly id: MemberId,
    readonly member: MemberProfile
  ) {}
}

export class MemberId {
  constructor(readonly value: number) {}
}

export class MemberName {
  constructor(readonly value: string) {}

  isMaxSize() {
    return this.value.length > 30
  }
}

export class MemberBirthday {
  constructor(readonly value: Date) {}

  getAge(): number {
    const nowDate = new Date()
    const birthNumber = 
      this.value.getFullYear() * 10000 
      + (this.value.getMonth() + 1 ) * 100 
      + this.value.getDate();
    const nowNumber =
      nowDate.getFullYear() * 10000 
      + (nowDate.getMonth() + 1 ) * 100 
      + nowDate.getDate();
 
    return Math.floor( (nowNumber - birthNumber) / 10000 );
  }
}

export class MemberGender {
  constructor(readonly value: number) {}

  readonly GENDER = {
    MEN: 1,
    WOMAN: 2
  } as const

  getName(): string {
    return this.value == this.GENDER.MEN ? '男性' : '女性'
  }
}

export class Members extends FCC<Member> {
  constructor(values: Member[]) {
    super(values)
  }
}

・MemberRelation.ts

import { FCC } from "./Fcc"
import { DepartmentId } from "./Department"
import { MemberProfile, MemberId, MemberBirthday, MemberGender, MemberName, Member } from "./Member"
import { PostId } from "./Post"
import { EmploymentStatusId } from "./EmploymentStatus"

export class MemberRelationAttribute {
  constructor(
    readonly memberProfile: MemberProfile,
    readonly departmentId: DepartmentId,
    readonly postId: PostId,
    readonly employmentStatusId: EmploymentStatusId
  ) {}

  update(id: MemberId): MemberRelation {
    return new MemberRelation(
      new Member(
        new MemberId(id.value),
        new MemberProfile(
          new MemberName(this.memberProfile.name.value),
          new MemberBirthday(this.memberProfile.birthday.value),
          new MemberGender(this.memberProfile.gender.value)
        )
      ),
      new DepartmentId(this.departmentId.value),
      new PostId(this.postId.value),
      new EmploymentStatusId(this.employmentStatusId.value)
    )
  }
}

export class MemberRelation {
  constructor(
    readonly member: Member,
    readonly departmentId: DepartmentId,
    readonly postId: PostId,
    readonly employmentStatusId: EmploymentStatusId
  ) {}

  static from(
    id: number,
    name: string,
    birthday: Date,
    gender: number,
    departmentId: number,
    postId: number,
    employmentStatusId: number
  ) {
    return new MemberRelation(
      new Member(
        new MemberId(id),
        new MemberProfile(
          new MemberName(name),
          new MemberBirthday(birthday),
          new MemberGender(gender)
        )
      ),
      new DepartmentId(departmentId),
      new PostId(postId),
      new EmploymentStatusId(employmentStatusId)
    )
  }
}

export class MemberRelations extends FCC<MemberRelation> {
  constructor(values: MemberRelation[]) {
    super(values)
  }
}

Application Business Rules

Application Business Rulesではアプリケーション固有のビジネスルールが含まれ、入出力するデータの流れを調整します。

MemberPortにインターフェイスを定義し、MemberGatewayで具象クラスを実装するようにしています。

MemberUseCaseではMemberControllerから受け取ったドメインをバリデーションなどで精査し、MemberGatewayの具象メソッドを呼び出すようにしています。ちなみにDIライブラリとしてTSyringeを使用しています。

・MemberPort.ts

import { SalaryAttribute } from '../domain/Salary'
import { MemberId } from '../domain/Member'
import { MemberRelation, MemberRelationAttribute, MemberRelations } from '../domain/MemberRelation'

export interface MemberPort {
  findAll(): Promise<MemberRelations>
  find(id: MemberId): Promise<MemberRelation>
  create(member: MemberRelationAttribute): Promise<void>
  createSalary(salary: SalaryAttribute, memberId: MemberId): Promise<void>
  update(member: MemberRelation): Promise<void>
  delete(id: MemberId): Promise<void>
}

・MemberUseCase.ts

import { MemberPort } from '../port/MemberPort'
import { MemberId } from '../domain/Member'
import { MemberRelation, MemberRelationAttribute, MemberRelations } from '../domain/MemberRelation'
import "reflect-metadata"
import { inject, singleton } from "tsyringe"
import { SalaryAttribute } from '../domain/Salary'

@singleton()
export class MemberUseCase {
  constructor(@inject("MemberPort") private memberPort: MemberPort) {}

  find(id: MemberId): Promise<MemberRelation> {
    return this.memberPort.find(id)
  }

  findAll(): Promise<MemberRelations> {
    return this.memberPort.findAll()
  }

  create(member: MemberRelationAttribute): Promise<void> {
    if (member.memberProfile.name.isMaxSize()) {
      throw new Error("名前は30文字以下です")
    }
    return this.memberPort.create(member)
  }

  createSalary(salary: SalaryAttribute, memberId: MemberId): Promise<void> {
    if (salary.remark.isMaxSize()) {
      throw new Error("備考は300文字以下です")
    }

    return this.memberPort.createSalary(salary, memberId)
  }

  async update(id: MemberId, member: MemberRelationAttribute): Promise<void> {
    const targetMember = await this.memberPort.find(id)
    const updateMember = member.update(targetMember.member.id)

    if (updateMember.member.member.name.isMaxSize()) {
      throw new Error("名前は30文字以下です")
    }
    return this.memberPort.update(updateMember)
  }

  delete(id: MemberId): Promise<void> {
    return this.memberPort.delete(id)
  }
}

Interface & Adapter

Interface & Adapterではドメインやユースケースに便利な形式からDBに便利な形式にデータを変換します。

MemberGatewayではMemberUseCaseから渡されたドメインをプリミティブなJson形式のオブジェクトに詰め替えてMemberDriverを呼び出しています。

なぜならDriver層にはドメインの知識を流出させたくないためであり、あくまでDriverに必要なデータだけをプリミティブな形で渡すようにします。

そしてDriverから返ってきた値をドメインに詰め替えてからUseCaseに返すようにします。

MemberControllerではリクエストされたパラメーターをドメインに詰め替えてUseCaseに渡し、UseCaseから返ってきたドメインをレスポンスとして返したい形式に変換して返します。またレスポンスとして返す時もリスポンスの型を定義し、変換して返すようにしています。

このようにこのレイヤでは主に入出力用に変換する処理を行っています。

・MemberGateway.ts

import { MemberPort } from '../port/MemberPort'
import { MemberDriver, MemberEntity } from '../driver/MemberDriver'
import { MemberRelation, MemberRelationAttribute, MemberRelations } from '../domain/MemberRelation'
import { MemberId, MemberGender, MemberName, MemberBirthday, MemberProfile, Member } from '../domain/Member'
import { DepartmentId } from '../domain/Department'
import { PostId } from '../domain/Post'
import { inject, singleton } from "tsyringe"
import { EmploymentStatusId } from '../domain/EmploymentStatus'
import { SalaryAttribute } from '../domain/Salary'

@singleton()
export class MemberGateway implements MemberPort {
  constructor(@inject("MemberDriver") private memberDriver: MemberDriver) {}

  async find(id: MemberId): Promise<MemberRelation> {
    const member: MemberEntity = await this.memberDriver.find(id.value)

    return this.convertMemberValue(member)
  }

  async findAll(): Promise<MemberRelations> {
    const members: MemberEntity[] = await this.memberDriver.findAll()

    return new MemberRelations(
      members.map((member: MemberEntity) => this.convertMemberValue(member))
    )
  }

  async create(member: MemberRelationAttribute): Promise<void> {
    await this.memberDriver.create({
      name: member.memberProfile.name.value,
      birthday: member.memberProfile.birthday.value,
      gender: member.memberProfile.gender.value,
      departmentId: member.departmentId.value,
      postId: member.postId.value,
      employmentStatusId: member.employmentStatusId.value
    })
  }

  async createSalary(salary: SalaryAttribute, memberId: MemberId): Promise<void> {
    await this.memberDriver.createSalary({
      paymentAmount: salary.paymentAmount.value,
      paymentType: salary.paymentType.value,
      remark: salary.remark.value,
      paymentDate: salary.paymentDate.value
    }, memberId.value)
  }

  async update(member: MemberRelation): Promise<void> {
    await this.memberDriver.update({
      id: member.member.id.value,
      name: member.member.member.name.value,
      birthday: member.member.member.birthday.value,
      gender: member.member.member.gender.value,
      departmentId: member.departmentId.value,
      postId: member.postId.value,
      employmentStatusId: member.employmentStatusId.value
    })
  }

  async delete(id: MemberId): Promise<void> {
    await this.memberDriver.delete(id.value)
  }

  private convertMemberValue(member: MemberEntity) {
    const converMember = MemberRelation.from(
      member.member.id,
      member.member.name,
      member.member.birthday,
      member.member.gender,
      member.departmentId,
      member.postId,
      member.employmentStatusId
    )

    return converMember
  }

}

・MemberController.ts

import { MemberUseCase } from '../usecases/MemberUseCase'
import { SalaryUseCase } from '../usecases/SalaryUseCase'
import { MemberRelation, MemberRelationAttribute, MemberRelations } from '../domain/MemberRelation'
import { MemberBirthday, MemberGender, MemberId, MemberName, MemberProfile } from '../domain/Member'
import { DepartmentId } from '../domain/Department'
import { PostId } from '../domain/Post'
import { inject, singleton } from "tsyringe"
import { EmploymentStatusId } from '../domain/EmploymentStatus'
import { MemberSalary } from '../domain/MemberSalary'
import { PaymentAmount, PaymentDate, PaymentType, Remark, SalaryAttribute } from '../domain/Salary'

@singleton()
export class MemberController {
  constructor(
    @inject("MemberUseCase") private memberUseCase: MemberUseCase,
    @inject("SalaryUseCase") private salaryUseCase: SalaryUseCase
  ) {}

  async findMember(id: number): Promise<MemberForDetailResponse> {
    const memberId = new MemberId(id)
    const member: MemberRelation = await this.memberUseCase.find(memberId)
    
    return this.serializeMemberForDetail(member)
  }

  async findMemberSalaries(id: number): Promise<MemberSalaries> {
    const memberId = new MemberId(id)
    const memberSalary: MemberSalary = await this.salaryUseCase.findByMemberId(memberId)

    return this.serializeMemberSalaries(memberSalary)
  }

  async findAllMembers(): Promise<MemberForListResponse[]> {
    const members: MemberRelations = await this.memberUseCase.findAll()

    return this.serializeMemberForList(members)
  }

  async createMember(createParams: CreateMemberParams): Promise<void> {
    const { name, birthday, gender, department_id, post_id, employment_status_id } = createParams
    const createMember = new MemberRelationAttribute(
      new MemberProfile(
        new MemberName(name),
        new MemberBirthday(birthday),
        new MemberGender(gender)
      ),
      new DepartmentId(department_id),
      new PostId(post_id),
      new EmploymentStatusId(employment_status_id)
    )
    await this.memberUseCase.create(createMember)
  }

  async createMemberSalary(createSalaryParams: CreateMemberSalaryParams): Promise<void> {
    const { member_id, payment_amount, payment_type, remark, payment_date } = createSalaryParams
    const createSalary = 
      new SalaryAttribute(
        new PaymentAmount(payment_amount),
        new PaymentType(payment_type),
        new Remark(remark),
        new PaymentDate(payment_date)
      )
    const memberId = new MemberId(member_id)
    await this.memberUseCase.createSalary(createSalary, memberId)
  }

  async updateMember(id: number, updateMemberParams: UpdateMemberParams): Promise<void> {
    const memberId = new MemberId(id)
    const { name, birthday, gender, department_id, post_id, employment_status_id } = updateMemberParams
    const updateMember = new MemberRelationAttribute(
      new MemberProfile(
        new MemberName(name),
        new MemberBirthday(birthday),
        new MemberGender(gender)
      ),
      new DepartmentId(department_id),
      new PostId(post_id),
      new EmploymentStatusId(employment_status_id)
    )
    await this.memberUseCase.update(memberId, updateMember)
  }

  async deleteMember(id: number): Promise<void> {
    const memberId = new MemberId(id)
    await this.memberUseCase.delete(memberId)
  }

  private serializeMemberForList(members: MemberRelations) {
    return members.map((member: MemberRelation) => {
      return {
        name: member.member.member.name.value,
        department_id: member.departmentId.value,
        post_id: member.postId.value,
        employment_status_id: member.employmentStatusId.value
      }
    })
  }

  private serializeMemberForDetail(member: MemberRelation) {
    return {
      id: member.member.id.value,
      name: member.member.member.name.value,
      birthday: member.member.member.birthday.value,
      age: member.member.member.birthday.getAge(),
      gender: member.member.member.gender.getName(),
      department_id: member.departmentId.value,
      post_id: member.postId.value,
      employment_status_id: member.employmentStatusId.value
    }
  }

  private serializeMemberSalaries(memberSalary: MemberSalary) {
    return {
      member_id: memberSalary.member.id.value,
      member_name: memberSalary.member.member.name.value,
      salaries: memberSalary.salaries.map(salary => {
        return {
          id: salary.id.value,
          payment_amount: salary.salaryAttribute.paymentAmount.value,
          payment_type: salary.salaryAttribute.paymentType.value,
          remark: salary.salaryAttribute.remark.value,
          payment_date: salary.salaryAttribute.paymentDate.value,
        }
      })
    }
  }
}

export interface CreateMemberParams {
  name: string,
  birthday: Date,
  gender: number,
  department_id: number,
  post_id: number,
  employment_status_id: number,
}

export interface CreateMemberSalaryParams {
  member_id: number,
  payment_amount: number,
  payment_type: string,
  remark: string,
  payment_date: Date
}

export interface UpdateMemberParams {
  name: string,
  birthday: Date,
  gender: number,
  department_id: number,
  post_id: number,
  employment_status_id: number,
}

export interface MemberForDetailResponse {
  id: number,
  name: string,
  birthday: Date,
  age: number,
  gender: string,
  department_id: number,
  post_id: number,
  employment_status_id: number
}

export interface MemberForListResponse {
  name: string,
  department_id: number,
  post_id: number,
  employment_status_id: number
}

export interface MemberSalaries {
  member_id: number,
  member_name: string,
  salaries: 
    {
      id: number,
      payment_amount: number,
      payment_type: string,
      remark: string,
      payment_date: Date,
    }[]
}

Framework & Driver

Framework & Driverはフレームワークやツールで構成されています。

このレイヤにあるMemberDriverはDBから欲しいデータを取得しMemberGatewayに返すようにしています。今回はDBから取得(ORMはSequelizeを使用)していますが、APIならここでAPIリクエストをして返ってきたデータを返します。返すデータはEntityとして詰め直してGatewayに返します。

MemberGatewayでドメインからJson形式に変換したJsonオブジェクトの型とMemberGatewayに返すEntityの型をここで定義しています。

他にもRouterなどありますがここでは割愛しています。

・MemberDriver.ts

import { singleton } from "tsyringe"
const db = require('../../models')

@singleton()
export class MemberDriver {
  async find(id: number): Promise<MemberEntity> {
    const member = await db.member.findByPk(id, {
      include: [
        { 
          model: db.department,
          as: 'department'
        },
        { 
          model: db.post,
          as: 'post'
        }
      ]
    })
 
    return {
      member: {
        id: member.id,
        name: member.name,
        birthday: member.birthday,
        gender: member.gender,
      },
      departmentId: member.department_id,
      postId: member.post_id,
      employmentStatusId: member.employment_status_id
    }
  }

  async findAll(): Promise<MemberEntity[]> {
    const members = await db.member.findAll({
      include: [
        { 
          model: db.department,
          as: 'department'
        },
        { 
          model: db.post,
          as: 'post'
        }
      ]
    })

    return　members.map((member: MemberModelEntity) => {
      return {
        member: {
          id: member.id,
          name: member.name,
          birthday: member.birthday,
          gender: member.gender,
        },
        departmentId: member.department_id,
        postId: member.post_id,
        employmentStatusId: member.employment_status_id
      }
    }) 
  }

  async create(member: MemberValueProfileJson): Promise<void> {
    await db.member.create({
      name: member.name,
      birthday: member.birthday,
      gender: member.gender,
      department_id: member.departmentId,
      post_id: member.postId,
      employment_status_id: member.employmentStatusId
    })
  }

  async createSalary(salary: SalaryJson, memberId: number): Promise<void> {
    await db.salary.create({
      member_id: memberId,
      payment_amount: salary.paymentAmount,
      payment_type: salary.paymentType,
      remark: salary.remark,
      payment_date: salary.paymentDate,
    })
  }

  async update(memberJson: MemberJson): Promise<void> {
    const targetMember = await db.member.findByPk(memberJson.id)
    targetMember.name = memberJson.name
    targetMember.birthday = memberJson.birthday
    targetMember.gender = memberJson.gender
    targetMember.department_id = memberJson.departmentId
    targetMember.post_id = memberJson.postId
    targetMember.employment_status_id = memberJson.employmentStatusId

    await targetMember.save()
  }

  async delete(id: number): Promise<void> {
    const targetMember = await db.member.findByPk(id)
    await targetMember.destroy()
  }
}

export interface MemberJson {
    id: number,
    name: string,
    birthday: Date,
    gender: number,
    departmentId: number,
    postId: number,
    employmentStatusId: number
}

export interface MemberValueProfileJson {
  name: string,
  birthday: Date,
  gender: number,
  departmentId: number,
  postId: number,
  employmentStatusId: number
}

export interface SalaryJson {
  paymentAmount: number,
  paymentType: string,
  remark: string | null,
  paymentDate: Date
}

export interface MemberEntity {
  member: {
    id: number,
    name: string,
    birthday: Date,
    gender: number
  },
  departmentId: number,
  postId: number,
  employmentStatusId: number
}

export interface MemberModelEntity {
  id: number,
  name: string,
  birthday: Date,
  gender: number,
  department_id: number,
  post_id: number,
  employment_status_id: number
}

クリーンアーキテクチャとは

クリーンアーキテクチャはソフトウェアをレイヤーに分割することで、関心事の分離を実現し、以下の特性を持ったシステムを生み出します。

• フレームワーク非依存：システムをフレームワークの制約で縛るのではなく、フレームワークをツールとして使用する
• テスト可能：ビジネスルールはUIやDB、サーバー、その他の外部要素がなくてもテストできる
• UI非依存：UIはシステムの他の部分を変更することなく、簡単に変更できる
• データベース非依存：ビジネスルールはDBに束縛されていない
• 外部エージェント非依存：ビジネスルールは外界のインターフェイスについて何も知らない

一般的に縁の中央に近づくほどソフトウェアのレベルが上がり、縁の外側は仕組みで内側は方針となっています。

縁の内側は外側について何も知らず、外側で宣言された関数やクラス、変数などは内側にあるコードで触れてはならず、依存性は外から中だけに向かっていきます。

Clean ArchitectureでAPIを実装する

今回はToDoアプリのAPIをClean Architectureで実装しました。

具体的にはTaskテーブルを作成し、そこにToDoのデータが格納され、一覧や詳細、登録などをこのAPIで実現できるようになっています。

中身はシンプルなCRUDで、どの処理をどこに書くかを意識して実装しました。また、ドメイン層ではDDDを意識した作りにしました。といっても今回はドメインがTaskしかないため振る舞いはほどんどなく、簡易的なものになっています。

Enterprise Business Rules(企業のビジネスルール)

このレイヤーにはアプリケーション全体の最重要ビジネスルールをカプセル化したドメインを格納しています。

今回はToDoアプリを想定したAPIとなっており、ビジネスロジックは更新時のみで、データ構造とアクセサメソッドのみ定義しています。

またDDDを意識した実装にし、それぞれのプロパティを値オブジェクトとして定義しています。

コンストラクタの引数が関数内で変更されないため、readonlyプロパティをつけています。こうすることで、引数が読み込み専用で変更されないことが担保されます。

・Domain

import moment from 'moment'
import { FCC } from './Fcc'

export class Task {
  constructor(
    readonly id: TaskId,
    readonly content: TaskContent,
    readonly status: TaskStatus,
    readonly createdAt: TaskCreatedAt,
    readonly updatedAt: TaskUpdatedAt
  ) {}

  readonly STATUS = {
    TODO: 1,
    DONE: 2,
  } as const;

  updateStatus(status: number) {
    const task = new Task(
      new TaskId(this.id.value),
      new TaskContent(this.content.value),
      new TaskStatus(Number(status)),
      new TaskCreatedAt(this.createdAt.value),
      new TaskUpdatedAt(this.updatedAt.value)
    )

    return task
  }
}

export class TaskId {
  constructor(readonly value: number) {}
}

export class TaskContent {
  constructor(readonly value: string) {}
}

export class TaskStatus {
  constructor(readonly value: number) {}
}

export class TaskCreatedAt {
  constructor(readonly value: moment.Moment) {}
}

export class TaskUpdatedAt {
  constructor(readonly value: moment.Moment) {}
}

export class Tasks extends FCC<Task> {
  constructor(values: Task[]) {
    super(values)
  }
}

Application Business Rules(アプリケーションのビジネスルール)

このレイヤーにはアプリケーション固有のビジネスルールが含まれ、入出力するデータの流れを調整します。

このレイヤーの変更がドメインに影響を与えることはなく、またこのレイヤーがDBやUI、共通のフレームワークなどの外部の変更の影響を受けることもありません。

ここでは依存関係を中心に向かうようにしたいため、依存関係逆転の原則(DIP)を使ってPortにインターフェイスを定義しています。そうすることでUseCaseがPortというインターフェイスに依存することになり、Portのインスタンス化をGatewayで行うようにしています。

具体的にはコンストラクタでTaskGatewayをTaskPortとして受け取ることで、インターフェイスを継承しています。

・UseCase

import { TaskPort } from '../port/TaskPort'

export class TaskUseCase {
  private taskPort: TaskPort

  constructor(taskPort: TaskPort) {
    this.taskPort = taskPort
  }

  getById(id: number) {
    return this.taskPort.find(id)
  }

  getList() {
    return this.taskPort.findAll()
  }

  create(content: string) {
    return this.taskPort.create(content)
  }

  async update(id: number, status: number) {
    const task = await this.taskPort.find(id)
    const updateTask = task.updateStatus(status)
    return this.taskPort.update(updateTask)
  }

  async delete(id: number) {
    return this.taskPort.delete(id)
  }
}

・Port

import { Task, Tasks } from '../domain/Task'

export interface TaskPort {
  findAll(): Promise<Tasks>
  find(id: number): Promise<Task>
  create(content: String): Promise<any>
  update(task: Task): Promise<any>
  delete(id: number): Promise<any>
}

Interface Adaptors(インターフェイスアダプター)

このレイヤーではドメインやユースケースに便利な形式から、永続フレームワーク(DB)に便利な形式にデータを変換します。

円の内側のコードは、DBについて何も知らず、DBがSQLであれば全てのSQLはこのレイヤーに限定する必要があります。

ここではPortの具象クラスであるGatewayとResourceを格納しています。そのため、GatewayではPortのインターフェイスを継承しています。

GatewayではconvertTaskメソッドでSQLから返ってきたEntityをDomainに変換する処理をしています。

ResourceのserializeTaskメソッドでTaskドメインからAPIのレスポンスとして返したい形に変換しています。

・Gateway

import { TaskPort } from '../port/TaskPort'
import { TaskDriver } from '../driver/TaskDriver'
import {
  Task,
  TaskContent,
  TaskCreatedAt,
  TaskId,
  Tasks,
  TaskStatus,
  TaskUpdatedAt
} from '../domain/Task'

export class TaskGateway implements TaskPort {
  private taskDriver: TaskDriver

  constructor(taskDriver: TaskDriver) {
    this.taskDriver = taskDriver
  }

  private convertTask(result: any) {
    const task = new Task(
      new TaskId(result.id),
      new TaskContent(result.content),
      new TaskStatus(result.status),
      new TaskCreatedAt(result.created_at),
      new TaskUpdatedAt(result.updated_at)
    )

    return task
  }

  async find(id: number): Promise<Task> {
    const result = await this.taskDriver.find(id)

    return this.convertTask(result[0])
  }

  async findAll(): Promise<Tasks> {
    try {
      const results = await this.taskDriver.findAll()

      return results.map((result: Task) => {
        return this.convertTask(result)
      })
    } catch (e) {
      throw e
    }
  }

  async create(content: String): Promise<any> {
    try {
      const result = await this.taskDriver.create(content)

      return result
    } catch (e) {
      throw e
    }
  }

  async update(task: Task): Promise<any> {
    try {
      const result = await this.taskDriver.update(task)

      return result
    } catch (e) {
      throw e
    }
  }

  async delete(id: number): Promise<any> {
    try {
      const result = await this.taskDriver.delete(id)

      return result
    } catch (e) {
      throw e
    }
  }
}

・Resource

import { TaskUseCase } from '../usecases/TaskUseCase'
import { Task } from '../domain/Task'

export class TaskResource {
  private taskUseCase: TaskUseCase

  constructor(taskUseCase: TaskUseCase) {
    this.taskUseCase = taskUseCase
  }

  async findTask(req: any, res: any) {
    const id = req.params.id
    const result = await this.taskUseCase.getById(id)

    return this.serialize(result)
  }

  async findAllTasks(req: any, res: any) {
    const result = await this.taskUseCase.getList()

    return this.serialize(result)
  }

  async createTask(req: any, res: any) {
    const { content } = req.body
    const result = await this.taskUseCase.create(content)
    return result
  }

  async updateTask(req: any, res: any) {
    const id = req.params.id
    const { status } = req.body
    const result = await this.taskUseCase.update(id, status)
    return result
  }

  async deleteTask(req: any, res: any) {
    const id = req.params.id
    const result = await this.taskUseCase.delete(id)
    return result
  }

  private serializeTask = (task: Task) => {
    return {
      id: task.id.value,
      content: task.content.value,
      status: task.status.value,
      createdAt: task.createdAt.value,
      updatedAt: task.updatedAt.value
    }
  }

  private serialize(data: any) {
    if (!data) {
      throw new Error('data is undefined or null')
    }
    if (Array.isArray(data)) {
      return data.map(task => this.serializeTask(task))
    }
    return this.serializeTask(data)
  }
}

Frameworks & Drivers(フレームワークとドライバ)

最も外側の円は、フレームワークやツールで構成されています。例えばDBやWebフレームワークなどがこのレイヤーに格納されています。RouterやDriverもこのレイヤーに格納しています。

Tasksテーブルのカラムであるcreated_atとupdated_atはdefaultValueを「CURRENT_TIMESTAMP」、「CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP」にして自動的に登録されるようにしています。

statusもdefaultValueを1にすることでcreateではデフォルトで登録できるようにしています。

・Driver

import { Task } from '../domain/Task'
import { IDBConnection } from './db/IDBConnection'

export class TaskDriver {
  private connection: any

  constructor(connection: IDBConnection) {
    this.connection = connection
  }

  async find(id: number): Promise<any> {
    const result = await this.connection.execute(
      'select * from tasks where id = ?',
      id
    )

    return result
  }

  async findAll(): Promise<any> {
    const result = await this.connection.execute('select * from tasks')
    return result
  }

  async create(content: String): Promise<any> {
    const result = await this.connection.execute(
      'insert into tasks (content) values (?)',
      content
    )
    return result
  }

  async update(task: Task): Promise<any> {
    const result = this.connection.execute(
      'update tasks set status = ? where id = ?',
      [task.status.value, task.id.value]
    )
    return result
  }

  async delete(id: number): Promise<any> {
    const result = await this.connection.execute(
      'delete from tasks where id = ?',
      id
    )
    return result
  }
}

Routerではexpressのrouterを使ってルーティング設定をしています。

またRouterで各層の依存関係を定義(DI)することで、それぞれレイヤーで利用可能な状態にします。

・Router

import express = require('express')
import { TaskUseCase } from '../usecases/TaskUseCase'
import { TaskGateway } from '../gateway/TaskGateway'
import { TaskResource } from '../rest/TaskResource'
import { MysqlConnection } from './db/MysqlConnection'
import { TaskDriver } from './TaskDriver'

const mysqlConnection = new MysqlConnection()
const taskDriver = new TaskDriver(mysqlConnection)
const taskGateway = new TaskGateway(taskDriver)
const taskUsecase = new TaskUseCase(taskGateway)
const taskResource = new TaskResource(taskUsecase)

const router = express.Router()

router.get('/tasks', async (req: express.Request, res: express.Response) => {
  const results = await taskResource.findAllTasks(req, res)
  res.send(results)
})

router.get(
  '/tasks/:id',
  async (req: express.Request, res: express.Response) => {
    const result = await taskResource.findTask(req, res)

    res.send(result)
  }
)

router.post('/tasks', async (req: express.Request, res: express.Response) => {
  const result = await taskResource.createTask(req, res)
  res.send(result)
})

router.patch(
  '/tasks/:id',
  async (req: express.Request, res: express.Response) => {
    const result = await taskResource.updateTask(req, res)
    res.send(result)
  }
)

router.delete(
  '/tasks/:id',
  async (req: express.Request, res: express.Response) => {
    const result = await taskResource.deleteTask(req, res)
    res.send(result)
  }
)

export default router

Serverではexpressを使ってサーバー処理を書いています。routerのパスや待ち受けるポート番号などを設定しています。

また、CORSで「http://localhost:3000」のみアクセスできるようにしています。

・Server

import express from 'express'
import router from './router'
import bodyParser from 'body-parser'
import cors from 'cors'

const app = express()

app.use(bodyParser.urlencoded({ extended: false }))
app.use(bodyParser.json())

const allowedOrigins = ['http://localhost:3000']

const options: cors.CorsOptions = {
  origin: allowedOrigins
}
app.use(cors(options))
app.use('/api', router)

app.listen(5000, () => {
  console.log('listening on port 5000')
})

export default app

・IDBConnection

export abstract class IDBConnection {
  abstract execute(query: string, params: any): any
}

・MysqlConnection

import mysql from 'mysql'
import dotenv from 'dotenv'
import util from 'util'
import { IDBConnection } from './IDBConnection'

export class MysqlConnection extends IDBConnection {
  private pool: any

  constructor() {
    super()
    dotenv.config()
    this.pool = mysql.createPool({
      connectionLimit: 5,
      host: process.env.DB_HOST_DEV,
      user: process.env.DB_USER_DEV,
      password: process.env.DB_PASSWORD_DEV,
      database: process.env.DB_NAME_DEV,
      timezone: 'utc'
    })

    this.pool.getConnection((error: any, connection: any) => {
      if (error) {
        if (error.code === 'PROTOCOL_CONNECTION_LOST') {
          console.error('Database connection was closed.')
        }
        if (error.code === 'ER_CON_COUNT_ERROR') {
          console.error('Database has too many connections.')
        }
        if (error.code === 'ECONNREFUSED') {
          console.error('Database connection was refused.')
        }
      }

      if (connection) connection.release()

      return
    })
    this.pool.query = util.promisify(this.pool.query)

    // pool event
    this.pool.on('connection', (connection: any) => {
      console.log('mysql connection create')
    })

    this.pool.on('release', (connection: any) => {
      console.log('Connection %d released', connection.threadId)
    })
  }

  execute(query: string, params: any = null) {
    if (params !== null) {
      return this.pool.query(query, params)
    } else {
      return this.pool.query(query)
    }
  }
}