@graphql-ts/schema

TypesSource
Search for an npm package
import { GraphQLScalarType, GraphQLList, GraphQLNonNull, GraphQLInputObjectType, GraphQLEnumType, GraphQLUnionType, GraphQLObjectType, GraphQLInterfaceType, GraphQLInt, GraphQLFloat, GraphQLString, GraphQLBoolean, GraphQLID } from 'graphql';
export { GraphQLEnumType as GEnumType, GraphQLInputObjectType as GInputObjectType, GraphQLInterfaceType as GInterfaceType, GraphQLList as GList, GraphQLNonNull as GNonNull, GraphQLObjectType as GObjectType, GraphQLScalarType as GScalarType, GraphQLUnionType as GUnionType } from 'graphql';
/** @deprecated */
/** @deprecated */
/**
* The `gWithContext` function accepts a `Context` type parameter which binds
* the returned functions so they can be used to compose GraphQL types into a
* GraphQL schema.
*
* A simple schema with only a query type looks like this:
*
* ```ts
* import { gWithContext } from "@graphql-ts/schema";
* import { GraphQLSchema, graphql } from "graphql";
*
* type Context = {};
*
* const g = gWithContext<Context>();
* type g<T> = gWithContext.infer<T>;
*
* const Query = g.object()({
* name: "Query",
* fields: {
* hello: g.field({
* type: g.String,
* resolve() {
* return "Hello!";
* },
* }),
* },
* });
*
* const schema = new GraphQLSchema({
* query: Query,
* });
*
* graphql({
* source: `
* query {
* hello
* }
* `,
* schema,
* }).then((result) => {
* console.log(result);
* });
* ```
*
* You can use pass the `schema` to `ApolloServer` and other GraphQL servers.
*
* You can also create a more advanced schema with other object types, circular
* types, args, and mutations. See {@link GWithContext} for what the other
* functions on `g` do.
*
* ```ts
* import { gWithContext } from "@graphql-ts/schema";
* import { GraphQLSchema, graphql } from "graphql";
* import { deepEqual } from "node:assert";
*
* type Context = {
* todos: Map<string, TodoItem>;
* };
*
* const g = gWithContext<Context>();
* type g<T> = gWithContext.infer<T>;
*
* type TodoItem = {
* id: string;
* title: string;
* relatedTodos: string[];
* };
*
* const Todo: g<typeof g.object<TodoItem>> = g.object<TodoItem>()({
* name: "Todo",
* fields: () => ({
* id: g.field({ type: g.nonNull(g.ID) }),
* title: g.field({ type: g.nonNull(g.String) }),
* relatedTodos: g.field({
* type: g.list(Todo),
* resolve(source, _args, context) {
* return source.relatedTodos
* .map((id) => context.todos.get(id))
* .filter((todo) => todo !== undefined);
* },
* }),
* }),
* });
*
* const Query = g.object()({
* name: "Query",
* fields: {
* todos: g.field({
* type: g.list(Todo),
* resolve(_source, _args, context) {
* return context.todos.values();
* },
* }),
* },
* });
*
* const Mutation = g.object()({
* name: "Mutation",
* fields: {
* createTodo: g.field({
* args: {
* title: g.arg({ type: g.nonNull(g.String) }),
* relatedTodos: g.arg({
* type: g.nonNull(g.list(g.nonNull(g.ID))),
* defaultValue: [],
* }),
* },
* type: Todo,
* resolve(_source, { title, relatedTodos }, context) {
* const todo = { title, relatedTodos, id: crypto.randomUUID() };
* context.todos.set(todo.id, todo);
* return todo;
* },
* }),
* },
* });
*
* const schema = new GraphQLSchema({
* query: Query,
* mutation: Mutation,
* });
*
* (async () => {
* const contextValue: Context = { todos: new Map() };
* {
* const result = await graphql({
* source: `
* query {
* todos {
* title
* }
* }
* `,
* schema,
* contextValue,
* });
* deepEqual(result, { data: { todos: [] } });
* }
*
* {
* const result = await graphql({
* source: `
* mutation {
* createTodo(title: "Try graphql-ts") {
* title
* }
* }
* `,
* schema,
* contextValue,
* });
* deepEqual(result, {
* data: { createTodo: { title: "Try graphql-ts" } },
* });
* }
* {
* const result = await graphql({
* source: `
* query {
* todos {
* title
* }
* }
* `,
* schema,
* contextValue,
* });
* deepEqual(result, {
* data: { todos: [{ title: "Try graphql-ts" }] },
* });
* }
* })();
* ```
*/
function gWithContext() {
return {
scalar(config) {
return new GraphQLScalarType(config);
},
list(of) {
return new GraphQLList(of);
},
nonNull(of) {
return new GraphQLNonNull(of);
},
inputObject(config) {
return new GraphQLInputObjectType(config);
},
enum(config) {
return new GraphQLEnumType(config);
},
union(config) {
return new GraphQLUnionType(config);
},
object() {
return function objectInner(config) {
return new GraphQLObjectType(config);
};
},
interface() {
return function interfaceInner(config) {
return new GraphQLInterfaceType(config);
};
},
fields() {
return function fieldsInner(fields) {
return fields;
};
},
field(field) {
if (!field.type) {
throw new Error("A type must be passed to g.field()");
}
return field;
},
interfaceField(field) {
if (!field.type) {
throw new Error("A type must be passed to g.interfaceField()");
}
return field;
},
arg(arg) {
if (!arg.type) {
throw new Error("A type must be passed to g.arg()");
}
return arg;
},
enumValues(values) {
return Object.fromEntries(values.map(value => [value, {
value
}]));
},
Int: GraphQLInt,
Float: GraphQLFloat,
String: GraphQLString,
Boolean: GraphQLBoolean,
ID: GraphQLID
};
}
// eslint-disable-next-line @typescript-eslint/no-namespace
export { gWithContext };