GraphQL과 PHP로 데이터 쿼리 시스템 구축하기 🚀

재능넷에서 사용자 정보를 가져오는 상황을 생각해봐요. REST API를 사용한다면 이렇게 될 거예요:

GET /users/123
GET /users/123/posts
GET /users/123/followers

세 번의 요청을 보내야 해요. 근데 GraphQL을 사용하면?

query {
  user(id: 123) {
    name
    email
    posts {
      title
    }
    followers {
      name
    }
  }
}

한 번의 요청으로 모든 정보를 가져올 수 있어요! 완전 개이득! 🎉

먼저, Composer를 사용해 라이브러리를 설치해볼까요?

composer require webonyx/graphql-php

설치가 끝났다면, 간단한 GraphQL 스키마를 정의해볼게요:

use GraphQL\Type\Definition\ObjectType;
use GraphQL\Type\Definition\Type;
use GraphQL\Type\Schema;

$queryType = new ObjectType([
    'name' => 'Query',
    'fields' => [
        'echo' => [
            'type' => Type::string(),
            'args' => [
                'message' => Type::nonNull(Type::string()),
            ],
            'resolve' => function ($root, $args) {
                return $args['message'];
            }
        ],
    ],
]);

$schema = new Schema([
    'query' => $queryType
]);

이렇게 하면 간단한 GraphQL 서버가 준비됐어요! 👏

먼저, 필요한 타입들을 정의해볼게요:

use GraphQL\Type\Definition\ObjectType;
use GraphQL\Type\Definition\Type;

$userType = new ObjectType([
    'name' => 'User',
    'fields' => [
        'id' => Type::id(),
        'name' => Type::string(),
        'email' => Type::string(),
        'talents' => Type::listOf($talentType),
    ]
]);

$talentType = new ObjectType([
    'name' => 'Talent',
    'fields' => [
        'id' => Type::id(),
        'title' => Type::string(),
        'description' => Type::string(),
        'price' => Type::float(),
        'user' => $userType,
        'reviews' => Type::listOf($reviewType),
    ]
]);

$reviewType = new ObjectType([
    'name' => 'Review',
    'fields' => [
        'id' => Type::id(),
        'content' => Type::string(),
        'rating' => Type::int(),
        'user' => $userType,
        'talent' => $talentType,
    ]
]);

이제 쿼리 타입을 만들어볼게요:

$queryType = new ObjectType([
    'name' => 'Query',
    'fields' => [
        'user' => [
            'type' => $userType,
            'args' => [
                'id' => Type::nonNull(Type::id())
            ],
            'resolve' => function ($root, $args) {
                // 여기서 실제 데이터베이스 쿼리를 수행해요
                return getUserById($args['id']);
            }
        ],
        'talent' => [
            'type' => $talentType,
            'args' => [
                'id' => Type::nonNull(Type::id())
            ],
            'resolve' => function ($root, $args) {
                return getTalentById($args['id']);
            }
        ],
        'talents' => [
            'type' => Type::listOf($talentType),
            'resolve' => function () {
                return getAllTalents();
            }
        ]
    ]
]);

마지막으로 스키마를 만들어요:

$schema = new Schema([
    'query' => $queryType
]);

function getUserById($id) {
    $pdo = new PDO('mysql:host=localhost;dbname=jaenung_net', 'username', 'password');
    $stmt = $pdo->prepare('SELECT * FROM users WHERE id = :id');
    $stmt->execute(['id' => $id]);
    return $stmt->fetch(PDO::FETCH_ASSOC);
}

// GraphQL 리졸버에서 이렇게 사용해요
'resolve' => function ($root, $args) {
    return getUserById($args['id']);
}

use GraphQL\Deferred;
use GraphQL\Executor\Promise\Adapter\SyncPromise;

$userType = new ObjectType([
    'name' => 'User',
    'fields' => [
        'id' => Type::id(),
        'name' => Type::string(),
        'talents' => [
            'type' => Type::listOf($talentType),
            'resolve' => function ($user, $args, $context) {
                $talentLoader = $context['talentLoader'];
                return new Deferred(function () use ($talentLoader, $user) {
                    return $talentLoader->load($user['id']);
                });
            }
        ]
    ]
]);

// 데이터 로더 설정
$talentLoader = new DataLoader(function ($userIds) {
    $talents = fetchTalentsForUsers($userIds);  // 한 번에 여러 사용자의 재능을 가져와요
    return new SyncPromise(function ($resolve) use ($talents, $userIds) {
        $talentsByUser = [];
        foreach ($talents as $talent) {
            $talentsByUser[$talent['user_id']][] = $talent;
        }
        $resolve(array_map(function ($userId) use ($talentsByUser) {
            return $talentsByUser[$userId] ?? [];
        }, $userIds));
    });
});

use Firebase\JWT\JWT;

function authenticateUser($token) {
    try {
        $decoded = JWT::decode($token, 'your-secret-key', array('HS256'));
        return $decoded->user_id;
    } catch (Exception $e) {
        return null;
    }
}

$queryType = new ObjectType([
    'name' => 'Query',
    'fields' => [
        'me' => [
            'type' => $userType,
            'resolve' => function ($root, $args, $context) {
                $userId = authenticateUser($context['token']);
                if (!$userId) {
                    throw new Exception('인증되지 않은 사용자입니다.');
                }
                return getUserById($userId);
            }
        ]
    ]
]);

use GraphQL\Error\FormattedError;

$errorFormatter = function(Throwable $e) {
    if ($e instanceof AuthenticationException) {
        return FormattedError::createFromException($e, [
            'category' => 'authentication'
        ]);
    }
    return FormattedError::createFromException($e);
};

$result = GraphQL::executeQuery($schema, $query)
    ->setErrorFormatter($errorFormatter)
    ->setErrorsHandler(function(array $errors, callable $formatter) {
        return array_map($formatter, $errors);
    });

echo json_encode($result);

use GraphQL\Validator\Rules\QueryComplexity;

$complexity = new QueryComplexity(100);  // 최대 복잡도를 100으로 제한

$result = GraphQL::executeQuery(
    $schema,
    $query,
    null,
    null,
    $variables,
    null,
    null,
    [$complexity]
);

use Predis\Client;

$redis = new Client();

function getUserById($id) {
    global $redis;
    $cacheKey = "user:{$id}";
    
    $cachedUser = $redis->get($cacheKey);
    if ($cachedUser) {
        return json_decode($cachedUser, true);
    }
    
    $user = fetchUserFromDatabase($id);  // 실제 데이터베이스에서 가져오는 함수
    $redis->setex($cacheKey, 3600, json_encode($user));  // 1시간 동안 캐시
    
    return $user;
}

// GraphQL 리졸버에서 이렇게 사용해요
'resolve' => function ($root, $args) {
    return getUserById($args['id']);
}

use GraphQL\Deferred;

$userLoader = new DataLoader(function ($ids) {
    return new Deferred(function () use ($ids) {
        $users = fetchUsersFromDatabase($ids);  // 한 번에 여러 사용자 정보를 가져와요
        return array_map(function ($id) use ($users) {
            return $users[$id] ?? null;
        }, $ids);
    });
});

$userType = new ObjectType([
    'name' => 'User',
    'fields' => [
        'id' => Type::id(),
        'name' => Type::string(),
        'email' => Type::string(),
    ]
]);

$queryType = new ObjectType([
    'name' => 'Query',
    'fields' => [
        'users' => [
            'type' => Type::listOf($userType),
            'args' => [
                'ids' => Type::listOf(Type::id())
            ],
            'resolve' => function  ($root, $args, $context) use ($userLoader) {
                return array_map(function ($id) use ($userLoader) {
                    return $userLoader->load($id);
                }, $args['ids']);
            }
        ]
    ]
]);

use React\Http\Server;
use React\Http\Message\Response;
use React\EventLoop\Factory;
use Psr\Http\Message\ServerRequestInterface;

$loop = Factory::create();

$server = new Server($loop, function (ServerRequestInterface $request) {
    $body = json_decode((string) $request->getBody(), true);
    $query = $body['query'];
    $variables = $body['variables'] ?? null;

    $promise = \React\Promise\resolve()->then(function () use ($query, $variables) {
        return GraphQL::executeQuery($schema, $query, null, null, $variables);
    });

    return $promise->then(
        function ($result) {
            return new Response(
                200,
                ['Content-Type' => 'application/json'],
                json_encode($result)
            );
        },
        function ($error) {
            return new Response(
                500,
                ['Content-Type' => 'application/json'],
                json_encode(['errors' => [['message' => $error->getMessage()]]])
            );
        }
    );
});

$socket = new \React\Socket\Server('127.0.0.1:8080', $loop);
$server->listen($socket);

$loop->run();

use GraphQL\Deferred;

$userType = new ObjectType([
    'name' => 'User',
    'fields' => [
        'id' => Type::id(),
        'name' => Type::string(),
        'totalTalents' => [
            'type' => Type::int(),
            'resolve' => function ($user, $args, $context) {
                $redis = $context['redis'];
                $cacheKey = "user:{$user['id']}:totalTalents";
                
                $cachedCount = $redis->get($cacheKey);
                if ($cachedCount !== false) {
                    return (int)$cachedCount;
                }
                
                return new Deferred(function () use ($user, $redis, $cacheKey) {
                    $count = countUserTalents($user['id']);  // 실제 카운트를 가져오는 함수
                    $redis->setex($cacheKey, 3600, $count);  // 1시간 동안 캐시
                    return $count;
                });
            }
        ]
    ]
]);

use GraphQL\Executor\Executor;
use GraphQL\Executor\Promise\Adapter\SyncPromiseAdapter;

$promiseAdapter = new SyncPromiseAdapter();

$executeFunction = function(
    $schema,
    $document,
    $rootValue,
    $contextValue,
    $variableValues,
    $operationName,
    callable $fieldResolver,
    array $validationRules = null
) use ($promiseAdapter) {
    $start = microtime(true);
    
    $result = Executor::promiseToExecute(
        $promiseAdapter,
        $schema,
        $document,
        $rootValue,
        $contextValue,
        $variableValues,
        $operationName,
        $fieldResolver,
        $validationRules
    );
    
    $end = microtime(true);
    $duration = ($end - $start) * 1000;  // 밀리초 단위
    
    // 여기서 $duration을 모니터링 시스템에 보내면 돼요
    sendToMonitoringSystem('graphql_query_duration', $duration);
    
    return $result;
};

$result = GraphQL::executeQuery(
    $schema,
    $query,
    null,
    null,
    $variables,
    null,
    $executeFunction
);

use Monolog\Logger;
use Monolog\Handler\StreamHandler;

$log = new Logger('graphql');
$log->pushHandler(new StreamHandler('path/to/your/graphql.log', Logger::DEBUG));

$result = GraphQL::executeQuery($schema, $query, null, null, $variables);

$log->info('GraphQL Query', [
    'query' => $query,
    'variables' => $variables,
    'result' => $result->toArray()
]);

# Nginx 설정
http {
    upstream php-fpm {
        server 127.0.0.1:9000;
        server 127.0.0.1:9001;
        server 127.0.0.1:9002;
    }

    server {
        listen 80;
        server_name api.jaenung.net;

        location /graphql {
            fastcgi_pass php-fpm;
            fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
            include fastcgi_params;
        }
    }
}

# PHP-FPM 설정
[www]
user = www-data
group = www-data
listen = 127.0.0.1:9000
pm = dynamic
pm.max_children = 50
pm.start_servers = 5
pm.min_spare_servers = 5
pm.max_spare_servers = 35

use Symfony\Component\RateLimit\Storage\CacheStorage;
use Symfony\Component\RateLimit\RateLimiter;
use Symfony\Component\Cache\Adapter\RedisAdapter;

$redis = new \Redis();
$redis->connect('localhost', 6379);

$storage = new CacheStorage(new RedisAdapter($redis));
$limiter = new RateLimiter('api', 100, '15 minutes', $storage);

$limit = $limiter->consume();
if (!$limit->isAccepted()) {
    header('HTTP/1.1 429 Too Many Requests');
    exit('Rate limit exceeded. Try again in ' . $limit->getRetryAfter()->format('%i minutes'));
}

// 여기서 GraphQL 쿼리 실행