graphile-postgis 1.1.1 → 2.2.0

package/plugins/detect-extension.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostgisExtensionDetectionPlugin = void 0;
+require("graphile-build");
+require("graphile-build-pg");
+/**
+ * PostgisExtensionDetectionPlugin
+ *
+ * Detects PostGIS presence in the database by searching for geometry/geography
+ * codecs in the pgRegistry. Stores detected info on the build object for
+ * downstream plugins.
+ *
+ * Gracefully degrades if PostGIS is not installed.
+ */
+exports.PostgisExtensionDetectionPlugin = {
+    name: 'PostgisExtensionDetectionPlugin',
+    version: '2.0.0',
+    description: 'Detects PostGIS extension in the database',
+    schema: {
+        hooks: {
+            build(build) {
+                const pgRegistry = build.input?.pgRegistry;
+                if (!pgRegistry) {
+                    return build;
+                }
+                let geometryCodec = null;
+                let geographyCodec = null;
+                let schemaName = 'public';
+                // Search through codecs for geometry and geography types
+                for (const codec of Object.values(pgRegistry.pgCodecs)) {
+                    const pg = codec?.extensions?.pg;
+                    if (!pg)
+                        continue;
+                    if (pg.name === 'geometry') {
+                        geometryCodec = codec;
+                        schemaName = pg.schemaName || 'public';
+                    }
+                    else if (pg.name === 'geography') {
+                        geographyCodec = codec;
+                    }
+                }
+                // PostGIS requires at least the geometry codec to be present.
+                // Geography is optional — not all databases use geography columns,
+                // so PostGraphile may not introspect the geography type at all.
+                if (!geometryCodec) {
+                    return build;
+                }
+                const postgisInfo = {
+                    schemaName,
+                    geometryCodec,
+                    geographyCodec
+                };
+                return build.extend(build, {
+                    pgGISExtensionInfo: postgisInfo,
+                    pgGISGraphQLTypesByCodecAndSubtype: {}
+                }, 'PostgisExtensionDetectionPlugin adding PostGIS build state');
+            }
+        }
+    }
+};

package/plugins/geometry-fields.d.ts

@@ -0,0 +1,21 @@
+import 'graphile-build';
+import 'graphile-build-pg';
+import type { GraphileConfig } from 'graphile-config';
+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 declare const PostgisGeometryFieldsPlugin: GraphileConfig.Plugin;

package/plugins/geometry-fields.js

@@ -0,0 +1,248 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostgisGeometryFieldsPlugin = void 0;
+require("graphile-build");
+require("graphile-build-pg");
+const constants_1 = require("../constants");
+const utils_1 = require("../utils");
+// Import types.ts for Build/Inflection/Scope augmentation side effects
+require("../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).
+ */
+exports.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 constants_1.GisSubtype.Point:
+                        return addPointFields(fields, build, pgGISCodecName, hasZ, GraphQLNonNull, GraphQLFloat, inflection);
+                    case constants_1.GisSubtype.LineString:
+                        return addLineStringFields(fields, build, pgGISCodecName, hasZ, hasM, srid, GraphQLList, getType);
+                    case constants_1.GisSubtype.Polygon:
+                        return addPolygonFields(fields, build, pgGISCodecName, hasZ, hasM, srid, GraphQLList, getType);
+                    case constants_1.GisSubtype.MultiPoint:
+                        return addMultiPointFields(fields, build, pgGISCodecName, hasZ, hasM, srid, GraphQLList, getType);
+                    case constants_1.GisSubtype.MultiLineString:
+                        return addMultiLineStringFields(fields, build, pgGISCodecName, hasZ, hasM, srid, GraphQLList, getType);
+                    case constants_1.GisSubtype.MultiPolygon:
+                        return addMultiPolygonFields(fields, build, pgGISCodecName, hasZ, hasM, srid, GraphQLList, getType);
+                    case constants_1.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, constants_1.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: (0, utils_1.getGISTypeName)(constants_1.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, constants_1.GisSubtype.LineString, hasZ, hasM, srid);
+    if (!LineStringType)
+        return fields;
+    return build.extend(fields, {
+        exterior: {
+            type: LineStringType,
+            resolve(data) {
+                const polygon = data.__geojson;
+                return {
+                    __gisType: (0, utils_1.getGISTypeName)(constants_1.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: (0, utils_1.getGISTypeName)(constants_1.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, constants_1.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: (0, utils_1.getGISTypeName)(constants_1.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, constants_1.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: (0, utils_1.getGISTypeName)(constants_1.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, constants_1.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: (0, utils_1.getGISTypeName)(constants_1.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 = constants_1.GisSubtype[geom.type];
+                    if (subtypeValue === undefined) {
+                        throw new Error(`Unsupported geometry subtype ${geom.type}`);
+                    }
+                    return {
+                        __gisType: (0, utils_1.getGISTypeName)(subtypeValue, hasZ, hasM),
+                        __srid: data.__srid,
+                        __geojson: geom
+                    };
+                });
+            }
+        }
+    }, 'PostgisGeometryFieldsPlugin adding GeometryCollection fields');
+}

package/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/plugins/inflection.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostgisInflectionPlugin = void 0;
+const constants_1 = require("../constants");
+// Import types.ts for the Inflection augmentation side effects
+require("../types");
+/**
+ * PostgisInflectionPlugin
+ *
+ * Adds inflection methods for generating PostGIS-related GraphQL type names.
+ */
+exports.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,
+                    constants_1.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,
+                    constants_1.SUBTYPE_STRING_BY_SUBTYPE[constants_1.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/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;