graphile-plugin-connection-filter-postgis 2.1.0 → 2.2.0

package/index.js

@@ -1,30 +1,24 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
+/**
+ * PostGIS Connection Filter Plugin for PostGraphile v5
+ *
+ * Adds PostGIS spatial filter operators (ST_Contains, ST_Intersects, etc.)
+ * to postgraphile-plugin-connection-filter.
+ *
+ * @example
+ * ```typescript
+ * import { PostgisConnectionFilterPreset } from 'graphile-plugin-connection-filter-postgis';
+ *
+ * const preset = {
+ *   extends: [PostgisConnectionFilterPreset]
+ * };
+ * ```
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PostGraphileConnectionFilterPostgisPlugin = void 0;
-const find_and_require_package_json_1 = require("find-and-require-package-json");
-const PgConnectionArgFilterPostgisOperatorsPlugin_1 = __importDefault(require("./PgConnectionArgFilterPostgisOperatorsPlugin"));
-const pkg = (0, find_and_require_package_json_1.findAndRequirePackageJson)(__dirname);
-const PostGraphileConnectionFilterPostgisPlugin = (builder, options) => {
-    builder.hook("build", (build) => {
-        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.5.0");
-        depends("graphile-plugin-connection-filter", "^3.0.0");
-        build.versions = build.extend(build.versions, { [pkg.name]: pkg.version });
-        return build;
-    });
-    (0, PgConnectionArgFilterPostgisOperatorsPlugin_1.default)(builder, options);
-};
-exports.PostGraphileConnectionFilterPostgisPlugin = PostGraphileConnectionFilterPostgisPlugin;
-exports.default = PostGraphileConnectionFilterPostgisPlugin;
+exports.PgConnectionArgFilterPostgisOperatorsPlugin = exports.PostgisConnectionFilterPreset = void 0;
+// Preset (recommended entry point)
+var preset_1 = require("./preset");
+Object.defineProperty(exports, "PostgisConnectionFilterPreset", { enumerable: true, get: function () { return preset_1.PostgisConnectionFilterPreset; } });
+// Plugin
+var plugin_1 = require("./plugin");
+Object.defineProperty(exports, "PgConnectionArgFilterPostgisOperatorsPlugin", { enumerable: true, get: function () { return plugin_1.PgConnectionArgFilterPostgisOperatorsPlugin; } });

package/package.json

@@ -1,23 +1,13 @@
 {
   "name": "graphile-plugin-connection-filter-postgis",
-  "version": "2.1.0",
-  "description": "PostGIS filtering options in PostGraphile",
-  "author": "Matt Bretl",
-  "homepage": "https://github.com/constructive-io/constructive",
-  "license": "MIT",
+  "version": "2.2.0",
+  "author": "Constructive <developers@constructive.io>",
+  "description": "PostGIS operators for postgraphile-plugin-connection-filter (PostGraphile v5)",
   "main": "index.js",
   "module": "esm/index.js",
   "types": "index.d.ts",
-  "scripts": {
-    "clean": "makage clean",
-    "copy": "makage assets",
-    "prepack": "pnpm run build",
-    "build": "makage build",
-    "build:dev": "makage build --dev",
-    "lint": "eslint . --fix",
-    "test": "jest --passWithNoTests",
-    "test:watch": "jest --watch"
-  },
+  "homepage": "https://github.com/constructive-io/constructive",
+  "license": "MIT",
   "publishConfig": {
     "access": "public",
     "directory": "dist"
@@ -29,35 +19,49 @@
   "bugs": {
     "url": "https://github.com/constructive-io/constructive/issues"
   },
-  "keywords": [
-    "postgraphile",
-    "graphile",
-    "plugin",
-    "postgres",
-    "postgresql",
-    "postgis",
-    "filters",
-    "constructive",
-    "pgpm"
-  ],
-  "dependencies": {
-    "find-and-require-package-json": "^0.9.0",
-    "graphile-build": "^4.14.1",
-    "graphile-build-pg": "^4.14.1",
-    "graphile-plugin-connection-filter": "^3.1.0",
-    "graphile-postgis": "^1.1.0"
+  "scripts": {
+    "clean": "makage clean",
+    "prepack": "npm run build",
+    "build": "makage build",
+    "build:dev": "makage build --dev",
+    "lint": "eslint . --fix",
+    "test": "jest",
+    "test:watch": "jest --watch"
   },
   "peerDependencies": {
-    "postgraphile": "^4.14.1"
+    "graphile-build": "^5.0.0-rc.4",
+    "graphile-config": "^1.0.0-rc.5",
+    "graphile-postgis": "^2.0.0",
+    "graphql": "^16.9.0",
+    "pg-sql2": "^5.0.0-rc.4",
+    "postgraphile": "^5.0.0-rc.4",
+    "postgraphile-plugin-connection-filter": "^3.0.0-rc.1"
+  },
+  "peerDependenciesMeta": {
+    "postgraphile-plugin-connection-filter": {
+      "optional": false
+    },
+    "graphile-postgis": {
+      "optional": false
+    }
   },
   "devDependencies": {
-    "@types/pg": "^8.16.0",
-    "graphile-test": "^3.1.0",
-    "graphql": "15.10.1",
-    "makage": "^0.1.12",
-    "pg": "^8.17.1",
-    "pgsql-test": "^3.1.0",
-    "postgraphile": "^4.14.1"
+    "@types/node": "^22.19.1",
+    "graphile-postgis": "^2.2.0",
+    "graphile-test": "^4.2.0",
+    "makage": "^0.1.10",
+    "postgraphile-plugin-connection-filter": "^3.0.0-rc.1"
   },
-  "gitHead": "048188f6b43ffaa6146e7694b2b0d35d34cb2945"
+  "keywords": [
+    "postgraphile",
+    "graphql",
+    "postgresql",
+    "postgis",
+    "connection-filter",
+    "spatial",
+    "geometry",
+    "geography",
+    "constructive"
+  ],
+  "gitHead": "b758178b808ce0bf451e86c0bd7e92079155db7c"
 }

package/plugin.d.ts

@@ -0,0 +1,14 @@
+import 'graphile-build';
+import type { GraphileConfig } from 'graphile-config';
+/**
+ * PgConnectionArgFilterPostgisOperatorsPlugin
+ *
+ * Adds PostGIS spatial filter operators to postgraphile-plugin-connection-filter.
+ *
+ * Includes:
+ * - ST_ function-based operators (contains, intersects, within, etc.)
+ * - SQL operator-based operators (&&, =, ~, etc. for bounding box ops)
+ *
+ * Requires graphile-postgis and postgraphile-plugin-connection-filter to be loaded.
+ */
+export declare const PgConnectionArgFilterPostgisOperatorsPlugin: GraphileConfig.Plugin;

package/plugin.js

@@ -0,0 +1,286 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PgConnectionArgFilterPostgisOperatorsPlugin = void 0;
+require("graphile-build");
+const pg_sql2_1 = __importDefault(require("pg-sql2"));
+const graphile_postgis_1 = require("graphile-postgis");
+const ALLOWED_SQL_OPERATORS = new Set([
+    '=',
+    '&&',
+    '&&&',
+    '&<',
+    '&<|',
+    '&>',
+    '|&>',
+    '<<',
+    '<<|',
+    '>>',
+    '|>>',
+    '~',
+    '~=',
+]);
+/**
+ * PgConnectionArgFilterPostgisOperatorsPlugin
+ *
+ * Adds PostGIS spatial filter operators to postgraphile-plugin-connection-filter.
+ *
+ * Includes:
+ * - ST_ function-based operators (contains, intersects, within, etc.)
+ * - SQL operator-based operators (&&, =, ~, etc. for bounding box ops)
+ *
+ * Requires graphile-postgis and postgraphile-plugin-connection-filter to be loaded.
+ */
+exports.PgConnectionArgFilterPostgisOperatorsPlugin = {
+    name: 'PgConnectionArgFilterPostgisOperatorsPlugin',
+    version: '2.0.0',
+    description: 'Adds PostGIS spatial filter operators to connection filter',
+    after: [
+        'PostgisRegisterTypesPlugin',
+        'PostgisExtensionDetectionPlugin',
+        'PostgisInflectionPlugin',
+        'PgConnectionArgFilterPlugin'
+    ],
+    schema: {
+        hooks: {
+            init(_, build) {
+                const postgisInfo = build.pgGISExtensionInfo;
+                if (!postgisInfo) {
+                    return _;
+                }
+                const addConnectionFilterOperator = build.addConnectionFilterOperator;
+                if (typeof addConnectionFilterOperator !== 'function') {
+                    return _;
+                }
+                const { inflection } = build;
+                const { schemaName, geometryCodec, geographyCodec } = postgisInfo;
+                // Collect all GQL type names for geometry and geography
+                const gqlTypeNamesByBase = {
+                    geometry: [],
+                    geography: []
+                };
+                const codecPairs = [['geometry', geometryCodec]];
+                if (geographyCodec) {
+                    codecPairs.push(['geography', geographyCodec]);
+                }
+                for (const [baseKey, codec] of codecPairs) {
+                    const typeName = codec.name;
+                    gqlTypeNamesByBase[baseKey].push(inflection.gisInterfaceName(typeName));
+                    for (const subtype of graphile_postgis_1.CONCRETE_SUBTYPES) {
+                        for (const hasZ of [false, true]) {
+                            for (const hasM of [false, true]) {
+                                gqlTypeNamesByBase[baseKey].push(inflection.gisType(typeName, subtype, hasZ, hasM, 0));
+                            }
+                        }
+                    }
+                }
+                // PostGIS function-based operators
+                const functionSpecs = [
+                    [
+                        'ST_3DIntersects',
+                        ['geometry'],
+                        'intersects3D',
+                        'They share any portion of space in 3D.'
+                    ],
+                    [
+                        'ST_Contains',
+                        ['geometry'],
+                        'contains',
+                        'No points of the specified geometry lie in the exterior, and at least one point of the interior of the specified geometry lies in the interior.'
+                    ],
+                    [
+                        'ST_ContainsProperly',
+                        ['geometry'],
+                        'containsProperly',
+                        'The specified geometry intersects the interior but not the boundary (or exterior).'
+                    ],
+                    [
+                        'ST_CoveredBy',
+                        ['geometry', 'geography'],
+                        'coveredBy',
+                        'No point is outside the specified geometry.'
+                    ],
+                    [
+                        'ST_Covers',
+                        ['geometry', 'geography'],
+                        'covers',
+                        'No point in the specified geometry is outside.'
+                    ],
+                    [
+                        'ST_Crosses',
+                        ['geometry'],
+                        'crosses',
+                        'They have some, but not all, interior points in common.'
+                    ],
+                    [
+                        'ST_Disjoint',
+                        ['geometry'],
+                        'disjoint',
+                        'They do not share any space together.'
+                    ],
+                    [
+                        'ST_Equals',
+                        ['geometry'],
+                        'equals',
+                        'They represent the same geometry. Directionality is ignored.'
+                    ],
+                    [
+                        'ST_Intersects',
+                        ['geometry', 'geography'],
+                        'intersects',
+                        'They share any portion of space in 2D.'
+                    ],
+                    [
+                        'ST_OrderingEquals',
+                        ['geometry'],
+                        'orderingEquals',
+                        'They represent the same geometry and points are in the same directional order.'
+                    ],
+                    [
+                        'ST_Overlaps',
+                        ['geometry'],
+                        'overlaps',
+                        'They share space, are of the same dimension, but are not completely contained by each other.'
+                    ],
+                    [
+                        'ST_Touches',
+                        ['geometry'],
+                        'touches',
+                        'They have at least one point in common, but their interiors do not intersect.'
+                    ],
+                    [
+                        'ST_Within',
+                        ['geometry'],
+                        'within',
+                        'Completely inside the specified geometry.'
+                    ]
+                ];
+                // SQL operator-based operators
+                const operatorSpecs = [
+                    [
+                        '=',
+                        ['geometry', 'geography'],
+                        'exactlyEquals',
+                        'Coordinates and coordinate order are the same as specified geometry.'
+                    ],
+                    [
+                        '&&',
+                        ['geometry', 'geography'],
+                        'bboxIntersects2D',
+                        "2D bounding box intersects the specified geometry's 2D bounding box."
+                    ],
+                    [
+                        '&&&',
+                        ['geometry'],
+                        'bboxIntersectsND',
+                        "n-D bounding box intersects the specified geometry's n-D bounding box."
+                    ],
+                    [
+                        '&<',
+                        ['geometry'],
+                        'bboxOverlapsOrLeftOf',
+                        "Bounding box overlaps or is to the left of the specified geometry's bounding box."
+                    ],
+                    [
+                        '&<|',
+                        ['geometry'],
+                        'bboxOverlapsOrBelow',
+                        "Bounding box overlaps or is below the specified geometry's bounding box."
+                    ],
+                    [
+                        '&>',
+                        ['geometry'],
+                        'bboxOverlapsOrRightOf',
+                        "Bounding box overlaps or is to the right of the specified geometry's bounding box."
+                    ],
+                    [
+                        '|&>',
+                        ['geometry'],
+                        'bboxOverlapsOrAbove',
+                        "Bounding box overlaps or is above the specified geometry's bounding box."
+                    ],
+                    [
+                        '<<',
+                        ['geometry'],
+                        'bboxLeftOf',
+                        "Bounding box is strictly to the left of the specified geometry's bounding box."
+                    ],
+                    [
+                        '<<|',
+                        ['geometry'],
+                        'bboxBelow',
+                        "Bounding box is strictly below the specified geometry's bounding box."
+                    ],
+                    [
+                        '>>',
+                        ['geometry'],
+                        'bboxRightOf',
+                        "Bounding box is strictly to the right of the specified geometry's bounding box."
+                    ],
+                    [
+                        '|>>',
+                        ['geometry'],
+                        'bboxAbove',
+                        "Bounding box is strictly above the specified geometry's bounding box."
+                    ],
+                    [
+                        '~',
+                        ['geometry'],
+                        'bboxContains',
+                        "Bounding box contains the specified geometry's bounding box."
+                    ],
+                    [
+                        '~=',
+                        ['geometry'],
+                        'bboxEquals',
+                        "Bounding box is the same as the specified geometry's bounding box."
+                    ]
+                ];
+                const allSpecs = [];
+                // Process function-based operators
+                for (const [fn, baseTypes, operatorName, description] of functionSpecs) {
+                    for (const baseType of baseTypes) {
+                        const sqlGisFunction = pg_sql2_1.default.identifier(schemaName, fn.toLowerCase());
+                        allSpecs.push({
+                            typeNames: gqlTypeNamesByBase[baseType],
+                            operatorName,
+                            description,
+                            resolve: (i, v) => pg_sql2_1.default.fragment `${sqlGisFunction}(${i}, ${v})`
+                        });
+                    }
+                }
+                // Process SQL operator-based operators
+                for (const [op, baseTypes, operatorName, description] of operatorSpecs) {
+                    if (!ALLOWED_SQL_OPERATORS.has(op)) {
+                        throw new Error(`Unexpected SQL operator: ${op}`);
+                    }
+                    for (const baseType of baseTypes) {
+                        allSpecs.push({
+                            typeNames: gqlTypeNamesByBase[baseType],
+                            operatorName,
+                            description,
+                            resolve: (i, v) => pg_sql2_1.default.fragment `${i} ${pg_sql2_1.default.raw(op)} ${v}`
+                        });
+                    }
+                }
+                // Sort by operator name for deterministic schema output
+                allSpecs.sort((a, b) => a.operatorName.localeCompare(b.operatorName));
+                // Register each operator with the connection filter plugin
+                for (const spec of allSpecs) {
+                    for (const typeName of spec.typeNames) {
+                        addConnectionFilterOperator(typeName, spec.operatorName, {
+                            description: spec.description,
+                            resolveType: (fieldType) => fieldType,
+                            resolve(sqlIdentifier, sqlValue, _input, _$where, _details) {
+                                return spec.resolve(sqlIdentifier, sqlValue);
+                            }
+                        });
+                    }
+                }
+                return _;
+            }
+        }
+    }
+};

package/preset.d.ts

@@ -0,0 +1,23 @@
+import type { GraphileConfig } from 'graphile-config';
+/**
+ * PostGIS Connection Filter Preset
+ *
+ * Adds PostGIS spatial filter operators to postgraphile-plugin-connection-filter.
+ * Requires graphile-postgis and postgraphile-plugin-connection-filter to be loaded.
+ *
+ * @example
+ * ```typescript
+ * import { GraphilePostgisPreset } from 'graphile-postgis';
+ * import { PostGraphileConnectionFilterPreset } from 'postgraphile-plugin-connection-filter';
+ * import { PostgisConnectionFilterPreset } from 'graphile-plugin-connection-filter-postgis';
+ *
+ * const preset = {
+ *   extends: [
+ *     GraphilePostgisPreset,
+ *     PostGraphileConnectionFilterPreset,
+ *     PostgisConnectionFilterPreset
+ *   ]
+ * };
+ * ```
+ */
+export declare const PostgisConnectionFilterPreset: GraphileConfig.Preset;

package/preset.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostgisConnectionFilterPreset = void 0;
+const plugin_1 = require("./plugin");
+/**
+ * PostGIS Connection Filter Preset
+ *
+ * Adds PostGIS spatial filter operators to postgraphile-plugin-connection-filter.
+ * Requires graphile-postgis and postgraphile-plugin-connection-filter to be loaded.
+ *
+ * @example
+ * ```typescript
+ * import { GraphilePostgisPreset } from 'graphile-postgis';
+ * import { PostGraphileConnectionFilterPreset } from 'postgraphile-plugin-connection-filter';
+ * import { PostgisConnectionFilterPreset } from 'graphile-plugin-connection-filter-postgis';
+ *
+ * const preset = {
+ *   extends: [
+ *     GraphilePostgisPreset,
+ *     PostGraphileConnectionFilterPreset,
+ *     PostgisConnectionFilterPreset
+ *   ]
+ * };
+ * ```
+ */
+exports.PostgisConnectionFilterPreset = {
+    plugins: [plugin_1.PgConnectionArgFilterPostgisOperatorsPlugin]
+};

package/types.d.ts

@@ -0,0 +1,23 @@
+import type { SQL } from 'pg-sql2';
+export interface PostgisFilterOperatorSpec {
+    /** PostGIS SQL function name (e.g. 'ST_Contains') */
+    sqlFunction?: string;
+    /** SQL operator (e.g. '&&', '=') — used instead of sqlFunction for operator-based specs */
+    sqlOperator?: string;
+    /** GraphQL filter operator name (e.g. 'contains', 'bboxIntersects2D') */
+    operatorName: string;
+    /** Human-readable description of the operator */
+    description: string;
+    /** Which base types this operator applies to: 'geometry', 'geography', or both */
+    baseTypes: ('geometry' | 'geography')[];
+}
+export interface ResolvedFilterSpec {
+    /** GraphQL type names this operator applies to (interface + all concrete types) */
+    typeNames: string[];
+    /** GraphQL filter operator name */
+    operatorName: string;
+    /** Description */
+    description: string;
+    /** SQL resolve function: (identifier, value) => SQL expression */
+    resolve: (i: SQL, v: SQL) => SQL;
+}

package/types.js

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

package/PgConnectionArgFilterPostgisOperatorsPlugin.d.ts

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