@graphql-ts/schema

TypesSource
Search for an npm package
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
var graphql = require('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 graphql.GraphQLScalarType(config);
},
list(of) {
return new graphql.GraphQLList(of);
},
nonNull(of) {
return new graphql.GraphQLNonNull(of);
},
inputObject(config) {
return new graphql.GraphQLInputObjectType(config);
},
enum(config) {
return new graphql.GraphQLEnumType(config);
},
union(config) {
return new graphql.GraphQLUnionType(config);
},
object() {
return function objectInner(config) {
return new graphql.GraphQLObjectType(config);
};
},
interface() {
return function interfaceInner(config) {
return new graphql.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: graphql.GraphQLInt,
Float: graphql.GraphQLFloat,
String: graphql.GraphQLString,
Boolean: graphql.GraphQLBoolean,
ID: graphql.GraphQLID
};
}
// eslint-disable-next-line @typescript-eslint/no-namespace
Object.defineProperty(exports, 'GEnumType', {
enumerable: true,
get: function () { return graphql.GraphQLEnumType; }
});
Object.defineProperty(exports, 'GInputObjectType', {
enumerable: true,
get: function () { return graphql.GraphQLInputObjectType; }
});
Object.defineProperty(exports, 'GInterfaceType', {
enumerable: true,
get: function () { return graphql.GraphQLInterfaceType; }
});
Object.defineProperty(exports, 'GList', {
enumerable: true,
get: function () { return graphql.GraphQLList; }
});
Object.defineProperty(exports, 'GNonNull', {
enumerable: true,
get: function () { return graphql.GraphQLNonNull; }
});
Object.defineProperty(exports, 'GObjectType', {
enumerable: true,
get: function () { return graphql.GraphQLObjectType; }
});
Object.defineProperty(exports, 'GScalarType', {
enumerable: true,
get: function () { return graphql.GraphQLScalarType; }
});
Object.defineProperty(exports, 'GUnionType', {
enumerable: true,
get: function () { return graphql.GraphQLUnionType; }
});
exports.gWithContext = gWithContext;