https://github.com/scalars/grapi
Make GraphQL API integration simple and easy. Autogen resolvers for mutation and queries in a GraphQL layer.
https://github.com/scalars/grapi
graphql graphql-js graphql-schema graphql-server mongo mongodb mutations queries
Last synced: about 2 months ago
JSON representation
Make GraphQL API integration simple and easy. Autogen resolvers for mutation and queries in a GraphQL layer.
- Host: GitHub
- URL: https://github.com/scalars/grapi
- Owner: scalars
- Created: 2021-03-17T17:47:37.000Z (almost 5 years ago)
- Default Branch: main
- Last Pushed: 2025-07-04T22:07:37.000Z (6 months ago)
- Last Synced: 2025-10-23T16:30:04.121Z (2 months ago)
- Topics: graphql, graphql-js, graphql-schema, graphql-server, mongo, mongodb, mutations, queries
- Language: TypeScript
- Homepage:
- Size: 223 KB
- Stars: 6
- Watchers: 2
- Forks: 1
- Open Issues: 2
-
Metadata Files:
- Readme: readme.md
Awesome Lists containing this project
README
> Businesses usually involving a broad spectrum of applications, that aren't integrated and requiring human intervention at almost every step of the process, this lack of integration and automation pretend to be solved trought an autogenerated GraphQL API Layer.
> **Grapi make GraphQL API integration simple and easy.**
## Installation
``` shell
yarn add @grapi/server
```
## Features
### Build GraphQL API with GraphQL SDL
SDL or Schema Definition Language is part of GraphQL Language, to define data and resolvers for the GraphQL API.
```graphql
# File schema.graphql
enum Gender {
NO_GENDER,
FEMALE,
MALE
}
type Actor @Model( dataSource: "datasource", key: "Actor" ) {
id: ID ! @unique
name: String !
gender: Gender
}
```
**Grapi** read SDL types and autogen resolvers for query and mutations on every model defined in SDL schema.
**Grapi for Typescript**
```shell
yarn init
yarn add @grapi/server @grapi/mongodb
yarn add ts-node apollo-server
yarn add -D typescript
```
```typescript
// server.ts
import { readFileSync } from 'fs'
import { resolve } from 'path'
import { MongodbDataSourceGroup } from '@grapi/mongodb'
import { Grapi } from '@grapi/server'
import { ApolloServer } from 'apollo-server'
const getDataSource = async () => {
const datasource = new MongodbDataSourceGroup(
process.env.MONGO_URI as string,
process.env.MONGO_DATA_BASE_NAME as string
)
await datasource.initialize()
return datasource
}
const startGraphQLServer = async () => {
const datasource = await getDataSource()
const sdl = readFileSync( resolve( __dirname, 'schema.graphql' ) ).toString()
const grapi = new Grapi( {
sdl,
dataSources: {
datasource: ( args ) => datasource.getDataSource( args.key ),
}
} )
const server = new ApolloServer( grapi.createApolloConfig() )
server.listen().then( ( { url } ) => {
console.info( `GraphQL Server On: ${ url }` )
console.info( `Go To Browser And See PlayGround` )
} )
}
startGraphQLServer()
```
Run server
```
yarn ts-node server.ts
```
#### You can see the GraphQL server in action with
[ GraphQL PlayGround ](https://www.electronjs.org/apps/graphql-playground)
[ Insomnia ](https://insomnia.rest/download)
[ Graphiql ](https://github.com/graphql/graphiql)
Also Apollo Server offer a GraphQL Playground open your browser
[ http://localhost:4000 ]( http://localhost:4000 )
### Auto-Generated GraphQL Schema
Main characteristic of Grapi is autogen a GraphQL API with types defined in SDL, the previous schema create the next resolvers.
#### Singular and Plural
```graphql
type Query {
actor( where: ActorWhereUniqueInput ): Actor !
actors( where: ActorWhereInput ): [ Actor ! ] !
}
```
#### Create - Update and Delete
```graphql
type Mutation {
createActor( data: ActorCreateInput ): Actor !
updateActor( where: ActorWhereUniqueInput data: ActorUpdateInput ): Actor !
deleteActor( where: ActorWhereUniqueInput ): Actor !
}
```
These resolvers serve a schema in a GraphQL Server.
Admit retrieve and save data from datasource provided
by Mongo DataSource or your custom data source.
### RelationShip Made Easy
Database relationships are associations between tables.
Grapi support autogen resolvers for queries and mutations in schema relations.
It's easy create a complex server with data relations to retrieve and save data.
Next schema examples shows how to create
different relationship types.
> The ```key``` value in directive ```@Model```
> is the collection name in mongodb
>
> The ```datasource``` value in directive ```@Model```
> is datasource alias defined in Grapi instance into dataSources object.
> That alias is arbitrary and is allow to named as you wish.
> The only condition is that in schema the alias has to be the same
#### One To One Unidirectional
```graphql
# File schema.graphql
type ActorToAddress implements Relation @config(
name: "ActorToAddress"
foreignKey: { key: "city_id", side: Actor }
)
type Actor @Model( dataSource: "datasource", key: "Actor" ) {
id: ID ! @unique
name: String !
address: Address @relation( with: ActorToAddress )
}
type Address @Model( dataSource: "datasource", key: "Address" ) {
id: ID ! @unique
street: String !
location: Json
}
```
#### One To One Bidirectional
```graphql
# File schema.graphql
type ActorToAddress implements Relation @config(
name: "ActorToAddress"
foreignKey: { key: "city_id", side: Actor }
)
type Actor @Model( dataSource: "datasource", key: "Actor" ) {
id: ID ! @unique
name: String !
address: Address @relation( with: ActorToAddress )
}
type Address @Model( dataSource: "datasource", key: "Address" ) {
id: ID ! @unique
street: String !
location: Json
actor: Actor @relation( with: ActorToAddress )
}
```
#### One To Many Bidirectional
```graphql
# File schema.graphql
type VehiclesFromActor implements Relation @config(
name: "VehiclesFromActor"
foreignKey: { key: "owner_car_id" }
)
type Actor @Model( dataSource: "datasource", key: "Actor" ) {
id: ID ! @unique
name: String !
vehicles: [ Vehicle ! ] ! @relation( with: VehiclesFromActor )
}
type Vehicle @Model( dataSource: "datasource", key: "Vehicle" ) {
id: ID ! @unique
trademark: String !
model: String
name: String
owner: Actor @relation( with: VehiclesFromActor )
}
```
#### Many To Many
```graphql
# File schema.graphql
type MoviesFromActorManyToMany implements Relation @config( name: "MoviesFromActorManyToMany" )
type Actor @Model( dataSource: "datasource", key: "Actor" ) {
id: ID ! @unique
name: String !
movies: [ Movie! ] ! @relation( with: MoviesFromActorManyToMany )
}
type Movie @Model( dataSource: "datasource", key: "Movie" ) {
id: ID ! @unique
title: String !
actors: [ Actor ! ] ! @relation( with: MoviesFromActorManyToMany )
}
```
## Supported data-sources
## License
Apache-2.0
With remote love from Colombia