@constructive-io/graphql-codegen 2.19.0 → 2.20.1

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 typed_document_1 = require("./typed-document");
+const error_1 = require("./error");
+// ============================================================================
+// 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,6 @@
+/**
+ * Client exports
+ */
+export { TypedDocumentString, type DocumentTypeDecoration } from './typed-document';
+export { DataError, DataErrorType, createError, parseGraphQLError, isDataError, PG_ERROR_CODES, type DataErrorOptions, type GraphQLError, } from './error';
+export { execute, createGraphQLClient, type ExecuteOptions, type GraphQLClientOptions, type GraphQLClient, type GraphQLResponse, } from './execute';

package/client/index.js

@@ -0,0 +1,18 @@
+"use strict";
+/**
+ * Client exports
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGraphQLClient = exports.execute = exports.PG_ERROR_CODES = exports.isDataError = exports.parseGraphQLError = exports.createError = 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, "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; } });
+Object.defineProperty(exports, "PG_ERROR_CODES", { enumerable: true, get: function () { return error_1.PG_ERROR_CODES; } });
+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;

package/core/ast.d.ts

@@ -0,0 +1,10 @@
+import type { DocumentNode, FieldNode } from 'graphql';
+import type { ASTFunctionParams, QueryFieldSelection, MutationASTParams } 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[];