graphile-postgis 1.1.1 → 2.2.0

package/PostgisRegisterTypesPlugin.d.ts

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

package/PostgisRegisterTypesPlugin.js

@@ -1,234 +0,0 @@
-"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

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

package/PostgisVersionPlugin.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const find_and_require_package_json_1 = require("find-and-require-package-json");
-const pkg = (0, find_and_require_package_json_1.findAndRequirePackageJson)(__dirname);
-const plugin = (builder) => {
-    builder.hook('build', (build) => {
-        // 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

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

package/Postgis_GeometryCollection_GeometriesPlugin.js

@@ -1,43 +0,0 @@
-"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

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

package/Postgis_LineString_PointsPlugin.js

@@ -1,40 +0,0 @@
-"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

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

package/Postgis_MultiLineString_LineStringsPlugin.js

@@ -1,38 +0,0 @@
-"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

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

package/Postgis_MultiPoint_PointsPlugin.js

@@ -1,38 +0,0 @@
-"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

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

package/Postgis_MultiPolygon_PolygonsPlugin.js

@@ -1,38 +0,0 @@
-"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

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

package/Postgis_Point_LatitudeLongitudePlugin.js

@@ -1,43 +0,0 @@
-"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

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

package/Postgis_Polygon_RingsPlugin.js

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

package/esm/PostgisExtensionDetectionPlugin.js

@@ -1,26 +0,0 @@
-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
-        });
-    });
-};
-export default PostgisExtensionDetectionPlugin;

package/esm/PostgisInflectionPlugin.js

@@ -1,34 +0,0 @@
-import { GisSubtype, SUBTYPE_STRING_BY_SUBTYPE } from './constants';
-const PostgisInflectionPlugin = (builder) => {
-    builder.hook('inflection', (inflection) => {
-        return {
-            ...inflection,
-            gisType(type, subtype, hasZ, hasM, _srid) {
-                return this.upperCamelCase([type.name, 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, SUBTYPE_STRING_BY_SUBTYPE[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';
-            }
-        };
-    });
-};
-export default PostgisInflectionPlugin;