graphile-plugin-connection-filter 2.3.1

package/ConnectionArgFilterPlugin.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from 'graphile-build';
+declare const ConnectionArgFilterPlugin: Plugin;
+export default ConnectionArgFilterPlugin;

package/ConnectionArgFilterPlugin.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ConnectionArgFilterPlugin = (builder) => {
+    builder.hook('inflection', (inflection) => {
+        return Object.assign(inflection, {
+            filterType(typeName) {
+                return `${typeName}Filter`;
+            },
+            filterFieldType(typeName) {
+                return `${typeName}Filter`;
+            },
+            filterFieldListType(typeName) {
+                return `${typeName}ListFilter`;
+            },
+        });
+    });
+};
+exports.default = ConnectionArgFilterPlugin;

package/LICENSE

@@ -0,0 +1,23 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Dan Lynch <pyramation@gmail.com>
+Copyright (c) 2025 Hyperweb <developers@hyperweb.io>
+Copyright (c) 2020-present, Interweb, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/PgConnectionArgFilterBackwardRelationsPlugin.d.ts

@@ -0,0 +1,12 @@
+import type { Plugin } from 'graphile-build';
+import type { PgAttribute, PgClass, PgConstraint } from 'graphile-build-pg';
+declare const PgConnectionArgFilterBackwardRelationsPlugin: Plugin;
+export interface BackwardRelationSpec {
+    table: PgClass;
+    keyAttributes: PgAttribute[];
+    foreignTable: PgClass;
+    foreignKeyAttributes: PgAttribute[];
+    foreignConstraint: PgConstraint;
+    isOneToMany: boolean;
+}
+export default PgConnectionArgFilterBackwardRelationsPlugin;

package/PgConnectionArgFilterBackwardRelationsPlugin.js

@@ -0,0 +1,244 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const PgConnectionArgFilterBackwardRelationsPlugin = (builder, rawOptions) => {
+    const { pgSimpleCollections, pgOmitListSuffix, connectionFilterUseListInflectors, } = rawOptions;
+    const hasConnections = pgSimpleCollections !== 'only';
+    const simpleInflectorsAreShorter = pgOmitListSuffix === true;
+    if (simpleInflectorsAreShorter &&
+        connectionFilterUseListInflectors === undefined) {
+        // TODO: in V3 consider doing this for the user automatically (doing it in V2 would be a breaking change)
+        console.warn(`We recommend you set the 'connectionFilterUseListInflectors' option to 'true' since you've set the 'pgOmitListSuffix' option`);
+    }
+    const useConnectionInflectors = connectionFilterUseListInflectors === undefined
+        ? hasConnections
+        : !connectionFilterUseListInflectors;
+    builder.hook('inflection', (inflection) => {
+        return Object.assign(inflection, {
+            filterManyType(table, foreignTable) {
+                return this.upperCamelCase(`${this.tableType(table)}-to-many-${this.tableType(foreignTable)}-filter`);
+            },
+            filterBackwardSingleRelationExistsFieldName(relationFieldName) {
+                return `${relationFieldName}Exists`;
+            },
+            filterBackwardManyRelationExistsFieldName(relationFieldName) {
+                return `${relationFieldName}Exist`;
+            },
+            filterSingleRelationByKeysBackwardsFieldName(fieldName) {
+                return fieldName;
+            },
+            filterManyRelationByKeysFieldName(fieldName) {
+                return fieldName;
+            },
+        });
+    });
+    builder.hook('GraphQLInputObjectType:fields', (fields, build, context) => {
+        const { describePgEntity, extend, newWithHooks, inflection, pgOmit: omit, pgSql: sql, pgIntrospectionResultsByKind: introspectionResultsByKind, graphql: { GraphQLInputObjectType, GraphQLBoolean }, connectionFilterResolve, connectionFilterRegisterResolver, connectionFilterTypesByTypeName, connectionFilterType, } = build;
+        const { fieldWithHooks, scope: { pgIntrospection: table, isPgConnectionFilter }, Self, } = context;
+        if (!isPgConnectionFilter || table.kind !== 'class')
+            return fields;
+        connectionFilterTypesByTypeName[Self.name] = Self;
+        const backwardRelationSpecs = introspectionResultsByKind.constraint
+            .filter((con) => con.type === 'f')
+            .filter((con) => con.foreignClassId === table.id)
+            .reduce((memo, foreignConstraint) => {
+            if (omit(foreignConstraint, 'read') ||
+                omit(foreignConstraint, 'filter')) {
+                return memo;
+            }
+            const foreignTable = introspectionResultsByKind.classById[foreignConstraint.classId];
+            if (!foreignTable) {
+                throw new Error(`Could not find the foreign table (constraint: ${foreignConstraint.name})`);
+            }
+            if (omit(foreignTable, 'read') || omit(foreignTable, 'filter')) {
+                return memo;
+            }
+            const attributes = introspectionResultsByKind.attribute
+                .filter((attr) => attr.classId === table.id)
+                .sort((a, b) => a.num - b.num);
+            const foreignAttributes = introspectionResultsByKind.attribute
+                .filter((attr) => attr.classId === foreignTable.id)
+                .sort((a, b) => a.num - b.num);
+            const keyAttributes = foreignConstraint.foreignKeyAttributeNums.map((num) => attributes.filter((attr) => attr.num === num)[0]);
+            const foreignKeyAttributes = foreignConstraint.keyAttributeNums.map((num) => foreignAttributes.filter((attr) => attr.num === num)[0]);
+            if (keyAttributes.some((attr) => omit(attr, 'read'))) {
+                return memo;
+            }
+            if (foreignKeyAttributes.some((attr) => omit(attr, 'read'))) {
+                return memo;
+            }
+            const isForeignKeyUnique = !!introspectionResultsByKind.constraint.find((c) => c.classId === foreignTable.id &&
+                (c.type === 'p' || c.type === 'u') &&
+                c.keyAttributeNums.length === foreignKeyAttributes.length &&
+                c.keyAttributeNums.every((n, i) => foreignKeyAttributes[i].num === n));
+            memo.push({
+                table,
+                keyAttributes,
+                foreignTable,
+                foreignKeyAttributes,
+                foreignConstraint,
+                isOneToMany: !isForeignKeyUnique,
+            });
+            return memo;
+        }, []);
+        let backwardRelationSpecByFieldName = {};
+        const addField = (fieldName, description, type, resolve, spec, hint) => {
+            // Field
+            fields = extend(fields, {
+                [fieldName]: fieldWithHooks(fieldName, {
+                    description,
+                    type,
+                }, {
+                    isPgConnectionFilterField: true,
+                }),
+            }, hint);
+            // Relation spec for use in resolver
+            backwardRelationSpecByFieldName = extend(backwardRelationSpecByFieldName, {
+                [fieldName]: spec,
+            });
+            // Resolver
+            connectionFilterRegisterResolver(Self.name, fieldName, resolve);
+        };
+        const resolveSingle = ({ sourceAlias, fieldName, fieldValue, queryBuilder, }) => {
+            if (fieldValue == null)
+                return null;
+            const { foreignTable, foreignKeyAttributes, keyAttributes } = backwardRelationSpecByFieldName[fieldName];
+            const foreignTableTypeName = inflection.tableType(foreignTable);
+            const foreignTableAlias = sql.identifier(Symbol());
+            const foreignTableFilterTypeName = inflection.filterType(foreignTableTypeName);
+            const sqlIdentifier = sql.identifier(foreignTable.namespace.name, foreignTable.name);
+            const sqlKeysMatch = sql.query `(${sql.join(foreignKeyAttributes.map((attr, i) => {
+                return sql.fragment `${foreignTableAlias}.${sql.identifier(attr.name)} = ${sourceAlias}.${sql.identifier(keyAttributes[i].name)}`;
+            }), ') and (')})`;
+            const sqlSelectWhereKeysMatch = sql.query `select 1 from ${sqlIdentifier} as ${foreignTableAlias} where ${sqlKeysMatch}`;
+            const sqlFragment = connectionFilterResolve(fieldValue, foreignTableAlias, foreignTableFilterTypeName, queryBuilder);
+            return sqlFragment == null
+                ? null
+                : sql.query `exists(${sqlSelectWhereKeysMatch} and (${sqlFragment}))`;
+        };
+        const resolveExists = ({ sourceAlias, fieldName, fieldValue, }) => {
+            if (fieldValue == null)
+                return null;
+            const { foreignTable, foreignKeyAttributes, keyAttributes } = backwardRelationSpecByFieldName[fieldName];
+            const foreignTableAlias = sql.identifier(Symbol());
+            const sqlIdentifier = sql.identifier(foreignTable.namespace.name, foreignTable.name);
+            const sqlKeysMatch = sql.query `(${sql.join(foreignKeyAttributes.map((attr, i) => {
+                return sql.fragment `${foreignTableAlias}.${sql.identifier(attr.name)} = ${sourceAlias}.${sql.identifier(keyAttributes[i].name)}`;
+            }), ') and (')})`;
+            const sqlSelectWhereKeysMatch = sql.query `select 1 from ${sqlIdentifier} as ${foreignTableAlias} where ${sqlKeysMatch}`;
+            return fieldValue === true
+                ? sql.query `exists(${sqlSelectWhereKeysMatch})`
+                : sql.query `not exists(${sqlSelectWhereKeysMatch})`;
+        };
+        const makeResolveMany = (backwardRelationSpec) => {
+            const resolveMany = ({ sourceAlias, fieldName, fieldValue, queryBuilder, }) => {
+                if (fieldValue == null)
+                    return null;
+                const { foreignTable } = backwardRelationSpecByFieldName[fieldName];
+                const foreignTableFilterManyTypeName = inflection.filterManyType(table, foreignTable);
+                const sqlFragment = connectionFilterResolve(fieldValue, sourceAlias, foreignTableFilterManyTypeName, queryBuilder, null, null, null, { backwardRelationSpec });
+                return sqlFragment == null ? null : sqlFragment;
+            };
+            return resolveMany;
+        };
+        for (const spec of backwardRelationSpecs) {
+            const { foreignTable, foreignKeyAttributes, foreignConstraint, isOneToMany, } = spec;
+            const foreignTableTypeName = inflection.tableType(foreignTable);
+            const foreignTableFilterTypeName = inflection.filterType(foreignTableTypeName);
+            const ForeignTableFilterType = connectionFilterType(newWithHooks, foreignTableFilterTypeName, foreignTable, foreignTableTypeName);
+            if (!ForeignTableFilterType)
+                continue;
+            if (isOneToMany) {
+                if (!omit(foreignTable, 'many')) {
+                    const filterManyTypeName = inflection.filterManyType(table, foreignTable);
+                    if (!connectionFilterTypesByTypeName[filterManyTypeName]) {
+                        connectionFilterTypesByTypeName[filterManyTypeName] = newWithHooks(GraphQLInputObjectType, {
+                            name: filterManyTypeName,
+                            description: `A filter to be used against many \`${foreignTableTypeName}\` object types. All fields are combined with a logical ‘and.’`,
+                        }, {
+                            foreignTable,
+                            isPgConnectionFilterMany: true,
+                        });
+                    }
+                    const FilterManyType = connectionFilterTypesByTypeName[filterManyTypeName];
+                    const fieldName = useConnectionInflectors
+                        ? inflection.manyRelationByKeys(foreignKeyAttributes, foreignTable, table, foreignConstraint)
+                        : inflection.manyRelationByKeysSimple(foreignKeyAttributes, foreignTable, table, foreignConstraint);
+                    const filterFieldName = inflection.filterManyRelationByKeysFieldName(fieldName);
+                    addField(filterFieldName, `Filter by the object’s \`${fieldName}\` relation.`, FilterManyType, makeResolveMany(spec), spec, `Adding connection filter backward relation field from ${describePgEntity(table)} to ${describePgEntity(foreignTable)}`);
+                    const existsFieldName = inflection.filterBackwardManyRelationExistsFieldName(fieldName);
+                    addField(existsFieldName, `Some related \`${fieldName}\` exist.`, GraphQLBoolean, resolveExists, spec, `Adding connection filter backward relation exists field from ${describePgEntity(table)} to ${describePgEntity(foreignTable)}`);
+                }
+            }
+            else {
+                const fieldName = inflection.singleRelationByKeysBackwards(foreignKeyAttributes, foreignTable, table, foreignConstraint);
+                const filterFieldName = inflection.filterSingleRelationByKeysBackwardsFieldName(fieldName);
+                addField(filterFieldName, `Filter by the object’s \`${fieldName}\` relation.`, ForeignTableFilterType, resolveSingle, spec, `Adding connection filter backward relation field from ${describePgEntity(table)} to ${describePgEntity(foreignTable)}`);
+                const existsFieldName = inflection.filterBackwardSingleRelationExistsFieldName(fieldName);
+                addField(existsFieldName, `A related \`${fieldName}\` exists.`, GraphQLBoolean, resolveExists, spec, `Adding connection filter backward relation exists field from ${describePgEntity(table)} to ${describePgEntity(foreignTable)}`);
+            }
+        }
+        return fields;
+    });
+    builder.hook('GraphQLInputObjectType:fields', (fields, build, context) => {
+        const { extend, newWithHooks, inflection, pgSql: sql, connectionFilterResolve, connectionFilterRegisterResolver, connectionFilterTypesByTypeName, connectionFilterType, } = build;
+        const { fieldWithHooks, scope: { foreignTable, isPgConnectionFilterMany }, Self, } = context;
+        if (!isPgConnectionFilterMany || !foreignTable)
+            return fields;
+        connectionFilterTypesByTypeName[Self.name] = Self;
+        const foreignTableTypeName = inflection.tableType(foreignTable);
+        const foreignTableFilterTypeName = inflection.filterType(foreignTableTypeName);
+        const FilterType = connectionFilterType(newWithHooks, foreignTableFilterTypeName, foreignTable, foreignTableTypeName);
+        const manyFields = {
+            every: fieldWithHooks('every', {
+                description: `Every related \`${foreignTableTypeName}\` matches the filter criteria. All fields are combined with a logical ‘and.’`,
+                type: FilterType,
+            }, {
+                isPgConnectionFilterManyField: true,
+            }),
+            some: fieldWithHooks('some', {
+                description: `Some related \`${foreignTableTypeName}\` matches the filter criteria. All fields are combined with a logical ‘and.’`,
+                type: FilterType,
+            }, {
+                isPgConnectionFilterManyField: true,
+            }),
+            none: fieldWithHooks('none', {
+                description: `No related \`${foreignTableTypeName}\` matches the filter criteria. All fields are combined with a logical ‘and.’`,
+                type: FilterType,
+            }, {
+                isPgConnectionFilterManyField: true,
+            }),
+        };
+        const resolve = ({ sourceAlias, fieldName, fieldValue, queryBuilder, parentFieldInfo, }) => {
+            if (fieldValue == null)
+                return null;
+            if (!parentFieldInfo || !parentFieldInfo.backwardRelationSpec)
+                throw new Error('Did not receive backward relation spec');
+            const { keyAttributes, foreignKeyAttributes } = parentFieldInfo.backwardRelationSpec;
+            const foreignTableAlias = sql.identifier(Symbol());
+            const sqlIdentifier = sql.identifier(foreignTable.namespace.name, foreignTable.name);
+            const sqlKeysMatch = sql.query `(${sql.join(foreignKeyAttributes.map((attr, i) => {
+                return sql.fragment `${foreignTableAlias}.${sql.identifier(attr.name)} = ${sourceAlias}.${sql.identifier(keyAttributes[i].name)}`;
+            }), ') and (')})`;
+            const sqlSelectWhereKeysMatch = sql.query `select 1 from ${sqlIdentifier} as ${foreignTableAlias} where ${sqlKeysMatch}`;
+            const sqlFragment = connectionFilterResolve(fieldValue, foreignTableAlias, foreignTableFilterTypeName, queryBuilder);
+            if (sqlFragment == null) {
+                return null;
+            }
+            else if (fieldName === 'every') {
+                return sql.query `not exists(${sqlSelectWhereKeysMatch} and not (${sqlFragment}))`;
+            }
+            else if (fieldName === 'some') {
+                return sql.query `exists(${sqlSelectWhereKeysMatch} and (${sqlFragment}))`;
+            }
+            else if (fieldName === 'none') {
+                return sql.query `not exists(${sqlSelectWhereKeysMatch} and (${sqlFragment}))`;
+            }
+            throw new Error(`Unknown field name: ${fieldName}`);
+        };
+        for (const fieldName of Object.keys(manyFields)) {
+            connectionFilterRegisterResolver(Self.name, fieldName, resolve);
+        }
+        return extend(fields, manyFields);
+    });
+};
+exports.default = PgConnectionArgFilterBackwardRelationsPlugin;

package/PgConnectionArgFilterColumnsPlugin.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from 'graphile-build';
+declare const PgConnectionArgFilterColumnsPlugin: Plugin;
+export default PgConnectionArgFilterColumnsPlugin;

package/PgConnectionArgFilterColumnsPlugin.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const PgConnectionArgFilterColumnsPlugin = (builder) => {
+    builder.hook('GraphQLInputObjectType:fields', (fields, build, context) => {
+        const { extend, newWithHooks, pgSql: sql, pgIntrospectionResultsByKind: introspectionResultsByKind, pgColumnFilter, pgOmit: omit, inflection, connectionFilterOperatorsType, connectionFilterRegisterResolver, connectionFilterResolve, connectionFilterTypesByTypeName, } = build;
+        const { fieldWithHooks, scope: { pgIntrospection: table, isPgConnectionFilter }, Self, } = context;
+        if (!isPgConnectionFilter || table.kind !== 'class')
+            return fields;
+        connectionFilterTypesByTypeName[Self.name] = Self;
+        const attrByFieldName = introspectionResultsByKind.attribute
+            .filter((attr) => attr.classId === table.id)
+            .filter((attr) => pgColumnFilter(attr, build, context))
+            .filter((attr) => !omit(attr, 'filter'))
+            .reduce((memo, attr) => {
+            const fieldName = inflection.column(attr);
+            memo[fieldName] = attr;
+            return memo;
+        }, {});
+        const operatorsTypeNameByFieldName = {};
+        const attrFields = Object.entries(attrByFieldName).reduce((memo, [fieldName, attr]) => {
+            const OperatorsType = connectionFilterOperatorsType(newWithHooks, attr.typeId, attr.typeModifier);
+            if (!OperatorsType) {
+                return memo;
+            }
+            operatorsTypeNameByFieldName[fieldName] = OperatorsType.name;
+            return extend(memo, {
+                [fieldName]: fieldWithHooks(fieldName, {
+                    description: `Filter by the object’s \`${fieldName}\` field.`,
+                    type: OperatorsType,
+                }, {
+                    isPgConnectionFilterField: true,
+                }),
+            });
+        }, {});
+        const resolve = ({ sourceAlias, fieldName, fieldValue, queryBuilder, }) => {
+            if (fieldValue == null)
+                return null;
+            const attr = attrByFieldName[fieldName];
+            const sqlIdentifier = sql.query `${sourceAlias}.${sql.identifier(attr.name)}`;
+            const pgType = attr.type;
+            const pgTypeModifier = attr.typeModifier;
+            const filterTypeName = operatorsTypeNameByFieldName[fieldName];
+            return connectionFilterResolve(fieldValue, sqlIdentifier, filterTypeName, queryBuilder, pgType, pgTypeModifier, fieldName);
+        };
+        for (const fieldName of Object.keys(attrFields)) {
+            connectionFilterRegisterResolver(Self.name, fieldName, resolve);
+        }
+        return extend(fields, attrFields);
+    });
+};
+exports.default = PgConnectionArgFilterColumnsPlugin;

package/PgConnectionArgFilterCompositeTypeColumnsPlugin.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from 'graphile-build';
+declare const PgConnectionArgFilterCompositeTypeColumnsPlugin: Plugin;
+export default PgConnectionArgFilterCompositeTypeColumnsPlugin;

package/PgConnectionArgFilterCompositeTypeColumnsPlugin.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const PgConnectionArgFilterCompositeTypeColumnsPlugin = (builder, rawOptions) => {
+    const { connectionFilterAllowedFieldTypes } = rawOptions;
+    builder.hook('GraphQLInputObjectType:fields', (fields, build, context) => {
+        const { extend, newWithHooks, pgSql: sql, pgIntrospectionResultsByKind: introspectionResultsByKind, pgGetGqlTypeByTypeIdAndModifier, pgColumnFilter, pgOmit: omit, inflection, connectionFilterRegisterResolver, connectionFilterResolve, connectionFilterType, connectionFilterTypesByTypeName, } = build;
+        const { fieldWithHooks, scope: { pgIntrospection: table, isPgConnectionFilter }, Self, } = context;
+        if (!isPgConnectionFilter || table.kind !== 'class')
+            return fields;
+        connectionFilterTypesByTypeName[Self.name] = Self;
+        const attrByFieldName = introspectionResultsByKind.attribute
+            .filter((attr) => attr.classId === table.id)
+            .filter((attr) => pgColumnFilter(attr, build, context))
+            .filter((attr) => !omit(attr, 'filter'))
+            .filter((attr) => attr.type &&
+            attr.type.type === 'c' &&
+            attr.type.class &&
+            !attr.type.class.isSelectable) // keep only the composite type columns
+            .reduce((memo, attr) => {
+            const fieldName = inflection.column(attr);
+            memo[fieldName] = attr;
+            return memo;
+        }, {});
+        const filterTypeNameByFieldName = {};
+        const attrFields = Object.entries(attrByFieldName).reduce((memo, [fieldName, attr]) => {
+            const NodeType = pgGetGqlTypeByTypeIdAndModifier(attr.typeId, attr.typeModifier);
+            if (!NodeType) {
+                return memo;
+            }
+            const nodeTypeName = NodeType.name;
+            // Respect `connectionFilterAllowedFieldTypes` config option
+            if (connectionFilterAllowedFieldTypes &&
+                !connectionFilterAllowedFieldTypes.includes(nodeTypeName)) {
+                return memo;
+            }
+            const filterTypeName = inflection.filterType(nodeTypeName);
+            const CompositeFilterType = connectionFilterType(newWithHooks, filterTypeName, attr.type.class, nodeTypeName);
+            if (!CompositeFilterType) {
+                return memo;
+            }
+            filterTypeNameByFieldName[fieldName] = filterTypeName;
+            return extend(memo, {
+                [fieldName]: fieldWithHooks(fieldName, {
+                    description: `Filter by the object’s \`${fieldName}\` field.`,
+                    type: CompositeFilterType,
+                }, {
+                    isPgConnectionFilterField: true,
+                }),
+            });
+        }, {});
+        const resolve = ({ sourceAlias, fieldName, fieldValue, queryBuilder, }) => {
+            if (fieldValue == null)
+                return null;
+            const attr = attrByFieldName[fieldName];
+            const sqlIdentifier = sql.query `(${sourceAlias}.${sql.identifier(attr.name)})`; // parentheses are required to avoid confusing the parser
+            const pgType = attr.type;
+            const pgTypeModifier = attr.typeModifier;
+            const filterTypeName = filterTypeNameByFieldName[fieldName];
+            return connectionFilterResolve(fieldValue, sqlIdentifier, filterTypeName, queryBuilder, pgType, pgTypeModifier, fieldName);
+        };
+        for (const fieldName of Object.keys(attrFields)) {
+            connectionFilterRegisterResolver(Self.name, fieldName, resolve);
+        }
+        return extend(fields, attrFields);
+    });
+};
+exports.default = PgConnectionArgFilterCompositeTypeColumnsPlugin;

package/PgConnectionArgFilterComputedColumnsPlugin.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from 'graphile-build';
+declare const PgConnectionArgFilterComputedColumnsPlugin: Plugin;
+export default PgConnectionArgFilterComputedColumnsPlugin;

package/PgConnectionArgFilterComputedColumnsPlugin.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const PgConnectionArgFilterComputedColumnsPlugin = (builder, rawOptions) => {
+    const { connectionFilterComputedColumns } = rawOptions;
+    builder.hook('GraphQLInputObjectType:fields', (fields, build, context) => {
+        const { extend, newWithHooks, pgIntrospectionResultsByKind: introspectionResultsByKind, pgOmit: omit, pgSql: sql, inflection, connectionFilterOperatorsType, connectionFilterRegisterResolver, connectionFilterResolve, connectionFilterTypesByTypeName, } = build;
+        const { scope: { isPgConnectionFilter, pgIntrospection: table }, fieldWithHooks, Self, } = context;
+        if (!isPgConnectionFilter || !table || table.kind !== 'class') {
+            return fields;
+        }
+        connectionFilterTypesByTypeName[Self.name] = Self;
+        const procByFieldName = introspectionResultsByKind.procedure.reduce((memo, proc) => {
+            // Must be marked @filterable OR enabled via plugin option
+            if (!(proc.tags.filterable || connectionFilterComputedColumns))
+                return memo;
+            // Must not be omitted
+            if (omit(proc, 'execute'))
+                return memo;
+            if (omit(proc, 'filter'))
+                return memo;
+            // Must be a computed column
+            const computedColumnDetails = getComputedColumnDetails(build, table, proc);
+            if (!computedColumnDetails)
+                return memo;
+            const { pseudoColumnName } = computedColumnDetails;
+            // Must have only one required argument
+            const inputArgsCount = proc.argTypeIds.filter((_typeId, idx) => proc.argModes.length === 0 || // all args are `in`
+                proc.argModes[idx] === 'i' || // this arg is `in`
+                proc.argModes[idx] === 'b' // this arg is `inout`
+            ).length;
+            const nonOptionalArgumentsCount = inputArgsCount - proc.argDefaultsNum;
+            if (nonOptionalArgumentsCount > 1) {
+                return memo;
+            }
+            // Must return a scalar or an array
+            if (proc.returnsSet)
+                return memo;
+            const returnType = introspectionResultsByKind.typeById[proc.returnTypeId];
+            const returnTypeTable = introspectionResultsByKind.classById[returnType.classId];
+            if (returnTypeTable)
+                return memo;
+            const isRecordLike = returnType.id === '2249';
+            if (isRecordLike)
+                return memo;
+            const isVoid = String(returnType.id) === '2278';
+            if (isVoid)
+                return memo;
+            // Looks good
+            const fieldName = inflection.computedColumn(pseudoColumnName, proc, table);
+            memo = build.extend(memo, { [fieldName]: proc });
+            return memo;
+        }, {});
+        const operatorsTypeNameByFieldName = {};
+        const procFields = Object.entries(procByFieldName).reduce((memo, [fieldName, proc]) => {
+            const OperatorsType = connectionFilterOperatorsType(newWithHooks, proc.returnTypeId, null);
+            if (!OperatorsType) {
+                return memo;
+            }
+            operatorsTypeNameByFieldName[fieldName] = OperatorsType.name;
+            return extend(memo, {
+                [fieldName]: fieldWithHooks(fieldName, {
+                    description: `Filter by the object’s \`${fieldName}\` field.`,
+                    type: OperatorsType,
+                }, {
+                    isPgConnectionFilterField: true,
+                }),
+            });
+        }, {});
+        const resolve = ({ sourceAlias, fieldName, fieldValue, queryBuilder, }) => {
+            if (fieldValue == null)
+                return null;
+            const proc = procByFieldName[fieldName];
+            const sqlIdentifier = sql.query `${sql.identifier(proc.namespace.name)}.${sql.identifier(proc.name)}(${sourceAlias})`;
+            const pgType = introspectionResultsByKind.typeById[proc.returnTypeId];
+            const pgTypeModifier = null;
+            const filterTypeName = operatorsTypeNameByFieldName[fieldName];
+            return connectionFilterResolve(fieldValue, sqlIdentifier, filterTypeName, queryBuilder, pgType, pgTypeModifier, fieldName);
+        };
+        for (const fieldName of Object.keys(procFields)) {
+            connectionFilterRegisterResolver(Self.name, fieldName, resolve);
+        }
+        return extend(fields, procFields);
+    });
+    function getComputedColumnDetails(build, table, proc) {
+        if (!proc.isStable)
+            return null;
+        if (proc.namespaceId !== table.namespaceId)
+            return null;
+        if (!proc.name.startsWith(`${table.name}_`))
+            return null;
+        if (proc.argTypeIds.length < 1)
+            return null;
+        if (proc.argTypeIds[0] !== table.type.id)
+            return null;
+        const argTypes = proc.argTypeIds.reduce((prev, typeId, idx) => {
+            if (proc.argModes.length === 0 || // all args are `in`
+                proc.argModes[idx] === 'i' || // this arg is `in`
+                proc.argModes[idx] === 'b' // this arg is `inout`
+            ) {
+                prev.push(build.pgIntrospectionResultsByKind.typeById[typeId]);
+            }
+            return prev;
+        }, []);
+        if (argTypes
+            .slice(1)
+            .some((type) => type.type === 'c' && type.class && type.class.isSelectable)) {
+            // Accepts two input tables? Skip.
+            return null;
+        }
+        const pseudoColumnName = proc.name.substr(table.name.length + 1);
+        return { argTypes, pseudoColumnName };
+    }
+};
+exports.default = PgConnectionArgFilterComputedColumnsPlugin;

package/PgConnectionArgFilterForwardRelationsPlugin.d.ts

@@ -0,0 +1,11 @@
+import type { Plugin } from 'graphile-build';
+import type { PgAttribute, PgClass, PgConstraint } from 'graphile-build-pg';
+declare const PgConnectionArgFilterForwardRelationsPlugin: Plugin;
+export interface ForwardRelationSpec {
+    table: PgClass;
+    keyAttributes: PgAttribute[];
+    foreignTable: PgClass;
+    foreignKeyAttributes: PgAttribute[];
+    constraint: PgConstraint;
+}
+export default PgConnectionArgFilterForwardRelationsPlugin;