graphile-pg-aggregates 1.1.0

package/esm/AddHavingAggregateTypesPlugin.js

@@ -0,0 +1,446 @@
+import { EXPORTABLE } from './EXPORTABLE';
+import { CORE_HAVING_FILTER_SPECS } from './interfaces';
+import { getComputedAttributeResources } from './utils';
+const version = '1.0.0';
+const pgAggregatesApplyAnd = EXPORTABLE(() => function apply($where) {
+    return $where;
+}, [], 'pgAggregatesApplyAnd');
+const pgAggregatesApplyHaving = EXPORTABLE(() => function apply($filter) {
+    return $filter;
+}, [], 'pgAggregatesApplyHaving');
+const pgAggregatesApplyAttributeFilter = EXPORTABLE(() => (PgBooleanFilter, aggregateSpec, attribute, attributeName, sql, $having) => {
+    const attributeExpression = sql.fragment `${$having.alias}.${sql.identifier(attributeName)}`;
+    const aggregateExpression = aggregateSpec.sqlAggregateWrap(attributeExpression, attribute.codec);
+    return new PgBooleanFilter($having, aggregateExpression);
+}, [], 'pgAggregatesApplyAttributeFilter');
+const pgAggregatesApplyComputedColumnFilter = EXPORTABLE(() => (PgBooleanFilter, aggregateSpec, computedAttributeResource, from, getNullableType, isInputObjectType, makeArgsRuntime, parameterAnalysis, parameters, pgFromExpressionRuntime, $having, input, { field, schema }) => {
+    if (input == null) {
+        return;
+    }
+    const fieldType = getNullableType(field.type);
+    if (!isInputObjectType(fieldType)) {
+        throw new Error(`Expected an input object type (${field.type})`);
+    }
+    const argsField = fieldType.getFields().args;
+    const firstArg = {
+        placeholder: $having.alias,
+        position: 0
+    };
+    let src;
+    if (argsField && input.args != null) {
+        const argsType = getNullableType(fieldType.getFields().args.type);
+        if (!isInputObjectType(argsType)) {
+            throw new Error(`Expected an input object type (${argsType})`);
+        }
+        const fields = argsType.getFields();
+        // 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.
+        src = pgFromExpressionRuntime(from, parameters, [firstArg, ...makeArgsRuntime(schema, fields, input.args)], parameterAnalysis);
+    }
+    else {
+        src = pgFromExpressionRuntime(from, parameters, [firstArg], parameterAnalysis);
+    }
+    const aggregateExpression = aggregateSpec.sqlAggregateWrap(src, computedAttributeResource.codec);
+    const $filter = new PgBooleanFilter($having, aggregateExpression);
+    // fieldArgs.apply($filter, "filter");
+    return $filter;
+}, [], 'pgAggregatesApplyComputedColumnFilter');
+const pgAggregatesPlanAggregatesField = EXPORTABLE(() => function apply($having) {
+    return $having;
+}, [], 'pgAggregatesPlanAggregatesField');
+const pgAggregatesApplyHavingBinaryOperation = EXPORTABLE(() => (codec, infix, sql, sqlValueWithCodec, $booleanFilter, input) => {
+    if (input == null)
+        return;
+    $booleanFilter.having(sql `(${sql.parens($booleanFilter.expression)} ${infix()} ${sqlValueWithCodec(input, codec)})`);
+}, [], 'pgAggregatesApplyHavingBinaryOperation');
+const Plugin = {
+    name: 'PgAggregatesAddHavingAggregateTypesPlugin',
+    description: `\
+Creates the types for the 'having' clause in groupedAggregates, the fields \
+below that for each aggregate spec, and adds fields for attributes and computed \
+columns.`,
+    version,
+    provides: ['aggregates'],
+    after: ['PgBasicsPlugin'],
+    schema: {
+        behaviorRegistry: {
+            add: {
+                having: {
+                    description: "Should we add a 'having' option to aggregates on this resource?",
+                    entities: ['pgResource']
+                },
+                havingBy: {
+                    description: "Should this function-like resource, or attribute, be usable in the 'having' clause when aggregating?",
+                    entities: ['pgResource', 'pgCodecAttribute']
+                }
+            }
+        },
+        entityBehavior: {
+            // having - for connections' groupedAggregates field
+            // havingBy - for computed column functions acting like attributes
+            pgResource: ['order', 'having', 'havingBy'],
+            pgCodecAttribute: ['havingBy']
+        },
+        hooks: {
+            build(build) {
+                if (!build.dataplanPg) {
+                    throw new Error(`PgBasicsPlugin must be loaded first`);
+                }
+                const { dataplanPg: { TYPES } } = build;
+                return build.extend(build, {
+                    pgHavingFilterTypeNameForCodec(codec) {
+                        switch (codec) {
+                            case TYPES.int2:
+                            case TYPES.int: {
+                                return build.inflection.aggregateHavingFilterInputType('int');
+                            }
+                            case TYPES.bigint: {
+                                return build.inflection.aggregateHavingFilterInputType('bigint');
+                            }
+                            case TYPES.float4:
+                            case TYPES.float: {
+                                return build.inflection.aggregateHavingFilterInputType('float');
+                            }
+                            case TYPES.money:
+                            case TYPES.numeric: {
+                                return build.inflection.aggregateHavingFilterInputType('bigfloat');
+                            }
+                            case TYPES.date:
+                            case TYPES.timestamp:
+                            case TYPES.timestamptz: {
+                                return build.inflection.aggregateHavingFilterInputType('datetime');
+                            }
+                            case TYPES.char:
+                            case TYPES.text:
+                            case TYPES.varchar: {
+                                return build.inflection.aggregateHavingFilterInputType('string');
+                            }
+                            default: {
+                                return null;
+                            }
+                        }
+                    }
+                }, 'adding pgHavingFilterTypeForTypeAndModifier');
+            },
+            init(_, build, _context) {
+                const { graphql: { GraphQLList, GraphQLNonNull, getNullableType, isInputObjectType }, inflection, sql, dataplanPg: { PgOrFilter, PgBooleanFilter, pgFromExpressionRuntime, generatePgParameterAnalysis }, EXPORTABLE } = build;
+                for (const spec of CORE_HAVING_FILTER_SPECS) {
+                    const name = build.inflection.aggregateHavingFilterInputType(spec);
+                    build.registerInputObjectType(name, {
+                        isPgHavingFilterInputType: true,
+                        pgHavingFilterSpec: spec
+                    }, () => ({
+                        name,
+                        fields: Object.create(null)
+                    }), '');
+                }
+                for (const resource of Object.values(build.input.pgRegistry.pgResources)) {
+                    if (resource.parameters ||
+                        !resource.codec.attributes ||
+                        resource.isUnique) {
+                        continue;
+                    }
+                    if (!build.behavior.pgResourceMatches(resource, 'order')) {
+                        continue;
+                    }
+                    if (!build.behavior.pgResourceMatches(resource, 'resource:groupedAggregates:having')) {
+                        continue;
+                    }
+                    const tableTypeName = inflection.tableType(resource.codec);
+                    const tableHavingInputTypeName = inflection.aggregateHavingInputType({
+                        resource: resource
+                    });
+                    build.registerInputObjectType(tableHavingInputTypeName, {
+                        pgTypeResource: resource,
+                        isPgAggregateHavingInputType: true
+                    }, () => ({
+                        description: build.wrapDescription(`Conditions for \`${tableTypeName}\` aggregates.`, 'type'),
+                        fields: () => {
+                            return {
+                                AND: {
+                                    type: new GraphQLList(new GraphQLNonNull(build.getInputTypeByName(tableHavingInputTypeName))),
+                                    apply: pgAggregatesApplyAnd
+                                    // No need to auto-apply, the having field calls `fieldArgs.apply(...)`
+                                },
+                                OR: {
+                                    type: new GraphQLList(new GraphQLNonNull(build.getInputTypeByName(tableHavingInputTypeName))),
+                                    apply: EXPORTABLE((PgOrFilter) => ($where) => new PgOrFilter($where), [PgOrFilter])
+                                    // No need to auto-apply, the having field calls `fieldArgs.apply(...)`
+                                }
+                            };
+                        }
+                    }), `Adding connection "groupBy" having input type for ${resource.name}.`);
+                    const computedAttributeResources = getComputedAttributeResources(build, resource);
+                    for (const aggregateSpec of build.pgAggregateSpecs) {
+                        for (const computedAttributeResource of computedAttributeResources) {
+                            const argsTypeName = inflection.aggregateHavingAggregateComputedAttributeArgsInputType({
+                                resource: resource,
+                                aggregateSpec,
+                                computedAttributeResource: computedAttributeResource
+                            });
+                            build.registerInputObjectType(argsTypeName, {}, () => {
+                                return {
+                                    fields: () => {
+                                        const { argDetails } = build.pgGetArgDetailsFromParameters(computedAttributeResource, computedAttributeResource.parameters, 1);
+                                        return argDetails.reduce((memo, { inputType, graphqlArgName }) => {
+                                            memo[graphqlArgName] = {
+                                                type: inputType
+                                                // NO PLAN NEEDED!
+                                            };
+                                            return memo;
+                                        }, Object.create(null));
+                                    }
+                                };
+                            }, '');
+                            const computedHavingInputName = inflection.aggregateHavingAggregateComputedAttributeInputType({
+                                resource: resource,
+                                aggregateSpec,
+                                computedAttributeResource: computedAttributeResource
+                            });
+                            /*const ComputedHavingInput =*/
+                            build.registerInputObjectType(computedHavingInputName, {}, () => {
+                                return {
+                                    fields: () => {
+                                        const havingFilterTypeName = build.pgHavingFilterTypeNameForCodec(computedAttributeResource.codec);
+                                        const HavingFilterType = havingFilterTypeName
+                                            ? build.getTypeByName(havingFilterTypeName)
+                                            : undefined;
+                                        const ArgsType = build.getTypeByName(argsTypeName);
+                                        if (!HavingFilterType || !ArgsType) {
+                                            return { fields: Object.create(null) };
+                                        }
+                                        const requiresAtLeastOneArg = computedAttributeResource.parameters
+                                            .slice(1)
+                                            .some((p) => !p.optional);
+                                        return {
+                                            ...(ArgsType
+                                                ? {
+                                                    args: {
+                                                        type: build.nullableIf(!requiresAtLeastOneArg, ArgsType)
+                                                        // NO PLAN NEEDED
+                                                    }
+                                                }
+                                                : null),
+                                            filter: {
+                                                type: new GraphQLNonNull(HavingFilterType),
+                                                apply: pgAggregatesApplyHaving
+                                                // No need to auto-apply, parent calls `fieldArgs.apply($filter, "filter")` below
+                                            }
+                                        };
+                                    }
+                                };
+                            }, '');
+                        }
+                        const typeName = inflection.aggregateHavingAggregateInputType({
+                            resource: resource,
+                            aggregateSpec
+                        });
+                        build.registerInputObjectType(typeName, {}, () => ({
+                            name: typeName,
+                            fields: ({ fieldWithHooks }) => {
+                                let fields = Object.create(null);
+                                fields = build.extend(fields, Object.entries(resource.codec.attributes).reduce((newFields, [attributeName, attribute]) => {
+                                    if (!build.behavior.pgCodecAttributeMatches([resource.codec, attributeName], 'attribute:havingBy')) {
+                                        return newFields;
+                                    }
+                                    const fieldName = inflection.attribute({
+                                        codec: resource.codec,
+                                        attributeName: attributeName
+                                    });
+                                    const havingFilterTypeName = build.pgHavingFilterTypeNameForCodec(attribute.codec);
+                                    const HavingFilterType = havingFilterTypeName
+                                        ? build.getTypeByName(havingFilterTypeName)
+                                        : undefined;
+                                    if (!HavingFilterType) {
+                                        return newFields;
+                                    }
+                                    const newField = fieldWithHooks({ fieldName }, () => ({
+                                        type: HavingFilterType,
+                                        apply: EXPORTABLE((PgBooleanFilter, aggregateSpec, attribute, attributeName, pgAggregatesApplyAttributeFilter, sql) => ($having) => {
+                                            return pgAggregatesApplyAttributeFilter(PgBooleanFilter, aggregateSpec, attribute, attributeName, sql, $having);
+                                        }, [
+                                            PgBooleanFilter,
+                                            aggregateSpec,
+                                            attribute,
+                                            attributeName,
+                                            pgAggregatesApplyAttributeFilter,
+                                            sql
+                                        ])
+                                    }));
+                                    return build.extend(newFields, { [fieldName]: newField }, `Adding attribute '${attributeName}' to having filter type for '${resource.name}'`);
+                                }, Object.create(null)), '');
+                                fields = build.extend(fields, computedAttributeResources.reduce((memo, computedAttributeResource) => {
+                                    if (!build.behavior.pgResourceMatches(computedAttributeResource, 'resource:havingBy')) {
+                                        return memo;
+                                    }
+                                    const codec = computedAttributeResource.codec;
+                                    if ((aggregateSpec.shouldApplyToEntity &&
+                                        !aggregateSpec.shouldApplyToEntity({
+                                            type: 'computedAttribute',
+                                            resource: computedAttributeResource
+                                        })) ||
+                                        !aggregateSpec.isSuitableType(codec)) {
+                                        return memo;
+                                    }
+                                    const argsTypeName = inflection.aggregateHavingAggregateComputedAttributeArgsInputType({
+                                        resource: resource,
+                                        aggregateSpec,
+                                        computedAttributeResource: computedAttributeResource
+                                    });
+                                    const havingFilterTypeName = build.pgHavingFilterTypeNameForCodec(computedAttributeResource.codec);
+                                    const HavingFilterType = havingFilterTypeName
+                                        ? build.getTypeByName(havingFilterTypeName)
+                                        : undefined;
+                                    const ArgsType = build.getTypeByName(argsTypeName);
+                                    const computedHavingInputName = inflection.aggregateHavingAggregateComputedAttributeInputType({
+                                        resource: resource,
+                                        aggregateSpec,
+                                        computedAttributeResource: computedAttributeResource
+                                    });
+                                    const ComputedHavingInput = build.getTypeByName(computedHavingInputName);
+                                    if (!HavingFilterType ||
+                                        !ArgsType ||
+                                        !ComputedHavingInput) {
+                                        return memo;
+                                    }
+                                    const fieldName = inflection.computedAttributeField({
+                                        resource: computedAttributeResource
+                                    });
+                                    const { from: rawFrom, parameters } = computedAttributeResource;
+                                    const { makeArgsRuntime } = build.pgGetArgDetailsFromParameters(computedAttributeResource, parameters, 1);
+                                    const parameterAnalysis = EXPORTABLE((generatePgParameterAnalysis, parameters) => generatePgParameterAnalysis(parameters), [generatePgParameterAnalysis, parameters], `${computedAttributeResource.name}ParameterAnalysis`);
+                                    const from = typeof rawFrom === 'function'
+                                        ? rawFrom
+                                        : () => rawFrom;
+                                    const newField = fieldWithHooks({ fieldName }, {
+                                        type: ComputedHavingInput,
+                                        apply: EXPORTABLE((PgBooleanFilter, aggregateSpec, computedAttributeResource, from, getNullableType, isInputObjectType, makeArgsRuntime, parameterAnalysis, parameters, pgAggregatesApplyComputedColumnFilter, pgFromExpressionRuntime) => ($having, input, info) => {
+                                            return pgAggregatesApplyComputedColumnFilter(PgBooleanFilter, aggregateSpec, computedAttributeResource, from, getNullableType, isInputObjectType, makeArgsRuntime, parameterAnalysis, parameters, pgFromExpressionRuntime, $having, input, info);
+                                        }, [
+                                            PgBooleanFilter,
+                                            aggregateSpec,
+                                            computedAttributeResource,
+                                            from,
+                                            getNullableType,
+                                            isInputObjectType,
+                                            makeArgsRuntime,
+                                            parameterAnalysis,
+                                            parameters,
+                                            pgAggregatesApplyComputedColumnFilter,
+                                            pgFromExpressionRuntime
+                                        ])
+                                        // No need to auto-apply, parent does `return $having;`
+                                    });
+                                    return build.extend(memo, { [fieldName]: newField }, `Adding computed attribute function '${computedAttributeResource.name}' to having filter type for '${resource.name}'`);
+                                }, Object.create(null)), '');
+                                return fields;
+                            }
+                        }), '');
+                    }
+                }
+                return _;
+            },
+            GraphQLInputObjectType_fields(inFields, build, context) {
+                const { sql, inflection, dataplanPg: { TYPES, sqlValueWithCodec }, EXPORTABLE } = build;
+                const { scope: { isPgHavingFilterInputType, pgHavingFilterSpec, isPgAggregateHavingInputType, pgTypeResource: table }, fieldWithHooks } = context;
+                let fields = inFields;
+                fields = (() => {
+                    if (!isPgAggregateHavingInputType ||
+                        !table ||
+                        table.parameters ||
+                        !table.codec.attributes) {
+                        return fields;
+                    }
+                    return build.extend(fields, build.pgAggregateSpecs.reduce((aggregateFields, aggregateSpec) => {
+                        if (!build.behavior.pgResourceMatches(table, `${aggregateSpec.id}:resource:groupedAggregates:having`)) {
+                            return aggregateFields;
+                        }
+                        const typeName = inflection.aggregateHavingAggregateInputType({
+                            resource: table,
+                            aggregateSpec
+                        });
+                        const SpecInput = build.getTypeByName(typeName);
+                        if (!SpecInput) {
+                            return aggregateFields;
+                        }
+                        const fieldName = inflection.aggregatesField({ aggregateSpec });
+                        return build.extend(aggregateFields, {
+                            [fieldName]: fieldWithHooks({ fieldName }, // e.g. 'average' or 'stddevPopulation'
+                            {
+                                type: SpecInput,
+                                apply: pgAggregatesPlanAggregatesField
+                                // No need to auto-apply, `filter` field does `return new PgBooleanFilter($having, aggregateExpression)`
+                            })
+                        }, '');
+                    }, Object.create(null)), `Adding attributes to having filter for '${table.name}'`);
+                })();
+                fields = (() => {
+                    if (!isPgHavingFilterInputType) {
+                        return fields;
+                    }
+                    const rawCodec = (() => {
+                        switch (pgHavingFilterSpec) {
+                            case 'int':
+                                return TYPES.int;
+                            case 'bigint':
+                                return TYPES.bigint;
+                            case 'float':
+                                return TYPES.float;
+                            case 'bigfloat':
+                                return TYPES.numeric;
+                            case 'datetime':
+                                return TYPES.timestamptz;
+                            default: {
+                                return null;
+                            }
+                        }
+                    })();
+                    if (rawCodec === null) {
+                        return fields;
+                    }
+                    const codec = rawCodec;
+                    const FieldType = build.getGraphQLTypeByPgCodec(codec, 'input');
+                    if (FieldType == null) {
+                        return fields;
+                    }
+                    function addBinaryOp(fieldName, infix) {
+                        fields = build.extend(fields, {
+                            [fieldName]: fieldWithHooks({ fieldName }, {
+                                type: FieldType,
+                                apply: EXPORTABLE((codec, infix, pgAggregatesApplyHavingBinaryOperation, sql, sqlValueWithCodec) => ($booleanFilter, input) => {
+                                    return pgAggregatesApplyHavingBinaryOperation(codec, infix, sql, sqlValueWithCodec, $booleanFilter, input);
+                                }, [
+                                    codec,
+                                    infix,
+                                    pgAggregatesApplyHavingBinaryOperation,
+                                    sql,
+                                    sqlValueWithCodec
+                                ])
+                                // No need to auto-apply
+                            })
+                        }, '');
+                    }
+                    switch (pgHavingFilterSpec) {
+                        case 'int':
+                        case 'bigint':
+                        case 'float':
+                        case 'bigfloat':
+                        case 'datetime': {
+                            addBinaryOp('equalTo', EXPORTABLE((sql) => () => sql.fragment `=`, [sql]));
+                            addBinaryOp('notEqualTo', EXPORTABLE((sql) => () => sql.fragment `<>`, [sql]));
+                            addBinaryOp('greaterThan', EXPORTABLE((sql) => () => sql.fragment `>`, [sql]));
+                            addBinaryOp('greaterThanOrEqualTo', EXPORTABLE((sql) => () => sql.fragment `>=`, [sql]));
+                            addBinaryOp('lessThan', EXPORTABLE((sql) => () => sql.fragment `<`, [sql]));
+                            addBinaryOp('lessThanOrEqualTo', EXPORTABLE((sql) => () => sql.fragment `<=`, [sql]));
+                        }
+                    }
+                    return fields;
+                })();
+                return fields;
+            }
+        }
+    }
+};
+export { Plugin as PgAggregatesAddHavingAggregateTypesPlugin };

package/esm/AggregateSpecsPlugin.d.ts

@@ -0,0 +1 @@
+export declare const PgAggregatesSpecsPlugin: GraphileConfig.Plugin;

package/esm/AggregateSpecsPlugin.js

@@ -0,0 +1,203 @@
+import { EXPORTABLE } from './EXPORTABLE';
+import { BIGINT_OID, FLOAT4_OID, FLOAT8_OID, INT2_OID, INT4_OID, INTERVAL_OID, MONEY_OID, NUMERIC_OID } from './interfaces';
+const version = '1.0.0';
+const isNumberLike = (codec) => !!codec.extensions?.isNumberLike;
+const isIntervalLike = (codec) => !!codec.extensions?.isIntervalLike;
+const isIntervalLikeOrNumberLike = EXPORTABLE((isIntervalLike, isNumberLike) => (codec) => isIntervalLike(codec) || isNumberLike(codec), [isIntervalLike, isNumberLike]);
+export const PgAggregatesSpecsPlugin = {
+    name: 'PgAggregatesSpecsPlugin',
+    description: 'Created the default (extensible) aggregate specs and group-by specs used throughout this preset.',
+    version,
+    provides: ['aggregates'],
+    after: ['PgBasicsPlugin'],
+    gather: {
+        hooks: {
+            pgCodecs_PgCodec(_info, event) {
+                const { pgType, pgCodec } = event;
+                const isReg = pgType.getNamespace()?.nspname === 'pg_catalog' &&
+                    pgType.typname.startsWith('reg');
+                const isCatN = !isReg && pgType.typcategory === 'N';
+                const isInterval = !isReg && pgType._id === INTERVAL_OID;
+                if (isCatN || isInterval) {
+                    if (!pgCodec.extensions) {
+                        pgCodec.extensions = Object.create(null);
+                    }
+                }
+                if (isCatN) {
+                    pgCodec.extensions.isNumberLike = true;
+                }
+                if (isInterval) {
+                    pgCodec.extensions.isIntervalLike = true;
+                }
+            }
+        }
+    },
+    schema: {
+        hooks: {
+            build(build) {
+                if (!build.dataplanPg || !build.sql) {
+                    throw new Error(`PgBasicsPlugin must be loaded first`);
+                }
+                const { sql, dataplanPg: { TYPES }, EXPORTABLE } = build;
+                /** Maps from the data type of the attribute to the data type of the sum aggregate */
+                /** BigFloat is our fallback type; it should be valid for almost all numeric types */
+                const convertWithMapAndFallback = (dataTypeToAggregateTypeMap, fallback) => {
+                    return EXPORTABLE((dataTypeToAggregateTypeMap, fallback) => (codec) => {
+                        const oid = codec.extensions?.oid;
+                        const targetType = (oid ? dataTypeToAggregateTypeMap[oid] : null) ?? fallback;
+                        return targetType;
+                    }, [dataTypeToAggregateTypeMap, fallback]);
+                };
+                const pgAggregateSpecs = [
+                    {
+                        id: 'sum',
+                        humanLabel: 'sum',
+                        HumanLabel: 'Sum',
+                        isSuitableType: isIntervalLikeOrNumberLike,
+                        // I've wrapped it in `coalesce` so that it cannot be null
+                        sqlAggregateWrap: EXPORTABLE((sql) => (sqlFrag) => sql `coalesce(sum(${sqlFrag}), '0')`, [sql]),
+                        isNonNull: true,
+                        // A SUM(...) often ends up significantly larger than any individual
+                        // value; see
+                        // https://www.postgresql.org/docs/current/functions-aggregate.html for
+                        // how the sum aggregate changes result type.
+                        pgTypeCodecModifier: convertWithMapAndFallback({
+                            // TODO: this should use codecs rather than OIDs
+                            [INT2_OID]: TYPES.bigint, // smallint -> bigint
+                            [INT4_OID]: TYPES.bigint, // integer -> bigint
+                            [BIGINT_OID]: TYPES.numeric, // bigint -> numeric
+                            [FLOAT4_OID]: TYPES.float4, // real -> real
+                            [FLOAT8_OID]: TYPES.float, // double precision -> double precision
+                            [INTERVAL_OID]: TYPES.interval, // interval -> interval
+                            [MONEY_OID]: TYPES.money // money -> money
+                        }, TYPES.numeric /* numeric */)
+                    },
+                    {
+                        id: 'distinctCount',
+                        humanLabel: 'distinct count',
+                        HumanLabel: 'Distinct count',
+                        isSuitableType: () => true,
+                        sqlAggregateWrap: EXPORTABLE((sql) => (sqlFrag) => sql `count(distinct ${sqlFrag})`, [sql]),
+                        pgTypeCodecModifier: convertWithMapAndFallback({}, TYPES.bigint /* always use bigint */)
+                    },
+                    {
+                        id: 'min',
+                        humanLabel: 'minimum',
+                        HumanLabel: 'Minimum',
+                        isSuitableType: isIntervalLikeOrNumberLike,
+                        sqlAggregateWrap: EXPORTABLE((sql) => (sqlFrag) => sql `min(${sqlFrag})`, [sql])
+                    },
+                    {
+                        id: 'max',
+                        humanLabel: 'maximum',
+                        HumanLabel: 'Maximum',
+                        isSuitableType: isIntervalLikeOrNumberLike,
+                        sqlAggregateWrap: EXPORTABLE((sql) => (sqlFrag) => sql `max(${sqlFrag})`, [sql])
+                    },
+                    {
+                        id: 'average',
+                        humanLabel: 'mean average',
+                        HumanLabel: 'Mean average',
+                        isSuitableType: isIntervalLikeOrNumberLike,
+                        sqlAggregateWrap: EXPORTABLE((sql) => (sqlFrag) => sql `avg(${sqlFrag})`, [sql]),
+                        // An AVG(...) ends up more precise than any individual value; see
+                        // https://www.postgresql.org/docs/current/functions-aggregate.html for
+                        // how the avg aggregate changes result type.
+                        pgTypeCodecModifier: convertWithMapAndFallback({
+                            [INT2_OID]: TYPES.numeric, // smallint -> numeric
+                            [INT4_OID]: TYPES.numeric, // integer -> numeric
+                            [BIGINT_OID]: TYPES.numeric, // bigint -> numeric
+                            [NUMERIC_OID]: TYPES.numeric, // numeric -> numeric
+                            [FLOAT4_OID]: TYPES.float, // real -> double precision
+                            [FLOAT8_OID]: TYPES.float, // double precision -> double precision
+                            [INTERVAL_OID]: TYPES.interval // interval -> interval
+                        }, TYPES.numeric /* numeric */)
+                    },
+                    {
+                        id: 'stddevSample',
+                        humanLabel: 'sample standard deviation',
+                        HumanLabel: 'Sample standard deviation',
+                        isSuitableType: isNumberLike,
+                        sqlAggregateWrap: EXPORTABLE((sql) => (sqlFrag) => sql `stddev_samp(${sqlFrag})`, [sql]),
+                        // See https://www.postgresql.org/docs/current/functions-aggregate.html
+                        // for how this aggregate changes result type.
+                        pgTypeCodecModifier: convertWithMapAndFallback({
+                            [FLOAT4_OID]: TYPES.float, // real -> double precision
+                            [FLOAT8_OID]: TYPES.float // double precision -> double precision
+                        }, TYPES.numeric /* numeric */)
+                    },
+                    {
+                        id: 'stddevPopulation',
+                        humanLabel: 'population standard deviation',
+                        HumanLabel: 'Population standard deviation',
+                        isSuitableType: isNumberLike,
+                        sqlAggregateWrap: EXPORTABLE((sql) => (sqlFrag) => sql `stddev_pop(${sqlFrag})`, [sql]),
+                        // See https://www.postgresql.org/docs/current/functions-aggregate.html
+                        // for how this aggregate changes result type.
+                        pgTypeCodecModifier: convertWithMapAndFallback({
+                            [FLOAT4_OID]: TYPES.float, // real -> double precision
+                            [FLOAT8_OID]: TYPES.float // double precision -> double precision
+                        }, TYPES.numeric /* numeric */)
+                    },
+                    {
+                        id: 'varianceSample',
+                        humanLabel: 'sample variance',
+                        HumanLabel: 'Sample variance',
+                        isSuitableType: isNumberLike,
+                        sqlAggregateWrap: EXPORTABLE((sql) => (sqlFrag) => sql `var_samp(${sqlFrag})`, [sql]),
+                        // See https://www.postgresql.org/docs/current/functions-aggregate.html
+                        // for how this aggregate changes result type.
+                        pgTypeCodecModifier: convertWithMapAndFallback({
+                            [FLOAT4_OID]: TYPES.float, // real -> double precision
+                            [FLOAT8_OID]: TYPES.float // double precision -> double precision
+                        }, TYPES.numeric /* numeric */)
+                    },
+                    {
+                        id: 'variancePopulation',
+                        humanLabel: 'population variance',
+                        HumanLabel: 'Population variance',
+                        isSuitableType: isNumberLike,
+                        sqlAggregateWrap: EXPORTABLE((sql) => (sqlFrag) => sql `var_pop(${sqlFrag})`, [sql]),
+                        // See https://www.postgresql.org/docs/current/functions-aggregate.html
+                        // for how this aggregate changes result type.
+                        pgTypeCodecModifier: convertWithMapAndFallback({
+                            [FLOAT4_OID]: TYPES.float, // real -> double precision
+                            [FLOAT8_OID]: TYPES.float // double precision -> double precision
+                        }, TYPES.numeric /* numeric */)
+                    }
+                ];
+                const pgAggregateGroupBySpecs = [
+                    {
+                        id: 'truncated-to-hour',
+                        isSuitableType: EXPORTABLE((TYPES) => (codec) => codec === TYPES.timestamp || codec === TYPES.timestamptz, [TYPES]),
+                        sqlWrap: EXPORTABLE((sql) => (sqlFrag) => sql `date_trunc('hour', ${sqlFrag})`, [sql]),
+                        sqlWrapCodec(codec) {
+                            return codec;
+                        }
+                    },
+                    {
+                        id: 'truncated-to-day',
+                        isSuitableType: EXPORTABLE((TYPES) => (codec) => codec === TYPES.timestamp || codec === TYPES.timestamptz, [TYPES]),
+                        sqlWrap: EXPORTABLE((sql) => (sqlFrag) => sql `date_trunc('day', ${sqlFrag})`, [sql]),
+                        sqlWrapCodec(codec) {
+                            return codec;
+                        }
+                    }
+                ];
+                return build.extend(build, {
+                    pgAggregateSpecs,
+                    pgAggregateGroupBySpecs
+                }, 'Adding aggregate specs to build');
+            },
+            finalize(schema, build) {
+                build.pgAggregateSpecs.forEach((spec) => {
+                    build.exportNameHint(spec, `pgAggregateSpec_${spec.id.replace(/-/g, '_')}`);
+                });
+                build.pgAggregateGroupBySpecs.forEach((spec) => {
+                    build.exportNameHint(spec, `pgAggregateGroupBySpec_${spec.id.replace(/-/g, '_')}`);
+                });
+                return schema;
+            }
+        }
+    }
+};

package/esm/AggregatesSmartTagsPlugin.d.ts

@@ -0,0 +1,8 @@
+declare global {
+    namespace GraphileConfig {
+        interface GatherHelpers {
+            pgV4AggregatesSmartTags: Record<string, never>;
+        }
+    }
+}
+export declare const PgAggregatesSmartTagsPlugin: GraphileConfig.Plugin;