graphile-pg-aggregates 1.1.0

package/esm/InflectionPlugin.js

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

package/esm/OrderByAggregatesPlugin.d.ts

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

package/esm/OrderByAggregatesPlugin.js

@@ -0,0 +1,202 @@
+import { EXPORTABLE } from './EXPORTABLE';
+const version = '1.0.0';
+const pgAggregatesApplyOrderByTotalCount = EXPORTABLE(() => (TYPES, direction, relation, sql, table, $select) => {
+    const foreignTableAlias = $select.alias;
+    const conditions = [];
+    const tableAlias = sql.identifier(Symbol(table.name));
+    relation.localAttributes.forEach((localAttribute, i) => {
+        const remoteAttribute = relation.remoteAttributes[i];
+        conditions.push(sql.fragment `${tableAlias}.${sql.identifier(remoteAttribute)} = ${foreignTableAlias}.${sql.identifier(localAttribute)}`);
+    });
+    if (typeof table.from === 'function') {
+        throw new Error(`Function source unsupported`);
+    }
+    // TODO: refactor this to use joins instead of subqueries
+    const fragment = sql `(${sql.indent `select count(*)
+from ${table.from} ${tableAlias}
+where ${sql.parens(sql.join(conditions.map((c) => sql.parens(c)), ' AND '))}`})`;
+    $select.orderBy({
+        fragment,
+        codec: TYPES.bigint,
+        direction
+    });
+}, [], 'pgAggregatesApplyOrderByTotalCount');
+const pgAggregatesApplyOrderByAttribute = EXPORTABLE(() => (aggregateSpec, attribute, attributeName, direction, relation, sql, table, $select) => {
+    const foreignTableAlias = $select.alias;
+    const conditions = [];
+    const tableAlias = sql.identifier(Symbol(table.name));
+    relation.localAttributes.forEach((localAttribute, i) => {
+        const remoteAttribute = relation.remoteAttributes[i];
+        conditions.push(sql.fragment `${tableAlias}.${sql.identifier(remoteAttribute)} = ${foreignTableAlias}.${sql.identifier(localAttribute)}`);
+    });
+    if (typeof table.from === 'function') {
+        throw new Error(`Function source unsupported`);
+    }
+    // TODO: refactor this to use joins instead of subqueries
+    const fragment = sql `(${sql.indent `
+select ${aggregateSpec.sqlAggregateWrap(sql.fragment `${tableAlias}.${sql.identifier(attributeName)}`, attribute.codec)}
+from ${table.from} ${tableAlias}
+where ${sql.join(conditions.map((c) => sql.parens(c)), ' AND ')}`})`;
+    $select.orderBy({
+        fragment,
+        codec: aggregateSpec.pgTypeCodecModifier?.(attribute.codec) ??
+            attribute.codec,
+        direction
+    });
+}, [], 'pgAggregatesApplyOrderByAttribute');
+export const PgAggregatesOrderByAggregatesPlugin = {
+    name: 'PgAggregatesOrderByAggregatesPlugin',
+    description: 'Adds enum values to the OrderBy enum to allow ordering by aggregates on relations.',
+    version,
+    provides: ['aggregates'],
+    schema: {
+        behaviorRegistry: {
+            add: {
+                'relatedAggregates:orderBy': {
+                    description: '',
+                    entities: ['pgResource']
+                },
+                'aggregates:orderBy': {
+                    description: '',
+                    entities: ['pgCodecRelation']
+                },
+                'aggregate:orderBy': {
+                    description: '',
+                    entities: ['pgCodecAttribute']
+                }
+            }
+        },
+        entityBehavior: {
+            pgResource: 'resource:relatedAggregates:orderBy',
+            pgCodecRelation: ['select', 'manyRelation:aggregates:orderBy'],
+            pgCodecAttribute: ['attribute:aggregate:orderBy']
+        },
+        hooks: {
+            GraphQLEnumType_values(values, build, context) {
+                const { extend, sql, inflection, dataplanPg: { TYPES }, EXPORTABLE } = build;
+                const pgAggregateSpecs = build.pgAggregateSpecs;
+                const { scope: { isPgRowSortEnum, pgTypeResource, pgCodec } } = context;
+                const foreignTable = pgTypeResource ??
+                    Object.values(build.input.pgRegistry.pgResources).find((s) => s.codec === pgCodec && !s.parameters);
+                if (!isPgRowSortEnum ||
+                    !foreignTable ||
+                    foreignTable.parameters ||
+                    !foreignTable.codec.attributes) {
+                    return values;
+                }
+                if (!build.behavior.pgResourceMatches(foreignTable, 'resource:relatedAggregates:orderBy')) {
+                    return values;
+                }
+                const relations = foreignTable.getRelations();
+                const referenceeRelations = Object.entries(relations).filter(([_, rel]) => rel.isReferencee);
+                const newValues = referenceeRelations.reduce((memo, [relationName, relation]) => {
+                    if (!build.behavior.pgCodecRelationMatches(relation, 'select')) {
+                        return memo;
+                    }
+                    if (!build.behavior.pgCodecRelationMatches(relation, 'manyRelation:aggregates:orderBy')) {
+                        return memo;
+                    }
+                    const table = relation.remoteResource;
+                    const isUnique = !!relation.isUnique;
+                    if (isUnique) {
+                        // No point aggregating over a relation that's unique
+                        return memo;
+                    }
+                    // Add count
+                    const totalCountBaseName = inflection.orderByCountOfManyRelationByKeys({
+                        registry: foreignTable.registry,
+                        codec: foreignTable.codec,
+                        relationName
+                    });
+                    const makeTotalCountApply = (direction) => {
+                        return EXPORTABLE((TYPES, direction, pgAggregatesApplyOrderByTotalCount, relation, sql, table) => function apply($select) {
+                            pgAggregatesApplyOrderByTotalCount(TYPES, direction, relation, sql, table, $select);
+                        }, [
+                            TYPES,
+                            direction,
+                            pgAggregatesApplyOrderByTotalCount,
+                            relation,
+                            sql,
+                            table
+                        ]);
+                    };
+                    memo = build.extend(memo, {
+                        [`${totalCountBaseName}_ASC`]: {
+                            extensions: {
+                                grafast: {
+                                    apply: makeTotalCountApply('ASC')
+                                }
+                            }
+                        },
+                        [`${totalCountBaseName}_DESC`]: {
+                            extensions: {
+                                grafast: {
+                                    apply: makeTotalCountApply('DESC')
+                                }
+                            }
+                        }
+                    }, `Adding orderBy count to '${foreignTable.name}' using relation '${relationName}'`);
+                    // Add other aggregates
+                    pgAggregateSpecs.forEach((aggregateSpec) => {
+                        if (!build.behavior.pgCodecRelationMatches(relation, `${aggregateSpec.id}:manyRelation:aggregates:orderBy`)) {
+                            return;
+                        }
+                        for (const [attributeName, attribute] of Object.entries(table.codec.attributes)) {
+                            if (!build.behavior.pgCodecAttributeMatches([table.codec, attributeName], `${aggregateSpec.id}:attribute:aggregate:orderBy`)) {
+                                continue;
+                            }
+                            if ((aggregateSpec.shouldApplyToEntity &&
+                                !aggregateSpec.shouldApplyToEntity({
+                                    type: 'attribute',
+                                    codec: table.codec,
+                                    attributeName: attributeName
+                                })) ||
+                                !aggregateSpec.isSuitableType(attribute.codec)) {
+                                continue;
+                            }
+                            const baseName = inflection.orderByAttributeAggregateOfManyRelationByKeys({
+                                registry: foreignTable.registry,
+                                codec: foreignTable.codec,
+                                relationName,
+                                attributeName: attributeName,
+                                aggregateSpec
+                            });
+                            const makeApply = (direction) => {
+                                return EXPORTABLE((aggregateSpec, attribute, attributeName, direction, pgAggregatesApplyOrderByAttribute, relation, sql, table) => function apply($select) {
+                                    pgAggregatesApplyOrderByAttribute(aggregateSpec, attribute, attributeName, direction, relation, sql, table, $select);
+                                }, [
+                                    aggregateSpec,
+                                    attribute,
+                                    attributeName,
+                                    direction,
+                                    pgAggregatesApplyOrderByAttribute,
+                                    relation,
+                                    sql,
+                                    table
+                                ]);
+                            };
+                            memo = build.extend(memo, {
+                                [`${baseName}_ASC`]: {
+                                    extensions: {
+                                        grafast: {
+                                            apply: makeApply('ASC')
+                                        }
+                                    }
+                                },
+                                [`${baseName}_DESC`]: {
+                                    extensions: {
+                                        grafast: {
+                                            apply: makeApply('DESC')
+                                        }
+                                    }
+                                }
+                            }, `Adding orderBy ${aggregateSpec.id} of '${attributeName}' to '${foreignTable.name}' using constraint '${relationName}'`);
+                        }
+                    });
+                    return memo;
+                }, Object.create(null));
+                return extend(values, newValues, `Adding aggregate orders to '${foreignTable.name}'`);
+            }
+        }
+    }
+};

package/esm/index.d.ts

@@ -0,0 +1,42 @@
+import { PgAggregatesAddAggregateTypesPlugin } from './AddAggregateTypesPlugin';
+import { PgAggregatesAddConnectionAggregatesPlugin } from './AddConnectionAggregatesPlugin';
+import { PgAggregatesAddConnectionGroupedAggregatesPlugin } from './AddConnectionGroupedAggregatesPlugin';
+import { PgAggregatesAddGroupByAggregateEnumsPlugin } from './AddGroupByAggregateEnumsPlugin';
+import { PgAggregatesAddGroupByAggregateEnumValuesForAttributesPlugin } from './AddGroupByAggregateEnumValuesForAttributesPlugin';
+import { PgAggregatesAddHavingAggregateTypesPlugin } from './AddHavingAggregateTypesPlugin';
+import { PgAggregatesSpecsPlugin } from './AggregateSpecsPlugin';
+import { PgAggregatesSmartTagsPlugin } from './AggregatesSmartTagsPlugin';
+import { PgAggregatesFilterRelationalAggregatesPlugin } from './FilterRelationalAggregatesPlugin';
+import { PgAggregatesInflectorsPlugin } from './InflectionPlugin';
+import { PgAggregatesOrderByAggregatesPlugin } from './OrderByAggregatesPlugin';
+export declare const PgAggregatesPreset: GraphileConfig.Preset;
+export { AggregateGroupBySpec, AggregateSpec, AggregateTargetEntity } from './interfaces';
+export { PgAggregatesAddAggregateTypesPlugin };
+export { PgAggregatesAddConnectionAggregatesPlugin };
+export { PgAggregatesAddConnectionGroupedAggregatesPlugin };
+export { PgAggregatesAddGroupByAggregateEnumsPlugin };
+export { PgAggregatesAddGroupByAggregateEnumValuesForAttributesPlugin };
+export { PgAggregatesAddHavingAggregateTypesPlugin };
+export { PgAggregatesSpecsPlugin };
+export { PgAggregatesSmartTagsPlugin };
+export { PgAggregatesFilterRelationalAggregatesPlugin };
+export { PgAggregatesInflectorsPlugin };
+export { PgAggregatesOrderByAggregatesPlugin };
+declare global {
+    namespace GraphileBuild {
+        interface AggregateSpecIds {
+            sum: true;
+            distinctCount: true;
+            min: true;
+            max: true;
+            average: true;
+            stddevSample: true;
+            stddevPopulation: true;
+            varianceSample: true;
+            variancePopulation: true;
+        }
+        interface BehaviorStrings {
+            'resource:groupedAggregates': true;
+        }
+    }
+}

package/esm/index.js

@@ -0,0 +1,37 @@
+import { PgAggregatesAddAggregateTypesPlugin } from './AddAggregateTypesPlugin';
+import { PgAggregatesAddConnectionAggregatesPlugin } from './AddConnectionAggregatesPlugin';
+import { PgAggregatesAddConnectionGroupedAggregatesPlugin } from './AddConnectionGroupedAggregatesPlugin';
+import { PgAggregatesAddGroupByAggregateEnumsPlugin } from './AddGroupByAggregateEnumsPlugin';
+import { PgAggregatesAddGroupByAggregateEnumValuesForAttributesPlugin } from './AddGroupByAggregateEnumValuesForAttributesPlugin';
+import { PgAggregatesAddHavingAggregateTypesPlugin } from './AddHavingAggregateTypesPlugin';
+import { PgAggregatesSpecsPlugin } from './AggregateSpecsPlugin';
+import { PgAggregatesSmartTagsPlugin } from './AggregatesSmartTagsPlugin';
+import { PgAggregatesFilterRelationalAggregatesPlugin } from './FilterRelationalAggregatesPlugin';
+import { PgAggregatesInflectorsPlugin } from './InflectionPlugin';
+import { PgAggregatesOrderByAggregatesPlugin } from './OrderByAggregatesPlugin';
+export const PgAggregatesPreset = {
+    plugins: [
+        PgAggregatesInflectorsPlugin,
+        PgAggregatesSmartTagsPlugin,
+        PgAggregatesSpecsPlugin,
+        PgAggregatesAddGroupByAggregateEnumsPlugin,
+        PgAggregatesAddGroupByAggregateEnumValuesForAttributesPlugin,
+        PgAggregatesAddHavingAggregateTypesPlugin,
+        PgAggregatesAddAggregateTypesPlugin,
+        PgAggregatesAddConnectionAggregatesPlugin,
+        PgAggregatesAddConnectionGroupedAggregatesPlugin,
+        PgAggregatesOrderByAggregatesPlugin,
+        PgAggregatesFilterRelationalAggregatesPlugin
+    ]
+};
+export { PgAggregatesAddAggregateTypesPlugin };
+export { PgAggregatesAddConnectionAggregatesPlugin };
+export { PgAggregatesAddConnectionGroupedAggregatesPlugin };
+export { PgAggregatesAddGroupByAggregateEnumsPlugin };
+export { PgAggregatesAddGroupByAggregateEnumValuesForAttributesPlugin };
+export { PgAggregatesAddHavingAggregateTypesPlugin };
+export { PgAggregatesSpecsPlugin };
+export { PgAggregatesSmartTagsPlugin };
+export { PgAggregatesFilterRelationalAggregatesPlugin };
+export { PgAggregatesInflectorsPlugin };
+export { PgAggregatesOrderByAggregatesPlugin };

package/esm/interfaces.d.ts

@@ -0,0 +1,145 @@
+import type { PgCodec, PgResource, sql } from '@dataplan/pg';
+type SQL = ReturnType<typeof sql>;
+declare global {
+    namespace DataplanPg {
+        interface PgCodecExtensions {
+            isNumberLike?: boolean;
+            isIntervalLike?: boolean;
+        }
+        interface PgConditionStepExtensions {
+            pgFilterAttribute?: {
+                codec: PgCodec<any, any, any, any, any, any, any>;
+                expression: SQL;
+            };
+        }
+    }
+    namespace GraphileBuild {
+        interface Inflection {
+            filterTableAggregateType(foreignTable: PgResource<any, any, any, any>, spec: AggregateSpec): string;
+        }
+        interface Build {
+            pgAggregateSpecs: AggregateSpec[];
+            pgAggregateGroupBySpecs: AggregateGroupBySpec[];
+            pgHavingFilterTypeNameForCodec(codec: PgCodec<any, any, any, any>): string | null;
+        }
+        interface ScopeObject {
+            isPgAggregateContainerType?: boolean;
+            isPgAggregateType?: boolean;
+            pgAggregateSpec?: AggregateSpec;
+        }
+        interface ScopeInputObject {
+            pgTypeResource?: PgResource<any, any, any, any>;
+            isPgHavingFilterInputType?: boolean;
+            isPgAggregateHavingInputType?: boolean;
+            pgHavingFilterSpec?: string;
+            isPgConnectionAggregateFilter?: boolean;
+            isPgConnectionAggregateAggregateFilter?: boolean;
+            pgConnectionAggregateFilterAggregateSpec?: AggregateSpec;
+        }
+        interface ScopeObjectFieldsField {
+            isPgAggregateField?: boolean;
+            isPgConnectionAggregateField?: boolean;
+            pgFieldResource?: PgResource<any, any, any, any, any>;
+        }
+        interface ScopeInputObjectFieldsField {
+            isPgConnectionFilterAggregatesField?: boolean;
+        }
+        interface ScopeEnum {
+            pgTypeResource?: PgResource<any, any, any, any, any>;
+            isPgAggregateGroupEnum?: boolean;
+        }
+    }
+}
+export type AggregateTargetEntity = {
+    type: 'attribute';
+    /** table codec - NOT attribute codec! */
+    codec: PgCodec<any, any, any, any, any, any, any>;
+    /** attribute name available on this codec */
+    attributeName: string;
+    resource?: never;
+} | {
+    type: 'computedAttribute';
+    resource: PgResource<any, any, any, any, any>;
+    codec?: never;
+    attributeName?: never;
+};
+export interface AggregateGroupBySpec {
+    /** Must not change since it's used in type names/etc */
+    id: string;
+    /** Return true if we can process this type */
+    isSuitableType: (codec: PgCodec<any, any, any, any, any, any, any>) => boolean;
+    /** Return false if we cannot process this attribute (default: true) */
+    shouldApplyToEntity?: (entity: AggregateTargetEntity) => boolean;
+    /** Wraps the SQL to return a derivative (e.g.:
+     * ```
+     * sqlFrag => sql.fragment`date_trunc('hour', ${sqlFrag})`)
+     * ```
+     */
+    sqlWrap: (sqlFrag: SQL) => SQL;
+    /**
+     * Which codec represents the type returned by sqlWrap?
+     */
+    sqlWrapCodec: (codec: PgCodec<any, any, any, any, any, any, any>) => PgCodec<any, any, any, any, any, any, any>;
+}
+export interface AggregateSpec {
+    /** Must not change since it's used in type names/etc */
+    id: keyof GraphileBuild.AggregateSpecIds;
+    /** Used in descriptions, starts with lowercase */
+    humanLabel: string;
+    /** Used in descriptions, starts with uppercase */
+    HumanLabel: string;
+    /** Return true if we can process this type */
+    isSuitableType: (codec: PgCodec<any, any, any, any>) => boolean;
+    /** Return false if we cannot process this attribute (default: true) */
+    shouldApplyToEntity?: (entity: AggregateTargetEntity) => boolean;
+    /** Wraps the SQL in an aggregate call */
+    sqlAggregateWrap: (sqlFrag: SQL, codec: PgCodec<any, any, any, any>) => SQL;
+    /**
+     * Used to translate the PostgreSQL return type for the aggregate; for example:
+     *
+     * - Sum over int should give bigint
+     * - Average of int should be float
+     * - Median of int should be int
+     */
+    pgTypeCodecModifier?: (codec: PgCodec<any, any, any, any>) => PgCodec<any, any, any, any>;
+    /** Set true if the result is guaranteed to be non-null */
+    isNonNull?: boolean;
+}
+export declare const BIGINT_OID = "20";
+export declare const INT2_OID = "21";
+export declare const INT4_OID = "23";
+export declare const FLOAT4_OID = "700";
+export declare const FLOAT8_OID = "701";
+export declare const NUMERIC_OID = "1700";
+export declare const MONEY_OID = "790";
+export declare const INTERVAL_OID = "1186";
+export declare const DATE_OID = "1082";
+export declare const TIMESTAMP_OID = "1114";
+export declare const TIMESTAMPTZ_OID = "1184";
+export declare const TIME_OID = "1083";
+export declare const TIMETZ_OID = "1266";
+export declare const JSON_OID = "114";
+export declare const JSONB_OID = "3802";
+export declare const UUID_OID = "2950";
+export declare const BIT_OID = "1560";
+export declare const VARBIT_OID = "1562";
+export declare const CHAR_OID = "18";
+export declare const TEXT_OID = "25";
+export declare const VARCHAR_OID = "1043";
+export declare const POINT_OID = "600";
+export declare const INET_OID = "869";
+export declare const CIDR_OID = "650";
+export declare const MAC_ADDR_OID = "829";
+export declare const MAC_ADDR8_OID = "774";
+export declare const REG_PROC_OID = "24";
+export declare const REG_PROCEDURE_OID = "2202";
+export declare const REG_OPER_OID = "2203";
+export declare const REG_OPERATOR_OID = "2204";
+export declare const REG_CLASS_OID = "2205";
+export declare const REG_OID = "2206";
+export declare const REG_ROLE_OID = "4096";
+export declare const REG_NAMESPACE_OID = "4089";
+export declare const REG_CONFIG_OID = "3734";
+export declare const REG_DICTIONARY_OID = "3769";
+export declare const CORE_HAVING_FILTER_SPECS: readonly ["int", "bigint", "float", "bigfloat", "datetime", "string"];
+export {};

package/esm/interfaces.js

@@ -0,0 +1,44 @@
+export const BIGINT_OID = '20';
+export const INT2_OID = '21';
+export const INT4_OID = '23';
+export const FLOAT4_OID = '700';
+export const FLOAT8_OID = '701';
+export const NUMERIC_OID = '1700';
+export const MONEY_OID = '790';
+export const INTERVAL_OID = '1186';
+export const DATE_OID = '1082';
+export const TIMESTAMP_OID = '1114';
+export const TIMESTAMPTZ_OID = '1184';
+export const TIME_OID = '1083';
+export const TIMETZ_OID = '1266';
+export const JSON_OID = '114';
+export const JSONB_OID = '3802';
+export const UUID_OID = '2950';
+export const BIT_OID = '1560';
+export const VARBIT_OID = '1562';
+export const CHAR_OID = '18';
+export const TEXT_OID = '25';
+export const VARCHAR_OID = '1043';
+export const POINT_OID = '600';
+export const INET_OID = '869';
+export const CIDR_OID = '650';
+export const MAC_ADDR_OID = '829';
+export const MAC_ADDR8_OID = '774';
+export const REG_PROC_OID = '24';
+export const REG_PROCEDURE_OID = '2202';
+export const REG_OPER_OID = '2203';
+export const REG_OPERATOR_OID = '2204';
+export const REG_CLASS_OID = '2205';
+export const REG_OID = '2206';
+export const REG_ROLE_OID = '4096';
+export const REG_NAMESPACE_OID = '4089';
+export const REG_CONFIG_OID = '3734';
+export const REG_DICTIONARY_OID = '3769';
+export const CORE_HAVING_FILTER_SPECS = [
+    'int',
+    'bigint',
+    'float',
+    'bigfloat',
+    'datetime',
+    'string'
+];

package/esm/utils.d.ts

@@ -0,0 +1,23 @@
+import type { PgResource, PgResourceParameter } from '@dataplan/pg';
+import type { GraphileBuild } from 'graphile-build';
+export declare function getComputedAttributeResources(build: GraphileBuild.Build, resource: PgResource<any, any, any, any>): PgResource<string, import("@dataplan/pg").PgCodecWithAttributes<{
+    [x: string]: import("@dataplan/pg").PgCodecAttribute<import("@dataplan/pg").PgCodec<string, /*elided*/ any, any, any, import("@dataplan/pg").PgCodec<string, any, any, any, any, any, any>, import("@dataplan/pg").PgCodec<string, any, any, any, any, any, any>, import("@dataplan/pg").PgCodec<string, undefined, any, any, undefined, any, undefined>>, boolean>;
+}>, readonly import("@dataplan/pg").PgResourceUnique<{
+    [x: string]: import("@dataplan/pg").PgCodecAttribute<import("@dataplan/pg").PgCodec<string, /*elided*/ any, any, any, import("@dataplan/pg").PgCodec<string, any, any, any, any, any, any>, import("@dataplan/pg").PgCodec<string, any, any, any, any, any, any>, import("@dataplan/pg").PgCodec<string, undefined, any, any, undefined, any, undefined>>, boolean>;
+}>[], readonly PgResourceParameter<string, import("@dataplan/pg").PgCodec<string, {
+    [x: string]: import("@dataplan/pg").PgCodecAttribute<import("@dataplan/pg").PgCodec<string, /*elided*/ any, any, any, import("@dataplan/pg").PgCodec<string, any, any, any, any, any, any>, import("@dataplan/pg").PgCodec<string, any, any, any, any, any, any>, import("@dataplan/pg").PgCodec<string, undefined, any, any, undefined, any, undefined>>, boolean>;
+}, any, any, import("@dataplan/pg").PgCodec<string, any, any, any, any, any, any>, import("@dataplan/pg").PgCodec<string, any, any, any, any, any, any>, import("@dataplan/pg").PgCodec<string, undefined, any, any, undefined, any, undefined>>>[], import("@dataplan/pg").PgRegistry<Record<string, import("@dataplan/pg").PgCodec<string, {
+    [x: string]: import("@dataplan/pg").PgCodecAttribute<import("@dataplan/pg").PgCodec<string, /*elided*/ any, any, any, import("@dataplan/pg").PgCodec<string, any, any, any, any, any, any>, import("@dataplan/pg").PgCodec<string, any, any, any, any, any, any>, import("@dataplan/pg").PgCodec<string, undefined, any, any, undefined, any, undefined>>, boolean>;
+}, any, any, any, any, any>>, Record<string, import("@dataplan/pg").PgResourceOptions<string, import("@dataplan/pg").PgCodecWithAttributes<{
+    [x: string]: import("@dataplan/pg").PgCodecAttribute<import("@dataplan/pg").PgCodec<string, /*elided*/ any, any, any, import("@dataplan/pg").PgCodec<string, any, any, any, any, any, any>, import("@dataplan/pg").PgCodec<string, any, any, any, any, any, any>, import("@dataplan/pg").PgCodec<string, undefined, any, any, undefined, any, undefined>>, boolean>;
+}>, readonly import("@dataplan/pg").PgResourceUnique<{
+    [x: string]: import("@dataplan/pg").PgCodecAttribute<import("@dataplan/pg").PgCodec<string, /*elided*/ any, any, any, import("@dataplan/pg").PgCodec<string, any, any, any, any, any, any>, import("@dataplan/pg").PgCodec<string, any, any, any, any, any, any>, import("@dataplan/pg").PgCodec<string, undefined, any, any, undefined, any, undefined>>, boolean>;
+}>[], readonly PgResourceParameter<string, import("@dataplan/pg").PgCodec<string, {
+    [x: string]: import("@dataplan/pg").PgCodecAttribute<import("@dataplan/pg").PgCodec<string, /*elided*/ any, any, any, import("@dataplan/pg").PgCodec<string, any, any, any, any, any, any>, import("@dataplan/pg").PgCodec<string, any, any, any, any, any, any>, import("@dataplan/pg").PgCodec<string, undefined, any, any, undefined, any, undefined>>, boolean>;
+}, any, any, import("@dataplan/pg").PgCodec<string, any, any, any, any, any, any>, import("@dataplan/pg").PgCodec<string, any, any, any, any, any, any>, import("@dataplan/pg").PgCodec<string, undefined, any, any, undefined, any, undefined>>>[]>>, Record<string, Record<string, import("@dataplan/pg").PgCodecRelationConfig<import("@dataplan/pg").PgCodec<string, {
+    [x: string]: import("@dataplan/pg").PgCodecAttribute<import("@dataplan/pg").PgCodec<string, /*elided*/ any, any, any, import("@dataplan/pg").PgCodec<string, any, any, any, any, any, any>, import("@dataplan/pg").PgCodec<string, any, any, any, any, any, any>, import("@dataplan/pg").PgCodec<string, undefined, any, any, undefined, any, undefined>>, boolean>;
+}, any, any, undefined, any, undefined>, import("@dataplan/pg").PgResourceOptions<any, import("@dataplan/pg").PgCodecWithAttributes<{
+    [x: string]: import("@dataplan/pg").PgCodecAttribute<import("@dataplan/pg").PgCodec<string, /*elided*/ any, any, any, import("@dataplan/pg").PgCodec<string, any, any, any, any, any, any>, import("@dataplan/pg").PgCodec<string, any, any, any, any, any, any>, import("@dataplan/pg").PgCodec<string, undefined, any, any, undefined, any, undefined>>, boolean>;
+}>, any, any>>>>, {
+    [executorName: string]: import("@dataplan/pg").PgExecutor<any, any>;
+}>>[];

package/esm/utils.js

@@ -0,0 +1,22 @@
+export function getComputedAttributeResources(build, resource) {
+    const computedAttributeResources = Object.values(build.input.pgRegistry.pgResources).filter((s) => {
+        if (!s.parameters || s.parameters.length < 1) {
+            return false;
+        }
+        if (s.codec.attributes) {
+            return false;
+        }
+        if (!s.isUnique) {
+            return false;
+        }
+        if (s.codec.arrayOfCodec) {
+            return false;
+        }
+        const firstParameter = s.parameters[0];
+        if (firstParameter.codec !== resource.codec) {
+            return false;
+        }
+        return true;
+    });
+    return computedAttributeResources;
+}