graphile-postgis 0.1.0 → 0.1.2

package/LICENSE

@@ -1,6 +1,8 @@
 The MIT License (MIT)
 
-Copyright (c) 2020 Dan Lynch <pyramation@gmail.com>
+Copyright (c) 2025 Dan Lynch <pyramation@gmail.com>
+Copyright (c) 2025 Hyperweb <developers@hyperweb.io>
+Copyright (c) 2020-present, Interweb, Inc.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/PostgisExtensionDetectionPlugin.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from 'graphile-build';
+declare const PostgisExtensionDetectionPlugin: Plugin;
+export default PostgisExtensionDetectionPlugin;

package/PostgisExtensionDetectionPlugin.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const PostgisExtensionDetectionPlugin = (builder) => {
+    builder.hook('build', (build) => {
+        const postgisBuild = build;
+        const { pgIntrospectionResultsByKind: introspectionResultsByKind } = postgisBuild;
+        const pgGISExtension = introspectionResultsByKind.extension.find((extension) => extension.name === 'postgis');
+        // Check we have the postgis extension
+        if (!pgGISExtension) {
+            console.warn('PostGIS extension not found in database; skipping');
+            return postgisBuild;
+        }
+        // Extract the geography and geometry types
+        const pgGISGeometryType = introspectionResultsByKind.type.find((type) => type.name === 'geometry' && type.namespaceId === pgGISExtension.namespaceId);
+        const pgGISGeographyType = introspectionResultsByKind.type.find((type) => type.name === 'geography' && type.namespaceId === pgGISExtension.namespaceId);
+        if (!pgGISGeographyType || !pgGISGeometryType) {
+            throw new Error("PostGIS is installed, but we couldn't find the geometry/geography types!");
+        }
+        return postgisBuild.extend(postgisBuild, {
+            pgGISGraphQLTypesByTypeAndSubtype: {},
+            pgGISGraphQLInterfaceTypesByType: {},
+            pgGISGeometryType,
+            pgGISGeographyType,
+            pgGISExtension
+        });
+    });
+};
+exports.default = PostgisExtensionDetectionPlugin;

package/PostgisInflectionPlugin.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from 'graphile-build';
+declare const PostgisInflectionPlugin: Plugin;
+export default PostgisInflectionPlugin;

package/PostgisInflectionPlugin.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("./constants");
+const PostgisInflectionPlugin = (builder) => {
+    builder.hook('inflection', (inflection) => {
+        return {
+            ...inflection,
+            gisType(type, subtype, hasZ, hasM, _srid) {
+                return this.upperCamelCase([type.name, constants_1.SUBTYPE_STRING_BY_SUBTYPE[subtype], hasZ ? 'z' : null, hasM ? 'm' : null]
+                    .filter(Boolean)
+                    .join('-'));
+            },
+            gisInterfaceName(type) {
+                return this.upperCamelCase(`${type.name}-interface`);
+            },
+            gisDimensionInterfaceName(type, hasZ, hasM) {
+                return this.upperCamelCase([type.name, constants_1.SUBTYPE_STRING_BY_SUBTYPE[constants_1.GisSubtype.Geometry], hasZ ? 'z' : null, hasM ? 'm' : null]
+                    .filter(Boolean)
+                    .join('-'));
+            },
+            geojsonFieldName() {
+                return 'geojson';
+            },
+            gisXFieldName(_type) {
+                return _type.name === 'geography' ? 'longitude' : 'x';
+            },
+            gisYFieldName(_type) {
+                return _type.name === 'geography' ? 'latitude' : 'y';
+            },
+            gisZFieldName(_type) {
+                return _type.name === 'geography' ? 'height' : 'z';
+            }
+        };
+    });
+};
+exports.default = PostgisInflectionPlugin;

package/PostgisRegisterTypesPlugin.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from 'graphile-build';
+declare const PostgisRegisterTypesPlugin: Plugin;
+export default PostgisRegisterTypesPlugin;

package/PostgisRegisterTypesPlugin.js

@@ -0,0 +1,232 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("./constants");
+const makeGeoJSONType_1 = __importDefault(require("./makeGeoJSONType"));
+const utils_1 = require("./utils");
+const SUBTYPES = [
+    constants_1.GisSubtype.Point,
+    constants_1.GisSubtype.LineString,
+    constants_1.GisSubtype.Polygon,
+    constants_1.GisSubtype.MultiPoint,
+    constants_1.GisSubtype.MultiLineString,
+    constants_1.GisSubtype.MultiPolygon,
+    constants_1.GisSubtype.GeometryCollection
+];
+const identity = (input) => input;
+const PostgisRegisterTypesPlugin = (builder) => {
+    builder.hook('build', (build) => {
+        const rawBuild = build;
+        const GeoJSON = (0, makeGeoJSONType_1.default)(rawBuild.graphql, rawBuild.inflection.builtin('GeoJSON'));
+        rawBuild.addType(GeoJSON);
+        return rawBuild.extend(rawBuild, {
+            getPostgisTypeByGeometryType(pgGISType, subtype, hasZ = false, hasM = false, srid = 0) {
+                const typeModifier = (0, utils_1.getGISTypeModifier)(subtype, hasZ, hasM, srid);
+                return this.pgGetGqlTypeByTypeIdAndModifier(pgGISType.id, typeModifier);
+            },
+            pgGISIncludedTypes: [],
+            pgGISIncludeType(Type) {
+                this.pgGISIncludedTypes.push(Type);
+            }
+        });
+    });
+    builder.hook('init', (input, build) => {
+        const rawBuild = build;
+        const { newWithHooks, pgIntrospectionResultsByKind: introspectionResultsByKind, graphql: { GraphQLInt, GraphQLNonNull, GraphQLInterfaceType, GraphQLObjectType }, pgRegisterGqlTypeByTypeId, pgRegisterGqlInputTypeByTypeId, pgTweaksByTypeIdAndModifer, getTypeByName, pgSql: sql, pg2gql, pg2GqlMapper, inflection, pgGISGraphQLTypesByTypeAndSubtype: constructedTypes, pgGISGraphQLInterfaceTypesByType: interfacesMap, pgGISGeometryType: GEOMETRY_TYPE, pgGISGeographyType: GEOGRAPHY_TYPE, pgGISExtension: POSTGIS, pgGISIncludeType: includeType } = rawBuild;
+        if (!GEOMETRY_TYPE || !GEOGRAPHY_TYPE) {
+            return input;
+        }
+        console.warn('PostGIS plugin enabled');
+        const GeoJSON = getTypeByName(inflection.builtin('GeoJSON'));
+        if (!GeoJSON) {
+            throw new Error('GeoJSON type was not registered on the build');
+        }
+        const geojsonFieldName = inflection.geojsonFieldName();
+        const ensureInterfaceStore = (type) => {
+            if (!interfacesMap[type.id]) {
+                interfacesMap[type.id] = {};
+            }
+        };
+        const getGisInterface = (type) => {
+            const zmflag = -1; // no dimensional constraint; could be xy/xyz/xym/xyzm
+            ensureInterfaceStore(type);
+            if (!interfacesMap[type.id][zmflag]) {
+                interfacesMap[type.id][zmflag] = newWithHooks(GraphQLInterfaceType, {
+                    name: inflection.gisInterfaceName(type),
+                    fields: {
+                        [geojsonFieldName]: {
+                            type: GeoJSON,
+                            description: 'Converts the object to GeoJSON'
+                        },
+                        srid: {
+                            type: new GraphQLNonNull(GraphQLInt),
+                            description: 'Spatial reference identifier (SRID)'
+                        }
+                    },
+                    resolveType(value) {
+                        const Type = constructedTypes[type.id]?.[value.__gisType];
+                        return Type instanceof GraphQLObjectType ? Type : undefined;
+                    },
+                    description: `All ${type.name} types implement this interface`
+                }, {
+                    isPgGISInterface: true,
+                    pgGISType: type,
+                    pgGISZMFlag: zmflag
+                });
+                for (const subtype of SUBTYPES) {
+                    for (const hasZ of [false, true]) {
+                        for (const hasM of [false, true]) {
+                            const typeModifier = (0, utils_1.getGISTypeModifier)(subtype, hasZ, hasM, 0);
+                            const Type = getGisType(type, typeModifier);
+                            includeType(Type);
+                        }
+                    }
+                }
+            }
+            return interfacesMap[type.id][zmflag];
+        };
+        const getGisDimensionInterface = (type, hasZ, hasM) => {
+            const zmflag = (hasZ ? 2 : 0) + (hasM ? 1 : 0); // Equivalent to ST_Zmflag: https://postgis.net/docs/ST_Zmflag.html
+            const coords = { 0: 'XY', 1: 'XYM', 2: 'XYZ', 3: 'XYZM' };
+            ensureInterfaceStore(type);
+            if (!interfacesMap[type.id][zmflag]) {
+                interfacesMap[type.id][zmflag] = newWithHooks(GraphQLInterfaceType, {
+                    name: inflection.gisDimensionInterfaceName(type, hasZ, hasM),
+                    fields: {
+                        [geojsonFieldName]: {
+                            type: GeoJSON,
+                            description: 'Converts the object to GeoJSON'
+                        },
+                        srid: {
+                            type: new GraphQLNonNull(GraphQLInt),
+                            description: 'Spatial reference identifier (SRID)'
+                        }
+                    },
+                    resolveType(value) {
+                        const Type = constructedTypes[type.id]?.[value.__gisType];
+                        return Type instanceof GraphQLObjectType ? Type : undefined;
+                    },
+                    description: `All ${type.name} ${coords[zmflag]} types implement this interface`
+                }, {
+                    isPgGISDimensionInterface: true,
+                    pgGISType: type,
+                    pgGISZMFlag: zmflag
+                });
+                for (const subtype of SUBTYPES) {
+                    const typeModifier = (0, utils_1.getGISTypeModifier)(subtype, hasZ, hasM, 0);
+                    const Type = getGisType(type, typeModifier);
+                    includeType(Type);
+                }
+            }
+            return interfacesMap[type.id][zmflag];
+        };
+        const getGisType = (type, typeModifier) => {
+            const typeId = type.id;
+            const typeDetails = (0, utils_1.getGISTypeDetails)(typeModifier);
+            const { subtype, hasZ, hasM, srid } = typeDetails;
+            console.warn(`Getting ${type.name} type ${type.id}|${typeModifier}|${subtype}|${hasZ}|${hasM}|${srid}`);
+            if (!constructedTypes[typeId]) {
+                constructedTypes[typeId] = {};
+            }
+            const typeModifierKey = typeModifier ?? -1;
+            if (!pgTweaksByTypeIdAndModifer[typeId]) {
+                pgTweaksByTypeIdAndModifer[typeId] = {};
+            }
+            if (!pgTweaksByTypeIdAndModifer[typeId][typeModifierKey]) {
+                pgTweaksByTypeIdAndModifer[typeId][typeModifierKey] = (fragment) => {
+                    const params = [
+                        sql.literal('__gisType'),
+                        sql.fragment `${sql.identifier(POSTGIS?.namespaceName || 'public', 'postgis_type_name' // MUST be lowercase!
+                        )}(
+                ${sql.identifier(POSTGIS?.namespaceName || 'public', 'geometrytype' // MUST be lowercase!
+                        )}(${fragment}),
+                ${sql.identifier(POSTGIS?.namespaceName || 'public', 'st_coorddim' // MUST be lowercase!
+                        )}(${fragment}::text)
+              )`,
+                        sql.literal('__srid'),
+                        sql.fragment `${sql.identifier(POSTGIS?.namespaceName || 'public', 'st_srid' // MUST be lowercase!
+                        )}(${fragment})`,
+                        sql.literal('__geojson'),
+                        sql.fragment `${sql.identifier(POSTGIS?.namespaceName || 'public', 'st_asgeojson' // MUST be lowercase!
+                        )}(${fragment})::JSON`
+                    ];
+                    return sql.fragment `(case when ${fragment} is null then null else json_build_object(
+            ${sql.join(params, ', ')}
+          ) end)`;
+                };
+            }
+            const gisTypeKey = typeModifier != null ? (0, utils_1.getGISTypeName)(subtype, hasZ, hasM) : -1;
+            if (!constructedTypes[typeId][gisTypeKey]) {
+                if (typeModifierKey === -1) {
+                    constructedTypes[typeId][gisTypeKey] = getGisInterface(type);
+                }
+                else if (subtype === constants_1.GisSubtype.Geometry) {
+                    constructedTypes[typeId][gisTypeKey] = getGisDimensionInterface(type, hasZ, hasM);
+                }
+                else {
+                    const intType = introspectionResultsByKind.type.find((introspectionType) => introspectionType.name === 'int4' && introspectionType.namespaceName === 'pg_catalog');
+                    const jsonType = introspectionResultsByKind.type.find((introspectionType) => introspectionType.name === 'json' && introspectionType.namespaceName === 'pg_catalog');
+                    if (!intType || !jsonType) {
+                        throw new Error('Unable to locate built-in int4/json types');
+                    }
+                    constructedTypes[typeId][gisTypeKey] = newWithHooks(GraphQLObjectType, {
+                        name: inflection.gisType(type, subtype, hasZ, hasM, srid),
+                        interfaces: () => [
+                            getGisInterface(type),
+                            getGisDimensionInterface(type, hasZ, hasM)
+                        ],
+                        fields: {
+                            [geojsonFieldName]: {
+                                type: GeoJSON,
+                                resolve: (data) => {
+                                    return pg2gql(data.__geojson, jsonType);
+                                }
+                            },
+                            srid: {
+                                type: new GraphQLNonNull(GraphQLInt),
+                                resolve: (data) => {
+                                    return pg2gql(data.__srid, intType);
+                                }
+                            }
+                        }
+                    }, {
+                        isPgGISType: true,
+                        pgGISType: type,
+                        pgGISTypeDetails: typeDetails
+                    });
+                }
+            }
+            return constructedTypes[typeId][gisTypeKey];
+        };
+        console.warn(`Registering handler for ${GEOGRAPHY_TYPE.id}`);
+        pgRegisterGqlInputTypeByTypeId(GEOGRAPHY_TYPE.id, () => GeoJSON);
+        pg2GqlMapper[GEOGRAPHY_TYPE.id] = {
+            map: identity,
+            unmap: (o) => sql.fragment `st_geomfromgeojson(${sql.value(JSON.stringify(o))}::text)::${sql.identifier(POSTGIS?.namespaceName || 'public', 'geography')}`
+        };
+        pgRegisterGqlTypeByTypeId(GEOGRAPHY_TYPE.id, (_set, typeModifier) => {
+            return getGisType(GEOGRAPHY_TYPE, typeModifier);
+        });
+        console.warn(`Registering handler for ${GEOMETRY_TYPE.id}`);
+        pgRegisterGqlInputTypeByTypeId(GEOMETRY_TYPE.id, () => GeoJSON);
+        pg2GqlMapper[GEOMETRY_TYPE.id] = {
+            map: identity,
+            unmap: (o) => sql.fragment `st_geomfromgeojson(${sql.value(JSON.stringify(o))}::text)`
+        };
+        pgRegisterGqlTypeByTypeId(GEOMETRY_TYPE.id, (_set, typeModifier) => {
+            return getGisType(GEOMETRY_TYPE, typeModifier);
+        });
+        return input;
+    }, ['PostgisTypes'], ['PgTables'], ['PgTypes']);
+    builder.hook('GraphQLSchema', (schemaConfig, build) => {
+        const postgisBuild = build;
+        const existingTypes = schemaConfig.types ?? [];
+        return {
+            ...schemaConfig,
+            types: [...existingTypes, ...postgisBuild.pgGISIncludedTypes]
+        };
+    });
+};
+exports.default = PostgisRegisterTypesPlugin;

package/PostgisVersionPlugin.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from 'graphile-build';
+declare const plugin: Plugin;
+export default plugin;

package/PostgisVersionPlugin.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const plugin = (builder) => {
+    builder.hook('build', (build) => {
+        const pkg = require('../package.json');
+        // Check dependencies
+        if (!build.versions) {
+            throw new Error(`Plugin ${pkg.name}@${pkg.version} requires graphile-build@^4.1.0 in order to check dependencies (current version: ${build.graphileBuildVersion})`);
+        }
+        const depends = (name, range) => {
+            if (!build.hasVersion(name, range)) {
+                throw new Error(`Plugin ${pkg.name}@${pkg.version} requires ${name}@${range} (${build.versions[name]
+                    ? `current version: ${build.versions[name]}`
+                    : 'not found'})`);
+            }
+        };
+        depends('graphile-build-pg', '^4.4.0');
+        // Register this plugin
+        build.versions = build.extend(build.versions, { [pkg.name]: pkg.version });
+        return build;
+    });
+};
+exports.default = plugin;

package/Postgis_GeometryCollection_GeometriesPlugin.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from 'graphile-build';
+declare const PostgisGeometryCollectionGeometriesPlugin: Plugin;
+export default PostgisGeometryCollectionGeometriesPlugin;

package/Postgis_GeometryCollection_GeometriesPlugin.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("./constants");
+const utils_1 = require("./utils");
+const PostgisGeometryCollectionGeometriesPlugin = (builder) => {
+    builder.hook('GraphQLObjectType:fields', function AddGeometriesToGeometryCollection(fields, build, context) {
+        const { scope: { isPgGISType, pgGISType, pgGISTypeDetails } } = context;
+        if (!isPgGISType ||
+            !pgGISType ||
+            !pgGISTypeDetails ||
+            pgGISTypeDetails.subtype !== constants_1.GisSubtype.GeometryCollection) {
+            return fields;
+        }
+        const { extend, pgGISGraphQLInterfaceTypesByType, graphql: { GraphQLList } } = build;
+        const { hasZ, hasM } = pgGISTypeDetails;
+        const zmflag = (hasZ ? 2 : 0) + (hasM ? 1 : 0); // Equivalent to ST_Zmflag: https://postgis.net/docs/ST_Zmflag.html
+        const Interface = pgGISGraphQLInterfaceTypesByType[pgGISType.id][zmflag];
+        if (!Interface) {
+            console.warn("Unexpectedly couldn't find the interface");
+            return fields;
+        }
+        return extend(fields, {
+            geometries: {
+                type: new GraphQLList(Interface),
+                resolve(data) {
+                    const geometryCollection = data.__geojson;
+                    return geometryCollection.geometries.map((geom) => {
+                        const subtype = constants_1.GisSubtype[geom.type];
+                        if (subtype === undefined) {
+                            throw new Error(`Unsupported geometry subtype ${geom.type}`);
+                        }
+                        return {
+                            __gisType: (0, utils_1.getGISTypeName)(subtype, hasZ, hasM),
+                            __srid: data.__srid,
+                            __geojson: geom
+                        };
+                    });
+                }
+            }
+        });
+    });
+};
+exports.default = PostgisGeometryCollectionGeometriesPlugin;

package/Postgis_LineString_PointsPlugin.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from 'graphile-build';
+declare const PostgisLineStringPointsPlugin: Plugin;
+export default PostgisLineStringPointsPlugin;

package/Postgis_LineString_PointsPlugin.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("./constants");
+const utils_1 = require("./utils");
+const PostgisLineStringPointsPlugin = (builder) => {
+    builder.hook('GraphQLObjectType:fields', (fields, build, context) => {
+        const { scope: { isPgGISType, pgGISType, pgGISTypeDetails } } = context;
+        if (!isPgGISType ||
+            !pgGISType ||
+            !pgGISTypeDetails ||
+            pgGISTypeDetails.subtype !== constants_1.GisSubtype.LineString) {
+            return fields;
+        }
+        const { extend, getPostgisTypeByGeometryType, graphql: { GraphQLList } } = build;
+        const { hasZ, hasM, srid } = pgGISTypeDetails;
+        const Point = getPostgisTypeByGeometryType(pgGISType, constants_1.GisSubtype.Point, hasZ, hasM, srid);
+        if (!Point) {
+            return fields;
+        }
+        return extend(fields, {
+            points: {
+                type: new GraphQLList(Point),
+                resolve(data) {
+                    const lineString = data.__geojson;
+                    return lineString.coordinates.map((coord) => {
+                        return {
+                            __gisType: (0, utils_1.getGISTypeName)(constants_1.GisSubtype.Point, hasZ, hasM),
+                            __srid: data.__srid,
+                            __geojson: {
+                                type: 'Point',
+                                coordinates: coord
+                            }
+                        };
+                    });
+                }
+            }
+        });
+    });
+};
+exports.default = PostgisLineStringPointsPlugin;

package/Postgis_MultiLineString_LineStringsPlugin.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from 'graphile-build';
+declare const PostgisMultiLineStringLineStringsPlugin: Plugin;
+export default PostgisMultiLineStringLineStringsPlugin;

package/Postgis_MultiLineString_LineStringsPlugin.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("./constants");
+const utils_1 = require("./utils");
+const PostgisMultiLineStringLineStringsPlugin = (builder) => {
+    builder.hook('GraphQLObjectType:fields', (fields, build, context) => {
+        const { scope: { isPgGISType, pgGISType, pgGISTypeDetails } } = context;
+        if (!isPgGISType ||
+            !pgGISType ||
+            !pgGISTypeDetails ||
+            pgGISTypeDetails.subtype !== constants_1.GisSubtype.MultiLineString) {
+            return fields;
+        }
+        const { extend, getPostgisTypeByGeometryType, graphql: { GraphQLList } } = build;
+        const { hasZ, hasM, srid } = pgGISTypeDetails;
+        const LineString = getPostgisTypeByGeometryType(pgGISType, constants_1.GisSubtype.LineString, hasZ, hasM, srid);
+        if (!LineString) {
+            return fields;
+        }
+        return extend(fields, {
+            lines: {
+                type: new GraphQLList(LineString),
+                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
+                        }
+                    }));
+                }
+            }
+        });
+    });
+};
+exports.default = PostgisMultiLineStringLineStringsPlugin;

package/Postgis_MultiPoint_PointsPlugin.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from 'graphile-build';
+declare const PostgisMultiPointPointsPlugin: Plugin;
+export default PostgisMultiPointPointsPlugin;

package/Postgis_MultiPoint_PointsPlugin.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("./constants");
+const utils_1 = require("./utils");
+const PostgisMultiPointPointsPlugin = (builder) => {
+    builder.hook('GraphQLObjectType:fields', (fields, build, context) => {
+        const { scope: { isPgGISType, pgGISType, pgGISTypeDetails } } = context;
+        if (!isPgGISType ||
+            !pgGISType ||
+            !pgGISTypeDetails ||
+            pgGISTypeDetails.subtype !== constants_1.GisSubtype.MultiPoint) {
+            return fields;
+        }
+        const { extend, getPostgisTypeByGeometryType, graphql: { GraphQLList } } = build;
+        const { hasZ, hasM, srid } = pgGISTypeDetails;
+        const Point = getPostgisTypeByGeometryType(pgGISType, constants_1.GisSubtype.Point, hasZ, hasM, srid);
+        if (!Point) {
+            return fields;
+        }
+        return extend(fields, {
+            points: {
+                type: new GraphQLList(Point),
+                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
+                        }
+                    }));
+                }
+            }
+        });
+    });
+};
+exports.default = PostgisMultiPointPointsPlugin;

package/Postgis_MultiPolygon_PolygonsPlugin.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from 'graphile-build';
+declare const PostgisMultiPolygonPolygonsPlugin: Plugin;
+export default PostgisMultiPolygonPolygonsPlugin;

package/Postgis_MultiPolygon_PolygonsPlugin.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("./constants");
+const utils_1 = require("./utils");
+const PostgisMultiPolygonPolygonsPlugin = (builder) => {
+    builder.hook('GraphQLObjectType:fields', (fields, build, context) => {
+        const { scope: { isPgGISType, pgGISType, pgGISTypeDetails } } = context;
+        if (!isPgGISType ||
+            !pgGISType ||
+            !pgGISTypeDetails ||
+            pgGISTypeDetails.subtype !== constants_1.GisSubtype.MultiPolygon) {
+            return fields;
+        }
+        const { extend, getPostgisTypeByGeometryType, graphql: { GraphQLList } } = build;
+        const { hasZ, hasM, srid } = pgGISTypeDetails;
+        const PolygonType = getPostgisTypeByGeometryType(pgGISType, constants_1.GisSubtype.Polygon, hasZ, hasM, srid);
+        if (!PolygonType) {
+            return fields;
+        }
+        return 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
+                        }
+                    }));
+                }
+            }
+        });
+    });
+};
+exports.default = PostgisMultiPolygonPolygonsPlugin;

package/Postgis_Point_LatitudeLongitudePlugin.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from 'graphile-build';
+declare const PostgisPointLatitudeLongitudePlugin: Plugin;
+export default PostgisPointLatitudeLongitudePlugin;

package/Postgis_Point_LatitudeLongitudePlugin.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("./constants");
+const PostgisPointLatitudeLongitudePlugin = (builder) => {
+    builder.hook('GraphQLObjectType:fields', (fields, build, context) => {
+        const { scope: { isPgGISType, pgGISType, pgGISTypeDetails } } = context;
+        if (!isPgGISType || !pgGISType || !pgGISTypeDetails || pgGISTypeDetails.subtype !== constants_1.GisSubtype.Point) {
+            return fields;
+        }
+        const { extend, graphql: { GraphQLNonNull, GraphQLFloat }, inflection } = build;
+        const xFieldName = inflection.gisXFieldName(pgGISType);
+        const yFieldName = inflection.gisYFieldName(pgGISType);
+        const zFieldName = inflection.gisZFieldName(pgGISType);
+        return extend(fields, {
+            [xFieldName]: {
+                type: new GraphQLNonNull(GraphQLFloat),
+                resolve(data) {
+                    const point = data.__geojson;
+                    return point.coordinates[0];
+                }
+            },
+            [yFieldName]: {
+                type: new GraphQLNonNull(GraphQLFloat),
+                resolve(data) {
+                    const point = data.__geojson;
+                    return point.coordinates[1];
+                }
+            },
+            ...(pgGISTypeDetails.hasZ
+                ? {
+                    [zFieldName]: {
+                        type: new GraphQLNonNull(GraphQLFloat),
+                        resolve(data) {
+                            const point = data.__geojson;
+                            return point.coordinates[2];
+                        }
+                    }
+                }
+                : {})
+        });
+    });
+};
+exports.default = PostgisPointLatitudeLongitudePlugin;

package/Postgis_Polygon_RingsPlugin.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from 'graphile-build';
+declare const PostgisPolygonRingsPlugin: Plugin;
+export default PostgisPolygonRingsPlugin;