@constructive-io/graphql-codegen 2.32.0 → 3.0.1

package/types/config.d.ts

@@ -1,6 +1,7 @@
 /**
  * SDK Configuration types
  */
+import type { PgConfig } from 'pg-env';
 /**
  * Entity relationship definition for cascade invalidation
  */
@@ -56,21 +57,84 @@ export interface QueryKeyConfig {
      */
     generateMutationKeys?: boolean;
 }
+/**
+ * PGPM module configuration for ephemeral database creation
+ */
+export interface PgpmConfig {
+    /**
+     * Path to a PGPM module directory
+     * Creates an ephemeral database, deploys the module, and introspects
+     */
+    modulePath?: string;
+    /**
+     * Path to a PGPM workspace directory
+     * Must be used together with `moduleName`
+     */
+    workspacePath?: string;
+    /**
+     * Name of the module within the PGPM workspace
+     * Must be used together with `workspacePath`
+     */
+    moduleName?: string;
+}
+/**
+ * Database configuration for direct database introspection
+ */
+export interface DbConfig {
+    /**
+     * PostgreSQL connection configuration
+     * Falls back to environment variables (PGHOST, PGPORT, PGUSER, PGPASSWORD, PGDATABASE)
+     * via @pgpmjs/env when not specified
+     */
+    config?: Partial<PgConfig>;
+    /**
+     * PGPM module configuration for ephemeral database creation
+     * When specified, creates an ephemeral database from the module
+     */
+    pgpm?: PgpmConfig;
+    /**
+     * PostgreSQL schemas to introspect
+     * Mutually exclusive with `apiNames`
+     * @example ['public', 'app_public']
+     */
+    schemas?: string[];
+    /**
+     * API names to resolve schemas from
+     * Queries services_public.api_schemas to automatically determine schemas
+     * Mutually exclusive with `schemas`
+     * @example ['my_api']
+     */
+    apiNames?: string[];
+    /**
+     * Keep the ephemeral database after introspection (for debugging)
+     * Only applies when using pgpm
+     * @default false
+     */
+    keepDb?: boolean;
+}
 /**
  * Target configuration for graphql-codegen
  * Represents a single schema source and output destination.
+ *
+ * Source options (choose one):
+ * - endpoint: GraphQL endpoint URL for live introspection
+ * - schemaFile: Path to GraphQL schema file (.graphql)
+ * - db: Database configuration for direct introspection or PGPM module
  */
 export interface GraphQLSDKConfigTarget {
     /**
      * GraphQL endpoint URL for live introspection
-     * Either endpoint or schema must be provided
      */
     endpoint?: string;
     /**
      * Path to GraphQL schema file (.graphql) for file-based generation
-     * Either endpoint or schema must be provided
      */
-    schema?: string;
+    schemaFile?: string;
+    /**
+     * Database configuration for direct database introspection or PGPM module
+     * Use db.schemas or db.apiNames to specify which schemas to introspect
+     */
+    db?: DbConfig;
     /**
      * Headers to include in introspection requests
      */
@@ -147,39 +211,18 @@ export interface GraphQLSDKConfigTarget {
         skipQueryField?: boolean;
     };
     /**
-     * ORM client generation options
-     * When set, generates a Prisma-like ORM client in addition to or instead of React Query hooks
-     */
-    orm?: {
-        /**
-         * Whether to generate ORM client
-         * @default false
-         */
-        enabled?: boolean;
-        /**
-         * Output directory for generated ORM client
-         * @default './generated/orm'
-         */
-        output?: string;
-        /**
-         * Whether to import shared types from hooks output or generate standalone
-         * When true, ORM types.ts will re-export from ../graphql/types
-         * @default true
-         */
-        useSharedTypes?: boolean;
-    };
+     * Whether to generate ORM client
+     * When enabled, generates a Prisma-like ORM client to {output}/orm
+     * @default false
+     */
+    orm?: boolean;
     /**
-     * React Query integration options
-     * Controls whether React Query hooks are generated
+     * Whether to generate React Query hooks
+     * When enabled, generates React Query hooks to {output}/hooks
+     * When false, only standalone fetch functions are generated (no React dependency)
+     * @default false
      */
-    reactQuery?: {
-        /**
-         * Whether to generate React Query hooks (useQuery, useMutation)
-         * When false, only standalone fetch functions are generated (no React dependency)
-         * @default false
-         */
-        enabled?: boolean;
-    };
+    reactQuery?: boolean;
     /**
      * Query key generation configuration
      * Controls how query keys are structured for cache management
@@ -190,24 +233,31 @@ export interface GraphQLSDKConfigTarget {
      * When enabled via CLI --watch flag, the CLI will poll the endpoint for schema changes
      */
     watch?: WatchConfig;
-}
-/**
- * Multi-target configuration for graphql-codegen
- */
-export interface GraphQLSDKMultiConfig {
     /**
-     * Shared defaults applied to every target
+     * Authorization header value (convenience option, also available in headers)
      */
-    defaults?: GraphQLSDKConfigTarget;
+    authorization?: string;
     /**
-     * Named target configurations
+     * Enable verbose output
+     * @default false
      */
-    targets: Record<string, GraphQLSDKConfigTarget>;
+    verbose?: boolean;
+    /**
+     * Dry run - don't write files, just show what would be generated
+     * @default false
+     */
+    dryRun?: boolean;
+    /**
+     * Skip custom operations (only generate table CRUD)
+     * @default false
+     */
+    skipCustomOperations?: boolean;
 }
 /**
  * Main configuration type for graphql-codegen
+ * This is the same as GraphQLSDKConfigTarget - we keep the alias for clarity.
  */
-export type GraphQLSDKConfig = GraphQLSDKConfigTarget | GraphQLSDKMultiConfig;
+export type GraphQLSDKConfig = GraphQLSDKConfigTarget;
 /**
  * Watch mode configuration options
  *
@@ -237,117 +287,30 @@ export interface WatchConfig {
      */
     clearScreen?: boolean;
 }
-/**
- * Resolved watch configuration with defaults applied
- */
-export interface ResolvedWatchConfig {
-    pollInterval: number;
-    debounce: number;
-    touchFile: string | null;
-    clearScreen: boolean;
-}
-/**
- * Resolved query key configuration with defaults applied
- */
-export interface ResolvedQueryKeyConfig {
-    style: 'flat' | 'hierarchical';
-    relationships: Record<string, EntityRelationship>;
-    generateScopedKeys: boolean;
-    generateCascadeHelpers: boolean;
-    generateMutationKeys: boolean;
-}
-/**
- * Resolved configuration with defaults applied
- */
-export interface ResolvedConfig {
-    /**
-     * GraphQL endpoint URL (empty string if using schema file)
-     */
-    endpoint: string;
-    /**
-     * Path to GraphQL schema file (null if using endpoint)
-     */
-    schema: string | null;
-    headers: Record<string, string>;
-    output: string;
-    tables: {
-        include: string[];
-        exclude: string[];
-        systemExclude: string[];
-    };
-    queries: {
-        include: string[];
-        exclude: string[];
-        systemExclude: string[];
-    };
-    mutations: {
-        include: string[];
-        exclude: string[];
-        systemExclude: string[];
-    };
-    excludeFields: string[];
-    hooks: {
-        queries: boolean;
-        mutations: boolean;
-        queryKeyPrefix: string;
-    };
-    postgraphile: {
-        schema: string;
-    };
-    codegen: {
-        maxFieldDepth: number;
-        skipQueryField: boolean;
-    };
-    orm: {
-        enabled: boolean;
-        output: string;
-        useSharedTypes: boolean;
-    };
-    reactQuery: {
-        enabled: boolean;
-    };
-    queryKeys: ResolvedQueryKeyConfig;
-    watch: ResolvedWatchConfig;
-}
 /**
  * Default watch configuration values
  */
-export declare const DEFAULT_WATCH_CONFIG: ResolvedWatchConfig;
+export declare const DEFAULT_WATCH_CONFIG: WatchConfig;
 /**
  * Default query key configuration values
  */
-export declare const DEFAULT_QUERY_KEY_CONFIG: ResolvedQueryKeyConfig;
+export declare const DEFAULT_QUERY_KEY_CONFIG: QueryKeyConfig;
 /**
  * Default configuration values
  */
-export declare const DEFAULT_CONFIG: ResolvedConfig;
+export declare const DEFAULT_CONFIG: GraphQLSDKConfigTarget;
 /**
  * Helper function to define configuration with type checking
  */
 export declare function defineConfig(config: GraphQLSDKConfig): GraphQLSDKConfig;
 /**
- * Resolved target configuration helper
- */
-export interface ResolvedTargetConfig {
-    name: string;
-    config: ResolvedConfig;
-}
-/**
- * Type guard for multi-target configs
- */
-export declare function isMultiConfig(config: GraphQLSDKConfig): config is GraphQLSDKMultiConfig;
-/**
- * Merge two target configs (defaults + overrides).
+ * Merge two configs (base + overrides).
  * Uses deepmerge with array replacement strategy - when a user specifies
  * an array like include: ['users'], it replaces the default ['*'] entirely.
  */
 export declare function mergeConfig(base: GraphQLSDKConfigTarget, overrides: GraphQLSDKConfigTarget): GraphQLSDKConfigTarget;
 /**
- * Resolve configuration by applying defaults.
- * Uses deepmerge with array replacement strategy.
- */
-export declare function resolveConfig(config: GraphQLSDKConfig): ResolvedConfig;
-/**
- * Resolve all targets in a multi-target config
+ * Get configuration options by merging defaults with user config.
+ * Similar to getEnvOptions pattern from @pgpmjs/env.
  */
-export declare function resolveConfigTargets(config: GraphQLSDKMultiConfig): ResolvedTargetConfig[];
+export declare function getConfigOptions(overrides?: GraphQLSDKConfigTarget): GraphQLSDKConfigTarget;

package/types/config.js

@@ -8,10 +8,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DEFAULT_CONFIG = exports.DEFAULT_QUERY_KEY_CONFIG = exports.DEFAULT_WATCH_CONFIG = void 0;
 exports.defineConfig = defineConfig;
-exports.isMultiConfig = isMultiConfig;
 exports.mergeConfig = mergeConfig;
-exports.resolveConfig = resolveConfig;
-exports.resolveConfigTargets = resolveConfigTargets;
+exports.getConfigOptions = getConfigOptions;
 const deepmerge_1 = __importDefault(require("deepmerge"));
 /**
  * Array merge strategy that replaces arrays (source wins over target).
@@ -25,7 +23,7 @@ const replaceArrays = (_target, source) => source;
 exports.DEFAULT_WATCH_CONFIG = {
     pollInterval: 3000,
     debounce: 800,
-    touchFile: null,
+    touchFile: undefined,
     clearScreen: true,
 };
 /**
@@ -43,7 +41,6 @@ exports.DEFAULT_QUERY_KEY_CONFIG = {
  */
 exports.DEFAULT_CONFIG = {
     endpoint: '',
-    schema: null,
     headers: {},
     output: './generated/graphql',
     tables: {
@@ -74,14 +71,8 @@ exports.DEFAULT_CONFIG = {
         maxFieldDepth: 2,
         skipQueryField: true,
     },
-    orm: {
-        enabled: false,
-        output: './generated/orm',
-        useSharedTypes: true,
-    },
-    reactQuery: {
-        enabled: false,
-    },
+    orm: false,
+    reactQuery: false,
     queryKeys: exports.DEFAULT_QUERY_KEY_CONFIG,
     watch: exports.DEFAULT_WATCH_CONFIG,
 };
@@ -92,14 +83,7 @@ function defineConfig(config) {
     return config;
 }
 /**
- * Type guard for multi-target configs
- */
-function isMultiConfig(config) {
-    const targets = config.targets;
-    return typeof targets === 'object' && targets !== null;
-}
-/**
- * Merge two target configs (defaults + overrides).
+ * Merge two configs (base + overrides).
  * Uses deepmerge with array replacement strategy - when a user specifies
  * an array like include: ['users'], it replaces the default ['*'] entirely.
  */
@@ -107,22 +91,9 @@ function mergeConfig(base, overrides) {
     return (0, deepmerge_1.default)(base, overrides, { arrayMerge: replaceArrays });
 }
 /**
- * Resolve configuration by applying defaults.
- * Uses deepmerge with array replacement strategy.
- */
-function resolveConfig(config) {
-    if (isMultiConfig(config)) {
-        throw new Error('Multi-target config cannot be resolved with resolveConfig(). Use resolveConfigTargets().');
-    }
-    return (0, deepmerge_1.default)(exports.DEFAULT_CONFIG, config, { arrayMerge: replaceArrays });
-}
-/**
- * Resolve all targets in a multi-target config
+ * Get configuration options by merging defaults with user config.
+ * Similar to getEnvOptions pattern from @pgpmjs/env.
  */
-function resolveConfigTargets(config) {
-    const defaults = config.defaults ?? {};
-    return Object.entries(config.targets).map(([name, target]) => ({
-        name,
-        config: resolveConfig(mergeConfig(defaults, target)),
-    }));
+function getConfigOptions(overrides = {}) {
+    return (0, deepmerge_1.default)(exports.DEFAULT_CONFIG, overrides, { arrayMerge: replaceArrays });
 }

package/types/index.d.ts

@@ -5,5 +5,5 @@ export type { CleanTable, CleanField, CleanFieldType, CleanRelations, CleanBelon
 export type { PageInfo, ConnectionResult, QueryOptions, OrderByItem, FilterOperator, FieldFilter, RelationalFilter, Filter, } from './query';
 export type { MutationOptions, CreateInput, UpdateInput, DeleteInput, MutationResult, } from './mutation';
 export type { SimpleFieldSelection, FieldSelectionPreset, FieldSelection, SelectionOptions, } from './selection';
-export type { GraphQLSDKConfig, GraphQLSDKConfigTarget, GraphQLSDKMultiConfig, ResolvedConfig, ResolvedTargetConfig, } from './config';
-export { defineConfig, resolveConfig, resolveConfigTargets, DEFAULT_CONFIG, } from './config';
+export type { GraphQLSDKConfig, GraphQLSDKConfigTarget, } from './config';
+export { defineConfig, getConfigOptions, mergeConfig, DEFAULT_CONFIG, } from './config';

package/types/index.js

@@ -3,9 +3,9 @@
  * Type exports for @constructive-io/graphql-codegen
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_CONFIG = exports.resolveConfigTargets = exports.resolveConfig = exports.defineConfig = void 0;
+exports.DEFAULT_CONFIG = exports.mergeConfig = exports.getConfigOptions = exports.defineConfig = void 0;
 var config_1 = require("./config");
 Object.defineProperty(exports, "defineConfig", { enumerable: true, get: function () { return config_1.defineConfig; } });
-Object.defineProperty(exports, "resolveConfig", { enumerable: true, get: function () { return config_1.resolveConfig; } });
-Object.defineProperty(exports, "resolveConfigTargets", { enumerable: true, get: function () { return config_1.resolveConfigTargets; } });
+Object.defineProperty(exports, "getConfigOptions", { enumerable: true, get: function () { return config_1.getConfigOptions; } });
+Object.defineProperty(exports, "mergeConfig", { enumerable: true, get: function () { return config_1.mergeConfig; } });
 Object.defineProperty(exports, "DEFAULT_CONFIG", { enumerable: true, get: function () { return config_1.DEFAULT_CONFIG; } });

package/cli/commands/generate-orm.d.ts

@@ -1,53 +0,0 @@
-/**
- * Generate ORM command - generates Prisma-like ORM client from GraphQL schema
- *
- * This command:
- * 1. Fetches schema from endpoint or loads from file
- * 2. Infers table metadata from introspection (replaces _meta)
- * 3. Generates a Prisma-like ORM client with fluent API
- */
-export interface GenerateOrmOptions {
-    /** Path to config file */
-    config?: string;
-    /** Named target in a multi-target config */
-    target?: string;
-    /** GraphQL endpoint URL (overrides config) */
-    endpoint?: string;
-    /** Path to GraphQL schema file (.graphql) */
-    schema?: string;
-    /** Output directory (overrides config) */
-    output?: string;
-    /** Authorization header */
-    authorization?: string;
-    /** Verbose output */
-    verbose?: boolean;
-    /** Dry run - don't write files */
-    dryRun?: boolean;
-    /** Skip custom operations (only generate table CRUD) */
-    skipCustomOperations?: boolean;
-}
-export interface GenerateOrmTargetResult {
-    name: string;
-    output: string;
-    success: boolean;
-    message: string;
-    tables?: string[];
-    customQueries?: string[];
-    customMutations?: string[];
-    filesWritten?: string[];
-    errors?: string[];
-}
-export interface GenerateOrmResult {
-    success: boolean;
-    message: string;
-    targets?: GenerateOrmTargetResult[];
-    tables?: string[];
-    customQueries?: string[];
-    customMutations?: string[];
-    filesWritten?: string[];
-    errors?: string[];
-}
-/**
- * Execute the generate-orm command (generates ORM client)
- */
-export declare function generateOrm(options?: GenerateOrmOptions): Promise<GenerateOrmResult>;