Prisma로 GraphQL API를 구축하고 의 앱 플랫폼에 배포하는 방법


저자는 기부를 위해 쓰기 프로그램을 선택했습니다.

소개

GraphQL은 스키마 정의 언어와 쿼리 언어로 구성된 API용 쿼리 언어로, API 소비자는 유연한 쿼리를 지원하는 데 필요한 데이터만 가져올 수 있습니다. GraphQL을 사용하면 개발자가 iOS, Android 및 앱의 웹 변형과 같은 여러 클라이언트의 다양한 요구 사항을 충족하면서 API를 발전시킬 수 있습니다. 또한 GraphQL 스키마는 API에 대한 형식 안전성을 추가하는 동시에 API에 대한 문서 형식을 제공합니다.

Prisma는 세 가지 주요 도구가 포함된 오픈 소스 데이터베이스 툴킷입니다.

  • Prisma 클라이언트: Node.js 및 TypeScript용 자동 생성 및 유형 안전 쿼리 빌더
  • Prisma Migrate: 선언적 데이터 모델링 및 마이그레이션 시스템
  • Prisma Studio: 데이터베이스에서 데이터를 보고 편집하는 GUI.

Prisma는 복잡한 데이터베이스 워크플로(예: 스키마 마이그레이션 또는 복잡한 SQL 쿼리 작성)에 시간을 소비하는 대신 부가가치 기능 구현에 집중하려는 애플리케이션 개발자를 위해 데이터베이스 작업을 용이하게 합니다.

이 튜토리얼에서는 각각의 책임이 서로를 보완하므로 GraphQL과 Prisma를 함께 사용합니다. GraphQL은 프런트엔드 및 모바일 앱과 같은 클라이언트에서 사용할 데이터에 대한 유연한 인터페이스를 제공합니다. GraphQL은 특정 데이터베이스에 연결되어 있지 않습니다. 데이터가 저장될 데이터베이스와의 상호 작용을 처리하기 위해 Prisma가 들어오는 곳입니다.

DigitalOcean의 앱 플랫폼은 인프라에 대한 걱정 없이 애플리케이션을 배포하고 클라우드에서 데이터베이스를 프로비저닝할 수 있는 완벽한 방법을 제공합니다. 이렇게 하면 클라우드에서 애플리케이션을 실행하는 운영 오버헤드가 줄어듭니다. 특히 일일 백업 및 자동 장애 조치를 통해 관리형 PostgreSQL 데이터베이스를 생성하는 기능이 있습니다. 앱 플랫폼에는 기본 Node.js 지원 간소화 배포가 있습니다.

Node.js를 사용하여 JavaScript에서 블로그 애플리케이션용 GraphQL API를 빌드합니다. 먼저 Apollo 서버를 사용하여 메모리 내 데이터 구조로 지원되는 GraphQL API를 빌드합니다. 그런 다음 API를 DigitalOcean 앱 플랫폼에 배포합니다. 마지막으로 Prisma를 사용하여 메모리 내 저장소를 교체하고 PostgreSQL 데이터베이스에 데이터를 유지하고 애플리케이션을 다시 배포합니다.

튜토리얼이 끝나면 HTTP를 통해 전송된 GraphQL 요청을 처리하고 PostgreSQL 데이터베이스에 대해 CRUD 작업을 수행하는 DigitalOcean에 Node.js GraphQL API가 배포됩니다.

DigitalOcean Community 저장소에서 이 프로젝트의 코드를 찾을 수 있습니다.

전제 조건

이 가이드를 시작하기 전에 다음이 필요합니다.

  • GitHub 계정.
  • DigitalOcean 계정.
  • 오픈 소스에 기여하기: 컴퓨터에 Git을 설치하고 설정하기 위해 Git 시작하기
  • Node.js를 설치하고 컴퓨터에 Node.js를 설치하고 설정하기 위한 로컬 개발 환경을 만드는 방법
  • PostgreSQL 데이터베이스를 로컬로 실행하기 위해 컴퓨터에 Docker가 설치되었습니다.

Node.js, GraphQL 및 PostgreSQL에 대한 기본적인 지식이 있으면 도움이 되지만 이 자습서에 반드시 필요한 것은 아닙니다.

1단계 — Node.js 프로젝트 만들기

이 단계에서는 npm으로 Node.js 프로젝트를 설정하고 종속성 apollo-servergraphql을 설치합니다. 이 프로젝트는 이 튜토리얼 전체에서 빌드하고 배포할 GraphQL API의 기반이 됩니다.

먼저 프로젝트의 새 디렉터리를 만듭니다.

  1. mkdir prisma-graphql

다음으로 디렉터리로 이동하여 빈 npm 프로젝트를 초기화합니다.

  1. cd prisma-graphql
  2. npm init --yes

이 명령은 npm 프로젝트의 구성 파일로 사용되는 최소한의 package.json 파일을 생성합니다.

다음 출력을 받게 됩니다.

Output
Wrote to /Users/your_username/workspace/prisma-graphql/package.json: { "name": "prisma-graphql", "version": "1.0.0", "description": "", "main": "index.js", "scripts": { "test": "echo \"Error: no test specified\" && exit 1" }, "keywords": [], "author": "", "license": "ISC" }

이제 프로젝트에서 TypeScript를 구성할 준비가 되었습니다.

필요한 종속 항목을 설치합니다.

  1. npm install apollo-server graphql --save

이 명령은 프로젝트에 두 개의 패키지를 종속 항목으로 설치합니다.

  • apollo-server는 GraphQL 요청이 해결되는 방법과 데이터를 가져오는 방법을 정의하는 데 사용하는 HTTP 라이브러리입니다.
  • graphql은 GraphQL 스키마를 빌드하는 데 사용할 라이브러리입니다.

프로젝트를 만들고 종속 항목을 설치했습니다. 다음 단계에서는 GraphQL 스키마를 정의합니다.

2단계 - GraphQL 스키마 및 해석기 정의

이 단계에서는 GraphQL 스키마 및 해당 리졸버를 정의합니다. 스키마는 API가 처리할 수 있는 작업을 정의합니다. 리졸버는 다음 단계에서 데이터베이스 쿼리로 대체할 메모리 내 데이터 구조를 사용하여 이러한 요청을 처리하기 위한 논리를 정의합니다.

먼저 소스 파일을 포함할 src라는 새 디렉터리를 만듭니다.

  1. mkdir src

그런 다음 다음 명령을 실행하여 스키마에 대한 파일을 생성합니다.

  1. nano src/schema.js

파일에 다음 코드를 추가합니다.

const { gql } = require('apollo-server')

const typeDefs = gql`
  type Post {
    content: String
    id: ID!
    published: Boolean!
    title: String!
  }

  type Query {
    feed: [Post!]!
    post(id: ID!): Post
  }

  type Mutation {
    createDraft(content: String, title: String!): Post!
    publish(id: ID!): Post
  }
`

gql 태그 템플릿을 사용하여 GraphQL 스키마를 정의합니다. 스키마는 API에 대해 실행할 수 있는 쿼리의 모양을 함께 정의하는 유형 정의 모음(따라서 typeDefs)입니다. 이렇게 하면 GraphQL 스키마 문자열이 Apollo가 예상하는 형식으로 변환됩니다.

스키마에는 세 가지 유형이 있습니다.

  • Post는 블로깅 앱의 게시물 유형을 정의하고 각 필드 뒤에 유형이 오는 4개의 필드를 포함합니다(예: String).
  • Query는 대괄호로 표시된 여러 게시물을 반환하는 feed 쿼리와 단일 인수를 허용하고 반환하는 post 쿼리를 정의합니다. 단일 게시물.
  • Mutation은 초안 Post를 생성하기 위한 createDraft 변형과 publish 변형을 정의합니다. >id 및 게시물을 반환합니다.

모든 GraphQL API에는 쿼리 유형이 있으며 변형 유형이 있을 수도 있고 없을 수도 있습니다. 이러한 유형은 일반 객체 유형과 동일하지만 모든 GraphQL 쿼리의 진입점을 정의하기 때문에 특별합니다.

다음으로 posts 배열을 src/schema.js 파일의 typeDefs 변수 아래에 추가합니다.

...
const posts = [
  {
    id: 1,
    title: 'Subscribe to GraphQL Weekly for community news ',
    content: 'https://graphqlweekly.com/',
    published: true,
  },
  {
    id: 2,
    title: 'Follow DigitalOcean on Twitter',
    content: 'https://twitter.com/digitalocean',
    published: true,
  },
  {
    id: 3,
    title: 'What is GraphQL?',
    content: 'GraphQL is a query language for APIs',
    published: false,
  },
]

3개의 미리 정의된 게시물로 posts 배열을 정의합니다. 각 post 개체의 구조는 스키마에서 정의한 Post 유형과 일치합니다. 이 배열은 API에서 제공할 게시물을 보유합니다. 후속 단계에서는 데이터베이스와 Prisma 클라이언트가 도입되면 어레이를 교체합니다.

다음으로 방금 정의한 posts 배열 아래에 다음 코드를 추가하여 resolvers 개체를 정의합니다.

...
const resolvers = {
  Query: {
    feed: (parent, args) => {
      return posts.filter((post) => post.published)
    },
    post: (parent, args) => {
      return posts.find((post) => post.id === Number(args.id))
    },
  },
  Mutation: {
    createDraft: (parent, args) => {
      posts.push({
        id: posts.length + 1,
        title: args.title,
        content: args.content,
        published: false,
      })
      return posts[posts.length - 1]
    },
    publish: (parent, args) => {
      const postToPublish = posts.find((post) => post.id === Number(args.id))
      postToPublish.published = true
      return postToPublish
    },
  },
  Post: {
    content: (parent) => parent.content,
    id: (parent) => parent.id,
    published: (parent) => parent.published,
    title: (parent) => parent.title,
  },
}

module.exports = {
  resolvers,
  typeDefs,
}

GraphQL 스키마와 동일한 구조를 따르는 리졸버를 정의합니다. 스키마 유형의 모든 필드에는 스키마의 해당 필드에 대한 데이터를 반환하는 책임이 있는 해당 해석기 함수가 있습니다. 예를 들어 Query.feed() 해석기는 posts 배열을 필터링하여 게시된 게시물을 반환합니다.

리졸버 함수는 다음 네 가지 인수를 받습니다.

  • parent는 리졸버 체인에 있는 이전 리졸버의 반환 값입니다. 최상위 확인자의 경우 이전 확인자가 호출되지 않았기 때문에 부모는 정의되지 않음입니다. 예를 들어 feed 쿼리를 만들 때 query.feed() 리졸버는 parent의 값 undefined로 호출됩니다. 그리고 Post의 리졸버가 호출됩니다. 여기서 parentfeed 리졸버에서 반환된 객체입니다.
  • args는 쿼리에 대한 매개변수를 전달합니다. 예를 들어 post 쿼리는 가져올 게시물의 id를 수신합니다.
  • context는 각 리졸버가 쓰고 읽을 수 있는 리졸버 체인을 통해 전달되는 객체로, 리졸버가 정보를 공유할 수 있도록 합니다.
  • info는 쿼리 또는 변형의 AST 표현입니다. 자세한 내용은 GraphQL 기본 사항에 대한 Prisma 시리즈에서 확인할 수 있습니다.

contextinfo는 이러한 리졸버에서 필요하지 않으므로 parentargs만 정의됩니다.

완료되면 파일을 저장하고 종료합니다.

참고: 리졸버가 Post에 대한 4개의 리졸버와 같이 리졸버의 이름과 동일한 필드를 반환하면 Apollo 서버가 이를 자동으로 리졸브합니다. 즉, 이러한 리졸버를 명시적으로 정의할 필요가 없습니다.

-  Post: {
-    content: (parent) => parent.content,
-    id: (parent) => parent.id,
-    published: (parent) => parent.published,
-    title: (parent) => parent.title,
-  },

다음 단계에서 Apollo Server로 서버를 인스턴스화하는 데 사용할 수 있도록 스키마와 리졸버를 내보냅니다.

3단계 - GraphQL 서버 생성

이 단계에서는 Apollo 서버로 GraphQL 서버를 만들고 서버가 연결을 수락할 수 있도록 포트에 바인딩합니다.

먼저 다음 명령을 실행하여 서버용 파일을 만듭니다.

  1. nano src/server.js

파일에 다음 코드를 추가합니다.

const { ApolloServer } = require('apollo-server')
const { resolvers, typeDefs } = require('./schema')

const port = process.env.PORT || 8080

new ApolloServer({ resolvers, typeDefs }).listen({ port }, () =>
  console.log(`Server ready at: http://localhost:${port}`),
)

여기에서 서버를 인스턴스화하고 이전 단계의 스키마와 확인자를 전달합니다.

서버가 바인드할 포트는 PORT 환경 변수에서 설정됩니다. 설정하지 않으면 기본값은 8080입니다. PORT 환경 변수는 앱 플랫폼에 의해 자동으로 설정되며 서버가 배포되면 연결을 수락할 수 있도록 합니다.

파일을 저장하고 종료합니다.

GraphQL API를 실행할 준비가 되었습니다. 다음 명령으로 서버를 시작합니다.

  1. node src/server.js

다음 출력을 받게 됩니다.

Output
Server ready at: http://localhost:8080

서버에 대한 진입점이 명확하도록 package.json 파일에 시작 스크립트를 추가하는 것이 좋습니다. 이렇게 하면 App Platform이 배포된 후 서버를 시작할 수 있습니다.

먼저 CTRL+C를 눌러 서버를 중지합니다. 그런 다음 시작 스크립트를 추가하려면 package.json 파일을 엽니다.

  1. nano package.json

강조 표시된 텍스트를 package.json\scripts\ 개체에 추가합니다.

{
  "name": "prisma-graphql",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1",
    "start": "node ./src/server.js"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "dependencies": {
    "apollo-server": "^3.11.1",
    "graphql": "^16.6.0"
  }
}

파일을 저장하고 종료합니다.

이제 다음 명령으로 서버를 시작할 수 있습니다.

  1. npm start

다음 출력을 받게 됩니다.

Output
> prisma-graphql@1.0.0 start > node ./src/server.js Server ready at: http://localhost:8080

GraphQL API를 테스트하려면 출력에서 URL을 열면 Apollo GraphQL Studio로 연결됩니다. 홈 페이지에서 Query Your Server 버튼을 클릭하여 IDE와 상호 작용합니다.

Apollo GraphQL Studio는 쿼리 및 변형을 전송하여 API를 테스트할 수 있는 IDE입니다.

예를 들어 게시된 게시물만 반환하는 feed 쿼리를 테스트하려면 IDE 왼쪽에 다음 쿼리를 입력하고 실행 또는 재생 버튼을 눌러 쿼리를 보냅니다.

query {
  feed {
    id
    title
    content
    published
  }
}

응답에는 URL이 포함된 GraphQL Weekly 구독 제목과 URL이 포함된 Twitter에서 DigitalOcean 팔로우가 표시됩니다.

새 탭을 만들려면 이전 검색어 위에 있는 표시줄에서 + 버튼을 클릭하세요. 그런 다음 createDraft 변형을 테스트하려면 다음 변형을 입력합니다.

mutation {
  createDraft(title: "Deploying a GraphQL API to DigitalOcean") {
    id
    title
    content
    published
  }
}

재생 버튼을 사용하여 변형을 제출하면 응답의 일부로 title 필드 내에서 DigitalOcean에 GraphQL API 배포라는 응답을 받게 됩니다.

참고: createDraft 다음의 중괄호({}) 안에 필드를 추가하거나 제거하여 변형에서 반환할 필드를 선택할 수 있습니다. 예를 들어 idtitle만 반환하려는 경우 다음 변형을 보낼 수 있습니다.

mutation {
  createDraft(title: "Deploying a GraphQL API to DigitalOcean") {
    id
    title
  }
}

GraphQL 서버를 성공적으로 생성하고 테스트했습니다. 다음 단계에서는 프로젝트에 대한 GitHub 리포지토리를 생성합니다.

4단계 — GitHub 리포지토리 생성

이 단계에서는 프로젝트용 GitHub 리포지토리를 생성하고 변경 사항을 푸시하여 GraphQL API가 GitHub에서 App Platform으로 자동 배포될 수 있도록 합니다.

먼저 CTRL+C를 눌러 개발 서버를 중지합니다. 그런 다음 다음 명령을 사용하여 prisma-graphql 폴더에서 리포지토리를 초기화합니다.

  1. git init

다음으로 다음 두 명령을 사용하여 코드를 리포지토리에 커밋합니다.

  1. git add src package-lock.json package.json
  2. git commit -m 'Initial commit'

변경 사항이 로컬 리포지토리에 커밋되었으므로 이제 GitHub에 리포지토리를 생성하고 변경 사항을 푸시합니다.

GitHub로 이동하여 새 리포지토리를 만듭니다. 일관성을 위해 리포지토리 이름을 prisma-graphql로 지정한 다음 리포지토리 생성을 클릭합니다.

리포지토리가 생성된 후 다음 명령을 사용하여 변경 사항을 푸시합니다. 여기에는 기본 로컬 브랜치의 이름을 main으로 변경하는 것이 포함됩니다.

  1. git remote add origin git@github.com:your_github_username/prisma-graphql.git
  2. git branch -M main
  3. git push --set-upstream origin main

변경 사항을 성공적으로 커밋하고 GitHub에 푸시했습니다. 다음으로 리포지토리를 앱 플랫폼에 연결하고 GraphQL API를 배포합니다.

5단계 - 앱 플랫폼에 배포

이 단계에서는 방금 생성한 GitHub 리포지토리를 DigitalOcean에 연결한 다음 변경 사항을 GitHub에 푸시할 때 GraphQL API가 자동으로 배포될 수 있도록 앱 플랫폼을 구성합니다.

먼저 DigitalOcean Cloud Console에서 앱 플랫폼 페이지를 방문하여 앱 만들기 버튼을 클릭합니다.

GitHub가 기본값인 서비스 공급자 옵션이 표시됩니다.

GitHub 계정에 DigitalOcean을 구성하지 않은 경우 액세스 관리 버튼을 클릭하여 GitHub로 리디렉션합니다.

모든 리포지토리 또는 특정 리포지토리를 선택할 수 있습니다. 설치 및 승인을 클릭하면 DigitalOcean 앱 플랫폼 생성으로 다시 리디렉션됩니다.

리포지토리 your_github_username/prisma-graphql을 선택하고 다음을 클릭합니다. 자동 배포는 기본적으로 선택되며 재배포 시 일관성을 위해 선택된 상태로 둘 수 있습니다.

리소스 페이지에서 계획 편집 버튼을 클릭하여 적합한 계획을 선택합니다. 필요한 플랜 크기로 기본 플랜을 선택하십시오(이 자습서에서는 $5.00/월 - 기본 플랜을 사용함).

그런 다음 뒤로를 눌러 생성 페이지로 돌아갑니다.

프로젝트 이름 옆에 있는 펜 아이콘을 누르면 앱 구성을 사용자 정의할 수 있습니다. 애플리케이션 설정 페이지가 열립니다.

Run Command가 npm start로 설정되어 있는지 확인합니다. 기본적으로 앱 플랫폼은 HTTP 포트를 8080으로 설정합니다. 이는 GraphQL 서버가 바인딩하도록 구성한 것과 동일한 포트입니다.

구성 사용자 지정을 마치면 뒤로 버튼을 눌러 설정 페이지로 돌아갑니다. 그런 다음 다음 버튼을 눌러 환경 변수 페이지로 이동합니다.

현재 환경 변수는 추가 구성이 필요하지 않습니다. 다음 버튼을 클릭합니다.

정보 페이지에서 앱 세부 정보 및 위치를 조정할 수 있습니다. 앱 정보를 편집하여 앱을 배포할 지역을 선택하십시오. 저장 버튼을 눌러 앱 세부 정보를 확인합니다. 그런 다음 다음 버튼을 클릭합니다.

검토 페이지에서 선택한 모든 옵션을 검토할 수 있습니다. 그런 다음 리소스 만들기를 클릭합니다. 초기 배포 진행 상황을 볼 수 있는 앱 페이지로 리디렉션됩니다.

빌드가 완료되면 앱이 배포되었음을 나타내는 알림을 받게 됩니다.

이제 DigitalOcean 콘솔에서 앱 이름 아래의 URL에서 배포된 GraphQL API를 방문할 수 있습니다. ondigitalocean.app 하위 도메인을 통해 연결됩니다. URL을 열면 이 튜토리얼의 3단계에서와 같은 방식으로 GraphQL Playground가 열립니다.

리포지토리를 앱 플랫폼에 성공적으로 연결하고 GraphQL API를 배포했습니다. 다음으로 앱을 발전시키고 GraphQL API의 메모리 내 데이터를 데이터베이스로 교체합니다.

6단계 - PostgreSQL로 Prisma 설정

지금까지 메모리 내 posts 배열을 사용하여 데이터를 저장하는 GraphQL API를 구축했습니다. 서버가 다시 시작되면 데이터에 대한 모든 변경 사항이 손실됩니다. 데이터를 안전하게 유지하려면 posts 배열을 PostgreSQL 데이터베이스로 바꾸고 Prisma를 사용하여 데이터에 액세스합니다.

이 단계에서는 Prisma CLI를 설치하고, 초기 Prisma 스키마(데이터베이스 스키마를 포함하는 Prisma 설정을 위한 기본 구성 파일)를 생성하고, Docker를 사용하여 로컬에서 PostgreSQL을 설정하고, Prisma를 여기에 연결합니다.

다음 명령으로 Prisma CLI를 설치하여 시작하십시오.

  1. npm install --save-dev prisma

Prisma CLI는 데이터베이스 마이그레이션 실행 및 Prisma 클라이언트 생성과 같은 데이터베이스 워크플로에 도움이 됩니다.

다음으로 Docker를 사용하여 PostgreSQL 데이터베이스를 설정합니다. 다음 명령을 사용하여 새 Docker Compose 파일을 만듭니다.

  1. nano docker-compose.yml

새로 생성된 파일에 다음 코드를 추가합니다.

version: '3.8'
services:
  postgres:
    image: postgres:14
    restart: always
    environment:
      - POSTGRES_USER=test-user
      - POSTGRES_PASSWORD=test-password
    volumes:
      - postgres:/var/lib/postgresql/data
    ports:
      - '5432:5432'
volumes:
  postgres:

이 Docker Compose 구성 파일은 시스템에서 공식 PostgreSQL Docker 이미지를 시작하는 역할을 합니다. POSTGRES_USERPOSTGRES_PASSWORD 환경 변수는 수퍼유저(관리자 권한이 있는 사용자)의 자격 증명을 설정합니다. 또한 이러한 자격 증명을 사용하여 Prisma를 데이터베이스에 연결합니다. test-usertest-password를 사용자 자격 증명으로 바꿉니다.

마지막으로 PostgreSQL이 데이터를 저장할 볼륨을 정의하고 컴퓨터의 5432 포트를 Docker 컨테이너의 동일한 포트에 바인딩합니다.

파일을 저장하고 종료합니다.

이 설정이 완료되면 다음 명령을 사용하여 PostgreSQL 데이터베이스 서버를 시작할 수 있습니다.

  1. docker-compose up -d

로드하는 데 몇 분 정도 걸릴 수 있습니다.

다음 명령을 사용하여 데이터베이스 서버가 실행 중인지 확인할 수 있습니다.

  1. docker ps

이 명령은 다음과 유사한 내용을 출력합니다.

Output
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES 198f9431bf73 postgres:10.3 "docker-entrypoint.s…" 45 seconds ago Up 11 seconds 0.0.0.0:5432->5432/tcp prisma-graphql_postgres_1

PostgreSQL 컨테이너를 실행하면 이제 Prisma 설정을 만들 수 있습니다. Prisma CLI에서 다음 명령을 실행합니다.

  1. npx prisma init

모범 사례로서 Prisma CLI의 모든 호출은 로컬 설치를 사용하도록 하기 위해 npx 접두사를 붙여야 합니다.

다음과 같은 출력이 인쇄됩니다.

Output
✔ Your Prisma schema was created at prisma/schema.prisma You can now open it in your favorite editor. Next steps: 1. Set the DATABASE_URL in the .env file to point to your existing database. If your database has no tables yet, read https://pris.ly/d/getting-started 2. Set the provider of the datasource block in schema.prisma to match your database: postgresql, mysql, sqlite, sqlserver, mongodb or cockroachdb. 3. Run prisma db pull to turn your database schema into a Prisma schema. 4. Run prisma generate to generate the Prisma Client. You can then start querying your database. More information in our documentation: https://pris.ly/d/getting-started

명령을 실행한 후 Prisma CLI는 프로젝트 폴더에 .env라는 dotenv 파일을 생성하여 데이터베이스 연결 URL을 정의하고 prisma라는 새로운 중첩 폴더를 생성합니다. schema.prisma 파일을 포함합니다. 이것은 Prisma 프로젝트의 기본 구성 파일입니다(데이터 모델을 포함할 것임).

Prisma가 데이터베이스 위치를 알고 있는지 확인하려면 .env 파일을 엽니다.

  1. nano .env

사용자 자격 증명으로 DATABASE_URL 환경 변수를 조정합니다.

DATABASE_URL="postgresql://test-user:test-password@localhost:5432/my-blog?schema=public"

Docker Compose 파일에 지정된 데이터베이스 자격 증명 test-usertest-password를 사용합니다. Docker Compose 파일에서 자격 증명을 수정한 경우 해당 파일의 자격 증명과 일치하도록 이 줄을 업데이트해야 합니다. 연결 URL의 형식에 대해 자세히 알아보려면 Prisma 문서를 방문하십시오.

PostgreSQL을 성공적으로 시작하고 Prisma 스키마를 사용하여 Prisma를 구성했습니다. 다음 단계에서는 블로그용 데이터 모델을 정의하고 Prisma Migrate를 사용하여 데이터베이스 스키마를 생성합니다.

7단계 - Prisma Migrate로 데이터 모델 정의

이제 방금 생성한 Prisma 스키마 파일에서 데이터 모델을 정의합니다. 그런 다음 이 데이터 모델은 Prisma Migrate를 사용하여 데이터베이스에 매핑되어 데이터 모델에 해당하는 테이블을 생성하기 위한 SQL 문을 생성하고 보냅니다.

블로그를 구축하고 있으므로 애플리케이션의 주요 항목은 사용자게시물입니다. 이 단계에서는 GraphQL 스키마의 Post 유형과 유사한 구조로 Post 모델을 정의합니다. 이후 단계에서 앱을 발전시키고 사용자 모델을 추가합니다.

참고: GraphQL API는 데이터베이스의 추상화 계층으로 볼 수 있습니다. GraphQL API를 구축할 때 GraphQL 스키마가 데이터베이스 스키마와 매우 유사한 것이 일반적입니다. 그러나 추상화로 두 스키마가 반드시 동일한 구조를 가질 필요는 없으므로 일부 데이터가 API 계층에 대해 민감하거나 관련이 없는 것으로 간주될 수 있으므로 API를 통해 노출할 데이터를 제어할 수 있습니다.

Prisma는 자체 데이터 모델링 언어를 사용하여 애플리케이션 데이터의 형태를 정의합니다.

package.json이 있는 프로젝트 폴더에서 schema.prisma 파일을 엽니다.

  1. nano prisma/schema.prisma

참고: 현재 작업 디렉터리를 출력하는 pwd 명령을 사용하여 터미널에서 어떤 폴더에 있는지 확인할 수 있습니다. 또한 ls 명령으로 파일을 나열하면 파일 시스템을 탐색하는 데 도움이 됩니다.

다음 모델 정의를 추가합니다.

...
model Post {
  id        Int     @default(autoincrement()) @id
  title     String
  content   String?
  published Boolean @default(false)
}

필드를 정의합니다. 모델은 데이터베이스 테이블에 매핑됩니다. 필드는 개별 을 나타냅니다.

id 필드에는 다음 필드 속성이 있습니다.

  • @default(autoincrement())는 열의 자동 증가 기본값을 설정합니다.
  • @id는 열을 테이블의 기본 키로 설정합니다.

파일을 저장하고 종료합니다.

모델이 준비되면 이제 migrate dev 명령과 함께 Prisma Migrate를 사용하여 데이터베이스에 해당 테이블을 생성하여 마이그레이션 파일을 생성하고 실행할 수 있습니다.

터미널에서 다음 명령을 실행합니다.

  1. npx prisma migrate dev --name init --skip-generate

이 명령은 파일 시스템에 새로운 마이그레이션을 생성하고 데이터베이스 스키마를 생성하기 위해 데이터베이스에 대해 실행합니다. --name init 플래그는 마이그레이션의 이름을 지정합니다(파일 시스템에 생성된 마이그레이션 폴더의 이름을 지정하는 데 사용됨). --skip-generate 플래그는 Prisma 클라이언트 생성을 건너뜁니다(다음 단계에서 수행됨).

이 명령은 다음과 유사한 내용을 출력합니다.

Output
Environment variables loaded from .env Prisma schema loaded from prisma/schema.prisma Datasource "db": PostgreSQL database "my-blog", schema "public" at "localhost:5432" PostgreSQL database my-blog created at localhost:5432 Applying migration `20201201110111_init` The following migration(s) have been created and applied from new schema changes: migrations/ └─ 20201201110111_init/ └─ migration.sql Your database is now in sync with your schema.

이제 prisma/migrations 디렉터리가 SQL 마이그레이션 파일로 채워집니다. 이 접근 방식을 사용하면 데이터베이스 스키마의 변경 사항을 추적하고 프로덕션 환경에서 동일한 데이터베이스 스키마를 생성할 수 있습니다.

참고: my-blog 데이터베이스와 함께 Prisma Migrate를 이미 사용했고 prisma/migration 폴더의 마이그레이션과 데이터베이스 스키마 간에 불일치가 있는 경우 다음 출력과 함께 데이터베이스를 재설정하라는 메시지가 표시됩니다.

Output
? We need to reset the PostgreSQL database "my-blog" at "localhost:5432". All data will be lost. Do you want to continue? › (y/N)

데이터베이스를 재설정하는 y를 입력하여 이 문제를 해결할 수 있습니다. 이로 인해 데이터베이스의 모든 데이터가 손실될 수 있으므로 주의하십시오.

이제 데이터베이스 스키마를 만들었습니다. 다음 단계에서는 Prisma 클라이언트를 설치하고 GraphQL 리졸버에서 사용합니다.

8단계 - GraphQL 리졸버에서 Prisma 클라이언트 사용

Prisma 클라이언트는 Node.js 애플리케이션에서 프로그래밍 방식으로 데이터베이스의 데이터를 읽고 쓰는 데 사용할 수 있는 자동 생성 및 유형 안전 객체 관계형 매퍼(ORM)입니다. 이 단계에서는 프로젝트에 Prisma 클라이언트를 설치합니다.

터미널에서 Prisma Client npm 패키지를 설치합니다.

  1. npm install @prisma/client

참고: Prisma 클라이언트는 node_modules 폴더에 Prisma 스키마를 기반으로 코드를 생성하여 풍부한 자동 완성 기능을 제공합니다. 코드를 생성하려면 npx prisma generate 명령을 사용합니다. 이는 일반적으로 새 마이그레이션을 생성하고 실행한 후에 수행됩니다. 그러나 첫 번째 설치에서는 postinstall 후크에서 자동으로 생성되므로 이 작업이 필요하지 않습니다.

데이터베이스 및 GraphQL 스키마를 생성하고 Prisma 클라이언트를 설치한 후 이제 GraphQL 리졸버에서 Prisma 클라이언트를 사용하여 데이터베이스의 데이터를 읽고 씁니다. 지금까지 데이터를 저장하는 데 사용한 posts 배열을 교체하여 이 작업을 수행합니다.

다음 파일을 만들고 엽니다.

  1. nano src/db.js

새 파일에 다음 줄을 추가합니다.

const { PrismaClient } = require('@prisma/client')

module.exports = {
  prisma: new PrismaClient(),
}

이 코드는 Prisma Client를 가져와 인스턴스를 생성하고 확인자에서 사용할 인스턴스를 내보냅니다.

이제 src/db.js 파일을 저장하고 닫습니다.

다음으로 prisma 인스턴스를 src/schema.js로 가져옵니다. 이렇게 하려면 src/schema.js를 엽니다.

  1. nano src/schema.js

파일 맨 위에 있는 ./db에서 prisma를 가져오려면 다음 행을 추가하십시오.

const { prisma } = require('./db')
...

그런 다음 하이픈 기호(-)로 표시된 줄을 삭제하여 posts 배열을 제거합니다.

...
-const posts = [
-  {
-    id: 1,
-    title: 'Subscribe to GraphQL Weekly for community news ',
-    content: 'https://graphqlweekly.com/',
-    published: true,
-  },
-  {
-    id: 2,
-    title: 'Follow DigitalOcean on Twitter',
-    content: 'https://twitter.com/digitalocean',
-    published: true,
-  },
-  {
-    id: 3,
-    title: 'What is GraphQL?',
-    content: 'GraphQL is a query language for APIs',
-    published: false,
-  },
-]
...

다음으로 데이터베이스에서 게시된 게시물을 가져오도록 Query 확인자를 업데이트합니다. 먼저 resolvers.Query에서 기존 줄을 삭제한 다음 강조 표시된 줄을 추가하여 개체를 업데이트합니다.

...
const resolvers = {
  Query: {
    feed: (parent, args) => {
      return prisma.post.findMany({
        where: { published: true },
      })
    },
    post: (parent, args) => {
      return prisma.post.findUnique({
        where: { id: Number(args.id) },
      })
    },
  },
...

여기에서는 두 개의 Prisma 클라이언트 쿼리를 사용합니다.

  • findManypublish 필드가 false인 게시물을 가져옵니다.
  • findUniqueid 필드가 id GraphQL 인수와 동일한 단일 게시물을 가져옵니다.

GraphQL 사양에 따라 ID 유형은 String과 동일한 방식으로 직렬화됩니다. 따라서 Prisma 스키마의 idint이기 때문에 Number로 변환합니다.

다음으로 Mutation 리졸버를 업데이트하여 데이터베이스의 게시물을 저장하고 업데이트합니다. 먼저 resolvers.Mutation 개체와 Number(args.id) 줄에서 코드를 삭제한 다음 강조 표시된 줄을 추가합니다.

const resolvers = {
  ...
  Mutation: {
    createDraft: (parent, args) => {
      return prisma.post.create({
        data: {
          title: args.title,
          content: args.content,
        },
      })
    },
    publish: (parent, args) => {
      return prisma.post.update({
        where: {
          id: Number(args.id),
        },
        data: {
          published: true,
        },
      })
    },
  },
}

두 개의 Prisma 클라이언트 쿼리를 사용하고 있습니다.

  • createPost 레코드를 생성합니다.
  • 업데이트id가 쿼리 인수의 항목과 일치하는 Post 레코드의 게시된 필드를 업데이트합니다.

마지막으로 resolvers.Post 개체를 제거합니다.

...
-Post: {
-  content: (parent) => parent.content,
-  id: (parent) => parent.id,
-  published: (parent) => parent.published,
-  title: (parent) => parent.title,
-},
...

이제 schema.js는 다음과 같이 읽어야 합니다.

const { gql } = require('apollo-server')
const { prisma } = require('./db')

const typeDefs = gql`
  type Post {
    content: String
    id: ID!
    published: Boolean!
    title: String!
  }

  type Query {
    feed: [Post!]!
    post(id: ID!): Post
  }

  type Mutation {
    createDraft(content: String, title: String!): Post!
    publish(id: ID!): Post
  }
`

const resolvers = {
  Query: {
    feed: (parent, args) => {
      return prisma.post.findMany({
        where: { published: true },
      })
    },
    post: (parent, args) => {
      return prisma.post.findUnique({
        where: { id: Number(args.id) },
      })
    },
  },
  Mutation: {
    createDraft: (parent, args) => {
      return prisma.post.create({
        data: {
          title: args.title,
          content: args.content,
        },
      })
    },
    publish: (parent, args) => {
      return prisma.post.update({
        where: {
          id: Number(args.id),
        },
        data: {
          published: true,
        },
      })
    },
  },
}

module.exports = {
  resolvers,
  typeDefs,
}

파일을 저장하고 닫습니다.

이제 Prisma 클라이언트를 사용하도록 리졸버를 업데이트했으므로 서버를 시작하여 다음 명령을 사용하여 GraphQL API와 데이터베이스 간의 데이터 흐름을 테스트합니다.

  1. npm start

다시 한 번 다음 출력을 받게 됩니다.

Output
Server ready at: http://localhost:8080

출력의 주소에서 Apollo GraphQL Studio를 열고 3단계의 동일한 쿼리를 사용하여 GraphQL API를 테스트합니다.

이제 변경 사항을 App Platform에 배포할 수 있도록 변경 사항을 커밋합니다. CTRL+C를 사용하여 Apollo 서버를 중지합니다.

node_modules 폴더와 .env 파일을 커밋하지 않으려면 프로젝트 폴더에서 .gitignore 파일을 확인하세요.

  1. cat .gitignore

.gitignore 파일에 다음 줄이 포함되어 있는지 확인하십시오.

node_modules
.env

그렇지 않은 경우 일치하도록 파일을 업데이트합니다.

파일을 저장하고 종료합니다.

그런 다음 다음 두 명령을 실행하여 변경 사항을 커밋합니다.

  1. git add .
  2. git commit -m 'Add Prisma'

다음과 같은 출력 응답을 받게 됩니다.

Output
git commit -m 'Add Prisma' [main 1646d07] Add Prisma 9 files changed, 157 insertions(+), 39 deletions(-) create mode 100644 .gitignore create mode 100644 docker-compose.yml create mode 100644 prisma/migrations/20201201110111_init/migration.sql create mode 100644 prisma/migrations/migration_lock.toml create mode 100644 prisma/schema.prisma create mode 100644 src/db.js

Prisma 클라이언트를 사용하여 데이터베이스에 대한 쿼리 및 변형을 수행하도록 GraphQL 리졸버를 업데이트한 다음 모든 변경 사항을 원격 리포지토리에 커밋했습니다. 다음으로 앱 플랫폼에서 앱에 PostgreSQL 데이터베이스를 추가합니다.

9단계 - 앱 플랫폼에서 PostgreSQL 데이터베이스 생성 및 마이그레이션

이 단계에서는 앱 플랫폼에서 앱에 PostgreSQL 데이터베이스를 추가합니다. 그런 다음 배포된 데이터베이스 스키마가 로컬 데이터베이스와 일치하도록 Prisma Migrate를 사용하여 마이그레이션을 실행합니다.

먼저 앱 플랫폼 콘솔을 방문하여 5단계에서 만든 prisma-graphql 프로젝트를 선택합니다.

그런 다음 생성 버튼을 클릭하고 드롭다운 메뉴에서 데이터베이스 생성/연결을 선택하면 데이터베이스를 구성하는 페이지로 이동합니다.

Dev Database를 선택하고 이름을 선택한 다음 Create and Attach를 클릭합니다.

데이터베이스 생성을 위한 진행률 표시줄이 있는 프로젝트 보기로 다시 리디렉션됩니다.

데이터베이스가 생성된 후 로컬 시스템에서 DigitalOcean의 프로덕션 데이터베이스에 대해 데이터베이스 마이그레이션을 실행합니다. 마이그레이션을 실행하려면 호스팅된 데이터베이스의 연결 문자열이 필요합니다.

가져오려면 설정 탭의 구성요소 섹션에서 db 아이콘을 클릭하세요.

연결 세부 정보에서 보기를 누른 다음 드롭다운 메뉴에서 연결 문자열을 선택합니다. 다음 구조를 갖는 데이터베이스 URL을 복사합니다.

postgresql://db:some_password@unique_identifier.db.ondigitalocean.com:25060/db?sslmode=require

그런 다음 터미널에서 다음 명령을 실행하여 your_db_connection_string을 방금 복사한 URL로 설정했는지 확인합니다.

  1. DATABASE_URL="your_db_connection_string" npx prisma migrate deploy

이 명령은 Prisma Migrate를 사용하여 라이브 데이터베이스에 대한 마이그레이션을 실행합니다.

마이그레이션이 성공하면 다음과 같은 결과가 표시됩니다.

Output
PostgreSQL database db created at unique_identifier.db.ondigitalocean.com:25060 Prisma Migrate applied the following migration(s): migrations/ └─ 20201201110111_init/ └─ migration.sql

현재 Prisma 스키마와 일치하는 DigitalOcean에서 프로덕션 데이터베이스를 성공적으로 마이그레이션했습니다.

참고: 다음 오류 메시지가 표시되는 경우:

Output
Error: P1001: Can't reach database server at `unique_identifier.db.ondigitalocean.com`:`25060`

데이터베이스 대시보드로 이동하여 데이터베이스가 프로비저닝되었는지 확인하십시오. 데이터베이스의 신뢰할 수 있는 소스를 업데이트하거나 비활성화해야 할 수 있습니다.

이제 다음 명령으로 Git 변경 사항을 푸시하여 앱을 배포할 수 있습니다.

  1. git push

참고: 앱 플랫폼은 런타임 시 애플리케이션에서 DATABASE_URL 환경 변수를 사용할 수 있도록 합니다. Prisma 클라이언트는 Prisma 스키마의 datasource 블록에 있는 env(\DATABASE_URL\)와 함께 해당 환경 변수를 사용합니다.

그러면 빌드가 자동으로 트리거됩니다. 앱 플랫폼 콘솔을 열면 배포 진행률 표시줄이 나타납니다.

배포가 성공하면 배포 진행 라이브 메시지를 받게 됩니다.

이제 배포된 GraphQL API를 데이터베이스와 함께 백업했습니다. 라이브 앱을 열면 Apollo GraphQL Studio로 연결됩니다. 3단계와 동일한 쿼리를 사용하여 GraphQL API를 테스트합니다.

마지막 단계에서는 User 모델을 추가하여 GraphQL API를 발전시킵니다.

10단계 - 사용자 모델 추가

블로그용 GraphQL API에는 Post라는 단일 엔터티가 있습니다. 이 단계에서는 Prisma 스키마에서 새 모델을 정의하고 새 모델을 사용하도록 GraphQL 스키마를 조정하여 API를 발전시킵니다. 게시물 모델과 일대다 관계가 있는 사용자 모델을 도입하여 게시물 작성자를 나타내고 각 사용자에게 여러 게시물을 연결할 수 있습니다. . 그런 다음 API를 통해 사용자 생성 및 사용자와의 게시물 연결을 허용하도록 GraphQL 스키마를 발전시킵니다.

먼저 Prisma 스키마를 엽니다.

  1. nano prisma/schema.prisma

강조 표시된 줄을 추가하여 authorId 필드를 Post 모델에 추가하고 User 모델을 정의합니다.

...
model Post {
  id        Int     @id @default(autoincrement())
  title     String
  content   String?
  published Boolean @default(false)
  author    User?   @relation(fields: [authorId], references: [id])
  authorId  Int?
}

model User {
  id    Int    @id @default(autoincrement())
  email String @unique
  name  String
  posts Post[]
}

Prisma 스키마에 다음 항목을 추가했습니다.

  • 두 개의 관계 필드: authorposts. 관계 필드는 Prisma 수준에서 모델 간의 연결을 정의하며 데이터베이스에 존재하지 않습니다. 이러한 필드는 Prisma 클라이언트를 생성하고 Prisma 클라이언트와의 관계에 액세스하는 데 사용됩니다.
  • authorId 필드는 @relation 속성에서 참조합니다. Prisma는 PostUser를 연결하기 위해 데이터베이스에 외래 키를 생성합니다.
  • 사용자를 나타내는 User 모델입니다.

Post 모델의 author 필드는 선택 사항이지만 사용자와 연결되지 않은 게시물을 만들 수 있습니다.

완료되면 파일을 저장하고 종료합니다.

그런 다음 다음 명령을 사용하여 로컬에서 마이그레이션을 만들고 적용합니다.

  1. npx prisma migrate dev --name "add-user"

마이그레이션이 성공하면 다음 메시지가 표시됩니다.

Output
Environment variables loaded from .env Prisma schema loaded from prisma/schema.prisma Datasource "db": PostgreSQL database "my-blog", schema "public" at "localhost:5432" Applying migration `20201201123056_add_user` The following migration(s) have been created and applied from new schema changes: migrations/ └─ 20201201123056_add_user/ └─ migration.sql Your database is now in sync with your schema. ✔ Generated Prisma Client (4.6.1 | library) to ./node_modules/@prisma/client in 53ms

이 명령은 또한 새로운 테이블과 필드를 사용할 수 있도록 Prisma Client를 생성합니다.

이제 데이터베이스 스키마가 로컬 데이터베이스와 동일하도록 App Platform의 프로덕션 데이터베이스에 대해 마이그레이션을 실행합니다. 터미널에서 다음 명령을 실행하고 DATABASE_URL을 App Platform의 연결 URL로 설정합니다.

  1. DATABASE_URL="your_db_connection_string" npx prisma migrate deploy

다음 출력을 받게 됩니다.

Output
Environment variables loaded from .env Prisma schema loaded from prisma/schema.prisma Datasource "db": PostgreSQL database "db", schema "public" at "unique_identifier.db.ondigitalocean.com:25060" 2 migrations found in prisma/migrations Applying migration `20201201123056_add_user` The following migration have been applied: migrations/ └─ 20201201123056_add_user/ └─ migration.sql All migrations have been successfully applied.

이제 업데이트된 데이터베이스 스키마를 사용하도록 GraphQL 스키마와 리졸버를 업데이트합니다.

src/schema.js 파일을 엽니다.

  1. nano src/schema.js

다음과 같이 강조 표시된 줄로 typeDefs를 업데이트합니다.

...
const typeDefs = gql`
  type User {
    email: String!
    id: ID!
    name: String
    posts: [Post!]!
  }

  type Post {
    content: String
    id: ID!
    published: Boolean!
    title: String!
    author: User
  }

  type Query {
    feed: [Post!]!
    post(id: ID!): Post
  }

  type Mutation {
    createUser(data: UserCreateInput!): User!
    createDraft(authorEmail: String, content: String, title: String!): Post!
    publish(id: ID!): Post
  }

  input UserCreateInput {
    email: String!
    name: String
    posts: [PostCreateWithoutAuthorInput!]
  }

  input PostCreateWithoutAuthorInput {
    content: String
    published: Boolean
    title: String!
  }
`
...

이 업데이트된 코드에서 GraphQL 스키마에 다음 변경 사항을 추가합니다.

  • Post의 배열을 반환하는 User 유형입니다.
  • author 필드를 Post 유형으로 지정합니다.
  • 입력 유형으로 UserCreateInput을 예상하는 createUser 변형
  • createUser 변형의 일부로 게시물을 생성하기 위해 UserCreateInput 입력에 사용되는 PostCreateWithoutAuthorInput 입력 유형입니다.
  • createDraft 변형에 대한 authorEmail 선택적 인수

스키마가 업데이트되면 이제 스키마와 일치하도록 리졸버를 업데이트합니다.

다음과 같이 강조 표시된 줄로 resolvers 개체를 업데이트합니다.

...
const resolvers = {
  Query: {
    feed: (parent, args) => {
      return prisma.post.findMany({
        where: { published: true },
      })
    },
    post: (parent, args) => {
      return prisma.post.findUnique({
        where: { id: Number(args.id) },
      })
    },
  },
  Mutation: {
    createDraft: (parent, args) => {
      return prisma.post.create({
        data: {
          title: args.title,
          content: args.content,
          published: false,
          author: args.authorEmail && {
            connect: { email: args.authorEmail },
          },
        },
      })
    },
    publish: (parent, args) => {
      return prisma.post.update({
        where: { id: Number(args.id) },
        data: {
          published: true,
        },
      })
    },
    createUser: (parent, args) => {
      return prisma.user.create({
        data: {
          email: args.data.email,
          name: args.data.name,
          posts: {
            create: args.data.posts,
          },
        },
      })
    },
  },
  User: {
    posts: (parent, args) => {
      return prisma.user
        .findUnique({
          where: { id: parent.id },
        })
        .posts()
    },
  },
  Post: {
    author: (parent, args) => {
      return prisma.post
        .findUnique({
          where: { id: parent.id },
        })
        .author()
    },
  },
}
...

createDraft 변형 확인자는 이제 authorEmail 인수(전달된 경우)를 사용하여 생성된 초안과 기존 사용자 간의 관계를 생성합니다.

새로운 createUser 변형 확인자는 중첩된 쓰기를 사용하여 사용자 및 관련 게시물을 생성합니다.

User.postsPost.author 해석기는 postsauthor 필드를 해석하는 방법을 정의합니다. >사용자 또는 게시물이 쿼리됩니다. 이들은 Prisma의 Fluent API를 사용하여 관계를 가져옵니다.

파일을 저장하고 종료합니다.

서버를 시작하여 GraphQL API를 테스트합니다.

  1. npm start

다음 GraphQL 변형을 사용하여 createUser 리졸버를 테스트하여 시작합니다.

mutation {
  createUser(data: { email: "natalia@prisma.io", name: "Natalia" }) {
    email
    id
  }
}

이 변형은 사용자를 생성합니다.

다음으로 다음 변형을 사용하여 createDraft 리졸버를 테스트합니다.

mutation {
  createDraft(
    authorEmail: "natalia@prisma.io"
    title: "Deploying a GraphQL API to App Platform"
  ) {
    id
    title
    content
    published
    author {
      id
      name
    }
  }
}

쿼리의 반환 값이 Post일 때마다 author를 가져올 수 있습니다. 이 예에서는 Post.author 리졸버가 호출됩니다.

테스트가 끝나면 서버를 닫습니다.

그런 다음 변경 사항을 커밋하고 푸시하여 API를 배포합니다.

  1. git add .
  2. git commit -m "add user model"
  3. git push

업데이트를 배포하는 데 몇 분 정도 걸릴 수 있습니다.

Prisma Migrate로 데이터베이스 스키마를 성공적으로 발전시켰고 GraphQL API에 새 모델을 노출했습니다.

결론

이 기사에서는 Prisma로 GraphQL API를 구축하고 이를 DigitalOcean의 앱 플랫폼에 배포했습니다. Apollo 서버를 사용하여 GraphQL 스키마와 리졸버를 정의했습니다. 그런 다음 GraphQL 확인자에서 Prisma 클라이언트를 사용하여 PostgreSQL 데이터베이스에서 데이터를 유지하고 쿼리했습니다. 다음 단계로 개별 사용자를 가져오는 쿼리와 기존 초안을 사용자에게 연결하는 변형으로 GraphQL API를 확장할 수 있습니다.

데이터베이스의 데이터 탐색에 관심이 있다면 prisma-examples 저장소를 확인하세요.

DigitalOcean Community 저장소에서 이 프로젝트의 코드를 찾을 수 있습니다.