No native modules, iOS pod installs, Android linking, or Expo prebuild steps are required. This is a pure Node.js library.

Project setup

1. Drop the source/ directory into your project, e.g. at src/graphql-compose/.

2. In tsconfig.json, ensure moduleResolution is set to node or bundler and that esModuleInterop is true:

{
  "compilerOptions": {
    "moduleResolution": "node",
    "esModuleInterop": true,
    "strict": true
  }
}

3. If importing directly from source/ rather than the npm package, add a path alias:

{
  "compilerOptions": {
    "paths": {
      "graphql-compose": ["./src/graphql-compose/index.ts"]
    }
  }
}

4. When using the npm package directly (recommended), simply install per the dependencies section and import from graphql-compose. No environment variables are required.

5. Ensure your installed graphql version is compatible (graphql-compose targets graphql v15/v16). Pin a single version to avoid duplicate graphql package issues.

Public API

SchemaComposer

import { SchemaComposer } from 'graphql-compose';
const sc = new SchemaComposer<MyContext>();

The central registry. Create object types, input types, enums, scalars, unions, and interfaces through its create*TC methods. Call sc.buildSchema() to produce a GraphQLSchema. Use the exported schemaComposer singleton for single-schema projects or instantiate your own for multi-schema or test isolation scenarios.

ObjectTypeComposer

import { ObjectTypeComposer, SchemaComposer } from 'graphql-compose';
const sc = new SchemaComposer();
const UserTC: ObjectTypeComposer = sc.createObjectTC({ name: 'User', fields: { id: 'ID!', name: 'String!' } });

Wraps a GraphQLObjectType and exposes methods to add, remove, reorder, and modify fields and arguments, attach interfaces, add Resolvers, and convert the type to an input equivalent. Use when you need to build or modify object output types programmatically.

Resolver

import { Resolver, SchemaComposer } from 'graphql-compose';
const sc = new SchemaComposer();
const findUser = new Resolver({
  name: 'findUser',
  type: 'User',
  args: { id: 'ID!' },
  resolve: async ({ args, context }) => { /* ... */ },
}, sc);

A named, reusable field config that encapsulates type, args, and resolve function. Resolvers can be composed with .wrap(), .wrapResolve(), and middleware chains. Use them to define data-fetching logic separately from the schema shape, then attach to types with UserTC.addResolver(findUser).

InterfaceTypeComposer

import { InterfaceTypeComposer, SchemaComposer } from 'graphql-compose';
const sc = new SchemaComposer();
const NodeITC: InterfaceTypeComposer = sc.createInterfaceTC({ name: 'Node', fields: { id: 'ID!' } });

Wraps GraphQLInterfaceType and supports the same field manipulation API as ObjectTypeComposer. Use when multiple object types share a common field contract.

Working examples

Scenario - Define types and build a schema

Create two related types, wire a query, and build a GraphQLSchema ready to pass to an HTTP server.

import { SchemaComposer } from 'graphql-compose';

const sc = new SchemaComposer();

const PostTC = sc.createObjectTC({
  name: 'Post',
  fields: {
    id: 'ID!',
    title: 'String!',
    body: 'String',
  },
});

const AuthorTC = sc.createObjectTC({
  name: 'Author',
  fields: {
    id: 'ID!',
    name: 'String!',
    posts: { type: () => [PostTC], resolve: (author) => [] },
  },
});

sc.Query.addFields({
  author: {
    type: AuthorTC,
    args: { id: 'ID!' },
    resolve: (_source, { id }) => ({ id, name: 'Alice' }),
  },
});

const schema = sc.buildSchema();
// Pass `schema` to express-graphql, Apollo Server, etc.

Scenario - Use Resolvers with middleware

Define a Resolver, wrap it to add logging, and attach it to a query field.

import { SchemaComposer, Resolver } from 'graphql-compose';

const sc = new SchemaComposer();

const UserTC = sc.createObjectTC({ name: 'User', fields: { id: 'ID!', email: 'String!' } });

const findUserResolver = new Resolver(
  {
    name: 'findUser',
    type: UserTC,
    args: { id: 'ID!' },
    resolve: async ({ args }) => ({ id: args.id, email: 'user@example.com' }),
  },
  sc
);

const loggedResolver = findUserResolver.wrapResolve((next) => async (rp) => {
  console.log('resolving findUser with args', rp.args);
  return next(rp);
});

sc.Query.addFields({ user: loggedResolver.getFieldConfig() });

const schema = sc.buildSchema();

Scenario - Use custom scalar types and enums

Incorporate built-in custom scalars and define an enum type.

import { SchemaComposer, GraphQLDate, GraphQLJSON } from 'graphql-compose';

const sc = new SchemaComposer();

sc.add(GraphQLDate);
sc.add(GraphQLJSON);

const StatusETC = sc.createEnumTC({
  name: 'Status',
  values: {
    ACTIVE: { value: 'active' },
    INACTIVE: { value: 'inactive' },
  },
});

const EventTC = sc.createObjectTC({
  name: 'Event',
  fields: {
    id: 'ID!',
    createdAt: { type: () => sc.get('Date') },
    metadata: { type: () => sc.get('JSON') },
    status: StatusETC,
  },
});

sc.Query.addFields({
  event: { type: EventTC, resolve: () => ({ id: '1', createdAt: new Date(), metadata: {}, status: 'active' }) },
});

const schema = sc.buildSchema();

File walkthrough

• index.ts - Barrel file; re-exports every public class, util, and scalar. Import from here in application code.
• SchemaComposer.ts - Registry for all composers; provides createObjectTC, createInputTC, createEnumTC, buildSchema, and more.
• ObjectTypeComposer.ts - Full CRUD API over a GraphQLObjectType's fields, interfaces, directives, and extensions.
• InputTypeComposer.ts - Same surface as ObjectTypeComposer but for GraphQLInputObjectType.
• InterfaceTypeComposer.ts - Manages interface fields and the set of implementing types.
• UnionTypeComposer.ts - Manages union member types and type-resolver function.
• EnumTypeComposer.ts - Adds/removes/modifies enum values on a GraphQLEnumType.
• ScalarTypeComposer.ts - Thin wrapper over GraphQLScalarType for registry integration.
• Resolver.ts - Encapsulates type + args + resolve; supports wrapping and middleware.
• TypeMapper.ts - Parses SDL strings and type-definition objects into composer instances.
• TypeStorage.ts - Internal Map-backed store keyed by type name or constructor.
• ListComposer.ts - Utility wrapper that marks a composer as a List type.
• NonNullComposer.ts - Utility wrapper that marks a composer as NonNull.
• ThunkComposer.ts - Defers type resolution via thunk to break circular references.
• graphql.ts - Centralised re-export of graphql peer dependency to avoid version splits.
• type/ - Contains GraphQLDate, GraphQLBuffer, GraphQLJSON, GraphQLJSONObject scalar implementations.
• utils/ - Internal helpers: projection parsing, schema printing, type path traversal, deep merge, pluralize, dedent, and more.
• __mocks__/ - Jest mock of SchemaComposer for unit tests.

Common pitfalls and fixes

• Duplicate graphql installations: if graphql appears in both your dependencies and a subdependency with a different version, type guards like isObjectType will fail silently. Fix: add a resolutions or overrides field in package.json to force a single version.
• Circular type references cause undefined at runtime: wrap cross-referencing field types in thunk functions (() => OtherTC) so resolution is deferred until the schema is built.
• sc.buildSchema() throws "Query type must be provided": you must add at least one field to sc.Query before calling buildSchema().
• ESM/CJS interop issues: graphql-type-json is a CJS package; ensure esModuleInterop: true in tsconfig.json and that your bundler/runner supports CJS interop.
• Custom scalars not found by name: after creating a custom scalar, call sc.add(GraphQLDate) explicitly so it registers under its name in the composer registry before referencing it by string.
• TypeScript strict mode errors on schemaComposer singleton: the exported schemaComposer is typed SchemaComposer<any>; create a typed instance (new SchemaComposer<MyContext>()) for full context type safety.

Vibe-coding prompt template

I have a copy of the graphql-compose library source in `source/` and a USAGE.md
integration guide. The upstream npm package is `graphql-compose`.

Please integrate graphql-compose into my existing TypeScript/Node.js project by
doing the following step by step:

1. Read `USAGE.md` and `source/index.ts` to understand all available exports.
2. Install required dependencies as listed in USAGE.md.
3. Create a `src/schema/index.ts` file that instantiates a `SchemaComposer`,
   defines at least one ObjectTypeComposer with fields, wires it to the Query
   type, and exports the built `GraphQLSchema`.
4. If I describe any custom types, enums, or resolvers, add them using the
   real APIs from `source/ObjectTypeComposer.ts`, `source/Resolver.ts`,
   and `source/EnumTypeComposer.ts` as shown in USAGE.md examples.
5. Add a Resolver with a `.wrapResolve()` middleware for logging.
6. Ensure `tsconfig.json` has `esModuleInterop: true` and `moduleResolution: node`.
7. Point out any circular reference risks and wrap those fields in thunks.
8. Do not invent any API methods - only use exports visible in `source/index.ts`
   and documented in USAGE.md.

License and credit

graphql-compose is published under the MIT License. See the upstream repository and source/LICENSE if present for the full license text. Upstream package: graphql-compose by the graphql-compose contributors.

This product’s unique contribution is clean room implementation of valuable code block into AVCP compatible standard.

The full install guide and integration prompts unlock after purchase.

GraphQL Tools: Schema Building and Transformation Toolkit

Automation, Utilities & Developer Tools

Free