PHPackages                             rodrigoaramburu/php-json-server - PHPackages - PHPackages  [Skip to content](#main-content)[PHPackages](/)[Directory](/)[Categories](/categories)[Trending](/trending)[Leaderboard](/leaderboard)[Changelog](/changelog)[Analyze](/analyze)[Collections](/collections)[Log in](/login)[Sign up](/register)

1. [Directory](/)
2. /
3. [API Development](/categories/api)
4. /
5. rodrigoaramburu/php-json-server

ActiveLibrary[API Development](/categories/api)

rodrigoaramburu/php-json-server
===============================

Biblioteca para criar uma API Rest fake para prototipação de front-end

v1.0.0(3y ago)024MITPHPPHP >8.0

Since Aug 4Pushed 3y ago1 watchersCompare

[ Source](https://github.com/rodrigoaramburu/php-json-server)[ Packagist](https://packagist.org/packages/rodrigoaramburu/php-json-server)[ RSS](/packages/rodrigoaramburu-php-json-server/feed)WikiDiscussions main Synced 1mo ago

READMEChangelogDependencies (7)Versions (9)Used By (0)

PHP JSON Server
===============

[](#php-json-server)

PHP JSON Server é uma biblioteca simples para fornecer uma API REST em poucos minutos para ser utilizada em testes de *front-end* por exemplo.

Ela pode rodar através do servidor *build-in* do PHP ou ser integrada a um *framework* com bastante facilidade. Também possui um CLI para iniciar um servidor de maneira rápida e gerar os dados da API.

**\* NÃO DEVE SER UTILIZADO EM PRODUÇÃO**

Inpirada na biblioteca [Zlob/php-json-server](https://github.com/Zlob/php-json-server)

Instalação
----------

[](#instalação)

Via composer `composer require rodrigoaramburu/php-json-server`.

Criamos um arquivo `index.php` com o seguinte código.

```
$server = new Server([
    'database-file' => __DIR__.'/database.json',
]);

$path = $_SERVER['REQUEST_URI'];
$body = file_get_contents('php://input');
$headers = getallheaders();
$response = $server->handle($_SERVER['REQUEST_METHOD'], $path, $body, $headers);

$server->send($response);
```

Ao criar o `Server` passamos o caminho para o *json* de dados da API. Nele definimos os dados iniciais e quais coleções a API vai ter. Veja um exemplo de `database.json`

```
{
    "embed-resources": {
        "posts" : ["comments"]
    },
    "posts": [
        {
            "id": 1,
            "title": "Lorem ipsum dolor sit amet",
            "author": "Rodrigo",
            "content": "Nunc volutpat ipsum eget sapien ornare..."
        },
        {
            "id": 2,
            "title": "Duis quis arcu mi",
            "author": "Rodrigo",
            "content": "Suspendisse auctor dolor risus, vel posuere libero..."
        }
    ],
    "comments": [
        {
            "id": 1,
            "post_id": 1,
            "comment": "Pellentesque id orci sodales, dignissim massa vel"
        },
        {
            "id": 2,
            "post_id": 2,
            "comment": "Maecenas elit dui, venenatis ut erat vitae"
        },
        {
            "id": 3,
            "post_id": 1,
            "comment": "Quisque velit tellus, tempus vitae condimentum nec"
        }
    ]
}

```

Cada propriedade do *JSON* representa uma coleção sendo seu valor um *array* de objetos contidos na coleção. Podemos ligar um objeto de uma coleção com de outra coleção com uma "chave estrangeira" com o formato `_id`, isto irá fazer com que ao ser recuperada o campo de "chave estrangeira" será substituido pelo resource com o id especificado.

Para carregar todos um resource juntamente com todos os outros que tem que tem uma chave estrangeira para ele adicionamos esta relação a entrada *embed-resources* do arquivo de dados.

Com o *JSON* acima a API irá nos fornecer as seguintes rotas.

MethodUrlGET/postsGET/posts/1GET/posts/commentsGET/posts/1/commentsPOST/postsPOST/posts/1/commentsPUT/posts/1PUT/posts/1/comments/3DELETE/posts/1DELETE/posts/1/comments/3Com o `database.json` e o `index.php` podemos rodar a API com o servidor *build-in* do *PHP*.

```
php -S localhost:8000 index.php
```

Também podemos integra-lo facilmente com outros *frameworks*. Veja um exemplo utilizando o ***Slim***.

```
use DI\Container;
use JsonServer\Server;
use Slim\Factory\AppFactory;
use Psr\Http\Message\RequestInterface;
use Psr\Http\Message\ResponseInterface;

$container = new Container();
AppFactory::setContainer($container);
$app = AppFactory::create();

$server = new Server([
    'database-file' => __DIR__.'/database.json',
]);

$app->any('/api/{path:.*}' , function(RequestInterface $request, ResponseInterface $response, $args) use($server){

    $path = '/'.$args['path'];
    $body = (string) $request->getBody();
    $headers = $request->getHeaders();
    $response = $server->handle($request->getMethod(), $path, $body, $headers);

    return $response;
});

$app->run();
```

- Obs.: neste caso as rotas da api serão precedidas por `/api`

Como o retorno do método `handle` é um objeto da interface `Psr\Http\Message\ResponseInterface` basta retornar para o *Slim* construir a resposta.

Middlewares
-----------

[](#middlewares)

O servidor permite a utilização de *middlewares*, para isso basta estender a classe abstrata `JsonServer\Middlewares\Middleware` implementando o método `public function process(RequestInterface $request, Handler $handler): ResponseInterface;`

```
use JsonServer\Middlewares\Handler;
use JsonServer\Middlewares\Middleware;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;

class ExampleMiddleware extends Middleware
{
    public function process(ServerRequestInterface $request, Handler $handler): ResponseInterface
    {
        //antes de ser processado
        $authToken = $request->getHeader("Authorization");

        $response = $handler->handle($request);

        // após ser processado
        $response = $response->withHeader('Content-Type','application/json');
        return $response;
    }
}
```

E depois adicionar ao `$server`:

```
$server->addMiddleware(new ExampleMiddleware());
```

### Middleware Rota Estática

[](#middleware-rota-estática)

Podemos criar rotas estáticas utilizando o middleware `StaticMiddleware`, ele recebe no construtor um *array* ou o caminho para um arquivo *json* com as rotas.

```
$staticRoutes = new StaticMiddleware([
    "/static/route" => [
        "GET" => [
            "body" => "{\"message\": \"Uma resposta GET para o cliente \"}",
            "statusCode" => 200,
            "headers" => [
                "Content-Type" => "application/json"
            ]
        ],
        "POST" => [
            "body" => "{\"message\": \"Uma resposta POST para o cliente\"}",
            "statusCode" => 201,
            "headers" => [
                "Content-Type" => "application/json"
            ]
        ],
    ]
]);
$server->addMiddleware($staticRoutes);
```

Em vez de passar o array podemos passar um json com as configurações das rotas em um arquivo *json* como `static.json`.

```
{
    "/static/route": {
        "GET": {
            "body": "{\"message\": \"Uma resposta GET para o cliente \"}",
            "statusCode": 200,
            "headers": {
                "Content-Type": "application/json"
            }
        },
        "POST": {
            "body": "{\"message\": \"Uma resposta POST para o cliente\"}",
            "statusCode": 201,
            "headers": {
                "Content-Type": "application/json"
            }
        }
    }
}
```

E adicionamos passamos seu caminho ao *middleware*

```
$staticRoutes = new StaticMiddleware(__DIR__.'/static.json');
$server->addMiddleware($staticRoutes);
```

Filtros e Ordenação
-------------------

[](#filtros-e-ordenação)

Podemos filtrar um recurso por campo passando o campo e o valor como *query param*:

```
http://localhost:8000/posts?author=rodrigo

```

Podemos ordenar o resultado por um campo passado por *query param* os parâmetros de *\_sort* para o nome do campo e *\_order* para o sentido (asc, desc);

```
localhost:8000/posts?_sort=author&_order=desc

```

CLI
---

[](#cli)

### Iniciando o servidor

[](#iniciando-o-servidor)

Também é possível iniciar um servidor de forma mais simples através de comando CLI, para isso basta ter os arquivos JSON na pasta e rodar

```
vendor/bin/json-server start
```

Podemos passar os seguintes parâmetros:

ParâmetrosDescriçãodata-dir=PATHespecifica o diretório contento os arquivos json como `database.json`port=PORTespecifica a porta que o servidor irá rodar--use-static-routehabilita o middelware de rotas estáticas, as rotas devem ser especificadas no arquivos `static.json`### Gerando o database.json

[](#gerando-o-databasejson)

Podemos gerar o arquivo de dados utilizando o seguinte comando

```
vendor/bin/json-server generate database resource1 resource2 ...
```

Podemos passar os seguinte parâmentros

ParâmetrosDescriçãofilename=FILENAMEespecifica o nome do arquivo que será gravado os dadosembed=RELATIONSespecifica as relações dos *resources*. Deve ser passado no formato: 'resourcePai\[resourceFilho1,resourceFilho2\]; ... '### Gerando dados dos *Resources*

[](#gerando-dados-dos-resources)

Podemos gerar os dados de um *resource* utilizando o seguinte comando:

```
vendor/bin/json-server generate resources resource_name [filename=FILENAME] [fields=FIELDS_LIST]
```

Podemos passar os seguinte parâmentros

ParâmetrosDescriçãofilename=FILENAMEespecifica o nome do arquivo que será gravado os dadosnum=NUM\_OF\_RESOURCESespecifica o número de *resources* a serem criadosfields=FIELDS\_LISTlista de campos a serem criados no *resource*. Deve ser informado no formato. *'field.type;field.type; ...'*. O *type* deve ser um método do lib [Faker](https://fakerphp.github.io/), com seus parâmetros(se houver) passados separados por ponto após o nome do método. Ex.: `idade.numberBetween.20.70`### Gerando rotas estáticas

[](#gerando-rotas-estáticas)

Podemos gerar o arquivo de rotas estaticas para o middleware `StaticMiddleware` com o seguinte comando:

```
vendor/bin/json-server generate database static [filename=FILENAME] [path=PATH] [method=METHOD] [body=BODY] [statusCode=STATUS_CODE] [headers=HEADER-LIST]
```

ParâmetrosDescriçãofilename=FILENAMEespecifica o nome do arquivo que será gravado os dadospath=PATHpath da rotamethod=METHODmétodo da rotabody=BODYbody da respostastatusCode=STATUS\_CODEcódigo de esta http da respostaheaders=HEADER-LISTlista de header da resposta. Informadado no formato headers="header1

###  Health Score

25

—

LowBetter than 37% of packages

Maintenance20

Infrequent updates — may be unmaintained

Popularity6

Limited adoption so far

Community7

Small or concentrated contributor base

Maturity57

Maturing project, gaining track record

 Bus Factor1

Top contributor holds 100% of commits — single point of failure

How is this calculated?**Maintenance (25%)** — Last commit recency, latest release date, and issue-to-star ratio. Uses a 2-year decay window.

**Popularity (30%)** — Total and monthly downloads, GitHub stars, and forks. Logarithmic scaling prevents top-heavy scores.

**Community (15%)** — Contributors, dependents, forks, watchers, and maintainers. Measures real ecosystem engagement.

**Maturity (30%)** — Project age, version count, PHP version support, and release stability.

###  Release Activity

Cadence

Every ~3 days

Total

7

Last Release

1362d ago

Major Versions

v0.3.1 → v1.0.02022-08-25

### Community

Maintainers

![](https://www.gravatar.com/avatar/0f110334568d29fc9abc433301d4edbe2f36aeebfc23a526cd9a24509285bc7f?d=identicon)[rodrigoaramburu](/maintainers/rodrigoaramburu)

---

Top Contributors

[![rodrigoaramburu](https://avatars.githubusercontent.com/u/389627?v=4)](https://github.com/rodrigoaramburu "rodrigoaramburu (64 commits)")

---

Tags

apiapi-fakerjsonphp

###  Code Quality

TestsPest

Code StyleLaravel Pint

### Embed Badge

![Health badge](/badges/rodrigoaramburu-php-json-server/health.svg)

```
[![Health](https://phpackages.com/badges/rodrigoaramburu-php-json-server/health.svg)](https://phpackages.com/packages/rodrigoaramburu-php-json-server)
```

###  Alternatives

[sylius/sylius

E-Commerce platform for PHP, based on Symfony framework.

8.4k5.6M651](/packages/sylius-sylius)[knuckleswtf/scribe

Generate API documentation for humans from your Laravel codebase.✍

2.3k12.2M45](/packages/knuckleswtf-scribe)[aimeos/ai-admin-graphql

Aimeos Admin GraphQL API extension

944100.0k4](/packages/aimeos-ai-admin-graphql)[kirschbaum-development/laravel-openapi-validator

Automatic OpenAPI validation for Laravel HTTP tests

581.1M5](/packages/kirschbaum-development-laravel-openapi-validator)[wordpress/php-ai-client

A provider agnostic PHP AI client SDK to communicate with any generative AI models of various capabilities using a uniform API.

26236.6k14](/packages/wordpress-php-ai-client)[toshy/bunnynet-php

BunnyNet API client for PHP

61172.1k6](/packages/toshy-bunnynet-php)

PHPackages © 2026

[Directory](/)[Categories](/categories)[Trending](/trending)[Changelog](/changelog)[Analyze](/analyze)