@constructive-io/graphql-codegen 4.6.1 → 4.7.0

package/esm/core/custom-ast.js

@@ -1,162 +1,7 @@
-import * as t from 'gql-ast';
-import { Kind } from 'graphql';
 /**
- * Get custom AST for MetaField type - handles PostgreSQL types that need subfield selections
+ * Re-export custom AST utilities from @constructive-io/graphql-query.
+ *
+ * These custom AST builders handle PostgreSQL types that need subfield selections
+ * (geometry, interval, etc.). The canonical implementations now live in graphql-query.
  */
-export function getCustomAst(fieldDefn) {
-    if (!fieldDefn) {
-        return null;
-    }
-    const { pgType } = fieldDefn.type;
-    if (pgType === 'geometry') {
-        return geometryAst(fieldDefn.name);
-    }
-    if (pgType === 'interval') {
-        return intervalAst(fieldDefn.name);
-    }
-    return t.field({
-        name: fieldDefn.name,
-    });
-}
-/**
- * Generate custom AST for CleanField type - handles GraphQL types that need subfield selections
- */
-export 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
- */
-export 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
- */
-export function geometryPointAst(name) {
-    return t.field({
-        name,
-        selectionSet: t.selectionSet({
-            selections: toFieldArray(['x', 'y']),
-        }),
-    });
-}
-/**
- * Generate AST for GeometryGeometryCollection type
- */
-export function geometryCollectionAst(name) {
-    // Manually create inline fragment since gql-ast doesn't support it
-    const inlineFragment = {
-        kind: Kind.INLINE_FRAGMENT,
-        typeCondition: {
-            kind: Kind.NAMED_TYPE,
-            name: {
-                kind: Kind.NAME,
-                value: 'GeometryPoint',
-            },
-        },
-        selectionSet: {
-            kind: Kind.SELECTION_SET,
-            selections: [
-                {
-                    kind: Kind.FIELD,
-                    name: {
-                        kind: Kind.NAME,
-                        value: 'x',
-                    },
-                },
-                {
-                    kind: Kind.FIELD,
-                    name: {
-                        kind: Kind.NAME,
-                        value: 'y',
-                    },
-                },
-            ],
-        },
-    };
-    return t.field({
-        name,
-        selectionSet: t.selectionSet({
-            selections: [
-                t.field({
-                    name: 'geometries',
-                    selectionSet: t.selectionSet({
-                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                        selections: [inlineFragment], // gql-ast limitation with inline fragments
-                    }),
-                }),
-            ],
-        }),
-    });
-}
-/**
- * Generate AST for generic geometry type (returns geojson)
- */
-export function geometryAst(name) {
-    return t.field({
-        name,
-        selectionSet: t.selectionSet({
-            selections: toFieldArray(['geojson']),
-        }),
-    });
-}
-/**
- * Generate AST for interval type
- */
-export function intervalAst(name) {
-    return t.field({
-        name,
-        selectionSet: t.selectionSet({
-            selections: toFieldArray([
-                'days',
-                'hours',
-                'minutes',
-                'months',
-                'seconds',
-                'years',
-            ]),
-        }),
-    });
-}
-function toFieldArray(strArr) {
-    return strArr.map((fieldName) => t.field({ name: fieldName }));
-}
-/**
- * Check if an object has interval type shape
- */
-export function isIntervalType(obj) {
-    if (!obj || typeof obj !== 'object')
-        return false;
-    return ['days', 'hours', 'minutes', 'months', 'seconds', 'years'].every((key) => Object.prototype.hasOwnProperty.call(obj, key));
-}
+export { getCustomAst, getCustomAstForCleanField, requiresSubfieldSelection, geometryPointAst, geometryCollectionAst, geometryAst, intervalAst, isIntervalType, } from '@constructive-io/graphql-query';

package/esm/core/introspect/infer-tables.d.ts

@@ -1,42 +1,4 @@
-import type { IntrospectionQueryResponse } from '../../types/introspection';
-import type { CleanTable } from '../../types/schema';
 /**
- * PostGraphile naming patterns for type detection
+ * Re-export table inference from @constructive-io/graphql-query.
  */
-declare const PATTERNS: {
-    connection: RegExp;
-    edge: RegExp;
-    filter: RegExp;
-    condition: RegExp;
-    orderBy: RegExp;
-    patch: RegExp;
-    createInput: RegExp;
-    updateInput: RegExp;
-    deleteInput: RegExp;
-    createPayload: RegExp;
-    updatePayload: RegExp;
-    deletePayload: RegExp;
-    createMutation: RegExp;
-    updateMutation: RegExp;
-    deleteMutation: RegExp;
-};
-export interface InferTablesOptions {
-    /**
-     * Custom pattern overrides (for non-standard PostGraphile configurations)
-     */
-    patterns?: Partial<typeof PATTERNS>;
-    /**
-     * Include PostgreSQL COMMENT descriptions on tables and fields.
-     * @default true
-     */
-    comments?: boolean;
-}
-/**
- * Infer CleanTable[] from GraphQL introspection by recognizing PostGraphile patterns
- *
- * @param introspection - Standard GraphQL introspection response
- * @param options - Optional configuration
- * @returns Array of CleanTable objects compatible with existing generators
- */
-export declare function inferTablesFromIntrospection(introspection: IntrospectionQueryResponse, options?: InferTablesOptions): CleanTable[];
-export {};
+export { inferTablesFromIntrospection, type InferTablesOptions, } from '@constructive-io/graphql-query';