postgraphile-plugin-connection-filter/dist/AddConnectionFilterOperatorPlugin.js

Filtering on PostGraphile connections

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.AddConnectionFilterOperatorPlugin = void 0;
const interfaces_1 = require("./interfaces");
const PgConnectionArgFilterOperatorsPlugin_1 = require("./PgConnectionArgFilterOperatorsPlugin");
const version_1 = require("./version");
exports.AddConnectionFilterOperatorPlugin = {
    name: "AddConnectionFilterOperatorPlugin",
    version: version_1.version,
    schema: {
        hooks: {
            build(build) {
                const { inflection } = build;
                build[interfaces_1.$$filters] = new Map();
                build.addConnectionFilterOperator = (typeNameOrNames, filterName, spec) => {
                    if (!build.status.isBuildPhaseComplete ||
                        build.status.isInitPhaseComplete) {
                        throw new Error(`addConnectionFilterOperator may only be called during the 'init' phase`);
                    }
                    const typeNames = Array.isArray(typeNameOrNames)
                        ? typeNameOrNames
                        : [typeNameOrNames];
                    for (const typeName of typeNames) {
                        const filterTypeName = inflection.filterType(typeName);
                        let operatorSpecByFilterName = build[interfaces_1.$$filters].get(filterTypeName);
                        if (!operatorSpecByFilterName) {
                            operatorSpecByFilterName = new Map();
                            build[interfaces_1.$$filters].set(filterTypeName, operatorSpecByFilterName);
                        }
                        if (operatorSpecByFilterName.has(filterName)) {
                            throw new Error(`Filter '${filterName}' already registered on '${filterTypeName}'`);
                        }
                        operatorSpecByFilterName.set(filterName, spec);
                    }
                };
                return build;
            },
            GraphQLInputObjectType_fields(inFields, build, context) {
                let fields = inFields;
                const { scope: { pgConnectionFilterOperators }, Self, fieldWithHooks, } = context;
                if (!pgConnectionFilterOperators) {
                    return fields;
                }
                const operatorSpecByFilterName = build[interfaces_1.$$filters].get(Self.name);
                if (!operatorSpecByFilterName) {
                    return fields;
                }
                const { inputTypeName, rangeElementInputTypeName } = pgConnectionFilterOperators;
                const rangeElementInputType = rangeElementInputTypeName
                    ? build.getTypeByName(rangeElementInputTypeName)
                    : null;
                const fieldInputType = build.getTypeByName(inputTypeName);
                if (!fieldInputType) {
                    return fields;
                }
                for (const [filterName, spec] of operatorSpecByFilterName.entries()) {
                    const { description, resolveInputCodec, resolveType } = spec;
                    const firstCodec = pgConnectionFilterOperators.pgCodecs[0];
                    const inputCodec = resolveInputCodec
                        ? resolveInputCodec(firstCodec)
                        : firstCodec;
                    const codecGraphQLType = build.getGraphQLTypeByPgCodec(inputCodec, "input");
                    if (!codecGraphQLType) {
                        continue;
                    }
                    const type = resolveType
                        ? resolveType(codecGraphQLType)
                        : codecGraphQLType;
                    fields = build.extend(fields, {
                        [filterName]: fieldWithHooks({
                            fieldName: filterName,
                            isPgConnectionFilterOperator: true,
                        }, {
                            description,
                            type,
                            apply: (0, PgConnectionArgFilterOperatorsPlugin_1.makeApplyFromOperatorSpec)(build, Self.name, filterName, spec, type),
                        }),
                    }, "");
                }
                return fields;
            },
        },
    },
};
//# sourceMappingURL=AddConnectionFilterOperatorPlugin.js.map