graphql-compose-connection/lib/types/connectionType.js

Plugin for `graphql-compose` which provide a connection resolver for types.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.prepareConnectionType = exports.prepareEdgeType = exports.preparePageInfoType = void 0;
const graphql_compose_1 = require("graphql-compose");
const globalPageInfoTypes = {};
function createGlobalPageInfoType(name) {
    if (!globalPageInfoTypes[name]) {
        globalPageInfoTypes[name] = graphql_compose_1.ObjectTypeComposer.createTemp(`
      """Information about pagination in a connection."""
      type ${name} {
        """When paginating forwards, are there more items?"""
        hasNextPage: Boolean!
        
        """When paginating backwards, are there more items?"""
        hasPreviousPage: Boolean!

        """When paginating backwards, the cursor to continue."""
        startCursor: String

        """When paginating forwards, the cursor to continue."""
        endCursor: String
      }
    `);
    }
    return globalPageInfoTypes[name];
}
function preparePageInfoType(schemaComposer, name = 'PageInfo') {
    if (schemaComposer.has(name)) {
        return schemaComposer.getOTC(name);
    }
    const tc = createGlobalPageInfoType(name);
    schemaComposer.set(name, tc);
    return tc;
}
exports.preparePageInfoType = preparePageInfoType;
function prepareEdgeType(nodeTypeComposer, edgeTypeName, edgeFields) {
    const name = edgeTypeName || `${nodeTypeComposer.getTypeName()}Edge`;
    if (nodeTypeComposer.schemaComposer.has(name)) {
        return nodeTypeComposer.schemaComposer.getOTC(name);
    }
    const edgeType = nodeTypeComposer.schemaComposer.createObjectTC({
        name,
        description: 'An edge in a connection.',
        fields: Object.assign(Object.assign({}, edgeFields), { node: {
                type: new graphql_compose_1.NonNullComposer(nodeTypeComposer),
                description: 'The item at the end of the edge',
            }, cursor: {
                type: 'String!',
                description: 'A cursor for use in pagination',
            } }),
    });
    return edgeType;
}
exports.prepareEdgeType = prepareEdgeType;
function prepareConnectionType(typeComposer, resolverName, edgeTypeName, edgeFields) {
    const name = `${typeComposer.getTypeName()}${graphql_compose_1.upperFirst(resolverName || 'connection')}`;
    if (typeComposer.schemaComposer.has(name)) {
        return typeComposer.schemaComposer.getOTC(name);
    }
    const connectionType = typeComposer.schemaComposer.createObjectTC({
        name,
        description: 'A connection to a list of items.',
        fields: {
            count: {
                type: 'Int!',
                description: 'Total object count.',
            },
            pageInfo: {
                type: new graphql_compose_1.NonNullComposer(preparePageInfoType(typeComposer.schemaComposer)),
                description: 'Information to aid in pagination.',
            },
            edges: {
                type: new graphql_compose_1.NonNullComposer(new graphql_compose_1.ListComposer(new graphql_compose_1.NonNullComposer(prepareEdgeType(typeComposer, edgeTypeName, edgeFields)))),
                description: 'Information to aid in pagination.',
            },
        },
    });
    return connectionType;
}
exports.prepareConnectionType = prepareConnectionType;
//# sourceMappingURL=connectionType.js.map