graphile-pg-aggregates 1.1.0

package/esm/AddConnectionAggregatesPlugin.js

@@ -0,0 +1,53 @@
+import { EXPORTABLE } from './EXPORTABLE';
+const version = '1.0.0';
+const pgAggregatesCloneSubplanWithoutPaginationSingle = 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
+                        };
+                    })
+                };
+            }
+        }
+    }
+};
+export { Plugin as PgAggregatesAddConnectionAggregatesPlugin };

package/esm/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/esm/AddConnectionGroupedAggregatesPlugin.js

@@ -0,0 +1,115 @@
+import { EXPORTABLE } from './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 = EXPORTABLE(() => function plan($connection) {
+    return $connection.cloneSubplanWithoutPagination('aggregate');
+}, [], 'pgAggregateCloneSubplanWithoutPaginationAsAggregate');
+const pgAggregatesApplyGroupedAggregate = EXPORTABLE(() => function (_$parent, $pgSelect, input) {
+    return input.apply($pgSelect);
+}, [], 'pgAggregatesApplyGroupedAggregate');
+const pgAggregatesApplyConditionsToGroupedAggregates = 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
+                        };
+                    })
+                };
+            }
+        }
+    }
+};
+export { Plugin as PgAggregatesAddConnectionGroupedAggregatesPlugin };

package/esm/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/esm/AddGroupByAggregateEnumValuesForAttributesPlugin.js

@@ -0,0 +1,113 @@
+import { EXPORTABLE } from './EXPORTABLE';
+const version = '1.0.0';
+const applyGroupByAggregateSpec = EXPORTABLE(() => (sql, aggregateGroupBySpec, attributeName, attrCodec, qb) => {
+    qb.groupBy({
+        fragment: aggregateGroupBySpec.sqlWrap(sql `${qb.alias}.${sql.identifier(attributeName)}`),
+        codec: aggregateGroupBySpec.sqlWrapCodec(attrCodec)
+    });
+}, [], 'applyGroupByAggregateSpec');
+const applyGroupByAttribute = 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}'`);
+            }
+        }
+    }
+};
+export { Plugin as PgAggregatesAddGroupByAggregateEnumValuesForAttributesPlugin };

package/esm/AddGroupByAggregateEnumsPlugin.d.ts

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

package/esm/AddGroupByAggregateEnumsPlugin.js

@@ -0,0 +1,48 @@
+const version = '1.0.0';
+const Plugin = {
+    name: 'PgAggregatesAddGroupByAggregateEnumsPlugin',
+    description: 'Creates the enum types used for grouping in groupedAggregates.',
+    version,
+    provides: ['aggregates'],
+    schema: {
+        entityBehavior: {
+            pgResource: ['select', 'order', 'groupedAggregates']
+        },
+        hooks: {
+            // Create the group by enums for each table
+            init(_, build) {
+                const { inflection } = build;
+                for (const resource of Object.values(build.input.pgRegistry.pgResources)) {
+                    if (resource.parameters ||
+                        !resource.codec.attributes ||
+                        resource.isUnique) {
+                        continue;
+                    }
+                    if (!build.behavior.pgResourceMatches(resource, 'select')) {
+                        continue;
+                    }
+                    if (!build.behavior.pgResourceMatches(resource, 'order')) {
+                        continue;
+                    }
+                    if (!build.behavior.pgResourceMatches(resource, 'resource:groupedAggregates')) {
+                        continue;
+                    }
+                    const tableTypeName = inflection.tableType(resource.codec);
+                    /* const TableGroupByType = */
+                    build.registerEnumType(inflection.aggregateGroupByType({ resource }), {
+                        pgTypeResource: resource,
+                        isPgAggregateGroupEnum: true
+                    }, () => ({
+                        name: inflection.aggregateGroupByType({ resource }),
+                        description: build.wrapDescription(`Grouping methods for \`${tableTypeName}\` for usage during aggregation.`, 'type'),
+                        values: {
+                        /* no default values, these will be added via hooks */
+                        }
+                    }), `Adding connection "groupBy" enum type for ${resource.name}.`);
+                }
+                return _;
+            }
+        }
+    }
+};
+export { Plugin as PgAggregatesAddGroupByAggregateEnumsPlugin };

package/esm/AddHavingAggregateTypesPlugin.d.ts

@@ -0,0 +1,22 @@
+declare global {
+    namespace GraphileBuild {
+        interface BehaviorStrings {
+            'resource:groupedAggregates:having': true;
+            having: true;
+            'resource:havingBy': true;
+            'attribute:havingBy': true;
+            havingBy: true;
+            'sum:resource:groupedAggregates:having': true;
+            'distinctCount:resource:groupedAggregates:having': true;
+            'min:resource:groupedAggregates:having': true;
+            'max:resource:groupedAggregates:having': true;
+            'average:resource:groupedAggregates:having': true;
+            'stddevSample:resource:groupedAggregates:having': true;
+            'stddevPopulation:resource:groupedAggregates:having': true;
+            'varianceSample:resource:groupedAggregates:having': true;
+            'variancePopulation:resource:groupedAggregates:having': true;
+        }
+    }
+}
+declare const Plugin: GraphileConfig.Plugin;
+export { Plugin as PgAggregatesAddHavingAggregateTypesPlugin };