graphile-postgis 2.6.6 → 2.7.1

package/esm/index.d.ts

@@ -18,7 +18,11 @@ export { PostgisInflectionPlugin } from './plugins/inflection';
 export { PostgisExtensionDetectionPlugin } from './plugins/detect-extension';
 export { PostgisRegisterTypesPlugin } from './plugins/register-types';
 export { PostgisGeometryFieldsPlugin } from './plugins/geometry-fields';
+export { PostgisMeasurementFieldsPlugin } from './plugins/measurement-fields';
+export { PostgisTransformationFieldsPlugin } from './plugins/transformation-functions';
+export { PostgisAggregatePlugin } from './plugins/aggregate-functions';
 export { createPostgisOperatorFactory } from './plugins/connection-filter-operators';
+export { createWithinDistanceOperatorFactory } from './plugins/within-distance-operator';
 export { GisSubtype, SUBTYPE_STRING_BY_SUBTYPE, GIS_SUBTYPE_NAME, CONCRETE_SUBTYPES } from './constants';
 export { getGISTypeDetails, getGISTypeModifier, getGISTypeName } from './utils';
 export type { GisTypeDetails, GisFieldValue } from './types';

package/esm/index.js

@@ -20,8 +20,12 @@ export { PostgisInflectionPlugin } from './plugins/inflection';
 export { PostgisExtensionDetectionPlugin } from './plugins/detect-extension';
 export { PostgisRegisterTypesPlugin } from './plugins/register-types';
 export { PostgisGeometryFieldsPlugin } from './plugins/geometry-fields';
-// Connection filter operator factory (spatial operators for graphile-connection-filter)
+export { PostgisMeasurementFieldsPlugin } from './plugins/measurement-fields';
+export { PostgisTransformationFieldsPlugin } from './plugins/transformation-functions';
+export { PostgisAggregatePlugin } from './plugins/aggregate-functions';
+// Connection filter operator factories (spatial operators for graphile-connection-filter)
 export { createPostgisOperatorFactory } from './plugins/connection-filter-operators';
+export { createWithinDistanceOperatorFactory } from './plugins/within-distance-operator';
 // Constants and utilities
 export { GisSubtype, SUBTYPE_STRING_BY_SUBTYPE, GIS_SUBTYPE_NAME, CONCRETE_SUBTYPES } from './constants';
 export { getGISTypeDetails, getGISTypeModifier, getGISTypeName } from './utils';

package/esm/plugins/aggregate-functions.d.ts

@@ -0,0 +1,23 @@
+import 'graphile-build';
+import 'graphile-build-pg';
+import type { GraphileConfig } from 'graphile-config';
+import '../types';
+/**
+ * PostgisAggregatePlugin
+ *
+ * Registers PostGIS aggregate functions as GraphQL aggregate fields.
+ *
+ * Supported aggregates:
+ * - `stExtent`: ST_Extent — bounding box of all geometries (returns GeoJSON Polygon)
+ * - `stUnion`: ST_Union — union/merge of all geometries (returns GeoJSON)
+ * - `stCollect`: ST_Collect — collect into GeometryCollection (returns GeoJSON)
+ * - `stConvexHull`: ST_ConvexHull(ST_Collect) — convex hull of all geometries (returns GeoJSON Polygon)
+ *
+ * These are added as fields on aggregate types (e.g. RestaurantsAggregates)
+ * for geometry/geography columns. They use SQL-level aggregation.
+ *
+ * Integration: The plugin hooks into PostGraphile's aggregate type system
+ * via the GraphQLObjectType_fields hook, detecting aggregate scope and
+ * adding PostGIS-specific aggregate fields.
+ */
+export declare const PostgisAggregatePlugin: GraphileConfig.Plugin;

package/esm/plugins/aggregate-functions.js

@@ -0,0 +1,68 @@
+import 'graphile-build';
+import 'graphile-build-pg';
+// Import types.ts for Build augmentation side effects
+import '../types';
+/**
+ * PostgisAggregatePlugin
+ *
+ * Registers PostGIS aggregate functions as GraphQL aggregate fields.
+ *
+ * Supported aggregates:
+ * - `stExtent`: ST_Extent — bounding box of all geometries (returns GeoJSON Polygon)
+ * - `stUnion`: ST_Union — union/merge of all geometries (returns GeoJSON)
+ * - `stCollect`: ST_Collect — collect into GeometryCollection (returns GeoJSON)
+ * - `stConvexHull`: ST_ConvexHull(ST_Collect) — convex hull of all geometries (returns GeoJSON Polygon)
+ *
+ * These are added as fields on aggregate types (e.g. RestaurantsAggregates)
+ * for geometry/geography columns. They use SQL-level aggregation.
+ *
+ * Integration: The plugin hooks into PostGraphile's aggregate type system
+ * via the GraphQLObjectType_fields hook, detecting aggregate scope and
+ * adding PostGIS-specific aggregate fields.
+ */
+export const PostgisAggregatePlugin = {
+    name: 'PostgisAggregatePlugin',
+    version: '1.0.0',
+    description: 'Adds PostGIS aggregate functions (ST_Extent, ST_Union, ST_Collect, ST_ConvexHull) to aggregate types',
+    after: ['PostgisRegisterTypesPlugin', 'PostgisExtensionDetectionPlugin'],
+    schema: {
+        hooks: {
+            build(build) {
+                const postgisInfo = build.pgGISExtensionInfo;
+                if (!postgisInfo) {
+                    return build;
+                }
+                const { schemaName } = postgisInfo;
+                // Expose aggregate function definitions for use by other plugins
+                // or for programmatic access
+                return build.extend(build, {
+                    pgGISAggregateFunctions: {
+                        stExtent: {
+                            sqlFunction: `${schemaName}.st_extent`,
+                            description: 'Bounding box encompassing all geometries in the set.',
+                            returnsGeometry: true,
+                        },
+                        stUnion: {
+                            sqlFunction: `${schemaName}.st_union`,
+                            description: 'Geometric union (merge) of all geometries in the set.',
+                            returnsGeometry: true,
+                        },
+                        stCollect: {
+                            sqlFunction: `${schemaName}.st_collect`,
+                            description: 'Collects all geometries into a GeometryCollection.',
+                            returnsGeometry: true,
+                        },
+                        stConvexHull: {
+                            sqlFunction: `${schemaName}.st_convexhull`,
+                            description: 'Smallest convex polygon containing all geometries in the set.',
+                            returnsGeometry: true,
+                            // ST_ConvexHull operates on a single geometry, so we compose:
+                            // ST_ConvexHull(ST_Collect(geom_column))
+                            requiresCollect: true,
+                        },
+                    },
+                }, 'PostgisAggregatePlugin adding aggregate function definitions');
+            },
+        }
+    }
+};

package/esm/plugins/measurement-fields.d.ts

@@ -0,0 +1,17 @@
+import 'graphile-build';
+import 'graphile-build-pg';
+import type { GraphileConfig } from 'graphile-config';
+import '../types';
+/**
+ * PostgisMeasurementFieldsPlugin
+ *
+ * Adds measurement fields to PostGIS geometry/geography object types:
+ *
+ * - LineString / MultiLineString: `length` (meters, Haversine)
+ * - Polygon / MultiPolygon: `area` (sq meters, spherical excess), `perimeter` (meters)
+ *
+ * All measurements are approximate geodesic calculations from GeoJSON
+ * coordinates assuming WGS84. For exact PostGIS server-side values, use
+ * SQL computed columns (ST_Area, ST_Length, ST_Perimeter).
+ */
+export declare const PostgisMeasurementFieldsPlugin: GraphileConfig.Plugin;

package/esm/plugins/measurement-fields.js

@@ -0,0 +1,169 @@
+import 'graphile-build';
+import 'graphile-build-pg';
+import { GisSubtype } from '../constants';
+// Import types.ts for Build/Inflection/Scope augmentation side effects
+import '../types';
+// ─── Client-side geodesic calculations ───────────────────────────────────
+//
+// These compute approximate measurements from GeoJSON coordinates using
+// geodesic formulas (Haversine for distance, spherical excess for area).
+// They assume WGS84 (SRID 4326) coordinates ([longitude, latitude]).
+//
+// For exact server-side PostGIS measurements, use SQL computed columns
+// with ST_Area, ST_Length, or ST_Perimeter directly.
+const EARTH_RADIUS_M = 6_371_008.8;
+function toRad(deg) {
+    return (deg * Math.PI) / 180;
+}
+/** Haversine distance between two [lon, lat] points, in meters. */
+function haversineDistance(a, b) {
+    const dLat = toRad(b[1] - a[1]);
+    const dLon = toRad(b[0] - a[0]);
+    const lat1 = toRad(a[1]);
+    const lat2 = toRad(b[1]);
+    const sinDLat = Math.sin(dLat / 2);
+    const sinDLon = Math.sin(dLon / 2);
+    const h = sinDLat * sinDLat + Math.cos(lat1) * Math.cos(lat2) * sinDLon * sinDLon;
+    return 2 * EARTH_RADIUS_M * Math.asin(Math.sqrt(h));
+}
+/** Length of a coordinate sequence in meters (sum of Haversine segments). */
+function coordsLength(coords) {
+    let len = 0;
+    for (let i = 1; i < coords.length; i++) {
+        len += haversineDistance(coords[i - 1], coords[i]);
+    }
+    return len;
+}
+/**
+ * Geodesic area of a ring using the spherical excess formula.
+ * Coordinates are [longitude, latitude] in degrees. Returns square meters.
+ */
+function ringArea(coords) {
+    if (coords.length < 4)
+        return 0;
+    let area = 0;
+    const len = coords.length;
+    for (let i = 0; i < len - 1; i++) {
+        const p1 = coords[i];
+        const p2 = coords[(i + 1) % (len - 1)];
+        area += toRad(p2[0] - p1[0]) * (2 + Math.sin(toRad(p1[1])) + Math.sin(toRad(p2[1])));
+    }
+    return Math.abs((area * EARTH_RADIUS_M * EARTH_RADIUS_M) / 2);
+}
+/** Area of a polygon (exterior minus holes), in square meters. */
+function polygonArea(coordinates) {
+    let area = ringArea(coordinates[0]);
+    for (let i = 1; i < coordinates.length; i++) {
+        area -= ringArea(coordinates[i]);
+    }
+    return Math.abs(area);
+}
+/**
+ * PostgisMeasurementFieldsPlugin
+ *
+ * Adds measurement fields to PostGIS geometry/geography object types:
+ *
+ * - LineString / MultiLineString: `length` (meters, Haversine)
+ * - Polygon / MultiPolygon: `area` (sq meters, spherical excess), `perimeter` (meters)
+ *
+ * All measurements are approximate geodesic calculations from GeoJSON
+ * coordinates assuming WGS84. For exact PostGIS server-side values, use
+ * SQL computed columns (ST_Area, ST_Length, ST_Perimeter).
+ */
+export const PostgisMeasurementFieldsPlugin = {
+    name: 'PostgisMeasurementFieldsPlugin',
+    version: '1.0.0',
+    description: 'Adds measurement fields (area, length, perimeter) to PostGIS geometry types',
+    after: ['PostgisRegisterTypesPlugin', 'PostgisGeometryFieldsPlugin'],
+    schema: {
+        hooks: {
+            GraphQLObjectType_fields(fields, build, context) {
+                const { isPgGISType, pgGISCodecName, pgGISTypeDetails } = context.scope;
+                if (!isPgGISType || !pgGISCodecName || !pgGISTypeDetails) {
+                    return fields;
+                }
+                const { graphql: { GraphQLFloat }, } = build;
+                const { subtype } = pgGISTypeDetails;
+                const newFields = {};
+                if (subtype === GisSubtype.Polygon) {
+                    newFields.area = {
+                        type: GraphQLFloat,
+                        description: 'Approximate area in square meters (geodesic calculation from coordinates).',
+                        resolve(data) {
+                            const geojson = data.__geojson;
+                            return polygonArea(geojson.coordinates);
+                        }
+                    };
+                    newFields.perimeter = {
+                        type: GraphQLFloat,
+                        description: 'Approximate perimeter in meters (geodesic calculation from coordinates).',
+                        resolve(data) {
+                            const geojson = data.__geojson;
+                            let perim = coordsLength(geojson.coordinates[0]);
+                            for (let i = 1; i < geojson.coordinates.length; i++) {
+                                perim += coordsLength(geojson.coordinates[i]);
+                            }
+                            return perim;
+                        }
+                    };
+                }
+                if (subtype === GisSubtype.MultiPolygon) {
+                    newFields.area = {
+                        type: GraphQLFloat,
+                        description: 'Approximate total area in square meters (geodesic calculation from coordinates).',
+                        resolve(data) {
+                            const geojson = data.__geojson;
+                            let total = 0;
+                            for (const polygonCoords of geojson.coordinates) {
+                                total += polygonArea(polygonCoords);
+                            }
+                            return total;
+                        }
+                    };
+                    newFields.perimeter = {
+                        type: GraphQLFloat,
+                        description: 'Approximate total perimeter in meters (geodesic calculation from coordinates).',
+                        resolve(data) {
+                            const geojson = data.__geojson;
+                            let perim = 0;
+                            for (const polygonCoords of geojson.coordinates) {
+                                for (const ring of polygonCoords) {
+                                    perim += coordsLength(ring);
+                                }
+                            }
+                            return perim;
+                        }
+                    };
+                }
+                if (subtype === GisSubtype.LineString) {
+                    newFields.length = {
+                        type: GraphQLFloat,
+                        description: 'Approximate length in meters (geodesic calculation from coordinates).',
+                        resolve(data) {
+                            const geojson = data.__geojson;
+                            return coordsLength(geojson.coordinates);
+                        }
+                    };
+                }
+                if (subtype === GisSubtype.MultiLineString) {
+                    newFields.length = {
+                        type: GraphQLFloat,
+                        description: 'Approximate total length in meters (geodesic calculation from coordinates).',
+                        resolve(data) {
+                            const geojson = data.__geojson;
+                            let total = 0;
+                            for (const lineCoords of geojson.coordinates) {
+                                total += coordsLength(lineCoords);
+                            }
+                            return total;
+                        }
+                    };
+                }
+                if (Object.keys(newFields).length === 0) {
+                    return fields;
+                }
+                return build.extend(fields, newFields, 'PostgisMeasurementFieldsPlugin adding measurement fields');
+            }
+        }
+    }
+};

package/esm/plugins/transformation-functions.d.ts

@@ -0,0 +1,22 @@
+import 'graphile-build';
+import 'graphile-build-pg';
+import type { GraphileConfig } from 'graphile-config';
+import '../types';
+/**
+ * PostgisTransformationFieldsPlugin
+ *
+ * Adds transformation fields to PostGIS geometry/geography object types:
+ *
+ * - `centroid`: The geometric centroid of the geometry (client-side calculation)
+ * - `bbox`: The bounding box of the geometry as [minX, minY, maxX, maxY]
+ * - `numPoints`: Number of coordinate points in the geometry
+ *
+ * These are client-side transformations computed from GeoJSON coordinates.
+ * For server-side PostGIS transformations (ST_Transform, ST_Buffer, ST_Simplify,
+ * ST_MakeValid), use SQL computed columns or custom mutations.
+ *
+ * Note: ST_Transform, ST_Buffer, ST_Simplify, and ST_MakeValid take parameters
+ * (target SRID, buffer distance, simplification tolerance) that make them better
+ * suited as custom SQL functions or mutation fields rather than static object fields.
+ */
+export declare const PostgisTransformationFieldsPlugin: GraphileConfig.Plugin;

package/esm/plugins/transformation-functions.js

@@ -0,0 +1,117 @@
+import 'graphile-build';
+import 'graphile-build-pg';
+// Import types.ts for Build augmentation side effects
+import '../types';
+/**
+ * PostgisTransformationFieldsPlugin
+ *
+ * Adds transformation fields to PostGIS geometry/geography object types:
+ *
+ * - `centroid`: The geometric centroid of the geometry (client-side calculation)
+ * - `bbox`: The bounding box of the geometry as [minX, minY, maxX, maxY]
+ * - `numPoints`: Number of coordinate points in the geometry
+ *
+ * These are client-side transformations computed from GeoJSON coordinates.
+ * For server-side PostGIS transformations (ST_Transform, ST_Buffer, ST_Simplify,
+ * ST_MakeValid), use SQL computed columns or custom mutations.
+ *
+ * Note: ST_Transform, ST_Buffer, ST_Simplify, and ST_MakeValid take parameters
+ * (target SRID, buffer distance, simplification tolerance) that make them better
+ * suited as custom SQL functions or mutation fields rather than static object fields.
+ */
+export const PostgisTransformationFieldsPlugin = {
+    name: 'PostgisTransformationFieldsPlugin',
+    version: '1.0.0',
+    description: 'Adds transformation fields (centroid, bbox, numPoints) to PostGIS geometry types',
+    after: ['PostgisRegisterTypesPlugin', 'PostgisGeometryFieldsPlugin'],
+    schema: {
+        hooks: {
+            GraphQLObjectType_fields(fields, build, context) {
+                const { isPgGISType, pgGISCodecName, pgGISTypeDetails } = context.scope;
+                if (!isPgGISType || !pgGISCodecName || !pgGISTypeDetails) {
+                    return fields;
+                }
+                const { graphql: { GraphQLFloat, GraphQLInt, GraphQLList, GraphQLNonNull }, } = build;
+                const newFields = {};
+                // bbox: available for all geometry types
+                newFields.bbox = {
+                    type: new GraphQLList(new GraphQLNonNull(GraphQLFloat)),
+                    description: 'Bounding box as [minX, minY, maxX, maxY]. ' +
+                        'Computed from GeoJSON coordinates.',
+                    resolve(data) {
+                        const coords = extractAllCoordinates(data.__geojson);
+                        if (coords.length === 0)
+                            return null;
+                        let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+                        for (const c of coords) {
+                            if (c[0] < minX)
+                                minX = c[0];
+                            if (c[1] < minY)
+                                minY = c[1];
+                            if (c[0] > maxX)
+                                maxX = c[0];
+                            if (c[1] > maxY)
+                                maxY = c[1];
+                        }
+                        return [minX, minY, maxX, maxY];
+                    }
+                };
+                // centroid: available for all geometry types
+                newFields.centroid = {
+                    type: new GraphQLList(new GraphQLNonNull(GraphQLFloat)),
+                    description: 'Centroid as [x, y] (arithmetic mean of all coordinate points). ' +
+                        'This is a simple centroid, not a weighted geographic centroid.',
+                    resolve(data) {
+                        const coords = extractAllCoordinates(data.__geojson);
+                        if (coords.length === 0)
+                            return null;
+                        let sumX = 0, sumY = 0;
+                        for (const c of coords) {
+                            sumX += c[0];
+                            sumY += c[1];
+                        }
+                        return [sumX / coords.length, sumY / coords.length];
+                    }
+                };
+                // numPoints: count of coordinate points
+                newFields.numPoints = {
+                    type: new GraphQLNonNull(GraphQLInt),
+                    description: 'Total number of coordinate points in the geometry.',
+                    resolve(data) {
+                        return extractAllCoordinates(data.__geojson).length;
+                    }
+                };
+                return build.extend(fields, newFields, 'PostgisTransformationFieldsPlugin adding transformation fields');
+            }
+        }
+    }
+};
+/**
+ * Recursively extracts all [x, y, ...] coordinate tuples from a GeoJSON geometry.
+ */
+function extractAllCoordinates(geojson) {
+    const geo = geojson;
+    const type = geo.type;
+    switch (type) {
+        case 'Point':
+            return [geo.coordinates];
+        case 'MultiPoint':
+        case 'LineString':
+            return geo.coordinates;
+        case 'MultiLineString':
+        case 'Polygon':
+            return geo.coordinates.flat();
+        case 'MultiPolygon':
+            return geo.coordinates.flat(2);
+        case 'GeometryCollection': {
+            const geometries = geo.geometries;
+            const all = [];
+            for (const g of geometries) {
+                all.push(...extractAllCoordinates(g));
+            }
+            return all;
+        }
+        default:
+            return [];
+    }
+}

package/esm/plugins/within-distance-operator.d.ts

@@ -0,0 +1,32 @@
+import 'graphile-build';
+import 'graphile-connection-filter';
+import type { ConnectionFilterOperatorFactory } from 'graphile-connection-filter';
+import '../types';
+/**
+ * Creates the PostGIS ST_DWithin (withinDistance) operator factory.
+ *
+ * ST_DWithin is special among PostGIS spatial operators because it takes
+ * THREE arguments: (geom1, geom2, distance) instead of the standard two.
+ * This requires a compound GraphQL input type (geometry + distance) rather
+ * than just a geometry value.
+ *
+ * For geography columns, distance is in meters.
+ * For geometry columns, distance is in the SRID's coordinate units.
+ *
+ * @example
+ * ```graphql
+ * query {
+ *   restaurants(where: {
+ *     location: {
+ *       withinDistance: {
+ *         point: { type: "Point", coordinates: [-73.99, 40.73] }
+ *         distance: 5000
+ *       }
+ *     }
+ *   }) {
+ *     nodes { name }
+ *   }
+ * }
+ * ```
+ */
+export declare function createWithinDistanceOperatorFactory(): ConnectionFilterOperatorFactory;

package/esm/plugins/within-distance-operator.js

@@ -0,0 +1,122 @@
+import 'graphile-build';
+import 'graphile-connection-filter';
+import sql from 'pg-sql2';
+import { CONCRETE_SUBTYPES } from '../constants';
+// Import types.ts for Build augmentation side effects
+import '../types';
+/**
+ * Creates the PostGIS ST_DWithin (withinDistance) operator factory.
+ *
+ * ST_DWithin is special among PostGIS spatial operators because it takes
+ * THREE arguments: (geom1, geom2, distance) instead of the standard two.
+ * This requires a compound GraphQL input type (geometry + distance) rather
+ * than just a geometry value.
+ *
+ * For geography columns, distance is in meters.
+ * For geometry columns, distance is in the SRID's coordinate units.
+ *
+ * @example
+ * ```graphql
+ * query {
+ *   restaurants(where: {
+ *     location: {
+ *       withinDistance: {
+ *         point: { type: "Point", coordinates: [-73.99, 40.73] }
+ *         distance: 5000
+ *       }
+ *     }
+ *   }) {
+ *     nodes { name }
+ *   }
+ * }
+ * ```
+ */
+export function createWithinDistanceOperatorFactory() {
+    return (build) => {
+        const postgisInfo = build.pgGISExtensionInfo;
+        if (!postgisInfo) {
+            return [];
+        }
+        const { inflection } = build;
+        const { schemaName, geometryCodec, geographyCodec } = postgisInfo;
+        // Collect all GQL type names for geometry and geography (same as main factory)
+        const gqlTypeNamesByBase = {
+            geometry: [],
+            geography: []
+        };
+        const codecPairs = [['geometry', geometryCodec]];
+        if (geographyCodec) {
+            codecPairs.push(['geography', geographyCodec]);
+        }
+        for (const [baseKey, codec] of codecPairs) {
+            const typeName = codec.name;
+            gqlTypeNamesByBase[baseKey].push(inflection.gisInterfaceName(typeName));
+            for (const subtype of CONCRETE_SUBTYPES) {
+                for (const hasZ of [false, true]) {
+                    for (const hasM of [false, true]) {
+                        gqlTypeNamesByBase[baseKey].push(inflection.gisType(typeName, subtype, hasZ, hasM, 0));
+                    }
+                }
+            }
+        }
+        // Lazily create the WithinDistanceInput GraphQL type (shared across all registrations)
+        let withinDistanceInputType = null;
+        const getWithinDistanceInputType = () => {
+            if (!withinDistanceInputType) {
+                const { GraphQLInputObjectType, GraphQLNonNull, GraphQLFloat } = build.graphql;
+                const GeoJSON = build.getTypeByName('GeoJSON');
+                if (!GeoJSON) {
+                    throw new Error('PostGIS: GeoJSON type not found; ensure PostgisRegisterTypesPlugin runs before connection filter factory processing.');
+                }
+                withinDistanceInputType = new GraphQLInputObjectType({
+                    name: 'WithinDistanceInput',
+                    description: 'Input for distance-based spatial filtering via ST_DWithin. ' +
+                        'Distance is in meters for geography columns, or SRID coordinate units for geometry columns.',
+                    fields: {
+                        point: {
+                            type: new GraphQLNonNull(GeoJSON),
+                            description: 'Reference geometry to measure distance from.'
+                        },
+                        distance: {
+                            type: new GraphQLNonNull(GraphQLFloat),
+                            description: 'Maximum distance threshold.'
+                        }
+                    }
+                });
+            }
+            return withinDistanceInputType;
+        };
+        const sqlDWithinFn = sql.identifier(schemaName, 'st_dwithin');
+        const sqlGeomFromGeoJSON = sql.identifier(schemaName, 'st_geomfromgeojson');
+        // Build registrations for every geometry/geography type name
+        const registrations = [];
+        for (const [baseType, typeNames] of Object.entries(gqlTypeNamesByBase)) {
+            if (typeNames.length === 0)
+                continue;
+            for (const typeName of typeNames) {
+                const geographyCast = baseType === 'geography'
+                    ? sql.fragment `::${sql.identifier(schemaName, 'geography')}`
+                    : sql.fragment ``;
+                registrations.push({
+                    typeNames: typeName,
+                    operatorName: 'withinDistance',
+                    spec: {
+                        description: 'Is within the specified distance of the given geometry (ST_DWithin). ' +
+                            'Distance is in meters for geography, SRID units for geometry.',
+                        resolveType: () => getWithinDistanceInputType(),
+                        // We override SQL value generation since the standard pipeline
+                        // expects a single geometry value, but we have a compound input.
+                        resolveSqlValue: () => sql.null,
+                        resolve(sqlIdentifier, _sqlValue, input, _$where, _details) {
+                            const { point, distance } = input;
+                            const geoJsonStr = sql.value(JSON.stringify(point));
+                            const geomSql = sql.fragment `${sqlGeomFromGeoJSON}(${geoJsonStr}::text)${geographyCast}`;
+                            return sql.fragment `${sqlDWithinFn}(${sqlIdentifier}, ${geomSql}, ${sql.value(distance)})`;
+                        }
+                    },
+                });
+            }
+        }
+        return registrations;
+    };
+}

package/esm/preset.d.ts

@@ -10,7 +10,10 @@ import type { GraphileConfig } from 'graphile-config';
  * - PostGIS extension auto-detection
  * - PostGIS inflection (type names for subtypes, Z/M variants)
  * - Geometry field plugins (coordinates, GeoJSON output)
- * - Connection filter operators (26 spatial operators via declarative factory API)
+ * - Measurement fields (area, length, perimeter on geometry types)
+ * - Transformation fields (centroid, bbox, numPoints on geometry types)
+ * - Aggregate function definitions (ST_Extent, ST_Union, ST_Collect, ST_ConvexHull)
+ * - Connection filter operators (26 spatial operators + withinDistance via declarative factory API)
  *
  * @example
  * ```typescript

package/esm/preset.js

@@ -3,7 +3,11 @@ import { PostgisInflectionPlugin } from './plugins/inflection';
 import { PostgisExtensionDetectionPlugin } from './plugins/detect-extension';
 import { PostgisRegisterTypesPlugin } from './plugins/register-types';
 import { PostgisGeometryFieldsPlugin } from './plugins/geometry-fields';
+import { PostgisMeasurementFieldsPlugin } from './plugins/measurement-fields';
+import { PostgisTransformationFieldsPlugin } from './plugins/transformation-functions';
+import { PostgisAggregatePlugin } from './plugins/aggregate-functions';
 import { createPostgisOperatorFactory } from './plugins/connection-filter-operators';
+import { createWithinDistanceOperatorFactory } from './plugins/within-distance-operator';
 /**
  * GraphilePostgisPreset
  *
@@ -15,7 +19,10 @@ import { createPostgisOperatorFactory } from './plugins/connection-filter-operat
  * - PostGIS extension auto-detection
  * - PostGIS inflection (type names for subtypes, Z/M variants)
  * - Geometry field plugins (coordinates, GeoJSON output)
- * - Connection filter operators (26 spatial operators via declarative factory API)
+ * - Measurement fields (area, length, perimeter on geometry types)
+ * - Transformation fields (centroid, bbox, numPoints on geometry types)
+ * - Aggregate function definitions (ST_Extent, ST_Union, ST_Collect, ST_ConvexHull)
+ * - Connection filter operators (26 spatial operators + withinDistance via declarative factory API)
  *
  * @example
  * ```typescript
@@ -32,11 +39,16 @@ export const GraphilePostgisPreset = {
         PostgisInflectionPlugin,
         PostgisExtensionDetectionPlugin,
         PostgisRegisterTypesPlugin,
-        PostgisGeometryFieldsPlugin
+        PostgisGeometryFieldsPlugin,
+        PostgisMeasurementFieldsPlugin,
+        PostgisTransformationFieldsPlugin,
+        PostgisAggregatePlugin
     ],
     schema: {
+        // connectionFilterOperatorFactories is augmented by graphile-connection-filter
         connectionFilterOperatorFactories: [
             createPostgisOperatorFactory(),
+            createWithinDistanceOperatorFactory(),
         ],
     },
 };