@constructive-io/graphql-codegen 4.6.0 → 4.7.0

package/client/error.d.ts

@@ -1,95 +1,4 @@
 /**
- * Error handling for GraphQL operations
- * Provides consistent error types and parsing for PostGraphile responses
+ * Re-export error handling utilities from @constructive-io/graphql-query.
  */
-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;
+export { DataError, DataErrorType, PG_ERROR_CODES, createError, parseGraphQLError, isDataError, type DataErrorOptions, type GraphQLError, } from '@constructive-io/graphql-query';

package/client/error.js

@@ -1,277 +1,13 @@
 "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);
-}
+exports.isDataError = exports.parseGraphQLError = exports.createError = exports.PG_ERROR_CODES = exports.DataErrorType = exports.DataError = void 0;
 /**
- * Check if value is a DataError
+ * Re-export error handling utilities from @constructive-io/graphql-query.
  */
-function isDataError(error) {
-    return error instanceof DataError;
-}
+var graphql_query_1 = require("@constructive-io/graphql-query");
+Object.defineProperty(exports, "DataError", { enumerable: true, get: function () { return graphql_query_1.DataError; } });
+Object.defineProperty(exports, "DataErrorType", { enumerable: true, get: function () { return graphql_query_1.DataErrorType; } });
+Object.defineProperty(exports, "PG_ERROR_CODES", { enumerable: true, get: function () { return graphql_query_1.PG_ERROR_CODES; } });
+Object.defineProperty(exports, "createError", { enumerable: true, get: function () { return graphql_query_1.createError; } });
+Object.defineProperty(exports, "parseGraphQLError", { enumerable: true, get: function () { return graphql_query_1.parseGraphQLError; } });
+Object.defineProperty(exports, "isDataError", { enumerable: true, get: function () { return graphql_query_1.isDataError; } });

package/client/execute.d.ts

@@ -1,57 +1,4 @@
 /**
- * GraphQL execution utilities
+ * Re-export GraphQL execution utilities from @constructive-io/graphql-query.
  */
-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 {};
+export { execute, createGraphQLClient, type ExecuteOptions, type GraphQLResponse, type GraphQLClientOptions, type GraphQLClient, } from '@constructive-io/graphql-query';

package/client/execute.js

@@ -1,124 +1,9 @@
 "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}`);
-}
+exports.createGraphQLClient = exports.execute = void 0;
 /**
- * Create a GraphQL client instance
+ * Re-export GraphQL execution utilities from @constructive-io/graphql-query.
  */
-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;
-        },
-    };
-}
+var graphql_query_1 = require("@constructive-io/graphql-query");
+Object.defineProperty(exports, "execute", { enumerable: true, get: function () { return graphql_query_1.execute; } });
+Object.defineProperty(exports, "createGraphQLClient", { enumerable: true, get: function () { return graphql_query_1.createGraphQLClient; } });

package/client/typed-document.d.ts

@@ -1,31 +1,4 @@
 /**
- * TypedDocumentString - Type-safe wrapper for GraphQL documents
- * Compatible with GraphQL codegen client preset
+ * Re-export TypedDocumentString from @constructive-io/graphql-query.
  */
-/**
- * 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;
-}
+export { TypedDocumentString, type DocumentTypeDecoration, } from '@constructive-io/graphql-query';

package/client/typed-document.js

@@ -1,44 +1,8 @@
 "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
+ * Re-export TypedDocumentString from @constructive-io/graphql-query.
  */
-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;
+var graphql_query_1 = require("@constructive-io/graphql-query");
+Object.defineProperty(exports, "TypedDocumentString", { enumerable: true, get: function () { return graphql_query_1.TypedDocumentString; } });

package/core/ast.d.ts

@@ -1,10 +1,8 @@
-import type { DocumentNode, FieldNode } from 'graphql';
-import type { ASTFunctionParams, MutationASTParams, QueryFieldSelection } from './types';
-export declare const getAll: ({ queryName, operationName, selection, }: ASTFunctionParams) => DocumentNode;
-export declare const getCount: ({ queryName, operationName, query, }: Omit<ASTFunctionParams, "selection">) => DocumentNode;
-export declare const getMany: ({ builder, queryName, operationName, query, selection, }: ASTFunctionParams) => DocumentNode;
-export declare const getOne: ({ queryName, operationName, query, selection, }: ASTFunctionParams) => DocumentNode;
-export declare const createOne: ({ mutationName, operationName, mutation, selection, }: MutationASTParams) => DocumentNode;
-export declare const patchOne: ({ mutationName, operationName, mutation, selection, }: MutationASTParams) => DocumentNode;
-export declare const deleteOne: ({ mutationName, operationName, mutation, }: Omit<MutationASTParams, "selection">) => DocumentNode;
-export declare function getSelections(selection?: QueryFieldSelection[]): FieldNode[];
+/**
+ * Re-export AST builders from @constructive-io/graphql-query.
+ *
+ * These are the low-level AST generation functions (getAll, getMany, getOne,
+ * createOne, patchOne, deleteOne, getSelections). The canonical implementations
+ * now live in graphql-query.
+ */
+export { getAll, getCount, getMany, getOne, createOne, patchOne, deleteOne, getSelections, } from '@constructive-io/graphql-query';