@constructive-io/graphql-codegen 2.22.1 → 2.23.1

package/cli/introspect/source/file.js

@@ -0,0 +1,103 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileSchemaSource = void 0;
+/**
+ * File Schema Source
+ *
+ * Loads GraphQL schema from a local .graphql SDL file and converts it
+ * to introspection format using the graphql package.
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const graphql_1 = require("graphql");
+const types_1 = require("./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.
+ */
+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 types_1.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 types_1.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 types_1.SchemaSourceError('Schema file is empty', this.describe());
+        }
+        // Parse SDL to GraphQL schema
+        let schema;
+        try {
+            schema = (0, graphql_1.buildSchema)(sdl);
+        }
+        catch (err) {
+            throw new types_1.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 = (0, graphql_1.introspectionFromSchema)(schema);
+        }
+        catch (err) {
+            throw new types_1.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}`;
+    }
+}
+exports.FileSchemaSource = FileSchemaSource;

package/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/cli/introspect/source/index.js

@@ -0,0 +1,72 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSchemaSource = createSchemaSource;
+exports.validateSourceOptions = validateSourceOptions;
+/**
+ * Schema Source Module
+ *
+ * Provides a unified interface for loading GraphQL schemas from different sources:
+ * - Live GraphQL endpoints (via introspection)
+ * - Static .graphql schema files
+ */
+__exportStar(require("./types"), exports);
+__exportStar(require("./endpoint"), exports);
+__exportStar(require("./file"), exports);
+const endpoint_1 = require("./endpoint");
+const file_1 = require("./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
+ */
+function createSchemaSource(options) {
+    if (options.schema) {
+        return new file_1.FileSchemaSource({
+            schemaPath: options.schema,
+        });
+    }
+    if (options.endpoint) {
+        return new endpoint_1.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)
+ */
+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/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/cli/introspect/source/types.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchemaSourceError = void 0;
+/**
+ * Error thrown when a schema source fails to fetch
+ */
+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);
+    }
+}
+exports.SchemaSourceError = SchemaSourceError;

package/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/cli/introspect/transform.js

@@ -1,181 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformMetaToCleanTables = transformMetaToCleanTables;
 exports.getTableNames = getTableNames;
 exports.findTable = findTable;
 exports.filterTables = filterTables;
-/**
- * Transform _meta response to CleanTable array
- */
-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/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/cli/watch/cache.js

@@ -46,7 +46,7 @@ const path = __importStar(require("node:path"));
 const hash_1 = require("./hash");
 /**
  * Lightweight in-memory schema cache
- * Only stores the combined hash string to detect changes
+ * Only stores the schema hash string to detect changes
  */
 class SchemaCache {
     /** Current schema hash (in-memory only) */
@@ -55,8 +55,8 @@ 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 };
     }
@@ -79,14 +79,10 @@ 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 (0, hash_1.hashObject)(meta);
-        const schemaHash = await (0, hash_1.hashObject)(schema);
-        return (0, hash_1.combineHashes)(metaHash, schemaHash);
+    async computeHash(schema) {
+        return (0, hash_1.hashObject)(schema);
     }
 }
 exports.SchemaCache = SchemaCache;

package/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>;