graphile-plugin-connection-filter 2.3.1

package/README.md

@@ -0,0 +1,364 @@
+# graphile-plugin-connection-filter
+
+<p align="center" width="100%">
+  <img height="250" src="https://raw.githubusercontent.com/launchql/launchql/refs/heads/main/assets/outline-logo.svg" />
+</p>
+
+<p align="center" width="100%">
+  <a href="https://github.com/launchql/launchql/actions/workflows/run-tests.yaml">
+    <img height="20" src="https://github.com/launchql/launchql/actions/workflows/run-tests.yaml/badge.svg" />
+  </a>
+   <a href="https://github.com/launchql/launchql/blob/main/LICENSE"><img height="20" src="https://img.shields.io/badge/license-MIT-blue.svg"/></a>
+   <a href="https://www.npmjs.com/package/graphile-plugin-connection-filter"><img height="20" src="https://img.shields.io/github/package-json/v/launchql/launchql?filename=graphile%2Fgraphile-plugin-connection-filter%2Fpackage.json"/></a>
+</p>
+
+Adds a powerful suite of filtering capabilities to a PostGraphile schema.
+
+> **Warning:** Use of this plugin with the default options may make it **astoundingly trivial** for a malicious actor (or a well-intentioned application that generates complex GraphQL queries) to overwhelm your database with expensive queries. See the [Performance and Security](https://github.com/graphile-contrib/graphile-plugin-connection-filter#performance-and-security) section below for details.
+
+## Usage
+
+Requires PostGraphile v4.5.0 or higher.
+
+Install with:
+
+```
+yarn add postgraphile graphile-plugin-connection-filter
+```
+
+CLI usage via `--append-plugins`:
+
+```
+postgraphile --append-plugins graphile-plugin-connection-filter -c postgres://localhost/my_db ...
+```
+
+Library usage via `appendPlugins`:
+
+```ts
+import ConnectionFilterPlugin from "graphile-plugin-connection-filter";
+// or: const ConnectionFilterPlugin = require("graphile-plugin-connection-filter");
+
+const middleware = postgraphile(DATABASE_URL, SCHEMAS, {
+  appendPlugins: [ConnectionFilterPlugin],
+});
+```
+
+## Performance and Security
+
+By default, this plugin:
+
+- Exposes a large number of filter operators, including some that can perform expensive pattern matching.
+- Allows filtering on [computed columns](https://www.graphile.org/postgraphile/computed-columns/), which can result in expensive operations.
+- Allows filtering on functions that return `setof`, which can result in expensive operations.
+- Allows filtering on List fields (Postgres arrays), which can result in expensive operations.
+
+To protect your server, you can:
+
+- Use the `connectionFilterAllowedFieldTypes` and `connectionFilterAllowedOperators` options to limit the filterable fields and operators exposed through GraphQL.
+- Set `connectionFilterComputedColumns: false` to prevent filtering on [computed columns](https://www.graphile.org/postgraphile/computed-columns/).
+- Set `connectionFilterSetofFunctions: false` to prevent filtering on functions that return `setof`.
+- Set `connectionFilterArrays: false` to prevent filtering on List fields (Postgres arrays).
+
+Also see the [Production Considerations](https://www.graphile.org/postgraphile/production) page of the official PostGraphile docs, which discusses query whitelisting.
+
+## Features
+
+This plugin supports filtering on almost all PostgreSQL types, including complex types such as domains, ranges, arrays, and composite types. For details on the specific operators supported for each type, see [docs/operators.md](https://github.com/graphile-contrib/graphile-plugin-connection-filter/blob/master/docs/operators.md).
+
+See also:
+
+- [@graphile/pg-aggregates](https://github.com/graphile/pg-aggregates) - integrates with this plugin to enable powerful aggregate filtering
+- [postgraphile-plugin-connection-filter-postgis](https://github.com/graphile-contrib/postgraphile-plugin-connection-filter-postgis) - adds PostGIS functions and operators for filtering on `geography`/`geometry` columns
+- [postgraphile-plugin-fulltext-filter](https://github.com/mlipscombe/postgraphile-plugin-fulltext-filter) - adds a full text search operator for filtering on `tsvector` columns
+- [postgraphile-plugin-unaccented-text-search-filter](https://github.com/spacefill/postgraphile-plugin-unaccented-text-search-filter) - adds unaccent text search operators
+
+## Handling `null` and empty objects
+
+By default, this plugin will throw an error when `null` literals or empty objects (`{}`) are included in `filter` input objects. This prevents queries with ambiguous semantics such as `filter: { field: null }` and `filter: { field: { equalTo: null } }` from returning unexpected results. For background on this decision, see https://github.com/graphile-contrib/graphile-plugin-connection-filter/issues/58.
+
+To allow `null` and `{}` in inputs, use the `connectionFilterAllowNullInput` and `connectionFilterAllowEmptyObjectInput` options documented under [Plugin Options](https://github.com/graphile-contrib/graphile-plugin-connection-filter#plugin-options). Please note that even with `connectionFilterAllowNullInput` enabled, `null` is never interpreted as a SQL `NULL`; fields with `null` values are simply ignored when resolving the query.
+
+## Plugin Options
+
+When using PostGraphile as a library, the following plugin options can be passed via `graphileBuildOptions`:
+
+#### connectionFilterAllowedOperators
+
+Restrict filtering to specific operators:
+
+```js
+postgraphile(pgConfig, schema, {
+  graphileBuildOptions: {
+    connectionFilterAllowedOperators: [
+      "isNull",
+      "equalTo",
+      "notEqualTo",
+      "distinctFrom",
+      "notDistinctFrom",
+      "lessThan",
+      "lessThanOrEqualTo",
+      "greaterThan",
+      "greaterThanOrEqualTo",
+      "in",
+      "notIn",
+    ],
+  },
+});
+```
+
+#### connectionFilterAllowedFieldTypes
+
+Restrict filtering to specific field types:
+
+```js
+postgraphile(pgConfig, schema, {
+  graphileBuildOptions: {
+    connectionFilterAllowedFieldTypes: ["String", "Int"],
+  },
+});
+```
+
+The available field types will depend on your database schema.
+
+#### connectionFilterArrays
+
+Enable/disable filtering on PostgreSQL arrays:
+
+```js
+postgraphile(pgConfig, schema, {
+  graphileBuildOptions: {
+    connectionFilterArrays: false, // default: true
+  },
+});
+```
+
+#### connectionFilterComputedColumns
+
+Enable/disable filtering by computed columns:
+
+```js
+postgraphile(pgConfig, schema, {
+  graphileBuildOptions: {
+    connectionFilterComputedColumns: false, // default: true
+  },
+});
+```
+
+Consider setting this to `false` and using `@filterable` [smart comments](https://www.graphile.org/postgraphile/smart-comments/) to selectively enable filtering:
+
+```sql
+create function app_public.foo_computed(foo app_public.foo)
+  returns ... as $$ ... $$ language sql stable;
+
+comment on function app_public.foo_computed(foo app_public.foo) is E'@filterable';
+```
+
+#### connectionFilterOperatorNames
+
+Use alternative names (e.g. `eq`, `ne`) for operators:
+
+```js
+postgraphile(pgConfig, schema, {
+  graphileBuildOptions: {
+    connectionFilterOperatorNames: {
+      equalTo: "eq",
+      notEqualTo: "ne",
+    },
+  },
+});
+```
+
+#### connectionFilterRelations
+
+Enable/disable filtering on related fields:
+
+```js
+postgraphile(pgConfig, schema, {
+  graphileBuildOptions: {
+    connectionFilterRelations: true, // default: false
+  },
+});
+```
+
+#### connectionFilterSetofFunctions
+
+Enable/disable filtering on functions that return `setof`:
+
+```js
+postgraphile(pgConfig, schema, {
+  graphileBuildOptions: {
+    connectionFilterSetofFunctions: false, // default: true
+  },
+});
+```
+
+Consider setting this to `false` and using `@filterable` [smart comments](https://www.graphile.org/postgraphile/smart-comments/) to selectively enable filtering:
+
+```sql
+create function app_public.some_foos()
+  returns setof ... as $$ ... $$ language sql stable;
+
+comment on function app_public.some_foos() is E'@filterable';
+```
+
+#### connectionFilterLogicalOperators
+
+Enable/disable filtering with logical operators (`and`/`or`/`not`):
+
+```js
+postgraphile(pgConfig, schema, {
+  graphileBuildOptions: {
+    connectionFilterLogicalOperators: false, // default: true
+  },
+});
+```
+
+#### connectionFilterAllowNullInput
+
+Allow/forbid `null` literals in input:
+
+```js
+postgraphile(pgConfig, schema, {
+  graphileBuildOptions: {
+    connectionFilterAllowNullInput: true, // default: false
+  },
+});
+```
+
+When `false`, passing `null` as a field value will throw an error.
+When `true`, passing `null` as a field value is equivalent to omitting the field.
+
+#### connectionFilterAllowEmptyObjectInput
+
+Allow/forbid empty objects (`{}`) in input:
+
+```js
+postgraphile(pgConfig, schema, {
+  graphileBuildOptions: {
+    connectionFilterAllowEmptyObjectInput: true, // default: false
+  },
+});
+```
+
+When `false`, passing `{}` as a field value will throw an error.
+When `true`, passing `{}` as a field value is equivalent to omitting the field.
+
+#### connectionFilterUseListInflectors
+
+When building the "many" relationship filters, if this option is set `true`
+then we will use the "list" field names rather than the "connection" field
+names when naming the fields in the filter input. This would be desired if you
+have `simpleCollection` set to `"only"` or `"both"` and you've simplified your
+inflection to omit the `-list` suffix, e.g. using
+`@graphile-contrib/pg-simplify-inflector`'s `pgOmitListSuffix` option. Use this
+if you see `Connection` added to your filter field names.
+
+```js
+postgraphile(pgConfig, schema, {
+  graphileBuildOptions: {
+    connectionFilterUseListInflectors: true, // default: false
+  },
+});
+```
+
+## Examples
+
+```graphql
+query {
+  allPosts(filter: {
+    createdAt: { greaterThan: "2021-01-01" }
+  }) {
+    ...
+  }
+}
+```
+
+For an extensive set of examples, see [docs/examples.md](https://github.com/graphile-contrib/graphile-plugin-connection-filter/blob/master/docs/examples.md).
+
+## Development
+
+To establish a test environment, create an empty PostgreSQL database with C collation (required for consistent ordering of strings) and set a `TEST_DATABASE_URL` environment variable with your database connection string.
+
+```bash
+createdb graphile_test_c --template template0 --lc-collate C
+export TEST_DATABASE_URL=postgres://localhost:5432/graphile_test_c
+yarn
+yarn test
+```
+
+---
+
+## Education and Tutorials
+
+ 1. 🚀 [Quickstart: Getting Up and Running](https://launchql.com/learn/quickstart)
+Get started with modular databases in minutes. Install prerequisites and deploy your first module.
+
+ 2. 📦 [Modular PostgreSQL Development with Database Packages](https://launchql.com/learn/modular-postgres)
+Learn to organize PostgreSQL projects with pgpm workspaces and reusable database modules.
+
+ 3. ✏️ [Authoring Database Changes](https://launchql.com/learn/authoring-database-changes)
+Master the workflow for adding, organizing, and managing database changes with pgpm.
+
+ 4. 🧪 [End-to-End PostgreSQL Testing with TypeScript](https://launchql.com/learn/e2e-postgres-testing)
+Master end-to-end PostgreSQL testing with ephemeral databases, RLS testing, and CI/CD automation.
+
+ 5. ⚡ [Supabase Testing](https://launchql.com/learn/supabase)
+Use TypeScript-first tools to test Supabase projects with realistic RLS, policies, and auth contexts.
+
+ 6. 💧 [Drizzle ORM Testing](https://launchql.com/learn/drizzle-testing)
+Run full-stack tests with Drizzle ORM, including database setup, teardown, and RLS enforcement.
+
+ 7. 🔧 [Troubleshooting](https://launchql.com/learn/troubleshooting)
+Common issues and solutions for pgpm, PostgreSQL, and testing.
+
+## Related LaunchQL Tooling
+
+### 🧪 Testing
+
+* [launchql/pgsql-test](https://github.com/launchql/launchql/tree/main/packages/pgsql-test): **📊 Isolated testing environments** with per-test transaction rollbacks—ideal for integration tests, complex migrations, and RLS simulation.
+* [launchql/supabase-test](https://github.com/launchql/launchql/tree/main/packages/supabase-test): **🧪 Supabase-native test harness** preconfigured for the local Supabase stack—per-test rollbacks, JWT/role context helpers, and CI/GitHub Actions ready.
+* [launchql/graphile-test](https://github.com/launchql/launchql/tree/main/packages/graphile-test): **🔐 Authentication mocking** for Graphile-focused test helpers and emulating row-level security contexts.
+* [launchql/pg-query-context](https://github.com/launchql/launchql/tree/main/packages/pg-query-context): **🔒 Session context injection** to add session-local context (e.g., `SET LOCAL`) into queries—ideal for setting `role`, `jwt.claims`, and other session settings.
+
+### 🧠 Parsing & AST
+
+* [launchql/pgsql-parser](https://github.com/launchql/pgsql-parser): **🔄 SQL conversion engine** that interprets and converts PostgreSQL syntax.
+* [launchql/libpg-query-node](https://github.com/launchql/libpg-query-node): **🌉 Node.js bindings** for `libpg_query`, converting SQL into parse trees.
+* [launchql/pg-proto-parser](https://github.com/launchql/pg-proto-parser): **📦 Protobuf parser** for parsing PostgreSQL Protocol Buffers definitions to generate TypeScript interfaces, utility functions, and JSON mappings for enums.
+* [@pgsql/enums](https://github.com/launchql/pgsql-parser/tree/main/packages/enums): **🏷️ TypeScript enums** for PostgreSQL AST for safe and ergonomic parsing logic.
+* [@pgsql/types](https://github.com/launchql/pgsql-parser/tree/main/packages/types): **📝 Type definitions** for PostgreSQL AST nodes in TypeScript.
+* [@pgsql/utils](https://github.com/launchql/pgsql-parser/tree/main/packages/utils): **🛠️ AST utilities** for constructing and transforming PostgreSQL syntax trees.
+* [launchql/pg-ast](https://github.com/launchql/launchql/tree/main/packages/pg-ast): **🔍 Low-level AST tools** and transformations for Postgres query structures.
+
+### 🚀 API & Dev Tools
+
+* [launchql/server](https://github.com/launchql/launchql/tree/main/packages/server): **⚡ Express-based API server** powered by PostGraphile to expose a secure, scalable GraphQL API over your Postgres database.
+* [launchql/explorer](https://github.com/launchql/launchql/tree/main/packages/explorer): **🔎 Visual API explorer** with GraphiQL for browsing across all databases and schemas—useful for debugging, documentation, and API prototyping.
+
+### 🔁 Streaming & Uploads
+
+* [launchql/s3-streamer](https://github.com/launchql/launchql/tree/main/packages/s3-streamer): **📤 Direct S3 streaming** for large files with support for metadata injection and content validation.
+* [launchql/etag-hash](https://github.com/launchql/launchql/tree/main/packages/etag-hash): **🏷️ S3-compatible ETags** created by streaming and hashing file uploads in chunks.
+* [launchql/etag-stream](https://github.com/launchql/launchql/tree/main/packages/etag-stream): **🔄 ETag computation** via Node stream transformer during upload or transfer.
+* [launchql/uuid-hash](https://github.com/launchql/launchql/tree/main/packages/uuid-hash): **🆔 Deterministic UUIDs** generated from hashed content, great for deduplication and asset referencing.
+* [launchql/uuid-stream](https://github.com/launchql/launchql/tree/main/packages/uuid-stream): **🌊 Streaming UUID generation** based on piped file content—ideal for upload pipelines.
+* [launchql/upload-names](https://github.com/launchql/launchql/tree/main/packages/upload-names): **📂 Collision-resistant filenames** utility for structured and unique file names for uploads.
+
+### 🧰 CLI & Codegen
+
+* [pgpm](https://github.com/launchql/launchql/tree/main/packages/pgpm): **🖥️ PostgreSQL Package Manager** for modular Postgres development. Works with database workspaces, scaffolding, migrations, seeding, and installing database packages.
+* [@launchql/cli](https://github.com/launchql/launchql/tree/main/packages/cli): **🖥️ Command-line toolkit** for managing LaunchQL projects—supports database scaffolding, migrations, seeding, code generation, and automation.
+* [launchql/launchql-gen](https://github.com/launchql/launchql/tree/main/packages/launchql-gen): **✨ Auto-generated GraphQL** mutations and queries dynamically built from introspected schema data.
+* [@launchql/query-builder](https://github.com/launchql/launchql/tree/main/packages/query-builder): **🏗️ SQL constructor** providing a robust TypeScript-based query builder for dynamic generation of `SELECT`, `INSERT`, `UPDATE`, `DELETE`, and stored procedure calls—supports advanced SQL features like `JOIN`, `GROUP BY`, and schema-qualified queries.
+* [@launchql/query](https://github.com/launchql/launchql/tree/main/packages/query): **🧩 Fluent GraphQL builder** for PostGraphile schemas. ⚡ Schema-aware via introspection, 🧩 composable and ergonomic for building deeply nested queries.
+
+## Credits
+
+🛠 Built by LaunchQL — if you like our tools, please checkout and contribute to [our github ⚛️](https://github.com/launchql)
+
+
+## Disclaimer
+
+AS DESCRIBED IN THE LICENSES, THE SOFTWARE IS PROVIDED "AS IS", AT YOUR OWN RISK, AND WITHOUT WARRANTIES OF ANY KIND.
+
+No developer or entity involved in creating this software will be liable for any claims or damages whatsoever associated with your use, inability to use, or your interaction with other users of the code, including any direct, indirect, incidental, special, exemplary, punitive or consequential damages, or loss of profits, cryptocurrencies, tokens, or anything else of value.

package/esm/ConnectionArgFilterPlugin.js

@@ -0,0 +1,16 @@
+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`;
+            },
+        });
+    });
+};
+export default ConnectionArgFilterPlugin;

package/esm/PgConnectionArgFilterBackwardRelationsPlugin.js

@@ -0,0 +1,242 @@
+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);
+    });
+};
+export default PgConnectionArgFilterBackwardRelationsPlugin;