GraphQL Loom

Weaving
runtime typesValibot typesZod typesYup typesDrizzle TablePrisma ModelMikro ORM Entity
into GraphQL Schema
Star on GitHubGetting Started

The most familiar Schema Library

import { , ,  } from "@gqloom/core"
import {  } from "@gqloom/valibot"
import * as  from "valibot"
 
const  = .({
  : .(.("Giraffe")),
  : .(.(), .("The giraffe's name")),
  : .(),
})
 
const  = .(, {
  : (.(.(), .()))
    .({
      : .(
        .(.(), () => new ().()),
        .(() => new ())
      ),
    })
    .((, {  }) => {
      return .() - ..()
    }),
})
 
export const  = (, )
schema.graphql
type Giraffe {
  """The giraffe's name"""
  name: String!
  birthday: String!
  age(currentDate: String): Int!
}
  • 🧩

    Rich Integration

    Use your most familiar validation libraries and ORMs to build your next GraphQL application.

  • 🔒

    Type Safety

    Automatically infer types from the Schema, enjoy intelligent code completion during development, and detect potential problems during compilation.

  • 🔋

    Fully Prepared

    Middleware, context, subscriptions, and federated graphs are ready.

  • 🔮

    No Magic

    Without decorators, metadata, reflection, or code generation, it can run anywhere with just JavaScript/TypeScript.

  • 🧑‍💻

    Development Experience

    Fewer boilerplate codes, semantic API design, and extensive ecosystem integration make development enjoyable.

Full Featured GraphQL

Resolver

Resolvers are the core components of GraphQL. You can define query, mutation, and subscription operations within them, and also dynamically add additional fields to objects for flexible data processing.

Context

With the context mechanism, you can conveniently inject data anywhere in the application, ensuring efficient data flow between different components and layers.

Middleware

Adopting the concept of aspect - oriented programming, middleware allows you to seamlessly integrate additional logic during the resolution process, such as error handling, user permission verification, and log tracking, enhancing the robustness and maintainability of the system.

Dataloader

Dataloader is a powerful tool for optimizing performance. It can fetch data in batches, significantly reducing the number of database queries, effectively improving system performance, and making the code structure clearer and easier to maintain.

Subscription

The subscription feature provides clients with the ability to obtain real - time data updates without manual polling, ensuring that clients always stay in sync with server data and enhancing the user experience.

Federation

Federation is a microservice - based GraphQL architecture that can easily aggregate multiple services to enable cross - service queries, allowing you to manage complex distributed systems as if operating on a single graph.

CRUD interfaces are ready for activation

Create CRUD operations using defined database models from Drizzle, MikroORM, Prisma with ResolverFactory.

  • Like a skilled weaver, embed precisely defined database tables seamlessly into the GraphQL Schema.
  • With just a few lines of code, easily build a CRUD system and enjoy ORM's convenience.
  • Both resolvers and single operations can be customized with inputs and middleware to meet diverse needs.
  • Using a flexible approach, freely combine resolvers and add operations to the graph for endless potential.
src/index.ts
import {  } from "node:http"
import {  } from "@gqloom/core"
import {  } from "@gqloom/drizzle"
import {  } from "drizzle-orm/node-postgres"
import {  } from "graphql-yoga"
import * as  from "./schema"
 
const  = (..!, { :  })
 
const  = (, "users").()
const  = (, "posts").()
 
const  = (, )
 
const  = ({  })
const  = ()
.(4000, () => {
  .("Server is running on http://localhost:4000/graphql")
})

Full Power of GraphQL

  • 🔐

    Type Safety

    Strong type system to ensure the consistency and security of data from the server to the client.

  • 🧩

    Flexible Aggregation

    Automatically aggregate multiple queries, reducing the number of client requests and ensuring the simplicity of the server-side API.

  • 🚀

    Efficient Querying

    The client can specify the required data structure, reducing unnecessary data transfer and improving the performance and maintainability of the API.

  • 🔌

    Easy to Extend

    Extending the API by adding new fields and types without modifying existing code.

  • 👥

    Efficient Collaboration

    Using Schema as documentation, which can reduce communication costs and improve development efficiency in team development.

  • 🌳

    Thriving Ecosystem

    Tools and frameworks are emerging constantly. The active community, with diverse applications, is growing fast and has bright prospects.