graphile-pg-aggregates 1.1.0

package/AddAggregateTypesPlugin.d.ts

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

package/AddAggregateTypesPlugin.js

@@ -0,0 +1,268 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PgAggregatesAddAggregateTypesPlugin = void 0;
+const EXPORTABLE_1 = require("./EXPORTABLE");
+const utils_1 = require("./utils");
+const version = '1.0.0';
+const isSuitableSource = (build, resource) => {
+    if (resource.parameters || !resource.codec.attributes) {
+        return false;
+    }
+    if (!build.behavior.pgResourceMatches(resource, 'select')) {
+        return false;
+    }
+    return !!build.behavior.pgResourceMatches(resource, 'resource:aggregates');
+};
+const pgAggregatesPlanKeys = (0, EXPORTABLE_1.EXPORTABLE)(() => (lambda, $pgSelectSingle) => {
+    const $pgSelect = $pgSelectSingle.getClassStep();
+    const $groupDetails = $pgSelect.getGroupDetails();
+    return lambda([$groupDetails, $pgSelectSingle], ([groupDetails, item]) => {
+        if (groupDetails.indicies.length === 0 || item == null) {
+            return null;
+        }
+        else {
+            return groupDetails.indicies.map(({ index }) => item[index]);
+        }
+    });
+}, [], 'pgAggregatesPlanKeys');
+const pgAggregatesPlanAggregates = (0, EXPORTABLE_1.EXPORTABLE)(() => function plan($pgSelectSingle) {
+    return $pgSelectSingle;
+}, [], 'pgAggregatesPlanAggregates');
+const pgAggregatesPlanAggregateAttribute = (0, EXPORTABLE_1.EXPORTABLE)(() => (attributeCodec, attributeName, codec, spec, sql, $pgSelectSingle) => {
+    // Note this expression is just an sql fragment, so you
+    // could add CASE statements, function calls, or whatever
+    // you need here
+    const sqlAttribute = sql.fragment `${$pgSelectSingle.getClassStep().alias}.${sql.identifier(attributeName)}`;
+    const sqlAggregate = spec.sqlAggregateWrap(sqlAttribute, attributeCodec);
+    return $pgSelectSingle.select(sqlAggregate, codec);
+}, [], 'pgAggregatesPlanAggregateAttribute');
+const pgAggregatesPlanComputedColumnAggregates = (0, EXPORTABLE_1.EXPORTABLE)(() => (codec, computedAttributeResource, makeArgs, pgFromExpression, spec, targetCodec, $pgSelectSingle, fieldArgs) => {
+    // Because we require that the computed attribute is
+    // evaluated inline, we have to convert it to an
+    // expression here; this is only needed because of the
+    // aggregation.
+    const src = pgFromExpression($pgSelectSingle, computedAttributeResource.from, computedAttributeResource.parameters, [
+        {
+            placeholder: $pgSelectSingle.getClassStep().alias,
+            position: 0
+        },
+        ...makeArgs(fieldArgs)
+    ]);
+    const sqlAggregate = spec.sqlAggregateWrap(src, codec);
+    return $pgSelectSingle.select(sqlAggregate, targetCodec);
+}, [], 'pgAggregatesPlanComputedColumnAggregates');
+const Plugin = {
+    name: 'PgAggregatesAddAggregateTypesPlugin',
+    description: `\
+Creates the FooAggregates type for each suitable resource, creates the 'sum' \
+and similar fields on this type, and the entries within these types for \
+attributes and computed columns.`,
+    version,
+    provides: ['aggregates'],
+    // Create the aggregates type for each table
+    schema: {
+        behaviorRegistry: {
+            add: {
+                aggregates: {
+                    description: 'For collection resources (e.g. returning a setof records)',
+                    entities: ['pgResource']
+                },
+                aggregate: {
+                    description: 'for computed column resources (e.g. returning a scalar)',
+                    entities: ['pgResource']
+                }
+            }
+        },
+        entityBehavior: {
+            // `aggregates` - for collection resources (e.g. returning a setof records)
+            // `aggregate` - for computed column resources (e.g. returning a scalar)
+            pgResource: ['select', 'aggregates', 'aggregate'],
+            pgCodecAttribute: 'aggregate'
+        },
+        hooks: {
+            init(init, build, _context) {
+                const { graphql: { GraphQLList, GraphQLString }, grafast: { lambda }, dataplanPg: { assertPgClassSingleStep }, inflection, input: { pgRegistry: { pgResources } }, EXPORTABLE } = build;
+                // TODO: should we be using the codec rather than the source here? What if two sources share the same codec?
+                for (const resource of Object.values(pgResources)) {
+                    if (!isSuitableSource(build, resource)) {
+                        continue;
+                    }
+                    /* const AggregateContainerType = */
+                    build.registerObjectType(inflection.aggregateContainerType({ resource: resource }), {
+                        isPgAggregateContainerType: true,
+                        pgTypeResource: resource
+                    }, () => ({
+                        assertStep: assertPgClassSingleStep,
+                        fields: {
+                            keys: {
+                                type: new GraphQLList(GraphQLString),
+                                plan: EXPORTABLE((lambda, pgAggregatesPlanKeys) => function plan($pgSelectSingle) {
+                                    return pgAggregatesPlanKeys(lambda, $pgSelectSingle);
+                                }, [lambda, pgAggregatesPlanKeys])
+                            }
+                        }
+                    }), `@graphile/pg-aggregates aggregate container type for ${resource.name}`);
+                    for (const aggregateSpec of build.pgAggregateSpecs) {
+                        const aggregateTypeName = inflection.aggregateType({
+                            resource: resource,
+                            aggregateSpec
+                        });
+                        if (!build.behavior.pgResourceMatches(resource, `${aggregateSpec.id}:resource:aggregates`)) {
+                            continue;
+                        }
+                        build.registerObjectType(aggregateTypeName, {
+                            isPgAggregateType: true,
+                            pgAggregateSpec: aggregateSpec,
+                            pgTypeResource: resource
+                        }, () => ({}), `${aggregateTypeName} aggregate type for '${resource.name}' source`);
+                    }
+                }
+                return init;
+            },
+            GraphQLObjectType_fields(inFields, build, context) {
+                let fields = inFields;
+                const { inflection, sql, graphql: { GraphQLNonNull, isOutputType }, dataplanPg: { pgFromExpression }, EXPORTABLE } = build;
+                const { fieldWithHooks, Self, scope: { isPgAggregateContainerType, isPgAggregateType, pgTypeResource: resource, pgAggregateSpec: spec } } = context;
+                if (!resource || !isSuitableSource(build, resource)) {
+                    return fields;
+                }
+                // Hook the '*Aggregates' type for each source to add the "sum" operation
+                if (isPgAggregateContainerType) {
+                    fields = build.extend(fields, build.pgAggregateSpecs.reduce((memo, aggregateSpec) => {
+                        return build.recoverable(memo, () => {
+                            if (!build.behavior.pgResourceMatches(resource, `${aggregateSpec.id}:resource:aggregates`)) {
+                                return memo;
+                            }
+                            const aggregateTypeName = inflection.aggregateType({
+                                resource: resource,
+                                aggregateSpec
+                            });
+                            const AggregateType = build.getTypeByName(aggregateTypeName);
+                            if (!AggregateType || !isOutputType(AggregateType)) {
+                                return memo;
+                            }
+                            const fieldName = inflection.aggregatesField({ aggregateSpec });
+                            return build.extend(memo, {
+                                [fieldName]: fieldWithHooks({
+                                    fieldName,
+                                    isPgAggregateField: true,
+                                    pgAggregateSpec: aggregateSpec,
+                                    pgFieldResource: resource
+                                }, () => ({
+                                    description: `${aggregateSpec.HumanLabel} aggregates across the matching connection (ignoring before/after/first/last/offset)`,
+                                    type: AggregateType,
+                                    plan: pgAggregatesPlanAggregates
+                                }))
+                            }, `Adding aggregates field to ${Self.name}`);
+                        });
+                    }, Object.create(null)), 'Adding sum operation to aggregate type');
+                }
+                // Hook the sum aggregates type to add fields for each numeric source attribute
+                if (isPgAggregateType && spec) {
+                    fields = build.extend(fields, 
+                    // Figure out the attributes that we're allowed to do a `SUM(...)` of
+                    Object.entries(resource.codec.attributes).reduce((memo, [attributeName, attribute]) => {
+                        if (!build.behavior.pgCodecAttributeMatches([resource.codec, attributeName], `${spec.id}:attribute:aggregate`)) {
+                            return memo;
+                        }
+                        if ((spec.shouldApplyToEntity &&
+                            !spec.shouldApplyToEntity({
+                                type: 'attribute',
+                                codec: resource.codec,
+                                attributeName
+                            })) ||
+                            !spec.isSuitableType(attribute.codec)) {
+                            return memo;
+                        }
+                        const codec = spec.pgTypeCodecModifier
+                            ? spec.pgTypeCodecModifier(attribute.codec)
+                            : attribute.codec;
+                        const Type = build.getGraphQLTypeByPgCodec(codec, 'output');
+                        if (!Type) {
+                            return memo;
+                        }
+                        const fieldName = inflection.attribute({
+                            attributeName,
+                            codec: resource.codec
+                        });
+                        return build.extend(memo, {
+                            [fieldName]: fieldWithHooks({
+                                fieldName,
+                                // In case anyone wants to hook us, describe ourselves
+                                isPgConnectionAggregateField: true
+                                //pgFieldIntrospection: attr,
+                                //TODO: add more details here
+                            }, () => {
+                                const attributeCodec = attribute.codec;
+                                return {
+                                    description: `${spec.HumanLabel} of ${fieldName} across the matching connection`,
+                                    type: spec.isNonNull ? new GraphQLNonNull(Type) : Type,
+                                    plan: EXPORTABLE((attributeCodec, attributeName, codec, pgAggregatesPlanAggregateAttribute, spec, sql) => function plan($pgSelectSingle) {
+                                        return pgAggregatesPlanAggregateAttribute(attributeCodec, attributeName, codec, spec, sql, $pgSelectSingle);
+                                    }, [
+                                        attributeCodec,
+                                        attributeName,
+                                        codec,
+                                        pgAggregatesPlanAggregateAttribute,
+                                        spec,
+                                        sql
+                                    ])
+                                };
+                            })
+                        }, `Add attribute '${attributeName}' compatible with this aggregate`);
+                    }, Object.create(null)), 'Add attributes compatible with this aggregate');
+                    const computedAttributeSources = (0, utils_1.getComputedAttributeResources)(build, resource);
+                    fields = build.extend(fields, computedAttributeSources.reduce((memo, computedAttributeResource) => {
+                        if (!build.behavior.pgResourceMatches(computedAttributeResource, `${spec.id}:resource:aggregate`)) {
+                            return memo;
+                        }
+                        const codec = computedAttributeResource.codec;
+                        if ((spec.shouldApplyToEntity &&
+                            !spec.shouldApplyToEntity({
+                                type: 'computedAttribute',
+                                resource: computedAttributeResource
+                            })) ||
+                            !spec.isSuitableType(codec)) {
+                            return memo;
+                        }
+                        const fieldName = inflection.computedAttributeField({
+                            resource: computedAttributeResource
+                        });
+                        const targetCodec = spec.pgTypeCodecModifier?.(codec) ?? codec;
+                        const targetType = build.getGraphQLTypeByPgCodec(targetCodec, 'output');
+                        if (!targetType) {
+                            return memo;
+                        }
+                        return build.extend(memo, {
+                            [fieldName]: fieldWithHooks({
+                                fieldName
+                            }, () => {
+                                const { makeFieldArgs, makeArgs } = build.pgGetArgDetailsFromParameters(computedAttributeResource, computedAttributeResource.parameters, 1);
+                                return {
+                                    type: targetType,
+                                    description: `${spec.HumanLabel} of this field across the matching connection.${computedAttributeResource.description
+                                        ? `\n\n---\n\n${computedAttributeResource.description}`
+                                        : ''}`,
+                                    args: makeFieldArgs(),
+                                    plan: EXPORTABLE((codec, computedAttributeResource, makeArgs, pgAggregatesPlanComputedColumnAggregates, pgFromExpression, spec, targetCodec) => function plan($pgSelectSingle, fieldArgs) {
+                                        return pgAggregatesPlanComputedColumnAggregates(codec, computedAttributeResource, makeArgs, pgFromExpression, spec, targetCodec, $pgSelectSingle, fieldArgs);
+                                    }, [
+                                        codec,
+                                        computedAttributeResource,
+                                        makeArgs,
+                                        pgAggregatesPlanComputedColumnAggregates,
+                                        pgFromExpression,
+                                        spec,
+                                        targetCodec
+                                    ])
+                                };
+                            })
+                        }, '');
+                    }, Object.create(null)), '');
+                }
+                return fields;
+            }
+        }
+    }
+};
+exports.PgAggregatesAddAggregateTypesPlugin = Plugin;

package/AddConnectionAggregatesPlugin.d.ts

@@ -0,0 +1,2 @@
+declare const Plugin: GraphileConfig.Plugin;
+export { Plugin as PgAggregatesAddConnectionAggregatesPlugin };

package/AddConnectionAggregatesPlugin.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PgAggregatesAddConnectionAggregatesPlugin = void 0;
+const EXPORTABLE_1 = require("./EXPORTABLE");
+const version = '1.0.0';
+const pgAggregatesCloneSubplanWithoutPaginationSingle = (0, EXPORTABLE_1.EXPORTABLE)(() => function plan($connection) {
+    return $connection.cloneSubplanWithoutPagination('aggregate').single();
+}, [], 'pgAggregatesCloneSubplanWithoutPaginationSingle');
+const Plugin = {
+    name: 'PgAggregatesAddConnectionAggregatesPlugin',
+    description: 'Adds the `aggregates` field to connections.',
+    version,
+    provides: ['aggregates'],
+    schema: {
+        hooks: {
+            // Hook all connections to add the 'aggregates' field
+            GraphQLObjectType_fields(fields, build, context) {
+                const { inflection } = build;
+                const { fieldWithHooks, scope: { pgCodec, pgTypeResource, isConnectionType, isPgConnectionRelated } } = context;
+                const table = pgTypeResource ??
+                    Object.values(build.input.pgRegistry.pgResources).find((s) => s.codec === pgCodec && !s.parameters);
+                // If it's not a table connection, abort
+                if (!isConnectionType ||
+                    !isPgConnectionRelated ||
+                    !table ||
+                    table.parameters ||
+                    !table.codec.attributes) {
+                    return fields;
+                }
+                if (!build.behavior.pgResourceMatches(table, `resource:aggregates`)) {
+                    return fields;
+                }
+                const AggregateContainerType = build.getTypeByName(inflection.aggregateContainerType({ resource: table }));
+                if (!AggregateContainerType ||
+                    Object.keys(AggregateContainerType.getFields()).length === 0) {
+                    // No aggregates for this connection, abort
+                    return fields;
+                }
+                const fieldName = inflection.aggregatesContainerField({
+                    resource: table
+                });
+                return {
+                    ...fields,
+                    [fieldName]: fieldWithHooks({ fieldName }, () => {
+                        return {
+                            description: `Aggregates across the matching connection (ignoring before/after/first/last/offset)`,
+                            type: AggregateContainerType,
+                            plan: pgAggregatesCloneSubplanWithoutPaginationSingle
+                        };
+                    })
+                };
+            }
+        }
+    }
+};
+exports.PgAggregatesAddConnectionAggregatesPlugin = Plugin;

package/AddConnectionGroupedAggregatesPlugin.d.ts

@@ -0,0 +1,10 @@
+declare global {
+    namespace GraphileBuild {
+        interface BehaviorStrings {
+            'resource:groupedAggregates': true;
+            groupedAggregates: true;
+        }
+    }
+}
+declare const Plugin: GraphileConfig.Plugin;
+export { Plugin as PgAggregatesAddConnectionGroupedAggregatesPlugin };

package/AddConnectionGroupedAggregatesPlugin.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PgAggregatesAddConnectionGroupedAggregatesPlugin = void 0;
+const EXPORTABLE_1 = require("./EXPORTABLE");
+const version = '1.0.0';
+function isValidEnum(build, enumType) {
+    try {
+        if (!enumType) {
+            return false;
+        }
+        if (!(enumType instanceof build.graphql.GraphQLEnumType)) {
+            return false;
+        }
+        if (Object.keys(enumType.getValues()).length === 0) {
+            return false;
+        }
+    }
+    catch {
+        return false;
+    }
+    return true;
+}
+const pgAggregateCloneSubplanWithoutPaginationAsAggregate = (0, EXPORTABLE_1.EXPORTABLE)(() => function plan($connection) {
+    return $connection.cloneSubplanWithoutPagination('aggregate');
+}, [], 'pgAggregateCloneSubplanWithoutPaginationAsAggregate');
+const pgAggregatesApplyGroupedAggregate = (0, EXPORTABLE_1.EXPORTABLE)(() => function (_$parent, $pgSelect, input) {
+    return input.apply($pgSelect);
+}, [], 'pgAggregatesApplyGroupedAggregate');
+const pgAggregatesApplyConditionsToGroupedAggregates = (0, EXPORTABLE_1.EXPORTABLE)(() => function applyPlan(_$parent, $pgSelect, input) {
+    return input.apply($pgSelect, (queryBuilder) => queryBuilder.havingBuilder());
+}, [], 'pgAggregatesApplyConditionsToGroupedAggregates');
+const Plugin = {
+    name: 'PgAggregatesAddConnectionGroupedAggregatesPlugin',
+    description: 'Adds the groupedAggregates field to connections.',
+    version,
+    provides: ['aggregates'],
+    schema: {
+        behaviorRegistry: {
+            add: {
+                'resource:groupedAggregates': {
+                    description: 'Should we enable grouped aggregates on this resource?',
+                    entities: ['pgResource']
+                },
+                groupedAggregates: {
+                    description: 'Should we enable grouped aggregates on this resource?',
+                    entities: ['pgResource']
+                }
+            }
+        },
+        entityBehavior: {
+            pgResource: [
+                'resource:groupedAggregates',
+                'resource:groupedAggregates:having'
+            ]
+        },
+        hooks: {
+            GraphQLObjectType_fields(fields, build, context) {
+                const { graphql: { GraphQLList, GraphQLNonNull }, inflection } = build;
+                const { fieldWithHooks, scope: { pgCodec, pgTypeResource, isConnectionType, isPgConnectionRelated } } = context;
+                const table = pgTypeResource ??
+                    Object.values(build.input.pgRegistry.pgResources).find((s) => s.codec === pgCodec && !s.parameters);
+                // If it's not a table connection, abort
+                if (!isConnectionType ||
+                    !isPgConnectionRelated ||
+                    !table ||
+                    table.parameters ||
+                    !table.codec.attributes) {
+                    return fields;
+                }
+                if (!build.behavior.pgResourceMatches(table, `resource:groupedAggregates`)) {
+                    return fields;
+                }
+                const AggregateContainerType = build.getTypeByName(inflection.aggregateContainerType({ resource: table }));
+                if (!AggregateContainerType ||
+                    Object.keys(AggregateContainerType.getFields()).length === 0) {
+                    // No aggregates for this connection, abort
+                    return fields;
+                }
+                const fieldName = inflection.groupedAggregatesContainerField({
+                    resource: table
+                });
+                const TableGroupByType = build.getTypeByName(inflection.aggregateGroupByType({ resource: table }));
+                const TableHavingInputType = build.getTypeByName(inflection.aggregateHavingInputType({ resource: table }));
+                const tableTypeName = inflection.tableType(table.codec);
+                if (!TableGroupByType || !isValidEnum(build, TableGroupByType)) {
+                    return fields;
+                }
+                return {
+                    ...fields,
+                    [fieldName]: fieldWithHooks({ fieldName }, () => {
+                        return {
+                            description: `Grouped aggregates across the matching connection (ignoring before/after/first/last/offset)`,
+                            type: new GraphQLList(new GraphQLNonNull(AggregateContainerType)),
+                            args: {
+                                groupBy: {
+                                    type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(TableGroupByType))),
+                                    description: build.wrapDescription(`The method to use when grouping \`${tableTypeName}\` for these aggregates.`, 'arg'),
+                                    applyPlan: pgAggregatesApplyGroupedAggregate
+                                },
+                                ...(TableHavingInputType
+                                    ? {
+                                        having: {
+                                            type: TableHavingInputType,
+                                            description: build.wrapDescription(`Conditions on the grouped aggregates.`, 'arg'),
+                                            applyPlan: pgAggregatesApplyConditionsToGroupedAggregates
+                                        }
+                                    }
+                                    : null)
+                            },
+                            plan: pgAggregateCloneSubplanWithoutPaginationAsAggregate
+                        };
+                    })
+                };
+            }
+        }
+    }
+};
+exports.PgAggregatesAddConnectionGroupedAggregatesPlugin = Plugin;

package/AddGroupByAggregateEnumValuesForAttributesPlugin.d.ts

@@ -0,0 +1,10 @@
+declare global {
+    namespace GraphileBuild {
+        interface BehaviorStrings {
+            'attribute:groupBy': true;
+            groupBy: true;
+        }
+    }
+}
+declare const Plugin: GraphileConfig.Plugin;
+export { Plugin as PgAggregatesAddGroupByAggregateEnumValuesForAttributesPlugin };

package/AddGroupByAggregateEnumValuesForAttributesPlugin.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PgAggregatesAddGroupByAggregateEnumValuesForAttributesPlugin = void 0;
+const EXPORTABLE_1 = require("./EXPORTABLE");
+const version = '1.0.0';
+const applyGroupByAggregateSpec = (0, EXPORTABLE_1.EXPORTABLE)(() => (sql, aggregateGroupBySpec, attributeName, attrCodec, qb) => {
+    qb.groupBy({
+        fragment: aggregateGroupBySpec.sqlWrap(sql `${qb.alias}.${sql.identifier(attributeName)}`),
+        codec: aggregateGroupBySpec.sqlWrapCodec(attrCodec)
+    });
+}, [], 'applyGroupByAggregateSpec');
+const applyGroupByAttribute = (0, EXPORTABLE_1.EXPORTABLE)(() => (sql, attributeName, attrCodec, qb) => {
+    qb.groupBy({
+        fragment: sql.fragment `${qb.alias}.${sql.identifier(attributeName)}`,
+        codec: attrCodec
+    });
+}, [], 'applyGroupByAttribute');
+const Plugin = {
+    name: 'PgAggregatesAddGroupByAggregateEnumValuesForAttributesPlugin',
+    description: 'Adds values representing table attributes to the enum that defines the groupedAggregates groupings.',
+    version,
+    provides: ['aggregates'],
+    // Now add group by attributes
+    schema: {
+        behaviorRegistry: {
+            add: {
+                'attribute:groupBy': {
+                    description: 'Can we group by this attribute when aggregating?',
+                    entities: ['pgCodecAttribute']
+                },
+                groupBy: {
+                    description: 'Can we group by this attribute when aggregating?',
+                    entities: ['pgCodecAttribute']
+                }
+            }
+        },
+        entityBehavior: {
+            pgCodecAttribute: ['attribute:groupBy']
+        },
+        hooks: {
+            GraphQLEnumType_values(values, build, context) {
+                const { extend, inflection, sql, pgAggregateGroupBySpecs, EXPORTABLE } = build;
+                const { scope: { isPgAggregateGroupEnum, pgTypeResource: table } } = context;
+                if (!isPgAggregateGroupEnum ||
+                    !table ||
+                    table.parameters ||
+                    !table.codec.attributes) {
+                    return values;
+                }
+                return extend(values, Object.entries(table.codec.attributes).reduce((memo, [attributeName, attribute]) => {
+                    // Grouping requires ordering.
+                    if (!build.behavior.pgCodecAttributeMatches([table.codec, attributeName], 'orderBy')) {
+                        return memo;
+                    }
+                    if (!build.behavior.pgCodecAttributeMatches([table.codec, attributeName], `attribute:groupBy`)) {
+                        return memo;
+                    }
+                    const unique = !!table.uniques.find((u) => u.attributes.length === 1 && u.attributes[0] === attributeName);
+                    if (unique)
+                        return memo; // No point grouping by something that's unique.
+                    const fieldName = inflection.aggregateGroupByAttributeEnum({
+                        resource: table,
+                        attributeName
+                    });
+                    const attrCodec = attribute.codec;
+                    memo = extend(memo, {
+                        [fieldName]: {
+                            extensions: {
+                                grafast: {
+                                    apply: EXPORTABLE((applyGroupByAttribute, attrCodec, attributeName, sql) => function ($pgSelect) {
+                                        applyGroupByAttribute(sql, attributeName, attrCodec, $pgSelect);
+                                    }, [applyGroupByAttribute, attrCodec, attributeName, sql])
+                                }
+                            }
+                        }
+                    }, `Adding groupBy enum value for ${table.name}.${attributeName}.`);
+                    // Derivatives of this attribute
+                    pgAggregateGroupBySpecs.forEach((aggregateGroupBySpec) => {
+                        if ((!aggregateGroupBySpec.shouldApplyToEntity ||
+                            aggregateGroupBySpec.shouldApplyToEntity({
+                                type: 'attribute',
+                                codec: table.codec,
+                                attributeName
+                            })) &&
+                            aggregateGroupBySpec.isSuitableType(attribute.codec)) {
+                            const fieldName = inflection.aggregateGroupByAttributeDerivativeEnum({
+                                resource: table,
+                                attributeName,
+                                aggregateGroupBySpec
+                            });
+                            memo = extend(memo, {
+                                [fieldName]: {
+                                    extensions: {
+                                        grafast: {
+                                            apply: EXPORTABLE((aggregateGroupBySpec, applyGroupByAggregateSpec, attrCodec, attributeName, sql) => function (qb) {
+                                                applyGroupByAggregateSpec(sql, aggregateGroupBySpec, attributeName, attrCodec, qb);
+                                            }, [
+                                                aggregateGroupBySpec,
+                                                applyGroupByAggregateSpec,
+                                                attrCodec,
+                                                attributeName,
+                                                sql
+                                            ])
+                                        }
+                                    }
+                                }
+                            }, `Adding groupBy enum value for '${aggregateGroupBySpec.id}' derivative of ${table.name}.${attributeName}.`);
+                        }
+                    });
+                    return memo;
+                }, Object.create(null)), `Adding group by values for attributes from table '${table.name}'`);
+            }
+        }
+    }
+};
+exports.PgAggregatesAddGroupByAggregateEnumValuesForAttributesPlugin = Plugin;

package/AddGroupByAggregateEnumsPlugin.d.ts

@@ -0,0 +1,2 @@
+declare const Plugin: GraphileConfig.Plugin;
+export { Plugin as PgAggregatesAddGroupByAggregateEnumsPlugin };