graphile-connection-filter 1.1.0

package/esm/plugins/ConnectionFilterAttributesPlugin.js

@@ -0,0 +1,79 @@
+import '../augmentations';
+import { isEmpty } from '../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.
+ */
+export const 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,
+                                isEmpty,
+                            ]),
+                        })),
+                    }, 'Adding attribute-based filtering');
+                }
+                return fields;
+            },
+        },
+    },
+};

package/esm/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;

package/esm/plugins/ConnectionFilterBackwardRelationsPlugin.js

@@ -0,0 +1,398 @@
+import '../augmentations';
+import { makeAssertAllowed } from '../utils';
+const version = '1.0.0';
+/**
+ * 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 const ConnectionFilterBackwardRelationsPlugin = {
+    name: 'ConnectionFilterBackwardRelationsPlugin',
+    version,
+    description: 'Adds backward relation filter fields to connection filter types',
+    inflection: {
+        add: {
+            filterManyType(_preset, table, foreignTable) {
+                return this.upperCamelCase(`${this.tableType(table)}-to-many-${this.tableType(foreignTable.codec)}-filter`);
+            },
+            filterBackwardSingleRelationExistsFieldName(_preset, relationFieldName) {
+                return `${relationFieldName}Exists`;
+            },
+            filterBackwardManyRelationExistsFieldName(_preset, relationFieldName) {
+                return `${relationFieldName}Exist`;
+            },
+            filterSingleRelationByKeysBackwardsFieldName(_preset, fieldName) {
+                return fieldName;
+            },
+            filterManyRelationByKeysFieldName(_preset, fieldName) {
+                return fieldName;
+            },
+        },
+    },
+    schema: {
+        behaviorRegistry: {
+            add: {
+                filterBy: {
+                    description: 'Whether a relation should be available as a filter field',
+                    entities: ['pgCodecRelation'],
+                },
+            },
+        },
+        entityBehavior: {
+            pgCodecRelation: 'filterBy',
+        },
+        hooks: {
+            init(_, build) {
+                // Runtime check: only proceed if relation filters are enabled
+                if (!build.options.connectionFilterRelations) {
+                    return _;
+                }
+                const { inflection } = build;
+                // Register "many" filter types (e.g. ClientToManyOrderFilter)
+                // These contain `some`, `every`, `none` fields.
+                const requireIndex = build.options.connectionFilterRelationsRequireIndex !== false;
+                for (const source of Object.values(build.input.pgRegistry.pgResources)) {
+                    if (source.parameters ||
+                        !source.codec.attributes ||
+                        source.isUnique) {
+                        continue;
+                    }
+                    for (const [_relationName, relation] of Object.entries(source.getRelations())) {
+                        if (!relation.isReferencee)
+                            continue;
+                        if (relation.isUnique)
+                            continue;
+                        const foreignTable = relation.remoteResource;
+                        if (typeof foreignTable.from === 'function')
+                            continue;
+                        if (!build.behavior.pgCodecRelationMatches(relation, 'filterBy')) {
+                            continue;
+                        }
+                        // Skip unindexed relations when requireIndex is enabled.
+                        // PgIndexBehaviorsPlugin sets relation.extensions.isIndexed = false
+                        // on relations without supporting indexes on the FK columns.
+                        if (requireIndex && relation.extensions?.isIndexed === false) {
+                            continue;
+                        }
+                        const filterManyTypeName = inflection.filterManyType(source.codec, foreignTable);
+                        const foreignTableTypeName = inflection.tableType(foreignTable.codec);
+                        if (!build.getTypeMetaByName(filterManyTypeName)) {
+                            build.recoverable(null, () => {
+                                build.registerInputObjectType(filterManyTypeName, {
+                                    foreignTable,
+                                    isPgConnectionFilterMany: true,
+                                }, () => ({
+                                    name: filterManyTypeName,
+                                    description: `A filter to be used against many \`${foreignTableTypeName}\` object types. All fields are combined with a logical \u2018and.\u2019`,
+                                }), `ConnectionFilterBackwardRelationsPlugin: Adding '${filterManyTypeName}' type for ${foreignTable.name}`);
+                            });
+                        }
+                    }
+                }
+                return _;
+            },
+            GraphQLInputObjectType_fields(inFields, build, context) {
+                let fields = inFields;
+                // Runtime check: only proceed if relation filters are enabled
+                if (!build.options.connectionFilterRelations) {
+                    return fields;
+                }
+                const { extend, inflection, sql, graphql: { GraphQLBoolean }, EXPORTABLE, } = build;
+                const { fieldWithHooks, scope: { pgCodec, isPgConnectionFilter, foreignTable: scopeForeignTable, isPgConnectionFilterMany, }, Self, } = context;
+                const assertAllowed = makeAssertAllowed(build);
+                // ─── Part 1: Add backward relation fields to table filter types ───
+                const source = pgCodec &&
+                    Object.values(build.input.pgRegistry.pgResources).find((s) => s.codec === pgCodec && !s.parameters);
+                if (isPgConnectionFilter && pgCodec && pgCodec.attributes && source) {
+                    const requireIndex = build.options.connectionFilterRelationsRequireIndex !== false;
+                    const backwardRelations = Object.entries(source.getRelations()).filter(([_relationName, relation]) => relation.isReferencee);
+                    for (const [relationName, relation] of backwardRelations) {
+                        const foreignTable = relation.remoteResource;
+                        if (!build.behavior.pgCodecRelationMatches(relation, 'filterBy')) {
+                            continue;
+                        }
+                        if (typeof foreignTable.from === 'function') {
+                            continue;
+                        }
+                        // Skip unindexed relations when requireIndex is enabled.
+                        // PgIndexBehaviorsPlugin sets relation.extensions.isIndexed = false
+                        // on backward relations without supporting indexes on the FK columns.
+                        if (requireIndex && relation.extensions?.isIndexed === false) {
+                            continue;
+                        }
+                        const isForeignKeyUnique = relation.isUnique;
+                        const foreignTableExpression = foreignTable.from;
+                        const localAttributes = relation.localAttributes;
+                        const remoteAttributes = relation.remoteAttributes;
+                        if (isForeignKeyUnique) {
+                            // One-to-one: add a single relation filter field
+                            const fieldName = inflection.singleRelationBackwards({
+                                registry: source.registry,
+                                codec: source.codec,
+                                relationName,
+                            });
+                            const filterFieldName = inflection.filterSingleRelationByKeysBackwardsFieldName(fieldName);
+                            const foreignTableTypeName = inflection.tableType(foreignTable.codec);
+                            const foreignTableFilterTypeName = inflection.filterType(foreignTableTypeName);
+                            const ForeignTableFilterType = build.getTypeByName(foreignTableFilterTypeName);
+                            if (!ForeignTableFilterType)
+                                continue;
+                            fields = extend(fields, {
+                                [filterFieldName]: fieldWithHooks({
+                                    fieldName: filterFieldName,
+                                    isPgConnectionFilterField: true,
+                                }, () => ({
+                                    description: `Filter by the object\u2019s \`${fieldName}\` relation.`,
+                                    type: ForeignTableFilterType,
+                                    apply: EXPORTABLE((assertAllowed, foreignTable, foreignTableExpression, localAttributes, remoteAttributes, sql) => function ($where, value) {
+                                        assertAllowed(value, 'object');
+                                        if (value == null)
+                                            return;
+                                        const $subQuery = $where.existsPlan({
+                                            tableExpression: foreignTableExpression,
+                                            alias: foreignTable.name,
+                                        });
+                                        localAttributes.forEach((localAttribute, i) => {
+                                            const remoteAttribute = remoteAttributes[i];
+                                            $subQuery.where(sql `${$where.alias}.${sql.identifier(localAttribute)} = ${$subQuery.alias}.${sql.identifier(remoteAttribute)}`);
+                                        });
+                                        return $subQuery;
+                                    }, [
+                                        assertAllowed,
+                                        foreignTable,
+                                        foreignTableExpression,
+                                        localAttributes,
+                                        remoteAttributes,
+                                        sql,
+                                    ]),
+                                })),
+                            }, `Adding connection filter backward single relation field from ${source.name} to ${foreignTable.name}`);
+                            // Add exists field
+                            const existsFieldName = inflection.filterBackwardSingleRelationExistsFieldName(fieldName);
+                            fields = extend(fields, {
+                                [existsFieldName]: fieldWithHooks({
+                                    fieldName: existsFieldName,
+                                    isPgConnectionFilterField: true,
+                                }, () => ({
+                                    description: `A related \`${fieldName}\` exists.`,
+                                    type: GraphQLBoolean,
+                                    apply: EXPORTABLE((assertAllowed, foreignTable, foreignTableExpression, localAttributes, remoteAttributes, sql) => function ($where, value) {
+                                        assertAllowed(value, 'scalar');
+                                        if (value == null)
+                                            return;
+                                        const $subQuery = $where.existsPlan({
+                                            tableExpression: foreignTableExpression,
+                                            alias: foreignTable.name,
+                                            equals: value,
+                                        });
+                                        localAttributes.forEach((localAttribute, i) => {
+                                            const remoteAttribute = remoteAttributes[i];
+                                            $subQuery.where(sql `${$where.alias}.${sql.identifier(localAttribute)} = ${$subQuery.alias}.${sql.identifier(remoteAttribute)}`);
+                                        });
+                                    }, [
+                                        assertAllowed,
+                                        foreignTable,
+                                        foreignTableExpression,
+                                        localAttributes,
+                                        remoteAttributes,
+                                        sql,
+                                    ]),
+                                })),
+                            }, `Adding connection filter backward single relation exists field for ${fieldName}`);
+                        }
+                        else {
+                            // One-to-many: add a "many" filter field (e.g. ordersByClientId: ClientToManyOrderFilter)
+                            const fieldName = inflection._manyRelation({
+                                registry: source.registry,
+                                codec: source.codec,
+                                relationName,
+                            });
+                            const filterFieldName = inflection.filterManyRelationByKeysFieldName(fieldName);
+                            const filterManyTypeName = inflection.filterManyType(source.codec, foreignTable);
+                            const FilterManyType = build.getTypeByName(filterManyTypeName);
+                            if (!FilterManyType)
+                                continue;
+                            // The many relation field tags $where with relation info so that
+                            // some/every/none can create the appropriate EXISTS subquery.
+                            fields = extend(fields, {
+                                [filterFieldName]: fieldWithHooks({
+                                    fieldName: filterFieldName,
+                                    isPgConnectionFilterField: true,
+                                    isPgConnectionFilterManyField: true,
+                                }, () => ({
+                                    description: `Filter by the object\u2019s \`${fieldName}\` relation.`,
+                                    type: FilterManyType,
+                                    apply: EXPORTABLE((assertAllowed, foreignTable, foreignTableExpression, localAttributes, remoteAttributes) => function ($where, value) {
+                                        assertAllowed(value, 'object');
+                                        if (value == null)
+                                            return;
+                                        // Tag $where with relation info for some/every/none
+                                        $where._manyRelation = {
+                                            foreignTable,
+                                            foreignTableExpression,
+                                            localAttributes,
+                                            remoteAttributes,
+                                        };
+                                        return $where;
+                                    }, [
+                                        assertAllowed,
+                                        foreignTable,
+                                        foreignTableExpression,
+                                        localAttributes,
+                                        remoteAttributes,
+                                    ]),
+                                })),
+                            }, `Adding connection filter backward many relation field from ${source.name} to ${foreignTable.name}`);
+                            // Add exists field for many relations
+                            const existsFieldName = inflection.filterBackwardManyRelationExistsFieldName(fieldName);
+                            fields = extend(fields, {
+                                [existsFieldName]: fieldWithHooks({
+                                    fieldName: existsFieldName,
+                                    isPgConnectionFilterField: true,
+                                }, () => ({
+                                    description: `\`${fieldName}\` exist.`,
+                                    type: GraphQLBoolean,
+                                    apply: EXPORTABLE((assertAllowed, foreignTable, foreignTableExpression, localAttributes, remoteAttributes, sql) => function ($where, value) {
+                                        assertAllowed(value, 'scalar');
+                                        if (value == null)
+                                            return;
+                                        const $subQuery = $where.existsPlan({
+                                            tableExpression: foreignTableExpression,
+                                            alias: foreignTable.name,
+                                            equals: value,
+                                        });
+                                        localAttributes.forEach((localAttribute, i) => {
+                                            const remoteAttribute = remoteAttributes[i];
+                                            $subQuery.where(sql `${$where.alias}.${sql.identifier(localAttribute)} = ${$subQuery.alias}.${sql.identifier(remoteAttribute)}`);
+                                        });
+                                    }, [
+                                        assertAllowed,
+                                        foreignTable,
+                                        foreignTableExpression,
+                                        localAttributes,
+                                        remoteAttributes,
+                                        sql,
+                                    ]),
+                                })),
+                            }, `Adding connection filter backward many relation exists field for ${fieldName}`);
+                        }
+                    }
+                }
+                // ─── Part 2: Add some/every/none fields to "many" filter types ───
+                if (isPgConnectionFilterMany && scopeForeignTable) {
+                    const foreignTableTypeName = inflection.tableType(scopeForeignTable.codec);
+                    const foreignTableFilterTypeName = inflection.filterType(foreignTableTypeName);
+                    const ForeignTableFilterType = build.getTypeByName(foreignTableFilterTypeName);
+                    if (!ForeignTableFilterType)
+                        return fields;
+                    fields = extend(fields, {
+                        // `some`: EXISTS (... WHERE join AND filter)
+                        some: fieldWithHooks({
+                            fieldName: 'some',
+                            isPgConnectionFilterField: true,
+                        }, () => ({
+                            description: 'Filters to entities where at least one related entity matches.',
+                            type: ForeignTableFilterType,
+                            apply: EXPORTABLE((assertAllowed, sql) => function ($where, value) {
+                                assertAllowed(value, 'object');
+                                if (value == null)
+                                    return;
+                                const rel = $where._manyRelation;
+                                if (!rel)
+                                    return;
+                                const $subQuery = $where.existsPlan({
+                                    tableExpression: rel.foreignTableExpression,
+                                    alias: rel.foreignTable.name,
+                                });
+                                rel.localAttributes.forEach((la, i) => {
+                                    $subQuery.where(sql `${$where.alias}.${sql.identifier(la)} = ${$subQuery.alias}.${sql.identifier(rel.remoteAttributes[i])}`);
+                                });
+                                return $subQuery;
+                            }, [assertAllowed, sql]),
+                        })),
+                        // `every`: NOT EXISTS (... WHERE join AND NOT(filter))
+                        every: fieldWithHooks({
+                            fieldName: 'every',
+                            isPgConnectionFilterField: true,
+                        }, () => ({
+                            description: 'Filters to entities where every related entity matches.',
+                            type: ForeignTableFilterType,
+                            apply: EXPORTABLE((assertAllowed, sql) => function ($where, value) {
+                                assertAllowed(value, 'object');
+                                if (value == null)
+                                    return;
+                                const rel = $where._manyRelation;
+                                if (!rel)
+                                    return;
+                                // NOT EXISTS (... WHERE join AND NOT(filter))
+                                const $subQuery = $where.existsPlan({
+                                    tableExpression: rel.foreignTableExpression,
+                                    alias: rel.foreignTable.name,
+                                    equals: false,
+                                });
+                                rel.localAttributes.forEach((la, i) => {
+                                    $subQuery.where(sql `${$where.alias}.${sql.identifier(la)} = ${$subQuery.alias}.${sql.identifier(rel.remoteAttributes[i])}`);
+                                });
+                                // Negate the inner filter conditions
+                                const $not = $subQuery.notPlan();
+                                return $not;
+                            }, [assertAllowed, sql]),
+                        })),
+                        // `none`: NOT EXISTS (... WHERE join AND filter)
+                        none: fieldWithHooks({
+                            fieldName: 'none',
+                            isPgConnectionFilterField: true,
+                        }, () => ({
+                            description: 'Filters to entities where no related entity matches.',
+                            type: ForeignTableFilterType,
+                            apply: EXPORTABLE((assertAllowed, sql) => function ($where, value) {
+                                assertAllowed(value, 'object');
+                                if (value == null)
+                                    return;
+                                const rel = $where._manyRelation;
+                                if (!rel)
+                                    return;
+                                // NOT EXISTS (... WHERE join AND filter)
+                                const $subQuery = $where.existsPlan({
+                                    tableExpression: rel.foreignTableExpression,
+                                    alias: rel.foreignTable.name,
+                                    equals: false,
+                                });
+                                rel.localAttributes.forEach((la, i) => {
+                                    $subQuery.where(sql `${$where.alias}.${sql.identifier(la)} = ${$subQuery.alias}.${sql.identifier(rel.remoteAttributes[i])}`);
+                                });
+                                return $subQuery;
+                            }, [assertAllowed, sql]),
+                        })),
+                    }, 'Adding some/every/none fields to many filter type');
+                }
+                return fields;
+            },
+        },
+    },
+};

package/esm/plugins/ConnectionFilterComputedAttributesPlugin.d.ts

@@ -0,0 +1,19 @@
+import '../augmentations';
+import type { GraphileConfig } from 'graphile-config';
+/**
+ * ConnectionFilterComputedAttributesPlugin
+ *
+ * Adds filter fields for computed columns (PostgreSQL functions that take
+ * a table row as their first argument and return a scalar).
+ *
+ * For example, given:
+ *   CREATE FUNCTION person_full_name(person) RETURNS text AS $$ ... $$;
+ *
+ * This plugin adds a `fullName` filter field to `PersonFilter`, typed as `StringFilter`,
+ * allowing queries like:
+ *   { people(filter: { fullName: { startsWith: "John" } }) { ... } }
+ *
+ * Controlled by the `connectionFilterComputedColumns` schema option (default: true).
+ * Requires the `filterBy` behavior on the pgResource to be enabled.
+ */
+export declare const ConnectionFilterComputedAttributesPlugin: GraphileConfig.Plugin;

package/esm/plugins/ConnectionFilterComputedAttributesPlugin.js

@@ -0,0 +1,133 @@
+import '../augmentations';
+import { isComputedScalarAttributeResource, getComputedAttributeResources, } from '../utils';
+const version = '1.0.0';
+/**
+ * ConnectionFilterComputedAttributesPlugin
+ *
+ * Adds filter fields for computed columns (PostgreSQL functions that take
+ * a table row as their first argument and return a scalar).
+ *
+ * For example, given:
+ *   CREATE FUNCTION person_full_name(person) RETURNS text AS $$ ... $$;
+ *
+ * This plugin adds a `fullName` filter field to `PersonFilter`, typed as `StringFilter`,
+ * allowing queries like:
+ *   { people(filter: { fullName: { startsWith: "John" } }) { ... } }
+ *
+ * Controlled by the `connectionFilterComputedColumns` schema option (default: true).
+ * Requires the `filterBy` behavior on the pgResource to be enabled.
+ */
+export const ConnectionFilterComputedAttributesPlugin = {
+    name: 'ConnectionFilterComputedAttributesPlugin',
+    version,
+    description: 'Adds filter fields for computed column functions (scalar-returning functions that take a table row)',
+    schema: {
+        behaviorRegistry: {
+            add: {
+                filterBy: {
+                    description: 'Whether a computed attribute resource should be available as a filter field',
+                    entities: ['pgResource'],
+                },
+            },
+        },
+        entityBehavior: {
+            pgResource: {
+                inferred(behavior, entity, build) {
+                    if (build.options.connectionFilterComputedColumns &&
+                        isComputedScalarAttributeResource(entity)) {
+                        return [behavior, 'filterBy'];
+                    }
+                    return behavior;
+                },
+            },
+        },
+        hooks: {
+            GraphQLInputObjectType_fields(inFields, build, context) {
+                let fields = inFields;
+                const { inflection, connectionFilterOperatorsDigest, dataplanPg: { TYPES, PgCondition }, EXPORTABLE, } = build;
+                const { fieldWithHooks, scope: { pgCodec: codec, isPgConnectionFilter }, } = context;
+                // Only apply to table-level filter types (e.g. UserFilter)
+                if (!isPgConnectionFilter ||
+                    !codec ||
+                    !codec.attributes ||
+                    codec.isAnonymous) {
+                    return fields;
+                }
+                // Find the source resource for this codec
+                const source = Object.values(build.input.pgRegistry.pgResources).find((s) => s.codec === codec && !s.parameters && !s.isUnique);
+                if (!source) {
+                    return fields;
+                }
+                const computedAttributeResources = getComputedAttributeResources(build, source);
+                for (const computedAttributeResource of computedAttributeResources) {
+                    // Must return a scalar or an array (not a composite)
+                    if (!computedAttributeResource.isUnique) {
+                        continue;
+                    }
+                    if (computedAttributeResource.codec.attributes) {
+                        continue;
+                    }
+                    if (computedAttributeResource.codec === TYPES.void) {
+                        continue;
+                    }
+                    // Get the operator type for this codec
+                    const digest = connectionFilterOperatorsDigest(computedAttributeResource.codec);
+                    if (!digest) {
+                        continue;
+                    }
+                    const OperatorsType = build.getTypeByName(digest.operatorsTypeName);
+                    if (!OperatorsType) {
+                        continue;
+                    }
+                    // Check behavior
+                    if (!build.behavior.pgResourceMatches(computedAttributeResource, 'filterBy')) {
+                        continue;
+                    }
+                    // Must have no required arguments beyond the first (the table row)
+                    const { argDetails } = build.pgGetArgDetailsFromParameters(computedAttributeResource, computedAttributeResource.parameters.slice(1));
+                    if (argDetails.some((a) => a.required)) {
+                        continue;
+                    }
+                    // Derive the field name from the computed attribute function
+                    const fieldName = inflection.computedAttributeField({
+                        resource: computedAttributeResource,
+                    });
+                    const functionResultCodec = computedAttributeResource.codec;
+                    fields = build.extend(fields, {
+                        [fieldName]: fieldWithHooks({
+                            fieldName,
+                            isPgConnectionFilterField: true,
+                        }, {
+                            description: `Filter by the object\u2019s \`${fieldName}\` field.`,
+                            type: OperatorsType,
+                            apply: EXPORTABLE((PgCondition, computedAttributeResource, fieldName, functionResultCodec) => function ($where, value) {
+                                if (typeof computedAttributeResource.from !==
+                                    'function') {
+                                    throw new Error(`Unexpected...`);
+                                }
+                                if (value == null)
+                                    return;
+                                const expression = computedAttributeResource.from({
+                                    placeholder: $where.alias,
+                                });
+                                const $col = new PgCondition($where);
+                                $col.extensions.pgFilterAttribute = {
+                                    fieldName,
+                                    codec: functionResultCodec,
+                                    expression,
+                                };
+                                return $col;
+                            }, [
+                                PgCondition,
+                                computedAttributeResource,
+                                fieldName,
+                                functionResultCodec,
+                            ]),
+                        }),
+                    }, '');
+                }
+                return fields;
+            },
+        },
+    },
+};