graphile-postgis 0.1.0 → 0.1.1

package/esm/Postgis_MultiLineString_LineStringsPlugin.js

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

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

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

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

@@ -0,0 +1,47 @@
+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/constants.js

@@ -0,0 +1,31 @@
+export var GisSubtype;
+(function (GisSubtype) {
+    GisSubtype[GisSubtype["Geometry"] = 0] = "Geometry";
+    GisSubtype[GisSubtype["Point"] = 1] = "Point";
+    GisSubtype[GisSubtype["LineString"] = 2] = "LineString";
+    GisSubtype[GisSubtype["Polygon"] = 3] = "Polygon";
+    GisSubtype[GisSubtype["MultiPoint"] = 4] = "MultiPoint";
+    GisSubtype[GisSubtype["MultiLineString"] = 5] = "MultiLineString";
+    GisSubtype[GisSubtype["MultiPolygon"] = 6] = "MultiPolygon";
+    GisSubtype[GisSubtype["GeometryCollection"] = 7] = "GeometryCollection";
+})(GisSubtype || (GisSubtype = {}));
+export const SUBTYPE_STRING_BY_SUBTYPE = {
+    [GisSubtype.Geometry]: 'geometry',
+    [GisSubtype.Point]: 'point',
+    [GisSubtype.LineString]: 'line-string',
+    [GisSubtype.Polygon]: 'polygon',
+    [GisSubtype.MultiPoint]: 'multi-point',
+    [GisSubtype.MultiLineString]: 'multi-line-string',
+    [GisSubtype.MultiPolygon]: 'multi-polygon',
+    [GisSubtype.GeometryCollection]: 'geometry-collection'
+};
+export const GIS_SUBTYPE_NAME = {
+    [GisSubtype.Geometry]: 'Geometry',
+    [GisSubtype.Point]: 'Point',
+    [GisSubtype.LineString]: 'LineString',
+    [GisSubtype.Polygon]: 'Polygon',
+    [GisSubtype.MultiPoint]: 'MultiPoint',
+    [GisSubtype.MultiLineString]: 'MultiLineString',
+    [GisSubtype.MultiPolygon]: 'MultiPolygon',
+    [GisSubtype.GeometryCollection]: 'GeometryCollection'
+};

package/esm/index.js

@@ -0,0 +1,33 @@
+import PostgisExtensionDetectionPlugin from './PostgisExtensionDetectionPlugin';
+import PostgisInflectionPlugin from './PostgisInflectionPlugin';
+import PostgisRegisterTypesPlugin from './PostgisRegisterTypesPlugin';
+import PostgisVersionPlugin from './PostgisVersionPlugin';
+import Postgis_GeometryCollection_GeometriesPlugin from './Postgis_GeometryCollection_GeometriesPlugin';
+import Postgis_LineString_PointsPlugin from './Postgis_LineString_PointsPlugin';
+import Postgis_MultiLineString_LineStringsPlugin from './Postgis_MultiLineString_LineStringsPlugin';
+import Postgis_MultiPoint_PointsPlugin from './Postgis_MultiPoint_PointsPlugin';
+import Postgis_MultiPolygon_PolygonsPlugin from './Postgis_MultiPolygon_PolygonsPlugin';
+import Postgis_Point_LatitudeLongitudePlugin from './Postgis_Point_LatitudeLongitudePlugin';
+import Postgis_Polygon_RingsPlugin from './Postgis_Polygon_RingsPlugin';
+const PostgisPlugin = async (builder, options) => {
+    await PostgisVersionPlugin(builder, options);
+    await PostgisInflectionPlugin(builder, options);
+    await PostgisExtensionDetectionPlugin(builder, options);
+    await PostgisRegisterTypesPlugin(builder, options);
+    // Enhancing the `Point` type:
+    await Postgis_Point_LatitudeLongitudePlugin(builder, options);
+    // Enhancing the `LineString` type:
+    await Postgis_LineString_PointsPlugin(builder, options);
+    // Enhancing the `Polygon` type:
+    await Postgis_Polygon_RingsPlugin(builder, options);
+    // Enhancing the `MultiPoint` type:
+    await Postgis_MultiPoint_PointsPlugin(builder, options);
+    // Enhancing the `MultiLineString` type:
+    await Postgis_MultiLineString_LineStringsPlugin(builder, options);
+    // Enhancing the `MultiPolygon` type:
+    await Postgis_MultiPolygon_PolygonsPlugin(builder, options);
+    // Enhancing the `GeometryCollection` type:
+    await Postgis_GeometryCollection_GeometriesPlugin(builder, options);
+};
+export { PostgisExtensionDetectionPlugin, PostgisInflectionPlugin, PostgisRegisterTypesPlugin, PostgisVersionPlugin, Postgis_GeometryCollection_GeometriesPlugin, Postgis_LineString_PointsPlugin, Postgis_MultiLineString_LineStringsPlugin, Postgis_MultiPoint_PointsPlugin, Postgis_MultiPolygon_PolygonsPlugin, Postgis_Point_LatitudeLongitudePlugin, Postgis_Polygon_RingsPlugin };
+export default PostgisPlugin;

package/esm/makeGeoJSONType.js

@@ -0,0 +1,39 @@
+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/esm/types.js

@@ -0,0 +1 @@
+export {};

package/esm/utils.js

@@ -0,0 +1,47 @@
+import { GIS_SUBTYPE_NAME, GisSubtype } from './constants';
+export const getGISTypeDetails = (modifier) => {
+    const allZeroesHopefully = modifier >> 24;
+    if (allZeroesHopefully !== 0) {
+        throw new Error('Unsupported PostGIS modifier');
+    }
+    // Ref: https://github.com/postgis/postgis/blob/2.5.2/liblwgeom/liblwgeom.h.in#L156-L173
+    // #define TYPMOD_GET_SRID(typmod) ((((typmod) & 0x0FFFFF00) - ((typmod) & 0x10000000)) >> 8)
+    // #define TYPMOD_GET_TYPE(typmod) ((typmod & 0x000000FC)>>2)
+    // #define TYPMOD_GET_Z(typmod) ((typmod & 0x00000002)>>1)
+    // #define TYPMOD_GET_M(typmod) (typmod & 0x00000001)
+    const srid = ((modifier & 0x0fffff00) - (modifier & 0x10000000)) >> 8;
+    const subtypeNumeric = (modifier & 0x000000fc) >> 2;
+    const hasZ = (modifier & 0x00000002) >> 1 === 1;
+    const hasM = (modifier & 0x00000001) === 1;
+    if (subtypeNumeric !== GisSubtype.Geometry &&
+        subtypeNumeric !== GisSubtype.Point &&
+        subtypeNumeric !== GisSubtype.LineString &&
+        subtypeNumeric !== GisSubtype.Polygon &&
+        subtypeNumeric !== GisSubtype.MultiPoint &&
+        subtypeNumeric !== GisSubtype.MultiLineString &&
+        subtypeNumeric !== GisSubtype.MultiPolygon &&
+        subtypeNumeric !== GisSubtype.GeometryCollection) {
+        throw new Error(`Unsupported PostGIS modifier, expected 0-7, received ${subtypeNumeric} (${modifier})`);
+    }
+    const subtype = subtypeNumeric;
+    return {
+        subtype,
+        hasZ,
+        hasM,
+        srid
+    };
+};
+export const getGISTypeModifier = (subtype, hasZ, hasM, srid) => {
+    // Ref: https://github.com/postgis/postgis/blob/2.5.2/liblwgeom/liblwgeom.h.in#L156-L173
+    // #define TYPMOD_SET_SRID(typmod, srid) ((typmod) = (((typmod) & 0xE00000FF) | ((srid & 0x001FFFFF)<<8)))
+    // #define TYPMOD_SET_TYPE(typmod, type) ((typmod) = (typmod & 0xFFFFFF03) | ((type & 0x0000003F)<<2))
+    // #define TYPMOD_SET_Z(typmod) ((typmod) = typmod | 0x00000002)
+    // #define TYPMOD_SET_M(typmod) ((typmod) = typmod | 0x00000001)
+    return (((srid & 0x001fffff) << 8) +
+        ((subtype & 0x0000003f) << 2) +
+        (hasZ ? 0x00000002 : 0) +
+        (hasM ? 0x00000001 : 0));
+};
+export const getGISTypeName = (subtype, hasZ, hasM) => {
+    return `${GIS_SUBTYPE_NAME[subtype]}${hasZ ? 'Z' : ''}${hasM ? 'M' : ''}`;
+};

package/index.d.ts

@@ -0,0 +1,15 @@
+import type { Plugin } from 'graphile-build';
+import PostgisExtensionDetectionPlugin from './PostgisExtensionDetectionPlugin';
+import PostgisInflectionPlugin from './PostgisInflectionPlugin';
+import PostgisRegisterTypesPlugin from './PostgisRegisterTypesPlugin';
+import PostgisVersionPlugin from './PostgisVersionPlugin';
+import Postgis_GeometryCollection_GeometriesPlugin from './Postgis_GeometryCollection_GeometriesPlugin';
+import Postgis_LineString_PointsPlugin from './Postgis_LineString_PointsPlugin';
+import Postgis_MultiLineString_LineStringsPlugin from './Postgis_MultiLineString_LineStringsPlugin';
+import Postgis_MultiPoint_PointsPlugin from './Postgis_MultiPoint_PointsPlugin';
+import Postgis_MultiPolygon_PolygonsPlugin from './Postgis_MultiPolygon_PolygonsPlugin';
+import Postgis_Point_LatitudeLongitudePlugin from './Postgis_Point_LatitudeLongitudePlugin';
+import Postgis_Polygon_RingsPlugin from './Postgis_Polygon_RingsPlugin';
+declare const PostgisPlugin: Plugin;
+export { PostgisExtensionDetectionPlugin, PostgisInflectionPlugin, PostgisRegisterTypesPlugin, PostgisVersionPlugin, Postgis_GeometryCollection_GeometriesPlugin, Postgis_LineString_PointsPlugin, Postgis_MultiLineString_LineStringsPlugin, Postgis_MultiPoint_PointsPlugin, Postgis_MultiPolygon_PolygonsPlugin, Postgis_Point_LatitudeLongitudePlugin, Postgis_Polygon_RingsPlugin };
+export default PostgisPlugin;

package/index.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Postgis_Polygon_RingsPlugin = exports.Postgis_Point_LatitudeLongitudePlugin = exports.Postgis_MultiPolygon_PolygonsPlugin = exports.Postgis_MultiPoint_PointsPlugin = exports.Postgis_MultiLineString_LineStringsPlugin = exports.Postgis_LineString_PointsPlugin = exports.Postgis_GeometryCollection_GeometriesPlugin = exports.PostgisVersionPlugin = exports.PostgisRegisterTypesPlugin = exports.PostgisInflectionPlugin = exports.PostgisExtensionDetectionPlugin = void 0;
+const PostgisExtensionDetectionPlugin_1 = __importDefault(require("./PostgisExtensionDetectionPlugin"));
+exports.PostgisExtensionDetectionPlugin = PostgisExtensionDetectionPlugin_1.default;
+const PostgisInflectionPlugin_1 = __importDefault(require("./PostgisInflectionPlugin"));
+exports.PostgisInflectionPlugin = PostgisInflectionPlugin_1.default;
+const PostgisRegisterTypesPlugin_1 = __importDefault(require("./PostgisRegisterTypesPlugin"));
+exports.PostgisRegisterTypesPlugin = PostgisRegisterTypesPlugin_1.default;
+const PostgisVersionPlugin_1 = __importDefault(require("./PostgisVersionPlugin"));
+exports.PostgisVersionPlugin = PostgisVersionPlugin_1.default;
+const Postgis_GeometryCollection_GeometriesPlugin_1 = __importDefault(require("./Postgis_GeometryCollection_GeometriesPlugin"));
+exports.Postgis_GeometryCollection_GeometriesPlugin = Postgis_GeometryCollection_GeometriesPlugin_1.default;
+const Postgis_LineString_PointsPlugin_1 = __importDefault(require("./Postgis_LineString_PointsPlugin"));
+exports.Postgis_LineString_PointsPlugin = Postgis_LineString_PointsPlugin_1.default;
+const Postgis_MultiLineString_LineStringsPlugin_1 = __importDefault(require("./Postgis_MultiLineString_LineStringsPlugin"));
+exports.Postgis_MultiLineString_LineStringsPlugin = Postgis_MultiLineString_LineStringsPlugin_1.default;
+const Postgis_MultiPoint_PointsPlugin_1 = __importDefault(require("./Postgis_MultiPoint_PointsPlugin"));
+exports.Postgis_MultiPoint_PointsPlugin = Postgis_MultiPoint_PointsPlugin_1.default;
+const Postgis_MultiPolygon_PolygonsPlugin_1 = __importDefault(require("./Postgis_MultiPolygon_PolygonsPlugin"));
+exports.Postgis_MultiPolygon_PolygonsPlugin = Postgis_MultiPolygon_PolygonsPlugin_1.default;
+const Postgis_Point_LatitudeLongitudePlugin_1 = __importDefault(require("./Postgis_Point_LatitudeLongitudePlugin"));
+exports.Postgis_Point_LatitudeLongitudePlugin = Postgis_Point_LatitudeLongitudePlugin_1.default;
+const Postgis_Polygon_RingsPlugin_1 = __importDefault(require("./Postgis_Polygon_RingsPlugin"));
+exports.Postgis_Polygon_RingsPlugin = Postgis_Polygon_RingsPlugin_1.default;
+const PostgisPlugin = async (builder, options) => {
+    await (0, PostgisVersionPlugin_1.default)(builder, options);
+    await (0, PostgisInflectionPlugin_1.default)(builder, options);
+    await (0, PostgisExtensionDetectionPlugin_1.default)(builder, options);
+    await (0, PostgisRegisterTypesPlugin_1.default)(builder, options);
+    // Enhancing the `Point` type:
+    await (0, Postgis_Point_LatitudeLongitudePlugin_1.default)(builder, options);
+    // Enhancing the `LineString` type:
+    await (0, Postgis_LineString_PointsPlugin_1.default)(builder, options);
+    // Enhancing the `Polygon` type:
+    await (0, Postgis_Polygon_RingsPlugin_1.default)(builder, options);
+    // Enhancing the `MultiPoint` type:
+    await (0, Postgis_MultiPoint_PointsPlugin_1.default)(builder, options);
+    // Enhancing the `MultiLineString` type:
+    await (0, Postgis_MultiLineString_LineStringsPlugin_1.default)(builder, options);
+    // Enhancing the `MultiPolygon` type:
+    await (0, Postgis_MultiPolygon_PolygonsPlugin_1.default)(builder, options);
+    // Enhancing the `GeometryCollection` type:
+    await (0, Postgis_GeometryCollection_GeometriesPlugin_1.default)(builder, options);
+};
+exports.default = PostgisPlugin;

package/makeGeoJSONType.d.ts

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

package/makeGeoJSONType.js

@@ -0,0 +1,42 @@
+"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
+    });
+}

package/package.json

@@ -1,69 +1,54 @@
 {
   "name": "graphile-postgis",
-  "version": "0.1.0",
-  "description": "graphile postgis in JS",
+  "version": "0.1.1",
+  "description": "Graphile/PostGraphile PostGIS integration plugin",
   "author": "Dan Lynch <pyramation@gmail.com>",
-  "homepage": "https://github.com/pyramation/graphile-postgis#readme",
-  "license": "SEE LICENSE IN LICENSE",
-  "main": "main/index.js",
-  "module": "module/index.js",
-  "directories": {
-    "lib": "src",
-    "test": "__tests__"
-  },
-  "files": [
-    "main",
-    "module"
-  ],
+  "homepage": "https://github.com/launchql/launchql",
+  "license": "MIT",
+  "main": "index.js",
+  "module": "esm/index.js",
+  "types": "index.d.ts",
   "scripts": {
-    "build:main": "cross-env BABEL_ENV=production babel src --out-dir main --delete-dir-on-start",
-    "build:module": "cross-env MODULE=true babel src --out-dir module --delete-dir-on-start",
-    "build": "npm run build:module && npm run build:main",
-    "prepublish": "npm run build",
-    "dev": "cross-env NODE_ENV=development babel-node src/index",
-    "watch": "cross-env NODE_ENV=development babel-watch src/index",
-    "lint": "eslint src --fix",
+    "clean": "makage clean",
+    "copy": "makage assets",
+    "prepack": "pnpm run build",
+    "build": "makage build",
+    "build:dev": "makage build --dev",
+    "lint": "eslint . --fix",
     "test": "jest",
-    "test:watch": "jest --watch",
-    "test:debug": "node --inspect node_modules/.bin/jest --runInBand"
+    "test:watch": "jest --watch"
   },
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "directory": "dist"
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/pyramation/graphile-postgis"
+    "url": "https://github.com/launchql/launchql"
   },
-  "keywords": [],
+  "keywords": [
+    "graphile",
+    "postgraphile",
+    "postgis",
+    "postgres",
+    "graphql",
+    "launchql"
+  ],
   "bugs": {
-    "url": "https://github.com/pyramation/graphile-postgis/issues"
+    "url": "https://github.com/launchql/launchql/issues"
   },
   "devDependencies": {
-    "@babel/cli": "7.11.6",
-    "@babel/core": "7.11.6",
-    "@babel/node": "^7.10.5",
-    "@babel/plugin-proposal-class-properties": "7.10.4",
-    "@babel/plugin-proposal-export-default-from": "7.10.4",
-    "@babel/plugin-proposal-object-rest-spread": "7.11.0",
-    "@babel/plugin-transform-runtime": "7.11.5",
-    "@babel/preset-env": "7.11.5",
-    "babel-core": "7.0.0-bridge.0",
-    "babel-eslint": "10.1.0",
-    "babel-jest": "25.1.0",
-    "babel-watch": "^7.0.0",
-    "cross-env": "^7.0.2",
-    "eslint": "6.8.0",
-    "eslint-config-prettier": "^6.10.0",
-    "eslint-plugin-prettier": "^3.1.2",
-    "graphql": "14.0.2",
-    "jest": "^24.5.0",
-    "jest-in-case": "^1.0.2",
-    "pg": "^8.4.1",
-    "postgraphile-core": "^4.9.0",
-    "prettier": "^2.1.2",
-    "regenerator-runtime": "^0.13.7"
+    "@types/geojson": "^7946.0.14",
+    "graphile-test": "^2.8.9",
+    "makage": "^0.1.6",
+    "pgsql-test": "^2.14.12"
   },
   "dependencies": {
-    "@babel/runtime": "^7.11.2"
-  }
+    "graphile-build": "^4.14.1",
+    "graphile-build-pg": "^4.14.1",
+    "graphile-utils": "^4.14.1",
+    "graphql": "15.10.1",
+    "pg": "^8.16.0"
+  },
+  "gitHead": "3812f24a480b2035b3413ec7fecfe492f294e590"
 }

package/types.d.ts

@@ -0,0 +1,59 @@
+import type { Build, Inflection } from 'graphile-build';
+import type { PgExtension, PgIntrospectionResultsByKind, PgType } from 'graphile-build-pg';
+import type { SQL } from 'graphile-build-pg/node8plus/QueryBuilder';
+import type { GraphQLInputType, GraphQLInterfaceType, GraphQLObjectType, GraphQLOutputType, GraphQLType } from 'graphql';
+import type { Geometry } from 'geojson';
+import type { GisSubtype } from './constants';
+export interface GisTypeDetails {
+    subtype: GisSubtype;
+    hasZ: boolean;
+    hasM: boolean;
+    srid: number;
+}
+export type GisGraphQLType = GraphQLInterfaceType | GraphQLObjectType;
+export interface GisFieldValue {
+    __gisType: string;
+    __srid: number;
+    __geojson: Geometry;
+}
+export interface PostgisInflection extends Inflection {
+    gisType(type: PgType, subtype: GisSubtype, hasZ: boolean, hasM: boolean, srid?: number): string;
+    gisInterfaceName(type: PgType): string;
+    gisDimensionInterfaceName(type: PgType, hasZ: boolean, hasM: boolean): string;
+    geojsonFieldName(): string;
+    gisXFieldName(type: PgType): string;
+    gisYFieldName(type: PgType): string;
+    gisZFieldName(type: PgType): string;
+}
+export type PgTweaksByTypeIdAndModifier = Record<string | number, Record<string | number, (fragment: SQL, resolveData: unknown) => SQL>>;
+export interface PgMapper {
+    map: (value: unknown) => unknown;
+    unmap: (value: unknown) => SQL;
+}
+export interface PostgisBuild extends Build {
+    extend<TBase extends object, TExtension extends object>(base: TBase, extension: TExtension): TBase & TExtension;
+    newWithHooks: <TType extends GraphQLOutputType, TConfig extends object>(constructor: new (config: TConfig) => TType, spec: TConfig, scope?: Record<string, unknown>) => TType;
+    getTypeByName: (name: string) => GraphQLType | undefined;
+    pgIntrospectionResultsByKind: PgIntrospectionResultsByKind;
+    pgRegisterGqlTypeByTypeId: (typeId: string | number, generator: (set: Record<string, unknown>, typeModifier: number | null) => GraphQLOutputType) => void;
+    pgRegisterGqlInputTypeByTypeId: (typeId: string | number, generator: () => GraphQLInputType) => void;
+    pgGetGqlTypeByTypeIdAndModifier: (typeId: string | number, typeModifier: number | null) => GraphQLOutputType | GraphQLInterfaceType | null | undefined;
+    pgTweaksByTypeIdAndModifer: PgTweaksByTypeIdAndModifier;
+    pgSql: typeof import('graphile-build-pg/node8plus/QueryBuilder').sql;
+    pg2gql: (value: unknown, type: PgType) => unknown;
+    pg2GqlMapper: Record<string | number, PgMapper>;
+    pgGISGraphQLTypesByTypeAndSubtype: Record<string | number, Record<string | number, GisGraphQLType>>;
+    pgGISGraphQLInterfaceTypesByType: Record<string | number, Record<number, GraphQLInterfaceType>>;
+    pgGISGeometryType?: PgType;
+    pgGISGeographyType?: PgType;
+    pgGISExtension?: PgExtension;
+    pgGISIncludedTypes: GisGraphQLType[];
+    pgGISIncludeType: (type: GisGraphQLType) => void;
+    getPostgisTypeByGeometryType: (pgGISType: PgType, subtype: GisSubtype, hasZ?: boolean, hasM?: boolean, srid?: number) => GraphQLOutputType | GraphQLInterfaceType | null | undefined;
+    inflection: PostgisInflection;
+}
+export interface GisScope {
+    isPgGISType?: boolean;
+    pgGISType?: PgType;
+    pgGISTypeDetails?: GisTypeDetails;
+}

package/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/utils.d.ts

@@ -0,0 +1,5 @@
+import { GisSubtype } from './constants';
+import type { GisTypeDetails } from './types';
+export declare const getGISTypeDetails: (modifier: number) => GisTypeDetails;
+export declare const getGISTypeModifier: (subtype: GisSubtype, hasZ: boolean, hasM: boolean, srid: number) => number;
+export declare const getGISTypeName: (subtype: GisSubtype, hasZ: boolean, hasM: boolean) => string;