nextjs-hasura-auth 0.1.1 → 0.1.3

package/dist/lib/graphql-proxy.d.ts

@@ -0,0 +1,6 @@
+import { NextRequest, NextResponse } from 'next/server';
+import http from 'http';
+import { WebSocket, WebSocketServer } from 'ws';
+export declare function proxyGET(request: NextRequest): Promise<NextResponse>;
+export declare function proxyPOST(request: NextRequest): Promise<NextResponse>;
+export declare function proxySOCKET(client: WebSocket, request: http.IncomingMessage, server: WebSocketServer): Promise<void>;

package/dist/lib/graphql-proxy.js

@@ -0,0 +1,385 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.proxyGET = proxyGET;
+exports.proxyPOST = proxyPOST;
+exports.proxySOCKET = proxySOCKET;
+const server_1 = require("next/server");
+const ws_1 = __importStar(require("ws"));
+const jwt_1 = require("next-auth/jwt");
+const debug_1 = __importDefault(require("@/lib/debug"));
+const jwt_2 = require("@/lib/jwt");
+const debugGraphql = (0, debug_1.default)('graphql:proxy');
+let HASURA_ENDPOINT;
+let HASURA_WS_ENDPOINT;
+let HASURA_ADMIN_SECRET;
+let NEXTAUTH_SECRET;
+if (typeof window === 'undefined') {
+    // --- Environment Variables --- (Moved here, consider centralizing further)
+    HASURA_ENDPOINT = process.env.NEXT_PUBLIC_HASURA_GRAPHQL_URL;
+    HASURA_WS_ENDPOINT = HASURA_ENDPOINT === null || HASURA_ENDPOINT === void 0 ? void 0 : HASURA_ENDPOINT.replace('https', 'wss').replace('http', 'ws');
+    HASURA_ADMIN_SECRET = process.env.HASURA_ADMIN_SECRET;
+    NEXTAUTH_SECRET = process.env.NEXTAUTH_SECRET;
+    // --- Basic Checks --- (Moved here)
+    if (!HASURA_ENDPOINT) {
+        console.error("❌ CRITICAL: NEXT_PUBLIC_HASURA_GRAPHQL_URL environment variable is not set.");
+        debugGraphql("❌ CRITICAL: NEXT_PUBLIC_HASURA_GRAPHQL_URL environment variable is not set.");
+    }
+    if (!HASURA_WS_ENDPOINT) {
+        console.error("❌ CRITICAL: Cannot derive WebSocket endpoint from NEXT_PUBLIC_HASURA_GRAPHQL_URL.");
+        debugGraphql("❌ CRITICAL: Cannot derive WebSocket endpoint from NEXT_PUBLIC_HASURA_GRAPHQL_URL.");
+    }
+    if (!HASURA_ADMIN_SECRET) {
+        // Allow Admin Secret to be optional for WS if only JWT is used, but log warning
+        console.warn("⚠️ WARNING: HASURA_ADMIN_SECRET environment variable is not set. Anonymous WS access will fail.");
+        debugGraphql("⚠️ WARNING: HASURA_ADMIN_SECRET environment variable is not set. Anonymous WS access will fail.");
+    }
+    if (!NEXTAUTH_SECRET) {
+        console.error("❌ CRITICAL: NEXTAUTH_SECRET environment variable is not set.");
+        debugGraphql("❌ CRITICAL: NEXTAUTH_SECRET environment variable is not set.");
+    }
+}
+// =======================================================================
+// GET Handler Logic
+// =======================================================================
+function proxyGET(request) {
+    return __awaiter(this, void 0, void 0, function* () {
+        debugGraphql('Executing proxyGET');
+        return server_1.NextResponse.json({
+            status: 'ok',
+            message: 'GraphQL API and WebSocket proxy active',
+            endpoints: {
+                http: '/api/graphql',
+                ws: '/api/graphql' // WebSocket uses the same endpoint via upgrade
+            },
+            hasura_endpoint: HASURA_ENDPOINT,
+        });
+    });
+}
+// =======================================================================
+// POST Handler Logic
+// =======================================================================
+function proxyPOST(request) {
+    return __awaiter(this, void 0, void 0, function* () {
+        debugGraphql('--- proxyPOST Start ---');
+        if (!HASURA_ENDPOINT) {
+            const errorMsg = 'Hasura HTTP endpoint is not configured on the server.';
+            console.error(`❌ ${errorMsg}`);
+            debugGraphql(`❌ ${errorMsg}`);
+            return server_1.NextResponse.json({ errors: [{ message: errorMsg }] }, { status: 500 });
+        }
+        try {
+            const body = yield request.json();
+            const queryStr = JSON.stringify(body).substring(0, 200);
+            debugGraphql(`📤 GraphQL Query Received (preview): ${queryStr}${queryStr.length >= 200 ? '...' : ''}`);
+            const headers = {
+                'Content-Type': 'application/json',
+            };
+            if (!HASURA_ADMIN_SECRET) {
+                const errorMsg = 'HASURA_ADMIN_SECRET is not configured on the server for HTTP proxy.';
+                console.error(`❌ ${errorMsg}`);
+                debugGraphql(`❌ ${errorMsg}`);
+                // Important: Do not proceed if admin secret is missing for POST
+                return server_1.NextResponse.json({ errors: [{ message: errorMsg }] }, { status: 500 });
+            }
+            headers['x-hasura-admin-secret'] = HASURA_ADMIN_SECRET;
+            debugGraphql('🔑 Using Hasura Admin Secret for downstream HTTP request.');
+            debugGraphql(`🔗 Sending request to Hasura HTTP: ${HASURA_ENDPOINT}`);
+            const hasuraResponse = yield fetch(HASURA_ENDPOINT, {
+                method: 'POST',
+                headers,
+                body: JSON.stringify(body),
+            });
+            const data = yield hasuraResponse.json();
+            if (data.errors) {
+                console.error('❌ Error response from Hasura:', JSON.stringify(data.errors));
+                debugGraphql('❌ Error response from Hasura:', JSON.stringify(data.errors));
+            }
+            else {
+                debugGraphql('✅ Successful response from Hasura HTTP.');
+            }
+            debugGraphql('--- proxyPOST End ---');
+            return server_1.NextResponse.json(data, { status: hasuraResponse.status });
+        }
+        catch (error) {
+            console.error('❌ Error proxying HTTP GraphQL request:', error.stack || error);
+            debugGraphql('❌ Error proxying HTTP GraphQL request:', error.message);
+            debugGraphql('--- proxyPOST End (Error) ---');
+            return server_1.NextResponse.json({
+                errors: [
+                    {
+                        message: 'Error processing GraphQL request via proxy.',
+                        extensions: {
+                            code: 'INTERNAL_SERVER_ERROR',
+                            path: 'graphql-proxy-http'
+                        }
+                    }
+                ]
+            }, { status: 500 });
+        }
+    });
+}
+// =======================================================================
+// SOCKET Handler Logic
+// =======================================================================
+function proxySOCKET(client, request, server) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const clientId = Math.random().toString(36).substring(2, 8); // Shorter ID
+        debugGraphql(`--- proxySOCKET [${clientId}] Start ---`);
+        if (!HASURA_WS_ENDPOINT) {
+            console.error(`❌ [${clientId}] Hasura WebSocket endpoint not configured.`);
+            debugGraphql(`❌ [${clientId}] Hasura WebSocket endpoint not configured.`);
+            client.close(1011, 'WebSocket endpoint not configured');
+            return;
+        }
+        if (!NEXTAUTH_SECRET) {
+            console.error(`❌ [${clientId}] NEXTAUTH_SECRET not configured.`);
+            debugGraphql(`❌ [${clientId}] NEXTAUTH_SECRET not configured.`);
+            client.close(1011, 'Server authentication secret not configured');
+            return;
+        }
+        let hasuraWs = null;
+        let clientConnectionInitialized = false;
+        let hasuraConnectionInitialized = false;
+        const closeConnections = (code = 1000, reason = 'Closing connection') => {
+            debugGraphql(`[${clientId}] Closing connections: Code=${code}, Reason=${reason}`);
+            if (client.readyState === ws_1.WebSocket.OPEN || client.readyState === ws_1.WebSocket.CONNECTING) {
+                client.close(code, reason);
+            }
+            if (hasuraWs && (hasuraWs.readyState === ws_1.WebSocket.OPEN || hasuraWs.readyState === ws_1.WebSocket.CONNECTING)) {
+                hasuraWs.close(code, reason);
+            }
+            debugGraphql(`[${clientId}] Connections closed.`);
+        };
+        try {
+            const token = yield (0, jwt_1.getToken)({
+                req: request,
+                secret: NEXTAUTH_SECRET
+            });
+            const headers = {};
+            if (token === null || token === void 0 ? void 0 : token.sub) {
+                debugGraphql(`👤 [${clientId}] User authenticated (ID: ${token.sub}). Generating Hasura JWT.`);
+                try {
+                    const hasuraClaims = {
+                        'x-hasura-allowed-roles': ['user', 'anonymous', 'me'], // Keep fixed roles for simplicity in proxy
+                        'x-hasura-default-role': 'user',
+                        'x-hasura-user-id': token.sub,
+                    };
+                    const jwt = yield (0, jwt_2.generateJWT)(token.sub, hasuraClaims); // Assumes generateJWT uses env secret
+                    headers['Authorization'] = `Bearer ${jwt}`;
+                    debugGraphql(`🔑 [${clientId}] Using generated JWT (user role) for Hasura WS connection.`);
+                }
+                catch (jwtError) {
+                    console.error(`❌ [${clientId}] Failed to generate Hasura JWT for user:`, jwtError);
+                    debugGraphql(`❌ [${clientId}] Failed to generate Hasura JWT for user:`, jwtError.message);
+                    closeConnections(1011, "JWT generation failed");
+                    return;
+                }
+            }
+            else {
+                // --- MODIFICATION START: Generate Anonymous JWT instead of using Admin Secret ---
+                debugGraphql(`👤 [${clientId}] User not authenticated. Generating Anonymous JWT.`);
+                try {
+                    const anonymousUserId = `anon-${clientId}`; // Create a unique-ish ID for anonymous user
+                    const hasuraClaims = {
+                        'x-hasura-allowed-roles': ['anonymous'], // Only allow anonymous role
+                        'x-hasura-default-role': 'anonymous',
+                        'x-hasura-user-id': anonymousUserId, // Provide an ID
+                    };
+                    // Use the same secret mechanism as for authenticated users
+                    const jwt = yield (0, jwt_2.generateJWT)(anonymousUserId, hasuraClaims); // Assumes generateJWT uses env secret
+                    headers['Authorization'] = `Bearer ${jwt}`;
+                    debugGraphql(`🔑 [${clientId}] Using generated JWT (anonymous role) for Hasura WS connection.`);
+                }
+                catch (jwtError) {
+                    console.error(`❌ [${clientId}] Failed to generate Hasura JWT for anonymous:`, jwtError);
+                    debugGraphql(`❌ [${clientId}] Failed to generate Hasura JWT for anonymous:`, jwtError.message);
+                    // Fallback or error closing might depend on requirements, here we close.
+                    closeConnections(1011, "Anonymous JWT generation failed");
+                    return;
+                }
+                // --- MODIFICATION END ---
+                /* --- OLD CODE using Admin Secret ---
+                } else if (HASURA_ADMIN_SECRET) {
+                  debugGraphql(`👤 [${clientId}] User not authenticated. Using Admin Secret for Hasura WS connection.`);
+                  headers['x-hasura-admin-secret'] = HASURA_ADMIN_SECRET;
+                } else {
+                   debugGraphql(`❌ [${clientId}] Anonymous connection attempted, but no Admin Secret configured.`);
+                   console.error(`❌ [${clientId}] Anonymous connection attempted, but no Admin Secret configured.`);
+                   closeConnections(1011, 'Server configuration error for anonymous access.');
+                   return;
+                }
+                */
+            }
+            debugGraphql(`🔗 [${clientId}] Establishing connection to Hasura WS: ${HASURA_WS_ENDPOINT}`);
+            hasuraWs = new ws_1.default(HASURA_WS_ENDPOINT, 'graphql-ws', { headers });
+            // --- WebSocket Event Handlers (Moved logic here) --- 
+            hasuraWs.on('open', () => {
+                debugGraphql(`✅ [${clientId}] Connection to Hasura WS established.`);
+                const initMessage = { type: 'connection_init', payload: {} };
+                debugGraphql(`📤 [${clientId}] Sending connection_init to Hasura.`);
+                hasuraWs === null || hasuraWs === void 0 ? void 0 : hasuraWs.send(JSON.stringify(initMessage));
+            });
+            client.on('message', (message) => {
+                if (!hasuraWs || hasuraWs.readyState !== ws_1.WebSocket.OPEN) {
+                    debugGraphql(`⚠️ [${clientId}] Received message from client, but Hasura WS not open. Ignoring.`);
+                    return;
+                }
+                try {
+                    const messageStr = message.toString();
+                    const parsedMessage = JSON.parse(messageStr);
+                    const type = parsedMessage.type;
+                    // const preview = messageStr.substring(0, 100) + (messageStr.length > 100 ? '...' : '');
+                    if (type === 'connection_init') {
+                        debugGraphql(`🤝 [${clientId}] Received connection_init from client.`);
+                        clientConnectionInitialized = true;
+                        if (hasuraConnectionInitialized) {
+                            debugGraphql(`🤝 [${clientId}] Sending connection_ack to client (Hasura already acked).`);
+                            client.send(JSON.stringify({ type: 'connection_ack' }));
+                        }
+                        return; // Do NOT forward client's connection_init
+                    }
+                    if (!clientConnectionInitialized) {
+                        console.error(`❌ [${clientId}] Message type ${type} received from client before connection_init.`);
+                        debugGraphql(`❌ [${clientId}] Message type ${type} received from client before connection_init.`);
+                        closeConnections(4401, 'Connection not initialized');
+                        return;
+                    }
+                    if (['start', 'stop', 'subscribe', 'complete'].includes(type)) {
+                        debugGraphql(`📤 [${clientId}] Forwarding ${type} C -> H`);
+                        hasuraWs.send(messageStr);
+                    }
+                    else {
+                        debugGraphql(`❓ [${clientId}] Unknown message type from client: ${type}. Ignoring.`);
+                    }
+                }
+                catch (err) {
+                    console.error(`❌ [${clientId}] Error processing client message:`, err);
+                    debugGraphql(`❌ [${clientId}] Error processing client message:`, err.message);
+                }
+            });
+            hasuraWs.on('message', (message) => {
+                if (client.readyState !== ws_1.WebSocket.OPEN) {
+                    debugGraphql(`⚠️ [${clientId}] Received message from Hasura, but client WS not open. Ignoring.`);
+                    return;
+                }
+                try {
+                    const messageStr = message.toString();
+                    const parsedMessage = JSON.parse(messageStr);
+                    const type = parsedMessage.type;
+                    // const preview = messageStr.substring(0, 100) + (messageStr.length > 100 ? '...' : '');
+                    if (type === 'connection_ack') {
+                        debugGraphql(`🤝 [${clientId}] Received connection_ack from Hasura.`);
+                        hasuraConnectionInitialized = true;
+                        if (clientConnectionInitialized) {
+                            debugGraphql(`🤝 [${clientId}] Sending connection_ack to client (Hasura just acked).`);
+                            client.send(JSON.stringify({ type: 'connection_ack' }));
+                        }
+                        return;
+                    }
+                    if (type === 'ka') {
+                        // debugGraphql(`[${clientId}] Received keep-alive from Hasura. Ignoring.`);
+                        return; // Ignore Hasura keep-alive
+                    }
+                    let messageToSend = messageStr;
+                    if (type === 'data') {
+                        debugGraphql(`🔄 [${clientId}] Translating message type 'data' -> 'next'`);
+                        parsedMessage.type = 'next';
+                        messageToSend = JSON.stringify(parsedMessage);
+                    }
+                    else if (type === 'error') {
+                        debugGraphql(`❗ [${clientId}] Forwarding error H -> C`);
+                    }
+                    else if (type === 'complete') {
+                        debugGraphql(`✅ [${clientId}] Forwarding complete H -> C`);
+                    }
+                    else {
+                        debugGraphql(`❓ [${clientId}] Unknown message type from Hasura: ${type}. Forwarding as-is.`);
+                    }
+                    client.send(messageToSend);
+                }
+                catch (err) {
+                    console.error(`❌ [${clientId}] Error processing Hasura message:`, err);
+                    debugGraphql(`❌ [${clientId}] Error processing Hasura message:`, err.message);
+                }
+            });
+            client.on('close', (code, reason) => {
+                const reasonStr = reason.toString();
+                debugGraphql(`👋 [${clientId}] Client disconnected: ${code} ${reasonStr}`);
+                debugGraphql(`--- proxySOCKET [${clientId}] End (Client Close) ---`);
+                closeConnections(code, reasonStr);
+            });
+            hasuraWs.on('close', (code, reason) => {
+                const reasonStr = reason.toString();
+                debugGraphql(`👋 [${clientId}] Hasura disconnected: ${code} ${reasonStr}`);
+                debugGraphql(`--- proxySOCKET [${clientId}] End (Hasura Close) ---`);
+                closeConnections(code, reasonStr);
+            });
+            client.on('error', (error) => {
+                console.error(`❌ [${clientId}] Client WebSocket error:`, error);
+                debugGraphql(`❌ [${clientId}] Client WebSocket error:`, error.message);
+                debugGraphql(`--- proxySOCKET [${clientId}] End (Client Error) ---`);
+                closeConnections(1011, 'Client error');
+            });
+            hasuraWs.on('error', (error) => {
+                console.error(`❌ [${clientId}] Hasura WebSocket error:`, error);
+                debugGraphql(`❌ [${clientId}] Hasura WebSocket error:`, error.message);
+                debugGraphql(`--- proxySOCKET [${clientId}] End (Hasura Error) ---`);
+                closeConnections(1011, 'Hasura connection error');
+            });
+        }
+        catch (error) {
+            console.error(`❌ [${clientId}] Error setting up WebSocket proxy:`, error);
+            debugGraphql(`❌ [${clientId}] Error setting up WebSocket proxy:`, error.message);
+            debugGraphql(`--- proxySOCKET [${clientId}] End (Setup Error) ---`);
+            // Ensure client connection is closed on setup error
+            if (client.readyState === ws_1.WebSocket.OPEN || client.readyState === ws_1.WebSocket.CONNECTING) {
+                client.close(1011, 'Proxy setup error');
+            }
+        }
+    });
+}

package/dist/lib/hasura-schema.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/hasura-schema.js

@@ -0,0 +1,65 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// lib/hasura-schema.ts
+const axios_1 = __importDefault(require("axios"));
+const dotenv_1 = __importDefault(require("dotenv"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const graphql_1 = require("graphql"); // Use standard introspection query function
+dotenv_1.default.config({ path: path_1.default.resolve(__dirname, '../.env') });
+const HASURA_GRAPHQL_URL = process.env.NEXT_PUBLIC_HASURA_GRAPHQL_URL;
+const HASURA_ADMIN_SECRET = process.env.HASURA_ADMIN_SECRET;
+const OUTPUT_PATH = path_1.default.resolve(__dirname, '../public/hasura-schema.json');
+if (!HASURA_GRAPHQL_URL) {
+    console.error('❌ Ошибка: NEXT_PUBLIC_HASURA_GRAPHQL_URL не определен в .env');
+    process.exit(1);
+}
+function fetchSchema() {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        console.log(`🚀 Запрос схемы интроспекции с ${HASURA_GRAPHQL_URL}...`);
+        try {
+            const headers = {
+                'Content-Type': 'application/json',
+            };
+            if (HASURA_ADMIN_SECRET) {
+                headers['X-Hasura-Admin-Secret'] = HASURA_ADMIN_SECRET;
+                console.log('🔑 Используется Hasura Admin Secret.');
+            }
+            else {
+                console.warn('⚠️ HASURA_ADMIN_SECRET не найден. Запрос схемы без админ-прав (может быть неполным).');
+            }
+            const response = yield axios_1.default.post(HASURA_GRAPHQL_URL, // Add non-null assertion here
+            {
+                query: (0, graphql_1.getIntrospectionQuery)(), // Use the function to get the query string
+            }, { headers });
+            if (response.data.errors) {
+                throw new Error(`Ошибка GraphQL при запросе схемы: ${JSON.stringify(response.data.errors)}`);
+            }
+            if (!response.data || !response.data.data || !response.data.data.__schema) {
+                throw new Error('Некорректный ответ от сервера Hasura. Отсутствует data.__schema.');
+            }
+            const introspectionResult = response.data;
+            console.log(`💾 Сохранение схемы в ${OUTPUT_PATH}...`);
+            fs_1.default.writeFileSync(OUTPUT_PATH, JSON.stringify(introspectionResult, null, 2)); // Сохраняем весь результат
+            console.log(`✅ Схема успешно получена и сохранена в ${OUTPUT_PATH}`);
+        }
+        catch (error) {
+            console.error('❌ Ошибка при получении или сохранении схемы:', ((_a = error.response) === null || _a === void 0 ? void 0 : _a.data) || error.message || error);
+            process.exit(1);
+        }
+    });
+}
+fetchSchema();

package/dist/lib/hasura.d.ts

@@ -0,0 +1,16 @@
+import { AxiosInstance } from 'axios';
+interface HasuraOptions {
+    url: string;
+    secret: string;
+}
+export declare class Hasura {
+    private readonly clientInstance;
+    constructor(options: HasuraOptions);
+    get client(): AxiosInstance;
+    sql(sql: string, source?: string, cascade?: boolean): Promise<any>;
+    v1(request: {
+        type: string;
+        args: object;
+    }): Promise<any>;
+}
+export {};

package/dist/lib/hasura.js

@@ -0,0 +1,102 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Hasura = void 0;
+const axios_1 = __importDefault(require("axios"));
+const debug_1 = __importDefault(require("./debug")); // Assuming debug is in lib and alias @ points to root/src
+const debug = (0, debug_1.default)('hasura');
+class Hasura {
+    constructor(options) {
+        const { url, secret } = options;
+        if (!url || !secret) {
+            const errorMessage = '❌ Hasura URL or Admin Secret is missing. Check NEXT_PUBLIC_HASURA_GRAPHQL_ENDPOINT and HASURA_ADMIN_SECRET environment variables.';
+            debug(errorMessage);
+            throw new Error(errorMessage);
+        }
+        this.clientInstance = axios_1.default.create({
+            baseURL: url.replace('/v1/graphql', ''), // Ensure base URL is correct
+            headers: {
+                'Content-Type': 'application/json',
+                'X-Hasura-Admin-Secret': secret,
+            },
+        });
+        debug('✅ Hasura client initialized successfully.');
+    }
+    get client() {
+        return this.clientInstance;
+    }
+    sql(sql_1) {
+        return __awaiter(this, arguments, void 0, function* (sql, source = 'default', cascade = false) {
+            var _a, _b, _c;
+            debug('🔧 Executing SQL via /v2/query...');
+            try {
+                const response = yield this.clientInstance.post('/v2/query', {
+                    type: 'run_sql',
+                    args: {
+                        source,
+                        sql,
+                        cascade,
+                    },
+                });
+                debug('✅ SQL executed successfully.');
+                return response.data;
+            }
+            catch (error) {
+                const errorMessage = `❌ Error executing SQL: ${((_b = (_a = error.response) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.error) || error.message}`;
+                debug(errorMessage, ((_c = error.response) === null || _c === void 0 ? void 0 : _c.data) || error);
+                throw new Error(errorMessage); // Re-throw after logging
+            }
+        });
+    }
+    v1(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e, _f, _g, _h;
+            debug(`🚀 Sending request to /v1/metadata: ${request.type}`);
+            try {
+                const response = yield this.clientInstance.post('/v1/metadata', request);
+                debug(`✅ /v1/metadata request successful for type: ${request.type}`);
+                return response.data;
+            }
+            catch (error) {
+                // Log specific Hasura errors if available, otherwise log the general error
+                const hasuraError = ((_b = (_a = error.response) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.error) || ((_d = (_c = error.response) === null || _c === void 0 ? void 0 : _c.data) === null || _d === void 0 ? void 0 : _d.message) || error.message;
+                const errorCode = (_f = (_e = error.response) === null || _e === void 0 ? void 0 : _e.data) === null || _f === void 0 ? void 0 : _f.code;
+                const requestType = request.type; // Get the type of the request
+                // Don't throw an error for common "already exists/tracked/not found/defined" issues
+                const ignorableErrors = [
+                    'already exists',
+                    'already tracked',
+                    'not found',
+                    'already defined', // for permissions creation
+                ];
+                let isIgnorable = typeof hasuraError === 'string' && ignorableErrors.some(phrase => hasuraError.includes(phrase));
+                // Specifically ignore 'permission-denied' ONLY for drop/untrack operations, as it likely means "not found" in this context
+                if (!isIgnorable && errorCode === 'permission-denied' && (requestType.startsWith('pg_drop_') || requestType.startsWith('pg_untrack_'))) {
+                    debug(`📝 Note: Ignoring 'permission-denied' for ${requestType}, likely means target object was not found.`);
+                    isIgnorable = true;
+                }
+                if (isIgnorable) {
+                    debug(`📝 Note: Non-critical issue for ${requestType} - ${hasuraError} ${errorCode ? `(Code: ${errorCode})` : ''}`);
+                    return ((_g = error.response) === null || _g === void 0 ? void 0 : _g.data) || { info: hasuraError }; // Return info instead of throwing
+                }
+                else {
+                    const errorMessage = `❌ Error in /v1/metadata for type ${requestType}: ${hasuraError} ${errorCode ? `(Code: ${errorCode})` : ''}`;
+                    debug(errorMessage, ((_h = error.response) === null || _h === void 0 ? void 0 : _h.data) || error);
+                    throw new Error(errorMessage); // Re-throw critical errors
+                }
+            }
+        });
+    }
+}
+exports.Hasura = Hasura;

package/dist/lib/hooks/useCheckConnection.d.ts

@@ -0,0 +1,7 @@
+type ConnectionStatus = 'connecting' | 'connected' | 'error';
+/**
+ * Hook to check connection to Hasura GraphQL endpoint
+ * @returns {ConnectionStatus} Current connection status
+ */
+export declare function useCheckConnection(): ConnectionStatus;
+export default useCheckConnection;

package/dist/lib/hooks/useCheckConnection.js

@@ -0,0 +1,62 @@
+"use strict";
+'use client';
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useCheckConnection = useCheckConnection;
+const react_1 = require("react");
+const apollo_1 = require("../apollo");
+const debug_1 = __importDefault(require("@/lib/debug"));
+// Create a debug logger for this module
+const debug = (0, debug_1.default)('hooks:connection');
+/**
+ * Hook to check connection to Hasura GraphQL endpoint
+ * @returns {ConnectionStatus} Current connection status
+ */
+function useCheckConnection() {
+    const [status, setStatus] = (0, react_1.useState)('connecting');
+    (0, react_1.useEffect)(() => {
+        let mounted = true;
+        const checkConnectionStatus = () => __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (mounted)
+                    setStatus('connecting');
+                const client = (0, apollo_1.getClient)();
+                const isConnected = yield (0, apollo_1.checkConnection)(client);
+                if (!mounted)
+                    return;
+                if (isConnected) {
+                    // Use the debug function directly if log is undefined
+                    debug('hooks:connection', '✅ Connected to Hasura GraphQL endpoint');
+                    setStatus('connected');
+                }
+                else {
+                    debug('hooks:connection', '❌ Failed to connect to Hasura GraphQL endpoint');
+                    setStatus('error');
+                }
+            }
+            catch (error) {
+                if (mounted) {
+                    debug('hooks:connection', '❌ Connection error:', error);
+                    setStatus('error');
+                }
+            }
+        });
+        checkConnectionStatus();
+        return () => {
+            mounted = false;
+        };
+    }, []);
+    return status;
+}
+exports.default = useCheckConnection;

package/dist/lib/index.d.ts

@@ -1,3 +1,8 @@
 export * from './utils';
 export * from './apollo';
 export * from './generator';
+export * from './hasura';
+export * from './auth';
+export * from './client';
+export * from './jwt';
+export * from './graphql-proxy';