graphile-pg-aggregates 1.1.0

package/FilterRelationalAggregatesPlugin.js

@@ -0,0 +1,443 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PgAggregatesFilterRelationalAggregatesPlugin = exports.Plugin = void 0;
+const EXPORTABLE_1 = require("./EXPORTABLE");
+const version = '1.0.0';
+const pgAggregateApplyAttributeOrder = (0, EXPORTABLE_1.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 = (0, EXPORTABLE_1.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 = (0, EXPORTABLE_1.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 = (0, EXPORTABLE_1.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');
+exports.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;
+            }
+        }
+    }
+};
+exports.PgAggregatesFilterRelationalAggregatesPlugin = exports.Plugin;
+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/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;

package/InflectionPlugin.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PgAggregatesInflectorsPlugin = void 0;
+const version = '1.0.0';
+exports.PgAggregatesInflectorsPlugin = {
+    name: 'PgAggregatesInflectorsPlugin',
+    description: 'Adds the inflectors used by the pg-aggregates preset.',
+    version,
+    provides: ['aggregates'],
+    inflection: {
+        add: {
+            aggregateContainerType(_preset, details) {
+                return this.upperCamelCase(`${this._singularizedCodecName(details.resource.codec)}-aggregates`);
+            },
+            aggregateType(_preset, details) {
+                return this.upperCamelCase(`${this._singularizedCodecName(details.resource.codec)}-${details.aggregateSpec.id}-aggregates`);
+            },
+            aggregatesContainerField(_preset, _details) {
+                return 'aggregates';
+            },
+            groupedAggregatesContainerField(_preset, _details) {
+                return 'groupedAggregates';
+            },
+            aggregatesField(_preset, details) {
+                return details.aggregateSpec.id;
+            },
+            aggregateGroupByType(_preset, details) {
+                return this.upperCamelCase(`${this._singularizedCodecName(details.resource.codec)}-group-by`);
+            },
+            aggregateGroupByAttributeEnum(_preset, details) {
+                return this.constantCase(`${this._attributeName({
+                    attributeName: details.attributeName,
+                    codec: details.resource.codec
+                })}`);
+            },
+            aggregateHavingInputType(_preset, details) {
+                return this.upperCamelCase(`${this._singularizedCodecName(details.resource.codec)}-having-input`);
+            },
+            aggregateHavingAggregateInputType(_preset, details) {
+                return this.upperCamelCase(`${this._singularizedCodecName(details.resource.codec)}-having-${details.aggregateSpec.id}-input`);
+            },
+            aggregateHavingAggregateComputedAttributeInputType(_preset, details) {
+                return this.upperCamelCase(`${this._singularizedCodecName(details.resource.codec)}-having-${details.aggregateSpec.id}-${this._resourceName(details.computedAttributeResource)}-input`);
+            },
+            aggregateHavingAggregateComputedAttributeArgsInputType(_preset, details) {
+                return this.upperCamelCase(`${this._singularizedCodecName(details.resource.codec)}-having-${details.aggregateSpec.id}-${this._resourceName(details.computedAttributeResource)}-args-input`);
+            },
+            aggregateGroupByAttributeDerivativeEnum(_preset, details) {
+                return this.constantCase(`${this._attributeName({
+                    attributeName: details.attributeName,
+                    codec: details.resource.codec
+                })}-${details.aggregateGroupBySpec.id}`);
+            },
+            orderByCountOfManyRelationByKeys(_preset, details) {
+                const relationName = this._manyRelation(details);
+                return this.constantCase(`${relationName}-count`);
+            },
+            orderByAttributeAggregateOfManyRelationByKeys(_preset, details) {
+                const relationName = this._manyRelation(details);
+                const relation = details.registry.pgRelations[details.codec.name][details.relationName];
+                return this.constantCase(`${relationName}-${details.aggregateSpec.id}-${this._attributeName({
+                    codec: relation.remoteResource.codec,
+                    attributeName: details.attributeName
+                })}`);
+            },
+            aggregateHavingFilterInputType(_preset, spec) {
+                return this.upperCamelCase(`having-${spec}-filter`);
+            }
+        }
+    }
+};

package/LICENSE

@@ -0,0 +1,23 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Dan Lynch <pyramation@gmail.com>
+Copyright (c) 2025 Constructive <developers@constructive.io>
+Copyright (c) 2020-present, Interweb, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/OrderByAggregatesPlugin.d.ts

@@ -0,0 +1,31 @@
+declare global {
+    namespace GraphileBuild {
+        interface BehaviorStrings {
+            'relatedAggregates:orderBy': true;
+            'resource:relatedAggregates:orderBy': true;
+            'aggregates:orderBy': true;
+            'manyRelation:aggregates:orderBy': true;
+            'aggregate:orderBy': true;
+            'attribute:aggregate:orderBy': true;
+            'sum:manyRelation:aggregates:orderBy': true;
+            'distinctCount:manyRelation:aggregates:orderBy': true;
+            'min:manyRelation:aggregates:orderBy': true;
+            'max:manyRelation:aggregates:orderBy': true;
+            'average:manyRelation:aggregates:orderBy': true;
+            'stddevSample:manyRelation:aggregates:orderBy': true;
+            'stddevPopulation:manyRelation:aggregates:orderBy': true;
+            'varianceSample:manyRelation:aggregates:orderBy': true;
+            'variancePopulation:manyRelation:aggregates:orderBy': true;
+            'sum:attribute:aggregate:orderBy': true;
+            'distinctCount:attribute:aggregate:orderBy': true;
+            'min:attribute:aggregate:orderBy': true;
+            'max:attribute:aggregate:orderBy': true;
+            'average:attribute:aggregate:orderBy': true;
+            'stddevSample:attribute:aggregate:orderBy': true;
+            'stddevPopulation:attribute:aggregate:orderBy': true;
+            'varianceSample:attribute:aggregate:orderBy': true;
+            'variancePopulation:attribute:aggregate:orderBy': true;
+        }
+    }
+}
+export declare const PgAggregatesOrderByAggregatesPlugin: GraphileConfig.Plugin;