@constructive-io/graphql-codegen 2.22.1 → 2.23.1

package/esm/cli/introspect/source/file.js

@@ -0,0 +1,66 @@
+/**
+ * File Schema Source
+ *
+ * Loads GraphQL schema from a local .graphql SDL file and converts it
+ * to introspection format using the graphql package.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { buildSchema, introspectionFromSchema } from 'graphql';
+import { SchemaSourceError } from './types';
+/**
+ * Schema source that loads from a local GraphQL schema file
+ *
+ * Supports .graphql files containing SDL (Schema Definition Language).
+ * The SDL is parsed using graphql-js and converted to introspection format.
+ */
+export class FileSchemaSource {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async fetch() {
+        const absolutePath = path.isAbsolute(this.options.schemaPath)
+            ? this.options.schemaPath
+            : path.resolve(process.cwd(), this.options.schemaPath);
+        // Check file exists
+        if (!fs.existsSync(absolutePath)) {
+            throw new SchemaSourceError(`Schema file not found: ${absolutePath}`, this.describe());
+        }
+        // Read file content
+        let sdl;
+        try {
+            sdl = await fs.promises.readFile(absolutePath, 'utf-8');
+        }
+        catch (err) {
+            throw new SchemaSourceError(`Failed to read schema file: ${err instanceof Error ? err.message : 'Unknown error'}`, this.describe(), err instanceof Error ? err : undefined);
+        }
+        // Validate non-empty
+        if (!sdl.trim()) {
+            throw new SchemaSourceError('Schema file is empty', this.describe());
+        }
+        // Parse SDL to GraphQL schema
+        let schema;
+        try {
+            schema = buildSchema(sdl);
+        }
+        catch (err) {
+            throw new SchemaSourceError(`Invalid GraphQL SDL: ${err instanceof Error ? err.message : 'Unknown error'}`, this.describe(), err instanceof Error ? err : undefined);
+        }
+        // Convert to introspection format
+        let introspectionResult;
+        try {
+            introspectionResult = introspectionFromSchema(schema);
+        }
+        catch (err) {
+            throw new SchemaSourceError(`Failed to generate introspection: ${err instanceof Error ? err.message : 'Unknown error'}`, this.describe(), err instanceof Error ? err : undefined);
+        }
+        // Convert graphql-js introspection result to our mutable type
+        // The graphql-js types are readonly, but our types are mutable
+        const introspection = JSON.parse(JSON.stringify(introspectionResult));
+        return { introspection };
+    }
+    describe() {
+        return `file: ${this.options.schemaPath}`;
+    }
+}

package/esm/cli/introspect/source/index.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Schema Source Module
+ *
+ * Provides a unified interface for loading GraphQL schemas from different sources:
+ * - Live GraphQL endpoints (via introspection)
+ * - Static .graphql schema files
+ */
+export * from './types';
+export * from './endpoint';
+export * from './file';
+import type { SchemaSource } from './types';
+export interface CreateSchemaSourceOptions {
+    /**
+     * GraphQL endpoint URL (for live introspection)
+     */
+    endpoint?: string;
+    /**
+     * Path to GraphQL schema file (.graphql)
+     */
+    schema?: string;
+    /**
+     * Optional authorization header for endpoint requests
+     */
+    authorization?: string;
+    /**
+     * Optional additional headers for endpoint requests
+     */
+    headers?: Record<string, string>;
+    /**
+     * Request timeout in milliseconds (for endpoint requests)
+     */
+    timeout?: number;
+}
+/**
+ * Create a schema source based on configuration
+ *
+ * @param options - Source configuration
+ * @returns Appropriate SchemaSource implementation
+ * @throws Error if neither endpoint nor schema is provided
+ */
+export declare function createSchemaSource(options: CreateSchemaSourceOptions): SchemaSource;
+/**
+ * Validate that source options are valid (at least one source specified)
+ */
+export declare function validateSourceOptions(options: CreateSchemaSourceOptions): {
+    valid: boolean;
+    error?: string;
+};

package/esm/cli/introspect/source/index.js

@@ -0,0 +1,54 @@
+/**
+ * Schema Source Module
+ *
+ * Provides a unified interface for loading GraphQL schemas from different sources:
+ * - Live GraphQL endpoints (via introspection)
+ * - Static .graphql schema files
+ */
+export * from './types';
+export * from './endpoint';
+export * from './file';
+import { EndpointSchemaSource } from './endpoint';
+import { FileSchemaSource } from './file';
+/**
+ * Create a schema source based on configuration
+ *
+ * @param options - Source configuration
+ * @returns Appropriate SchemaSource implementation
+ * @throws Error if neither endpoint nor schema is provided
+ */
+export function createSchemaSource(options) {
+    if (options.schema) {
+        return new FileSchemaSource({
+            schemaPath: options.schema,
+        });
+    }
+    if (options.endpoint) {
+        return new EndpointSchemaSource({
+            endpoint: options.endpoint,
+            authorization: options.authorization,
+            headers: options.headers,
+            timeout: options.timeout,
+        });
+    }
+    throw new Error('Either endpoint or schema must be provided. ' +
+        'Use --endpoint for live introspection or --schema for a local file.');
+}
+/**
+ * Validate that source options are valid (at least one source specified)
+ */
+export function validateSourceOptions(options) {
+    if (!options.endpoint && !options.schema) {
+        return {
+            valid: false,
+            error: 'Either endpoint or schema must be provided',
+        };
+    }
+    if (options.endpoint && options.schema) {
+        return {
+            valid: false,
+            error: 'Cannot use both endpoint and schema. Choose one source.',
+        };
+    }
+    return { valid: true };
+}

package/esm/cli/introspect/source/types.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Schema Source Types
+ *
+ * Defines the interface for schema sources, allowing the codegen pipeline
+ * to work with both live GraphQL endpoints and static schema files.
+ */
+import type { IntrospectionQueryResponse } from '../../../types/introspection';
+/**
+ * Result from fetching a schema source
+ */
+export interface SchemaSourceResult {
+    /**
+     * The GraphQL introspection data
+     */
+    introspection: IntrospectionQueryResponse;
+}
+/**
+ * Abstract interface for schema sources
+ *
+ * Implementations:
+ * - EndpointSchemaSource: Fetches from a live GraphQL endpoint
+ * - FileSchemaSource: Loads from a local .graphql schema file
+ */
+export interface SchemaSource {
+    /**
+     * Fetch or load the GraphQL introspection data
+     * @throws SchemaSourceError if fetching fails
+     */
+    fetch(): Promise<SchemaSourceResult>;
+    /**
+     * Human-readable description of the source (for logging)
+     * @example "endpoint: https://api.example.com/graphql"
+     * @example "file: ./schema.graphql"
+     */
+    describe(): string;
+}
+/**
+ * Error thrown when a schema source fails to fetch
+ */
+export declare class SchemaSourceError extends Error {
+    /**
+     * Description of the source that failed
+     */
+    readonly source: string;
+    /**
+     * Original error that caused the failure
+     */
+    readonly cause?: Error;
+    constructor(message: string, 
+    /**
+     * Description of the source that failed
+     */
+    source: string, 
+    /**
+     * Original error that caused the failure
+     */
+    cause?: Error);
+}

package/esm/cli/introspect/source/types.js

@@ -0,0 +1,23 @@
+/**
+ * Error thrown when a schema source fails to fetch
+ */
+export class SchemaSourceError extends Error {
+    source;
+    cause;
+    constructor(message, 
+    /**
+     * Description of the source that failed
+     */
+    source, 
+    /**
+     * Original error that caused the failure
+     */
+    cause) {
+        super(`${message} (source: ${source})`);
+        this.source = source;
+        this.cause = cause;
+        this.name = 'SchemaSourceError';
+        // Maintain proper prototype chain
+        Object.setPrototypeOf(this, SchemaSourceError.prototype);
+    }
+}

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

@@ -1,12 +1,11 @@
 /**
- * Transform _meta query response to CleanTable[] format
+ * Table utility functions for CleanTable[]
+ *
+ * Note: The _meta transform functions have been removed.
+ * Tables are now inferred from standard GraphQL introspection
+ * using inferTablesFromIntrospection() in ./infer-tables.ts
  */
 import type { CleanTable } from '../../types/schema';
-import type { MetaQueryResponse } from './meta-query';
-/**
- * Transform _meta response to CleanTable array
- */
-export declare function transformMetaToCleanTables(metaResponse: MetaQueryResponse): CleanTable[];
 /**
  * Get table names from CleanTable array
  */

package/esm/cli/introspect/transform.js

@@ -1,175 +1,3 @@
-/**
- * Transform _meta response to CleanTable array
- */
-export function transformMetaToCleanTables(metaResponse) {
-    const { tables } = metaResponse._meta;
-    return tables.map((table) => transformTable(table));
-}
-/**
- * Transform a single MetaTable to CleanTable
- */
-function transformTable(table) {
-    return {
-        name: table.name,
-        fields: transformFields(table.fields),
-        relations: transformRelations(table.relations),
-        inflection: transformInflection(table.inflection),
-        query: transformQuery(table.query),
-        constraints: transformConstraints(table),
-    };
-}
-/**
- * Transform MetaField[] to CleanField[]
- */
-function transformFields(fields) {
-    return fields.map((field) => ({
-        name: field.name,
-        type: transformFieldType(field.type),
-    }));
-}
-/**
- * Transform MetaFieldType to CleanFieldType
- */
-function transformFieldType(type) {
-    return {
-        gqlType: type.gqlType,
-        isArray: type.isArray,
-        modifier: type.modifier,
-        pgAlias: type.pgAlias,
-        pgType: type.pgType,
-        subtype: type.subtype,
-        typmod: type.typmod,
-    };
-}
-/**
- * Transform table relations
- */
-function transformRelations(relations) {
-    return {
-        belongsTo: relations.belongsTo.map(transformBelongsTo),
-        hasOne: relations.hasOne.map(transformHasOne),
-        hasMany: relations.hasMany.map(transformHasMany),
-        manyToMany: relations.manyToMany.map(transformManyToMany),
-    };
-}
-/**
- * Transform belongsTo relation
- */
-function transformBelongsTo(rel) {
-    return {
-        fieldName: rel.fieldName,
-        isUnique: rel.isUnique,
-        referencesTable: rel.references.name,
-        type: rel.type,
-        keys: transformFields(rel.keys),
-    };
-}
-/**
- * Transform hasOne relation
- */
-function transformHasOne(rel) {
-    return {
-        fieldName: rel.fieldName,
-        isUnique: rel.isUnique,
-        referencedByTable: rel.referencedBy.name,
-        type: rel.type,
-        keys: transformFields(rel.keys),
-    };
-}
-/**
- * Transform hasMany relation
- */
-function transformHasMany(rel) {
-    return {
-        fieldName: rel.fieldName,
-        isUnique: rel.isUnique,
-        referencedByTable: rel.referencedBy.name,
-        type: rel.type,
-        keys: transformFields(rel.keys),
-    };
-}
-/**
- * Transform manyToMany relation
- */
-function transformManyToMany(rel) {
-    return {
-        fieldName: rel.fieldName,
-        rightTable: rel.rightTable.name,
-        junctionTable: rel.junctionTable.name,
-        type: rel.type,
-    };
-}
-/**
- * Transform inflection data
- */
-function transformInflection(inflection) {
-    return {
-        allRows: inflection.allRows,
-        allRowsSimple: inflection.allRowsSimple,
-        conditionType: inflection.conditionType,
-        connection: inflection.connection,
-        createField: inflection.createField,
-        createInputType: inflection.createInputType,
-        createPayloadType: inflection.createPayloadType,
-        deleteByPrimaryKey: inflection.deleteByPrimaryKey,
-        deletePayloadType: inflection.deletePayloadType,
-        edge: inflection.edge,
-        edgeField: inflection.edgeField,
-        enumType: inflection.enumType,
-        filterType: inflection.filterType,
-        inputType: inflection.inputType,
-        orderByType: inflection.orderByType,
-        patchField: inflection.patchField,
-        patchType: inflection.patchType,
-        tableFieldName: inflection.tableFieldName,
-        tableType: inflection.tableType,
-        typeName: inflection.typeName,
-        updateByPrimaryKey: inflection.updateByPrimaryKey,
-        updatePayloadType: inflection.updatePayloadType,
-    };
-}
-/**
- * Transform query names
- */
-function transformQuery(query) {
-    return {
-        all: query.all,
-        one: query.one,
-        create: query.create,
-        update: query.update,
-        delete: query.delete,
-    };
-}
-/**
- * Transform constraints
- */
-function transformConstraints(table) {
-    return {
-        primaryKey: table.primaryKeyConstraints.map(transformConstraint),
-        foreignKey: table.foreignKeyConstraints.map(transformForeignKeyConstraint),
-        unique: table.uniqueConstraints.map(transformConstraint),
-    };
-}
-/**
- * Transform a basic constraint
- */
-function transformConstraint(constraint) {
-    return {
-        name: constraint.name,
-        fields: transformFields(constraint.fields),
-    };
-}
-/**
- * Transform a foreign key constraint
- */
-function transformForeignKeyConstraint(constraint) {
-    return {
-        name: constraint.name,
-        fields: transformFields(constraint.fields),
-        refTable: constraint.refTable.name,
-        refFields: transformFields(constraint.refFields),
-    };
-}
 /**
  * Get table names from CleanTable array
  */

package/esm/cli/watch/cache.d.ts

@@ -4,11 +4,10 @@
  * Only stores the hash in memory - no file I/O during normal operation.
  * Touch file feature is optional and only writes when explicitly configured.
  */
-import type { MetaQueryResponse } from '../introspect/meta-query';
 import type { IntrospectionQueryResponse } from '../../types/introspection';
 /**
  * Lightweight in-memory schema cache
- * Only stores the combined hash string to detect changes
+ * Only stores the schema hash string to detect changes
  */
 export declare class SchemaCache {
     /** Current schema hash (in-memory only) */
@@ -17,7 +16,7 @@ export declare class SchemaCache {
      * Check if schema has changed by comparing hashes
      * This is the hot path - must be efficient
      */
-    hasChanged(meta: MetaQueryResponse, schema: IntrospectionQueryResponse): Promise<{
+    hasChanged(schema: IntrospectionQueryResponse): Promise<{
         changed: boolean;
         newHash: string;
     }>;
@@ -34,7 +33,7 @@ export declare class SchemaCache {
      */
     clear(): void;
     /**
-     * Compute hash from meta and schema responses
+     * Compute hash from schema response
      */
     private computeHash;
 }

package/esm/cli/watch/cache.js

@@ -6,10 +6,10 @@
  */
 import * as fs from 'node:fs';
 import * as path from 'node:path';
-import { hashObject, combineHashes } from './hash';
+import { hashObject } from './hash';
 /**
  * Lightweight in-memory schema cache
- * Only stores the combined hash string to detect changes
+ * Only stores the schema hash string to detect changes
  */
 export class SchemaCache {
     /** Current schema hash (in-memory only) */
@@ -18,8 +18,8 @@ export class SchemaCache {
      * Check if schema has changed by comparing hashes
      * This is the hot path - must be efficient
      */
-    async hasChanged(meta, schema) {
-        const newHash = await this.computeHash(meta, schema);
+    async hasChanged(schema) {
+        const newHash = await this.computeHash(schema);
         const changed = this.currentHash === null || this.currentHash !== newHash;
         return { changed, newHash };
     }
@@ -42,14 +42,10 @@ export class SchemaCache {
         this.currentHash = null;
     }
     /**
-     * Compute hash from meta and schema responses
+     * Compute hash from schema response
      */
-    async computeHash(meta, schema) {
-        // Hash each response separately then combine
-        // This is more efficient than stringifying both together
-        const metaHash = await hashObject(meta);
-        const schemaHash = await hashObject(schema);
-        return combineHashes(metaHash, schemaHash);
+    async computeHash(schema) {
+        return hashObject(schema);
     }
 }
 /**

package/esm/cli/watch/poller.d.ts

@@ -5,7 +5,6 @@
  * No file I/O during normal polling - only touchFile is optional file write.
  */
 import { EventEmitter } from 'node:events';
-import type { MetaQueryResponse } from '../introspect/meta-query';
 import type { IntrospectionQueryResponse } from '../../types/introspection';
 import { SchemaCache } from './cache';
 import type { PollResult, WatchOptions } from './types';
@@ -62,4 +61,4 @@ export declare class SchemaPoller extends EventEmitter {
 /**
  * Utility to compute schema hash without full poll
  */
-export declare function computeSchemaHash(meta: MetaQueryResponse, schema: IntrospectionQueryResponse): Promise<string>;
+export declare function computeSchemaHash(schema: IntrospectionQueryResponse): Promise<string>;

package/esm/cli/watch/poller.js

@@ -5,10 +5,9 @@
  * No file I/O during normal polling - only touchFile is optional file write.
  */
 import { EventEmitter } from 'node:events';
-import { fetchMeta } from '../introspect/fetch-meta';
 import { fetchSchema } from '../introspect/fetch-schema';
 import { SchemaCache, touchFile } from './cache';
-import { hashObject, combineHashes } from './hash';
+import { hashObject } from './hash';
 /**
  * Schema poller that periodically introspects a GraphQL endpoint
  * and emits events when the schema changes.
@@ -56,39 +55,31 @@ export class SchemaPoller extends EventEmitter {
     async poll() {
         // Prevent concurrent polls
         if (this.isPolling) {
-            return { success: false, changed: false, error: 'Poll already in progress' };
+            return {
+                success: false,
+                changed: false,
+                error: 'Poll already in progress',
+            };
         }
         this.isPolling = true;
         const startTime = Date.now();
         this.emit('poll-start', this.createEvent('poll-start'));
         try {
-            // Fetch both _meta and __schema
-            const [metaResult, schemaResult] = await Promise.all([
-                fetchMeta({
-                    endpoint: this.options.endpoint,
-                    authorization: this.options.authorization,
-                    headers: this.options.headers,
-                    timeout: 30000,
-                }),
-                fetchSchema({
-                    endpoint: this.options.endpoint,
-                    authorization: this.options.authorization,
-                    headers: this.options.headers,
-                    timeout: 30000,
-                }),
-            ]);
+            // Fetch __schema via standard introspection
+            const schemaResult = await fetchSchema({
+                endpoint: this.options.endpoint,
+                authorization: this.options.authorization,
+                headers: this.options.headers,
+                timeout: 30000,
+            });
             const duration = Date.now() - startTime;
             // Check for errors
-            if (!metaResult.success) {
-                return this.handleError(`_meta fetch failed: ${metaResult.error}`, duration);
-            }
             if (!schemaResult.success) {
                 return this.handleError(`__schema fetch failed: ${schemaResult.error}`, duration);
             }
-            const meta = metaResult.data;
             const schema = schemaResult.data;
             // Check if schema changed
-            const { changed, newHash } = await this.cache.hasChanged(meta, schema);
+            const { changed, newHash } = await this.cache.hasChanged(schema);
             // Reset error counter on success
             this.consecutiveErrors = 0;
             if (changed) {
@@ -99,11 +90,11 @@ export class SchemaPoller extends EventEmitter {
                     touchFile(this.options.touchFile);
                 }
                 this.emit('schema-changed', this.createEvent('schema-changed', { hash: newHash, duration }));
-                return { success: true, changed: true, hash: newHash, meta, schema };
+                return { success: true, changed: true, hash: newHash, schema };
             }
             this.emit('schema-unchanged', this.createEvent('schema-unchanged', { duration }));
             this.emit('poll-success', this.createEvent('poll-success', { duration }));
-            return { success: true, changed: false, hash: newHash, meta, schema };
+            return { success: true, changed: false, hash: newHash, schema };
         }
         catch (err) {
             const duration = Date.now() - startTime;
@@ -126,22 +117,14 @@ export class SchemaPoller extends EventEmitter {
      */
     async seedCache() {
         try {
-            const [metaResult, schemaResult] = await Promise.all([
-                fetchMeta({
-                    endpoint: this.options.endpoint,
-                    authorization: this.options.authorization,
-                    headers: this.options.headers,
-                    timeout: 30000,
-                }),
-                fetchSchema({
-                    endpoint: this.options.endpoint,
-                    authorization: this.options.authorization,
-                    headers: this.options.headers,
-                    timeout: 30000,
-                }),
-            ]);
-            if (metaResult.success && schemaResult.success) {
-                const { newHash } = await this.cache.hasChanged(metaResult.data, schemaResult.data);
+            const schemaResult = await fetchSchema({
+                endpoint: this.options.endpoint,
+                authorization: this.options.authorization,
+                headers: this.options.headers,
+                timeout: 30000,
+            });
+            if (schemaResult.success) {
+                const { newHash } = await this.cache.hasChanged(schemaResult.data);
                 this.cache.updateHash(newHash);
             }
         }
@@ -171,7 +154,8 @@ export class SchemaPoller extends EventEmitter {
         this.consecutiveErrors++;
         this.emit('poll-error', this.createEvent('poll-error', { error, duration }));
         // Slow down polling after multiple consecutive errors
-        if (this.consecutiveErrors >= this.MAX_CONSECUTIVE_ERRORS && this.pollTimer) {
+        if (this.consecutiveErrors >= this.MAX_CONSECUTIVE_ERRORS &&
+            this.pollTimer) {
             this.stop();
             const newInterval = this.options.pollInterval * 2;
             this.pollTimer = setInterval(() => {
@@ -191,8 +175,6 @@ export class SchemaPoller extends EventEmitter {
 /**
  * Utility to compute schema hash without full poll
  */
-export async function computeSchemaHash(meta, schema) {
-    const metaHash = await hashObject(meta);
-    const schemaHash = await hashObject(schema);
-    return combineHashes(metaHash, schemaHash);
+export async function computeSchemaHash(schema) {
+    return hashObject(schema);
 }

package/esm/cli/watch/types.d.ts

@@ -1,7 +1,6 @@
 /**
  * Watch mode types
  */
-import type { MetaQueryResponse } from '../introspect/meta-query';
 import type { IntrospectionQueryResponse } from '../../types/introspection';
 /**
  * Result of a schema poll operation
@@ -14,8 +13,6 @@ export interface PollResult {
     error?: string;
     /** The new hash if successful */
     hash?: string;
-    /** Meta response if successful */
-    meta?: MetaQueryResponse;
     /** Schema response if successful */
     schema?: IntrospectionQueryResponse;
 }