nextjs-hasura-auth 0.1.2 → 0.1.4

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.js

@@ -18,7 +18,6 @@ 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
-// Загружаем переменные окружения из корневого .env
 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;
@@ -52,12 +51,6 @@ function fetchSchema() {
             if (!response.data || !response.data.data || !response.data.data.__schema) {
                 throw new Error('Некорректный ответ от сервера Hasura. Отсутствует data.__schema.');
             }
-            // Структурируем схему для совместимости с генератором (опционально, можно просто сохранить __schema)
-            // Пока оставим простую структуру, аналогичную schema.js, но только с __schema
-            // const structuredSchema = {
-            //   __schema: response.data.data.__schema
-            // };
-            // Для начала сохраним полный результат интроспекции, codegen его поймет
             const introspectionResult = response.data;
             console.log(`💾 Сохранение схемы в ${OUTPUT_PATH}...`);
             fs_1.default.writeFileSync(OUTPUT_PATH, JSON.stringify(introspectionResult, null, 2)); // Сохраняем весь результат

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

@@ -5,3 +5,4 @@ export * from './hasura';
 export * from './auth';
 export * from './client';
 export * from './jwt';
+export * from './graphql-proxy';

package/dist/lib/index.js

@@ -22,3 +22,4 @@ __exportStar(require("./hasura"), exports);
 __exportStar(require("./auth"), exports);
 __exportStar(require("./client"), exports);
 __exportStar(require("./jwt"), exports);
+__exportStar(require("./graphql-proxy"), exports);

package/dist/lib/test-utils.d.ts

@@ -0,0 +1,11 @@
+import { ReactElement } from 'react';
+import { screen } from '@testing-library/react';
+import { ApolloClient } from '@apollo/client';
+/**
+ * Custom renderer that wraps the component with necessary providers
+ */
+declare const customRender: (ui: ReactElement, { apolloClient, ...renderOptions }?: {
+    apolloClient?: ApolloClient<import("@apollo/client").NormalizedCacheObject> | undefined;
+}) => import("@testing-library/react").RenderResult<typeof import("@testing-library/dom/types/queries"), HTMLElement, HTMLElement>;
+export * from '@testing-library/react';
+export { customRender as render, screen };

package/dist/lib/test-utils.js

@@ -0,0 +1,59 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.screen = exports.render = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("@testing-library/react");
+Object.defineProperty(exports, "screen", { enumerable: true, get: function () { return react_1.screen; } });
+const client_1 = require("@apollo/client");
+// Create a mock Apollo client for testing
+const createMockClient = () => {
+    return new client_1.ApolloClient({
+        cache: new client_1.InMemoryCache(),
+        defaultOptions: {
+            watchQuery: {
+                fetchPolicy: 'no-cache',
+            },
+            query: {
+                fetchPolicy: 'no-cache',
+            },
+        },
+    });
+};
+/**
+ * Custom renderer that wraps the component with necessary providers
+ */
+const customRender = (ui, _a = {}) => {
+    var { apolloClient = createMockClient() } = _a, renderOptions = __rest(_a, ["apolloClient"]);
+    const AllTheProviders = ({ children }) => {
+        return ((0, jsx_runtime_1.jsx)(client_1.ApolloProvider, { client: apolloClient, children: children }));
+    };
+    return (0, react_1.render)(ui, Object.assign({ wrapper: AllTheProviders }, renderOptions));
+};
+exports.render = customRender;
+// re-export everything from testing-library
+__exportStar(require("@testing-library/react"), exports);

package/dist/lib/tokenUtils.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Generates a short-lived JWT for email verification.
+ * @param userId - The ID of the user to verify.
+ * @returns Promise<string> - The generated verification token.
+ */
+export declare function generateVerificationToken(userId: string): Promise<string>;
+/**
+ * Verifies an email verification token.
+ * @param token - The token string to verify.
+ * @returns Promise<{ userId: string } | null> - The user ID if the token is valid and has the correct scope, otherwise null.
+ */
+export declare function verifyVerificationToken(token: string): Promise<{
+    userId: string;
+} | null>;