graphile-postgis 1.1.1 → 2.2.0

package/plugins/register-types.js

@@ -0,0 +1,325 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostgisRegisterTypesPlugin = void 0;
+require("graphile-build");
+require("graphile-build-pg");
+const pg_sql2_1 = __importDefault(require("pg-sql2"));
+const constants_1 = require("../constants");
+const utils_1 = require("../utils");
+// Import types.ts for the Build/Inflection/Scope augmentation side effects
+require("../types");
+/**
+ * PostgisRegisterTypesPlugin
+ *
+ * The core plugin that:
+ * 1. Registers a GeoJSON scalar type
+ * 2. Creates GraphQL interfaces for geometry/geography base types
+ * 3. Creates GraphQL interfaces for each dimension combination (XY, XYZ, XYM, XYZM)
+ * 4. Creates concrete GraphQL object types for each subtype/dimension combo
+ * 5. Registers codec-to-type mappings so PostGraphile knows how to handle
+ *    geometry/geography columns
+ *
+ * In v5, type registration is done during the init hook using
+ * build.registerObjectType / build.registerInterfaceType / build.registerScalarType.
+ *
+ * The SQL tweak wraps geometry/geography values in json_build_object() containing
+ * __gisType, __srid, and __geojson fields, which downstream resolvers use.
+ */
+exports.PostgisRegisterTypesPlugin = {
+    name: 'PostgisRegisterTypesPlugin',
+    version: '2.0.0',
+    description: 'Registers PostGIS GeoJSON scalar and geometry/geography types',
+    after: ['PostgisExtensionDetectionPlugin', 'PostgisInflectionPlugin'],
+    schema: {
+        hooks: {
+            init(_, build) {
+                const postgisInfo = build.pgGISExtensionInfo;
+                if (!postgisInfo) {
+                    return _;
+                }
+                const { inflection, graphql: { GraphQLInt, GraphQLNonNull, Kind } } = build;
+                const constructedTypes = build.pgGISGraphQLTypesByCodecAndSubtype;
+                if (!constructedTypes) {
+                    return _;
+                }
+                const { geometryCodec, geographyCodec } = postgisInfo;
+                // Register the GeoJSON scalar type
+                build.registerScalarType('GeoJSON', {}, () => ({
+                    description: 'The `GeoJSON` scalar type represents GeoJSON values as specified by ' +
+                        '[RFC 7946](https://tools.ietf.org/html/rfc7946).',
+                    serialize: (value) => value,
+                    parseValue: (value) => {
+                        if (value === null || value === undefined)
+                            return value;
+                        if (typeof value !== 'object' || Array.isArray(value)) {
+                            throw new TypeError('GeoJSON must be an object');
+                        }
+                        const obj = value;
+                        if (typeof obj.type !== 'string') {
+                            throw new TypeError('GeoJSON must have a "type" string property');
+                        }
+                        if (obj.type === 'Feature' || obj.type === 'FeatureCollection') {
+                            throw new TypeError(`GeoJSON type "${obj.type}" is not supported for PostGIS geometry input. Extract the geometry from your Feature first.`);
+                        }
+                        const validTypes = ['Point', 'MultiPoint', 'LineString', 'MultiLineString', 'Polygon', 'MultiPolygon', 'GeometryCollection'];
+                        if (!validTypes.includes(obj.type)) {
+                            throw new TypeError(`GeoJSON type "${obj.type}" is not a recognized GeoJSON type`);
+                        }
+                        return value;
+                    },
+                    parseLiteral(ast, variables) {
+                        return parseLiteralGeoJSON(ast, variables, Kind);
+                    }
+                }), 'PostgisRegisterTypesPlugin registering GeoJSON scalar');
+                // Process geometry and (optionally) geography types
+                const gisCodecs = [geometryCodec, geographyCodec].filter((c) => c !== null);
+                for (const gisCodec of gisCodecs) {
+                    const key = gisCodec.name;
+                    const typeName = gisCodec.name;
+                    if (!constructedTypes[key]) {
+                        constructedTypes[key] = {};
+                    }
+                    // Register the main interface (no dimensional constraint)
+                    const mainInterfaceName = inflection.gisInterfaceName(typeName);
+                    build.registerInterfaceType(mainInterfaceName, {
+                        isPgGISInterface: true,
+                        pgGISCodecName: typeName,
+                        pgGISZMFlag: -1
+                    }, () => ({
+                        description: `All ${typeName} types implement this interface`,
+                        fields: () => {
+                            const geoJsonType = build.getTypeByName('GeoJSON');
+                            if (!geoJsonType) {
+                                throw new Error('PostGIS: GeoJSON scalar type not found.');
+                            }
+                            return {
+                                [inflection.geojsonFieldName()]: {
+                                    type: geoJsonType,
+                                    description: 'Converts the object to GeoJSON'
+                                },
+                                srid: {
+                                    type: new GraphQLNonNull(GraphQLInt),
+                                    description: 'Spatial reference identifier (SRID)'
+                                }
+                            };
+                        },
+                        resolveType(value) {
+                            const gisTypeKey = value.__gisType;
+                            const resolvedTypeName = constructedTypes[key]?.[gisTypeKey];
+                            if (typeof resolvedTypeName === 'string') {
+                                return resolvedTypeName;
+                            }
+                            throw new Error(`PostGIS: Could not resolve type for __gisType="${gisTypeKey}" on codec="${key}". Known types: ${Object.keys(constructedTypes[key] ?? {}).join(', ')}`);
+                        }
+                    }), `PostgisRegisterTypesPlugin registering ${mainInterfaceName} interface`);
+                    // Register dimension interfaces (XY, XYZ, XYM, XYZM)
+                    for (const hasZ of [false, true]) {
+                        for (const hasM of [false, true]) {
+                            const zmflag = (hasZ ? 2 : 0) + (hasM ? 1 : 0);
+                            const coords = { 0: 'XY', 1: 'XYM', 2: 'XYZ', 3: 'XYZM' };
+                            const dimInterfaceName = inflection.gisDimensionInterfaceName(typeName, hasZ, hasM);
+                            build.registerInterfaceType(dimInterfaceName, {
+                                isPgGISDimensionInterface: true,
+                                pgGISCodecName: typeName,
+                                pgGISZMFlag: zmflag
+                            }, () => ({
+                                description: `All ${typeName} ${coords[zmflag]} types implement this interface`,
+                                fields: () => {
+                                    const geoJsonType = build.getTypeByName('GeoJSON');
+                                    if (!geoJsonType) {
+                                        throw new Error('PostGIS: GeoJSON scalar type not found.');
+                                    }
+                                    return {
+                                        [inflection.geojsonFieldName()]: {
+                                            type: geoJsonType,
+                                            description: 'Converts the object to GeoJSON'
+                                        },
+                                        srid: {
+                                            type: new GraphQLNonNull(GraphQLInt),
+                                            description: 'Spatial reference identifier (SRID)'
+                                        }
+                                    };
+                                },
+                                resolveType(value) {
+                                    const gisTypeKey = value.__gisType;
+                                    const concreteTypeName = constructedTypes[key]?.[gisTypeKey];
+                                    if (typeof concreteTypeName === 'string') {
+                                        return concreteTypeName;
+                                    }
+                                    throw new Error(`PostGIS: Could not resolve type for __gisType="${gisTypeKey}" on codec="${key}". Known types: ${Object.keys(constructedTypes[key] ?? {}).join(', ')}`);
+                                }
+                            }), `PostgisRegisterTypesPlugin registering ${dimInterfaceName} interface`);
+                            // Register concrete object types for each subtype + this dimension
+                            for (const subtype of constants_1.CONCRETE_SUBTYPES) {
+                                const concreteTypeName = inflection.gisType(typeName, subtype, hasZ, hasM, 0);
+                                const typeModifier = (0, utils_1.getGISTypeModifier)(subtype, hasZ, hasM, 0);
+                                const typeDetails = (0, utils_1.getGISTypeDetails)(typeModifier);
+                                build.registerObjectType(concreteTypeName, {
+                                    isPgGISType: true,
+                                    pgGISCodecName: typeName,
+                                    pgGISTypeDetails: typeDetails
+                                }, () => ({
+                                    description: `A PostGIS ${typeName} ${(0, utils_1.getGISTypeName)(subtype, hasZ, hasM)} type`,
+                                    interfaces: () => [
+                                        build.getTypeByName(mainInterfaceName),
+                                        build.getTypeByName(dimInterfaceName)
+                                    ].filter(Boolean),
+                                    fields: () => {
+                                        const geoJsonType = build.getTypeByName('GeoJSON');
+                                        if (!geoJsonType) {
+                                            throw new Error('PostGIS: GeoJSON scalar type not found.');
+                                        }
+                                        return {
+                                            [inflection.geojsonFieldName()]: {
+                                                type: geoJsonType,
+                                                description: 'Converts the object to GeoJSON',
+                                                resolve(data) {
+                                                    return data.__geojson;
+                                                }
+                                            },
+                                            srid: {
+                                                type: new GraphQLNonNull(GraphQLInt),
+                                                description: 'Spatial reference identifier (SRID)',
+                                                resolve(data) {
+                                                    return data.__srid;
+                                                }
+                                            }
+                                        };
+                                    }
+                                }), `PostgisRegisterTypesPlugin registering ${concreteTypeName} type`);
+                                // Track the type by its gisTypeKey for resolveType lookups
+                                const gisTypeKey = (0, utils_1.getGISTypeName)(subtype, hasZ, hasM);
+                                constructedTypes[key][gisTypeKey] = concreteTypeName;
+                            }
+                            // Map the Geometry subtype (0) for this dimension to the dimension interface
+                            const geomDimKey = (0, utils_1.getGISTypeName)(constants_1.GisSubtype.Geometry, hasZ, hasM);
+                            constructedTypes[key][geomDimKey] = dimInterfaceName;
+                        }
+                    }
+                    // Map null/unspecified modifier to the main interface
+                    constructedTypes[key][-1] = mainInterfaceName;
+                }
+                // Register type mappings so PostGraphile knows what GraphQL types to
+                // use for geometry/geography columns.
+                //
+                // Without BOTH input AND output mappings, PgAttributesPlugin silently
+                // omits geometry columns from the schema:
+                // - Input: GeoJSON scalar (accepts GeoJSON objects)
+                // - Output: The main interface type (e.g. GeometryInterface), which uses
+                //   resolveType to dispatch to concrete types (GeometryPoint, etc.)
+                const { setGraphQLTypeForPgCodec } = build;
+                if (typeof setGraphQLTypeForPgCodec === 'function') {
+                    for (const gisCodec of gisCodecs) {
+                        const mainInterfaceName = inflection.gisInterfaceName(gisCodec.name);
+                        setGraphQLTypeForPgCodec(gisCodec, 'input', 'GeoJSON');
+                        setGraphQLTypeForPgCodec(gisCodec, 'output', mainInterfaceName);
+                    }
+                }
+                return _;
+            },
+            build(build) {
+                const postgisInfo = build.pgGISExtensionInfo;
+                if (!postgisInfo) {
+                    return build;
+                }
+                const { schemaName } = postgisInfo;
+                const constructedTypes = build.pgGISGraphQLTypesByCodecAndSubtype;
+                if (!constructedTypes) {
+                    return build;
+                }
+                return build.extend(build, {
+                    getPostgisTypeByGeometryType(gisCodecName, subtype, hasZ = false, hasM = false, _srid = 0) {
+                        const gisTypeKey = (0, utils_1.getGISTypeName)(subtype, hasZ, hasM);
+                        const resolvedTypeName = constructedTypes[gisCodecName]?.[gisTypeKey];
+                        if (typeof resolvedTypeName === 'string') {
+                            return build.getTypeByName(resolvedTypeName);
+                        }
+                        return undefined;
+                    },
+                    pgGISWrapExpression(fragment) {
+                        // PostGIS function names MUST be lowercase for PostgreSQL identifier matching
+                        const params = [
+                            pg_sql2_1.default.literal('__gisType'),
+                            pg_sql2_1.default.fragment `${pg_sql2_1.default.identifier(schemaName, 'geometrytype')}(${fragment})`,
+                            pg_sql2_1.default.literal('__srid'),
+                            pg_sql2_1.default.fragment `${pg_sql2_1.default.identifier(schemaName, 'st_srid')}(${fragment})`,
+                            pg_sql2_1.default.literal('__geojson'),
+                            pg_sql2_1.default.fragment `${pg_sql2_1.default.identifier(schemaName, 'st_asgeojson')}(${fragment})::JSON`
+                        ];
+                        return pg_sql2_1.default.fragment `(case when ${fragment} is null then null else json_build_object(
+              ${pg_sql2_1.default.join(params, ', ')}
+            ) end)`;
+                    },
+                    pgGISFromGeoJSON(value, codecName) {
+                        const jsonStr = pg_sql2_1.default.value(JSON.stringify(value));
+                        if (codecName === 'geography') {
+                            return pg_sql2_1.default.fragment `${pg_sql2_1.default.identifier(schemaName, 'st_geomfromgeojson')}(${jsonStr}::text)::${pg_sql2_1.default.identifier(schemaName, 'geography')}`;
+                        }
+                        return pg_sql2_1.default.fragment `${pg_sql2_1.default.identifier(schemaName, 'st_geomfromgeojson')}(${jsonStr}::text)`;
+                    }
+                }, 'PostgisRegisterTypesPlugin adding PostGIS helpers to build');
+            },
+            // Add all registered PostGIS concrete types to the schema so they are
+            // discoverable for resolveType on the interfaces. Types registered via
+            // build.registerObjectType() during init are lazy — they are only
+            // materialized when getTypeByName() is called.
+            //
+            // We MUST use GraphQLSchema_types (not GraphQLSchema) because the
+            // GraphQLSchema hook's types property gets overwritten by the
+            // GraphQLSchema_types hook that runs immediately after it.
+            GraphQLSchema_types(types, build) {
+                const constructedTypes = build.pgGISGraphQLTypesByCodecAndSubtype;
+                if (!constructedTypes) {
+                    return types;
+                }
+                for (const codecTypes of Object.values(constructedTypes)) {
+                    for (const typeName of Object.values(codecTypes)) {
+                        if (typeof typeName === 'string') {
+                            const graphqlType = build.getTypeByName(typeName);
+                            if (graphqlType && !types.includes(graphqlType)) {
+                                types.push(graphqlType);
+                            }
+                        }
+                    }
+                }
+                return types;
+            }
+        }
+    }
+};
+/**
+ * Recursively parses a GeoJSON literal from a GraphQL AST.
+ */
+function parseLiteralGeoJSON(ast, variables, Kind, depth = 0) {
+    if (depth > 32) {
+        throw new Error('GeoJSON input exceeds maximum nesting depth');
+    }
+    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] = parseLiteralGeoJSON(field.value, variables, Kind, depth + 1);
+            });
+            return value;
+        }
+        case Kind.LIST:
+            return ast.values.map((n) => parseLiteralGeoJSON(n, variables, Kind, depth + 1));
+        case Kind.NULL:
+            return null;
+        case Kind.VARIABLE: {
+            const variableName = ast.name.value;
+            return variables ? variables[variableName] : undefined;
+        }
+        default:
+            return undefined;
+    }
+}

package/preset.d.ts

@@ -0,0 +1,18 @@
+import type { GraphileConfig } from 'graphile-config';
+/**
+ * GraphilePostgisPreset
+ *
+ * A preset that includes all PostGIS plugins for PostGraphile v5.
+ * Use this as the recommended way to add PostGIS support.
+ *
+ * @example
+ * ```typescript
+ * import { GraphilePostgisPreset } from 'graphile-postgis';
+ *
+ * const preset = {
+ *   extends: [GraphilePostgisPreset]
+ * };
+ * ```
+ */
+export declare const GraphilePostgisPreset: GraphileConfig.Preset;
+export default GraphilePostgisPreset;

package/preset.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphilePostgisPreset = void 0;
+const codec_1 = require("./plugins/codec");
+const inflection_1 = require("./plugins/inflection");
+const detect_extension_1 = require("./plugins/detect-extension");
+const register_types_1 = require("./plugins/register-types");
+const geometry_fields_1 = require("./plugins/geometry-fields");
+/**
+ * GraphilePostgisPreset
+ *
+ * A preset that includes all PostGIS plugins for PostGraphile v5.
+ * Use this as the recommended way to add PostGIS support.
+ *
+ * @example
+ * ```typescript
+ * import { GraphilePostgisPreset } from 'graphile-postgis';
+ *
+ * const preset = {
+ *   extends: [GraphilePostgisPreset]
+ * };
+ * ```
+ */
+exports.GraphilePostgisPreset = {
+    plugins: [
+        codec_1.PostgisCodecPlugin,
+        inflection_1.PostgisInflectionPlugin,
+        detect_extension_1.PostgisExtensionDetectionPlugin,
+        register_types_1.PostgisRegisterTypesPlugin,
+        geometry_fields_1.PostgisGeometryFieldsPlugin
+    ]
+};
+exports.default = exports.GraphilePostgisPreset;

package/types.d.ts

@@ -1,8 +1,7 @@
-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 { PgCodec } from '@dataplan/pg';
 import type { Geometry } from 'geojson';
+import type { GraphQLInterfaceType, GraphQLObjectType } from 'graphql';
+import type { SQL } from 'pg-sql2';
 import type { GisSubtype } from './constants';
 export interface GisTypeDetails {
     subtype: GisSubtype;
@@ -10,50 +9,76 @@ export interface GisTypeDetails {
     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;
+/**
+ * PostGIS extension detection result stored on the build object.
+ */
+export interface PostgisExtensionInfo {
+    /** The schema name where PostGIS is installed (e.g. 'public') */
+    schemaName: string;
+    /** The geometry codec from the registry */
+    geometryCodec: PgCodec;
+    /** The geography codec from the registry (optional — not all databases use geography columns) */
+    geographyCodec: PgCodec | null;
 }
-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;
+/**
+ * Module augmentations for PostGraphile v5 types.
+ *
+ * These declare the custom properties that our PostGIS plugins add to the
+ * build object, inflection, and scope interfaces. This allows downstream
+ * code (including our own plugins) to use these properties without `any` casts.
+ */
+declare global {
+    namespace GraphileBuild {
+        interface Build {
+            /** PostGIS extension info (set by PostgisExtensionDetectionPlugin) */
+            pgGISExtensionInfo?: PostgisExtensionInfo;
+            /** Map of codec name -> gisTypeKey -> GraphQL type name (for resolveType) */
+            pgGISGraphQLTypesByCodecAndSubtype?: Record<string, Record<string | number, string>>;
+            /** Gets a registered PostGIS GraphQL type by geometry type, subtype, and dimension */
+            getPostgisTypeByGeometryType?(gisCodecName: string, subtype: GisSubtype, hasZ?: boolean, hasM?: boolean, srid?: number): GraphQLObjectType | GraphQLInterfaceType | undefined;
+            /** Wraps a geometry/geography SQL expression in json_build_object() with metadata */
+            pgGISWrapExpression?(fragment: SQL): SQL;
+            /** Creates an SQL fragment to convert GeoJSON input to a geometry value */
+            pgGISFromGeoJSON?(value: Record<string, unknown>, codecName: string): SQL;
+        }
+        interface Inflection {
+            /** Generate GraphQL type name for a PostGIS concrete type */
+            gisType(typeName: string, subtype: GisSubtype, hasZ: boolean, hasM: boolean, srid?: number): string;
+            /** Generate interface name for a PostGIS base type (e.g. GeometryInterface) */
+            gisInterfaceName(typeName: string): string;
+            /** Generate dimension interface name (e.g. GeometryGeometryZ) */
+            gisDimensionInterfaceName(typeName: string, hasZ: boolean, hasM: boolean): string;
+            /** Generate GeoJSON field name */
+            geojsonFieldName(): string;
+            /** Generate X coordinate field name */
+            gisXFieldName(typeName: string): string;
+            /** Generate Y coordinate field name */
+            gisYFieldName(typeName: string): string;
+            /** Generate Z coordinate field name */
+            gisZFieldName(typeName: string): string;
+        }
+        interface ScopeObject {
+            /** Whether this is a PostGIS concrete type */
+            isPgGISType?: boolean;
+            /** The codec name (geometry/geography) this type belongs to */
+            pgGISCodecName?: string;
+            /** The type details (subtype, hasZ, hasM, srid) */
+            pgGISTypeDetails?: GisTypeDetails;
+        }
+        interface ScopeInterface {
+            /** Whether this is a PostGIS base interface */
+            isPgGISInterface?: boolean;
+            /** Whether this is a PostGIS dimension interface */
+            isPgGISDimensionInterface?: boolean;
+            /** The codec name (geometry/geography) this interface belongs to */
+            pgGISCodecName?: string;
+            /** The ZM flag (-1 for base, 0-3 for dimension) */
+            pgGISZMFlag?: number;
+        }
+    }
 }

package/utils.d.ts

@@ -1,5 +1,21 @@
 import { GisSubtype } from './constants';
 import type { GisTypeDetails } from './types';
+/**
+ * Decodes a PostGIS type modifier into its component parts.
+ *
+ * Implements the C macro bit layout from liblwgeom.h:
+ * - SRID: bits 8-28
+ * - Subtype: bits 2-7
+ * - hasZ: bit 1
+ * - hasM: bit 0
+ */
 export declare const getGISTypeDetails: (modifier: number) => GisTypeDetails;
+/**
+ * Encodes PostGIS type details into a type modifier integer.
+ */
 export declare const getGISTypeModifier: (subtype: GisSubtype, hasZ: boolean, hasM: boolean, srid: number) => number;
+/**
+ * Returns the GIS type name string for a given subtype and Z/M flags.
+ * E.g. "PointZ", "MultiPolygonZM", "LineString"
+ */
 export declare const getGISTypeName: (subtype: GisSubtype, hasZ: boolean, hasM: boolean) => string;

package/utils.js

@@ -2,6 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getGISTypeName = exports.getGISTypeModifier = exports.getGISTypeDetails = void 0;
 const constants_1 = require("./constants");
+/**
+ * Decodes a PostGIS type modifier into its component parts.
+ *
+ * Implements the C macro bit layout from liblwgeom.h:
+ * - SRID: bits 8-28
+ * - Subtype: bits 2-7
+ * - hasZ: bit 1
+ * - hasM: bit 0
+ */
 const getGISTypeDetails = (modifier) => {
     const allZeroesHopefully = modifier >> 24;
     if (allZeroesHopefully !== 0) {
@@ -27,14 +36,12 @@ const getGISTypeDetails = (modifier) => {
         throw new Error(`Unsupported PostGIS modifier, expected 0-7, received ${subtypeNumeric} (${modifier})`);
     }
     const subtype = subtypeNumeric;
-    return {
-        subtype,
-        hasZ,
-        hasM,
-        srid
-    };
+    return { subtype, hasZ, hasM, srid };
 };
 exports.getGISTypeDetails = getGISTypeDetails;
+/**
+ * Encodes PostGIS type details into a type modifier integer.
+ */
 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)))
@@ -47,6 +54,10 @@ const getGISTypeModifier = (subtype, hasZ, hasM, srid) => {
         (hasM ? 0x00000001 : 0));
 };
 exports.getGISTypeModifier = getGISTypeModifier;
+/**
+ * Returns the GIS type name string for a given subtype and Z/M flags.
+ * E.g. "PointZ", "MultiPolygonZM", "LineString"
+ */
 const getGISTypeName = (subtype, hasZ, hasM) => {
     return `${constants_1.GIS_SUBTYPE_NAME[subtype]}${hasZ ? 'Z' : ''}${hasM ? 'M' : ''}`;
 };

package/PostgisExtensionDetectionPlugin.d.ts

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

package/PostgisExtensionDetectionPlugin.js

@@ -1,28 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const PostgisExtensionDetectionPlugin = (builder) => {
-    builder.hook('build', (build) => {
-        const postgisBuild = build;
-        const { pgIntrospectionResultsByKind: introspectionResultsByKind } = postgisBuild;
-        const pgGISExtension = introspectionResultsByKind.extension.find((extension) => extension.name === 'postgis');
-        // Check we have the postgis extension
-        if (!pgGISExtension) {
-            console.warn('PostGIS extension not found in database; skipping');
-            return postgisBuild;
-        }
-        // Extract the geography and geometry types
-        const pgGISGeometryType = introspectionResultsByKind.type.find((type) => type.name === 'geometry' && type.namespaceId === pgGISExtension.namespaceId);
-        const pgGISGeographyType = introspectionResultsByKind.type.find((type) => type.name === 'geography' && type.namespaceId === pgGISExtension.namespaceId);
-        if (!pgGISGeographyType || !pgGISGeometryType) {
-            throw new Error("PostGIS is installed, but we couldn't find the geometry/geography types!");
-        }
-        return postgisBuild.extend(postgisBuild, {
-            pgGISGraphQLTypesByTypeAndSubtype: {},
-            pgGISGraphQLInterfaceTypesByType: {},
-            pgGISGeometryType,
-            pgGISGeographyType,
-            pgGISExtension
-        });
-    });
-};
-exports.default = PostgisExtensionDetectionPlugin;

package/PostgisInflectionPlugin.d.ts

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

package/PostgisInflectionPlugin.js

@@ -1,36 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const constants_1 = require("./constants");
-const PostgisInflectionPlugin = (builder) => {
-    builder.hook('inflection', (inflection) => {
-        return {
-            ...inflection,
-            gisType(type, subtype, hasZ, hasM, _srid) {
-                return this.upperCamelCase([type.name, constants_1.SUBTYPE_STRING_BY_SUBTYPE[subtype], hasZ ? 'z' : null, hasM ? 'm' : null]
-                    .filter(Boolean)
-                    .join('-'));
-            },
-            gisInterfaceName(type) {
-                return this.upperCamelCase(`${type.name}-interface`);
-            },
-            gisDimensionInterfaceName(type, hasZ, hasM) {
-                return this.upperCamelCase([type.name, constants_1.SUBTYPE_STRING_BY_SUBTYPE[constants_1.GisSubtype.Geometry], hasZ ? 'z' : null, hasM ? 'm' : null]
-                    .filter(Boolean)
-                    .join('-'));
-            },
-            geojsonFieldName() {
-                return 'geojson';
-            },
-            gisXFieldName(_type) {
-                return _type.name === 'geography' ? 'longitude' : 'x';
-            },
-            gisYFieldName(_type) {
-                return _type.name === 'geography' ? 'latitude' : 'y';
-            },
-            gisZFieldName(_type) {
-                return _type.name === 'geography' ? 'height' : 'z';
-            }
-        };
-    });
-};
-exports.default = PostgisInflectionPlugin;