nextjs-hasura-auth 0.1.1 → 0.1.2

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;