gqtx/cjs/relay.js

'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

function createRelayHelpers(t) {
    function nodeDefinitions(idFetcher) {
        const nodeInterface = t.interfaceType({
            name: 'Node',
            description: 'An object with an ID',
            fields: () => [
                t.abstractField('id', t.NonNull(t.ID), {
                    description: 'The id of the object.',
                }),
            ],
        });
        const nodeField = t.field('node', {
            type: nodeInterface,
            args: {
                id: t.arg(t.NonNullInput(t.ID), 'The ID of an object'),
            },
            resolve: (_src, { id }, context, info) => idFetcher(id, context, info),
        });
        return { nodeInterface, nodeField };
    }
    const forwardConnectionArgs = {
        after: t.arg(t.String),
        first: t.arg(t.Int),
    };
    const backwardConnectionArgs = {
        before: t.arg(t.String),
        last: t.arg(t.Int),
    };
    const connectionArgs = {
        ...forwardConnectionArgs,
        ...backwardConnectionArgs,
    };
    const pageInfoType = t.objectType({
        name: 'PageInfo',
        description: 'Information about pagination in a connection.',
        fields: () => [
            t.defaultField('hasNextPage', t.NonNull(t.Boolean), {
                description: 'When paginating forwards, are there more items?',
            }),
            t.defaultField('hasPreviousPage', t.NonNull(t.Boolean), {
                description: 'When paginating backwards, are there more items?',
            }),
            t.defaultField('startCursor', t.String, {
                description: 'When paginating backwards, the cursor to continue.',
            }),
            t.defaultField('endCursor', t.String, {
                description: 'When paginating forwards, the cursor to continue.',
            }),
        ],
    });
    /**
     * Returns ObjectTypes for a connection with the given name,
     * and whose nodes are of the specified type.
     */
    function connectionDefinitions(config) {
        const { nodeType } = config;
        const name = config.name || nodeType.name;
        // TODO
        const edgeFields = config.edgeFields || (() => []);
        const connectionFields = config.connectionFields || (() => []);
        const edgeType = t.objectType({
            name: name + 'Edge',
            description: 'An edge in a connection.',
            fields: () => [
                t.defaultField('node', t.NonNull(nodeType), {
                    description: 'The item at the end of the edge',
                }),
                t.defaultField('cursor', t.NonNull(t.String), {
                    description: 'A cursor for use in pagination',
                }),
                ...edgeFields(),
            ],
        });
        const connectionType = t.objectType({
            name: name + 'Connection',
            description: 'A connection to a list of items.',
            fields: () => [
                t.defaultField('pageInfo', t.NonNull(pageInfoType), {
                    description: 'Information to aid in pagination.',
                }),
                t.defaultField('edges', t.List(edgeType), {
                    description: 'A list of edges.',
                }),
                ...connectionFields(),
            ],
        });
        return { edgeType, connectionType };
    }
    return {
        nodeDefinitions,
        forwardConnectionArgs,
        backwardConnectionArgs,
        connectionArgs,
        pageInfoType,
        connectionDefinitions,
    };
}

exports.createRelayHelpers = createRelayHelpers;