nextjs-hasura-auth 0.1.2 → 0.1.3

package/dist/lib/client.js

@@ -0,0 +1,353 @@
+"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.useDelete = exports.useUpdate = exports.useInsert = exports.useSelect = exports.Client = void 0;
+exports.useClient = useClient;
+exports.useQuery = useQuery;
+exports.useSubscription = useSubscription;
+exports.useMutation = useMutation;
+const client_1 = require("@apollo/client");
+const react_1 = require("react");
+const client_2 = require("@apollo/client");
+const debug_1 = __importDefault(require("./debug"));
+const generator_1 = __importDefault(require("./generator"));
+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, including an optional `role`.
+     * @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* () {
+            const { role } = options, genOptions = __rest(options, ["role"]); // Extract role
+            debug('Executing select with options:', genOptions, 'Role:', role);
+            const generated = this.generate(Object.assign(Object.assign({}, genOptions), { operation: 'query' }));
+            try {
+                const result = yield this.apolloClient.query({
+                    query: generated.query,
+                    variables: generated.variables,
+                    fetchPolicy: 'network-only', // Ensure fresh data for direct calls
+                    context: role ? { role } : undefined, // Pass role in context
+                });
+                if (result.errors) {
+                    debug('GraphQL errors during select:', result.errors);
+                    throw new client_1.ApolloError({ graphQLErrors: result.errors });
+                }
+                debug('Select successful, returning 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, including an optional `role`.
+     * @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;
+            const { role } = options, genOptions = __rest(options, ["role"]); // Extract role
+            debug('Executing insert with options:', genOptions, 'Role:', role);
+            const generated = this.generate(Object.assign(Object.assign({}, genOptions), { operation: 'insert' }));
+            try {
+                const result = yield this.apolloClient.mutate({
+                    mutation: generated.query,
+                    variables: generated.variables,
+                    context: role ? { role } : undefined, // Pass role in context
+                });
+                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.');
+                return returnData;
+            }
+            catch (error) {
+                debug('Error during insert:', error);
+                throw error;
+            }
+        });
+    }
+    /**
+     * Executes a GraphQL update mutation.
+     * @param options - Options for generating the mutation, including an optional `role`.
+     * @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;
+            const { role } = options, genOptions = __rest(options, ["role"]); // Extract role
+            debug('Executing update with options:', genOptions, 'Role:', role);
+            const generated = this.generate(Object.assign(Object.assign({}, genOptions), { operation: 'update' }));
+            try {
+                const result = yield this.apolloClient.mutate({
+                    mutation: generated.query,
+                    variables: generated.variables,
+                    context: role ? { role } : undefined, // Pass role in context
+                });
+                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.');
+                return returnData;
+            }
+            catch (error) {
+                debug('Error during update:', error);
+                throw error;
+            }
+        });
+    }
+    /**
+     * Executes a GraphQL delete mutation.
+     * @param options - Options for generating the mutation, including an optional `role`.
+     * @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;
+            const { role } = options, genOptions = __rest(options, ["role"]); // Extract role
+            debug('Executing delete with options:', genOptions, 'Role:', role);
+            const generated = this.generate(Object.assign(Object.assign({}, genOptions), { operation: 'delete' }));
+            try {
+                const result = yield this.apolloClient.mutate({
+                    mutation: generated.query,
+                    variables: generated.variables,
+                    context: role ? { role } : undefined, // Pass role in context
+                });
+                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.');
+                return returnData;
+            }
+            catch (error) {
+                debug('Error during delete:', error);
+                throw error;
+            }
+        });
+    }
+    /**
+     * Initiates a GraphQL subscription.
+     * Note: Role support via context might not work for WebSockets depending on Apollo Link setup.
+     * Role is typically set during WebSocket connection establishment.
+     * @param options - Options for generating the subscription, including an optional `role`.
+     * @returns An Observable for the subscription results.
+     */
+    subscribe(options) {
+        const { role } = options, genOptions = __rest(options, ["role"]); // Extract role
+        debug('Initiating subscribe with options:', genOptions, 'Role:', role);
+        const generated = this.generate(Object.assign(Object.assign({}, genOptions), { operation: 'subscription' }));
+        return this.apolloClient.subscribe({
+            query: generated.query,
+            variables: generated.variables,
+            context: role ? { role } : undefined, // Pass role, effectiveness depends on link chain
+        });
+    }
+    useSubscription(
+    // First arg: Generator options (table, returning, where, etc.)
+    generateOptions, 
+    // Second arg: Hook options (Apollo options + role)
+    hookOptions // Allow variables here for subscription
+    ) {
+        return useSubscription(generateOptions, (0, react_1.useMemo)(() => (Object.assign(Object.assign({}, hookOptions), { client: this.apolloClient })), [hookOptions]));
+    }
+    ;
+    useQuery(
+    // First arg: Generator options (table, returning, where, etc.)
+    generateOptions, 
+    // Second arg: Hook options (Apollo options + role)
+    hookOptions // Allow variables here for query
+    ) {
+        return useQuery(generateOptions, (0, react_1.useMemo)(() => (Object.assign(Object.assign({}, hookOptions), { client: this.apolloClient })), [hookOptions]));
+    }
+}
+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 (0, react_1.useMemo)(() => new Client(client), [client]);
+}
+// Helper to extract Apollo options and context for HOOKS
+// Adjusted to not expect variables in mutation options directly
+function prepareHookArgs(options, isMutation = false) {
+    const _a = options || {}, { role } = _a, apolloOptions = __rest(_a, ["role"]);
+    const context = role ? { role } : undefined;
+    // Extract variables only if not a mutation (variables are passed to mutate fn)
+    // And if options actually contain variables (e.g., for query/sub)
+    const variables = !isMutation && options && 'variables' in options ? options.variables : undefined;
+    debug('Preparing hook args', { role, context, variables: isMutation ? '(mutation - in mutate fn)' : variables, apolloOptions });
+    return { context, variables, apolloOptions };
+}
+// Standalone Hooks
+function useQuery(
+// First arg: Generator options (table, returning, where, etc.)
+generateOptions, 
+// Second arg: Hook options (Apollo options + role)
+hookOptions // Allow variables here for query
+) {
+    var _a, _b;
+    const client = (0, client_2.useApolloClient)(); // Use client from context
+    // Generate query using the imported 'generate' function
+    const { query: queryString, variables: generatedVariables, varCounter } = (0, react_1.useMemo)(() => (0, generator_1.default)(Object.assign({ operation: 'query' }, generateOptions)), [generateOptions]);
+    // Ensure gql receives a string
+    const query = (0, react_1.useMemo)(() => (0, client_1.gql) `${queryString}`, [queryString]);
+    // Combine variables from generator and hook options (hook options override)
+    // Cast the combined object to TVariables
+    const combinedVariables = Object.assign(Object.assign({}, generatedVariables), hookOptions === null || hookOptions === void 0 ? void 0 : hookOptions.variables);
+    // Prepare arguments for the actual Apollo hook
+    const { context, apolloOptions } = prepareHookArgs(hookOptions, false);
+    const operationName = ((_a = query.definitions[0]) === null || _a === void 0 ? void 0 : _a.kind) === 'OperationDefinition' ? ((_b = query.definitions[0].name) === null || _b === void 0 ? void 0 : _b.value) || 'UnnamedQuery' : 'UnnamedQuery';
+    debug(`Executing query ${operationName}`, { query: queryString, variables: combinedVariables, context, options: apolloOptions });
+    const result = (0, client_2.useQuery)(query, Object.assign({ client, variables: combinedVariables, context }, apolloOptions));
+    debug(`Query ${operationName} result`, { loading: result.loading, error: result.error, data: !!result.data });
+    return result;
+}
+function useSubscription(
+// First arg: Generator options (table, returning, where, etc.)
+generateOptions, 
+// Second arg: Hook options (Apollo options + role)
+hookOptions // Allow variables here for subscription
+) {
+    var _a, _b, _c;
+    const apolloClient = (0, client_2.useApolloClient)(); // Use client from context
+    const client = (_a = hookOptions === null || hookOptions === void 0 ? void 0 : hookOptions.client) !== null && _a !== void 0 ? _a : apolloClient;
+    // Generate subscription using the imported 'generate' function
+    const { query: subscriptionString, variables: generatedVariables, varCounter } = (0, react_1.useMemo)(() => (0, generator_1.default)(Object.assign({ operation: 'subscription' }, generateOptions)), [generateOptions]);
+    // Ensure gql receives a string
+    const subscription = (0, react_1.useMemo)(() => (0, client_1.gql) `${subscriptionString}`, [subscriptionString]);
+    // Combine variables from generator and hook options (hook options override)
+    // Cast the combined object to TVariables
+    const combinedVariables = Object.assign(Object.assign({}, generatedVariables), hookOptions === null || hookOptions === void 0 ? void 0 : hookOptions.variables);
+    // Prepare arguments for the actual Apollo hook
+    const { context, apolloOptions } = prepareHookArgs(hookOptions, false);
+    const operationName = ((_b = subscription.definitions[0]) === null || _b === void 0 ? void 0 : _b.kind) === 'OperationDefinition' ? ((_c = subscription.definitions[0].name) === null || _c === void 0 ? void 0 : _c.value) || 'UnnamedSub' : 'UnnamedSub';
+    // Note: WebSocketLink in apollo.tsx might not support dynamic context/role per subscription easily.
+    // The role set via context here primarily affects the initial HTTP request if applicable,
+    // or needs custom WebSocket handling if role must change mid-subscription.
+    debug(`Executing subscription ${operationName}`, { query: subscriptionString, variables: combinedVariables, context, options: apolloOptions });
+    // Explicitly cast apolloOptions to the correct type expected by useApolloSubscription
+    const typedApolloOptions = apolloOptions;
+    const result = (0, client_2.useSubscription)(subscription, Object.assign({ client, variables: combinedVariables, context }, (typedApolloOptions)));
+    debug(`Subscription ${operationName} result`, { loading: result.loading, error: result.error, data: !!result.data });
+    return result;
+}
+function useMutation(
+// First arg: Generator options (MUST include operation: 'insert' | 'update' | 'delete')
+generateOptions, // Use full GenerateOptions for mutations
+// Second arg: Hook options (Apollo options + role)
+hookOptions) {
+    var _a, _b, _c;
+    const apolloClient = (0, client_2.useApolloClient)(); // Use client from context
+    const client = (_a = hookOptions === null || hookOptions === void 0 ? void 0 : hookOptions.client) !== null && _a !== void 0 ? _a : apolloClient;
+    // Validate that operation is insert/update/delete
+    if (!['insert', 'update', 'delete'].includes(generateOptions.operation)) {
+        throw new Error(`useMutation hook requires operation to be 'insert', 'update', or 'delete' in generateOptions.`);
+    }
+    // Generate mutation using the imported 'generate' function
+    // Variables from generateOptions are the *base* for the mutation
+    const { query: mutationString, variables: baseVariables, varCounter } = (0, react_1.useMemo)(() => (0, generator_1.default)(generateOptions), [generateOptions]);
+    // Ensure gql receives a string
+    const mutation = (0, react_1.useMemo)(() => (0, client_1.gql) `${mutationString}`, [mutationString]);
+    // Prepare arguments for the actual Apollo hook (context, apolloOptions)
+    // Variables are NOT prepared here, they are passed to the mutate function
+    const { context, apolloOptions } = prepareHookArgs(hookOptions, true); // Pass true for isMutation
+    const operationName = ((_b = mutation.definitions[0]) === null || _b === void 0 ? void 0 : _b.kind) === 'OperationDefinition' ? ((_c = mutation.definitions[0].name) === null || _c === void 0 ? void 0 : _c.value) || 'UnnamedMutation' : 'UnnamedMutation';
+    debug(`Preparing mutation ${operationName}`, { query: mutationString, context, options: apolloOptions, baseVariables });
+    // Explicitly cast apolloOptions to the correct type expected by useApolloMutation
+    const typedApolloOptions = apolloOptions;
+    // Variables are passed to the mutate function, not the hook itself usually
+    const [mutate, result] = (0, client_2.useMutation)(mutation, Object.assign({ client, // Pass the client explicitly if needed
+        context }, (typedApolloOptions)));
+    // Wrap the mutate function to potentially add logging or other logic
+    const wrappedMutate = (0, react_1.useCallback)((mutateOptions) => __awaiter(this, void 0, void 0, function* () {
+        // Combine base variables from generator with variables passed to this specific mutate call
+        // Cast the combined object to TVariables
+        const finalVariables = Object.assign(Object.assign({}, baseVariables), mutateOptions === null || mutateOptions === void 0 ? void 0 : mutateOptions.variables);
+        debug(`Executing mutation ${operationName}`, {
+            variables: finalVariables,
+            context: (mutateOptions === null || mutateOptions === void 0 ? void 0 : mutateOptions.context) || context, // Use context from mutate call or default
+            optimisticResponse: mutateOptions === null || mutateOptions === void 0 ? void 0 : mutateOptions.optimisticResponse,
+            update: !!(mutateOptions === null || mutateOptions === void 0 ? void 0 : mutateOptions.update),
+        });
+        try {
+            // Pass final combined variables to the actual mutate function
+            const mutationResult = yield mutate(Object.assign(Object.assign({}, mutateOptions), { variables: finalVariables }));
+            debug(`Mutation ${operationName} success`, { data: mutationResult.data });
+            return mutationResult;
+        }
+        catch (error) {
+            debug(`Mutation ${operationName} error`, { error });
+            // Let the error propagate to be handled by Apollo Client / component
+            throw error;
+        }
+    }), [mutate, operationName, context, baseVariables]); // Include baseVariables in dependency array
+    debug(`Mutation ${operationName} hook state`, { loading: result.loading, error: result.error, data: result.data });
+    return [wrappedMutate, result];
+}
+// Aliases for convenience (Hooks)
+exports.useSelect = useQuery;
+const useInsert = (genOpts, hookOpts) => useMutation(Object.assign({ operation: 'insert' }, genOpts), hookOpts);
+exports.useInsert = useInsert;
+const useUpdate = (genOpts, hookOpts) => useMutation(Object.assign({ operation: 'update' }, genOpts), hookOpts);
+exports.useUpdate = useUpdate;
+const useDelete = (genOpts, hookOpts) => useMutation(Object.assign({ operation: 'delete' }, genOpts), hookOpts);
+exports.useDelete = useDelete;
+exports.useSubscribe = useSubscription;

package/dist/lib/email.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Sends the verification email to a newly registered user.
+ * @param email - The recipient's email address.
+ * @param token - The verification token.
+ * @returns Promise<boolean> - True if email was sent successfully.
+ */
+export declare function sendVerificationEmail(email: string, token: string): Promise<boolean>;

package/dist/lib/email.js

@@ -0,0 +1,90 @@
+"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.sendVerificationEmail = sendVerificationEmail;
+const resend_1 = require("resend");
+const debug_1 = __importDefault(require("@/lib/debug"));
+const debug = (0, debug_1.default)('email');
+const resendApiKey = process.env.RESEND_API_KEY;
+const nextAuthUrl = process.env.NEXTAUTH_URL; // Base URL for verification links
+if (!resendApiKey) {
+    console.warn('⚠️ RESEND_API_KEY environment variable is not set. Email sending will be disabled.');
+    debug('Resend API key not found.');
+}
+if (!nextAuthUrl) {
+    console.warn('⚠️ NEXTAUTH_URL environment variable is not set. Verification links might be incorrect.');
+    debug('NEXTAUTH_URL not found.');
+}
+const resend = resendApiKey ? new resend_1.Resend(resendApiKey) : null;
+/**
+ * Sends an email using Resend.
+ * @param options - Email options (to, subject, html, from).
+ * @returns Promise<boolean> - True if email was sent successfully (or Resend is disabled), false otherwise.
+ */
+function sendEmail(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!resend) {
+            debug('Resend is not configured (missing API key). Skipping email send to: %s', options.to);
+            // In development or if key is missing, maybe we pretend it succeeded?
+            // Or return false to indicate it wasn't actually sent. Let's return true for now.
+            return true;
+        }
+        const { to, subject, html, from = 'onboarding@resend.dev' } = options; // Default 'from' address
+        debug('Attempting to send email via Resend to: %s Subject: %s', to, subject);
+        try {
+            const { data, error } = yield resend.emails.send({
+                from: from,
+                to: to,
+                subject: subject,
+                html: html,
+            });
+            if (error) {
+                debug('Error sending email via Resend:', error);
+                console.error("Resend API Error:", error);
+                return false;
+            }
+            debug('Email sent successfully via Resend. ID: %s', data === null || data === void 0 ? void 0 : data.id);
+            return true;
+        }
+        catch (error) {
+            debug('Failed to send email due to exception:', error);
+            console.error("Exception during email send:", error);
+            return false;
+        }
+    });
+}
+/**
+ * Sends the verification email to a newly registered user.
+ * @param email - The recipient's email address.
+ * @param token - The verification token.
+ * @returns Promise<boolean> - True if email was sent successfully.
+ */
+function sendVerificationEmail(email, token) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const verificationLink = `${nextAuthUrl || 'http://localhost:3000'}/api/auth/verify?token=${token}`;
+        debug('Generated verification link: %s', verificationLink);
+        const subject = 'Verify your email address';
+        const html = `<p>Welcome! Please click the link below to verify your email address:</p>
+                  <p><a href="${verificationLink}">Verify Email</a></p>
+                  <p>If you didn't request this, please ignore this email.</p>
+                  <p>Link: ${verificationLink}</p>`; // Include link as text too
+        return sendEmail({
+            to: email,
+            subject: subject,
+            html: html,
+            // You might want to customize the 'from' address later
+            // from: 'Your App Name <verify@yourdomain.com>' 
+        });
+    });
+}

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>;