@constructive-io/graphql-query 2.8.0 → 3.0.1

package/ast.d.ts

@@ -1,4 +1,4 @@
-import type { DocumentNode, FieldNode } from 'graphql';
+import { type DocumentNode, type FieldNode } from 'graphql';
 import type { ASTFunctionParams, FieldSelection, MutationASTParams } from './types';
 export declare const getAll: ({ queryName, operationName, query: _query, selection, }: ASTFunctionParams) => DocumentNode;
 export declare const getCount: ({ queryName, operationName, query, }: Omit<ASTFunctionParams, "selection">) => DocumentNode;

package/ast.js

@@ -36,6 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.deleteOne = exports.patchOne = exports.createOne = exports.getOne = exports.getMany = exports.getCount = exports.getAll = void 0;
 exports.getSelections = getSelections;
 const t = __importStar(require("gql-ast"));
+const graphql_1 = require("graphql");
 const inflection_1 = require("inflection");
 const custom_ast_1 = require("./custom-ast");
 const NON_MUTABLE_PROPS = ['createdAt', 'createdBy', 'updatedAt', 'updatedBy'];
@@ -76,7 +77,7 @@ const createGqlMutation = ({ operationName, mutationName, selectArgs, selections
     return t.document({
         definitions: [
             t.operationDefinition({
-                operation: 'mutation',
+                operation: graphql_1.OperationTypeNode.MUTATION,
                 name: mutationName,
                 variableDefinitions,
                 selectionSet: t.selectionSet({ selections: opSel }),
@@ -105,7 +106,7 @@ const getAll = ({ queryName, operationName, query: _query, selection, }) => {
     const ast = t.document({
         definitions: [
             t.operationDefinition({
-                operation: 'query',
+                operation: graphql_1.OperationTypeNode.QUERY,
                 name: queryName,
                 selectionSet: t.selectionSet({ selections: opSel }),
             }),
@@ -149,7 +150,7 @@ const getCount = ({ queryName, operationName, query, }) => {
     const ast = t.document({
         definitions: [
             t.operationDefinition({
-                operation: 'query',
+                operation: graphql_1.OperationTypeNode.QUERY,
                 name: queryName,
                 variableDefinitions,
                 selectionSet: t.selectionSet({ selections: opSel }),
@@ -246,7 +247,7 @@ const getMany = ({ builder, queryName, operationName, query, selection, }) => {
     const ast = t.document({
         definitions: [
             t.operationDefinition({
-                operation: 'query',
+                operation: graphql_1.OperationTypeNode.QUERY,
                 name: queryName,
                 variableDefinitions,
                 selectionSet: t.selectionSet({
@@ -303,7 +304,7 @@ const getOne = ({ queryName, operationName, query, selection, }) => {
     const ast = t.document({
         definitions: [
             t.operationDefinition({
-                operation: 'query',
+                operation: graphql_1.OperationTypeNode.QUERY,
                 name: queryName,
                 variableDefinitions,
                 selectionSet: t.selectionSet({ selections: opSel }),

package/custom-ast.js

@@ -42,6 +42,7 @@ exports.geometryAst = geometryAst;
 exports.intervalAst = intervalAst;
 exports.isIntervalType = isIntervalType;
 const t = __importStar(require("gql-ast"));
+const graphql_1 = require("graphql");
 function getCustomAst(fieldDefn) {
     if (!fieldDefn) {
         return null;
@@ -116,28 +117,28 @@ function geometryPointAst(name) {
 function geometryCollectionAst(name) {
     // Manually create inline fragment since gql-ast doesn't support it
     const inlineFragment = {
-        kind: 'InlineFragment',
+        kind: graphql_1.Kind.INLINE_FRAGMENT,
         typeCondition: {
-            kind: 'NamedType',
+            kind: graphql_1.Kind.NAMED_TYPE,
             name: {
-                kind: 'Name',
+                kind: graphql_1.Kind.NAME,
                 value: 'GeometryPoint',
             },
         },
         selectionSet: {
-            kind: 'SelectionSet',
+            kind: graphql_1.Kind.SELECTION_SET,
             selections: [
                 {
-                    kind: 'Field',
+                    kind: graphql_1.Kind.FIELD,
                     name: {
-                        kind: 'Name',
+                        kind: graphql_1.Kind.NAME,
                         value: 'x',
                     },
                 },
                 {
-                    kind: 'Field',
+                    kind: graphql_1.Kind.FIELD,
                     name: {
-                        kind: 'Name',
+                        kind: graphql_1.Kind.NAME,
                         value: 'y',
                     },
                 },

package/esm/ast.js

@@ -1,4 +1,5 @@
 import * as t from 'gql-ast';
+import { OperationTypeNode, } from 'graphql';
 import { camelize, singularize } from 'inflection';
 import { getCustomAst } from './custom-ast';
 const NON_MUTABLE_PROPS = ['createdAt', 'createdBy', 'updatedAt', 'updatedBy'];
@@ -39,7 +40,7 @@ const createGqlMutation = ({ operationName, mutationName, selectArgs, selections
     return t.document({
         definitions: [
             t.operationDefinition({
-                operation: 'mutation',
+                operation: OperationTypeNode.MUTATION,
                 name: mutationName,
                 variableDefinitions,
                 selectionSet: t.selectionSet({ selections: opSel }),
@@ -68,7 +69,7 @@ export const getAll = ({ queryName, operationName, query: _query, selection, })
     const ast = t.document({
         definitions: [
             t.operationDefinition({
-                operation: 'query',
+                operation: OperationTypeNode.QUERY,
                 name: queryName,
                 selectionSet: t.selectionSet({ selections: opSel }),
             }),
@@ -111,7 +112,7 @@ export const getCount = ({ queryName, operationName, query, }) => {
     const ast = t.document({
         definitions: [
             t.operationDefinition({
-                operation: 'query',
+                operation: OperationTypeNode.QUERY,
                 name: queryName,
                 variableDefinitions,
                 selectionSet: t.selectionSet({ selections: opSel }),
@@ -207,7 +208,7 @@ export const getMany = ({ builder, queryName, operationName, query, selection, }
     const ast = t.document({
         definitions: [
             t.operationDefinition({
-                operation: 'query',
+                operation: OperationTypeNode.QUERY,
                 name: queryName,
                 variableDefinitions,
                 selectionSet: t.selectionSet({
@@ -263,7 +264,7 @@ export const getOne = ({ queryName, operationName, query, selection, }) => {
     const ast = t.document({
         definitions: [
             t.operationDefinition({
-                operation: 'query',
+                operation: OperationTypeNode.QUERY,
                 name: queryName,
                 variableDefinitions,
                 selectionSet: t.selectionSet({ selections: opSel }),

package/esm/custom-ast.js

@@ -1,4 +1,5 @@
 import * as t from 'gql-ast';
+import { Kind } from 'graphql';
 export function getCustomAst(fieldDefn) {
     if (!fieldDefn) {
         return null;
@@ -73,28 +74,28 @@ export function geometryPointAst(name) {
 export function geometryCollectionAst(name) {
     // Manually create inline fragment since gql-ast doesn't support it
     const inlineFragment = {
-        kind: 'InlineFragment',
+        kind: Kind.INLINE_FRAGMENT,
         typeCondition: {
-            kind: 'NamedType',
+            kind: Kind.NAMED_TYPE,
             name: {
-                kind: 'Name',
+                kind: Kind.NAME,
                 value: 'GeometryPoint',
             },
         },
         selectionSet: {
-            kind: 'SelectionSet',
+            kind: Kind.SELECTION_SET,
             selections: [
                 {
-                    kind: 'Field',
+                    kind: Kind.FIELD,
                     name: {
-                        kind: 'Name',
+                        kind: Kind.NAME,
                         value: 'x',
                     },
                 },
                 {
-                    kind: 'Field',
+                    kind: Kind.FIELD,
                     name: {
-                        kind: 'Name',
+                        kind: Kind.NAME,
                         value: 'y',
                     },
                 },

package/esm/executor.js

@@ -0,0 +1,176 @@
+/**
+ * QueryExecutor - Execute GraphQL queries using Grafast/PostGraphile v5
+ *
+ * This module provides a high-level interface for executing GraphQL queries
+ * against a PostgreSQL database using PostGraphile v5's Grafast execution engine.
+ */
+import { execute } from 'grafast';
+import { postgraphile } from 'postgraphile';
+import { ConstructivePreset, makePgService } from 'graphile-settings';
+import { withPgClientFromPgService } from 'graphile-build-pg';
+import { LRUCache } from 'lru-cache';
+/**
+ * Global cache for executor instances, keyed by connection string + schemas
+ */
+const executorCache = new LRUCache({
+    max: 10,
+    dispose: async (entry) => {
+        try {
+            await entry.pgl.release();
+        }
+        catch {
+            // Ignore disposal errors
+        }
+    },
+});
+/**
+ * Build a cache key from connection string and schemas
+ */
+const buildCacheKey = (connectionString, schemas) => {
+    return `${connectionString}:${schemas.sort().join(',')}`;
+};
+/**
+ * QueryExecutor - Execute GraphQL queries using Grafast
+ *
+ * Example usage:
+ * ```typescript
+ * const executor = new QueryExecutor({
+ *   connectionString: 'postgres://user:pass@localhost/db',
+ *   schemas: ['public'],
+ *   pgSettings: { role: 'authenticated' },
+ * });
+ *
+ * await executor.initialize();
+ *
+ * const result = await executor.execute<{ allUsers: { nodes: User[] } }>(
+ *   parse('query { allUsers { nodes { id name } } }')
+ * );
+ * ```
+ */
+export class QueryExecutor {
+    options;
+    executor = null;
+    cacheKey;
+    constructor(options) {
+        this.options = options;
+        this.cacheKey = buildCacheKey(options.connectionString, options.schemas);
+    }
+    /**
+     * Initialize the executor by building or retrieving the PostGraphile schema
+     *
+     * This method is called automatically by execute() if not already initialized,
+     * but can be called explicitly for eager initialization.
+     */
+    async initialize() {
+        // Check cache first
+        const cached = executorCache.get(this.cacheKey);
+        if (cached) {
+            this.executor = cached;
+            return;
+        }
+        // Create new PostGraphile instance
+        const pgService = makePgService({
+            connectionString: this.options.connectionString,
+            schemas: this.options.schemas,
+        });
+        // Note: Using 'as unknown as' to bypass strict type checking
+        // because GraphileConfig.Preset doesn't include pgServices in its type definition
+        // but postgraphile() accepts it at runtime
+        const preset = {
+            extends: [ConstructivePreset],
+            pgServices: [pgService],
+            grafast: {
+                context: () => ({
+                    pgSettings: this.options.pgSettings || {},
+                }),
+            },
+        };
+        const pgl = postgraphile(preset);
+        const schema = await pgl.getSchema();
+        const resolvedPreset = pgl.getResolvedPreset();
+        this.executor = {
+            pgl,
+            schema,
+            resolvedPreset,
+            pgService,
+            createdAt: Date.now(),
+        };
+        executorCache.set(this.cacheKey, this.executor);
+    }
+    /**
+     * Execute a GraphQL document against the schema
+     *
+     * @param document - Parsed GraphQL document (DocumentNode)
+     * @param variables - Optional variables for the query
+     * @param pgSettings - Optional per-request PostgreSQL settings (overrides constructor settings)
+     * @returns ExecutionResult with data and/or errors
+     */
+    async execute(document, variables, pgSettings) {
+        if (!this.executor) {
+            await this.initialize();
+        }
+        const { schema, resolvedPreset, pgService } = this.executor;
+        // Build context with pgSettings and withPgClient
+        const contextValue = {
+            pgSettings: pgSettings || this.options.pgSettings || {},
+        };
+        // Add withPgClient function using the pgService's configured key
+        const withPgClientKey = pgService.withPgClientKey ?? 'withPgClient';
+        contextValue[withPgClientKey] = withPgClientFromPgService.bind(null, pgService);
+        return execute({
+            schema,
+            document,
+            variableValues: variables,
+            contextValue,
+            resolvedPreset,
+        });
+    }
+    /**
+     * Get the GraphQL schema for introspection purposes
+     */
+    async getSchema() {
+        if (!this.executor) {
+            await this.initialize();
+        }
+        return this.executor.schema;
+    }
+    /**
+     * Get cache statistics
+     */
+    static getCacheStats() {
+        return {
+            size: executorCache.size,
+            maxSize: executorCache.max,
+        };
+    }
+    /**
+     * Clear all cached executors
+     */
+    static async clearCache() {
+        executorCache.clear();
+    }
+    /**
+     * Clear a specific executor from the cache
+     */
+    static async clearCacheEntry(connectionString, schemas) {
+        const key = buildCacheKey(connectionString, schemas);
+        return executorCache.delete(key);
+    }
+}
+/**
+ * Create a QueryExecutor instance with simplified options
+ *
+ * @param connectionString - PostgreSQL connection string
+ * @param schemas - Database schemas to expose
+ * @param pgSettings - Optional PostgreSQL settings
+ * @returns Initialized QueryExecutor
+ */
+export const createExecutor = async (connectionString, schemas, pgSettings) => {
+    const executor = new QueryExecutor({
+        connectionString,
+        schemas,
+        pgSettings,
+    });
+    await executor.initialize();
+    return executor;
+};

package/esm/index.js

@@ -1,3 +1,4 @@
 export { QueryBuilder } from './query-builder';
+export { QueryExecutor, createExecutor } from './executor';
 export * from './types';
 export * as MetaObject from './meta-object';

package/executor.d.ts

@@ -0,0 +1,88 @@
+/**
+ * QueryExecutor - Execute GraphQL queries using Grafast/PostGraphile v5
+ *
+ * This module provides a high-level interface for executing GraphQL queries
+ * against a PostgreSQL database using PostGraphile v5's Grafast execution engine.
+ */
+import type { DocumentNode, ExecutionResult, GraphQLSchema } from 'graphql';
+/**
+ * Configuration options for QueryExecutor
+ */
+export interface ExecutorOptions {
+    /** PostgreSQL connection string */
+    connectionString: string;
+    /** Database schemas to expose in the GraphQL schema */
+    schemas: string[];
+    /** PostgreSQL settings to apply (e.g., { role: 'authenticated' }) */
+    pgSettings?: Record<string, string>;
+    /** Maximum number of cached executor instances (default: 10) */
+    maxCacheSize?: number;
+}
+/**
+ * QueryExecutor - Execute GraphQL queries using Grafast
+ *
+ * Example usage:
+ * ```typescript
+ * const executor = new QueryExecutor({
+ *   connectionString: 'postgres://user:pass@localhost/db',
+ *   schemas: ['public'],
+ *   pgSettings: { role: 'authenticated' },
+ * });
+ *
+ * await executor.initialize();
+ *
+ * const result = await executor.execute<{ allUsers: { nodes: User[] } }>(
+ *   parse('query { allUsers { nodes { id name } } }')
+ * );
+ * ```
+ */
+export declare class QueryExecutor {
+    private options;
+    private executor;
+    private cacheKey;
+    constructor(options: ExecutorOptions);
+    /**
+     * Initialize the executor by building or retrieving the PostGraphile schema
+     *
+     * This method is called automatically by execute() if not already initialized,
+     * but can be called explicitly for eager initialization.
+     */
+    initialize(): Promise<void>;
+    /**
+     * Execute a GraphQL document against the schema
+     *
+     * @param document - Parsed GraphQL document (DocumentNode)
+     * @param variables - Optional variables for the query
+     * @param pgSettings - Optional per-request PostgreSQL settings (overrides constructor settings)
+     * @returns ExecutionResult with data and/or errors
+     */
+    execute<T = unknown>(document: DocumentNode, variables?: Record<string, unknown>, pgSettings?: Record<string, string>): Promise<ExecutionResult<T>>;
+    /**
+     * Get the GraphQL schema for introspection purposes
+     */
+    getSchema(): Promise<GraphQLSchema>;
+    /**
+     * Get cache statistics
+     */
+    static getCacheStats(): {
+        size: number;
+        maxSize: number;
+    };
+    /**
+     * Clear all cached executors
+     */
+    static clearCache(): Promise<void>;
+    /**
+     * Clear a specific executor from the cache
+     */
+    static clearCacheEntry(connectionString: string, schemas: string[]): Promise<boolean>;
+}
+/**
+ * Create a QueryExecutor instance with simplified options
+ *
+ * @param connectionString - PostgreSQL connection string
+ * @param schemas - Database schemas to expose
+ * @param pgSettings - Optional PostgreSQL settings
+ * @returns Initialized QueryExecutor
+ */
+export declare const createExecutor: (connectionString: string, schemas: string[], pgSettings?: Record<string, string>) => Promise<QueryExecutor>;

package/executor.js

@@ -0,0 +1,181 @@
+"use strict";
+/**
+ * QueryExecutor - Execute GraphQL queries using Grafast/PostGraphile v5
+ *
+ * This module provides a high-level interface for executing GraphQL queries
+ * against a PostgreSQL database using PostGraphile v5's Grafast execution engine.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createExecutor = exports.QueryExecutor = void 0;
+const grafast_1 = require("grafast");
+const postgraphile_1 = require("postgraphile");
+const graphile_settings_1 = require("graphile-settings");
+const graphile_build_pg_1 = require("graphile-build-pg");
+const lru_cache_1 = require("lru-cache");
+/**
+ * Global cache for executor instances, keyed by connection string + schemas
+ */
+const executorCache = new lru_cache_1.LRUCache({
+    max: 10,
+    dispose: async (entry) => {
+        try {
+            await entry.pgl.release();
+        }
+        catch {
+            // Ignore disposal errors
+        }
+    },
+});
+/**
+ * Build a cache key from connection string and schemas
+ */
+const buildCacheKey = (connectionString, schemas) => {
+    return `${connectionString}:${schemas.sort().join(',')}`;
+};
+/**
+ * QueryExecutor - Execute GraphQL queries using Grafast
+ *
+ * Example usage:
+ * ```typescript
+ * const executor = new QueryExecutor({
+ *   connectionString: 'postgres://user:pass@localhost/db',
+ *   schemas: ['public'],
+ *   pgSettings: { role: 'authenticated' },
+ * });
+ *
+ * await executor.initialize();
+ *
+ * const result = await executor.execute<{ allUsers: { nodes: User[] } }>(
+ *   parse('query { allUsers { nodes { id name } } }')
+ * );
+ * ```
+ */
+class QueryExecutor {
+    options;
+    executor = null;
+    cacheKey;
+    constructor(options) {
+        this.options = options;
+        this.cacheKey = buildCacheKey(options.connectionString, options.schemas);
+    }
+    /**
+     * Initialize the executor by building or retrieving the PostGraphile schema
+     *
+     * This method is called automatically by execute() if not already initialized,
+     * but can be called explicitly for eager initialization.
+     */
+    async initialize() {
+        // Check cache first
+        const cached = executorCache.get(this.cacheKey);
+        if (cached) {
+            this.executor = cached;
+            return;
+        }
+        // Create new PostGraphile instance
+        const pgService = (0, graphile_settings_1.makePgService)({
+            connectionString: this.options.connectionString,
+            schemas: this.options.schemas,
+        });
+        // Note: Using 'as unknown as' to bypass strict type checking
+        // because GraphileConfig.Preset doesn't include pgServices in its type definition
+        // but postgraphile() accepts it at runtime
+        const preset = {
+            extends: [graphile_settings_1.ConstructivePreset],
+            pgServices: [pgService],
+            grafast: {
+                context: () => ({
+                    pgSettings: this.options.pgSettings || {},
+                }),
+            },
+        };
+        const pgl = (0, postgraphile_1.postgraphile)(preset);
+        const schema = await pgl.getSchema();
+        const resolvedPreset = pgl.getResolvedPreset();
+        this.executor = {
+            pgl,
+            schema,
+            resolvedPreset,
+            pgService,
+            createdAt: Date.now(),
+        };
+        executorCache.set(this.cacheKey, this.executor);
+    }
+    /**
+     * Execute a GraphQL document against the schema
+     *
+     * @param document - Parsed GraphQL document (DocumentNode)
+     * @param variables - Optional variables for the query
+     * @param pgSettings - Optional per-request PostgreSQL settings (overrides constructor settings)
+     * @returns ExecutionResult with data and/or errors
+     */
+    async execute(document, variables, pgSettings) {
+        if (!this.executor) {
+            await this.initialize();
+        }
+        const { schema, resolvedPreset, pgService } = this.executor;
+        // Build context with pgSettings and withPgClient
+        const contextValue = {
+            pgSettings: pgSettings || this.options.pgSettings || {},
+        };
+        // Add withPgClient function using the pgService's configured key
+        const withPgClientKey = pgService.withPgClientKey ?? 'withPgClient';
+        contextValue[withPgClientKey] = graphile_build_pg_1.withPgClientFromPgService.bind(null, pgService);
+        return (0, grafast_1.execute)({
+            schema,
+            document,
+            variableValues: variables,
+            contextValue,
+            resolvedPreset,
+        });
+    }
+    /**
+     * Get the GraphQL schema for introspection purposes
+     */
+    async getSchema() {
+        if (!this.executor) {
+            await this.initialize();
+        }
+        return this.executor.schema;
+    }
+    /**
+     * Get cache statistics
+     */
+    static getCacheStats() {
+        return {
+            size: executorCache.size,
+            maxSize: executorCache.max,
+        };
+    }
+    /**
+     * Clear all cached executors
+     */
+    static async clearCache() {
+        executorCache.clear();
+    }
+    /**
+     * Clear a specific executor from the cache
+     */
+    static async clearCacheEntry(connectionString, schemas) {
+        const key = buildCacheKey(connectionString, schemas);
+        return executorCache.delete(key);
+    }
+}
+exports.QueryExecutor = QueryExecutor;
+/**
+ * Create a QueryExecutor instance with simplified options
+ *
+ * @param connectionString - PostgreSQL connection string
+ * @param schemas - Database schemas to expose
+ * @param pgSettings - Optional PostgreSQL settings
+ * @returns Initialized QueryExecutor
+ */
+const createExecutor = async (connectionString, schemas, pgSettings) => {
+    const executor = new QueryExecutor({
+        connectionString,
+        schemas,
+        pgSettings,
+    });
+    await executor.initialize();
+    return executor;
+};
+exports.createExecutor = createExecutor;

package/index.d.ts

@@ -1,3 +1,4 @@
 export { QueryBuilder } from './query-builder';
+export { QueryExecutor, createExecutor } from './executor';
 export * from './types';
 export * as MetaObject from './meta-object';

package/index.js

@@ -36,8 +36,11 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MetaObject = exports.QueryBuilder = void 0;
+exports.MetaObject = exports.createExecutor = exports.QueryExecutor = exports.QueryBuilder = void 0;
 var query_builder_1 = require("./query-builder");
 Object.defineProperty(exports, "QueryBuilder", { enumerable: true, get: function () { return query_builder_1.QueryBuilder; } });
+var executor_1 = require("./executor");
+Object.defineProperty(exports, "QueryExecutor", { enumerable: true, get: function () { return executor_1.QueryExecutor; } });
+Object.defineProperty(exports, "createExecutor", { enumerable: true, get: function () { return executor_1.createExecutor; } });
 __exportStar(require("./types"), exports);
 exports.MetaObject = __importStar(require("./meta-object"));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@constructive-io/graphql-query",
-  "version": "2.8.0",
+  "version": "3.0.1",
   "description": "Constructive GraphQL Query",
   "author": "Constructive <developers@constructive.io>",
   "main": "index.js",
@@ -30,9 +30,15 @@
   },
   "dependencies": {
     "ajv": "^7.0.4",
-    "gql-ast": "^2.7.0",
-    "graphql": "15.10.1",
-    "inflection": "^3.0.2"
+    "gql-ast": "^3.0.0",
+    "grafast": "^1.0.0-rc.4",
+    "graphile-build-pg": "^5.0.0-rc.3",
+    "graphile-config": "1.0.0-rc.3",
+    "graphile-settings": "^4.0.1",
+    "graphql": "^16.9.0",
+    "inflection": "^3.0.0",
+    "lru-cache": "^10.4.3",
+    "postgraphile": "^5.0.0-rc.4"
   },
   "keywords": [
     "query",
@@ -42,7 +48,7 @@
     "database"
   ],
   "devDependencies": {
-    "makage": "^0.1.12"
+    "makage": "^0.1.10"
   },
-  "gitHead": "048188f6b43ffaa6146e7694b2b0d35d34cb2945"
+  "gitHead": "c05d6bd3dfa36690aefe21079042666dfae801a1"
 }

package/types.d.ts

@@ -137,3 +137,27 @@ export declare function isGraphQLVariables(obj: unknown): obj is GraphQLVariable
 export type StrictRecord<K extends PropertyKey, V> = Record<K, V> & {
     [P in PropertyKey]: P extends K ? V : never;
 };
+/**
+ * Configuration options for QueryExecutor
+ */
+export interface ExecutorOptions {
+    /** PostgreSQL connection string */
+    connectionString: string;
+    /** Database schemas to expose in the GraphQL schema */
+    schemas: string[];
+    /** PostgreSQL settings to apply (e.g., { role: 'authenticated' }) */
+    pgSettings?: Record<string, string>;
+    /** Maximum number of cached executor instances (default: 10) */
+    maxCacheSize?: number;
+}
+/**
+ * Cache statistics for QueryExecutor
+ */
+export interface ExecutorCacheStats {
+    size: number;
+    maxSize: number;
+}
+/**
+ * Re-export GraphQL execution types for convenience
+ */
+export type { ExecutionResult, GraphQLError, GraphQLSchema, } from 'graphql';