graphile-pg-aggregates 1.1.0

package/esm/AggregatesSmartTagsPlugin.js

@@ -0,0 +1,62 @@
+const version = '1.0.0';
+const EMPTY_OBJECT = Object.freeze({});
+export const PgAggregatesSmartTagsPlugin = {
+    name: 'PgAggregatesSmartTagsPlugin',
+    description: 'For compatibility with PostGraphile v4 schemas, this plugin attempts to convert `@aggregates` V4 smart tags to V5 behaviors',
+    version,
+    before: [
+        'PgAggregatesAddAggregateTypesPlugin',
+        'PgAggregatesFilterRelationalAggregatesPlugin',
+        'PgAggregatesOrderByAggregatesPlugin'
+    ],
+    provides: ['smart-tags'],
+    gather: {
+        namespace: 'pgV4AggregatesSmartTags',
+        initialCache() {
+            return EMPTY_OBJECT;
+        },
+        initialState() {
+            return EMPTY_OBJECT;
+        },
+        helpers: {},
+        hooks: {
+            // Run in the 'introspection' phase before anything uses the tags
+            pgIntrospection_introspection(info, event) {
+                for (const pgClass of event.introspection.classes) {
+                    processTags(pgClass.getTags());
+                }
+            }
+        }
+    }
+};
+function processTags(tags) {
+    switch (tags?.aggregates) {
+        case 'on':
+            addBehaviorToTags(tags, '+aggregates +aggregates:filterBy +aggregates:orderBy +aggregate +aggregate:filterBy +aggregate:orderBy');
+            break;
+        case 'off':
+            addBehaviorToTags(tags, '-aggregates -aggregates:filterBy -aggregates:orderBy -aggregate -aggregate:filterBy -aggregate:orderBy');
+            break;
+    }
+}
+function addBehaviorToTags(tags, behavior, prepend = false) {
+    if (Array.isArray(tags.behavior)) {
+        if (prepend) {
+            tags.behavior = [behavior, ...tags.behavior];
+        }
+        else {
+            tags.behavior = [...tags.behavior, behavior];
+        }
+    }
+    else if (typeof tags.behavior === 'string') {
+        tags.behavior = prepend
+            ? [behavior, tags.behavior]
+            : [tags.behavior, behavior];
+    }
+    else if (!tags.behavior) {
+        tags.behavior = [behavior];
+    }
+    else {
+        throw new Error(`Did not understand tags.behavior - it wasn't an array or a string`);
+    }
+}

package/esm/EXPORTABLE.d.ts

@@ -0,0 +1 @@
+export declare function EXPORTABLE<T, TScope extends any[]>(factory: (...args: TScope) => T, args: [...TScope], nameHint?: string): T;

package/esm/EXPORTABLE.js

@@ -0,0 +1,12 @@
+export function EXPORTABLE(factory, args, nameHint) {
+    const fn = factory(...args);
+    if (((typeof fn === 'object' && fn !== null) || typeof fn === 'function') &&
+        !('$exporter$factory' in fn)) {
+        Object.defineProperties(fn, {
+            $exporter$args: { value: args },
+            $exporter$factory: { value: factory },
+            $exporter$name: { writable: true, value: nameHint }
+        });
+    }
+    return fn;
+}

package/esm/FilterRelationalAggregatesPlugin.d.ts

@@ -0,0 +1,74 @@
+import type { PgCodec, PgConditionCapableParent, PgWhereConditionSpec, sql } from '@dataplan/pg';
+import type { Modifier } from 'grafast';
+import type { AggregateSpec } from './interfaces';
+type PgSQL = typeof sql;
+type SQL = ReturnType<PgSQL>;
+declare global {
+    namespace DataplanPg {
+        interface PgConditionExtensions {
+            pgFilterAttribute?: {
+                fieldName?: string;
+                codec: PgCodec;
+                expression?: SQL;
+            };
+        }
+    }
+    namespace GraphileBuild {
+        interface Build {
+            PgAggregateCondition: PgAggregateConditionClass;
+            PgAggregateConditionExpression: PgAggregateConditionExpressionClass;
+        }
+        interface BehaviorStrings {
+            'resource:aggregates:filterBy': true;
+            'aggregates:filterBy': true;
+            'aggregate:filterBy': true;
+            'sum:resource:aggregates:filterBy': true;
+            'distinctCount:resource:aggregates:filterBy': true;
+            'min:resource:aggregates:filterBy': true;
+            'max:resource:aggregates:filterBy': true;
+            'average:resource:aggregates:filterBy': true;
+            'stddevSample:resource:aggregates:filterBy': true;
+            'stddevPopulation:resource:aggregates:filterBy': true;
+            'varianceSample:resource:aggregates:filterBy': true;
+            'variancePopulation:resource:aggregates:filterBy': true;
+            'sum:attribute:aggregate:filterBy': true;
+            'distinctCount:attribute:aggregate:filterBy': true;
+            'min:attribute:aggregate:filterBy': true;
+            'max:attribute:aggregate:filterBy': true;
+            'average:attribute:aggregate:filterBy': true;
+            'stddevSample:attribute:aggregate:filterBy': true;
+            'stddevPopulation:attribute:aggregate:filterBy': true;
+            'varianceSample:attribute:aggregate:filterBy': true;
+            'variancePopulation:attribute:aggregate:filterBy': true;
+        }
+    }
+}
+export declare const Plugin: GraphileConfig.Plugin;
+export { Plugin as PgAggregatesFilterRelationalAggregatesPlugin };
+interface PgAggregateCondition<TParentStep extends PgConditionCapableParent> extends Modifier<TParentStep> {
+    sql: PgSQL;
+    tableExpression: SQL;
+    alias: SQL;
+    conditions: PgWhereConditionSpec<any>[];
+    expressions: SQL[];
+    where(condition: PgWhereConditionSpec<any>): void;
+    expression(expression: SQL): void;
+    forAggregate(spec: AggregateSpec): PgAggregateConditionExpression;
+    apply(): void;
+}
+interface PgAggregateConditionClass {
+    new <TParentStep extends PgConditionCapableParent>($parent: TParentStep, options: {
+        sql: PgSQL;
+        tableExpression: SQL;
+        alias?: string;
+    }, pgWhereConditionSpecListToSQL: GraphileBuild.Build['dataplanPg']['pgWhereConditionSpecListToSQL']): PgAggregateCondition<TParentStep>;
+}
+interface PgAggregateConditionExpression extends Modifier<PgAggregateCondition<any>> {
+    alias: SQL;
+    conditions: PgWhereConditionSpec<any>[];
+    where(condition: PgWhereConditionSpec<any>): void;
+    apply(): void;
+}
+interface PgAggregateConditionExpressionClass {
+    new ($parent: PgAggregateCondition<any>, spec: AggregateSpec, pgWhereConditionSpecListToSQL: GraphileBuild.Build['dataplanPg']['pgWhereConditionSpecListToSQL']): PgAggregateConditionExpression;
+}

package/esm/FilterRelationalAggregatesPlugin.js

@@ -0,0 +1,440 @@
+import { EXPORTABLE } from './EXPORTABLE';
+const version = '1.0.0';
+const pgAggregateApplyAttributeOrder = EXPORTABLE(() => (PgCondition, sql, spec, attributeName, attrCodec, rawAttrCodec, $parent, input) => {
+    if (input == null)
+        return;
+    const $col = new PgCondition($parent);
+    $col.extensions.pgFilterAttribute = {
+        codec: attrCodec,
+        expression: spec.sqlAggregateWrap(sql `${$col.alias}.${sql.identifier(attributeName)}`, rawAttrCodec)
+    };
+    return $col;
+}, [], 'pgAggregateApplyAttributeOrder');
+const pgAggregateApplyComputedAttributeOrder = EXPORTABLE(() => (PgCondition, sql, spec, proc, attrCodec, $parent, input) => {
+    if (input == null)
+        return;
+    const $col = new PgCondition($parent);
+    const sqlComputedAttributeCall = sql.query `${typeof proc.from === 'function'
+        ? proc.from({ placeholder: $col.alias })
+        : proc.from}`;
+    $col.extensions.pgFilterAttribute = {
+        codec: attrCodec,
+        expression: spec.sqlAggregateWrap(sqlComputedAttributeCall, proc.codec)
+    };
+    return $col;
+}, [], 'pgAggregateApplyComputedAttributeOrder');
+const pgAggregateApplyForeignCondition = EXPORTABLE(() => function (PgCondition, $subquery, input) {
+    if (input == null)
+        return;
+    // Enable all the helpers
+    const $condition = new PgCondition($subquery, false, 'AND');
+    return $condition;
+}, [], 'pgAggregateApplyForeignCondition');
+const pgAggregatesApply = EXPORTABLE(() => (PgAggregateCondition, pgWhereConditionSpecListToSQL, sql, $where, input) => {
+    if (input == null)
+        return;
+    // Constructive fork: read from _manyRelation (set by our
+    // ConnectionFilterBackwardRelationsPlugin) instead of upstream's
+    // $where.extensions.pgFilterRelation.
+    const rel = $where._manyRelation;
+    if (!rel) {
+        throw new Error(`Invalid use of aggregates filter: '_manyRelation' expected on $where. ` +
+            `Ensure graphile-connection-filter backward relations plugin has tagged $where.`);
+    }
+    const { localAttributes, remoteAttributes, foreignTableExpression, foreignTable } = rel;
+    const $subQuery = new PgAggregateCondition($where, {
+        sql,
+        tableExpression: foreignTableExpression,
+        alias: foreignTable.name
+    }, pgWhereConditionSpecListToSQL);
+    localAttributes.forEach((localAttribute, i) => {
+        const remoteAttribute = remoteAttributes[i];
+        $subQuery.where(sql `${$where.alias}.${sql.identifier(localAttribute)} = ${$subQuery.alias}.${sql.identifier(remoteAttribute)}`);
+    });
+    return $subQuery;
+}, [], 'pgAggregatesApply');
+export const Plugin = {
+    name: 'PgAggregatesFilterRelationalAggregatesPlugin',
+    description: `\
+Adds the ability to filter a collection by aggregates on relationships via \
+graphile-connection-filter, e.g. filtering all players based on \
+the sum of their points scored.`,
+    version,
+    // This has to run AFTER any plugins that provide `build.pgAggregateSpecs`
+    // otherwise we might add codecs to build.allPgCodecs before all the relevant
+    // codecs/specs are available.
+    after: ['PgBasicsPlugin', 'PgCodecsPlugin', 'aggregates'],
+    provides: ['codecs'],
+    before: ['ConnectionFilterArgPlugin'],
+    inflection: {
+        add: {
+            // TODO: rename this!
+            filterTableAggregateType(_preset, foreignTable, spec) {
+                const foreignTableTypeName = this.tableType(foreignTable.codec);
+                return this.filterType(foreignTableTypeName + this.upperCamelCase(spec.id) + 'Aggregate');
+            }
+        }
+    },
+    schema: {
+        behaviorRegistry: {
+            add: {
+                'aggregates:filterBy': {
+                    description: 'Can we filter by the details of this resource whilst aggregating the resource?',
+                    entities: ['pgResource']
+                },
+                'aggregate:filterBy': {
+                    description: 'Can we filter using the value of this attribute',
+                    entities: ['pgCodecAttribute']
+                }
+            }
+        },
+        entityBehavior: {
+            pgResource: ['aggregates:filterBy', 'aggregate:filterBy'],
+            pgCodecAttribute: ['aggregate:filterBy']
+        },
+        hooks: {
+            build(build) {
+                const { EXPORTABLE, grafast: { Modifier } } = build;
+                if (!build.allPgCodecs) {
+                    throw new Error('PgAggregatesFilterRelationalAggregatesPlugin must run after build.allPgCodecs has been established');
+                }
+                if (!build.pgAggregateSpecs) {
+                    throw new Error('PgAggregatesFilterRelationalAggregatesPlugin must run after build.pgAggregateSpecs has been established');
+                }
+                // Add aggregate derivative codecs to `allPgCodecs`
+                for (const spec of build.pgAggregateSpecs) {
+                    if (!spec.pgTypeCodecModifier) {
+                        continue;
+                    }
+                    for (const existingCodec of build.allPgCodecs) {
+                        if (spec.isSuitableType(existingCodec)) {
+                            const codec = spec.pgTypeCodecModifier(existingCodec);
+                            if (!build.allPgCodecs.has(codec)) {
+                                build.allPgCodecs.add(codec);
+                            }
+                        }
+                    }
+                }
+                const PgAggregateConditionExpression = EXPORTABLE((Modifier) => class PgAggregateConditionExpression extends Modifier {
+                    spec;
+                    pgWhereConditionSpecListToSQL;
+                    alias;
+                    conditions = [];
+                    constructor(parent, spec, pgWhereConditionSpecListToSQL) {
+                        super(parent);
+                        this.spec = spec;
+                        this.pgWhereConditionSpecListToSQL = pgWhereConditionSpecListToSQL;
+                        this.alias = parent.alias;
+                    }
+                    where(condition) {
+                        this.conditions.push(condition);
+                    }
+                    apply() {
+                        const sqlCondition = this.pgWhereConditionSpecListToSQL(this.alias, this.conditions);
+                        if (sqlCondition) {
+                            this.parent.expression(sqlCondition);
+                        }
+                    }
+                }, [Modifier]);
+                const PgAggregateCondition = EXPORTABLE((Modifier, PgAggregateConditionExpression) => class PgAggregateCondition extends Modifier {
+                    pgWhereConditionSpecListToSQL;
+                    sql;
+                    tableExpression;
+                    alias;
+                    conditions = [];
+                    expressions = [];
+                    constructor(parent, options, pgWhereConditionSpecListToSQL) {
+                        super(parent);
+                        this.pgWhereConditionSpecListToSQL = pgWhereConditionSpecListToSQL;
+                        const { sql, tableExpression, alias } = options;
+                        this.sql = sql;
+                        this.alias = sql.identifier(Symbol(alias ?? 'aggregate'));
+                        this.tableExpression = tableExpression;
+                    }
+                    where(condition) {
+                        this.conditions.push(condition);
+                    }
+                    expression(expression) {
+                        this.expressions.push(expression);
+                    }
+                    forAggregate(spec) {
+                        return new PgAggregateConditionExpression(this, spec, this.pgWhereConditionSpecListToSQL);
+                    }
+                    apply() {
+                        const { sql } = this;
+                        const sqlCondition = this.pgWhereConditionSpecListToSQL(this.alias, this.conditions);
+                        const where = sqlCondition
+                            ? sql `where ${sqlCondition}`
+                            : sql.blank;
+                        const boolExpr = this.expressions.length === 0
+                            ? sql.true
+                            : sql.parens(sql.join(this.expressions.map((expr) => sql.parens(expr)), '\nand\n'));
+                        const subquery = sql `(${sql.indent `\
+select ${boolExpr}
+from ${this.tableExpression} as ${this.alias}
+${where}`}
+group by ())`;
+                        return this.parent.where(subquery);
+                    }
+                }, [Modifier, PgAggregateConditionExpression]);
+                return build.extend(build, {
+                    PgAggregateCondition,
+                    PgAggregateConditionExpression
+                }, 'Adding step classes from postgraphile-plugin-connection-filter');
+            },
+            init(_, build) {
+                const { inflection, dataplanPg: { PgCondition }, EXPORTABLE } = build;
+                if (!inflection.filterType) {
+                    // Filter plugin is not enabled
+                    return _;
+                }
+                // Register the aggregate filter type for each table
+                for (const foreignTable of Object.values(build.input.pgRegistry.pgResources)) {
+                    if (foreignTable.parameters || !foreignTable.codec.attributes) {
+                        continue;
+                    }
+                    if (!build.behavior.pgResourceMatches(foreignTable, 'resource:aggregates:filterBy')) {
+                        continue;
+                    }
+                    const foreignTableTypeName = inflection.tableType(foreignTable.codec);
+                    const foreignTableFilterTypeName = inflection.filterType(foreignTableTypeName);
+                    const foreignTableAggregateFilterTypeName = inflection.filterType(foreignTableTypeName + 'Aggregates');
+                    build.recoverable(null, () => {
+                        const filterFieldName = 'where';
+                        build.registerInputObjectType(foreignTableAggregateFilterTypeName, {
+                            pgResource: foreignTable,
+                            isPgConnectionAggregateFilter: true
+                        }, () => {
+                            return {
+                                description: `A filter to be used against aggregates of \`${foreignTableTypeName}\` object types.`,
+                                fields: () => {
+                                    const type = build.getTypeByName(foreignTableFilterTypeName);
+                                    if (!type) {
+                                        return {};
+                                    }
+                                    return {
+                                        [filterFieldName]: {
+                                            description: `A filter that must pass for the relevant \`${foreignTableTypeName}\` object to be included within the aggregate.`,
+                                            type,
+                                            apply: EXPORTABLE((PgCondition, pgAggregateApplyForeignCondition) => ($subquery, input) => pgAggregateApplyForeignCondition(PgCondition, $subquery, input), [PgCondition, pgAggregateApplyForeignCondition], `${filterFieldName}Apply`)
+                                            // No need to auto-apply since we're applied manually via `fieldArgs.apply($subQuery)` below.
+                                        }
+                                    };
+                                }
+                            };
+                        }, 'Adding aggregate filter input type');
+                    });
+                    // Register the aggregate spec filter type for each aggreage spec for each source
+                    for (const spec of build.pgAggregateSpecs) {
+                        if (!build.behavior.pgResourceMatches(foreignTable, `${spec.id}:resource:aggregates:filterBy`)) {
+                            continue;
+                        }
+                        const filterTypeName = inflection.filterTableAggregateType(foreignTable, spec);
+                        build.registerInputObjectType(filterTypeName, {
+                            isPgConnectionAggregateAggregateFilter: true,
+                            pgConnectionAggregateFilterAggregateSpec: spec,
+                            pgTypeResource: foreignTable
+                        }, () => ({}), `Add '${spec.id}' aggregate filter type for '${foreignTableTypeName}'`);
+                    }
+                }
+                return _;
+            },
+            // This hook adds 'aggregates' under a "backwards" relation, siblings of
+            // every, some, none.
+            // See https://github.com/graphile-contrib/postgraphile-plugin-connection-filter/blob/6223cdb1d2ac5723aecdf55f735a18f8e2b98683/src/PgConnectionArgFilterBackwardRelationsPlugin.ts#L374
+            GraphQLInputObjectType_fields(inFields, build, context) {
+                let fields = inFields;
+                const { extend, inflection, sql, pgAggregateSpecs, dataplanPg: { PgCondition, pgWhereConditionSpecListToSQL }, PgAggregateCondition, EXPORTABLE } = build;
+                if (!inflection.filterType) {
+                    // Filter plugin is not enabled
+                    return inFields;
+                }
+                const { fieldWithHooks, scope: { foreignTable, isPgConnectionFilterMany, isPgConnectionAggregateFilter, pgResource, isPgConnectionAggregateAggregateFilter, pgConnectionAggregateFilterAggregateSpec: spec, pgTypeResource } } = context;
+                // Add 'aggregates' field to relation filters, next to `every`/`some`/`none`
+                fields = (() => {
+                    if (!isPgConnectionFilterMany || !foreignTable)
+                        return fields;
+                    const foreignTableTypeName = inflection.tableType(foreignTable.codec);
+                    const foreignTableAggregateFilterTypeName = inflection.filterType(foreignTableTypeName + 'Aggregates');
+                    const fieldName = 'aggregates';
+                    const AggregateType = build.getTypeByName(foreignTableAggregateFilterTypeName);
+                    if (!AggregateType) {
+                        return fields;
+                    }
+                    return build.extend(fields, {
+                        [fieldName]: fieldWithHooks({
+                            fieldName,
+                            isPgConnectionFilterAggregatesField: true
+                        }, {
+                            description: `Aggregates across related \`${foreignTableTypeName}\` match the filter criteria.`,
+                            type: AggregateType,
+                            apply: EXPORTABLE((PgAggregateCondition, pgAggregatesApply, pgWhereConditionSpecListToSQL, sql) => function ($where, input) {
+                                return pgAggregatesApply(PgAggregateCondition, pgWhereConditionSpecListToSQL, sql, $where, input);
+                            }, [
+                                PgAggregateCondition,
+                                pgAggregatesApply,
+                                pgWhereConditionSpecListToSQL,
+                                sql
+                            ])
+                            // No need to auto-apply, postgraphile-plugin-connection-filter explicitly calls fieldArgs.apply()
+                        })
+                    }, "Adding 'aggregates' filter field on relation");
+                })();
+                // This hook adds our various aggregates to the 'aggregates' input defined in `AggregateType` above
+                fields = (() => {
+                    if (!isPgConnectionAggregateFilter ||
+                        !pgResource ||
+                        pgResource.parameters ||
+                        !pgResource.codec.attributes) {
+                        return fields;
+                    }
+                    const foreignTable = pgResource;
+                    const foreignTableTypeName = inflection.tableType(foreignTable.codec);
+                    return pgAggregateSpecs.reduce((memo, spec) => {
+                        const filterTypeName = inflection.filterTableAggregateType(foreignTable, spec);
+                        const fieldName = inflection.camelCase(spec.id);
+                        const type = build.getTypeByName(filterTypeName);
+                        if (!type) {
+                            return memo;
+                        }
+                        return extend(memo, {
+                            [fieldName]: fieldWithHooks({ fieldName }, () => ({
+                                type,
+                                description: `${spec.HumanLabel} aggregate over matching \`${foreignTableTypeName}\` objects.`,
+                                apply: EXPORTABLE((spec) => function ($subquery, input) {
+                                    if (input == null)
+                                        return;
+                                    return $subquery.forAggregate(spec);
+                                }, [spec])
+                            }))
+                        }, `Adding aggregate '${spec.id}' filter input for '${pgResource.name}'. `);
+                    }, fields);
+                })();
+                // This hook adds matching attributes to the relevant aggregate types.
+                fields = (() => {
+                    if (!isPgConnectionAggregateAggregateFilter ||
+                        !spec ||
+                        !pgTypeResource ||
+                        pgTypeResource.parameters ||
+                        !pgTypeResource.codec.attributes) {
+                        return fields;
+                    }
+                    const table = pgTypeResource;
+                    const attributes = table.codec.attributes;
+                    fields = extend(fields, {
+                        ...Object.entries(attributes).reduce((memo, [attributeName, attribute]) => {
+                            if (!build.behavior.pgCodecAttributeMatches([table.codec, attributeName], `${spec.id}:attribute:aggregate:filterBy`)) {
+                                return memo;
+                            }
+                            if ((spec.shouldApplyToEntity &&
+                                !spec.shouldApplyToEntity({
+                                    type: 'attribute',
+                                    codec: table.codec,
+                                    attributeName: attributeName
+                                })) ||
+                                !spec.isSuitableType(attribute.codec)) {
+                                return memo;
+                            }
+                            const rawAttrCodec = attribute.codec;
+                            const attrCodec = spec.pgTypeCodecModifier
+                                ? spec.pgTypeCodecModifier(attribute.codec)
+                                : attribute.codec;
+                            const fieldName = inflection.attribute({
+                                codec: table.codec,
+                                attributeName
+                            });
+                            const digest = build.connectionFilterOperatorsDigest(attrCodec);
+                            if (!digest) {
+                                return memo;
+                            }
+                            const OperatorsType = build.getTypeByName(digest.operatorsTypeName);
+                            if (!OperatorsType) {
+                                return memo;
+                            }
+                            return build.extend(memo, {
+                                [fieldName]: {
+                                    type: OperatorsType,
+                                    apply: EXPORTABLE((PgCondition, attrCodec, attributeName, pgAggregateApplyAttributeOrder, rawAttrCodec, spec, sql) => function ($parent, input) {
+                                        return pgAggregateApplyAttributeOrder(PgCondition, sql, spec, attributeName, attrCodec, rawAttrCodec, $parent, input);
+                                    }, [
+                                        PgCondition,
+                                        attrCodec,
+                                        attributeName,
+                                        pgAggregateApplyAttributeOrder,
+                                        rawAttrCodec,
+                                        spec,
+                                        sql
+                                    ])
+                                    // No need to auto-apply since we're called via `fieldArgs.apply($subquery.forAggregate(spec))` above
+                                }
+                            }, `Add aggregate '${attributeName}' filter for source '${table.name}' for spec '${spec.id}'`);
+                        }, Object.create(null))
+                    }, `Adding per-attribute '${spec.id}' aggregate filters for '${pgTypeResource.name}'`);
+                    const computedAttributeResources = Object.values(build.input.pgRegistry.pgResources).filter((s) => isComputedScalarAttributeResource(s) &&
+                        s.parameters[0].codec === table.codec &&
+                        s.parameters.slice(1).every((p) => p.optional));
+                    fields = extend(fields, {
+                        ...computedAttributeResources.reduce((memo, proc) => {
+                            if ((spec.shouldApplyToEntity &&
+                                !spec.shouldApplyToEntity({
+                                    type: 'computedAttribute',
+                                    resource: proc
+                                })) ||
+                                !spec.isSuitableType(proc.codec)) {
+                                return memo;
+                            }
+                            const fieldName = inflection.computedAttributeField({
+                                resource: proc
+                            });
+                            const attrCodec = spec.pgTypeCodecModifier
+                                ? spec.pgTypeCodecModifier(proc.codec)
+                                : proc.codec;
+                            const digest = build.connectionFilterOperatorsDigest(attrCodec);
+                            if (!digest) {
+                                return memo;
+                            }
+                            const OperatorsType = build.getTypeByName(digest.operatorsTypeName);
+                            if (!OperatorsType) {
+                                return memo;
+                            }
+                            return build.extend(memo, {
+                                [fieldName]: {
+                                    type: OperatorsType,
+                                    apply: EXPORTABLE((PgCondition, attrCodec, pgAggregateApplyComputedAttributeOrder, proc, spec, sql) => function apply($parent, input) {
+                                        return pgAggregateApplyComputedAttributeOrder(PgCondition, sql, spec, proc, attrCodec, $parent, input);
+                                    }, [
+                                        PgCondition,
+                                        attrCodec,
+                                        pgAggregateApplyComputedAttributeOrder,
+                                        proc,
+                                        spec,
+                                        sql
+                                    ])
+                                }
+                            }, `Add computed aggregate '${fieldName}' filter for source '${table.name}' for spec '${spec.id}'`);
+                        }, Object.create(null))
+                    }, `Adding per-computed-column '${spec.id}' aggregate filters for '${pgTypeResource.name}'`);
+                    return fields;
+                })();
+                return fields;
+            }
+        }
+    }
+};
+export { Plugin as PgAggregatesFilterRelationalAggregatesPlugin };
+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;
+}

package/esm/InflectionPlugin.d.ts

@@ -0,0 +1,67 @@
+import type { PgCodecWithAttributes, PgRegistry, PgResource } from '@dataplan/pg';
+import type { AggregateGroupBySpec, AggregateSpec, CORE_HAVING_FILTER_SPECS } from './interfaces';
+declare global {
+    namespace GraphileBuild {
+        interface Inflection {
+            aggregateContainerType(this: Inflection, details: {
+                resource: PgResource<any, any, any, any, any>;
+            }): string;
+            aggregateType(this: Inflection, details: {
+                resource: PgResource<any, any, any, any, any>;
+                aggregateSpec: AggregateSpec;
+            }): string;
+            aggregatesContainerField(this: Inflection, details: {
+                resource: PgResource<any, any, any, any, any>;
+            }): string;
+            groupedAggregatesContainerField(this: Inflection, details: {
+                resource: PgResource<any, any, any, any, any>;
+            }): string;
+            aggregatesField(this: Inflection, details: {
+                aggregateSpec: AggregateSpec;
+            }): string;
+            aggregateGroupByType(this: Inflection, details: {
+                resource: PgResource<any, any, any, any, any>;
+            }): string;
+            aggregateGroupByAttributeEnum(this: Inflection, details: {
+                resource: PgResource<any, any, any, any, any>;
+                attributeName: string;
+            }): string;
+            aggregateHavingInputType(this: Inflection, details: {
+                resource: PgResource<any, any, any, any, any>;
+            }): string;
+            aggregateHavingAggregateInputType(this: Inflection, details: {
+                resource: PgResource<any, any, any, any, any>;
+                aggregateSpec: AggregateSpec;
+            }): string;
+            aggregateHavingAggregateComputedAttributeInputType(this: Inflection, details: {
+                resource: PgResource<any, any, any, any, any>;
+                aggregateSpec: AggregateSpec;
+                computedAttributeResource: PgResource<any, any, any, any, any>;
+            }): string;
+            aggregateHavingAggregateComputedAttributeArgsInputType(this: Inflection, details: {
+                resource: PgResource<any, any, any, any, any>;
+                aggregateSpec: AggregateSpec;
+                computedAttributeResource: PgResource<any, any, any, any, any>;
+            }): string;
+            aggregateGroupByAttributeDerivativeEnum(this: Inflection, details: {
+                resource: PgResource<any, any, any, any, any>;
+                attributeName: string;
+                aggregateGroupBySpec: AggregateGroupBySpec;
+            }): string;
+            orderByCountOfManyRelationByKeys(this: Inflection, details: {
+                registry: PgRegistry;
+                codec: PgCodecWithAttributes;
+                relationName: string;
+            }): string;
+            orderByAttributeAggregateOfManyRelationByKeys(this: Inflection, details: {
+                registry: PgRegistry;
+                codec: PgCodecWithAttributes;
+                relationName: string;
+                aggregateSpec: AggregateSpec;
+                attributeName: string;
+            }): string;
+            aggregateHavingFilterInputType(this: Inflection, spec: (typeof CORE_HAVING_FILTER_SPECS)[number]): string;
+        }
+    }
+}
+export declare const PgAggregatesInflectorsPlugin: GraphileConfig.Plugin;