nextjs-hasura-auth 0.1.0

package/dist/lib/generator.js

@@ -0,0 +1,548 @@
+"use strict";
+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.Generator = Generator;
+const debug_1 = __importDefault(require("./debug"));
+// @ts-ignore // Assuming debug.js is moved to lib/debug.ts or similar and returns a function
+const debug = (0, debug_1.default)('apollo:generator');
+const core_1 = require("@apollo/client/core"); // Use core for gql
+/**
+ * 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.
+ */
+function Generator(schema) {
+    // Check schema structure
+    if (!schema || !schema.first_level_queries) {
+        throw new Error('❌ Invalid schema format. Schema must contain first_level_queries field');
+    }
+    /**
+     * Generates a GraphQL query based on the provided options.
+     *
+     * @param opts - Options object for query generation.
+     * @returns The GraphQL query, variables, and current variable counter.
+     */
+    return function generate(opts) {
+        let varCounter = opts.varCounter || 1;
+        if (!opts || !opts.operation || !opts.table) {
+            throw new Error('❌ operation and table must be specified in options');
+        }
+        const { operation, table } = opts;
+        const where = opts.where || null;
+        const returning = opts.returning || null;
+        const aggregate = opts.aggregate || null;
+        const fragments = opts.fragments || [];
+        const validOperations = ['query', 'subscription', 'insert', 'update', 'delete'];
+        if (!validOperations.includes(operation)) {
+            throw new Error(`❌ Invalid operation type: ${operation}. Allowed types: ${validOperations.join(', ')}`);
+        }
+        let tableName = table;
+        let schemaSection = 'first_level_queries';
+        if (aggregate && operation === 'query') {
+            tableName = `${table}_aggregate`;
+        }
+        if (operation === 'query') {
+            schemaSection = 'first_level_queries';
+        }
+        else if (operation === 'subscription') {
+            schemaSection = 'subscriptions';
+        }
+        else if (['insert', 'update', 'delete'].includes(operation)) {
+            schemaSection = 'mutations';
+            if (operation === 'insert') {
+                tableName = `insert_${table}`;
+            }
+            else if (operation === 'update') {
+                // Handle _by_pk update separately later
+                // tableName = `update_${table}`; // Keep original table for now
+            }
+            else if (operation === 'delete') {
+                // Handle _by_pk delete separately later
+                // tableName = `delete_${table}`; // Keep original table for now
+            }
+        }
+        if (!schema[schemaSection]) {
+            throw new Error(`❌ Schema section ${schemaSection} not found. Schema might be outdated or incorrect.`);
+        }
+        // Special handling for update/delete by pk
+        let isByPkOperation = false;
+        if (['update', 'delete'].includes(operation) && opts.pk_columns) {
+            isByPkOperation = true;
+            tableName = `${operation}_${table}_by_pk`; // e.g., update_users_by_pk
+        }
+        else if (operation === 'query' && opts.pk_columns) {
+            isByPkOperation = true;
+            tableName = `${table}_by_pk`; // e.g., users_by_pk
+        }
+        else if (operation === 'insert' && opts.object && !opts.objects) {
+            // Try to find insert_table_one mutation
+            const oneMutationName = `insert_${table}_one`;
+            if (schema.mutations && schema.mutations[oneMutationName]) {
+                tableName = oneMutationName;
+                isByPkOperation = true; // Treat insert_one like a by_pk operation for simplicity
+            }
+            else {
+                tableName = `insert_${table}`; // Fallback to regular insert
+            }
+        }
+        else if (operation === 'insert') {
+            tableName = `insert_${table}`;
+        }
+        else if (operation === 'update') {
+            tableName = `update_${table}`;
+        }
+        else if (operation === 'delete') {
+            tableName = `delete_${table}`;
+        }
+        // If not by_pk, and it's a query/sub, keep the original table name for non-aggregate
+        else if (['query', 'subscription'].includes(operation) && !aggregate) {
+            tableName = table;
+        }
+        // If it's an aggregate query
+        else if (operation === 'query' && aggregate) {
+            tableName = `${table}_aggregate`;
+        }
+        const possibleQueries = Object.keys(schema[schemaSection]);
+        let queryName = possibleQueries.find(q => q === tableName);
+        // Fallback logic if specific query (like insert_table_one) wasn't found directly
+        if (!queryName) {
+            // General fallback: find first matching query
+            queryName = possibleQueries.find(q => q.includes(table)) || possibleQueries[0];
+            if (!queryName) {
+                throw new Error(`❌ Query/Mutation/Subscription for table "${table}" not found in schema section "${schemaSection}"`);
+            }
+            console.log(`[generator] ⚠️ Could not find exact query name "${tableName}", using fallback "${queryName}"`);
+        }
+        const queryInfo = schema[schemaSection][queryName];
+        if (!queryInfo) {
+            throw new Error(`❌ Query info for "${queryName}" not found in schema section "${schemaSection}"`);
+        }
+        const queryArgs = [];
+        const variables = {};
+        const varParts = [];
+        // Helper function with improved required logic
+        const getGqlType = (argName, argSchema, value, defaultType = 'String', forceRequired = false) => {
+            let typeName = (argSchema === null || argSchema === void 0 ? void 0 : argSchema.type) || defaultType;
+            let isList = (argSchema === null || argSchema === void 0 ? void 0 : argSchema.isList) || false; // Rely more on schema or explicit checks
+            let isRequired = forceRequired || (argSchema === null || argSchema === void 0 ? void 0 : argSchema.isRequired) || false;
+            // Check type name conventions first (e.g., from introspection)
+            if (typeof typeName === 'string') {
+                let baseTypeName = typeName;
+                if (baseTypeName.endsWith('!')) {
+                    isRequired = true;
+                    baseTypeName = baseTypeName.slice(0, -1);
+                }
+                if (baseTypeName.startsWith('[') && baseTypeName.endsWith(']')) {
+                    isList = true;
+                    baseTypeName = baseTypeName.slice(1, -1);
+                    // Check for inner required type e.g., [String!]
+                    if (baseTypeName.endsWith('!')) {
+                        // Mark inner as required if needed? (Handled later for known types)
+                        baseTypeName = baseTypeName.slice(0, -1);
+                    }
+                }
+                typeName = baseTypeName;
+            }
+            // Determine list/required based on arg name conventions
+            const baseTable = table; // Use original table name for type conventions
+            let finalType = typeName;
+            let finalIsRequired = isRequired;
+            let finalIsList = isList;
+            let innerRequired = false;
+            // Apply conventions/overrides
+            if (argName === 'objects') {
+                finalType = `${baseTable}_insert_input`;
+                finalIsList = true;
+                finalIsRequired = true;
+                innerRequired = true;
+            }
+            if (argName === 'object') {
+                finalType = `${baseTable}_insert_input`;
+                finalIsList = false;
+                finalIsRequired = true;
+            }
+            if (argName === 'order_by') {
+                finalType = `${baseTable}_order_by`;
+                finalIsList = true;
+                finalIsRequired = false;
+                innerRequired = true;
+            } // List itself not required, but inner usually is
+            if (argName === 'pk_columns') {
+                finalType = `${baseTable}_pk_columns_input`;
+                finalIsList = false;
+                finalIsRequired = true;
+            }
+            if (argName === '_set') {
+                finalType = `${baseTable}_set_input`;
+                finalIsList = false;
+                finalIsRequired = true;
+            }
+            if (argName === 'where') {
+                finalType = `${baseTable}_bool_exp`;
+                finalIsList = false;
+                finalIsRequired = false;
+            }
+            // If it's a direct PK arg (like `id` in `users_by_pk(id: uuid!)`)
+            if (forceRequired) {
+                finalIsRequired = true;
+                finalIsList = false; // Direct PK args are typically not lists
+            }
+            // Construct the final type string
+            let typeString = finalType;
+            if (finalIsList) {
+                typeString = `[${finalType}${innerRequired ? '!' : ''}]`;
+            }
+            if (finalIsRequired) {
+                typeString += '!';
+            }
+            return typeString;
+        };
+        // Argument processing function (now relies on getGqlType for correctness)
+        const processArg = (argName, value, argSchema, isDirectPk = false) => {
+            if (value === undefined || value === null)
+                return;
+            const varName = `v${varCounter++}`;
+            queryArgs.push(`${argName}: $${varName}`);
+            variables[varName] = value;
+            const gqlType = getGqlType(argName, argSchema, value, 'String', isDirectPk);
+            varParts.push(`$${varName}: ${gqlType}`);
+        };
+        // --- Argument Processing with deterministic order --- 
+        const argProcessingOrder = [
+            // Common args first
+            'where',
+            // PK args (direct or pk_columns object)
+            ...(isByPkOperation && opts.pk_columns ? Object.keys(opts.pk_columns) : []), // Direct PK args like 'id'
+            'pk_columns', // The pk_columns input object itself
+            // Mutation specific
+            '_set',
+            'objects',
+            'object',
+            // Pagination/Sorting
+            'limit',
+            'offset',
+            'order_by'
+        ];
+        const processedArgs = new Set();
+        // Process args in defined order
+        for (const argName of argProcessingOrder) {
+            if (!queryInfo.args || !queryInfo.args[argName])
+                continue; // Skip if arg not in schema
+            if (processedArgs.has(argName))
+                continue;
+            const argSchema = queryInfo.args[argName];
+            let value = undefined;
+            let isDirectPk = false;
+            // Map opts to schema args
+            if (argName === 'pk_columns' && opts.pk_columns) {
+                // Process this ONLY if the operation expects pk_columns (update_by_pk)
+                if (operation === 'update') {
+                    value = opts.pk_columns;
+                }
+                else {
+                    // For query_by_pk and delete_by_pk, pk_columns is used to find direct args
+                    continue; // Skip processing pk_columns itself here
+                }
+            }
+            else if (argName === '_set' && opts._set) {
+                value = opts._set;
+            }
+            else if (argName === 'objects' && (opts.objects || opts.object)) {
+                value = opts.objects || [opts.object];
+            }
+            else if (argName === 'object' && opts.object && !opts.objects) {
+                value = opts.object;
+            }
+            else if (isByPkOperation && opts.pk_columns && opts.pk_columns[argName] !== undefined) {
+                // Handle direct PK arg like `id` for `_by_pk` operations 
+                // Check if the schema actually expects this direct arg
+                if (queryInfo.args[argName]) {
+                    value = opts.pk_columns[argName];
+                    isDirectPk = true;
+                }
+                else {
+                    // This direct PK arg is not in schema, maybe it expects pk_columns object?
+                    // Let's skip processing it directly if pk_columns object is also in the processing order
+                    if (argProcessingOrder.includes('pk_columns'))
+                        continue;
+                    else
+                        value = opts.pk_columns[argName]; // Process if pk_columns object isn't expected
+                }
+            }
+            else if (opts[argName] !== undefined) {
+                value = opts[argName];
+            }
+            if (value !== undefined) {
+                processArg(argName, value, argSchema, isDirectPk);
+                processedArgs.add(argName);
+            }
+        }
+        // Process any remaining args not in the defined order (should be rare)
+        if (queryInfo.args) {
+            for (const argName in queryInfo.args) {
+                if (!processedArgs.has(argName)) {
+                    const value = opts[argName];
+                    if (value !== undefined) {
+                        processArg(argName, value, queryInfo.args[argName], false);
+                        processedArgs.add(argName);
+                    }
+                }
+            }
+        }
+        // --- End Argument Processing ---
+        const returningFields = [];
+        function processReturningField(field, currentVarCounterRef) {
+            if (typeof field === 'string') {
+                return field.trim();
+            }
+            if (typeof field === 'object' && field !== null) {
+                const fieldName = Object.keys(field)[0];
+                const subFieldsOrParams = field[fieldName];
+                if (typeof subFieldsOrParams === 'boolean' && subFieldsOrParams) {
+                    return fieldName;
+                }
+                if (typeof subFieldsOrParams === 'boolean' && !subFieldsOrParams) {
+                    return ''; // Explicitly skip false fields
+                }
+                if (Array.isArray(subFieldsOrParams)) {
+                    const subFieldsStr = subFieldsOrParams
+                        .map(sf => processReturningField(sf, currentVarCounterRef))
+                        .filter(Boolean) // Remove empty strings from skipped fields
+                        .join('\n        ');
+                    return subFieldsStr ? `${fieldName} {\n        ${subFieldsStr}\n      }` : '';
+                }
+                if (typeof subFieldsOrParams === 'string') {
+                    return `${fieldName} {\n        ${subFieldsOrParams}\n      }`;
+                }
+                // Handling nested query object with potential parameters
+                if (typeof subFieldsOrParams === 'object' && subFieldsOrParams !== null) {
+                    const { where: nestedWhere, limit: nestedLimit, offset: nestedOffset, order_by: nestedOrderBy, alias, returning: nestedReturningDef } = subFieldsOrParams, otherParams = __rest(subFieldsOrParams, ["where", "limit", "offset", "order_by", "alias", "returning"]);
+                    const relationName = fieldName;
+                    const fieldAliasOrName = alias || relationName;
+                    const relationArgTypeNameBase = alias ? alias : relationName;
+                    const nestedArgs = [];
+                    // Nested argument processing
+                    const processNestedArg = (argName, value, typeSuffix, defaultType = 'String', forceList = false) => {
+                        if (value === undefined || value === null)
+                            return;
+                        const varName = `v${currentVarCounterRef.count++}`;
+                        nestedArgs.push(`${argName}: $${varName}`);
+                        variables[varName] = value;
+                        // Construct type, e.g., users_bool_exp, posts_order_by
+                        let gqlType = typeSuffix ? `${relationArgTypeNameBase}${typeSuffix}` : defaultType;
+                        let isRequired = false; // Assume nested args aren't required unless schema says so
+                        let isList = forceList || (argName === 'order_by'); // Force list for order_by
+                        // Basic check if type name implies list/required (might need schema lookup)
+                        if (gqlType.startsWith('['))
+                            isList = true;
+                        if (gqlType.endsWith('!')) {
+                            isRequired = true;
+                            gqlType = gqlType.slice(0, -1);
+                        }
+                        // Strip list markers if present, handle wrapping below
+                        if (gqlType.startsWith('[') && gqlType.endsWith(']')) {
+                            gqlType = gqlType.slice(1, -1);
+                        }
+                        let finalType = gqlType;
+                        if (isList) {
+                            // Assume inner type is required for order_by list
+                            const innerRequired = argName === 'order_by' ? '!' : '';
+                            finalType = `[${gqlType}${innerRequired}]`;
+                            // Is the list itself required? (Usually not for nested args)
+                            isRequired = false;
+                        }
+                        varParts.push(`$${varName}: ${finalType}${isRequired ? '!' : ''}`);
+                    };
+                    processNestedArg('where', nestedWhere, '_bool_exp');
+                    processNestedArg('limit', nestedLimit, '', 'Int');
+                    processNestedArg('offset', nestedOffset, '', 'Int');
+                    // Pass forceList=true for order_by
+                    processNestedArg('order_by', nestedOrderBy, '_order_by', 'String', true);
+                    // Process other arbitrary parameters
+                    for (const paramName in otherParams) {
+                        processNestedArg(paramName, otherParams[paramName], ''); // Assume String default
+                    }
+                    const nestedArgsStr = nestedArgs.length > 0 ? `(${nestedArgs.join(', ')})` : '';
+                    let finalNestedReturning = ['id']; // Default returning 'id'
+                    if (nestedReturningDef) {
+                        if (Array.isArray(nestedReturningDef)) {
+                            finalNestedReturning = nestedReturningDef;
+                        }
+                        else if (typeof nestedReturningDef === 'string') {
+                            finalNestedReturning = nestedReturningDef.split(/\s+/).filter(Boolean);
+                        }
+                        else if (typeof nestedReturningDef === 'object') {
+                            // Convert object { field: true, another: {...} } to array ['field', { another: {...} }]
+                            finalNestedReturning = Object.entries(nestedReturningDef)
+                                .filter(([_, value]) => value) // Filter out false values
+                                .map(([key, value]) => (typeof value === 'boolean' ? key : { [key]: value }));
+                        }
+                    }
+                    const nestedFieldsStr = finalNestedReturning
+                        .map(f => processReturningField(f, currentVarCounterRef))
+                        .filter(Boolean) // Remove empty strings from skipped fields
+                        .join('\n        ');
+                    // Use alias in the field definition if present
+                    const fieldDefinition = alias ? `${relationName}: ${fieldAliasOrName}` : fieldAliasOrName;
+                    return nestedFieldsStr ? `${fieldDefinition}${nestedArgsStr} {\n        ${nestedFieldsStr}\n      }` : '';
+                }
+                return ''; // Skip invalid field types
+            }
+            return ''; // Skip invalid field types
+        }
+        const varCounterRef = { count: varCounter }; // Use ref for mutable counter in recursion
+        // ---- START MODIFICATION ----
+        let defaultFieldsGenerated = false;
+        // Function to generate default fields based on operation type and schema
+        const generateDefaultFields = () => {
+            var _a;
+            if (defaultFieldsGenerated)
+                return; // Generate only once
+            if (aggregate) {
+                // Aggregate logic already adds `aggregate { ... }` and potentially `nodes { ... }`
+                // No separate default fields needed here unless `returning` for nodes is omitted
+                // The existing aggregate logic handles the structure.
+            }
+            else if (queryInfo.returning_fields && !isByPkOperation && operation !== 'delete') {
+                // Default fields for query, subscription, insert (non-PK)
+                returningFields.push('id');
+                ['name', 'email', 'created_at', 'updated_at'].forEach(f => {
+                    if (queryInfo.returning_fields[f])
+                        returningFields.push(f);
+                });
+            }
+            else if (isByPkOperation && operation === 'delete') {
+                // Default for delete_by_pk: Try to return PK fields, fallback to id
+                if (opts.pk_columns && queryInfo.returning_fields) {
+                    Object.keys(opts.pk_columns).forEach(pkField => {
+                        if (queryInfo.returning_fields[pkField]) {
+                            returningFields.push(pkField);
+                        }
+                    });
+                }
+                // If no PK fields were added, push id as fallback
+                if (returningFields.length === 0 && ((_a = queryInfo.returning_fields) === null || _a === void 0 ? void 0 : _a.id)) {
+                    returningFields.push('id');
+                }
+            }
+            else { // Default for other mutations _by_pk (update) and query_by_pk
+                if (queryInfo.returning_fields) {
+                    returningFields.push('id'); // Default fallback
+                }
+            }
+            defaultFieldsGenerated = true;
+        };
+        // Process returning option
+        if (returning) {
+            if (Array.isArray(returning)) { // Explicit array provided - overrides defaults
+                returning
+                    .map(field => processReturningField(field, varCounterRef))
+                    .filter(Boolean)
+                    .forEach(processedField => returningFields.push(processedField));
+                defaultFieldsGenerated = true; // Mark defaults as handled/overridden
+            }
+            else if (typeof returning === 'string') { // Explicit string provided - overrides defaults
+                returning.split(/\s+/).filter(Boolean)
+                    .map(field => processReturningField(field, varCounterRef)) // Process simple strings
+                    .filter(Boolean)
+                    .forEach(processedField => returningFields.push(processedField));
+                defaultFieldsGenerated = true; // Mark defaults as handled/overridden
+            }
+            else if (typeof returning === 'object' && returning !== null) { // NEW: Object provided - ADD to defaults
+                // 1. Generate default fields first
+                generateDefaultFields();
+                // 2. Process the object as additional relations/fields
+                Object.entries(returning).forEach(([key, value]) => {
+                    // Construct the object format processReturningField expects: { relationName: subOptions }
+                    const fieldObject = { [key]: value };
+                    const processedField = processReturningField(fieldObject, varCounterRef);
+                    if (processedField) {
+                        // Avoid adding duplicates if default already added it (less likely for relations)
+                        if (!returningFields.includes(processedField)) {
+                            returningFields.push(processedField);
+                        }
+                    }
+                });
+            }
+            else {
+                // Invalid returning type? Fallback to defaults.
+                generateDefaultFields();
+            }
+        }
+        else { // returning is null or undefined - Use defaults
+            generateDefaultFields();
+        }
+        // ---- END MODIFICATION ----
+        varCounter = varCounterRef.count; // Update main counter
+        // Adjust structure for bulk mutations (insert, update, delete) vs single (_one, _by_pk)
+        let finalReturningFields = [...returningFields];
+        if (['insert', 'update', 'delete'].includes(operation) && !isByPkOperation) {
+            // Bulk operations usually return affected_rows and a nested 'returning' array
+            const fieldsForReturning = finalReturningFields.filter(f => !f.startsWith('affected_rows')); // Keep existing fields
+            finalReturningFields = ['affected_rows']; // Start with affected_rows
+            if (fieldsForReturning.length > 0) {
+                const returningFieldsStr = fieldsForReturning.join('\n        ');
+                finalReturningFields.push(`returning {\n        ${returningFieldsStr}\n      }`);
+            }
+        }
+        // Ensure single operations (_one, _by_pk) don't have affected_rows unless explicitly asked?
+        // The current logic seems to handle this by default returning fields based on queryInfo
+        // Determine the GraphQL operation type based on the input operation
+        let gqlOperationType;
+        if (operation === 'query') {
+            gqlOperationType = 'query';
+        }
+        else if (operation === 'subscription') {
+            gqlOperationType = 'subscription';
+        }
+        else { // insert, update, delete
+            gqlOperationType = 'mutation';
+        }
+        // Construct operation name (e.g., QueryUsers, MutationInsertUsersOne)
+        const opNamePrefix = gqlOperationType.charAt(0).toUpperCase() + gqlOperationType.slice(1);
+        // Ensure tablePascal handles potential empty parts from split
+        const tablePascal = queryName.split('_').map(part => part ? part.charAt(0).toUpperCase() + part.slice(1) : '').join('');
+        const operationName = `${opNamePrefix}${tablePascal}`;
+        const argsStr = queryArgs.length > 0 ? `(${queryArgs.join(', ')})` : '';
+        const returningStr = finalReturningFields.length > 0 ? finalReturningFields.join('\n      ') : (queryInfo.returning_fields ? 'id' : ''); // Fallback to id if possible
+        const fragmentsStr = fragments.length > 0 ? `\n${fragments.join('\n')}` : '';
+        const queryStr = `
+      ${gqlOperationType} ${operationName}${varParts.length > 0 ? `(${varParts.join(', ')})` : ''} {
+        ${queryName}${argsStr}${returningStr ? ` {
+          ${returningStr}
+        }` : ''}
+      }${fragmentsStr}
+    `;
+        try {
+            const gqlQuery = (0, core_1.gql)(queryStr);
+            return {
+                queryString: queryStr,
+                query: gqlQuery,
+                variables,
+                varCounter
+            };
+        }
+        catch (error) {
+            console.error("❌ Error parsing GraphQL query:", error.message);
+            console.error("Generated Query String:", queryStr);
+            console.error("Variables:", JSON.stringify(variables, null, 2));
+            throw new Error(`Failed to parse generated GraphQL query: ${error.message}`);
+        }
+    };
+}
+// Export the factory function
+exports.default = Generator;

package/dist/lib/index.d.ts

@@ -0,0 +1,3 @@
+export * from './utils';
+export * from './apollo';
+export * from './generator';

package/dist/lib/index.js

@@ -0,0 +1,20 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Export all utilities from the lib directory
+__exportStar(require("./utils"), exports);
+__exportStar(require("./apollo"), exports);
+__exportStar(require("./generator"), exports);

package/dist/lib/jwt.d.ts

@@ -0,0 +1,67 @@
+import { type JWTPayload } from 'jose';
+/**
+ * Get JWT secret from environment variables (for signing/verifying JWS)
+ * This remains synchronous as it doesn't involve async crypto operations here.
+ * @returns {Uint8Array} Secret key for JWT signing
+ */
+export declare const getJwtSecret: () => Uint8Array;
+/**
+ * Get NextAuth secret from environment variables and hash it using Web Crypto API (SHA-256).
+ * IMPORTANT: This MUST match the NEXTAUTH_SECRET used by next-auth.
+ * @returns {Promise<Uint8Array>} Secret key for JWE operations (always 32 bytes/256 bits)
+ */
+export declare const getNextAuthSecret: () => Promise<Uint8Array>;
+/**
+ * Extracts the algorithm type from JWT secret configuration (for JWS)
+ * This remains synchronous.
+ * @returns {string} The algorithm type (default: 'HS256')
+ */
+export declare const getJwtAlgorithm: () => string;
+/**
+ * Creates a JWT token (JWS) with Hasura claims
+ *
+ * @param {string} userId - User ID
+ * @param {Record<string, any>} [additionalClaims={}] - Additional claims for the token
+ * @param {{ expiresIn?: string }} [options={}] - Options for token generation
+ * @returns {Promise<string>} JWT token (JWS format)
+ */
+export declare const generateJWT: (userId: string, additionalClaims?: Record<string, any>, options?: {
+    expiresIn?: string;
+}) => Promise<string>;
+/**
+ * Verifies a JWT token (JWS)
+ * @param {string} token - JWT token (JWS format) to verify
+ * @returns {Promise<JWTPayload>} Token payload
+ */
+export declare const verifyJWT: (token: string) => Promise<JWTPayload>;
+/**
+ * Decrypts a NextAuth session token (JWE)
+ * @param {string} sessionToken - The encrypted session token (JWE) from the cookie
+ * @returns {Promise<JWTPayload>} The decrypted payload
+ */
+export declare const decryptNextAuthToken: (sessionToken: string) => Promise<JWTPayload>;
+/**
+ * Extract user ID from a verified/decrypted JWT payload
+ * @param {JWTPayload} payload - The token payload
+ * @returns {string | null} User ID or null if not found
+ */
+export declare const getUserIdFromPayload: (payload: JWTPayload) => string | null;
+/**
+ * Get Hasura claims from a verified/decrypted JWT payload
+ * @param {JWTPayload} payload - The token payload
+ * @returns {Record<string, any> | null} Hasura claims or null if not found
+ */
+export declare const getHasuraClaimsFromPayload: (payload: JWTPayload) => Record<string, any> | null;
+declare const _default: {
+    getJwtSecret: () => Uint8Array;
+    getNextAuthSecret: () => Promise<Uint8Array>;
+    getJwtAlgorithm: () => string;
+    generateJWT: (userId: string, additionalClaims?: Record<string, any>, options?: {
+        expiresIn?: string;
+    }) => Promise<string>;
+    verifyJWT: (token: string) => Promise<JWTPayload>;
+    decryptNextAuthToken: (sessionToken: string) => Promise<JWTPayload>;
+    getUserIdFromPayload: (payload: JWTPayload) => string | null;
+    getHasuraClaimsFromPayload: (payload: JWTPayload) => Record<string, any> | null;
+};
+export default _default;