graphile-postgis 1.1.0 → 2.2.0

package/esm/plugins/geometry-fields.js

@@ -0,0 +1,245 @@
+import 'graphile-build';
+import 'graphile-build-pg';
+import { GisSubtype } from '../constants';
+import { getGISTypeName } from '../utils';
+// Import types.ts for Build/Inflection/Scope augmentation side effects
+import '../types';
+/**
+ * PostgisGeometryFieldsPlugin
+ *
+ * Enhances PostGIS geometry object types with subtype-specific fields:
+ *
+ * - Point: x/longitude, y/latitude, optional z/height
+ * - LineString: points array
+ * - Polygon: exterior ring, interiors array
+ * - MultiPoint: points array
+ * - MultiLineString: lines array
+ * - MultiPolygon: polygons array
+ * - GeometryCollection: geometries array (uses dimension interface)
+ *
+ * Uses the GraphQLObjectType_fields hook to add fields based on the
+ * type's scope (isPgGISType, pgGISCodecName, pgGISTypeDetails).
+ */
+export const PostgisGeometryFieldsPlugin = {
+    name: 'PostgisGeometryFieldsPlugin',
+    version: '2.0.0',
+    description: 'Adds subtype-specific fields to PostGIS geometry types',
+    after: ['PostgisRegisterTypesPlugin', 'PostgisInflectionPlugin'],
+    schema: {
+        hooks: {
+            GraphQLObjectType_fields(fields, build, context) {
+                const { isPgGISType, pgGISCodecName, pgGISTypeDetails } = context.scope;
+                if (!isPgGISType || !pgGISCodecName || !pgGISTypeDetails) {
+                    return fields;
+                }
+                const { graphql: { GraphQLNonNull, GraphQLFloat, GraphQLList }, inflection } = build;
+                const typeDetails = pgGISTypeDetails;
+                const { subtype, hasZ, hasM, srid } = typeDetails;
+                const getType = build.getPostgisTypeByGeometryType;
+                switch (subtype) {
+                    case GisSubtype.Point:
+                        return addPointFields(fields, build, pgGISCodecName, hasZ, GraphQLNonNull, GraphQLFloat, inflection);
+                    case GisSubtype.LineString:
+                        return addLineStringFields(fields, build, pgGISCodecName, hasZ, hasM, srid, GraphQLList, getType);
+                    case GisSubtype.Polygon:
+                        return addPolygonFields(fields, build, pgGISCodecName, hasZ, hasM, srid, GraphQLList, getType);
+                    case GisSubtype.MultiPoint:
+                        return addMultiPointFields(fields, build, pgGISCodecName, hasZ, hasM, srid, GraphQLList, getType);
+                    case GisSubtype.MultiLineString:
+                        return addMultiLineStringFields(fields, build, pgGISCodecName, hasZ, hasM, srid, GraphQLList, getType);
+                    case GisSubtype.MultiPolygon:
+                        return addMultiPolygonFields(fields, build, pgGISCodecName, hasZ, hasM, srid, GraphQLList, getType);
+                    case GisSubtype.GeometryCollection:
+                        return addGeometryCollectionFields(fields, build, pgGISCodecName, hasZ, hasM, GraphQLList);
+                    default:
+                        return fields;
+                }
+            }
+        }
+    }
+};
+function addPointFields(fields, build, codecName, hasZ, GraphQLNonNull, GraphQLFloat, inflection) {
+    const xFieldName = inflection.gisXFieldName(codecName);
+    const yFieldName = inflection.gisYFieldName(codecName);
+    const zFieldName = inflection.gisZFieldName(codecName);
+    const newFields = {
+        [xFieldName]: {
+            type: new GraphQLNonNull(GraphQLFloat),
+            resolve(data) {
+                const coords = data.__geojson.coordinates;
+                if (coords.length < 1) {
+                    throw new Error('Point geometry has no x coordinate');
+                }
+                return coords[0];
+            }
+        },
+        [yFieldName]: {
+            type: new GraphQLNonNull(GraphQLFloat),
+            resolve(data) {
+                const coords = data.__geojson.coordinates;
+                if (coords.length < 2) {
+                    throw new Error('Point geometry has no y coordinate');
+                }
+                return coords[1];
+            }
+        }
+    };
+    if (hasZ) {
+        newFields[zFieldName] = {
+            type: new GraphQLNonNull(GraphQLFloat),
+            resolve(data) {
+                const coords = data.__geojson.coordinates;
+                if (coords.length < 3) {
+                    throw new Error('Point geometry has no z coordinate');
+                }
+                return coords[2];
+            }
+        };
+    }
+    return build.extend(fields, newFields, 'PostgisGeometryFieldsPlugin adding Point fields');
+}
+function addLineStringFields(fields, build, codecName, hasZ, hasM, srid, GraphQLList, getType) {
+    const PointType = getType?.(codecName, GisSubtype.Point, hasZ, hasM, srid);
+    if (!PointType)
+        return fields;
+    return build.extend(fields, {
+        points: {
+            type: new GraphQLList(PointType),
+            resolve(data) {
+                const lineString = data.__geojson;
+                return lineString.coordinates.map((coord) => ({
+                    __gisType: getGISTypeName(GisSubtype.Point, hasZ, hasM),
+                    __srid: data.__srid,
+                    __geojson: {
+                        type: 'Point',
+                        coordinates: coord
+                    }
+                }));
+            }
+        }
+    }, 'PostgisGeometryFieldsPlugin adding LineString fields');
+}
+function addPolygonFields(fields, build, codecName, hasZ, hasM, srid, GraphQLList, getType) {
+    const LineStringType = getType?.(codecName, GisSubtype.LineString, hasZ, hasM, srid);
+    if (!LineStringType)
+        return fields;
+    return build.extend(fields, {
+        exterior: {
+            type: LineStringType,
+            resolve(data) {
+                const polygon = data.__geojson;
+                return {
+                    __gisType: getGISTypeName(GisSubtype.LineString, hasZ, hasM),
+                    __srid: data.__srid,
+                    __geojson: {
+                        type: 'LineString',
+                        coordinates: polygon.coordinates[0]
+                    }
+                };
+            }
+        },
+        interiors: {
+            type: new GraphQLList(LineStringType),
+            resolve(data) {
+                const polygon = data.__geojson;
+                return polygon.coordinates.slice(1).map((coord) => ({
+                    __gisType: getGISTypeName(GisSubtype.LineString, hasZ, hasM),
+                    __srid: data.__srid,
+                    __geojson: {
+                        type: 'LineString',
+                        coordinates: coord
+                    }
+                }));
+            }
+        }
+    }, 'PostgisGeometryFieldsPlugin adding Polygon fields');
+}
+function addMultiPointFields(fields, build, codecName, hasZ, hasM, srid, GraphQLList, getType) {
+    const PointType = getType?.(codecName, GisSubtype.Point, hasZ, hasM, srid);
+    if (!PointType)
+        return fields;
+    return build.extend(fields, {
+        points: {
+            type: new GraphQLList(PointType),
+            resolve(data) {
+                const multiPoint = data.__geojson;
+                return multiPoint.coordinates.map((coord) => ({
+                    __gisType: getGISTypeName(GisSubtype.Point, hasZ, hasM),
+                    __srid: data.__srid,
+                    __geojson: {
+                        type: 'Point',
+                        coordinates: coord
+                    }
+                }));
+            }
+        }
+    }, 'PostgisGeometryFieldsPlugin adding MultiPoint fields');
+}
+function addMultiLineStringFields(fields, build, codecName, hasZ, hasM, srid, GraphQLList, getType) {
+    const LineStringType = getType?.(codecName, GisSubtype.LineString, hasZ, hasM, srid);
+    if (!LineStringType)
+        return fields;
+    return build.extend(fields, {
+        lines: {
+            type: new GraphQLList(LineStringType),
+            resolve(data) {
+                const multiLineString = data.__geojson;
+                return multiLineString.coordinates.map((coord) => ({
+                    __gisType: getGISTypeName(GisSubtype.LineString, hasZ, hasM),
+                    __srid: data.__srid,
+                    __geojson: {
+                        type: 'LineString',
+                        coordinates: coord
+                    }
+                }));
+            }
+        }
+    }, 'PostgisGeometryFieldsPlugin adding MultiLineString fields');
+}
+function addMultiPolygonFields(fields, build, codecName, hasZ, hasM, srid, GraphQLList, getType) {
+    const PolygonType = getType?.(codecName, GisSubtype.Polygon, hasZ, hasM, srid);
+    if (!PolygonType)
+        return fields;
+    return build.extend(fields, {
+        polygons: {
+            type: new GraphQLList(PolygonType),
+            resolve(data) {
+                const multiPolygon = data.__geojson;
+                return multiPolygon.coordinates.map((coord) => ({
+                    __gisType: getGISTypeName(GisSubtype.Polygon, hasZ, hasM),
+                    __srid: data.__srid,
+                    __geojson: {
+                        type: 'Polygon',
+                        coordinates: coord
+                    }
+                }));
+            }
+        }
+    }, 'PostgisGeometryFieldsPlugin adding MultiPolygon fields');
+}
+function addGeometryCollectionFields(fields, build, codecName, hasZ, hasM, GraphQLList) {
+    const dimInterfaceName = build.inflection.gisDimensionInterfaceName(codecName, hasZ, hasM);
+    const Interface = build.getTypeByName(dimInterfaceName);
+    if (!Interface) {
+        return fields;
+    }
+    return build.extend(fields, {
+        geometries: {
+            type: new GraphQLList(Interface),
+            resolve(data) {
+                const geometryCollection = data.__geojson;
+                return geometryCollection.geometries.map((geom) => {
+                    const subtypeValue = GisSubtype[geom.type];
+                    if (subtypeValue === undefined) {
+                        throw new Error(`Unsupported geometry subtype ${geom.type}`);
+                    }
+                    return {
+                        __gisType: getGISTypeName(subtypeValue, hasZ, hasM),
+                        __srid: data.__srid,
+                        __geojson: geom
+                    };
+                });
+            }
+        }
+    }, 'PostgisGeometryFieldsPlugin adding GeometryCollection fields');
+}

package/esm/plugins/inflection.d.ts

@@ -0,0 +1,8 @@
+import type { GraphileConfig } from 'graphile-config';
+import '../types';
+/**
+ * PostgisInflectionPlugin
+ *
+ * Adds inflection methods for generating PostGIS-related GraphQL type names.
+ */
+export declare const PostgisInflectionPlugin: GraphileConfig.Plugin;

package/esm/plugins/inflection.js

@@ -0,0 +1,52 @@
+import { GisSubtype, SUBTYPE_STRING_BY_SUBTYPE } from '../constants';
+// Import types.ts for the Inflection augmentation side effects
+import '../types';
+/**
+ * PostgisInflectionPlugin
+ *
+ * Adds inflection methods for generating PostGIS-related GraphQL type names.
+ */
+export const PostgisInflectionPlugin = {
+    name: 'PostgisInflectionPlugin',
+    version: '2.0.0',
+    description: 'Adds PostGIS-related inflection methods',
+    inflection: {
+        add: {
+            gisType(_options, typeName, subtype, hasZ, hasM, _srid) {
+                return this.upperCamelCase([
+                    typeName,
+                    SUBTYPE_STRING_BY_SUBTYPE[subtype],
+                    hasZ ? 'z' : null,
+                    hasM ? 'm' : null
+                ]
+                    .filter(Boolean)
+                    .join('-'));
+            },
+            gisInterfaceName(_options, typeName) {
+                return this.upperCamelCase(`${typeName}-interface`);
+            },
+            gisDimensionInterfaceName(_options, typeName, hasZ, hasM) {
+                return this.upperCamelCase([
+                    typeName,
+                    SUBTYPE_STRING_BY_SUBTYPE[GisSubtype.Geometry],
+                    hasZ ? 'z' : null,
+                    hasM ? 'm' : null
+                ]
+                    .filter(Boolean)
+                    .join('-'));
+            },
+            geojsonFieldName() {
+                return 'geojson';
+            },
+            gisXFieldName(_options, typeName) {
+                return typeName === 'geography' ? 'longitude' : 'x';
+            },
+            gisYFieldName(_options, typeName) {
+                return typeName === 'geography' ? 'latitude' : 'y';
+            },
+            gisZFieldName(_options, typeName) {
+                return typeName === 'geography' ? 'height' : 'z';
+            }
+        }
+    }
+};

package/esm/plugins/register-types.d.ts

@@ -0,0 +1,22 @@
+import 'graphile-build';
+import 'graphile-build-pg';
+import type { GraphileConfig } from 'graphile-config';
+import '../types';
+/**
+ * PostgisRegisterTypesPlugin
+ *
+ * The core plugin that:
+ * 1. Registers a GeoJSON scalar type
+ * 2. Creates GraphQL interfaces for geometry/geography base types
+ * 3. Creates GraphQL interfaces for each dimension combination (XY, XYZ, XYM, XYZM)
+ * 4. Creates concrete GraphQL object types for each subtype/dimension combo
+ * 5. Registers codec-to-type mappings so PostGraphile knows how to handle
+ *    geometry/geography columns
+ *
+ * In v5, type registration is done during the init hook using
+ * build.registerObjectType / build.registerInterfaceType / build.registerScalarType.
+ *
+ * The SQL tweak wraps geometry/geography values in json_build_object() containing
+ * __gisType, __srid, and __geojson fields, which downstream resolvers use.
+ */
+export declare const PostgisRegisterTypesPlugin: GraphileConfig.Plugin;

package/esm/plugins/register-types.js

@@ -0,0 +1,319 @@
+import 'graphile-build';
+import 'graphile-build-pg';
+import sql from 'pg-sql2';
+import { GisSubtype, CONCRETE_SUBTYPES } from '../constants';
+import { getGISTypeDetails, getGISTypeModifier, getGISTypeName } from '../utils';
+// Import types.ts for the Build/Inflection/Scope augmentation side effects
+import '../types';
+/**
+ * PostgisRegisterTypesPlugin
+ *
+ * The core plugin that:
+ * 1. Registers a GeoJSON scalar type
+ * 2. Creates GraphQL interfaces for geometry/geography base types
+ * 3. Creates GraphQL interfaces for each dimension combination (XY, XYZ, XYM, XYZM)
+ * 4. Creates concrete GraphQL object types for each subtype/dimension combo
+ * 5. Registers codec-to-type mappings so PostGraphile knows how to handle
+ *    geometry/geography columns
+ *
+ * In v5, type registration is done during the init hook using
+ * build.registerObjectType / build.registerInterfaceType / build.registerScalarType.
+ *
+ * The SQL tweak wraps geometry/geography values in json_build_object() containing
+ * __gisType, __srid, and __geojson fields, which downstream resolvers use.
+ */
+export const PostgisRegisterTypesPlugin = {
+    name: 'PostgisRegisterTypesPlugin',
+    version: '2.0.0',
+    description: 'Registers PostGIS GeoJSON scalar and geometry/geography types',
+    after: ['PostgisExtensionDetectionPlugin', 'PostgisInflectionPlugin'],
+    schema: {
+        hooks: {
+            init(_, build) {
+                const postgisInfo = build.pgGISExtensionInfo;
+                if (!postgisInfo) {
+                    return _;
+                }
+                const { inflection, graphql: { GraphQLInt, GraphQLNonNull, Kind } } = build;
+                const constructedTypes = build.pgGISGraphQLTypesByCodecAndSubtype;
+                if (!constructedTypes) {
+                    return _;
+                }
+                const { geometryCodec, geographyCodec } = postgisInfo;
+                // Register the GeoJSON scalar type
+                build.registerScalarType('GeoJSON', {}, () => ({
+                    description: 'The `GeoJSON` scalar type represents GeoJSON values as specified by ' +
+                        '[RFC 7946](https://tools.ietf.org/html/rfc7946).',
+                    serialize: (value) => value,
+                    parseValue: (value) => {
+                        if (value === null || value === undefined)
+                            return value;
+                        if (typeof value !== 'object' || Array.isArray(value)) {
+                            throw new TypeError('GeoJSON must be an object');
+                        }
+                        const obj = value;
+                        if (typeof obj.type !== 'string') {
+                            throw new TypeError('GeoJSON must have a "type" string property');
+                        }
+                        if (obj.type === 'Feature' || obj.type === 'FeatureCollection') {
+                            throw new TypeError(`GeoJSON type "${obj.type}" is not supported for PostGIS geometry input. Extract the geometry from your Feature first.`);
+                        }
+                        const validTypes = ['Point', 'MultiPoint', 'LineString', 'MultiLineString', 'Polygon', 'MultiPolygon', 'GeometryCollection'];
+                        if (!validTypes.includes(obj.type)) {
+                            throw new TypeError(`GeoJSON type "${obj.type}" is not a recognized GeoJSON type`);
+                        }
+                        return value;
+                    },
+                    parseLiteral(ast, variables) {
+                        return parseLiteralGeoJSON(ast, variables, Kind);
+                    }
+                }), 'PostgisRegisterTypesPlugin registering GeoJSON scalar');
+                // Process geometry and (optionally) geography types
+                const gisCodecs = [geometryCodec, geographyCodec].filter((c) => c !== null);
+                for (const gisCodec of gisCodecs) {
+                    const key = gisCodec.name;
+                    const typeName = gisCodec.name;
+                    if (!constructedTypes[key]) {
+                        constructedTypes[key] = {};
+                    }
+                    // Register the main interface (no dimensional constraint)
+                    const mainInterfaceName = inflection.gisInterfaceName(typeName);
+                    build.registerInterfaceType(mainInterfaceName, {
+                        isPgGISInterface: true,
+                        pgGISCodecName: typeName,
+                        pgGISZMFlag: -1
+                    }, () => ({
+                        description: `All ${typeName} types implement this interface`,
+                        fields: () => {
+                            const geoJsonType = build.getTypeByName('GeoJSON');
+                            if (!geoJsonType) {
+                                throw new Error('PostGIS: GeoJSON scalar type not found.');
+                            }
+                            return {
+                                [inflection.geojsonFieldName()]: {
+                                    type: geoJsonType,
+                                    description: 'Converts the object to GeoJSON'
+                                },
+                                srid: {
+                                    type: new GraphQLNonNull(GraphQLInt),
+                                    description: 'Spatial reference identifier (SRID)'
+                                }
+                            };
+                        },
+                        resolveType(value) {
+                            const gisTypeKey = value.__gisType;
+                            const resolvedTypeName = constructedTypes[key]?.[gisTypeKey];
+                            if (typeof resolvedTypeName === 'string') {
+                                return resolvedTypeName;
+                            }
+                            throw new Error(`PostGIS: Could not resolve type for __gisType="${gisTypeKey}" on codec="${key}". Known types: ${Object.keys(constructedTypes[key] ?? {}).join(', ')}`);
+                        }
+                    }), `PostgisRegisterTypesPlugin registering ${mainInterfaceName} interface`);
+                    // Register dimension interfaces (XY, XYZ, XYM, XYZM)
+                    for (const hasZ of [false, true]) {
+                        for (const hasM of [false, true]) {
+                            const zmflag = (hasZ ? 2 : 0) + (hasM ? 1 : 0);
+                            const coords = { 0: 'XY', 1: 'XYM', 2: 'XYZ', 3: 'XYZM' };
+                            const dimInterfaceName = inflection.gisDimensionInterfaceName(typeName, hasZ, hasM);
+                            build.registerInterfaceType(dimInterfaceName, {
+                                isPgGISDimensionInterface: true,
+                                pgGISCodecName: typeName,
+                                pgGISZMFlag: zmflag
+                            }, () => ({
+                                description: `All ${typeName} ${coords[zmflag]} types implement this interface`,
+                                fields: () => {
+                                    const geoJsonType = build.getTypeByName('GeoJSON');
+                                    if (!geoJsonType) {
+                                        throw new Error('PostGIS: GeoJSON scalar type not found.');
+                                    }
+                                    return {
+                                        [inflection.geojsonFieldName()]: {
+                                            type: geoJsonType,
+                                            description: 'Converts the object to GeoJSON'
+                                        },
+                                        srid: {
+                                            type: new GraphQLNonNull(GraphQLInt),
+                                            description: 'Spatial reference identifier (SRID)'
+                                        }
+                                    };
+                                },
+                                resolveType(value) {
+                                    const gisTypeKey = value.__gisType;
+                                    const concreteTypeName = constructedTypes[key]?.[gisTypeKey];
+                                    if (typeof concreteTypeName === 'string') {
+                                        return concreteTypeName;
+                                    }
+                                    throw new Error(`PostGIS: Could not resolve type for __gisType="${gisTypeKey}" on codec="${key}". Known types: ${Object.keys(constructedTypes[key] ?? {}).join(', ')}`);
+                                }
+                            }), `PostgisRegisterTypesPlugin registering ${dimInterfaceName} interface`);
+                            // Register concrete object types for each subtype + this dimension
+                            for (const subtype of CONCRETE_SUBTYPES) {
+                                const concreteTypeName = inflection.gisType(typeName, subtype, hasZ, hasM, 0);
+                                const typeModifier = getGISTypeModifier(subtype, hasZ, hasM, 0);
+                                const typeDetails = getGISTypeDetails(typeModifier);
+                                build.registerObjectType(concreteTypeName, {
+                                    isPgGISType: true,
+                                    pgGISCodecName: typeName,
+                                    pgGISTypeDetails: typeDetails
+                                }, () => ({
+                                    description: `A PostGIS ${typeName} ${getGISTypeName(subtype, hasZ, hasM)} type`,
+                                    interfaces: () => [
+                                        build.getTypeByName(mainInterfaceName),
+                                        build.getTypeByName(dimInterfaceName)
+                                    ].filter(Boolean),
+                                    fields: () => {
+                                        const geoJsonType = build.getTypeByName('GeoJSON');
+                                        if (!geoJsonType) {
+                                            throw new Error('PostGIS: GeoJSON scalar type not found.');
+                                        }
+                                        return {
+                                            [inflection.geojsonFieldName()]: {
+                                                type: geoJsonType,
+                                                description: 'Converts the object to GeoJSON',
+                                                resolve(data) {
+                                                    return data.__geojson;
+                                                }
+                                            },
+                                            srid: {
+                                                type: new GraphQLNonNull(GraphQLInt),
+                                                description: 'Spatial reference identifier (SRID)',
+                                                resolve(data) {
+                                                    return data.__srid;
+                                                }
+                                            }
+                                        };
+                                    }
+                                }), `PostgisRegisterTypesPlugin registering ${concreteTypeName} type`);
+                                // Track the type by its gisTypeKey for resolveType lookups
+                                const gisTypeKey = getGISTypeName(subtype, hasZ, hasM);
+                                constructedTypes[key][gisTypeKey] = concreteTypeName;
+                            }
+                            // Map the Geometry subtype (0) for this dimension to the dimension interface
+                            const geomDimKey = getGISTypeName(GisSubtype.Geometry, hasZ, hasM);
+                            constructedTypes[key][geomDimKey] = dimInterfaceName;
+                        }
+                    }
+                    // Map null/unspecified modifier to the main interface
+                    constructedTypes[key][-1] = mainInterfaceName;
+                }
+                // Register type mappings so PostGraphile knows what GraphQL types to
+                // use for geometry/geography columns.
+                //
+                // Without BOTH input AND output mappings, PgAttributesPlugin silently
+                // omits geometry columns from the schema:
+                // - Input: GeoJSON scalar (accepts GeoJSON objects)
+                // - Output: The main interface type (e.g. GeometryInterface), which uses
+                //   resolveType to dispatch to concrete types (GeometryPoint, etc.)
+                const { setGraphQLTypeForPgCodec } = build;
+                if (typeof setGraphQLTypeForPgCodec === 'function') {
+                    for (const gisCodec of gisCodecs) {
+                        const mainInterfaceName = inflection.gisInterfaceName(gisCodec.name);
+                        setGraphQLTypeForPgCodec(gisCodec, 'input', 'GeoJSON');
+                        setGraphQLTypeForPgCodec(gisCodec, 'output', mainInterfaceName);
+                    }
+                }
+                return _;
+            },
+            build(build) {
+                const postgisInfo = build.pgGISExtensionInfo;
+                if (!postgisInfo) {
+                    return build;
+                }
+                const { schemaName } = postgisInfo;
+                const constructedTypes = build.pgGISGraphQLTypesByCodecAndSubtype;
+                if (!constructedTypes) {
+                    return build;
+                }
+                return build.extend(build, {
+                    getPostgisTypeByGeometryType(gisCodecName, subtype, hasZ = false, hasM = false, _srid = 0) {
+                        const gisTypeKey = getGISTypeName(subtype, hasZ, hasM);
+                        const resolvedTypeName = constructedTypes[gisCodecName]?.[gisTypeKey];
+                        if (typeof resolvedTypeName === 'string') {
+                            return build.getTypeByName(resolvedTypeName);
+                        }
+                        return undefined;
+                    },
+                    pgGISWrapExpression(fragment) {
+                        // PostGIS function names MUST be lowercase for PostgreSQL identifier matching
+                        const params = [
+                            sql.literal('__gisType'),
+                            sql.fragment `${sql.identifier(schemaName, 'geometrytype')}(${fragment})`,
+                            sql.literal('__srid'),
+                            sql.fragment `${sql.identifier(schemaName, 'st_srid')}(${fragment})`,
+                            sql.literal('__geojson'),
+                            sql.fragment `${sql.identifier(schemaName, 'st_asgeojson')}(${fragment})::JSON`
+                        ];
+                        return sql.fragment `(case when ${fragment} is null then null else json_build_object(
+              ${sql.join(params, ', ')}
+            ) end)`;
+                    },
+                    pgGISFromGeoJSON(value, codecName) {
+                        const jsonStr = sql.value(JSON.stringify(value));
+                        if (codecName === 'geography') {
+                            return sql.fragment `${sql.identifier(schemaName, 'st_geomfromgeojson')}(${jsonStr}::text)::${sql.identifier(schemaName, 'geography')}`;
+                        }
+                        return sql.fragment `${sql.identifier(schemaName, 'st_geomfromgeojson')}(${jsonStr}::text)`;
+                    }
+                }, 'PostgisRegisterTypesPlugin adding PostGIS helpers to build');
+            },
+            // Add all registered PostGIS concrete types to the schema so they are
+            // discoverable for resolveType on the interfaces. Types registered via
+            // build.registerObjectType() during init are lazy — they are only
+            // materialized when getTypeByName() is called.
+            //
+            // We MUST use GraphQLSchema_types (not GraphQLSchema) because the
+            // GraphQLSchema hook's types property gets overwritten by the
+            // GraphQLSchema_types hook that runs immediately after it.
+            GraphQLSchema_types(types, build) {
+                const constructedTypes = build.pgGISGraphQLTypesByCodecAndSubtype;
+                if (!constructedTypes) {
+                    return types;
+                }
+                for (const codecTypes of Object.values(constructedTypes)) {
+                    for (const typeName of Object.values(codecTypes)) {
+                        if (typeof typeName === 'string') {
+                            const graphqlType = build.getTypeByName(typeName);
+                            if (graphqlType && !types.includes(graphqlType)) {
+                                types.push(graphqlType);
+                            }
+                        }
+                    }
+                }
+                return types;
+            }
+        }
+    }
+};
+/**
+ * Recursively parses a GeoJSON literal from a GraphQL AST.
+ */
+function parseLiteralGeoJSON(ast, variables, Kind, depth = 0) {
+    if (depth > 32) {
+        throw new Error('GeoJSON input exceeds maximum nesting depth');
+    }
+    switch (ast.kind) {
+        case Kind.STRING:
+        case Kind.BOOLEAN:
+            return ast.value;
+        case Kind.INT:
+        case Kind.FLOAT:
+            return parseFloat(ast.value);
+        case Kind.OBJECT: {
+            const value = Object.create(null);
+            ast.fields.forEach((field) => {
+                value[field.name.value] = parseLiteralGeoJSON(field.value, variables, Kind, depth + 1);
+            });
+            return value;
+        }
+        case Kind.LIST:
+            return ast.values.map((n) => parseLiteralGeoJSON(n, variables, Kind, depth + 1));
+        case Kind.NULL:
+            return null;
+        case Kind.VARIABLE: {
+            const variableName = ast.name.value;
+            return variables ? variables[variableName] : undefined;
+        }
+        default:
+            return undefined;
+    }
+}

package/esm/preset.d.ts

@@ -0,0 +1,18 @@
+import type { GraphileConfig } from 'graphile-config';
+/**
+ * GraphilePostgisPreset
+ *
+ * A preset that includes all PostGIS plugins for PostGraphile v5.
+ * Use this as the recommended way to add PostGIS support.
+ *
+ * @example
+ * ```typescript
+ * import { GraphilePostgisPreset } from 'graphile-postgis';
+ *
+ * const preset = {
+ *   extends: [GraphilePostgisPreset]
+ * };
+ * ```
+ */
+export declare const GraphilePostgisPreset: GraphileConfig.Preset;
+export default GraphilePostgisPreset;