@constructive-io/graphql-query 3.2.4 → 3.3.0

package/client/error.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Error handling for GraphQL operations
+ * Provides consistent error types and parsing for PostGraphile responses
+ */
+export declare const DataErrorType: {
+    readonly NETWORK_ERROR: "NETWORK_ERROR";
+    readonly TIMEOUT_ERROR: "TIMEOUT_ERROR";
+    readonly VALIDATION_FAILED: "VALIDATION_FAILED";
+    readonly REQUIRED_FIELD_MISSING: "REQUIRED_FIELD_MISSING";
+    readonly INVALID_MUTATION_DATA: "INVALID_MUTATION_DATA";
+    readonly QUERY_GENERATION_FAILED: "QUERY_GENERATION_FAILED";
+    readonly QUERY_EXECUTION_FAILED: "QUERY_EXECUTION_FAILED";
+    readonly UNAUTHORIZED: "UNAUTHORIZED";
+    readonly FORBIDDEN: "FORBIDDEN";
+    readonly TABLE_NOT_FOUND: "TABLE_NOT_FOUND";
+    readonly BAD_REQUEST: "BAD_REQUEST";
+    readonly NOT_FOUND: "NOT_FOUND";
+    readonly GRAPHQL_ERROR: "GRAPHQL_ERROR";
+    readonly UNIQUE_VIOLATION: "UNIQUE_VIOLATION";
+    readonly FOREIGN_KEY_VIOLATION: "FOREIGN_KEY_VIOLATION";
+    readonly NOT_NULL_VIOLATION: "NOT_NULL_VIOLATION";
+    readonly CHECK_VIOLATION: "CHECK_VIOLATION";
+    readonly EXCLUSION_VIOLATION: "EXCLUSION_VIOLATION";
+    readonly UNKNOWN_ERROR: "UNKNOWN_ERROR";
+};
+export type DataErrorType = (typeof DataErrorType)[keyof typeof DataErrorType];
+export interface DataErrorOptions {
+    tableName?: string;
+    fieldName?: string;
+    constraint?: string;
+    originalError?: Error;
+    code?: string;
+    context?: Record<string, unknown>;
+}
+/**
+ * Standard error class for data layer operations
+ */
+export declare class DataError extends Error {
+    readonly type: DataErrorType;
+    readonly code?: string;
+    readonly originalError?: Error;
+    readonly context?: Record<string, unknown>;
+    readonly tableName?: string;
+    readonly fieldName?: string;
+    readonly constraint?: string;
+    constructor(type: DataErrorType, message: string, options?: DataErrorOptions);
+    getUserMessage(): string;
+    isRetryable(): boolean;
+}
+export declare const PG_ERROR_CODES: {
+    readonly UNIQUE_VIOLATION: "23505";
+    readonly FOREIGN_KEY_VIOLATION: "23503";
+    readonly NOT_NULL_VIOLATION: "23502";
+    readonly CHECK_VIOLATION: "23514";
+    readonly EXCLUSION_VIOLATION: "23P01";
+    readonly NUMERIC_VALUE_OUT_OF_RANGE: "22003";
+    readonly STRING_DATA_RIGHT_TRUNCATION: "22001";
+    readonly INVALID_TEXT_REPRESENTATION: "22P02";
+    readonly DATETIME_FIELD_OVERFLOW: "22008";
+    readonly UNDEFINED_TABLE: "42P01";
+    readonly UNDEFINED_COLUMN: "42703";
+    readonly INSUFFICIENT_PRIVILEGE: "42501";
+};
+export declare const createError: {
+    network: (originalError?: Error) => DataError;
+    timeout: (originalError?: Error) => DataError;
+    unauthorized: (message?: string) => DataError;
+    forbidden: (message?: string) => DataError;
+    badRequest: (message: string, code?: string) => DataError;
+    notFound: (message?: string) => DataError;
+    graphql: (message: string, code?: string) => DataError;
+    uniqueViolation: (message: string, fieldName?: string, constraint?: string) => DataError;
+    foreignKeyViolation: (message: string, fieldName?: string, constraint?: string) => DataError;
+    notNullViolation: (message: string, fieldName?: string, constraint?: string) => DataError;
+    unknown: (originalError: Error) => DataError;
+};
+export interface GraphQLError {
+    message: string;
+    extensions?: {
+        code?: string;
+    } & Record<string, unknown>;
+    locations?: Array<{
+        line: number;
+        column: number;
+    }>;
+    path?: Array<string | number>;
+}
+/**
+ * Parse any error into a DataError
+ */
+export declare function parseGraphQLError(error: unknown): DataError;
+/**
+ * Check if value is a DataError
+ */
+export declare function isDataError(error: unknown): error is DataError;

package/client/error.js

@@ -0,0 +1,277 @@
+"use strict";
+/**
+ * Error handling for GraphQL operations
+ * Provides consistent error types and parsing for PostGraphile responses
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createError = exports.PG_ERROR_CODES = exports.DataError = exports.DataErrorType = void 0;
+exports.parseGraphQLError = parseGraphQLError;
+exports.isDataError = isDataError;
+// ============================================================================
+// Error Types
+// ============================================================================
+exports.DataErrorType = {
+    // Network/Connection errors
+    NETWORK_ERROR: 'NETWORK_ERROR',
+    TIMEOUT_ERROR: 'TIMEOUT_ERROR',
+    // Validation errors
+    VALIDATION_FAILED: 'VALIDATION_FAILED',
+    REQUIRED_FIELD_MISSING: 'REQUIRED_FIELD_MISSING',
+    INVALID_MUTATION_DATA: 'INVALID_MUTATION_DATA',
+    // Query errors
+    QUERY_GENERATION_FAILED: 'QUERY_GENERATION_FAILED',
+    QUERY_EXECUTION_FAILED: 'QUERY_EXECUTION_FAILED',
+    // Permission errors
+    UNAUTHORIZED: 'UNAUTHORIZED',
+    FORBIDDEN: 'FORBIDDEN',
+    // Schema errors
+    TABLE_NOT_FOUND: 'TABLE_NOT_FOUND',
+    // Request errors
+    BAD_REQUEST: 'BAD_REQUEST',
+    NOT_FOUND: 'NOT_FOUND',
+    // GraphQL-specific errors
+    GRAPHQL_ERROR: 'GRAPHQL_ERROR',
+    // PostgreSQL constraint errors (surfaced via PostGraphile)
+    UNIQUE_VIOLATION: 'UNIQUE_VIOLATION',
+    FOREIGN_KEY_VIOLATION: 'FOREIGN_KEY_VIOLATION',
+    NOT_NULL_VIOLATION: 'NOT_NULL_VIOLATION',
+    CHECK_VIOLATION: 'CHECK_VIOLATION',
+    EXCLUSION_VIOLATION: 'EXCLUSION_VIOLATION',
+    // Generic errors
+    UNKNOWN_ERROR: 'UNKNOWN_ERROR',
+};
+/**
+ * Standard error class for data layer operations
+ */
+class DataError extends Error {
+    type;
+    code;
+    originalError;
+    context;
+    tableName;
+    fieldName;
+    constraint;
+    constructor(type, message, options = {}) {
+        super(message);
+        this.name = 'DataError';
+        this.type = type;
+        this.code = options.code;
+        this.originalError = options.originalError;
+        this.context = options.context;
+        this.tableName = options.tableName;
+        this.fieldName = options.fieldName;
+        this.constraint = options.constraint;
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, DataError);
+        }
+    }
+    getUserMessage() {
+        switch (this.type) {
+            case exports.DataErrorType.NETWORK_ERROR:
+                return 'Network error. Please check your connection and try again.';
+            case exports.DataErrorType.TIMEOUT_ERROR:
+                return 'Request timed out. Please try again.';
+            case exports.DataErrorType.UNAUTHORIZED:
+                return 'You are not authorized. Please log in and try again.';
+            case exports.DataErrorType.FORBIDDEN:
+                return 'You do not have permission to access this resource.';
+            case exports.DataErrorType.VALIDATION_FAILED:
+                return 'Validation failed. Please check your input and try again.';
+            case exports.DataErrorType.REQUIRED_FIELD_MISSING:
+                return this.fieldName
+                    ? `The field "${this.fieldName}" is required.`
+                    : 'A required field is missing.';
+            case exports.DataErrorType.UNIQUE_VIOLATION:
+                return this.fieldName
+                    ? `A record with this ${this.fieldName} already exists.`
+                    : 'A record with this value already exists.';
+            case exports.DataErrorType.FOREIGN_KEY_VIOLATION:
+                return 'This record references a record that does not exist.';
+            case exports.DataErrorType.NOT_NULL_VIOLATION:
+                return this.fieldName
+                    ? `The field "${this.fieldName}" cannot be empty.`
+                    : 'A required field cannot be empty.';
+            case exports.DataErrorType.CHECK_VIOLATION:
+                return this.fieldName
+                    ? `The value for "${this.fieldName}" is not valid.`
+                    : 'The value does not meet the required constraints.';
+            default:
+                return this.message || 'An unexpected error occurred.';
+        }
+    }
+    isRetryable() {
+        return (this.type === exports.DataErrorType.NETWORK_ERROR ||
+            this.type === exports.DataErrorType.TIMEOUT_ERROR);
+    }
+}
+exports.DataError = DataError;
+// ============================================================================
+// PostgreSQL Error Codes
+// ============================================================================
+exports.PG_ERROR_CODES = {
+    UNIQUE_VIOLATION: '23505',
+    FOREIGN_KEY_VIOLATION: '23503',
+    NOT_NULL_VIOLATION: '23502',
+    CHECK_VIOLATION: '23514',
+    EXCLUSION_VIOLATION: '23P01',
+    NUMERIC_VALUE_OUT_OF_RANGE: '22003',
+    STRING_DATA_RIGHT_TRUNCATION: '22001',
+    INVALID_TEXT_REPRESENTATION: '22P02',
+    DATETIME_FIELD_OVERFLOW: '22008',
+    UNDEFINED_TABLE: '42P01',
+    UNDEFINED_COLUMN: '42703',
+    INSUFFICIENT_PRIVILEGE: '42501',
+};
+// ============================================================================
+// Error Factory
+// ============================================================================
+exports.createError = {
+    network: (originalError) => new DataError(exports.DataErrorType.NETWORK_ERROR, 'Network error occurred', {
+        originalError,
+    }),
+    timeout: (originalError) => new DataError(exports.DataErrorType.TIMEOUT_ERROR, 'Request timed out', {
+        originalError,
+    }),
+    unauthorized: (message = 'Authentication required') => new DataError(exports.DataErrorType.UNAUTHORIZED, message),
+    forbidden: (message = 'Access forbidden') => new DataError(exports.DataErrorType.FORBIDDEN, message),
+    badRequest: (message, code) => new DataError(exports.DataErrorType.BAD_REQUEST, message, { code }),
+    notFound: (message = 'Resource not found') => new DataError(exports.DataErrorType.NOT_FOUND, message),
+    graphql: (message, code) => new DataError(exports.DataErrorType.GRAPHQL_ERROR, message, { code }),
+    uniqueViolation: (message, fieldName, constraint) => new DataError(exports.DataErrorType.UNIQUE_VIOLATION, message, {
+        fieldName,
+        constraint,
+        code: '23505',
+    }),
+    foreignKeyViolation: (message, fieldName, constraint) => new DataError(exports.DataErrorType.FOREIGN_KEY_VIOLATION, message, {
+        fieldName,
+        constraint,
+        code: '23503',
+    }),
+    notNullViolation: (message, fieldName, constraint) => new DataError(exports.DataErrorType.NOT_NULL_VIOLATION, message, {
+        fieldName,
+        constraint,
+        code: '23502',
+    }),
+    unknown: (originalError) => new DataError(exports.DataErrorType.UNKNOWN_ERROR, originalError.message, {
+        originalError,
+    }),
+};
+function parseGraphQLErrorCode(code) {
+    if (!code)
+        return exports.DataErrorType.UNKNOWN_ERROR;
+    const normalized = code.toUpperCase();
+    // GraphQL standard codes
+    if (normalized === 'UNAUTHENTICATED')
+        return exports.DataErrorType.UNAUTHORIZED;
+    if (normalized === 'FORBIDDEN')
+        return exports.DataErrorType.FORBIDDEN;
+    if (normalized === 'GRAPHQL_VALIDATION_FAILED')
+        return exports.DataErrorType.QUERY_GENERATION_FAILED;
+    // PostgreSQL SQLSTATE codes
+    if (code === exports.PG_ERROR_CODES.UNIQUE_VIOLATION)
+        return exports.DataErrorType.UNIQUE_VIOLATION;
+    if (code === exports.PG_ERROR_CODES.FOREIGN_KEY_VIOLATION)
+        return exports.DataErrorType.FOREIGN_KEY_VIOLATION;
+    if (code === exports.PG_ERROR_CODES.NOT_NULL_VIOLATION)
+        return exports.DataErrorType.NOT_NULL_VIOLATION;
+    if (code === exports.PG_ERROR_CODES.CHECK_VIOLATION)
+        return exports.DataErrorType.CHECK_VIOLATION;
+    if (code === exports.PG_ERROR_CODES.EXCLUSION_VIOLATION)
+        return exports.DataErrorType.EXCLUSION_VIOLATION;
+    return exports.DataErrorType.UNKNOWN_ERROR;
+}
+function classifyByMessage(message) {
+    const lower = message.toLowerCase();
+    if (lower.includes('timeout') || lower.includes('timed out')) {
+        return exports.DataErrorType.TIMEOUT_ERROR;
+    }
+    if (lower.includes('network') ||
+        lower.includes('fetch') ||
+        lower.includes('failed to fetch')) {
+        return exports.DataErrorType.NETWORK_ERROR;
+    }
+    if (lower.includes('unauthorized') ||
+        lower.includes('authentication required')) {
+        return exports.DataErrorType.UNAUTHORIZED;
+    }
+    if (lower.includes('forbidden') || lower.includes('permission')) {
+        return exports.DataErrorType.FORBIDDEN;
+    }
+    if (lower.includes('duplicate key') || lower.includes('already exists')) {
+        return exports.DataErrorType.UNIQUE_VIOLATION;
+    }
+    if (lower.includes('foreign key constraint')) {
+        return exports.DataErrorType.FOREIGN_KEY_VIOLATION;
+    }
+    if (lower.includes('not-null constraint') ||
+        lower.includes('null value in column')) {
+        return exports.DataErrorType.NOT_NULL_VIOLATION;
+    }
+    return exports.DataErrorType.UNKNOWN_ERROR;
+}
+function extractFieldFromError(message, constraint, column) {
+    if (column)
+        return column;
+    const columnMatch = message.match(/column\s+"?([a-z_][a-z0-9_]*)"?/i);
+    if (columnMatch)
+        return columnMatch[1];
+    if (constraint) {
+        const constraintMatch = constraint.match(/_([a-z_][a-z0-9_]*)_(?:key|fkey|check|pkey)$/i);
+        if (constraintMatch)
+            return constraintMatch[1];
+    }
+    const keyMatch = message.match(/Key\s+\(([a-z_][a-z0-9_]*)\)/i);
+    if (keyMatch)
+        return keyMatch[1];
+    return undefined;
+}
+/**
+ * Parse any error into a DataError
+ */
+function parseGraphQLError(error) {
+    if (error instanceof DataError) {
+        return error;
+    }
+    // GraphQL error object
+    if (error &&
+        typeof error === 'object' &&
+        'message' in error &&
+        typeof error.message === 'string') {
+        const gqlError = error;
+        const extCode = gqlError.extensions?.code;
+        const mappedType = parseGraphQLErrorCode(extCode);
+        const column = gqlError.extensions?.column;
+        const constraint = gqlError.extensions?.constraint;
+        const fieldName = extractFieldFromError(gqlError.message, constraint, column);
+        if (mappedType !== exports.DataErrorType.UNKNOWN_ERROR) {
+            return new DataError(mappedType, gqlError.message, {
+                code: extCode,
+                fieldName,
+                constraint,
+                context: gqlError.extensions,
+            });
+        }
+        // Fallback: classify by message
+        const fallbackType = classifyByMessage(gqlError.message);
+        return new DataError(fallbackType, gqlError.message, {
+            code: extCode,
+            fieldName,
+            constraint,
+            context: gqlError.extensions,
+        });
+    }
+    // Standard Error
+    if (error instanceof Error) {
+        const type = classifyByMessage(error.message);
+        return new DataError(type, error.message, { originalError: error });
+    }
+    // Unknown
+    const message = typeof error === 'string' ? error : 'Unknown error occurred';
+    return new DataError(exports.DataErrorType.UNKNOWN_ERROR, message);
+}
+/**
+ * Check if value is a DataError
+ */
+function isDataError(error) {
+    return error instanceof DataError;
+}

package/client/execute.d.ts

@@ -0,0 +1,57 @@
+/**
+ * GraphQL execution utilities
+ */
+import type { DocumentNode } from 'graphql';
+import { TypedDocumentString } from './typed-document';
+type ExecutableDocument = TypedDocumentString<unknown, unknown> | DocumentNode | string;
+type ResultOf<TDocument> = TDocument extends TypedDocumentString<infer TResult, unknown> ? TResult : unknown;
+type VariablesOf<TDocument> = TDocument extends TypedDocumentString<unknown, infer TVariables> ? TVariables : Record<string, unknown>;
+export interface ExecuteOptions {
+    /** Custom headers to include */
+    headers?: Record<string, string>;
+    /** Request timeout in milliseconds */
+    timeout?: number;
+    /** Signal for request cancellation */
+    signal?: AbortSignal;
+}
+export interface GraphQLResponse<T = unknown> {
+    data?: T;
+    errors?: Array<{
+        message: string;
+        extensions?: {
+            code?: string;
+        } & Record<string, unknown>;
+        locations?: Array<{
+            line: number;
+            column: number;
+        }>;
+        path?: Array<string | number>;
+    }>;
+}
+/**
+ * Execute a GraphQL operation against an endpoint
+ */
+export declare function execute<TDocument extends ExecutableDocument>(endpoint: string, document: TDocument, variables?: VariablesOf<TDocument>, options?: ExecuteOptions): Promise<ResultOf<TDocument>>;
+export interface GraphQLClientOptions {
+    /** GraphQL endpoint URL */
+    endpoint: string;
+    /** Default headers to include with every request */
+    headers?: Record<string, string>;
+    /** Default timeout in milliseconds */
+    timeout?: number;
+}
+/**
+ * Create a GraphQL client instance
+ */
+export declare function createGraphQLClient(options: GraphQLClientOptions): {
+    /**
+     * Execute a GraphQL operation
+     */
+    execute<TDocument extends ExecutableDocument>(document: TDocument, variables?: VariablesOf<TDocument>, options?: ExecuteOptions): Promise<ResultOf<TDocument>>;
+    /**
+     * Get the endpoint URL
+     */
+    getEndpoint(): string;
+};
+export type GraphQLClient = ReturnType<typeof createGraphQLClient>;
+export {};

package/client/execute.js

@@ -0,0 +1,124 @@
+"use strict";
+/**
+ * GraphQL execution utilities
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.execute = execute;
+exports.createGraphQLClient = createGraphQLClient;
+const graphql_1 = require("graphql");
+const error_1 = require("./error");
+const typed_document_1 = require("./typed-document");
+// ============================================================================
+// Helpers
+// ============================================================================
+function documentToString(document) {
+    if (typeof document === 'string')
+        return document;
+    if (document instanceof typed_document_1.TypedDocumentString)
+        return document.toString();
+    // DocumentNode
+    if (document && typeof document === 'object' && 'kind' in document) {
+        return (0, graphql_1.print)(document);
+    }
+    throw error_1.createError.badRequest('Invalid GraphQL document');
+}
+// ============================================================================
+// Execute Function
+// ============================================================================
+/**
+ * Execute a GraphQL operation against an endpoint
+ */
+async function execute(endpoint, document, variables, options = {}) {
+    const { headers = {}, timeout = 30000, signal } = options;
+    // Create timeout controller
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    // Combine signals if provided
+    const combinedSignal = signal
+        ? AbortSignal.any([signal, controller.signal])
+        : controller.signal;
+    try {
+        const response = await fetch(endpoint, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Accept: 'application/graphql-response+json, application/json',
+                ...headers,
+            },
+            body: JSON.stringify({
+                query: documentToString(document),
+                ...(variables !== undefined && { variables }),
+            }),
+            signal: combinedSignal,
+        });
+        clearTimeout(timeoutId);
+        if (!response.ok) {
+            throw await handleHttpError(response);
+        }
+        const result = await response.json();
+        if (result.errors?.length) {
+            throw (0, error_1.parseGraphQLError)(result.errors[0]);
+        }
+        return result.data;
+    }
+    catch (error) {
+        clearTimeout(timeoutId);
+        if (error instanceof Error && error.name === 'AbortError') {
+            throw error_1.createError.timeout();
+        }
+        if (error instanceof Error && error.message.includes('fetch')) {
+            throw error_1.createError.network(error);
+        }
+        throw (0, error_1.parseGraphQLError)(error);
+    }
+}
+async function handleHttpError(response) {
+    const { status, statusText } = response;
+    if (status === 401) {
+        return error_1.createError.unauthorized('Authentication required');
+    }
+    if (status === 403) {
+        return error_1.createError.forbidden('Access forbidden');
+    }
+    if (status === 404) {
+        return error_1.createError.notFound('GraphQL endpoint not found');
+    }
+    // Try to extract error from response body
+    try {
+        const body = await response.json();
+        if (body.errors?.length) {
+            return (0, error_1.parseGraphQLError)(body.errors[0]);
+        }
+        if (body.message) {
+            return error_1.createError.badRequest(body.message);
+        }
+    }
+    catch {
+        // Couldn't parse response
+    }
+    return error_1.createError.badRequest(`Request failed: ${status} ${statusText}`);
+}
+/**
+ * Create a GraphQL client instance
+ */
+function createGraphQLClient(options) {
+    const { endpoint, headers: defaultHeaders = {}, timeout: defaultTimeout = 30000, } = options;
+    return {
+        /**
+         * Execute a GraphQL operation
+         */
+        async execute(document, variables, options = {}) {
+            return execute(endpoint, document, variables, {
+                headers: { ...defaultHeaders, ...options.headers },
+                timeout: options.timeout ?? defaultTimeout,
+                signal: options.signal,
+            });
+        },
+        /**
+         * Get the endpoint URL
+         */
+        getEndpoint() {
+            return endpoint;
+        },
+    };
+}

package/client/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Client barrel export
+ *
+ * Re-exports client utilities for GraphQL execution and error handling.
+ */
+export { TypedDocumentString, type DocumentTypeDecoration, } from './typed-document';
+export { DataError, DataErrorType, PG_ERROR_CODES, createError, parseGraphQLError, isDataError, type DataErrorOptions, type GraphQLError, } from './error';
+export { execute, createGraphQLClient, type ExecuteOptions, type GraphQLResponse, type GraphQLClientOptions, type GraphQLClient, } from './execute';

package/client/index.js

@@ -0,0 +1,20 @@
+"use strict";
+/**
+ * Client barrel export
+ *
+ * Re-exports client utilities for GraphQL execution and error handling.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGraphQLClient = exports.execute = exports.isDataError = exports.parseGraphQLError = exports.createError = exports.PG_ERROR_CODES = exports.DataErrorType = exports.DataError = exports.TypedDocumentString = void 0;
+var typed_document_1 = require("./typed-document");
+Object.defineProperty(exports, "TypedDocumentString", { enumerable: true, get: function () { return typed_document_1.TypedDocumentString; } });
+var error_1 = require("./error");
+Object.defineProperty(exports, "DataError", { enumerable: true, get: function () { return error_1.DataError; } });
+Object.defineProperty(exports, "DataErrorType", { enumerable: true, get: function () { return error_1.DataErrorType; } });
+Object.defineProperty(exports, "PG_ERROR_CODES", { enumerable: true, get: function () { return error_1.PG_ERROR_CODES; } });
+Object.defineProperty(exports, "createError", { enumerable: true, get: function () { return error_1.createError; } });
+Object.defineProperty(exports, "parseGraphQLError", { enumerable: true, get: function () { return error_1.parseGraphQLError; } });
+Object.defineProperty(exports, "isDataError", { enumerable: true, get: function () { return error_1.isDataError; } });
+var execute_1 = require("./execute");
+Object.defineProperty(exports, "execute", { enumerable: true, get: function () { return execute_1.execute; } });
+Object.defineProperty(exports, "createGraphQLClient", { enumerable: true, get: function () { return execute_1.createGraphQLClient; } });

package/client/typed-document.d.ts

@@ -0,0 +1,31 @@
+/**
+ * TypedDocumentString - Type-safe wrapper for GraphQL documents
+ * Compatible with GraphQL codegen client preset
+ */
+/**
+ * Document type decoration interface (from @graphql-typed-document-node/core)
+ */
+export interface DocumentTypeDecoration<TResult, TVariables> {
+    /**
+     * This type is used to ensure that the variables you pass in to the query are assignable to Variables
+     * and that the Result is assignable to whatever you pass your result to.
+     */
+    __apiType?: (variables: TVariables) => TResult;
+}
+/**
+ * Enhanced TypedDocumentString with type inference capabilities
+ * Compatible with GraphQL codegen client preset
+ */
+export declare class TypedDocumentString<TResult = unknown, TVariables = unknown> extends String implements DocumentTypeDecoration<TResult, TVariables> {
+    /** Same shape as the codegen implementation for structural typing */
+    __apiType?: (variables: TVariables) => TResult;
+    __meta__?: Record<string, unknown>;
+    private value;
+    constructor(value: string, meta?: Record<string, unknown>);
+    private generateHash;
+    toString(): string;
+    /**
+     * Get the hash for caching purposes
+     */
+    getHash(): string;
+}

package/client/typed-document.js

@@ -0,0 +1,44 @@
+"use strict";
+/**
+ * TypedDocumentString - Type-safe wrapper for GraphQL documents
+ * Compatible with GraphQL codegen client preset
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypedDocumentString = void 0;
+/**
+ * Enhanced TypedDocumentString with type inference capabilities
+ * Compatible with GraphQL codegen client preset
+ */
+class TypedDocumentString extends String {
+    /** Same shape as the codegen implementation for structural typing */
+    __apiType;
+    __meta__;
+    value;
+    constructor(value, meta) {
+        super(value);
+        this.value = value;
+        this.__meta__ = {
+            hash: this.generateHash(value),
+            ...meta,
+        };
+    }
+    generateHash(value) {
+        let hash = 0;
+        for (let i = 0; i < value.length; i++) {
+            const char = value.charCodeAt(i);
+            hash = (hash << 5) - hash + char;
+            hash = hash & hash; // Convert to 32-bit integer
+        }
+        return Math.abs(hash).toString(36);
+    }
+    toString() {
+        return this.value;
+    }
+    /**
+     * Get the hash for caching purposes
+     */
+    getHash() {
+        return this.__meta__?.hash;
+    }
+}
+exports.TypedDocumentString = TypedDocumentString;