@constructive-io/graphql-codegen 2.19.0 → 2.20.1

package/esm/cli/introspect/meta-query.js

@@ -0,0 +1,188 @@
+/**
+ * The _meta GraphQL query for introspecting PostGraphile schema
+ * This query fetches all table metadata including fields, constraints, and relations
+ */
+export const META_QUERY = `
+query Meta {
+  _meta {
+    tables {
+      name
+      query {
+        all
+        create
+        delete
+        one
+        update
+      }
+      fields {
+        name
+        type {
+          gqlType
+          isArray
+          modifier
+          pgAlias
+          pgType
+          subtype
+          typmod
+        }
+      }
+      inflection {
+        allRows
+        allRowsSimple
+        conditionType
+        connection
+        createField
+        createInputType
+        createPayloadType
+        deleteByPrimaryKey
+        deletePayloadType
+        edge
+        edgeField
+        enumType
+        filterType
+        inputType
+        orderByType
+        patchField
+        patchType
+        tableFieldName
+        tableType
+        typeName
+        updateByPrimaryKey
+        updatePayloadType
+      }
+      primaryKeyConstraints {
+        name
+        fields {
+          name
+          type {
+            gqlType
+            isArray
+            modifier
+            pgAlias
+            pgType
+            subtype
+            typmod
+          }
+        }
+      }
+      uniqueConstraints {
+        name
+        fields {
+          name
+          type {
+            gqlType
+            isArray
+            modifier
+            pgAlias
+            pgType
+            subtype
+            typmod
+          }
+        }
+      }
+      foreignKeyConstraints {
+        name
+        fields {
+          name
+          type {
+            gqlType
+            isArray
+            modifier
+            pgAlias
+            pgType
+            subtype
+            typmod
+          }
+        }
+        refFields {
+          name
+          type {
+            gqlType
+            isArray
+            modifier
+            pgAlias
+            pgType
+            subtype
+            typmod
+          }
+        }
+        refTable {
+          name
+        }
+      }
+      relations {
+        belongsTo {
+          fieldName
+          isUnique
+          keys {
+            name
+            type {
+              gqlType
+              isArray
+              modifier
+              pgAlias
+              pgType
+              subtype
+              typmod
+            }
+          }
+          references {
+            name
+          }
+          type
+        }
+        hasOne {
+          fieldName
+          isUnique
+          keys {
+            name
+            type {
+              gqlType
+              isArray
+              modifier
+              pgAlias
+              pgType
+              subtype
+              typmod
+            }
+          }
+          referencedBy {
+            name
+          }
+          type
+        }
+        hasMany {
+          fieldName
+          isUnique
+          keys {
+            name
+            type {
+              gqlType
+              isArray
+              modifier
+              pgAlias
+              pgType
+              subtype
+              typmod
+            }
+          }
+          referencedBy {
+            name
+          }
+          type
+        }
+        manyToMany {
+          fieldName
+          junctionTable {
+            name
+          }
+          rightTable {
+            name
+          }
+          type
+        }
+      }
+    }
+  }
+}
+`;

package/esm/cli/introspect/schema-query.d.ts

@@ -0,0 +1,20 @@
+/**
+ * GraphQL Schema Introspection Query
+ *
+ * Full introspection query that captures all queries, mutations, and types
+ * from a GraphQL endpoint via the standard __schema query.
+ */
+import type { IntrospectionQueryResponse } from '../../types/introspection';
+/**
+ * Full schema introspection query
+ *
+ * Captures:
+ * - All Query fields with args and return types
+ * - All Mutation fields with args and return types
+ * - All types (OBJECT, INPUT_OBJECT, ENUM, SCALAR) for resolution
+ *
+ * Uses a recursive TypeRef fragment to handle deeply nested type wrappers
+ * (e.g., [String!]! = NON_NULL(LIST(NON_NULL(SCALAR))))
+ */
+export declare const SCHEMA_INTROSPECTION_QUERY = "\nquery IntrospectSchema {\n  __schema {\n    queryType {\n      name\n    }\n    mutationType {\n      name\n    }\n    subscriptionType {\n      name\n    }\n    types {\n      kind\n      name\n      description\n      fields(includeDeprecated: true) {\n        name\n        description\n        args {\n          name\n          description\n          type {\n            ...TypeRef\n          }\n          defaultValue\n        }\n        type {\n          ...TypeRef\n        }\n        isDeprecated\n        deprecationReason\n      }\n      inputFields {\n        name\n        description\n        type {\n          ...TypeRef\n        }\n        defaultValue\n      }\n      interfaces {\n        name\n      }\n      enumValues(includeDeprecated: true) {\n        name\n        description\n        isDeprecated\n        deprecationReason\n      }\n      possibleTypes {\n        name\n      }\n    }\n    directives {\n      name\n      description\n      locations\n      args {\n        name\n        description\n        type {\n          ...TypeRef\n        }\n        defaultValue\n      }\n    }\n  }\n}\n\nfragment TypeRef on __Type {\n  kind\n  name\n  ofType {\n    kind\n    name\n    ofType {\n      kind\n      name\n      ofType {\n        kind\n        name\n        ofType {\n          kind\n          name\n          ofType {\n            kind\n            name\n            ofType {\n              kind\n              name\n              ofType {\n                kind\n                name\n              }\n            }\n          }\n        }\n      }\n    }\n  }\n}\n";
+export type { IntrospectionQueryResponse };

package/esm/cli/introspect/schema-query.js

@@ -0,0 +1,120 @@
+/**
+ * GraphQL Schema Introspection Query
+ *
+ * Full introspection query that captures all queries, mutations, and types
+ * from a GraphQL endpoint via the standard __schema query.
+ */
+/**
+ * Full schema introspection query
+ *
+ * Captures:
+ * - All Query fields with args and return types
+ * - All Mutation fields with args and return types
+ * - All types (OBJECT, INPUT_OBJECT, ENUM, SCALAR) for resolution
+ *
+ * Uses a recursive TypeRef fragment to handle deeply nested type wrappers
+ * (e.g., [String!]! = NON_NULL(LIST(NON_NULL(SCALAR))))
+ */
+export const SCHEMA_INTROSPECTION_QUERY = `
+query IntrospectSchema {
+  __schema {
+    queryType {
+      name
+    }
+    mutationType {
+      name
+    }
+    subscriptionType {
+      name
+    }
+    types {
+      kind
+      name
+      description
+      fields(includeDeprecated: true) {
+        name
+        description
+        args {
+          name
+          description
+          type {
+            ...TypeRef
+          }
+          defaultValue
+        }
+        type {
+          ...TypeRef
+        }
+        isDeprecated
+        deprecationReason
+      }
+      inputFields {
+        name
+        description
+        type {
+          ...TypeRef
+        }
+        defaultValue
+      }
+      interfaces {
+        name
+      }
+      enumValues(includeDeprecated: true) {
+        name
+        description
+        isDeprecated
+        deprecationReason
+      }
+      possibleTypes {
+        name
+      }
+    }
+    directives {
+      name
+      description
+      locations
+      args {
+        name
+        description
+        type {
+          ...TypeRef
+        }
+        defaultValue
+      }
+    }
+  }
+}
+
+fragment TypeRef on __Type {
+  kind
+  name
+  ofType {
+    kind
+    name
+    ofType {
+      kind
+      name
+      ofType {
+        kind
+        name
+        ofType {
+          kind
+          name
+          ofType {
+            kind
+            name
+            ofType {
+              kind
+              name
+              ofType {
+                kind
+                name
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}
+`;

package/esm/cli/introspect/transform-schema.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Transform GraphQL introspection data to clean operation types
+ *
+ * This module converts raw introspection responses into the CleanOperation
+ * format used by code generators.
+ */
+import type { IntrospectionQueryResponse, IntrospectionType } from '../../types/introspection';
+import { unwrapType, getBaseTypeName, isNonNull } from '../../types/introspection';
+import type { CleanOperation, TypeRegistry } from '../../types/schema';
+/**
+ * Build a type registry from introspection types
+ * Maps type names to their full resolved definitions
+ *
+ * This is a two-pass process to handle circular references:
+ * 1. First pass: Create all type entries with basic info
+ * 2. Second pass: Resolve fields with references to other types
+ */
+export declare function buildTypeRegistry(types: IntrospectionType[]): TypeRegistry;
+export interface TransformSchemaResult {
+    queries: CleanOperation[];
+    mutations: CleanOperation[];
+    typeRegistry: TypeRegistry;
+}
+/**
+ * Transform introspection response to clean operations
+ */
+export declare function transformSchemaToOperations(response: IntrospectionQueryResponse): TransformSchemaResult;
+/**
+ * Filter operations by include/exclude patterns
+ * Uses glob-like patterns (supports * wildcard)
+ */
+export declare function filterOperations(operations: CleanOperation[], include?: string[], exclude?: string[]): CleanOperation[];
+/**
+ * Get the set of table-related operation names from tables
+ * Used to identify which operations are already covered by table generators
+ *
+ * This includes:
+ * - Basic CRUD: all, one, create, update, delete
+ * - PostGraphile alternate mutations: updateXByY, deleteXByY (for unique constraints)
+ */
+export declare function getTableOperationNames(tables: Array<{
+    name: string;
+    query?: {
+        all: string;
+        one: string;
+        create: string;
+        update: string | null;
+        delete: string | null;
+    };
+    inflection?: {
+        tableType: string;
+    };
+}>): {
+    queries: Set<string>;
+    mutations: Set<string>;
+    tableTypePatterns: RegExp[];
+};
+/**
+ * Check if an operation is a table operation (already handled by table generators)
+ */
+export declare function isTableOperation(operation: CleanOperation, tableOperationNames: {
+    queries: Set<string>;
+    mutations: Set<string>;
+    tableTypePatterns: RegExp[];
+}): boolean;
+/**
+ * Get only custom operations (not covered by table generators)
+ */
+export declare function getCustomOperations(operations: CleanOperation[], tableOperationNames: {
+    queries: Set<string>;
+    mutations: Set<string>;
+    tableTypePatterns: RegExp[];
+}): CleanOperation[];
+export { unwrapType, getBaseTypeName, isNonNull };

package/esm/cli/introspect/transform-schema.js

@@ -0,0 +1,259 @@
+import { unwrapType, getBaseTypeName, isNonNull, } from '../../types/introspection';
+// ============================================================================
+// Type Registry Builder
+// ============================================================================
+/**
+ * Build a type registry from introspection types
+ * Maps type names to their full resolved definitions
+ *
+ * This is a two-pass process to handle circular references:
+ * 1. First pass: Create all type entries with basic info
+ * 2. Second pass: Resolve fields with references to other types
+ */
+export function buildTypeRegistry(types) {
+    const registry = new Map();
+    // First pass: Create all type entries
+    for (const type of types) {
+        // Skip built-in types that start with __
+        if (type.name.startsWith('__'))
+            continue;
+        const resolvedType = {
+            kind: type.kind,
+            name: type.name,
+            description: type.description ?? undefined,
+        };
+        // Resolve enum values for ENUM types (no circular refs possible)
+        if (type.kind === 'ENUM' && type.enumValues) {
+            resolvedType.enumValues = type.enumValues.map((ev) => ev.name);
+        }
+        registry.set(type.name, resolvedType);
+    }
+    // Second pass: Resolve fields (now that all types exist in registry)
+    for (const type of types) {
+        if (type.name.startsWith('__'))
+            continue;
+        const resolvedType = registry.get(type.name);
+        if (!resolvedType)
+            continue;
+        // Resolve fields for OBJECT types
+        if (type.kind === 'OBJECT' && type.fields) {
+            resolvedType.fields = type.fields.map((field) => transformFieldToCleanObjectFieldShallow(field));
+        }
+        // Resolve input fields for INPUT_OBJECT types
+        if (type.kind === 'INPUT_OBJECT' && type.inputFields) {
+            resolvedType.inputFields = type.inputFields.map((field) => transformInputValueToCleanArgumentShallow(field));
+        }
+    }
+    return registry;
+}
+/**
+ * Transform field to CleanObjectField without resolving nested types
+ * (shallow transformation to avoid circular refs)
+ */
+function transformFieldToCleanObjectFieldShallow(field) {
+    return {
+        name: field.name,
+        type: transformTypeRefShallow(field.type),
+        description: field.description ?? undefined,
+    };
+}
+/**
+ * Transform input value to CleanArgument without resolving nested types
+ */
+function transformInputValueToCleanArgumentShallow(inputValue) {
+    return {
+        name: inputValue.name,
+        type: transformTypeRefShallow(inputValue.type),
+        defaultValue: inputValue.defaultValue ?? undefined,
+        description: inputValue.description ?? undefined,
+    };
+}
+/**
+ * Transform TypeRef without resolving nested types
+ * Only handles wrappers (LIST, NON_NULL) and stores the type name
+ */
+function transformTypeRefShallow(typeRef) {
+    const cleanRef = {
+        kind: typeRef.kind,
+        name: typeRef.name,
+    };
+    if (typeRef.ofType) {
+        cleanRef.ofType = transformTypeRefShallow(typeRef.ofType);
+    }
+    return cleanRef;
+}
+/**
+ * Transform introspection response to clean operations
+ */
+export function transformSchemaToOperations(response) {
+    const { __schema: schema } = response;
+    const { types, queryType, mutationType } = schema;
+    // Build type registry first
+    const typeRegistry = buildTypeRegistry(types);
+    // Find Query and Mutation types
+    const queryTypeDef = types.find((t) => t.name === queryType.name);
+    const mutationTypeDef = mutationType
+        ? types.find((t) => t.name === mutationType.name)
+        : null;
+    // Transform queries
+    const queries = queryTypeDef?.fields
+        ? queryTypeDef.fields.map((field) => transformFieldToCleanOperation(field, 'query', types))
+        : [];
+    // Transform mutations
+    const mutations = mutationTypeDef?.fields
+        ? mutationTypeDef.fields.map((field) => transformFieldToCleanOperation(field, 'mutation', types))
+        : [];
+    return { queries, mutations, typeRegistry };
+}
+// ============================================================================
+// Field to Operation Transformation
+// ============================================================================
+/**
+ * Transform an introspection field to a CleanOperation
+ */
+function transformFieldToCleanOperation(field, kind, types) {
+    return {
+        name: field.name,
+        kind,
+        args: field.args.map((arg) => transformInputValueToCleanArgument(arg, types)),
+        returnType: transformTypeRefToCleanTypeRef(field.type, types),
+        description: field.description ?? undefined,
+        isDeprecated: field.isDeprecated,
+        deprecationReason: field.deprecationReason ?? undefined,
+    };
+}
+/**
+ * Transform an input value to CleanArgument
+ */
+function transformInputValueToCleanArgument(inputValue, types) {
+    return {
+        name: inputValue.name,
+        type: transformTypeRefToCleanTypeRef(inputValue.type, types),
+        defaultValue: inputValue.defaultValue ?? undefined,
+        description: inputValue.description ?? undefined,
+    };
+}
+// ============================================================================
+// Type Reference Transformation
+// ============================================================================
+/**
+ * Transform an introspection TypeRef to CleanTypeRef
+ * Recursively handles wrapper types (LIST, NON_NULL)
+ *
+ * NOTE: We intentionally do NOT resolve nested fields here to avoid
+ * infinite recursion from circular type references. Fields are resolved
+ * lazily via the TypeRegistry when needed for code generation.
+ */
+function transformTypeRefToCleanTypeRef(typeRef, types) {
+    const cleanRef = {
+        kind: typeRef.kind,
+        name: typeRef.name,
+    };
+    // Recursively transform ofType for wrappers (LIST, NON_NULL)
+    if (typeRef.ofType) {
+        cleanRef.ofType = transformTypeRefToCleanTypeRef(typeRef.ofType, types);
+    }
+    // For named types, only resolve enum values (they don't have circular refs)
+    // Fields are NOT resolved here - they're resolved via TypeRegistry during codegen
+    if (typeRef.name && !typeRef.ofType) {
+        const typeDef = types.find((t) => t.name === typeRef.name);
+        if (typeDef) {
+            // Add enum values for ENUM types (safe, no recursion)
+            if (typeDef.kind === 'ENUM' && typeDef.enumValues) {
+                cleanRef.enumValues = typeDef.enumValues.map((ev) => ev.name);
+            }
+            // NOTE: OBJECT and INPUT_OBJECT fields are resolved via TypeRegistry
+            // to avoid circular reference issues
+        }
+    }
+    return cleanRef;
+}
+// ============================================================================
+// Operation Filtering
+// ============================================================================
+/**
+ * Filter operations by include/exclude patterns
+ * Uses glob-like patterns (supports * wildcard)
+ */
+export function filterOperations(operations, include, exclude) {
+    let result = operations;
+    if (include && include.length > 0) {
+        result = result.filter((op) => matchesPatterns(op.name, include));
+    }
+    if (exclude && exclude.length > 0) {
+        result = result.filter((op) => !matchesPatterns(op.name, exclude));
+    }
+    return result;
+}
+/**
+ * Check if a name matches any of the patterns
+ * Supports simple glob patterns with * wildcard
+ */
+function matchesPatterns(name, patterns) {
+    return patterns.some((pattern) => {
+        if (pattern === '*')
+            return true;
+        if (pattern.includes('*')) {
+            const regex = new RegExp('^' + pattern.replace(/\*/g, '.*').replace(/\?/g, '.') + '$');
+            return regex.test(name);
+        }
+        return name === pattern;
+    });
+}
+// ============================================================================
+// Utility Functions
+// ============================================================================
+/**
+ * Get the set of table-related operation names from tables
+ * Used to identify which operations are already covered by table generators
+ *
+ * This includes:
+ * - Basic CRUD: all, one, create, update, delete
+ * - PostGraphile alternate mutations: updateXByY, deleteXByY (for unique constraints)
+ */
+export function getTableOperationNames(tables) {
+    const queries = new Set();
+    const mutations = new Set();
+    const tableTypePatterns = [];
+    for (const table of tables) {
+        if (table.query) {
+            queries.add(table.query.all);
+            queries.add(table.query.one);
+            mutations.add(table.query.create);
+            if (table.query.update)
+                mutations.add(table.query.update);
+            if (table.query.delete)
+                mutations.add(table.query.delete);
+        }
+        // Create patterns to match alternate CRUD mutations (updateXByY, deleteXByY)
+        if (table.inflection?.tableType) {
+            const typeName = table.inflection.tableType;
+            // Match: update{TypeName}By*, delete{TypeName}By*
+            tableTypePatterns.push(new RegExp(`^update${typeName}By`, 'i'));
+            tableTypePatterns.push(new RegExp(`^delete${typeName}By`, 'i'));
+        }
+    }
+    return { queries, mutations, tableTypePatterns };
+}
+/**
+ * Check if an operation is a table operation (already handled by table generators)
+ */
+export function isTableOperation(operation, tableOperationNames) {
+    if (operation.kind === 'query') {
+        return tableOperationNames.queries.has(operation.name);
+    }
+    // Check exact match first
+    if (tableOperationNames.mutations.has(operation.name)) {
+        return true;
+    }
+    // Check pattern match for alternate CRUD mutations (updateXByY, deleteXByY)
+    return tableOperationNames.tableTypePatterns.some((pattern) => pattern.test(operation.name));
+}
+/**
+ * Get only custom operations (not covered by table generators)
+ */
+export function getCustomOperations(operations, tableOperationNames) {
+    return operations.filter((op) => !isTableOperation(op, tableOperationNames));
+}
+// Re-export utility functions from introspection types
+export { unwrapType, getBaseTypeName, isNonNull };

package/esm/cli/introspect/transform-schema.test.d.ts

@@ -0,0 +1 @@
+export {};