graphile-connection-filter 1.1.0

package/esm/utils.js

@@ -0,0 +1,112 @@
+/**
+ * Utility functions for the connection filter plugin.
+ */
+/**
+ * Check if a value is an empty object (no own enumerable keys).
+ */
+export function isEmpty(o) {
+    return typeof o === 'object' && o !== null && Object.keys(o).length === 0;
+}
+/**
+ * Check if a pgResource is a computed scalar attribute function.
+ * A computed attribute is a function that:
+ * - has parameters
+ * - returns a scalar (no attributes on codec)
+ * - is unique (returns single row)
+ * - first parameter's codec has attributes (i.e. takes a table row)
+ */
+export function isComputedScalarAttributeResource(s) {
+    if (!s.parameters || s.parameters.length < 1) {
+        return false;
+    }
+    if (s.codec.attributes) {
+        return false;
+    }
+    if (!s.isUnique) {
+        return false;
+    }
+    const firstParameter = s.parameters[0];
+    if (!firstParameter?.codec.attributes) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Get all computed attribute resources for a given source.
+ */
+export function getComputedAttributeResources(build, source) {
+    const computedAttributeSources = Object.values(build.input.pgRegistry.pgResources).filter((s) => isComputedScalarAttributeResource(s) &&
+        s.parameters[0].codec === source.codec);
+    return computedAttributeSources;
+}
+/**
+ * Walks from a PgCondition up to the PgSelectQueryBuilder.
+ * Uses the .parent property on PgCondition to traverse up the chain,
+ * following Benjie's pattern from postgraphile-plugin-fulltext-filter.
+ *
+ * This is used by satellite plugins (search, BM25, pgvector) that need
+ * to access the query builder from within a filter's apply callback
+ * to inject SELECT expressions (for ranking/scoring) and ORDER BY clauses.
+ *
+ * @param build - The Graphile Build object (needs build.dataplanPg.PgCondition)
+ * @param $condition - The PgCondition instance from the filter apply callback
+ * @returns The PgSelectQueryBuilder if found, or null
+ */
+export function getQueryBuilder(build, $condition) {
+    const PgCondition = build.dataplanPg?.PgCondition;
+    if (!PgCondition)
+        return null;
+    let current = $condition;
+    const { alias } = current;
+    // Walk up through nested PgConditions (e.g. and/or/not)
+    // Note: PgCondition.parent is protected, so we use bracket notation
+    // to access it from outside the class hierarchy.
+    while (current &&
+        current instanceof PgCondition &&
+        current.alias === alias) {
+        current = current['parent'];
+    }
+    // Verify we found a query builder with matching alias
+    // Using duck-typing per Benjie's pattern
+    if (current &&
+        typeof current.selectAndReturnIndex === 'function' &&
+        current.alias === alias) {
+        return current;
+    }
+    return null;
+}
+/**
+ * Creates an assertion function that validates filter input values.
+ *
+ * Rejects empty objects in nested contexts (logical operators, relation filters)
+ * and optionally rejects null literals based on the connectionFilterAllowNullInput option.
+ *
+ * Note: Top-level empty filter `{}` is handled in ConnectionFilterArgPlugin's
+ * applyPlan — it's treated as "no filter" and skipped, not rejected.
+ */
+export function makeAssertAllowed(build) {
+    const { options, EXPORTABLE } = build;
+    const { connectionFilterAllowNullInput, } = options;
+    const assertAllowed = EXPORTABLE((connectionFilterAllowNullInput, isEmpty) => function (value, mode) {
+        // Reject empty objects in nested filter contexts (and/or/not, relation filters)
+        if (mode === 'object' && isEmpty(value)) {
+            throw Object.assign(new Error('Empty objects are forbidden in filter argument input.'), {});
+        }
+        if (mode === 'list') {
+            const arr = value;
+            if (arr) {
+                const l = arr.length;
+                for (let i = 0; i < l; i++) {
+                    if (isEmpty(arr[i])) {
+                        throw Object.assign(new Error('Empty objects are forbidden in filter argument input.'), {});
+                    }
+                }
+            }
+        }
+        // For all modes, check null
+        if (!connectionFilterAllowNullInput && value === null) {
+            throw Object.assign(new Error('Null literals are forbidden in filter argument input.'), {});
+        }
+    }, [connectionFilterAllowNullInput, isEmpty]);
+    return assertAllowed;
+}

package/index.d.ts

@@ -0,0 +1,55 @@
+/**
+ * graphile-connection-filter
+ *
+ * A PostGraphile v5 native connection filter plugin.
+ * Adds advanced filtering capabilities to connection and list fields.
+ *
+ * @example
+ * ```typescript
+ * import { ConnectionFilterPreset } from 'graphile-connection-filter';
+ *
+ * const preset = {
+ *   extends: [
+ *     ConnectionFilterPreset(),
+ *   ],
+ * };
+ * ```
+ *
+ * For satellite plugins that need to register custom operators, declare them
+ * as factories in the preset's `connectionFilterOperatorFactories` option:
+ * ```typescript
+ * import type { ConnectionFilterOperatorFactory } from 'graphile-connection-filter';
+ *
+ * const myOperatorFactory: ConnectionFilterOperatorFactory = (build) => [{
+ *   typeNames: 'MyType',
+ *   operatorName: 'myOperator',
+ *   spec: {
+ *     description: 'My custom operator',
+ *     resolve: (sqlIdentifier, sqlValue) => build.sql`${sqlIdentifier} OP ${sqlValue}`,
+ *   },
+ * }];
+ *
+ * export const MyPreset = {
+ *   schema: {
+ *     connectionFilterOperatorFactories: [myOperatorFactory],
+ *   },
+ *   plugins: [MyPlugin],
+ * };
+ * ```
+ *
+ * For satellite plugins that need to access the query builder from a filter apply:
+ * ```typescript
+ * import { getQueryBuilder } from 'graphile-connection-filter';
+ * // In your filter field's apply callback:
+ * const qb = getQueryBuilder(build, $condition);
+ * if (qb) {
+ *   const idx = qb.selectAndReturnIndex(sql`...`);
+ *   qb.setMeta('key', { selectIndex: idx });
+ * }
+ * ```
+ */
+export { ConnectionFilterPreset } from './preset';
+export { ConnectionFilterInflectionPlugin, ConnectionFilterTypesPlugin, ConnectionFilterArgPlugin, ConnectionFilterAttributesPlugin, ConnectionFilterOperatorsPlugin, ConnectionFilterCustomOperatorsPlugin, ConnectionFilterLogicalOperatorsPlugin, ConnectionFilterComputedAttributesPlugin, ConnectionFilterForwardRelationsPlugin, ConnectionFilterBackwardRelationsPlugin, makeApplyFromOperatorSpec, } from './plugins';
+export type { ConnectionFilterOperatorSpec, ConnectionFilterOperatorRegistration, ConnectionFilterOperatorFactory, ConnectionFilterOptions, ConnectionFilterOperatorsDigest, PgConnectionFilterOperatorsScope, } from './types';
+export { $$filters } from './types';
+export { isEmpty, makeAssertAllowed, getQueryBuilder, isComputedScalarAttributeResource, getComputedAttributeResources, } from './utils';

package/index.js

@@ -0,0 +1,77 @@
+"use strict";
+/**
+ * graphile-connection-filter
+ *
+ * A PostGraphile v5 native connection filter plugin.
+ * Adds advanced filtering capabilities to connection and list fields.
+ *
+ * @example
+ * ```typescript
+ * import { ConnectionFilterPreset } from 'graphile-connection-filter';
+ *
+ * const preset = {
+ *   extends: [
+ *     ConnectionFilterPreset(),
+ *   ],
+ * };
+ * ```
+ *
+ * For satellite plugins that need to register custom operators, declare them
+ * as factories in the preset's `connectionFilterOperatorFactories` option:
+ * ```typescript
+ * import type { ConnectionFilterOperatorFactory } from 'graphile-connection-filter';
+ *
+ * const myOperatorFactory: ConnectionFilterOperatorFactory = (build) => [{
+ *   typeNames: 'MyType',
+ *   operatorName: 'myOperator',
+ *   spec: {
+ *     description: 'My custom operator',
+ *     resolve: (sqlIdentifier, sqlValue) => build.sql`${sqlIdentifier} OP ${sqlValue}`,
+ *   },
+ * }];
+ *
+ * export const MyPreset = {
+ *   schema: {
+ *     connectionFilterOperatorFactories: [myOperatorFactory],
+ *   },
+ *   plugins: [MyPlugin],
+ * };
+ * ```
+ *
+ * For satellite plugins that need to access the query builder from a filter apply:
+ * ```typescript
+ * import { getQueryBuilder } from 'graphile-connection-filter';
+ * // In your filter field's apply callback:
+ * const qb = getQueryBuilder(build, $condition);
+ * if (qb) {
+ *   const idx = qb.selectAndReturnIndex(sql`...`);
+ *   qb.setMeta('key', { selectIndex: idx });
+ * }
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getComputedAttributeResources = exports.isComputedScalarAttributeResource = exports.getQueryBuilder = exports.makeAssertAllowed = exports.isEmpty = exports.$$filters = exports.makeApplyFromOperatorSpec = exports.ConnectionFilterBackwardRelationsPlugin = exports.ConnectionFilterForwardRelationsPlugin = exports.ConnectionFilterComputedAttributesPlugin = exports.ConnectionFilterLogicalOperatorsPlugin = exports.ConnectionFilterCustomOperatorsPlugin = exports.ConnectionFilterOperatorsPlugin = exports.ConnectionFilterAttributesPlugin = exports.ConnectionFilterArgPlugin = exports.ConnectionFilterTypesPlugin = exports.ConnectionFilterInflectionPlugin = exports.ConnectionFilterPreset = void 0;
+var preset_1 = require("./preset");
+Object.defineProperty(exports, "ConnectionFilterPreset", { enumerable: true, get: function () { return preset_1.ConnectionFilterPreset; } });
+// Re-export all plugins for granular use
+var plugins_1 = require("./plugins");
+Object.defineProperty(exports, "ConnectionFilterInflectionPlugin", { enumerable: true, get: function () { return plugins_1.ConnectionFilterInflectionPlugin; } });
+Object.defineProperty(exports, "ConnectionFilterTypesPlugin", { enumerable: true, get: function () { return plugins_1.ConnectionFilterTypesPlugin; } });
+Object.defineProperty(exports, "ConnectionFilterArgPlugin", { enumerable: true, get: function () { return plugins_1.ConnectionFilterArgPlugin; } });
+Object.defineProperty(exports, "ConnectionFilterAttributesPlugin", { enumerable: true, get: function () { return plugins_1.ConnectionFilterAttributesPlugin; } });
+Object.defineProperty(exports, "ConnectionFilterOperatorsPlugin", { enumerable: true, get: function () { return plugins_1.ConnectionFilterOperatorsPlugin; } });
+Object.defineProperty(exports, "ConnectionFilterCustomOperatorsPlugin", { enumerable: true, get: function () { return plugins_1.ConnectionFilterCustomOperatorsPlugin; } });
+Object.defineProperty(exports, "ConnectionFilterLogicalOperatorsPlugin", { enumerable: true, get: function () { return plugins_1.ConnectionFilterLogicalOperatorsPlugin; } });
+Object.defineProperty(exports, "ConnectionFilterComputedAttributesPlugin", { enumerable: true, get: function () { return plugins_1.ConnectionFilterComputedAttributesPlugin; } });
+Object.defineProperty(exports, "ConnectionFilterForwardRelationsPlugin", { enumerable: true, get: function () { return plugins_1.ConnectionFilterForwardRelationsPlugin; } });
+Object.defineProperty(exports, "ConnectionFilterBackwardRelationsPlugin", { enumerable: true, get: function () { return plugins_1.ConnectionFilterBackwardRelationsPlugin; } });
+Object.defineProperty(exports, "makeApplyFromOperatorSpec", { enumerable: true, get: function () { return plugins_1.makeApplyFromOperatorSpec; } });
+var types_1 = require("./types");
+Object.defineProperty(exports, "$$filters", { enumerable: true, get: function () { return types_1.$$filters; } });
+// Re-export utilities
+var utils_1 = require("./utils");
+Object.defineProperty(exports, "isEmpty", { enumerable: true, get: function () { return utils_1.isEmpty; } });
+Object.defineProperty(exports, "makeAssertAllowed", { enumerable: true, get: function () { return utils_1.makeAssertAllowed; } });
+Object.defineProperty(exports, "getQueryBuilder", { enumerable: true, get: function () { return utils_1.getQueryBuilder; } });
+Object.defineProperty(exports, "isComputedScalarAttributeResource", { enumerable: true, get: function () { return utils_1.isComputedScalarAttributeResource; } });
+Object.defineProperty(exports, "getComputedAttributeResources", { enumerable: true, get: function () { return utils_1.getComputedAttributeResources; } });

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "graphile-connection-filter",
+  "version": "1.1.0",
+  "description": "PostGraphile v5 native connection filter plugin - adds advanced filtering to connections",
+  "author": "Constructive <developers@constructive.io>",
+  "homepage": "https://github.com/constructive-io/constructive",
+  "license": "MIT",
+  "main": "index.js",
+  "module": "esm/index.js",
+  "types": "index.d.ts",
+  "scripts": {
+    "clean": "makage clean",
+    "prepack": "npm 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/constructive-io/constructive"
+  },
+  "keywords": [
+    "postgraphile",
+    "graphile",
+    "constructive",
+    "plugin",
+    "postgres",
+    "graphql",
+    "filter",
+    "connection-filter",
+    "v5"
+  ],
+  "bugs": {
+    "url": "https://github.com/constructive-io/constructive/issues"
+  },
+  "devDependencies": {
+    "@types/node": "^22.19.11",
+    "graphile-test": "^4.5.2",
+    "makage": "^0.1.10",
+    "pgsql-test": "^4.5.2"
+  },
+  "peerDependencies": {
+    "@dataplan/pg": "1.0.0-rc.5",
+    "graphile-build": "5.0.0-rc.4",
+    "graphile-build-pg": "5.0.0-rc.5",
+    "graphile-config": "1.0.0-rc.5",
+    "graphql": "^16.9.0",
+    "pg-sql2": "5.0.0-rc.4",
+    "postgraphile": "5.0.0-rc.7"
+  },
+  "gitHead": "1ade5f10df8e38a5f87bbd2e2f7ec2ba97267079"
+}

package/plugins/ConnectionFilterArgPlugin.d.ts

@@ -0,0 +1,13 @@
+import '../augmentations';
+import type { GraphileConfig } from 'graphile-config';
+/**
+ * ConnectionFilterArgPlugin
+ *
+ * Adds the filter argument (configurable name, default 'where') to connection
+ * and simple collection fields. Uses `applyPlan` to create a PgCondition that
+ * child filter fields can add WHERE clauses to.
+ *
+ * This runs before PgConnectionArgOrderByPlugin so that filters are applied
+ * before ordering (important for e.g. full-text search rank ordering).
+ */
+export declare const ConnectionFilterArgPlugin: GraphileConfig.Plugin;

package/plugins/ConnectionFilterArgPlugin.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectionFilterArgPlugin = void 0;
+require("../augmentations");
+const utils_1 = require("../utils");
+const version = '1.0.0';
+/**
+ * ConnectionFilterArgPlugin
+ *
+ * Adds the filter argument (configurable name, default 'where') to connection
+ * and simple collection fields. Uses `applyPlan` to create a PgCondition that
+ * child filter fields can add WHERE clauses to.
+ *
+ * This runs before PgConnectionArgOrderByPlugin so that filters are applied
+ * before ordering (important for e.g. full-text search rank ordering).
+ */
+exports.ConnectionFilterArgPlugin = {
+    name: 'ConnectionFilterArgPlugin',
+    version,
+    description: 'Adds the filter argument to connection and list fields',
+    before: ['PgConnectionArgOrderByPlugin'],
+    schema: {
+        hooks: {
+            GraphQLObjectType_fields_field_args(args, build, context) {
+                const { extend, inflection, EXPORTABLE, dataplanPg: { PgCondition }, } = build;
+                const { scope: { isPgFieldConnection, isPgFieldSimpleCollection, pgFieldResource: resource, pgFieldCodec, fieldName, }, Self, } = context;
+                const shouldAddFilter = isPgFieldConnection || isPgFieldSimpleCollection;
+                if (!shouldAddFilter)
+                    return args;
+                const codec = pgFieldCodec ?? resource?.codec;
+                if (!codec)
+                    return args;
+                // Check behavior: procedures use "filterProc", tables use "filter"
+                const desiredBehavior = resource?.parameters
+                    ? 'filterProc'
+                    : 'filter';
+                if (resource
+                    ? !build.behavior.pgResourceMatches(resource, desiredBehavior)
+                    : !build.behavior.pgCodecMatches(codec, desiredBehavior)) {
+                    return args;
+                }
+                const returnCodec = codec;
+                const nodeType = build.getGraphQLTypeByPgCodec(returnCodec, 'output');
+                if (!nodeType)
+                    return args;
+                const nodeTypeName = nodeType.name;
+                const filterTypeName = inflection.filterType(nodeTypeName);
+                const FilterType = build.getTypeByName(filterTypeName);
+                if (!FilterType)
+                    return args;
+                // For setof functions returning scalars, track the codec
+                const attributeCodec = resource?.parameters && !resource?.codec.attributes
+                    ? resource.codec
+                    : null;
+                const argName = build.options.connectionFilterArgumentName || 'where';
+                return extend(args, {
+                    [argName]: {
+                        description: 'A filter to be used in determining which values should be returned by the collection.',
+                        type: FilterType,
+                        ...(isPgFieldConnection
+                            ? {
+                                applyPlan: EXPORTABLE((PgCondition, isEmpty, attributeCodec) => function (_, $connection, fieldArg) {
+                                    const $pgSelect = $connection.getSubplan();
+                                    fieldArg.apply($pgSelect, (queryBuilder, value) => {
+                                        // If filter is null/undefined or empty {}, treat as "no filter" — skip
+                                        if (value == null || isEmpty(value))
+                                            return;
+                                        const condition = new PgCondition(queryBuilder);
+                                        if (attributeCodec) {
+                                            condition.extensions.pgFilterAttribute = {
+                                                codec: attributeCodec,
+                                            };
+                                        }
+                                        return condition;
+                                    });
+                                }, [PgCondition, utils_1.isEmpty, attributeCodec]),
+                            }
+                            : {
+                                applyPlan: EXPORTABLE((PgCondition, isEmpty, attributeCodec) => function (_, $pgSelect, fieldArg) {
+                                    fieldArg.apply($pgSelect, (queryBuilder, value) => {
+                                        // If filter is null/undefined or empty {}, treat as "no filter" — skip
+                                        if (value == null || isEmpty(value))
+                                            return;
+                                        const condition = new PgCondition(queryBuilder);
+                                        if (attributeCodec) {
+                                            condition.extensions.pgFilterAttribute = {
+                                                codec: attributeCodec,
+                                            };
+                                        }
+                                        return condition;
+                                    });
+                                }, [PgCondition, utils_1.isEmpty, attributeCodec]),
+                            }),
+                    },
+                }, `Adding connection filter '${argName}' arg to field '${fieldName}' of '${Self.name}'`);
+            },
+        },
+    },
+};

package/plugins/ConnectionFilterAttributesPlugin.d.ts

@@ -0,0 +1,14 @@
+import '../augmentations';
+import type { GraphileConfig } from 'graphile-config';
+/**
+ * ConnectionFilterAttributesPlugin
+ *
+ * Adds per-column filter fields to the table filter types.
+ * For example, on `UserFilter`, adds fields like `name` (type: StringFilter),
+ * `age` (type: IntFilter), etc.
+ *
+ * Each field's `apply` function creates a new PgCondition with the
+ * `pgFilterAttribute` extension set, so downstream operator fields know
+ * which column they are operating on.
+ */
+export declare const ConnectionFilterAttributesPlugin: GraphileConfig.Plugin;

package/plugins/ConnectionFilterAttributesPlugin.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectionFilterAttributesPlugin = void 0;
+require("../augmentations");
+const utils_1 = require("../utils");
+const version = '1.0.0';
+/**
+ * ConnectionFilterAttributesPlugin
+ *
+ * Adds per-column filter fields to the table filter types.
+ * For example, on `UserFilter`, adds fields like `name` (type: StringFilter),
+ * `age` (type: IntFilter), etc.
+ *
+ * Each field's `apply` function creates a new PgCondition with the
+ * `pgFilterAttribute` extension set, so downstream operator fields know
+ * which column they are operating on.
+ */
+exports.ConnectionFilterAttributesPlugin = {
+    name: 'ConnectionFilterAttributesPlugin',
+    version,
+    description: 'Adds column-based filter fields to connection filter types',
+    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: codec, attributeName });
+                    const colSpec = { fieldName, attributeName, attribute };
+                    const digest = connectionFilterOperatorsDigest(attribute.codec);
+                    if (!digest)
+                        continue;
+                    const OperatorsType = build.getTypeByName(digest.operatorsTypeName);
+                    if (!OperatorsType)
+                        continue;
+                    const { connectionFilterAllowNullInput, } = build.options;
+                    fields = build.extend(fields, {
+                        [fieldName]: fieldWithHooks({
+                            fieldName,
+                            isPgConnectionFilterField: true,
+                        }, () => ({
+                            description: `Filter by the object\u2019s \`${fieldName}\` field.`,
+                            type: OperatorsType,
+                            apply: EXPORTABLE((PgCondition, colSpec, connectionFilterAllowNullInput, isEmpty) => function (queryBuilder, value) {
+                                if (value === undefined) {
+                                    return;
+                                }
+                                if (isEmpty(value)) {
+                                    throw Object.assign(new Error('Empty objects are forbidden in filter argument input.'), {});
+                                }
+                                if (!connectionFilterAllowNullInput &&
+                                    value === null) {
+                                    throw Object.assign(new Error('Null literals are forbidden in filter argument input.'), {});
+                                }
+                                const condition = new PgCondition(queryBuilder);
+                                condition.extensions.pgFilterAttribute = colSpec;
+                                return condition;
+                            }, [
+                                PgCondition,
+                                colSpec,
+                                connectionFilterAllowNullInput,
+                                utils_1.isEmpty,
+                            ]),
+                        })),
+                    }, 'Adding attribute-based filtering');
+                }
+                return fields;
+            },
+        },
+    },
+};

package/plugins/ConnectionFilterBackwardRelationsPlugin.d.ts

@@ -0,0 +1,33 @@
+import '../augmentations';
+import type { GraphileConfig } from 'graphile-config';
+/**
+ * ConnectionFilterBackwardRelationsPlugin
+ *
+ * Adds backward relation filter fields to table filter types.
+ * A "backward" relation is one where another table has a FK referencing the current table.
+ *
+ * For unique backward relations (one-to-one), a single filter field is added:
+ * ```graphql
+ * allClients(filter: {
+ *   profileByClientId: { bio: { includes: "engineer" } }
+ * }) { ... }
+ * ```
+ *
+ * For non-unique backward relations (one-to-many), a "many" filter type is added
+ * with `some`, `every`, and `none` sub-fields:
+ * ```graphql
+ * allClients(filter: {
+ *   ordersByClientId: { some: { total: { greaterThan: 1000 } } }
+ * }) { ... }
+ * ```
+ *
+ * The SQL generated uses EXISTS subqueries:
+ * ```sql
+ * WHERE EXISTS (
+ *   SELECT 1 FROM orders
+ *   WHERE orders.client_id = clients.id
+ *   AND <nested filter conditions>
+ * )
+ * ```
+ */
+export declare const ConnectionFilterBackwardRelationsPlugin: GraphileConfig.Plugin;