graphile-postgis 0.1.0 → 0.1.2

package/module/PostgisRegisterTypesPlugin.js

@@ -1,267 +0,0 @@
-import { getGISTypeDetails, getGISTypeModifier, getGISTypeName } from './utils';
-import makeGeoJSONType from './makeGeoJSONType';
-
-function identity(input) {
-  return input;
-}
-
-const plugin = builder => {
-  builder.hook('build', build => {
-    const GeoJSON = makeGeoJSONType(build.graphql, build.inflection.builtin('GeoJSON'));
-    build.addType(GeoJSON);
-    return build.extend(build, {
-      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', (_, build) => {
-    const {
-      newWithHooks,
-      pgIntrospectionResultsByKind: introspectionResultsByKind,
-      graphql: {
-        GraphQLInt,
-        GraphQLNonNull,
-        GraphQLInterfaceType,
-        GraphQLObjectType
-      },
-      pgRegisterGqlTypeByTypeId,
-      pgRegisterGqlInputTypeByTypeId,
-      pgTweaksByTypeIdAndModifer,
-      getTypeByName,
-      pgSql: sql,
-      pg2gql,
-      pg2GqlMapper,
-      inflection,
-      pgGISGraphQLTypesByTypeAndSubtype: constructedTypes,
-      pgGISGraphQLInterfaceTypesByType: _interfaces,
-      pgGISGeometryType: GEOMETRY_TYPE,
-      pgGISGeographyType: GEOGRAPHY_TYPE,
-      pgGISExtension: POSTGIS,
-      pgGISIncludeType: includeType
-    } = build;
-
-    if (!GEOMETRY_TYPE || !GEOGRAPHY_TYPE) {
-      return _;
-    }
-
-    console.warn('PostGIS plugin enabled');
-    const GeoJSON = getTypeByName(inflection.builtin('GeoJSON'));
-    const geojsonFieldName = inflection.geojsonFieldName();
-
-    function getGisInterface(type) {
-      const zmflag = -1; // no dimensional constraint; could be xy/xyz/xym/xyzm
-
-      if (!_interfaces[type.id]) {
-        _interfaces[type.id] = {};
-      }
-
-      if (!_interfaces[type.id][zmflag]) {
-        _interfaces[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, _info) {
-            const Type = constructedTypes[type.id] && constructedTypes[type.id][value.__gisType];
-            return Type;
-          },
-
-          description: `All ${type.name} types implement this interface`
-        }, {
-          isPgGISInterface: true,
-          pgGISType: type,
-          pgGISZMFlag: zmflag
-        }); // Force creation of all GraphQL types that could be resolved from this interface
-
-        const subtypes = [1, 2, 3, 4, 5, 6, 7];
-
-        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 _interfaces[type.id][zmflag];
-    }
-
-    function 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'
-      }[zmflag];
-
-      if (!_interfaces[type.id]) {
-        _interfaces[type.id] = {};
-      }
-
-      if (!_interfaces[type.id][zmflag]) {
-        _interfaces[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, _info) {
-            const Type = constructedTypes[type.id] && constructedTypes[type.id][value.__gisType];
-            return Type;
-          },
-
-          description: `All ${type.name} ${coords} types implement this interface`
-        }, {
-          isPgGISDimensionInterface: true,
-          pgGISType: type,
-          pgGISZMFlag: zmflag
-        }); // Force creation of all GraphQL types that could be resolved from this interface
-
-        const subtypes = [1, 2, 3, 4, 5, 6, 7];
-
-        for (const subtype of subtypes) {
-          const typeModifier = getGISTypeModifier(subtype, hasZ, hasM, 0);
-          const Type = getGisType(type, typeModifier);
-          includeType(Type);
-        }
-      }
-
-      return _interfaces[type.id][zmflag];
-    }
-
-    function 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[type.id]) {
-        constructedTypes[type.id] = {};
-      }
-
-      const typeModifierKey = typeModifier != null ? typeModifier : -1;
-
-      if (!pgTweaksByTypeIdAndModifer[typeId]) {
-        pgTweaksByTypeIdAndModifer[typeId] = {};
-      }
-
-      if (!pgTweaksByTypeIdAndModifer[typeId][typeModifierKey]) {
-        pgTweaksByTypeIdAndModifer[typeId][typeModifierKey] = (fragment, _resolveData) => {
-          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[type.id][gisTypeKey]) {
-        if (typeModifierKey === -1) {
-          constructedTypes[type.id][gisTypeKey] = getGisInterface(type);
-        } else if (subtype === 0) {
-          constructedTypes[type.id][gisTypeKey] = getGisDimensionInterface(type, hasZ, hasM);
-        } else {
-          const intType = introspectionResultsByKind.type.find(t => t.name === 'int4' && t.namespaceName === 'pg_catalog');
-          const jsonType = introspectionResultsByKind.type.find(t => t.name === 'json' && t.namespaceName === 'pg_catalog');
-          constructedTypes[type.id][gisTypeKey] = newWithHooks(GraphQLObjectType, {
-            name: inflection.gisType(type, subtype, hasZ, hasM, srid),
-            interfaces: () => [getGisInterface(type), getGisDimensionInterface(type, hasZ, hasM)],
-            fields: {
-              [geojsonFieldName]: {
-                type: GeoJSON,
-                resolve: (data, _args, _context, _resolveInfo) => {
-                  return pg2gql(data.__geojson, jsonType);
-                }
-              },
-              srid: {
-                type: new GraphQLNonNull(GraphQLInt),
-                resolve: (data, _args, _context, _resolveInfo) => {
-                  return pg2gql(data.__srid, intType);
-                }
-              }
-            }
-          }, {
-            isPgGISType: true,
-            pgGISType: type,
-            pgGISTypeDetails: typeDetails
-          });
-        }
-      }
-
-      return constructedTypes[type.id][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 _;
-  }, ['PostgisTypes'], ['PgTables'], ['PgTypes']);
-  builder.hook('GraphQLSchema', (schema, build) => {
-    if (!schema.types) {
-      schema.types = [];
-    }
-
-    schema.types = [...schema.types, ...build.pgGISIncludedTypes];
-    return schema;
-  });
-};
-
-export default plugin;

package/module/Postgis_GeometryCollection_GeometriesPlugin.js

@@ -1,57 +0,0 @@
-import { GIS_SUBTYPE } from './constants';
-import { getGISTypeName } from './utils';
-
-const plugin = builder => {
-  builder.hook('GraphQLObjectType:fields', function AddGeometriesToGeometryCollection(fields, build, context) {
-    const {
-      scope: {
-        isPgGISType,
-        pgGISType,
-        pgGISTypeDetails
-      }
-    } = context;
-
-    if (!isPgGISType || !pgGISTypeDetails || pgGISTypeDetails.subtype !== GIS_SUBTYPE.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) {
-          return data.__geojson.geometries.map(geom => {
-            return {
-              __gisType: getGISTypeName(GIS_SUBTYPE[geom.type], hasZ, hasM),
-              __srid: data.__srid,
-              __geojson: geom
-            };
-          });
-        }
-
-      }
-    });
-  });
-};
-
-export default plugin;

package/module/Postgis_LineString_PointsPlugin.js

@@ -1,53 +0,0 @@
-import { GIS_SUBTYPE } from './constants';
-import { getGISTypeName } from './utils';
-
-const plugin = builder => {
-  builder.hook('GraphQLObjectType:fields', (fields, build, context) => {
-    const {
-      scope: {
-        isPgGISType,
-        pgGISType,
-        pgGISTypeDetails
-      }
-    } = context;
-
-    if (!isPgGISType || !pgGISTypeDetails || pgGISTypeDetails.subtype !== GIS_SUBTYPE.LineString) {
-      return fields;
-    }
-
-    const {
-      extend,
-      getPostgisTypeByGeometryType,
-      graphql: {
-        GraphQLList
-      }
-    } = build;
-    const {
-      hasZ,
-      hasM,
-      srid
-    } = pgGISTypeDetails;
-    const Point = getPostgisTypeByGeometryType(pgGISType, GIS_SUBTYPE.Point, hasZ, hasM, srid);
-    return extend(fields, {
-      points: {
-        type: new GraphQLList(Point),
-
-        resolve(data) {
-          return data.__geojson.coordinates.map(coord => {
-            return {
-              __gisType: getGISTypeName(GIS_SUBTYPE.Point, hasZ, hasM),
-              __srid: data.__srid,
-              __geojson: {
-                type: 'Point',
-                coordinates: coord
-              }
-            };
-          });
-        }
-
-      }
-    });
-  });
-};
-
-export default plugin;

package/module/Postgis_MultiLineString_LineStringsPlugin.js

@@ -1,51 +0,0 @@
-import { GIS_SUBTYPE } from './constants';
-import { getGISTypeName } from './utils';
-
-const plugin = builder => {
-  builder.hook('GraphQLObjectType:fields', (fields, build, context) => {
-    const {
-      scope: {
-        isPgGISType,
-        pgGISType,
-        pgGISTypeDetails
-      }
-    } = context;
-
-    if (!isPgGISType || !pgGISTypeDetails || pgGISTypeDetails.subtype !== GIS_SUBTYPE.MultiLineString) {
-      return fields;
-    }
-
-    const {
-      extend,
-      getPostgisTypeByGeometryType,
-      graphql: {
-        GraphQLList
-      }
-    } = build;
-    const {
-      hasZ,
-      hasM,
-      srid
-    } = pgGISTypeDetails;
-    const LineString = getPostgisTypeByGeometryType(pgGISType, GIS_SUBTYPE.LineString, hasZ, hasM, srid);
-    return extend(fields, {
-      lines: {
-        type: new GraphQLList(LineString),
-
-        resolve(data) {
-          return data.__geojson.coordinates.map(coord => ({
-            __gisType: getGISTypeName(GIS_SUBTYPE.LineString, hasZ, hasM),
-            __srid: data.__srid,
-            __geojson: {
-              type: 'LineString',
-              coordinates: coord
-            }
-          }));
-        }
-
-      }
-    });
-  });
-};
-
-export default plugin;

package/module/Postgis_MultiPoint_PointsPlugin.js

@@ -1,51 +0,0 @@
-import { GIS_SUBTYPE } from './constants';
-import { getGISTypeName } from './utils';
-
-const plugin = builder => {
-  builder.hook('GraphQLObjectType:fields', (fields, build, context) => {
-    const {
-      scope: {
-        isPgGISType,
-        pgGISType,
-        pgGISTypeDetails
-      }
-    } = context;
-
-    if (!isPgGISType || !pgGISTypeDetails || pgGISTypeDetails.subtype !== GIS_SUBTYPE.MultiPoint) {
-      return fields;
-    }
-
-    const {
-      extend,
-      getPostgisTypeByGeometryType,
-      graphql: {
-        GraphQLList
-      }
-    } = build;
-    const {
-      hasZ,
-      hasM,
-      srid
-    } = pgGISTypeDetails;
-    const Point = getPostgisTypeByGeometryType(pgGISType, GIS_SUBTYPE.Point, hasZ, hasM, srid);
-    return extend(fields, {
-      points: {
-        type: new GraphQLList(Point),
-
-        resolve(data) {
-          return data.__geojson.coordinates.map(coord => ({
-            __gisType: getGISTypeName(GIS_SUBTYPE.Point, hasZ, hasM),
-            __srid: data.__srid,
-            __geojson: {
-              type: 'Point',
-              coordinates: coord
-            }
-          }));
-        }
-
-      }
-    });
-  });
-};
-
-export default plugin;

package/module/Postgis_MultiPolygon_PolygonsPlugin.js

@@ -1,51 +0,0 @@
-import { GIS_SUBTYPE } from './constants';
-import { getGISTypeName } from './utils';
-
-const plugin = builder => {
-  builder.hook('GraphQLObjectType:fields', (fields, build, context) => {
-    const {
-      scope: {
-        isPgGISType,
-        pgGISType,
-        pgGISTypeDetails
-      }
-    } = context;
-
-    if (!isPgGISType || !pgGISTypeDetails || pgGISTypeDetails.subtype !== GIS_SUBTYPE.MultiPolygon) {
-      return fields;
-    }
-
-    const {
-      extend,
-      getPostgisTypeByGeometryType,
-      graphql: {
-        GraphQLList
-      }
-    } = build;
-    const {
-      hasZ,
-      hasM,
-      srid
-    } = pgGISTypeDetails;
-    const Polygon = getPostgisTypeByGeometryType(pgGISType, GIS_SUBTYPE.Polygon, hasZ, hasM, srid);
-    return extend(fields, {
-      polygons: {
-        type: new GraphQLList(Polygon),
-
-        resolve(data) {
-          return data.__geojson.coordinates.map(coord => ({
-            __gisType: getGISTypeName(GIS_SUBTYPE.Polygon, hasZ, hasM),
-            __srid: data.__srid,
-            __geojson: {
-              type: 'Polygon',
-              coordinates: coord
-            }
-          }));
-        }
-
-      }
-    });
-  });
-};
-
-export default plugin;

package/module/Postgis_Point_LatitudeLongitudePlugin.js

@@ -1,64 +0,0 @@
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
-
-import { GIS_SUBTYPE } from './constants';
-
-const plugin = builder => {
-  builder.hook('GraphQLObjectType:fields', (fields, build, context) => {
-    const {
-      scope: {
-        isPgGISType,
-        pgGISType,
-        pgGISTypeDetails
-      }
-    } = context;
-
-    if (!isPgGISType || !pgGISTypeDetails || pgGISTypeDetails.subtype !== GIS_SUBTYPE.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, _objectSpread({
-      [xFieldName]: {
-        type: new GraphQLNonNull(GraphQLFloat),
-
-        resolve(data) {
-          return data.__geojson.coordinates[0];
-        }
-
-      },
-      [yFieldName]: {
-        type: new GraphQLNonNull(GraphQLFloat),
-
-        resolve(data) {
-          return data.__geojson.coordinates[1];
-        }
-
-      }
-    }, pgGISTypeDetails.hasZ ? {
-      [zFieldName]: {
-        type: new GraphQLNonNull(GraphQLFloat),
-
-        resolve(data) {
-          return data.__geojson.coordinates[2];
-        }
-
-      }
-    } : {}));
-  });
-};
-
-export default plugin;

package/module/Postgis_Polygon_RingsPlugin.js

@@ -1,66 +0,0 @@
-import { GIS_SUBTYPE } from './constants';
-import { getGISTypeName } from './utils';
-
-const plugin = builder => {
-  builder.hook('GraphQLObjectType:fields', (fields, build, context) => {
-    const {
-      scope: {
-        isPgGISType,
-        pgGISType,
-        pgGISTypeDetails
-      }
-    } = context;
-
-    if (!isPgGISType || !pgGISTypeDetails || pgGISTypeDetails.subtype !== GIS_SUBTYPE.Polygon) {
-      return fields;
-    }
-
-    const {
-      extend,
-      getPostgisTypeByGeometryType,
-      graphql: {
-        GraphQLList
-      }
-    } = build;
-    const {
-      hasZ,
-      hasM,
-      srid
-    } = pgGISTypeDetails;
-    const LineString = getPostgisTypeByGeometryType(pgGISType, GIS_SUBTYPE.LineString, hasZ, hasM, srid);
-    return extend(fields, {
-      exterior: {
-        type: LineString,
-
-        resolve(data) {
-          return {
-            __gisType: getGISTypeName(GIS_SUBTYPE.LineString, hasZ, hasM),
-            __srid: data.__srid,
-            __geojson: {
-              type: 'LineString',
-              coordinates: data.__geojson.coordinates[0]
-            }
-          };
-        }
-
-      },
-      interiors: {
-        type: new GraphQLList(LineString),
-
-        resolve(data) {
-          return data.__geojson.coordinates.slice(1).map(coord => ({
-            __gisType: getGISTypeName(GIS_SUBTYPE.LineString, hasZ, hasM),
-            __srid: data.__srid,
-            __geojson: {
-              type: 'LineString',
-              coordinates: coord
-            }
-          }));
-        }
-
-      }
-    });
-  });
-};
-
-export default plugin;

package/module/constants.js

@@ -1,30 +0,0 @@
-export const SUBTYPE_STRING_BY_SUBTYPE = {
-  0: 'geometry',
-  1: 'point',
-  2: 'line-string',
-  3: 'polygon',
-  4: 'multi-point',
-  5: 'multi-line-string',
-  6: 'multi-polygon',
-  7: 'geometry-collection'
-};
-export const GIS_SUBTYPE = {
-  Geometry: 0,
-  Point: 1,
-  LineString: 2,
-  Polygon: 3,
-  MultiPoint: 4,
-  MultiLineString: 5,
-  MultiPolygon: 6,
-  GeometryCollection: 7
-};
-export const GIS_SUBTYPE_NAME = {
-  0: 'Geometry',
-  1: 'Point',
-  2: 'LineString',
-  3: 'Polygon',
-  4: 'MultiPoint',
-  5: 'MultiLineString',
-  6: 'MultiPolygon',
-  7: 'GeometryCollection'
-};