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

Filtering on PostGraphile connections

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.PgConnectionArgFilterAttributesPlugin = void 0;
const utils_1 = require("./utils");
const EXPORTABLE_1 = require("./EXPORTABLE");
const version_1 = require("./version");
const pgConnectionFilterApplyAttribute = (0, EXPORTABLE_1.EXPORTABLE)((isEmpty) => (PgCondition, fieldName, attributeName, attribute, connectionFilterAllowEmptyObjectInput, connectionFilterAllowNullInput, queryBuilder, value) => {
    if (value === undefined) {
        return;
    }
    if (!connectionFilterAllowEmptyObjectInput && isEmpty(value)) {
        throw Object.assign(new Error("Empty objects are forbidden in filter argument input."), {
        //TODO: mark this error as safe
        });
    }
    if (!connectionFilterAllowNullInput && value === null) {
        throw Object.assign(new Error("Null literals are forbidden in filter argument input."), {
        //TODO: mark this error as safe
        });
    }
    const condition = new PgCondition(queryBuilder);
    condition.extensions.pgFilterAttribute = {
        fieldName,
        attributeName,
        attribute,
    };
    return condition;
}, [utils_1.isEmpty], "pgConnectionFilterApplyAttribute");
exports.PgConnectionArgFilterAttributesPlugin = {
    name: "PgConnectionArgFilterAttributesPlugin",
    version: version_1.version,
    schema: {
        entityBehavior: {
            pgCodecAttribute: "attribute:filterBy",
        },
        hooks: {
            GraphQLInputObjectType_fields(inFields, build, context) {
                let fields = inFields;
                const { inflection, connectionFilterOperatorsDigest, dataplanPg: { PgCondition }, EXPORTABLE, } = build;
                const { fieldWithHooks, scope: { pgCodec: rawCodec, isPgConnectionFilter }, } = context;
                if (!isPgConnectionFilter || !rawCodec || !rawCodec.attributes) {
                    return fields;
                }
                const codec = rawCodec;
                for (const [attributeName, attribute] of Object.entries(codec.attributes)) {
                    if (!build.behavior.pgCodecAttributeMatches([codec, attributeName], "attribute:filterBy")) {
                        continue;
                    }
                    const fieldName = inflection.attribute({ codec, attributeName });
                    const digest = connectionFilterOperatorsDigest(attribute.codec);
                    if (!digest) {
                        continue;
                    }
                    const OperatorsType = build.getTypeByName(digest.operatorsTypeName);
                    if (!OperatorsType) {
                        continue;
                    }
                    const { connectionFilterAllowEmptyObjectInput, connectionFilterAllowNullInput, } = build.options;
                    fields = build.extend(fields, {
                        [fieldName]: fieldWithHooks({
                            fieldName,
                            isPgConnectionFilterField: true,
                        }, () => ({
                            description: `Filter by the object’s \`${fieldName}\` field.`,
                            type: OperatorsType,
                            apply: EXPORTABLE((PgCondition, attribute, attributeName, connectionFilterAllowEmptyObjectInput, connectionFilterAllowNullInput, fieldName, pgConnectionFilterApplyAttribute) => function (queryBuilder, value) {
                                return pgConnectionFilterApplyAttribute(PgCondition, fieldName, attributeName, attribute, connectionFilterAllowEmptyObjectInput, connectionFilterAllowNullInput, queryBuilder, value);
                            }, [
                                PgCondition,
                                attribute,
                                attributeName,
                                connectionFilterAllowEmptyObjectInput,
                                connectionFilterAllowNullInput,
                                fieldName,
                                pgConnectionFilterApplyAttribute,
                            ]),
                        })),
                    }, "Adding attribute-based filtering");
                }
                return fields;
            },
        },
    },
};
//# sourceMappingURL=PgConnectionArgFilterAttributesPlugin.js.map