wip: add geometry subtype metadata to _meta

Author: yyyyaaa

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,80 @@ describe('PostgisCodecPlugin', () => {
       });
     });
   });
+
+  describe('pgCodecs_attribute hook', () => {
+    const attributeHook = (PostgisCodecPlugin as { gather: { hooks: { pgCodecs_attribute: Function } } })
+      .gather.hooks.pgCodecs_attribute;
+
+    it('should store geometrySubtype for Polygon geometry column', async () => {
+      const typmod = getGISTypeModifier(GisSubtype.Polygon, false, false, 4326);
+      const attribute: Record<string, any> = { codec: { name: 'geometry' }, extensions: {} };
+      const event = { pgAttribute: { atttypmod: typmod }, attribute };
+
+      await attributeHook({}, event);
+      expect(attribute.extensions.geometrySubtype).toBe('Polygon');
+    });
+
+    it('should store geometrySubtype for Point geometry column', async () => {
+      const typmod = getGISTypeModifier(GisSubtype.Point, false, false, 4326);
+      const attribute: Record<string, any> = { codec: { name: 'geometry' }, extensions: {} };
+      const event = { pgAttribute: { atttypmod: typmod }, attribute };
+
+      await attributeHook({}, event);
+      expect(attribute.extensions.geometrySubtype).toBe('Point');
+    });
+
+    it('should store geometrySubtype for MultiPolygon geography column', async () => {
+      const typmod = getGISTypeModifier(GisSubtype.MultiPolygon, false, false, 4326);
+      const attribute: Record<string, any> = { codec: { name: 'geography' }, extensions: {} };
+      const event = { pgAttribute: { atttypmod: typmod }, attribute };
+
+      await attributeHook({}, event);
+      expect(attribute.extensions.geometrySubtype).toBe('MultiPolygon');
+    });
+
+    it('should skip unconstrained geometry (atttypmod = -1)', async () => {
+      const attribute: Record<string, any> = { codec: { name: 'geometry' }, extensions: {} };
+      const event = { pgAttribute: { atttypmod: -1 }, attribute };
+
+      await attributeHook({}, event);
+      expect(attribute.extensions.geometrySubtype).toBeUndefined();
+    });
+
+    it('should skip when atttypmod is null', async () => {
+      const attribute: Record<string, any> = { codec: { name: 'geometry' }, extensions: {} };
+      const event = { pgAttribute: { atttypmod: null as number | null }, attribute };
+
+      await attributeHook({}, event);
+      expect(attribute.extensions.geometrySubtype).toBeUndefined();
+    });
+
+    it('should not store subtype for base Geometry (subtype=0)', async () => {
+      const typmod = getGISTypeModifier(GisSubtype.Geometry, false, false, 4326);
+      const attribute: Record<string, any> = { codec: { name: 'geometry' }, extensions: {} };
+      const event = { pgAttribute: { atttypmod: typmod }, attribute };
+
+      await attributeHook({}, event);
+      expect(attribute.extensions.geometrySubtype).toBeUndefined();
+    });
+
+    it('should skip non-geometry codec types', async () => {
+      const typmod = getGISTypeModifier(GisSubtype.Point, false, false, 4326);
+      const attribute: Record<string, any> = { codec: { name: 'text' }, extensions: {} };
+      const event = { pgAttribute: { atttypmod: typmod }, attribute };
+
+      await attributeHook({}, event);
+      expect(attribute.extensions.geometrySubtype).toBeUndefined();
+    });
+
+    it('should create extensions object if not present', async () => {
+      const typmod = getGISTypeModifier(GisSubtype.LineString, false, false, 4326);
+      const attribute: Record<string, any> = { codec: { name: 'geometry' } };
+      const event = { pgAttribute: { atttypmod: typmod }, attribute };
+
+      await attributeHook({}, event);
+      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
@@ -226,6 +228,42 @@ 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 details = getGISTypeDetails(typmod);
+          const subtypeName = GIS_SUBTYPE_NAME[details.subtype];
+          if (subtypeName && subtypeName !== 'Geometry') {
+            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.
+        }
       }
     }
   }