@constructive-io/graphql-query 2.4.6 → 2.5.0

package/custom-ast.d.ts

@@ -1,4 +1,21 @@
-export declare function getCustomAst(fieldDefn: any): import("graphql").FieldNode;
-export declare function geometryAst(name: any): import("graphql").FieldNode;
-export declare function intervalAst(name: any): import("graphql").FieldNode;
+import type { CleanField, MetaField } from './types';
+export declare function getCustomAst(fieldDefn?: MetaField): any;
+/**
+ * Generate custom AST for CleanField type - handles GraphQL types that need subfield selections
+ */
+export declare function getCustomAstForCleanField(field: CleanField): any;
+/**
+ * Check if a CleanField requires subfield selection based on its GraphQL type
+ */
+export declare function requiresSubfieldSelection(field: CleanField): boolean;
+/**
+ * Generate AST for GeometryPoint type
+ */
+export declare function geometryPointAst(name: string): any;
+/**
+ * Generate AST for GeometryGeometryCollection type
+ */
+export declare function geometryCollectionAst(name: string): any;
+export declare function geometryAst(name: string): any;
+export declare function intervalAst(name: string): any;
 export declare function isIntervalType(obj: any): boolean;

package/custom-ast.js

@@ -1,5 +1,4 @@
 "use strict";
-// @ts-nocheck
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -35,11 +34,18 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getCustomAst = getCustomAst;
+exports.getCustomAstForCleanField = getCustomAstForCleanField;
+exports.requiresSubfieldSelection = requiresSubfieldSelection;
+exports.geometryPointAst = geometryPointAst;
+exports.geometryCollectionAst = geometryCollectionAst;
 exports.geometryAst = geometryAst;
 exports.intervalAst = intervalAst;
 exports.isIntervalType = isIntervalType;
 const t = __importStar(require("gql-ast"));
 function getCustomAst(fieldDefn) {
+    if (!fieldDefn) {
+        return null;
+    }
     const { pgType } = fieldDefn.type;
     if (pgType === 'geometry') {
         return geometryAst(fieldDefn.name);
@@ -48,15 +54,116 @@ function getCustomAst(fieldDefn) {
         return intervalAst(fieldDefn.name);
     }
     return t.field({
-        name: fieldDefn.name
+        name: fieldDefn.name,
+    });
+}
+/**
+ * Generate custom AST for CleanField type - handles GraphQL types that need subfield selections
+ */
+function getCustomAstForCleanField(field) {
+    const { name, type } = field;
+    const { gqlType, pgType } = type;
+    // Handle by GraphQL type first (this is what the error messages reference)
+    if (gqlType === 'GeometryPoint') {
+        return geometryPointAst(name);
+    }
+    if (gqlType === 'Interval') {
+        return intervalAst(name);
+    }
+    if (gqlType === 'GeometryGeometryCollection') {
+        return geometryCollectionAst(name);
+    }
+    // Handle by pgType as fallback
+    if (pgType === 'geometry') {
+        return geometryAst(name);
+    }
+    if (pgType === 'interval') {
+        return intervalAst(name);
+    }
+    // Return simple field for scalar types
+    return t.field({
+        name,
+    });
+}
+/**
+ * Check if a CleanField requires subfield selection based on its GraphQL type
+ */
+function requiresSubfieldSelection(field) {
+    const { gqlType } = field.type;
+    // Complex GraphQL types that require subfield selection
+    const complexTypes = [
+        'GeometryPoint',
+        'Interval',
+        'GeometryGeometryCollection',
+        'GeoJSON',
+    ];
+    return complexTypes.includes(gqlType);
+}
+/**
+ * Generate AST for GeometryPoint type
+ */
+function geometryPointAst(name) {
+    return t.field({
+        name,
+        selectionSet: t.selectionSet({
+            selections: toFieldArray(['x', 'y']),
+        }),
+    });
+}
+/**
+ * Generate AST for GeometryGeometryCollection type
+ */
+function geometryCollectionAst(name) {
+    // Manually create inline fragment since gql-ast doesn't support it
+    const inlineFragment = {
+        kind: 'InlineFragment',
+        typeCondition: {
+            kind: 'NamedType',
+            name: {
+                kind: 'Name',
+                value: 'GeometryPoint',
+            },
+        },
+        selectionSet: {
+            kind: 'SelectionSet',
+            selections: [
+                {
+                    kind: 'Field',
+                    name: {
+                        kind: 'Name',
+                        value: 'x',
+                    },
+                },
+                {
+                    kind: 'Field',
+                    name: {
+                        kind: 'Name',
+                        value: 'y',
+                    },
+                },
+            ],
+        },
+    };
+    return t.field({
+        name,
+        selectionSet: t.selectionSet({
+            selections: [
+                t.field({
+                    name: 'geometries',
+                    selectionSet: t.selectionSet({
+                        selections: [inlineFragment], // gql-ast limitation with inline fragments
+                    }),
+                }),
+            ],
+        }),
     });
 }
 function geometryAst(name) {
     return t.field({
         name,
         selectionSet: t.selectionSet({
-            selections: toFieldArray(['geojson'])
-        })
+            selections: toFieldArray(['geojson']),
+        }),
     });
 }
 function intervalAst(name) {
@@ -69,21 +176,14 @@ function intervalAst(name) {
                 'minutes',
                 'months',
                 'seconds',
-                'years'
-            ])
-        })
+                'years',
+            ]),
+        }),
     });
 }
 function toFieldArray(strArr) {
     return strArr.map((fieldName) => t.field({ name: fieldName }));
 }
 function isIntervalType(obj) {
-    return [
-        'days',
-        'hours',
-        'minutes',
-        'months',
-        'seconds',
-        'years'
-    ].every((key) => obj.hasOwnProperty(key));
+    return ['days', 'hours', 'minutes', 'months', 'seconds', 'years'].every((key) => obj.hasOwnProperty(key));
 }