Merge pull request #950 from constructive-io/fix/meta-geometry-v5

Add PostGraphile v5 geometry subtype metadata to _meta

Author: pyramation

graphile/graphile-postgis/__tests__/codec.test.ts

@@ -1,6 +1,8 @@
 import type { PgCodec } from '@dataplan/pg';
 import { PostgisCodecPlugin } from '../src/plugins/codec';
 import type { GisFieldValue } from '../src/types';
+import { GisSubtype } from '../src/constants';
+import { getGISTypeModifier } from '../src/utils';
 
 // Test event shape matching the GatherHooks.pgCodecs_findPgCodec event
 interface MockEvent {
@@ -242,4 +244,83 @@ describe('PostgisCodecPlugin', () => {
       });
     });
   });
+
+  describe('pgCodecs_attribute hook', () => {
+    const attributeHook = (PostgisCodecPlugin as { gather: { hooks: { pgCodecs_attribute: Function } } })
+      .gather.hooks.pgCodecs_attribute;
+
+    async function runAttributeHook({
+      codecName,
+      typmod,
+      withExtensions = true,
+    }: {
+      codecName: string;
+      typmod: number | null;
+      withExtensions?: boolean;
+    }) {
+      const attribute: Record<string, any> = { codec: { name: codecName } };
+      if (withExtensions) {
+        attribute.extensions = {};
+      }
+      const event = { pgAttribute: { atttypmod: typmod }, attribute };
+
+      await attributeHook({}, event);
+      return attribute;
+    }
+
+    it.each([
+      ['geometry', GisSubtype.Polygon, 'Polygon'],
+      ['geometry', GisSubtype.Point, 'Point'],
+      ['geography', GisSubtype.MultiPolygon, 'MultiPolygon'],
+    ])('stores geometrySubtype for %s subtype %s', async (codecName, subtype, expected) => {
+      const attribute = await runAttributeHook({
+        codecName,
+        typmod: getGISTypeModifier(subtype, false, false, 4326),
+      });
+
+      expect(attribute.extensions.geometrySubtype).toBe(expected);
+    });
+
+    it('should skip unconstrained geometry (atttypmod = -1)', async () => {
+      const attribute = await runAttributeHook({
+        codecName: 'geometry',
+        typmod: -1,
+      });
+      expect(attribute.extensions.geometrySubtype).toBeUndefined();
+    });
+
+    it('should skip when atttypmod is null', async () => {
+      const attribute = await runAttributeHook({
+        codecName: 'geometry',
+        typmod: null,
+      });
+      expect(attribute.extensions.geometrySubtype).toBeUndefined();
+    });
+
+    it('should not store subtype for base Geometry (subtype=0)', async () => {
+      const attribute = await runAttributeHook({
+        codecName: 'geometry',
+        typmod: getGISTypeModifier(GisSubtype.Geometry, false, false, 4326),
+      });
+      expect(attribute.extensions.geometrySubtype).toBeUndefined();
+    });
+
+    it('should skip non-geometry codec types', async () => {
+      const attribute = await runAttributeHook({
+        codecName: 'text',
+        typmod: getGISTypeModifier(GisSubtype.Point, false, false, 4326),
+      });
+      expect(attribute.extensions.geometrySubtype).toBeUndefined();
+    });
+
+    it('should create extensions object if not present', async () => {
+      const attribute = await runAttributeHook({
+        codecName: 'geometry',
+        typmod: getGISTypeModifier(GisSubtype.LineString, false, false, 4326),
+        withExtensions: false,
+      });
+      expect(attribute.extensions).toBeDefined();
+      expect(attribute.extensions.geometrySubtype).toBe('LineString');
+    });
+  });
 });

graphile/graphile-postgis/src/plugins/codec.ts

@@ -3,7 +3,9 @@ import type { PgCodec } from '@dataplan/pg';
 import type { GraphileConfig } from 'graphile-config';
 import type { SQL } from 'pg-sql2';
 import sql from 'pg-sql2';
+import { GIS_SUBTYPE_NAME } from '../constants';
 import type { GisFieldValue } from '../types';
+import { getGISTypeDetails } from '../utils';
 
 /**
  * Map from PostGIS uppercase geometry type names (from geometrytype()) to
@@ -52,6 +54,12 @@ function normalizeGisType(raw: string): string {
   return GIS_TYPE_NORMALIZE[raw] ?? raw;
 }
 
+function getGeometrySubtypeName(typmod: number): string | null {
+  const { subtype } = getGISTypeDetails(typmod);
+  const subtypeName = GIS_SUBTYPE_NAME[subtype];
+  return subtypeName && subtypeName !== 'Geometry' ? subtypeName : null;
+}
+
 /**
  * Scalar PgCodec for PostGIS geometry/geography types.
  *
@@ -226,6 +234,41 @@ export const PostgisCodecPlugin: GraphileConfig.Plugin = {
           );
           return;
         }
+      },
+
+      /**
+       * Annotate geometry/geography attributes with their subtype (Point,
+       * Polygon, LineString, etc.) decoded from the PostgreSQL type modifier.
+       *
+       * The atttypmod encodes subtype + SRID + Z/M flags. We decode it with
+       * getGISTypeDetails() and store the human-readable subtype name on
+       * attribute.extensions.geometrySubtype so the _meta plugin can expose it.
+       */
+      async pgCodecs_attribute(_info, event) {
+        const { pgAttribute, attribute } = event;
+        const codecName = attribute.codec?.name;
+        if (codecName !== 'geometry' && codecName !== 'geography') {
+          return;
+        }
+
+        const typmod = pgAttribute.atttypmod;
+        // atttypmod of -1 or null means no modifier (unconstrained geometry)
+        if (typmod == null || typmod === -1) {
+          return;
+        }
+
+        try {
+          const subtypeName = getGeometrySubtypeName(typmod);
+          if (subtypeName) {
+            if (!attribute.extensions) {
+              attribute.extensions = {};
+            }
+            (attribute.extensions as Record<string, unknown>).geometrySubtype = subtypeName;
+          }
+        } catch {
+          // If the modifier can't be decoded, silently skip — the column
+          // will still work, just without subtype info in _meta.
+        }
       }
     }
   }