@constructive-io/graphql-codegen 2.19.0 → 2.20.1

package/cli/introspect/fetch-schema.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchSchema = fetchSchema;
+/**
+ * Fetch GraphQL schema introspection from an endpoint
+ */
+const schema_query_1 = require("./schema-query");
+/**
+ * Fetch the full schema introspection from a GraphQL endpoint
+ */
+async function fetchSchema(options) {
+    const { endpoint, authorization, headers = {}, timeout = 30000 } = options;
+    // Build headers
+    const requestHeaders = {
+        'Content-Type': 'application/json',
+        Accept: 'application/json',
+        ...headers,
+    };
+    if (authorization) {
+        requestHeaders['Authorization'] = authorization;
+    }
+    // Create abort controller for timeout
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    try {
+        const response = await fetch(endpoint, {
+            method: 'POST',
+            headers: requestHeaders,
+            body: JSON.stringify({
+                query: schema_query_1.SCHEMA_INTROSPECTION_QUERY,
+                variables: {},
+            }),
+            signal: controller.signal,
+        });
+        clearTimeout(timeoutId);
+        if (!response.ok) {
+            return {
+                success: false,
+                error: `HTTP ${response.status}: ${response.statusText}`,
+                statusCode: response.status,
+            };
+        }
+        const json = (await response.json());
+        // Check for GraphQL errors
+        if (json.errors && json.errors.length > 0) {
+            const errorMessages = json.errors.map((e) => e.message).join('; ');
+            return {
+                success: false,
+                error: `GraphQL errors: ${errorMessages}`,
+                statusCode: response.status,
+            };
+        }
+        // Check if __schema is present
+        if (!json.data?.__schema) {
+            return {
+                success: false,
+                error: 'No __schema field in response. Introspection may be disabled on this endpoint.',
+                statusCode: response.status,
+            };
+        }
+        return {
+            success: true,
+            data: json.data,
+            statusCode: response.status,
+        };
+    }
+    catch (err) {
+        clearTimeout(timeoutId);
+        if (err instanceof Error) {
+            if (err.name === 'AbortError') {
+                return {
+                    success: false,
+                    error: `Request timeout after ${timeout}ms`,
+                };
+            }
+            return {
+                success: false,
+                error: err.message,
+            };
+        }
+        return {
+            success: false,
+            error: 'Unknown error occurred',
+        };
+    }
+}

package/cli/introspect/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Introspection module exports
+ */
+export { META_QUERY } from './meta-query';
+export type { MetaQueryResponse, MetaTable, MetaField, MetaFieldType, MetaConstraint, MetaForeignKeyConstraint, MetaTableQuery, MetaTableInflection, MetaBelongsToRelation, MetaHasRelation, MetaManyToManyRelation, MetaTableRelations, } from './meta-query';
+export { fetchMeta, validateEndpoint } from './fetch-meta';
+export type { FetchMetaOptions, FetchMetaResult } from './fetch-meta';
+export { transformMetaToCleanTables, getTableNames, findTable, filterTables, } from './transform';

package/cli/introspect/index.js

@@ -0,0 +1,16 @@
+"use strict";
+/**
+ * Introspection module exports
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterTables = exports.findTable = exports.getTableNames = exports.transformMetaToCleanTables = exports.validateEndpoint = exports.fetchMeta = exports.META_QUERY = void 0;
+var meta_query_1 = require("./meta-query");
+Object.defineProperty(exports, "META_QUERY", { enumerable: true, get: function () { return meta_query_1.META_QUERY; } });
+var fetch_meta_1 = require("./fetch-meta");
+Object.defineProperty(exports, "fetchMeta", { enumerable: true, get: function () { return fetch_meta_1.fetchMeta; } });
+Object.defineProperty(exports, "validateEndpoint", { enumerable: true, get: function () { return fetch_meta_1.validateEndpoint; } });
+var transform_1 = require("./transform");
+Object.defineProperty(exports, "transformMetaToCleanTables", { enumerable: true, get: function () { return transform_1.transformMetaToCleanTables; } });
+Object.defineProperty(exports, "getTableNames", { enumerable: true, get: function () { return transform_1.getTableNames; } });
+Object.defineProperty(exports, "findTable", { enumerable: true, get: function () { return transform_1.findTable; } });
+Object.defineProperty(exports, "filterTables", { enumerable: true, get: function () { return transform_1.filterTables; } });

package/cli/introspect/meta-query.d.ts

@@ -0,0 +1,111 @@
+/**
+ * The _meta GraphQL query for introspecting PostGraphile schema
+ * This query fetches all table metadata including fields, constraints, and relations
+ */
+export declare const META_QUERY = "\nquery Meta {\n  _meta {\n    tables {\n      name\n      query {\n        all\n        create\n        delete\n        one\n        update\n      }\n      fields {\n        name\n        type {\n          gqlType\n          isArray\n          modifier\n          pgAlias\n          pgType\n          subtype\n          typmod\n        }\n      }\n      inflection {\n        allRows\n        allRowsSimple\n        conditionType\n        connection\n        createField\n        createInputType\n        createPayloadType\n        deleteByPrimaryKey\n        deletePayloadType\n        edge\n        edgeField\n        enumType\n        filterType\n        inputType\n        orderByType\n        patchField\n        patchType\n        tableFieldName\n        tableType\n        typeName\n        updateByPrimaryKey\n        updatePayloadType\n      }\n      primaryKeyConstraints {\n        name\n        fields {\n          name\n          type {\n            gqlType\n            isArray\n            modifier\n            pgAlias\n            pgType\n            subtype\n            typmod\n          }\n        }\n      }\n      uniqueConstraints {\n        name\n        fields {\n          name\n          type {\n            gqlType\n            isArray\n            modifier\n            pgAlias\n            pgType\n            subtype\n            typmod\n          }\n        }\n      }\n      foreignKeyConstraints {\n        name\n        fields {\n          name\n          type {\n            gqlType\n            isArray\n            modifier\n            pgAlias\n            pgType\n            subtype\n            typmod\n          }\n        }\n        refFields {\n          name\n          type {\n            gqlType\n            isArray\n            modifier\n            pgAlias\n            pgType\n            subtype\n            typmod\n          }\n        }\n        refTable {\n          name\n        }\n      }\n      relations {\n        belongsTo {\n          fieldName\n          isUnique\n          keys {\n            name\n            type {\n              gqlType\n              isArray\n              modifier\n              pgAlias\n              pgType\n              subtype\n              typmod\n            }\n          }\n          references {\n            name\n          }\n          type\n        }\n        hasOne {\n          fieldName\n          isUnique\n          keys {\n            name\n            type {\n              gqlType\n              isArray\n              modifier\n              pgAlias\n              pgType\n              subtype\n              typmod\n            }\n          }\n          referencedBy {\n            name\n          }\n          type\n        }\n        hasMany {\n          fieldName\n          isUnique\n          keys {\n            name\n            type {\n              gqlType\n              isArray\n              modifier\n              pgAlias\n              pgType\n              subtype\n              typmod\n            }\n          }\n          referencedBy {\n            name\n          }\n          type\n        }\n        manyToMany {\n          fieldName\n          junctionTable {\n            name\n          }\n          rightTable {\n            name\n          }\n          type\n        }\n      }\n    }\n  }\n}\n";
+/**
+ * Types for the _meta query response
+ */
+export interface MetaFieldType {
+    gqlType: string;
+    isArray: boolean;
+    modifier: string | number | null;
+    pgAlias: string | null;
+    pgType: string | null;
+    subtype: string | null;
+    typmod: number | null;
+}
+export interface MetaField {
+    name: string;
+    type: MetaFieldType;
+}
+export interface MetaConstraint {
+    name: string;
+    fields: MetaField[];
+}
+export interface MetaForeignKeyConstraint extends MetaConstraint {
+    refFields: MetaField[];
+    refTable: {
+        name: string;
+    };
+}
+export interface MetaTableQuery {
+    all: string;
+    create: string;
+    delete: string | null;
+    one: string;
+    update: string | null;
+}
+export interface MetaTableInflection {
+    allRows: string;
+    allRowsSimple: string;
+    conditionType: string;
+    connection: string;
+    createField: string;
+    createInputType: string;
+    createPayloadType: string;
+    deleteByPrimaryKey: string | null;
+    deletePayloadType: string;
+    edge: string;
+    edgeField: string;
+    enumType: string;
+    filterType: string | null;
+    inputType: string;
+    orderByType: string;
+    patchField: string;
+    patchType: string | null;
+    tableFieldName: string;
+    tableType: string;
+    typeName: string;
+    updateByPrimaryKey: string | null;
+    updatePayloadType: string | null;
+}
+export interface MetaBelongsToRelation {
+    fieldName: string | null;
+    isUnique: boolean;
+    keys: MetaField[];
+    references: {
+        name: string;
+    };
+    type: string | null;
+}
+export interface MetaHasRelation {
+    fieldName: string | null;
+    isUnique: boolean;
+    keys: MetaField[];
+    referencedBy: {
+        name: string;
+    };
+    type: string | null;
+}
+export interface MetaManyToManyRelation {
+    fieldName: string | null;
+    junctionTable: {
+        name: string;
+    };
+    rightTable: {
+        name: string;
+    };
+    type: string | null;
+}
+export interface MetaTableRelations {
+    belongsTo: MetaBelongsToRelation[];
+    hasOne: MetaHasRelation[];
+    hasMany: MetaHasRelation[];
+    manyToMany: MetaManyToManyRelation[];
+}
+export interface MetaTable {
+    name: string;
+    query: MetaTableQuery;
+    fields: MetaField[];
+    inflection: MetaTableInflection;
+    primaryKeyConstraints: MetaConstraint[];
+    uniqueConstraints: MetaConstraint[];
+    foreignKeyConstraints: MetaForeignKeyConstraint[];
+    relations: MetaTableRelations;
+}
+export interface MetaQueryResponse {
+    _meta: {
+        tables: MetaTable[];
+    };
+}

package/cli/introspect/meta-query.js

@@ -0,0 +1,191 @@
+"use strict";
+/**
+ * The _meta GraphQL query for introspecting PostGraphile schema
+ * This query fetches all table metadata including fields, constraints, and relations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.META_QUERY = void 0;
+exports.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/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/cli/introspect/schema-query.js

@@ -0,0 +1,123 @@
+"use strict";
+/**
+ * GraphQL Schema Introspection Query
+ *
+ * Full introspection query that captures all queries, mutations, and types
+ * from a GraphQL endpoint via the standard __schema query.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SCHEMA_INTROSPECTION_QUERY = void 0;
+/**
+ * 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))))
+ */
+exports.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/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 };