graphile-postgis 0.0.1 → 0.1.1

package/module/PostgisRegisterTypesPlugin.js

@@ -1,268 +0,0 @@
-import { getGISTypeDetails, getGISTypeModifier, getGISTypeName } from "./utils";
-import { SQL } from "pg-sql2";
-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 _;
-    }
-
-    debug("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;
-      debug(`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];
-    }
-
-    debug(`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);
-    });
-    debug(`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/PostgisVersionPlugin.js

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

package/module/Postgis_GeometryCollection_GeometriesPlugin.js

@@ -1,55 +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
-    } = 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;