nextjs-hasura-auth 0.1.0 → 0.1.2

package/dist/lib/auth.jsx

@@ -0,0 +1,159 @@
+"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 __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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTokenFromRequest = getTokenFromRequest;
+exports.WsClientsManager = WsClientsManager;
+const debug_1 = __importDefault(require("@/lib/debug"));
+const jwt_1 = require("next-auth/jwt");
+const uuid_1 = require("uuid");
+const debug = (0, debug_1.default)('auth');
+function getTokenFromRequest(request) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const secureCookie = request.url.startsWith('https');
+        const cookieName = secureCookie
+            ? '__Secure-next-auth.session-token'
+            : 'next-auth.session-token';
+        debug(`GET /api/auth: Using cookie name: ${cookieName}, secure: ${secureCookie}`);
+        const token = yield (0, jwt_1.getToken)({
+            req: request, // Cast to any to satisfy getToken, NextRequest works
+            secret: process.env.NEXTAUTH_SECRET,
+            cookieName: cookieName,
+        });
+        return token;
+    });
+}
+function WsClientsManager(route = '') {
+    const clientManagerId = route + (0, uuid_1.v4)();
+    debug(`(${clientManagerId}): New WebSocket clients manager established.`);
+    const clients = new Map();
+    return {
+        Client: (client) => {
+            const clientId = (0, uuid_1.v4)();
+            clients.set(clientId, { ws: client });
+            debug(`(${clientManagerId}): New client (${clientId}) connected.`);
+            return clientId;
+        },
+        getToken(request, clientId) {
+            return __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                const cookieHeader = request.headers.cookie;
+                const userAgent = request.headers['user-agent'];
+                const forwardedProto = request.headers['x-forwarded-proto'];
+                const connectionEncrypted = (_a = request.connection) === null || _a === void 0 ? void 0 : _a.encrypted;
+                debug(`${clientManagerId}: (${clientId}): Incoming request details - URL: ${request.url}, Method: ${request.method}, User-Agent: ${userAgent}`);
+                debug(`${clientManagerId}: (${clientId}): Incoming headers:`, request.headers);
+                debug(`${clientManagerId}: (${clientId}): Connection encrypted: ${connectionEncrypted}`);
+                debug(`${clientManagerId}: (${clientId}): X-Forwarded-Proto: ${forwardedProto}`);
+                debug(`${clientManagerId}: (${clientId}): Full cookie header:`, cookieHeader || 'No cookies header');
+                // Determine secure context and cookie name
+                const isSecure = forwardedProto === 'https' || connectionEncrypted;
+                const sessionCookieName = isSecure
+                    ? '__Secure-next-auth.session-token'
+                    : 'next-auth.session-token';
+                debug(`${clientManagerId}: (${clientId}): Determined secure context: ${isSecure}`);
+                debug(`${clientManagerId}: (${clientId}): Expecting session cookie name: ${sessionCookieName}`);
+                let token = null;
+                let payload = null;
+                let userId = null;
+                const rawToken = false; // Keep false
+                try {
+                    debug(`SOCKET /api/auth (${clientId}): Preparing adapted request for getToken (raw: ${rawToken})...`);
+                    const parsedCookies = request.headers.cookie ?
+                        Object.fromEntries(request.headers.cookie.split('; ').map(c => {
+                            const [key, ...val] = c.split('=');
+                            return [key, decodeURIComponent(val.join('='))];
+                        }))
+                        : {};
+                    debug(`SOCKET /api/auth (${clientId}): Parsed cookies object:`, parsedCookies);
+                    const adaptedReq = {
+                        headers: request.headers,
+                        cookies: parsedCookies,
+                        url: request.url || '',
+                        method: request.method || 'GET',
+                    };
+                    debug(`SOCKET /api/auth (${clientId}): Final adapted request object for getToken:`, adaptedReq);
+                    const getTokenParams = {
+                        req: adaptedReq,
+                        secret: process.env.NEXTAUTH_SECRET,
+                        cookieName: sessionCookieName,
+                        raw: rawToken, // Should be false now
+                    };
+                    debug(`${clientManagerId}: (${clientId}): Calling getToken with params:`, {
+                        cookieName: getTokenParams.cookieName,
+                        raw: getTokenParams.raw,
+                        secretProvided: !!getTokenParams.secret,
+                    });
+                    token = yield (0, jwt_1.getToken)(getTokenParams);
+                    debug(`${clientManagerId}: (${clientId}): getToken result received.`);
+                    debug(`${clientManagerId}: (${clientId}): Decoded token value from getToken:`, token);
+                    debug(`${clientManagerId}: (${clientId}): getToken result type: ${typeof token}, isNull: ${token === null}`);
+                    if (token && typeof token === 'object' && token.sub) {
+                        payload = token;
+                        userId = payload.sub;
+                        debug(`${clientManagerId}: (${clientId}): User ${userId} authenticated via decoded token from getToken.`);
+                    }
+                    else {
+                        debug(`${clientManagerId}: (${clientId}): No valid token found or token is not an object with sub property.`);
+                    }
+                    return token;
+                }
+                catch (error) {
+                    debug(`${clientManagerId}: (${clientId}): Error preparing adapted request for getToken:`, error);
+                    throw error;
+                }
+            });
+        },
+        parseUser(request, clientId) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const token = yield this.getToken(request, clientId);
+                if (token && typeof token === 'object' && token.sub) {
+                    const _a = token, { accessToken } = _a, user = __rest(_a, ["accessToken"]);
+                    const client = clients.get(clientId);
+                    if (client) {
+                        client.userId = token.sub;
+                        client.user = user;
+                        clients.set(clientId, client);
+                        debug(`${clientManagerId}: (${clientId}): Client parsed and updated.`);
+                    }
+                    else {
+                        debug(`${clientManagerId}: (${clientId}): No client found in clients map.`);
+                    }
+                    return user;
+                }
+                else {
+                    debug(`${clientManagerId}: (${clientId}): No valid token found or token is not an object with sub property.`);
+                }
+                return null;
+            });
+        },
+        delete(clientId) {
+            clients.delete(clientId);
+            debug(`${clientManagerId}: (${clientId}): Client deleted from clients map.`);
+        },
+        getClient(clientId) {
+            return clients.get(clientId);
+        }
+    };
+}

package/dist/lib/client.d.ts

@@ -0,0 +1,82 @@
+import { ApolloClient, ApolloError, FetchResult, Observable, OperationVariables, useQuery as useApolloQuery, useSubscription as useApolloSubscription } from '@apollo/client';
+import { GenerateOptions, GenerateResult } from './generator';
+/**
+ * Represents the result structure from Apollo hooks, including potential errors.
+ */
+export interface HookResult<TData = any> {
+    loading: boolean;
+    data?: TData;
+    error?: ApolloError;
+    [key: string]: any;
+    generatedQuery?: GenerateResult['query'];
+    generatedVariables?: GenerateResult['variables'];
+}
+export declare class Client {
+    private apolloClient;
+    private generate;
+    constructor(apolloClient: ApolloClient<any>);
+    /**
+     * Executes a GraphQL query (select operation).
+     * @param options - Options for generating the query.
+     * @returns Promise resolving with the query result data.
+     * @throws ApolloError if the query fails or returns GraphQL errors.
+     */
+    select<TData = any>(options: Omit<GenerateOptions, 'operation'>): Promise<TData>;
+    /**
+     * Executes a GraphQL insert mutation.
+     * @param options - Options for generating the mutation.
+     * @returns Promise resolving with the mutation result data.
+     * @throws ApolloError if the mutation fails or returns GraphQL errors.
+     */
+    insert<TData = any>(options: Omit<GenerateOptions, 'operation'>): Promise<TData>;
+    /**
+     * Executes a GraphQL update mutation.
+     * @param options - Options for generating the mutation.
+     * @returns Promise resolving with the mutation result data.
+     * @throws ApolloError if the mutation fails or returns GraphQL errors.
+     */
+    update<TData = any>(options: Omit<GenerateOptions, 'operation'>): Promise<TData>;
+    /**
+     * Executes a GraphQL delete mutation.
+     * @param options - Options for generating the mutation.
+     * @returns Promise resolving with the mutation result data.
+     * @throws ApolloError if the mutation fails or returns GraphQL errors.
+     */
+    delete<TData = any>(options: Omit<GenerateOptions, 'operation'>): Promise<TData>;
+    /**
+     * Initiates a GraphQL subscription.
+     * @param options - Options for generating the subscription.
+     * @returns An Observable for the subscription results.
+     */
+    subscribe<TData = any, TVariables extends OperationVariables = OperationVariables>(options: Omit<GenerateOptions, 'operation'>): Observable<FetchResult<TData>>;
+}
+/**
+ * Hook to get the Apollo Client instance.
+ * Prefers the explicitly provided client, falls back to context, throws if none found.
+ * @param providedClient - An optional ApolloClient instance.
+ * @returns The ApolloClient instance.
+ * @throws Error if no client is found.
+ */
+export declare function useClient(providedClient?: ApolloClient<any> | null): ApolloClient<any>;
+/**
+ * Hook to perform a GraphQL query using the generator.
+ * @template TData - The expected data type.
+ * @param options - Options for the generator (operation is automatically set to 'query').
+ * @param providedClient - Optional ApolloClient instance to use instead of context.
+ * @param hookOptions - Optional additional options passed directly to Apollo's useQuery hook.
+ * @returns An object containing loading state, data, error, and the generated query/variables.
+ */
+export declare function useQuery<TData = any>(options: Omit<GenerateOptions, 'operation'>, providedClient?: ApolloClient<any> | null, hookOptions?: Omit<Parameters<typeof useApolloQuery>[1], 'variables' | 'client' | 'query'>): HookResult<TData>;
+/** Alias for useQuery */
+export declare const useSelect: typeof useQuery;
+/**
+ * Hook to perform a GraphQL subscription using the generator.
+ * @template TData - The expected data type.
+ * @param options - Options for the generator (operation is automatically set to 'subscription').
+ * @param providedClient - Optional ApolloClient instance to use instead of context.
+ * @param hookOptions - Optional additional options passed directly to Apollo's useSubscription hook.
+ * @returns An object containing loading state, data, error, and the generated query/variables.
+ */
+export declare function useSubscription<TData = any>(options: Omit<GenerateOptions, 'operation'>, providedClient?: ApolloClient<any> | null, hookOptions?: Omit<Parameters<typeof useApolloSubscription>[1], 'variables' | 'client' | 'query'>): HookResult<TData>;
+/** Alias for useSubscription */
+export declare const useSubscribe: typeof useSubscription;

package/dist/lib/client.jsx

@@ -0,0 +1,237 @@
+"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 __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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSubscribe = exports.useSelect = exports.Client = void 0;
+exports.useClient = useClient;
+exports.useQuery = useQuery;
+exports.useSubscription = useSubscription;
+const client_1 = require("@apollo/client");
+const react_1 = require("react");
+const generator_1 = __importDefault(require("./generator")); // Assuming generator exports the function directly
+const debug_1 = __importDefault(require("./debug"));
+const debug = (0, debug_1.default)('nha:client');
+class Client {
+    constructor(apolloClient) {
+        if (!apolloClient) {
+            throw new Error('❌ ApolloClient instance must be provided to the Client constructor.');
+        }
+        this.apolloClient = apolloClient;
+        this.generate = generator_1.default; // Use the imported generator function
+        debug('Client class initialized with ApolloClient instance.');
+    }
+    /**
+     * Executes a GraphQL query (select operation).
+     * @param options - Options for generating the query.
+     * @returns Promise resolving with the query result data.
+     * @throws ApolloError if the query fails or returns GraphQL errors.
+     */
+    select(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            debug('Executing select with options:', options);
+            const generated = this.generate(Object.assign(Object.assign({}, options), { operation: 'query' }));
+            try {
+                const result = yield this.apolloClient.query({
+                    query: generated.query,
+                    variables: generated.variables,
+                    fetchPolicy: 'network-only', // Ensure fresh data for direct calls
+                });
+                if (result.errors) {
+                    debug('GraphQL errors during select:', result.errors);
+                    throw new client_1.ApolloError({ graphQLErrors: result.errors });
+                }
+                debug('Select successful, returning data:', result.data);
+                return result.data;
+            }
+            catch (error) {
+                debug('Error during select:', error);
+                throw error; // Re-throw original error (could be ApolloError or network error)
+            }
+        });
+    }
+    /**
+     * Executes a GraphQL insert mutation.
+     * @param options - Options for generating the mutation.
+     * @returns Promise resolving with the mutation result data.
+     * @throws ApolloError if the mutation fails or returns GraphQL errors.
+     */
+    insert(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            debug('Executing insert with options:', options);
+            const generated = this.generate(Object.assign(Object.assign({}, options), { operation: 'insert' }));
+            try {
+                const result = yield this.apolloClient.mutate({
+                    mutation: generated.query,
+                    variables: generated.variables,
+                });
+                if (result.errors) {
+                    debug('GraphQL errors during insert:', result.errors);
+                    throw new client_1.ApolloError({ graphQLErrors: result.errors });
+                }
+                // Check if data exists, otherwise return an empty object or handle as needed
+                const returnData = (_a = result.data) !== null && _a !== void 0 ? _a : {};
+                debug('Insert successful, returning data:', returnData);
+                return returnData;
+            }
+            catch (error) {
+                debug('Error during insert:', error);
+                throw error;
+            }
+        });
+    }
+    /**
+     * Executes a GraphQL update mutation.
+     * @param options - Options for generating the mutation.
+     * @returns Promise resolving with the mutation result data.
+     * @throws ApolloError if the mutation fails or returns GraphQL errors.
+     */
+    update(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            debug('Executing update with options:', options);
+            const generated = this.generate(Object.assign(Object.assign({}, options), { operation: 'update' }));
+            try {
+                const result = yield this.apolloClient.mutate({
+                    mutation: generated.query,
+                    variables: generated.variables,
+                });
+                if (result.errors) {
+                    debug('GraphQL errors during update:', result.errors);
+                    throw new client_1.ApolloError({ graphQLErrors: result.errors });
+                }
+                const returnData = (_a = result.data) !== null && _a !== void 0 ? _a : {};
+                debug('Update successful, returning data:', returnData);
+                return returnData;
+            }
+            catch (error) {
+                debug('Error during update:', error);
+                throw error;
+            }
+        });
+    }
+    /**
+     * Executes a GraphQL delete mutation.
+     * @param options - Options for generating the mutation.
+     * @returns Promise resolving with the mutation result data.
+     * @throws ApolloError if the mutation fails or returns GraphQL errors.
+     */
+    delete(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            debug('Executing delete with options:', options);
+            const generated = this.generate(Object.assign(Object.assign({}, options), { operation: 'delete' }));
+            try {
+                const result = yield this.apolloClient.mutate({
+                    mutation: generated.query,
+                    variables: generated.variables,
+                });
+                if (result.errors) {
+                    debug('GraphQL errors during delete:', result.errors);
+                    throw new client_1.ApolloError({ graphQLErrors: result.errors });
+                }
+                const returnData = (_a = result.data) !== null && _a !== void 0 ? _a : {};
+                debug('Delete successful, returning data:', returnData);
+                return returnData;
+            }
+            catch (error) {
+                debug('Error during delete:', error);
+                throw error;
+            }
+        });
+    }
+    /**
+     * Initiates a GraphQL subscription.
+     * @param options - Options for generating the subscription.
+     * @returns An Observable for the subscription results.
+     */
+    subscribe(options) {
+        debug('Initiating subscribe with options:', options);
+        const generated = this.generate(Object.assign(Object.assign({}, options), { operation: 'subscription' }));
+        return this.apolloClient.subscribe({
+            query: generated.query,
+            variables: generated.variables,
+        });
+    }
+}
+exports.Client = Client;
+// --- React Hooks ---
+/**
+ * Hook to get the Apollo Client instance.
+ * Prefers the explicitly provided client, falls back to context, throws if none found.
+ * @param providedClient - An optional ApolloClient instance.
+ * @returns The ApolloClient instance.
+ * @throws Error if no client is found.
+ */
+function useClient(providedClient) {
+    const ApolloContext = (0, client_1.getApolloContext)();
+    const contextValue = (0, react_1.useContext)(ApolloContext);
+    const contextClient = contextValue === null || contextValue === void 0 ? void 0 : contextValue.client;
+    const client = providedClient !== null && providedClient !== void 0 ? providedClient : contextClient;
+    if (!client) {
+        throw new Error('❌ useClient: No ApolloClient instance found. Provide one directly or ensure the component is wrapped in an ApolloProvider.');
+    }
+    return client;
+}
+/**
+ * Hook to perform a GraphQL query using the generator.
+ * @template TData - The expected data type.
+ * @param options - Options for the generator (operation is automatically set to 'query').
+ * @param providedClient - Optional ApolloClient instance to use instead of context.
+ * @param hookOptions - Optional additional options passed directly to Apollo's useQuery hook.
+ * @returns An object containing loading state, data, error, and the generated query/variables.
+ */
+function useQuery(options, providedClient, hookOptions) {
+    // Memoize generator options based on a stable string representation
+    // Important: Ensure options object structure is consistent or use a deep-stable stringify
+    const optionsString = (0, react_1.useMemo)(() => JSON.stringify(options), [options]);
+    const memoizedOptions = (0, react_1.useMemo)(() => JSON.parse(optionsString), [optionsString]);
+    const client = useClient(providedClient);
+    const generated = (0, react_1.useMemo)(() => (0, generator_1.default)(Object.assign(Object.assign({}, memoizedOptions), { operation: 'query' })), [memoizedOptions] // Depend on the memoized options object
+    );
+    const _a = (0, client_1.useQuery)(generated.query, Object.assign({ client: client, variables: generated.variables }, hookOptions)), { loading, error, data } = _a, rest = __rest(_a, ["loading", "error", "data"]);
+    // Combine Apollo results with generator info
+    return Object.assign(Object.assign({ loading, error, data }, rest), { generatedQuery: generated.query, generatedVariables: generated.variables });
+}
+/** Alias for useQuery */
+exports.useSelect = useQuery;
+/**
+ * Hook to perform a GraphQL subscription using the generator.
+ * @template TData - The expected data type.
+ * @param options - Options for the generator (operation is automatically set to 'subscription').
+ * @param providedClient - Optional ApolloClient instance to use instead of context.
+ * @param hookOptions - Optional additional options passed directly to Apollo's useSubscription hook.
+ * @returns An object containing loading state, data, error, and the generated query/variables.
+ */
+function useSubscription(options, providedClient, hookOptions) {
+    // Memoize generator options
+    const optionsString = (0, react_1.useMemo)(() => JSON.stringify(options), [options]);
+    const memoizedOptions = (0, react_1.useMemo)(() => JSON.parse(optionsString), [optionsString]);
+    const client = useClient(providedClient);
+    const generated = (0, react_1.useMemo)(() => (0, generator_1.default)(Object.assign(Object.assign({}, memoizedOptions), { operation: 'subscription' })), [memoizedOptions]);
+    const _a = (0, client_1.useSubscription)(generated.query, Object.assign({ client: client, variables: generated.variables }, hookOptions)), { loading, error, data } = _a, rest = __rest(_a, ["loading", "error", "data"]);
+    return Object.assign(Object.assign({ loading, error, data }, rest), { generatedQuery: generated.query, generatedVariables: generated.variables });
+}
+/** Alias for useSubscription */
+exports.useSubscribe = useSubscription;

package/dist/lib/generator.d.ts

@@ -23,11 +23,6 @@ export interface GenerateResult {
     variables: Record<string, any>;
     varCounter: number;
 }
-/**
- * Creates a GraphQL query generator based on the provided schema.
- *
- * @param schema - The GraphQL schema in schema.json format.
- * @returns A function to generate queries.
- */
 export declare function Generator(schema: any): (opts: GenerateOptions) => GenerateResult;
-export default Generator;
+declare const _default: (opts: GenerateOptions) => GenerateResult;
+export default _default;