@constructive-io/graphql-codegen 2.22.1 → 2.23.0

package/cli/introspect/pluralize.js

@@ -0,0 +1,124 @@
+"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.singularize = singularize;
+exports.pluralize = pluralize;
+exports.lcFirst = lcFirst;
+exports.ucFirst = ucFirst;
+exports.toFieldName = toFieldName;
+exports.toQueryName = toQueryName;
+/**
+ * Pluralization utilities for inferring entity names from PostGraphile patterns
+ *
+ * Uses the 'inflection' package which is already a dependency of this package.
+ */
+const inflection = __importStar(require("inflection"));
+/**
+ * Latin plural suffixes that inflection handles differently than PostGraphile.
+ *
+ * The inflection library correctly singularizes Latin words (schemata → schematum),
+ * but PostGraphile uses English-style naming (schemata → schema).
+ *
+ * Format: [pluralSuffix, singularSuffix]
+ */
+const LATIN_SUFFIX_OVERRIDES = [
+    // Common Latin plural endings
+    ['schemata', 'schema'],
+    ['criteria', 'criterion'],
+    ['phenomena', 'phenomenon'],
+    ['media', 'medium'],
+    ['memoranda', 'memorandum'],
+    ['strata', 'stratum'],
+    ['curricula', 'curriculum'],
+    ['data', 'datum'],
+];
+/**
+ * Convert a word to its singular form
+ * @example "Users" → "User", "People" → "Person", "Schemata" → "Schema", "ApiSchemata" → "ApiSchema"
+ */
+function singularize(word) {
+    // Check for Latin suffix overrides (handles compound words like "ApiSchemata")
+    const lowerWord = word.toLowerCase();
+    for (const [pluralSuffix, singularSuffix] of LATIN_SUFFIX_OVERRIDES) {
+        if (lowerWord.endsWith(pluralSuffix)) {
+            // Find where the suffix starts in the original word (preserving case)
+            const suffixStart = word.length - pluralSuffix.length;
+            const prefix = word.slice(0, suffixStart);
+            const originalSuffix = word.slice(suffixStart);
+            // Preserve the casing of the first letter of the suffix
+            const isUpperSuffix = originalSuffix[0] === originalSuffix[0].toUpperCase();
+            const newSuffix = isUpperSuffix
+                ? singularSuffix.charAt(0).toUpperCase() + singularSuffix.slice(1)
+                : singularSuffix;
+            return prefix + newSuffix;
+        }
+    }
+    return inflection.singularize(word);
+}
+/**
+ * Convert a word to its plural form
+ * @example "User" → "Users", "Person" → "People"
+ */
+function pluralize(word) {
+    return inflection.pluralize(word);
+}
+/**
+ * Convert PascalCase to camelCase
+ * @example "UserProfile" → "userProfile"
+ */
+function lcFirst(str) {
+    return str.charAt(0).toLowerCase() + str.slice(1);
+}
+/**
+ * Convert camelCase to PascalCase
+ * @example "userProfile" → "UserProfile"
+ */
+function ucFirst(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}
+/**
+ * Convert a plural PascalCase type name to singular camelCase field name
+ * @example "Users" → "user", "OrderItems" → "orderItem"
+ */
+function toFieldName(pluralTypeName) {
+    return lcFirst(singularize(pluralTypeName));
+}
+/**
+ * Convert a singular PascalCase type name to plural camelCase query name
+ * @example "User" → "users", "OrderItem" → "orderItems"
+ */
+function toQueryName(singularTypeName) {
+    return lcFirst(pluralize(singularTypeName));
+}

package/cli/introspect/source/endpoint.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Endpoint Schema Source
+ *
+ * Fetches GraphQL schema via introspection from a live endpoint.
+ * Wraps the existing fetchSchema() function with the SchemaSource interface.
+ */
+import type { SchemaSource, SchemaSourceResult } from './types';
+export interface EndpointSchemaSourceOptions {
+    /**
+     * GraphQL endpoint URL
+     */
+    endpoint: string;
+    /**
+     * Optional authorization header value (e.g., "Bearer token")
+     */
+    authorization?: string;
+    /**
+     * Optional additional headers
+     */
+    headers?: Record<string, string>;
+    /**
+     * Request timeout in milliseconds (default: 30000)
+     */
+    timeout?: number;
+}
+/**
+ * Schema source that fetches from a live GraphQL endpoint
+ */
+export declare class EndpointSchemaSource implements SchemaSource {
+    private readonly options;
+    constructor(options: EndpointSchemaSourceOptions);
+    fetch(): Promise<SchemaSourceResult>;
+    describe(): string;
+}

package/cli/introspect/source/endpoint.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EndpointSchemaSource = void 0;
+const types_1 = require("./types");
+const fetch_schema_1 = require("../fetch-schema");
+/**
+ * Schema source that fetches from a live GraphQL endpoint
+ */
+class EndpointSchemaSource {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async fetch() {
+        const result = await (0, fetch_schema_1.fetchSchema)({
+            endpoint: this.options.endpoint,
+            authorization: this.options.authorization,
+            headers: this.options.headers,
+            timeout: this.options.timeout,
+        });
+        if (!result.success) {
+            throw new types_1.SchemaSourceError(result.error ?? 'Unknown error fetching schema', this.describe());
+        }
+        if (!result.data) {
+            throw new types_1.SchemaSourceError('No introspection data returned', this.describe());
+        }
+        return {
+            introspection: result.data,
+        };
+    }
+    describe() {
+        return `endpoint: ${this.options.endpoint}`;
+    }
+}
+exports.EndpointSchemaSource = EndpointSchemaSource;

package/cli/introspect/source/file.d.ts

@@ -0,0 +1,20 @@
+import type { SchemaSource, SchemaSourceResult } from './types';
+export interface FileSchemaSourceOptions {
+    /**
+     * Path to the GraphQL schema file (.graphql)
+     * Can be absolute or relative to current working directory
+     */
+    schemaPath: string;
+}
+/**
+ * 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 declare class FileSchemaSource implements SchemaSource {
+    private readonly options;
+    constructor(options: FileSchemaSourceOptions);
+    fetch(): Promise<SchemaSourceResult>;
+    describe(): string;
+}

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
  */