graphile-postgis 1.1.1 → 2.2.0

package/esm/PostgisRegisterTypesPlugin.js

@@ -1,229 +0,0 @@
-import { GisSubtype } from './constants';
-import makeGeoJSONType from './makeGeoJSONType';
-import { getGISTypeDetails, getGISTypeModifier, getGISTypeName } from './utils';
-const SUBTYPES = [
-    GisSubtype.Point,
-    GisSubtype.LineString,
-    GisSubtype.Polygon,
-    GisSubtype.MultiPoint,
-    GisSubtype.MultiLineString,
-    GisSubtype.MultiPolygon,
-    GisSubtype.GeometryCollection
-];
-const identity = (input) => input;
-const PostgisRegisterTypesPlugin = (builder) => {
-    builder.hook('build', (build) => {
-        const rawBuild = build;
-        const GeoJSON = makeGeoJSONType(rawBuild.graphql, rawBuild.inflection.builtin('GeoJSON'));
-        rawBuild.addType(GeoJSON);
-        return rawBuild.extend(rawBuild, {
-            getPostgisTypeByGeometryType(pgGISType, subtype, hasZ = false, hasM = false, srid = 0) {
-                const typeModifier = 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 = 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 = 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 = 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 ? getGISTypeName(subtype, hasZ, hasM) : -1;
-            if (!constructedTypes[typeId][gisTypeKey]) {
-                if (typeModifierKey === -1) {
-                    constructedTypes[typeId][gisTypeKey] = getGisInterface(type);
-                }
-                else if (subtype === 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]
-        };
-    });
-};
-export default PostgisRegisterTypesPlugin;

package/esm/PostgisVersionPlugin.js

@@ -1,22 +0,0 @@
-import { findAndRequirePackageJson } from 'find-and-require-package-json';
-const pkg = 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;
-    });
-};
-export default plugin;

package/esm/Postgis_GeometryCollection_GeometriesPlugin.js

@@ -1,41 +0,0 @@
-import { GisSubtype } from './constants';
-import { getGISTypeName } from './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 !== 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 = GisSubtype[geom.type];
-                        if (subtype === undefined) {
-                            throw new Error(`Unsupported geometry subtype ${geom.type}`);
-                        }
-                        return {
-                            __gisType: getGISTypeName(subtype, hasZ, hasM),
-                            __srid: data.__srid,
-                            __geojson: geom
-                        };
-                    });
-                }
-            }
-        });
-    });
-};
-export default PostgisGeometryCollectionGeometriesPlugin;

package/esm/Postgis_LineString_PointsPlugin.js

@@ -1,38 +0,0 @@
-import { GisSubtype } from './constants';
-import { getGISTypeName } from './utils';
-const PostgisLineStringPointsPlugin = (builder) => {
-    builder.hook('GraphQLObjectType:fields', (fields, build, context) => {
-        const { scope: { isPgGISType, pgGISType, pgGISTypeDetails } } = context;
-        if (!isPgGISType ||
-            !pgGISType ||
-            !pgGISTypeDetails ||
-            pgGISTypeDetails.subtype !== GisSubtype.LineString) {
-            return fields;
-        }
-        const { extend, getPostgisTypeByGeometryType, graphql: { GraphQLList } } = build;
-        const { hasZ, hasM, srid } = pgGISTypeDetails;
-        const Point = getPostgisTypeByGeometryType(pgGISType, 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: getGISTypeName(GisSubtype.Point, hasZ, hasM),
-                            __srid: data.__srid,
-                            __geojson: {
-                                type: 'Point',
-                                coordinates: coord
-                            }
-                        };
-                    });
-                }
-            }
-        });
-    });
-};
-export default PostgisLineStringPointsPlugin;

package/esm/Postgis_MultiLineString_LineStringsPlugin.js

@@ -1,36 +0,0 @@
-import { GisSubtype } from './constants';
-import { getGISTypeName } from './utils';
-const PostgisMultiLineStringLineStringsPlugin = (builder) => {
-    builder.hook('GraphQLObjectType:fields', (fields, build, context) => {
-        const { scope: { isPgGISType, pgGISType, pgGISTypeDetails } } = context;
-        if (!isPgGISType ||
-            !pgGISType ||
-            !pgGISTypeDetails ||
-            pgGISTypeDetails.subtype !== GisSubtype.MultiLineString) {
-            return fields;
-        }
-        const { extend, getPostgisTypeByGeometryType, graphql: { GraphQLList } } = build;
-        const { hasZ, hasM, srid } = pgGISTypeDetails;
-        const LineString = getPostgisTypeByGeometryType(pgGISType, 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: getGISTypeName(GisSubtype.LineString, hasZ, hasM),
-                        __srid: data.__srid,
-                        __geojson: {
-                            type: 'LineString',
-                            coordinates: coord
-                        }
-                    }));
-                }
-            }
-        });
-    });
-};
-export default PostgisMultiLineStringLineStringsPlugin;

package/esm/Postgis_MultiPoint_PointsPlugin.js

@@ -1,36 +0,0 @@
-import { GisSubtype } from './constants';
-import { getGISTypeName } from './utils';
-const PostgisMultiPointPointsPlugin = (builder) => {
-    builder.hook('GraphQLObjectType:fields', (fields, build, context) => {
-        const { scope: { isPgGISType, pgGISType, pgGISTypeDetails } } = context;
-        if (!isPgGISType ||
-            !pgGISType ||
-            !pgGISTypeDetails ||
-            pgGISTypeDetails.subtype !== GisSubtype.MultiPoint) {
-            return fields;
-        }
-        const { extend, getPostgisTypeByGeometryType, graphql: { GraphQLList } } = build;
-        const { hasZ, hasM, srid } = pgGISTypeDetails;
-        const Point = getPostgisTypeByGeometryType(pgGISType, 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: getGISTypeName(GisSubtype.Point, hasZ, hasM),
-                        __srid: data.__srid,
-                        __geojson: {
-                            type: 'Point',
-                            coordinates: coord
-                        }
-                    }));
-                }
-            }
-        });
-    });
-};
-export default PostgisMultiPointPointsPlugin;

package/esm/Postgis_MultiPolygon_PolygonsPlugin.js

@@ -1,36 +0,0 @@
-import { GisSubtype } from './constants';
-import { getGISTypeName } from './utils';
-const PostgisMultiPolygonPolygonsPlugin = (builder) => {
-    builder.hook('GraphQLObjectType:fields', (fields, build, context) => {
-        const { scope: { isPgGISType, pgGISType, pgGISTypeDetails } } = context;
-        if (!isPgGISType ||
-            !pgGISType ||
-            !pgGISTypeDetails ||
-            pgGISTypeDetails.subtype !== GisSubtype.MultiPolygon) {
-            return fields;
-        }
-        const { extend, getPostgisTypeByGeometryType, graphql: { GraphQLList } } = build;
-        const { hasZ, hasM, srid } = pgGISTypeDetails;
-        const PolygonType = getPostgisTypeByGeometryType(pgGISType, 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: getGISTypeName(GisSubtype.Polygon, hasZ, hasM),
-                        __srid: data.__srid,
-                        __geojson: {
-                            type: 'Polygon',
-                            coordinates: coord
-                        }
-                    }));
-                }
-            }
-        });
-    });
-};
-export default PostgisMultiPolygonPolygonsPlugin;

package/esm/Postgis_Point_LatitudeLongitudePlugin.js

@@ -1,41 +0,0 @@
-import { GisSubtype } from './constants';
-const PostgisPointLatitudeLongitudePlugin = (builder) => {
-    builder.hook('GraphQLObjectType:fields', (fields, build, context) => {
-        const { scope: { isPgGISType, pgGISType, pgGISTypeDetails } } = context;
-        if (!isPgGISType || !pgGISType || !pgGISTypeDetails || pgGISTypeDetails.subtype !== 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];
-                        }
-                    }
-                }
-                : {})
-        });
-    });
-};
-export default PostgisPointLatitudeLongitudePlugin;

package/esm/Postgis_Polygon_RingsPlugin.js

@@ -1,47 +0,0 @@
-import { GisSubtype } from './constants';
-import { getGISTypeName } from './utils';
-const PostgisPolygonRingsPlugin = (builder) => {
-    builder.hook('GraphQLObjectType:fields', (fields, build, context) => {
-        const { scope: { isPgGISType, pgGISType, pgGISTypeDetails } } = context;
-        if (!isPgGISType || !pgGISType || !pgGISTypeDetails || pgGISTypeDetails.subtype !== GisSubtype.Polygon) {
-            return fields;
-        }
-        const { extend, getPostgisTypeByGeometryType, graphql: { GraphQLList } } = build;
-        const { hasZ, hasM, srid } = pgGISTypeDetails;
-        const LineStringType = getPostgisTypeByGeometryType(pgGISType, GisSubtype.LineString, hasZ, hasM, srid);
-        if (!LineStringType) {
-            return fields;
-        }
-        return 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
-                        }
-                    }));
-                }
-            }
-        });
-    });
-};
-export default PostgisPolygonRingsPlugin;

package/esm/makeGeoJSONType.js

@@ -1,39 +0,0 @@
-export default function makeGeoJSONType(graphql, name = 'GeoJSON') {
-    const { Kind, GraphQLScalarType } = graphql;
-    const identity = (value) => value;
-    const parseLiteral = (ast, variables) => {
-        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] = parseLiteral(field.value, variables);
-                });
-                return value;
-            }
-            case Kind.LIST:
-                return ast.values.map((n) => parseLiteral(n, variables));
-            case Kind.NULL:
-                return null;
-            case Kind.VARIABLE: {
-                const variableName = ast.name.value;
-                return variables ? variables[variableName] : undefined;
-            }
-            default:
-                return undefined;
-        }
-    };
-    return new GraphQLScalarType({
-        name,
-        description: `The \`${name}\` scalar type represents GeoJSON values as specified by` +
-            '[RFC 7946](https://tools.ietf.org/html/rfc7946).',
-        serialize: identity,
-        parseValue: identity,
-        parseLiteral
-    });
-}

package/makeGeoJSONType.d.ts

@@ -1 +0,0 @@
-export default function makeGeoJSONType(graphql: typeof import('graphql'), name?: string): import('graphql').GraphQLScalarType;

package/makeGeoJSONType.js

@@ -1,42 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = makeGeoJSONType;
-function makeGeoJSONType(graphql, name = 'GeoJSON') {
-    const { Kind, GraphQLScalarType } = graphql;
-    const identity = (value) => value;
-    const parseLiteral = (ast, variables) => {
-        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] = parseLiteral(field.value, variables);
-                });
-                return value;
-            }
-            case Kind.LIST:
-                return ast.values.map((n) => parseLiteral(n, variables));
-            case Kind.NULL:
-                return null;
-            case Kind.VARIABLE: {
-                const variableName = ast.name.value;
-                return variables ? variables[variableName] : undefined;
-            }
-            default:
-                return undefined;
-        }
-    };
-    return new GraphQLScalarType({
-        name,
-        description: `The \`${name}\` scalar type represents GeoJSON values as specified by` +
-            '[RFC 7946](https://tools.ietf.org/html/rfc7946).',
-        serialize: identity,
-        parseValue: identity,
-        parseLiteral
-    });
-}