graphile-plugin-connection-filter 2.3.1

package/esm/PgConnectionArgFilterPlugin.js

@@ -0,0 +1,303 @@
+const PgConnectionArgFilterPlugin = (builder, rawOptions) => {
+    const { connectionFilterAllowedFieldTypes, connectionFilterArrays, connectionFilterSetofFunctions, connectionFilterAllowNullInput, connectionFilterAllowEmptyObjectInput, } = rawOptions;
+    // Add `filter` input argument to connection and simple collection types
+    builder.hook('GraphQLObjectType:fields:field:args', (args, build, context) => {
+        const { extend, newWithHooks, getTypeByName, inflection, pgGetGqlTypeByTypeIdAndModifier, pgOmit: omit, connectionFilterResolve, connectionFilterType, } = build;
+        const { scope: { isPgFieldConnection, isPgFieldSimpleCollection, pgFieldIntrospection: source, }, addArgDataGenerator, field, Self, } = context;
+        const shouldAddFilter = isPgFieldConnection || isPgFieldSimpleCollection;
+        if (!shouldAddFilter)
+            return args;
+        if (!source)
+            return args;
+        if (omit(source, 'filter'))
+            return args;
+        if (source.kind === 'procedure') {
+            if (!(source.tags.filterable || connectionFilterSetofFunctions)) {
+                return args;
+            }
+        }
+        const returnTypeId = source.kind === 'class' ? source.type.id : source.returnTypeId;
+        const returnType = source.kind === 'class'
+            ? source.type
+            : build.pgIntrospectionResultsByKind.type.find((t) => t.id === returnTypeId);
+        if (!returnType) {
+            return args;
+        }
+        const isRecordLike = returnTypeId === '2249';
+        const nodeTypeName = isRecordLike
+            ? inflection.recordFunctionReturnType(source)
+            : pgGetGqlTypeByTypeIdAndModifier(returnTypeId, null).name;
+        const filterTypeName = inflection.filterType(nodeTypeName);
+        const nodeType = getTypeByName(nodeTypeName);
+        if (!nodeType) {
+            return args;
+        }
+        const nodeSource = source.kind === 'procedure' && returnType.class
+            ? returnType.class
+            : source;
+        const FilterType = connectionFilterType(newWithHooks, filterTypeName, nodeSource, nodeTypeName);
+        if (!FilterType) {
+            return args;
+        }
+        // Generate SQL where clause from filter argument
+        addArgDataGenerator(function connectionFilter(args) {
+            return {
+                pgQuery: (queryBuilder) => {
+                    if (Object.prototype.hasOwnProperty.call(args, 'filter')) {
+                        const sqlFragment = connectionFilterResolve(args.filter, queryBuilder.getTableAlias(), filterTypeName, queryBuilder, returnType, null);
+                        if (sqlFragment != null) {
+                            queryBuilder.where(sqlFragment);
+                        }
+                    }
+                },
+            };
+        });
+        return extend(args, {
+            filter: {
+                description: 'A filter to be used in determining which values should be returned by the collection.',
+                type: FilterType,
+            },
+        }, `Adding connection filter arg to field '${field.name}' of '${Self.name}'`);
+    });
+    builder.hook('build', (build) => {
+        const { extend, graphql: { getNamedType, GraphQLInputObjectType, GraphQLList }, inflection, pgIntrospectionResultsByKind: introspectionResultsByKind, pgGetGqlInputTypeByTypeIdAndModifier, pgGetGqlTypeByTypeIdAndModifier, pgSql: sql, } = build;
+        const connectionFilterResolvers = {};
+        const connectionFilterTypesByTypeName = {};
+        const handleNullInput = () => {
+            if (!connectionFilterAllowNullInput) {
+                throw new Error('Null literals are forbidden in filter argument input.');
+            }
+            return null;
+        };
+        const handleEmptyObjectInput = () => {
+            if (!connectionFilterAllowEmptyObjectInput) {
+                throw new Error('Empty objects are forbidden in filter argument input.');
+            }
+            return null;
+        };
+        const isEmptyObject = (obj) => typeof obj === 'object' &&
+            obj !== null &&
+            !Array.isArray(obj) &&
+            Object.keys(obj).length === 0;
+        const connectionFilterRegisterResolver = (typeName, fieldName, resolve) => {
+            const existingResolvers = connectionFilterResolvers[typeName] || {};
+            if (existingResolvers[fieldName]) {
+                return;
+            }
+            connectionFilterResolvers[typeName] = extend(existingResolvers, {
+                [fieldName]: resolve,
+            });
+        };
+        const connectionFilterResolve = (obj, sourceAlias, typeName, queryBuilder, pgType, pgTypeModifier, parentFieldName, parentFieldInfo) => {
+            if (obj == null)
+                return handleNullInput();
+            if (isEmptyObject(obj))
+                return handleEmptyObjectInput();
+            const sqlFragments = Object.entries(obj)
+                .map(([key, value]) => {
+                if (value == null)
+                    return handleNullInput();
+                if (isEmptyObject(value))
+                    return handleEmptyObjectInput();
+                const resolversByFieldName = connectionFilterResolvers[typeName];
+                if (resolversByFieldName && resolversByFieldName[key]) {
+                    return resolversByFieldName[key]({
+                        sourceAlias,
+                        fieldName: key,
+                        fieldValue: value,
+                        queryBuilder,
+                        pgType,
+                        pgTypeModifier,
+                        parentFieldName,
+                        parentFieldInfo,
+                    });
+                }
+                throw new Error(`Unable to resolve filter field '${key}'`);
+            })
+                .filter((x) => x != null);
+            return sqlFragments.length === 0
+                ? null
+                : sql.query `(${sql.join(sqlFragments, ') and (')})`;
+        };
+        // Get or create types like IntFilter, StringFilter, etc.
+        const connectionFilterOperatorsType = (newWithHooks, pgTypeId, pgTypeModifier) => {
+            const pgType = introspectionResultsByKind.typeById[pgTypeId];
+            const allowedPgTypeTypes = ['b', 'd', 'e', 'r'];
+            if (!allowedPgTypeTypes.includes(pgType.type)) {
+                // Not a base, domain, enum, or range type? Skip.
+                return null;
+            }
+            // Perform some checks on the simple type (after removing array/range/domain wrappers)
+            const pgGetNonArrayType = (pgType) => pgType.isPgArray && pgType.arrayItemType
+                ? pgType.arrayItemType
+                : pgType;
+            const pgGetNonRangeType = (pgType) => pgType.rangeSubTypeId
+                ? introspectionResultsByKind.typeById[pgType.rangeSubTypeId]
+                : pgType;
+            const pgGetNonDomainType = (pgType) => pgType.type === 'd' && pgType.domainBaseTypeId
+                ? introspectionResultsByKind.typeById[pgType.domainBaseTypeId]
+                : pgType;
+            const pgGetSimpleType = (pgType) => pgGetNonDomainType(pgGetNonRangeType(pgGetNonArrayType(pgType)));
+            const pgSimpleType = pgGetSimpleType(pgType);
+            if (!pgSimpleType)
+                return null;
+            if (!(pgSimpleType.type === 'e' ||
+                (pgSimpleType.type === 'b' && !pgSimpleType.isPgArray))) {
+                // Haven't found an enum type or a non-array base type? Skip.
+                return null;
+            }
+            if (pgSimpleType.name === 'json') {
+                // The PG `json` type has no valid operators.
+                // Skip filter type creation to allow the proper
+                // operators to be exposed for PG `jsonb` types.
+                return null;
+            }
+            // Establish field type and field input type
+            const fieldType = pgGetGqlTypeByTypeIdAndModifier(pgTypeId, pgTypeModifier);
+            if (!fieldType)
+                return null;
+            const fieldInputType = pgGetGqlInputTypeByTypeIdAndModifier(pgTypeId, pgTypeModifier);
+            if (!fieldInputType)
+                return null;
+            // Avoid exposing filter operators on unrecognized types that PostGraphile handles as Strings
+            const namedType = getNamedType(fieldType);
+            const namedInputType = getNamedType(fieldInputType);
+            const actualStringPgTypeIds = [
+                '1042', // bpchar
+                '18', //   char
+                '19', //   name
+                '25', //   text
+                '1043', // varchar
+            ];
+            // Include citext as recognized String type
+            const citextPgType = introspectionResultsByKind.type.find((t) => t.name === 'citext');
+            if (citextPgType) {
+                actualStringPgTypeIds.push(citextPgType.id);
+            }
+            if (namedInputType &&
+                namedInputType.name === 'String' &&
+                !actualStringPgTypeIds.includes(pgSimpleType.id)) {
+                // Not a real string type? Skip.
+                return null;
+            }
+            // Respect `connectionFilterAllowedFieldTypes` config option
+            if (connectionFilterAllowedFieldTypes &&
+                !connectionFilterAllowedFieldTypes.includes(namedType.name)) {
+                return null;
+            }
+            const pgConnectionFilterOperatorsCategory = pgType.isPgArray
+                ? 'Array'
+                : pgType.rangeSubTypeId
+                    ? 'Range'
+                    : pgType.type === 'e'
+                        ? 'Enum'
+                        : pgType.type === 'd'
+                            ? 'Domain'
+                            : 'Scalar';
+            // Respect `connectionFilterArrays` config option
+            if (pgConnectionFilterOperatorsCategory === 'Array' &&
+                !connectionFilterArrays) {
+                return null;
+            }
+            const rangeElementInputType = pgType.rangeSubTypeId
+                ? pgGetGqlInputTypeByTypeIdAndModifier(pgType.rangeSubTypeId, pgTypeModifier)
+                : null;
+            const domainBaseType = pgType.type === 'd'
+                ? pgGetGqlTypeByTypeIdAndModifier(pgType.domainBaseTypeId, pgType.domainTypeModifier)
+                : null;
+            const isListType = fieldType instanceof GraphQLList;
+            const operatorsTypeName = isListType
+                ? inflection.filterFieldListType(namedType.name)
+                : inflection.filterFieldType(namedType.name);
+            const existingType = connectionFilterTypesByTypeName[operatorsTypeName];
+            if (existingType) {
+                return existingType;
+            }
+            return newWithHooks(GraphQLInputObjectType, {
+                name: operatorsTypeName,
+                description: `A filter to be used against ${namedType.name}${isListType ? ' List' : ''} fields. All fields are combined with a logical ‘and.’`,
+            }, {
+                isPgConnectionFilterOperators: true,
+                pgConnectionFilterOperatorsCategory,
+                fieldType,
+                fieldInputType,
+                rangeElementInputType,
+                domainBaseType,
+            }, true);
+        };
+        const connectionFilterType = (newWithHooks, filterTypeName, source, nodeTypeName) => {
+            const existingType = connectionFilterTypesByTypeName[filterTypeName];
+            if (existingType) {
+                return existingType;
+            }
+            const placeholder = new GraphQLInputObjectType({
+                name: filterTypeName,
+                fields: {},
+            });
+            connectionFilterTypesByTypeName[filterTypeName] = placeholder;
+            const FilterType = newWithHooks(GraphQLInputObjectType, {
+                description: `A filter to be used against \`${nodeTypeName}\` object types. All fields are combined with a logical ‘and.’`,
+                name: filterTypeName,
+            }, {
+                pgIntrospection: source,
+                isPgConnectionFilter: true,
+            }, true);
+            connectionFilterTypesByTypeName[filterTypeName] = FilterType;
+            return FilterType;
+        };
+        const escapeLikeWildcards = (input) => {
+            if ('string' !== typeof input) {
+                throw new Error('Non-string input was provided to escapeLikeWildcards');
+            }
+            else {
+                return input.split('%').join('\\%').split('_').join('\\_');
+            }
+        };
+        const addConnectionFilterOperator = (typeNames, operatorName, description, resolveType, resolve, options = {}) => {
+            if (!typeNames) {
+                const msg = `Missing first argument 'typeNames' in call to 'addConnectionFilterOperator' for operator '${operatorName}'`;
+                throw new Error(msg);
+            }
+            if (!operatorName) {
+                const msg = `Missing second argument 'operatorName' in call to 'addConnectionFilterOperator' for operator '${operatorName}'`;
+                throw new Error(msg);
+            }
+            if (!resolveType) {
+                const msg = `Missing fourth argument 'resolveType' in call to 'addConnectionFilterOperator' for operator '${operatorName}'`;
+                throw new Error(msg);
+            }
+            if (!resolve) {
+                const msg = `Missing fifth argument 'resolve' in call to 'addConnectionFilterOperator' for operator '${operatorName}'`;
+                throw new Error(msg);
+            }
+            const { connectionFilterScalarOperators } = build;
+            const gqlTypeNames = Array.isArray(typeNames) ? typeNames : [typeNames];
+            for (const gqlTypeName of gqlTypeNames) {
+                if (!connectionFilterScalarOperators[gqlTypeName]) {
+                    connectionFilterScalarOperators[gqlTypeName] = {};
+                }
+                if (connectionFilterScalarOperators[gqlTypeName][operatorName]) {
+                    const msg = `Operator '${operatorName}' already exists for type '${gqlTypeName}'.`;
+                    throw new Error(msg);
+                }
+                connectionFilterScalarOperators[gqlTypeName][operatorName] = {
+                    description,
+                    resolveType,
+                    resolve,
+                    // These functions may exist on `options`: resolveSqlIdentifier, resolveSqlValue, resolveInput
+                    ...options,
+                };
+            }
+        };
+        return extend(build, {
+            connectionFilterTypesByTypeName,
+            connectionFilterRegisterResolver,
+            connectionFilterResolve,
+            connectionFilterOperatorsType,
+            connectionFilterType,
+            escapeLikeWildcards,
+            addConnectionFilterOperator,
+        });
+    });
+};
+export default PgConnectionArgFilterPlugin;

package/esm/PgConnectionArgFilterRecordFunctionsPlugin.js

@@ -0,0 +1,73 @@
+const PgConnectionArgFilterRecordFunctionsPlugin = (builder, rawOptions) => {
+    const { connectionFilterSetofFunctions } = rawOptions;
+    builder.hook('GraphQLInputObjectType:fields', (fields, build, context) => {
+        const { extend, newWithHooks, pgSql: sql, pgIntrospectionResultsByKind: introspectionResultsByKind, pgGetGqlTypeByTypeIdAndModifier, inflection, describePgEntity, connectionFilterOperatorsType, connectionFilterRegisterResolver, connectionFilterResolve, connectionFilterTypesByTypeName, } = build;
+        const { fieldWithHooks, scope: { pgIntrospection: proc, isPgConnectionFilter }, Self, } = context;
+        if (!isPgConnectionFilter || proc.kind !== 'procedure')
+            return fields;
+        connectionFilterTypesByTypeName[Self.name] = Self;
+        // Must return a `RECORD` type
+        const isRecordLike = proc.returnTypeId === '2249';
+        if (!isRecordLike)
+            return fields;
+        // Must be marked @filterable OR enabled via plugin option
+        if (!(proc.tags.filterable || connectionFilterSetofFunctions))
+            return fields;
+        const argModesWithOutput = [
+            'o', // OUT,
+            'b', // INOUT
+            't', // TABLE
+        ];
+        const outputArgNames = proc.argTypeIds.reduce((prev, _, idx) => {
+            if (argModesWithOutput.includes(proc.argModes[idx])) {
+                prev.push(proc.argNames[idx] || '');
+            }
+            return prev;
+        }, []);
+        const outputArgTypes = proc.argTypeIds.reduce((prev, typeId, idx) => {
+            if (argModesWithOutput.includes(proc.argModes[idx])) {
+                prev.push(introspectionResultsByKind.typeById[typeId]);
+            }
+            return prev;
+        }, []);
+        const outputArgByFieldName = outputArgNames.reduce((memo, outputArgName, idx) => {
+            const fieldName = inflection.functionOutputFieldName(proc, outputArgName, idx + 1);
+            if (memo[fieldName]) {
+                throw new Error(`Tried to register field name '${fieldName}' twice in '${describePgEntity(proc)}'; the argument names are too similar.`);
+            }
+            memo[fieldName] = {
+                name: outputArgName,
+                type: outputArgTypes[idx],
+            };
+            return memo;
+        }, {});
+        const outputArgFields = Object.entries(outputArgByFieldName).reduce((memo, [fieldName, outputArg]) => {
+            const OperatorsType = connectionFilterOperatorsType(newWithHooks, outputArg.type.id, null);
+            if (!OperatorsType) {
+                return memo;
+            }
+            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 outputArg = outputArgByFieldName[fieldName];
+            const sqlIdentifier = sql.query `${sourceAlias}.${sql.identifier(outputArg.name)}`;
+            const typeName = pgGetGqlTypeByTypeIdAndModifier(outputArg.type.id, null).name;
+            const filterTypeName = inflection.filterType(typeName);
+            return connectionFilterResolve(fieldValue, sqlIdentifier, filterTypeName, queryBuilder, outputArg.type, null, fieldName);
+        };
+        for (const fieldName of Object.keys(outputArgFields)) {
+            connectionFilterRegisterResolver(Self.name, fieldName, resolve);
+        }
+        return extend(fields, outputArgFields);
+    });
+};
+export default PgConnectionArgFilterRecordFunctionsPlugin;

package/esm/index.js

@@ -0,0 +1,58 @@
+import ConnectionArgFilterPlugin from './ConnectionArgFilterPlugin';
+import PgConnectionArgFilterBackwardRelationsPlugin from './PgConnectionArgFilterBackwardRelationsPlugin';
+import PgConnectionArgFilterColumnsPlugin from './PgConnectionArgFilterColumnsPlugin';
+import PgConnectionArgFilterComputedColumnsPlugin from './PgConnectionArgFilterComputedColumnsPlugin';
+import PgConnectionArgFilterCompositeTypeColumnsPlugin from './PgConnectionArgFilterCompositeTypeColumnsPlugin';
+import PgConnectionArgFilterForwardRelationsPlugin from './PgConnectionArgFilterForwardRelationsPlugin';
+import PgConnectionArgFilterLogicalOperatorsPlugin from './PgConnectionArgFilterLogicalOperatorsPlugin';
+import PgConnectionArgFilterOperatorsPlugin from './PgConnectionArgFilterOperatorsPlugin';
+import PgConnectionArgFilterPlugin from './PgConnectionArgFilterPlugin';
+import PgConnectionArgFilterRecordFunctionsPlugin from './PgConnectionArgFilterRecordFunctionsPlugin';
+import pkg from '../package.json';
+const defaultOptions = {
+    connectionFilterArrays: true,
+    connectionFilterComputedColumns: true,
+    connectionFilterRelations: false,
+    connectionFilterSetofFunctions: true,
+    connectionFilterLogicalOperators: true,
+    connectionFilterAllowNullInput: false,
+    connectionFilterAllowEmptyObjectInput: false,
+};
+const PostGraphileConnectionFilterPlugin = (builder, configOptions = {}) => {
+    builder.hook('build', (build) => {
+        if (!build.versions) {
+            throw new Error(`Plugin ${pkg.name}@${pkg.version} requires graphile-build@^4.1.0 in order to check dependencies (current version: ${build.graphileBuildVersion})`);
+        }
+        const depends = (name, range) => {
+            if (!build.hasVersion(name, range)) {
+                throw new Error(`Plugin ${pkg.name}@${pkg.version} requires ${name}@${range} (${build.versions[name]
+                    ? `current version: ${build.versions[name]}`
+                    : 'not found'})`);
+            }
+        };
+        depends('graphile-build-pg', '^4.5.0');
+        build.versions = build.extend(build.versions, { [pkg.name]: pkg.version });
+        return build;
+    });
+    const options = {
+        ...defaultOptions,
+        ...configOptions,
+    };
+    const { connectionFilterRelations, connectionFilterLogicalOperators } = options;
+    ConnectionArgFilterPlugin(builder, options);
+    PgConnectionArgFilterPlugin(builder, options);
+    PgConnectionArgFilterColumnsPlugin(builder, options);
+    PgConnectionArgFilterComputedColumnsPlugin(builder, options);
+    PgConnectionArgFilterCompositeTypeColumnsPlugin(builder, options);
+    PgConnectionArgFilterRecordFunctionsPlugin(builder, options);
+    if (connectionFilterRelations) {
+        PgConnectionArgFilterBackwardRelationsPlugin(builder, options);
+        PgConnectionArgFilterForwardRelationsPlugin(builder, options);
+    }
+    if (connectionFilterLogicalOperators) {
+        PgConnectionArgFilterLogicalOperatorsPlugin(builder, options);
+    }
+    PgConnectionArgFilterOperatorsPlugin(builder, options);
+};
+export { PostGraphileConnectionFilterPlugin };
+export default PostGraphileConnectionFilterPlugin;

package/esm/types.js

@@ -0,0 +1 @@
+export {};

package/index.d.ts

@@ -0,0 +1,6 @@
+import type { Plugin } from 'graphile-build';
+import type { ConnectionFilterConfig, ConnectionFilterOptions } from './types';
+declare const PostGraphileConnectionFilterPlugin: Plugin;
+export type { ConnectionFilterConfig, ConnectionFilterOptions };
+export { PostGraphileConnectionFilterPlugin };
+export default PostGraphileConnectionFilterPlugin;

package/index.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostGraphileConnectionFilterPlugin = void 0;
+const ConnectionArgFilterPlugin_1 = __importDefault(require("./ConnectionArgFilterPlugin"));
+const PgConnectionArgFilterBackwardRelationsPlugin_1 = __importDefault(require("./PgConnectionArgFilterBackwardRelationsPlugin"));
+const PgConnectionArgFilterColumnsPlugin_1 = __importDefault(require("./PgConnectionArgFilterColumnsPlugin"));
+const PgConnectionArgFilterComputedColumnsPlugin_1 = __importDefault(require("./PgConnectionArgFilterComputedColumnsPlugin"));
+const PgConnectionArgFilterCompositeTypeColumnsPlugin_1 = __importDefault(require("./PgConnectionArgFilterCompositeTypeColumnsPlugin"));
+const PgConnectionArgFilterForwardRelationsPlugin_1 = __importDefault(require("./PgConnectionArgFilterForwardRelationsPlugin"));
+const PgConnectionArgFilterLogicalOperatorsPlugin_1 = __importDefault(require("./PgConnectionArgFilterLogicalOperatorsPlugin"));
+const PgConnectionArgFilterOperatorsPlugin_1 = __importDefault(require("./PgConnectionArgFilterOperatorsPlugin"));
+const PgConnectionArgFilterPlugin_1 = __importDefault(require("./PgConnectionArgFilterPlugin"));
+const PgConnectionArgFilterRecordFunctionsPlugin_1 = __importDefault(require("./PgConnectionArgFilterRecordFunctionsPlugin"));
+const package_json_1 = __importDefault(require("../package.json"));
+const defaultOptions = {
+    connectionFilterArrays: true,
+    connectionFilterComputedColumns: true,
+    connectionFilterRelations: false,
+    connectionFilterSetofFunctions: true,
+    connectionFilterLogicalOperators: true,
+    connectionFilterAllowNullInput: false,
+    connectionFilterAllowEmptyObjectInput: false,
+};
+const PostGraphileConnectionFilterPlugin = (builder, configOptions = {}) => {
+    builder.hook('build', (build) => {
+        if (!build.versions) {
+            throw new Error(`Plugin ${package_json_1.default.name}@${package_json_1.default.version} requires graphile-build@^4.1.0 in order to check dependencies (current version: ${build.graphileBuildVersion})`);
+        }
+        const depends = (name, range) => {
+            if (!build.hasVersion(name, range)) {
+                throw new Error(`Plugin ${package_json_1.default.name}@${package_json_1.default.version} requires ${name}@${range} (${build.versions[name]
+                    ? `current version: ${build.versions[name]}`
+                    : 'not found'})`);
+            }
+        };
+        depends('graphile-build-pg', '^4.5.0');
+        build.versions = build.extend(build.versions, { [package_json_1.default.name]: package_json_1.default.version });
+        return build;
+    });
+    const options = {
+        ...defaultOptions,
+        ...configOptions,
+    };
+    const { connectionFilterRelations, connectionFilterLogicalOperators } = options;
+    (0, ConnectionArgFilterPlugin_1.default)(builder, options);
+    (0, PgConnectionArgFilterPlugin_1.default)(builder, options);
+    (0, PgConnectionArgFilterColumnsPlugin_1.default)(builder, options);
+    (0, PgConnectionArgFilterComputedColumnsPlugin_1.default)(builder, options);
+    (0, PgConnectionArgFilterCompositeTypeColumnsPlugin_1.default)(builder, options);
+    (0, PgConnectionArgFilterRecordFunctionsPlugin_1.default)(builder, options);
+    if (connectionFilterRelations) {
+        (0, PgConnectionArgFilterBackwardRelationsPlugin_1.default)(builder, options);
+        (0, PgConnectionArgFilterForwardRelationsPlugin_1.default)(builder, options);
+    }
+    if (connectionFilterLogicalOperators) {
+        (0, PgConnectionArgFilterLogicalOperatorsPlugin_1.default)(builder, options);
+    }
+    (0, PgConnectionArgFilterOperatorsPlugin_1.default)(builder, options);
+};
+exports.PostGraphileConnectionFilterPlugin = PostGraphileConnectionFilterPlugin;
+exports.default = PostGraphileConnectionFilterPlugin;

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "graphile-plugin-connection-filter",
+  "version": "2.3.1",
+  "description": "Filtering on PostGraphile connections",
+  "author": "Matt Bretl",
+  "homepage": "https://github.com/launchql/launchql",
+  "license": "MIT",
+  "main": "index.js",
+  "module": "esm/index.js",
+  "types": "index.d.ts",
+  "scripts": {
+    "clean": "makage clean",
+    "copy": "makage assets",
+    "prepack": "pnpm run build",
+    "build": "makage build",
+    "build:dev": "makage build --dev",
+    "lint": "eslint . --fix",
+    "test": "jest",
+    "test:watch": "jest --watch"
+  },
+  "publishConfig": {
+    "access": "public",
+    "directory": "dist"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/launchql/launchql"
+  },
+  "keywords": [
+    "postgraphile",
+    "graphile",
+    "plugin",
+    "postgres",
+    "graphql",
+    "filters",
+    "launchql"
+  ],
+  "bugs": {
+    "url": "https://github.com/launchql/launchql/issues"
+  },
+  "dependencies": {
+    "graphile-build": "^4.14.1",
+    "graphile-build-pg": "^4.14.1",
+    "graphql": "15.10.1"
+  },
+  "peerDependencies": {
+    "postgraphile": "^4.14.1"
+  },
+  "devDependencies": {
+    "@graphile-contrib/pg-simplify-inflector": "^6.1.0",
+    "@types/pg": "^8.15.6",
+    "graphile-test": "^2.8.9",
+    "makage": "^0.1.6",
+    "pg": "^8.16.0",
+    "pgsql-test": "^2.14.12"
+  },
+  "gitHead": "3812f24a480b2035b3413ec7fecfe492f294e590"
+}

package/types.d.ts

@@ -0,0 +1,25 @@
+export type SimpleCollectionSetting = 'omit' | 'both' | 'only';
+export interface ConnectionFilterOptions {
+    connectionFilterAllowedOperators?: string[];
+    connectionFilterAllowedFieldTypes?: string[];
+    connectionFilterOperatorNames?: Record<string, string>;
+    connectionFilterUseListInflectors?: boolean;
+    connectionFilterArrays?: boolean;
+    connectionFilterComputedColumns?: boolean;
+    connectionFilterRelations?: boolean;
+    connectionFilterSetofFunctions?: boolean;
+    connectionFilterLogicalOperators?: boolean;
+    connectionFilterAllowNullInput?: boolean;
+    connectionFilterAllowEmptyObjectInput?: boolean;
+    pgSimpleCollections?: SimpleCollectionSetting;
+    pgOmitListSuffix?: boolean;
+}
+export type ConnectionFilterConfig = ConnectionFilterOptions & {
+    connectionFilterArrays: boolean;
+    connectionFilterComputedColumns: boolean;
+    connectionFilterRelations: boolean;
+    connectionFilterSetofFunctions: boolean;
+    connectionFilterLogicalOperators: boolean;
+    connectionFilterAllowNullInput: boolean;
+    connectionFilterAllowEmptyObjectInput: boolean;
+};

package/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });