dataloader - GitLite

KO | EN

gitlite — search

#python #llm #golang #go #linux #macos #nodejs #cli #kubernetes #vue #security #mcp #ios #openai

dataloader

(★ 13,382)

DataLoader는 애플리케이션의 데이터 가져오기(fetching) 레이어의 일부로 사용되는 범용 유틸리티로, 다양한 백엔드에 걸쳐 일관된 API를 제공하고 배치 처리(batching)와 캐싱(caching)을 통해 해당 백엔드로 향하는 요청 수를 줄여줍니다.

파일 탐색기

최종 버전 다운로드 (.zip)

- config.json
- README.md
- - bug-report.md
  - feature-request.md
  - question.md
- - validation.yml
- CouchDB.md
- GoogleDatastore.md
- Knex.md
- Redis.md
- RethinkDB.md
- SQL.md
- - jest_v24.x.x.js
- prepublish.sh
- watch.js
- - abuse.test.js
  - browser.test.js
  - dataloader.test.js
  - oldbrowser.test.js
  - unhandled.test.js
- index.d.ts
- index.js
.eslintignore
.eslintrc
.flowconfig
.gitignore
babel.config.js
CHANGELOG.md
CONTRIBUTING.md
LICENSE
package.json
README.md
renovate.json
yarn.lock

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# DataLoader
DataLoader는 애플리케이션의 데이터 페치 레이어의 일부로 사용되는 범용 유틸리티로, 배치 처리(batching)와 캐싱(caching)을 통해 데이터베이스나 웹 서비스 같은 다양한 원격 데이터 소스에 대해 단순하고 일관된 API를 제공합니다.
[![Build Status](https://github.com/graphql/dataloader/actions/workflows/validation.yml/badge.svg)](https://github.com/graphql/dataloader/actions/workflows/validation.yml)
[![Coverage Status](https://coveralls.io/repos/graphql/dataloader/badge.svg?branch=master&service=github)](https://coveralls.io/github/graphql/dataloader?branch=main)
이 도구는 2010년 Facebook의 [@schrockn][]이 당시 존재하던 다양한 키-값 저장소 백엔드 API들을 통합하기 위한 단순화 도구로 처음 개발한 "Loader" API를 이식한 것입니다. Facebook에서 "Loader"는 웹 서버 제품 코드 내의 프라이버시 인식 데이터 엔티티 로딩 및 캐싱 레이어인 "Ent" 프레임워크의 구현 세부 사항 중 하나가 되었습니다. 이는 궁극적으로 Facebook의 GraphQL 서버 구현 및 타입 정의의 근간이 되었습니다.
DataLoader는 Node.js 서비스를 위해 JavaScript로 구현된 이 원래 아이디어의 단순화된 버전입니다. DataLoader는 [graphql-js][] 서비스를 구현할 때 자주 사용되지만, 다른 상황에서도 유용하게 쓰입니다.
데이터 요청을 배치 처리하고 캐싱하는 이 메커니즘은 Node.js나 JavaScript만의 고유한 특징은 아니며, Facebook의 Haskell용 데이터 로딩 라이브러리인 [Haxl](https://github.com/facebook/Haxl)의 주된 동기이기도 합니다. Haxl의 작동 방식에 대한 자세한 내용은 이 [블로그 게시물](https://code.facebook.com/posts/302060973291128/open-sourcing-haxl-a-library-for-haskell/)에서 확인할 수 있습니다.
DataLoader는 Node.js용 GraphQL 서비스를 구축하는 데 유용할 뿐만 아니라, 다른 언어로 이 개념이 포팅될 수 있기를 바라며 이 개념에 대한 공개된 참조 구현으로서 제공됩니다. 만약 DataLoader를 다른 언어로 포팅하는 경우, 이 저장소의 링크를 포함할 수 있도록 이슈를 열어 주시기 바랍니다.

## Getting Started
먼저 npm을 사용하여 DataLoader를 설치합니다.
```sh
npm install --save dataloader
```
시작하려면 `DataLoader`를 생성합니다. 각 `DataLoader` 인스턴스는 고유한 캐시를 나타냅니다. 서로 다른 사용자가 서로 다른 정보를 볼 수 있는 [express][] 같은 웹 서버 내에서 사용할 경우, 일반적으로 요청마다 인스턴스가 생성됩니다.
> Note: DataLoader는 지원되는 모든 Node.js 버전에서 사용할 수 있는 전역 ES6 `Promise` 및 `Map` 클래스가 있는 JavaScript 환경을 가정합니다.

## Batching
배치 처리는 고급 기능이 아니라 DataLoader의 핵심 기능입니다.
배치 로딩 함수를 제공하여 로더를 생성합니다.
```js
const DataLoader = require('dataloader');
const userLoader = new DataLoader(keys => myBatchGetUsers(keys));
```
배치 로딩 함수는 키 배열(Array)을 인자로 받아 값 배열[\\*](#batch-function)으로 이행(resolve)되는 Promise를 반환합니다.
그런 다음 로더에서 개별 값을 로드합니다. DataLoader는 단일 실행 프레임(이벤트 루프의 단일 틱) 내에서 발생하는 모든 개별 로드 요청을 취합한 후, 요청된 모든 키와 함께 배치 함수를 호출합니다.
```js
const user = await userLoader.load(1);
const invitedBy = await userLoader.load(user.invitedByID);
console.log(`User 1 was invited by ${invitedBy}`);
// Elsewhere in your application
const user = await userLoader.load(2);
const lastInvited = await userLoader.load(user.lastInvitedID);
console.log(`User 2 last invited ${lastInvited}`);
```
개선되지 않은 애플리케이션이라면 필요한 정보를 가져오기 위해 백엔드와 네 번의 왕복 통신(round-trip)을 수행했을 테지만, DataLoader를 사용하면 이 애플리케이션은 최대 두 번만 수행하게 됩니다.
DataLoader를 사용하면 데이터 로딩 성능을 희생하지 않으면서 애플리케이션의 관련 없는 부분들을 서로 분리할 수 있습니다. 로더는 개별 값을 로드하는 API를 제공하지만, 동시에 발생하는 모든 요청은 취합되어 배치 로딩 함수로 전달됩니다. 이를 통해 애플리케이션 전체에 걸쳐 데이터 페치 요구 사항을 안전하게 분산시키고 최소한의 발신 데이터 요청을 유지할 수 있습니다.

uests.
#### Batch Function
배치 로딩 함수는 키 배열(Array)을 인자로 받아, 값 또는 Error 인스턴스 배열로 이뤄진 Promise를 반환합니다. 로더 자체는 `this` 컨텍스트로 제공됩니다.
```js
async function batchFunction(keys) {
const results = await db.fetchAllKeys(keys);
return keys.map(key => results[key] || new Error(`No result for ${key}`));
}
const loader = new DataLoader(batchFunction);
```
이 함수가 반드시 지켜야 하는 몇 가지 제약 사항이 있습니다:
- 값 배열의 길이는 키 배열의 길이와 같아야 합니다.
- 값 배열의 각 인덱스는 키 배열의 동일한 인덱스와 대응되어야 합니다.
예를 들어, 배치 함수에 다음과 같은 키 배열 `[ 2, 9, 6, 1 ]`이 전달되었고,
백엔드 서비스에서 다음과 같은 값들을 반환했다고 가정해 보겠습니다:
```js
{ id: 9, name: 'Chicago' }
{ id: 1, name: 'New York' }
{ id: 2, name: 'San Francisco' }
```
우리 백엔드 서비스는 요청한 순서와 다른 순서로 결과를 반환했습니다. 아마도 그렇게 처리하는 것이 더 효율적이었기 때문일 것입니다. 또한, 키 `6`에 대한 결과는 누락되었는데, 이는 해당 키에 대한 값이 존재하지 않음으로 해석할 수 있습니다.
배치 함수의 제약 사항을 준수하려면, 키 배열과 같은 길이의 값 배열을 반환해야 하며, 각 인덱스가 원래의 키인 `[ 2, 9, 6, 1 ]`과 일치하도록 순서를 다시 정렬해야 합니다:
```js
[
{ id: 2, name: 'San Francisco' },
{ id: 9, name: 'Chicago' },
null, // 혹은 `new Error()`
{ id: 1, name: 'New York' },
];
```
#### Batch Scheduling
기본적으로 DataLoader는 단일 실행 프레임 내에서 발생하는 모든 개별 로드 요청을 하나로 병합(coalesce)한 뒤, 요청된 모든 키와 함께 배치 함수를 호출합니다. 이를 통해 추가적인 지연 시간 없이 여러 관련 요청을 단일 배치로 묶을 수 있습니다. 실제로 이는 2010년 Facebook의 초기 PHP 구현에서 사용된 것과 동일한 동작 방식입니다. 작동 방식에 대한 자세한 내용은 [source code][]의 `enqueuePostPromiseJob`을 참고하세요.
하지만 때로는 이러한 동작이 원하지 않거나 최적이 아닐 수 있습니다. `setTimeout`을 이미 사용하고 있기 때문에 요청이 몇 번의 후속 틱에 걸쳐 분산되기를 원할 수도 있고, 실행 루프와 상관없이 디스패치를 수동으로 제어하고 싶을 수도 있습니다. DataLoader는 이러한 동작이나 기타 커스텀 동작을 구현할 수 있도록 커스텀 배치 스케줄러를 제공하는 기능을 지원합니다.
커스텀 스케줄러는 옵션에서 `batchScheduleFn`으로 제공됩니다. 이 함수는 콜백을 인자로 받아야 하며, 배치 요청을 실행하기 위해 가까운 시일 내에 해당 콜백을 호출해야 합니다.
예를 들어, 100ms 시간 창(window) 동안의 모든 요청을 수집하는 배치 스케줄러는 다음과 같습니다 (결과적으로 100ms의 지연 시간이 추가됩니다):
```js
const myLoader = new DataLoader(myBatchFn, {
batchScheduleFn: callback => setTimeout(callback, 100),
});
```
다른 예로, 수동으로 디스패치하는 배치 스케줄러는 다음과 같습니다:
```js
function createScheduler() {
let callbacks = [];
return {
schedule(callback) {
callbacks.push(callback);
},
dispatch() {
callbacks.forEach(callback => callback());
callbacks = [];
},
};
}
const { schedule, dispatch } = createScheduler();
const myLoader = new DataLoader(myBatchFn, { batchScheduleFn: schedule });
myLoader.load(1);
myLoader.load(2);
dispatch();
```
## Caching
DataLoader는 애플리케이션으로 향하는 단일 요청 내에서 발생하는 모든 로드에 대해 메모이제이션 캐시를 제공합니다. 특정 키로 `.load()`가 한 번 호출되면, 그 결과값이 캐시되어 중복 로드를 제거합니다.
#### Caching Per-Request
DataLoader 캐시는 Redis, Memcache 또는 기타 공유 애플리케이션 레벨의 캐시를 대체하지 \_않습니다\_ (does not). DataLoader는 무엇보다도 데이터 로딩 메커니즘이며, 그 캐시는 단일 애플리케이션 요청의 컨텍스트 내에서 동일한 데이터를 반복해서 로드하지 않는 목적만을 수행합니다. 이를 위해 간단한 인메모리 메모이제이션 캐시를 유지합니다 (더 정확히 말하자면, `.load()`는 메모이제이션된 함수입니다).
서로 다른 사용자의 여러 요청이 동일한 DataLoader 인스턴스를 공유하지 않도록 하세요. 이는 캐시된 데이터가 각 요청에 잘못 노출되는 결과를 초래할 수 있습니다. 일반적으로 DataLoader

er 인스턴스는 Request가 시작될 때 생성되며, Request가 끝나면 사용되지 않습니다.
예를 들어 [express][]와 함께 사용할 때:
```js
function createLoaders(authToken) {
return {
users: new DataLoader(ids => genUsers(authToken, ids)),
};
}
const app = express();
app.get('/', function (req, res) {
const authToken = authenticateUser(req);
const loaders = createLoaders(authToken);
res.send(renderPage(req, loaders));
});
app.listen();
```
#### 캐싱 및 배치 처리
동일한 키로 `.load()`를 후속 호출하면, 해당 키는 배치 함수에 전달되는 키 목록에 나타나지 않습니다. \_하지만\_ 결과 Promise는 여전히 현재 배치가 완료될 때까지 기다립니다. 이렇게 하면 캐시된 요청과 캐시되지 않은 요청 모두 동시에 해결(resolve)되므로, 후속 종속 로드에 대해 DataLoader 최적화를 사용할 수 있습니다.
아래 예시에서 User `1`은 우연히 캐시되어 있습니다. 하지만 User `1`과 `2`가 동일한 틱(tick)에서 로드되기 때문에, 이들은 동시에 해결됩니다. 즉, 두 `user.bestFriendID` 로드 역시 동일한 틱에서 발생하므로 총 두 번의 요청이 발생합니다(User `1`이 캐시되지 않은 경우와 동일함).
```js
userLoader.prime(1, { bestFriend: 3 });
async function getBestFriend(userID) {
const user = await userLoader.load(userID);
return await userLoader.load(user.bestFriendID);
}
// 애플리케이션의 한 부분에서
getBestFriend(1);
// 다른 곳에서
getBestFriend(2);
```
이러한 최적화가 없다면, 캐시된 User `1`이 즉시 해결될 경우 각 `user.bestFriendID` 로드가 서로 다른 시점에 발생하여 총 세 번의 요청이 발생할 수 있습니다.
#### 캐시 지우기
드문 경우이지만, 요청 캐시를 지워야 할 수도 있습니다.
로더의 캐시를 지워야 하는 가장 흔한 경우는 동일한 요청 내에서 뮤테이션(mutation)이나 업데이트가 발생한 후입니다. 이때 캐시된 값이 최신이 아닐 수 있으며, 향후 로드에서는 캐시되었을 가능성이 있는 값을 사용하지 않아야 합니다.
이해를 돕기 위해 SQL UPDATE를 사용하는 간단한 예시를 확인해 보세요.
```js
// Request가 시작됨...
const userLoader = new DataLoader(...);
// 그리고 값이 로드됨 (그리고 캐시됨).
const user = await userLoader.load(4);
// 뮤테이션이 발생하여 캐시에 있을 수 있는 내용을 무효화함.
await sqlRun('UPDATE users WHERE id=4 SET username="zuck"');
userLoader.clear(4);
// 나중에 뮤테이션된 데이터가 나타나도록 값을 다시 로드함.
const user = await userLoader.load(4);
// Request가 완료됨.
```
#### 에러 캐싱
배치 로드가 실패하면(즉, 배치 함수가 예외를 던지거나 거부된 Promise를 반환하는 경우), 요청된 값들은 캐시되지 않습니다. 그러나 배치 함수가 개별 값에 대해 `Error` 인스턴스를 반환하는 경우, 동일한 `Error`를 자주 로드하는 것을 피하기 위해 해당 `Error`는 캐시됩니다.
상황에 따라 이러한 개별 에러에 대한 캐시를 지우고 싶을 수 있습니다:
```js
try {
const user = await userLoader.load(1);
} catch (error) {
if (/\* determine if the error should not be cached \*/) {
userLoader.clear(1);
}
throw error
}
```
#### 캐시 비활성화하기
드문 경우지만, 캐시를 \_하지 않는\_ DataLoader가 필요할 수 있습니다.
`new DataLoader(myBatchFn, { cache: false })`를 호출하면 `.load()`에 대한 모든 호출이 \_새로운\_ Promise를 생성하도록 보장하며, 요청된 키는 메모리에 저장되지 않습니다.
그러나 메모이제이션 캐시가 비활성화되면, 배치 함수가 중복을 포함할 수 있는 키 배열을 받게 됩니다! 각 키는 `.load()` 호출 각각과 연관됩니다. 배치 로더는 요청된 키의 각 인스턴스에 대한 값을 제공해야 합니다.
예를 들면:
```js
const myLoader = new DataLoader(
keys => {
console.log(keys);
return someBatchLoadFn(keys);
},
{ cache: false },
);
myLoader.load('A');
myLoader.load('B');
myLoader.load('A');
// > [ 'A', 'B', 'A' ]
```
캐시를 완전히 비활성화하는 것보다 `.clear()` 또는 `.clearAll()`을 호출하는 방식으로 더 복잡한 캐시 동작을 구현할 수 있습니다. 예를 들어, 이 DataLoader는 메모이제이션 캐시가 활성화되어 있기 때문에 배치 함수에 고유한 키를 제공하지만, 캐시를 즉시 지웁니다.

batch 함수가 호출될 때
나중의 요청들이 새로운 값을 로드하게 됩니다.
```js
const myLoader = new DataLoader(keys => {
myLoader.clearAll();
return someBatchLoadFn(keys);
});
```
#### 커스텀 캐시
위에서 언급했듯이, DataLoader는 요청당 하나의 캐시(per-request cache)로 사용되도록 설계되었습니다.
요청은 수명이 짧기 때문에, DataLoader는 메모이제이션 캐시로 무한히 자라는 [Map][]을 사용합니다. 대부분의 요청은 수명이 짧고 요청이 완료된 후 전체 캐시가 폐기되므로 이는 문제가 되지 않습니다.
그러나 수명이 긴 DataLoader를 사용할 때는 이 메모이제이션 캐싱 전략이 안전하지 않습니다. 너무 많은 메모리를 소비할 수 있기 때문입니다. 이런 방식으로 DataLoader를 사용하는 경우, [Map][]과 동일한 API를 따르는 한 원하는 동작을 가진 커스텀 Cache 인스턴스를 제공할 수 있습니다.
아래 예제는 [lru\_map][] npm 패키지를 통해 최대 100개의 캐시된 값만 유지하도록 LRU(least recently used) 캐시를 사용합니다.
```js
import { LRUMap } from 'lru\_map';
const myLoader = new DataLoader(someBatchLoadFn, {
cacheMap: new LRUMap(100),
});
```
더 구체적으로, `get()`, `set()`, `delete()`, `clear()` 메서드를 구현하는 모든 객체를 제공할 수 있습니다. 이를 통해 다양한 [cache algorithms][]을 구현하는 커스텀 Map을 제공할 수 있습니다.
## API
#### class DataLoader
DataLoader는 일괄 로딩 함수(batch loading function)가 주어졌을 때, SQL 테이블의 `id` 컬럼이나 MongoDB 데이터베이스의 문서 이름과 같은 고유한 키를 사용하여 특정 데이터 백엔드로부터 데이터를 로드하기 위한 공용 API를 생성합니다.
각 `DataLoader` 인스턴스는 고유한 메모이제이션 캐시를 포함합니다. 수명이 긴 애플리케이션이나 서로 다른 접근 권한을 가진 많은 사용자를 서빙하는 애플리케이션에서 사용할 때는 주의를 기울여야 하며, 웹 요청당 새 인스턴스를 생성하는 것을 고려하세요.
##### `new DataLoader(batchLoadFn [, options])`
일괄 로딩 함수와 옵션을 받아 새로운 `DataLoader`를 생성합니다.
- \_batchLoadFn\_: 키의 배열을 받아 값의 배열로 resolve되는 Promise를 반환하는 함수입니다.
- \_options\_: 선택적 옵션 객체:
| 옵션 키 | 타입 | 기본값 | 설명 |
| ----------------- | -------- | ----------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `batch` | Boolean | `true` | `false`로 설정하면 배칭이 비활성화되며, 단일 로드 키로 `batchLoadFn`을 호출합니다. 이는 `maxBatchSize`를 `1`로 설정하는 것과 같습니다. |
| `maxBatchSize` | Number | `Infinity` | `batchLoadFn`에 전달되는 항목의 수를 제한합니다. 배칭을 비활성화하려면 `1`로 설정할 수 있습니다. |
| `batchScheduleFn` | Function | [Batch scheduling](#batch-scheduling) 참조 | 배치 실행을 나중에 스케줄링하는 함수입니다. 이 함수는 가까운 미래에 제공된 콜백을 호출할 것으로 예상됩니다. |
| `cache` | Boolean | `true` | `false`로 설정하면 메모이제이션 캐싱이 비활성화되어, 동일한 키를 로드할 때마다 `batchLoadFn`에서 새로운 Promise와 새로운 키가 생성됩니다. 이는 `cacheMap`을 `null`로 설정하는 것과 같습니다. |
| `cacheKeyFn` | Function | `key => key` | 주어진 로드 키에 대한 캐시 키를 생성합니다. 객체가 키이고 두 객체를 동일한 것으로 간주해야 할 때 유용합니다. |
| `cacheMap` | Object | `new Map()` | 캐시로 사용할 [Map][] 인스턴스 (또는 유사한 API를 가진 객체). 캐싱을 비활성화하려면 `null`로 설정할 수 있습니다. |
| `name` | String | `null` | 이 `DataLoader` 인스턴스에 부여된 이름입니다. APM 도구에 유용합니다. |
##### `load(key)`
키를 로드하고, 해당 키가 나타내는 값에 대한 `Promise`를 반환합니다.
- \_key\_: 로드할 키 값.
##### `loadMany(keys)`
여러 키를 로드하고, 값의 배열을 프로미스로 반환합니다.
```js
const [a, b] = await myLoader.loadMany(['a', 'b']);
```
이는 더 장황한 다음 코드와 유사합니다.
```js
const [a, b] = await Promise.all([myLoader.load('a'), myLoader.load('b')]);
```
그러나 로드 중 하나라도 실패하는 경우에는 차이가 있습니다. Promise.all()이 거부(reject)되는 곳에서는 loa

dMany()은 항상 이행(resolve)되지만, 각 결과는 값 또는 Error 인스턴스 중 하나입니다.
```js
var [a, b, c] = await myLoader.loadMany(['a', 'b', 'badkey']);
// c instanceof Error
```
- \_keys\_: 로드할 키 값들의 배열입니다.
##### `clear(key)`
캐시에 `key`가 존재하는 경우 해당 키의 값을 지웁니다. 메서드 체이닝을 위해 자기 자신을 반환합니다.
- \_key\_: 지울 키 값입니다.
##### `clearAll()`
전체 캐시를 지웁니다. 특정 이벤트로 인해 이 특정 `DataLoader` 전반에 걸쳐 알 수 없는 무효화가 발생할 때 사용합니다. 메서드 체이닝을 위해 자기 자신을 반환합니다.
##### `prime(key, value)`
제공된 키와 값으로 캐시를 미리 채웁니다. 키가 이미 존재하는 경우 변경되지 않습니다. (캐시를 강제로 채우려면 먼저 `loader.clear(key).prime(key, value)`를 사용하여 키를 지우세요.) 메서드 체이닝을 위해 자기 자신을 반환합니다.
특정 키에 에러를 캐시로 미리 채우려면 Error 인스턴스를 제공하세요.

## GraphQL과 함께 사용하기
DataLoader는 [GraphQL][graphql-js]과 아주 잘 어울립니다. GraphQL 필드는 독립형 함수로 설계되었습니다. 캐싱이나 배치(batching) 메커니즘이 없으면, 단순한(naive) GraphQL 서버는 필드가 resolve될 때마다 새로운 데이터베이스 요청을 발생시키기 쉽습니다.

다음 GraphQL 요청을 고려해 보세요:
```
{
me {
name
bestFriend {
name
}
friends(first: 5) {
name
bestFriend {
name
}
}
}
}
```
단순하게 생각하면, `me`, `bestFriend`, `friends`가 각각 백엔드를 요청해야 하는 경우 데이터베이스 요청이 최대 13개까지 발생할 수 있습니다!

DataLoader를 사용하면 [SQLite](examples/SQL.md) 예제와 같이 `User` 타입을 더 명확한 코드로 정의할 수 있으며, 데이터베이스 요청을 최대 4개로 줄이고 캐시 적중(cache hit)이 있는 경우 그보다 적게 발생시킬 수 있습니다.

```js
const UserType = new GraphQLObjectType({
name: 'User',
fields: () => ({
name: { type: GraphQLString },
bestFriend: {
type: UserType,
resolve: user => userLoader.load(user.bestFriendID),
},
friends: {
args: {
first: { type: GraphQLInt },
},
type: new GraphQLList(UserType),
resolve: async (user, { first }) => {
const rows = await queryLoader.load([
'SELECT toID FROM friends WHERE fromID=? LIMIT ?',
user.id,
first,
]);
return rows.map(row => userLoader.load(row.toID));
},
},
}),
});
```

## 공통 패턴
### 요청(request)당 새로운 DataLoader 생성하기.
많은 애플리케이션에서 DataLoader를 사용하는 웹 서버는 서로 다른 접근 권한을 가진 수많은 사용자들의 요청을 처리합니다. 여러 사용자에 걸쳐 하나의 캐시를 사용하는 것은 위험할 수 있으므로, 요청(request)당 새로운 DataLoader를 생성하는 것이 권장됩니다:

```js
function createLoaders(authToken) {
return {
users: new DataLoader(ids => genUsers(authToken, ids)),
cdnUrls: new DataLoader(rawUrls => genCdnUrls(authToken, rawUrls)),
stories: new DataLoader(keys => genStories(authToken, keys)),
};
}
// 들어오는 웹 요청을 처리할 때:
const loaders = createLoaders(request.query.authToken);
// 그런 다음, 애플리케이션 로직 내에서:
const user = await loaders.users.load(4);
const pic = await loaders.cdnUrls.load(user.rawPicUrl);
```

각 키가 `DataLoader`인 객체를 생성하는 것은 [graphql-js][] 요청의 `rootValue`의 일부와 같이 데이터 로딩을 수행해야 하는 코드에 전달할 단일 값을 제공하는 일반적인 패턴 중 하나입니다.

### 대체 키로 로딩하기.
가끔 어떤 종류의 값에는 여러 가지 방식으로 접근할 수 있습니다. 예를 들어, "User" 타입이 "id"뿐만 아니라 "username" 값으로도 로드될 수 있습니다. 동일한 사용자가 두 키 모두로 로드되는 경우, 어느 한쪽 소스에서 사용자가 로드될 때 두 캐시 모두를 채워두는 것이 유용할 수 있습니다:

```js
const userByIDLoader = new DataLoader(async ids => {
const users = await genUsersByID(ids);
for (let user of users) {
usernameLoader.prime(user.username, user);
}
return users;
});
const usernameLoader = new DataLoader(async names => {
const users = await genUsernames(names);
for (let user of users) {
userByIDLoader.prime(user.id, user);
}
return users;
});
```

### 불변성(immutability)을 강제하기 위한 결과 동결(Freezing)
DataLoader는 값을 캐시하기 때문에, 일반적으로 이러한 값들은 불변인 것처럼 다뤄질 것이라고 가정합니다. DataLoader 자체가 이를 강제하지는 않지만, 다음과 같이 할 수 있습니다

`Object.freeze()`를 사용하여 불변성(immutability)을 강제하는 고차 함수(higher-order function) 만들기:
```js
function freezeResults(batchLoader) {
return keys => batchLoader(keys).then(values => values.map(Object.freeze));
}
const myLoader = new DataLoader(freezeResults(myBatchLoader));
```
### 배열 대신 객체를 반환하는 배치 함수
DataLoader는 제공된 키와 동일한 길이의 배열을 반환하는 배치 함수를 예상합니다. 하지만 다른 라이브러리에서는 이것이 흔한 반환 형식이 아닐 수도 있습니다. DataLoader 고차 함수를 사용하면 한 형식을 다른 형식으로 변환할 수 있습니다. 아래 예제는 `{ key: value }` 결과를 DataLoader가 예상하는 형식으로 변환합니다.
```js
function objResults(batchLoader) {
return keys =>
batchLoader(keys).then(objValues =>
keys.map(key => objValues[key] || new Error(`No value for ${key}`)),
);
}
const myLoader = new DataLoader(objResults(myBatchLoader));
```
## 일반적인 백엔드
특정 백엔드로 시작하고 싶으신가요? [예제 디렉터리의 loader들](/examples)을 참고하세요.
## 기타 구현체
알파벳 순서로 나열됨
- Elixir
- [dataloader](https://github.com/absinthe-graphql/dataloader)
- Golang
- [Dataloader](https://github.com/nicksrandall/dataloader)
- Java
- [java-dataloader](https://github.com/graphql-java/java-dataloader)
- .Net
- [GraphQL .NET DataLoader](https://graphql-dotnet.github.io/docs/guides/dataloader/)
- [Green Donut](https://github.com/ChilliCream/graphql-platform?tab=readme-ov-file#green-donut)
- Perl
- [perl-DataLoader](https://github.com/richardjharris/perl-DataLoader)
- PHP
- [DataLoaderPHP](https://github.com/overblog/dataloader-php)
- Python
- [aiodataloader](https://github.com/syrusakbary/aiodataloader)
- ReasonML
- [bs-dataloader](https://github.com/ulrikstrid/bs-dataloader)
- Ruby
- [BatchLoader](https://github.com/exaspark/batch-loader)
- [Dataloader](https://github.com/sheerun/dataloader)
- [GraphQL Batch](https://github.com/Shopify/graphql-batch)
- Rust
- [Dataloader](https://github.com/cksac/dataloader-rs)
- Swift
- [SwiftDataLoader](https://github.com/kimdv/SwiftDataLoader)
- C++
- [cppdataloader](https://github.com/jafarlihi/cppdataloader)
## 비디오 소스 코드 가이드
\*\*DataLoader 소스 코드 가이드 (YouTube):\*\*
DataLoader v1 소스 코드 가이드입니다. 이 비디오가 제작된 이후 소스코드가 변경되었지만, 여전히 DataLoader의 존재 이유와 작동 방식을 파악하기 좋은 개요입니다.
[![](https://img.youtube.com/vi/OQTnXNCDywA/0.jpg)](https://youtu.be/OQTnXNCDywA)
[@schrockn]: https://github.com/schrockn
[Map]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global\_Objects/Map
[graphql-js]: https://github.com/graphql/graphql-js
[cache algorithms]: https://en.wikipedia.org/wiki/Cache\_algorithms
[express]: http://expressjs.com/
[babel/polyfill]: https://babeljs.io/docs/usage/polyfill/
[lru\_map]: https://github.com/rsms/js-lru
[source code]: https://github.com/graphql/dataloader/blob/main/src/index.js
# 이 레포지토리에 기여하기
이 레포지토리는 EasyCLA에 의해 관리됩니다. 프로젝트 참여자는 기여하기 전에 무료인 [GraphQL Specification Membership agreement](https://preview-spec-membership.graphql.org)에 서명해야 합니다. 이 작업은 단 한 번만 수행하면 되며, [개인 기여자](http://individual-spec-membership.graphql.org/) 또는 [고용주](http://corporate-spec-membership.graphql.org/)를 통해 서명할 수 있습니다.
서명 프로세스를 시작하려면 이 레포지토리에 PR을 열어주세요. 여전히 회원 가입 계약서가 필요한 경우 EasyCLA 봇이 머지를 차단할 것입니다.
[여기에서 자세한 정보](https://github.com/graphql/graphql-wg/tree/main/membership)를 확인하실 수 있습니다. 문제가 있는 경우 [operations@graphql.org](mailto:operations@graphql.org)로 이메일을 보내주세요.
만약 귀하의 회사가 GraphQL로부터 혜택을 받고 있고 우리 커뮤니티를 지탱하는 시스템과 사람들에게 필수적인 재정적 지원을 제공하고 싶다면, [GraphQL Foundation](https://foundation.graphql.org/join) 멤버십 가입도 고려해 주세요.