nextjs-hasura-auth 0.1.1 → 0.1.2

package/dist/lib/generator.js

@@ -15,28 +15,67 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Generator = Generator;
+// @ts-ignore
+const hasura_schema_json_1 = __importDefault(require("../public/hasura-schema.json")); // Импортируем результат интроспекции
 const debug_1 = __importDefault(require("./debug"));
-// @ts-ignore // Assuming debug.js is moved to lib/debug.ts or similar and returns a function
+const core_1 = require("@apollo/client/core");
 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.
- */
+// Получаем объект __schema из импортированного результата
+// Добавляем базовую проверку
+if (!hasura_schema_json_1.default.data || !hasura_schema_json_1.default.data.__schema) {
+    throw new Error('❌ Invalid introspection result format. Expected { data: { __schema: { ... } } }');
+}
+const schema = hasura_schema_json_1.default.data.__schema;
+// --- Вспомогательная функция для разбора типа GraphQL ---
+// Рекурсивно разбирает тип (обрабатывая NON_NULL и LIST) и возвращает базовое имя и флаги
+function getTypeInfo(type) {
+    let isList = false;
+    let isNonNull = false;
+    let isNonNullItem = false; // Для проверки [Type!]
+    let currentType = type;
+    if (currentType.kind === 'NON_NULL') {
+        isNonNull = true;
+        currentType = currentType.ofType;
+    }
+    if (currentType.kind === 'LIST') {
+        isList = true;
+        currentType = currentType.ofType;
+        if (currentType.kind === 'NON_NULL') {
+            isNonNullItem = true;
+            currentType = currentType.ofType;
+        }
+    }
+    // Второй NON_NULL возможен для [Type!]!
+    if (currentType.kind === 'NON_NULL') {
+        isNonNullItem = true; // Если внешний LIST был NON_NULL, то и внутренний тоже
+        currentType = currentType.ofType;
+    }
+    return {
+        name: currentType.name || null, // Return null if name is missing
+        kind: currentType.kind,
+        isList,
+        isNonNull,
+        isNonNullItem,
+    };
+}
+// --- ---
 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');
+    var _a, _b;
+    if (!schema || !schema.queryType || !schema.types) {
+        throw new Error('❌ Invalid schema format. Expected standard introspection __schema object.');
+    }
+    const queryRootName = schema.queryType.name;
+    const mutationRootName = (_a = schema.mutationType) === null || _a === void 0 ? void 0 : _a.name; // Может отсутствовать
+    const subscriptionRootName = (_b = schema.subscriptionType) === null || _b === void 0 ? void 0 : _b.name; // Может отсутствовать
+    // Находим детальные описания корневых типов
+    const queryRoot = schema.types.find((t) => t.kind === 'OBJECT' && t.name === queryRootName);
+    const mutationRoot = mutationRootName ? schema.types.find((t) => t.kind === 'OBJECT' && t.name === mutationRootName) : null;
+    const subscriptionRoot = subscriptionRootName ? schema.types.find((t) => t.kind === 'OBJECT' && t.name === subscriptionRootName) : null;
+    if (!queryRoot) {
+        throw new Error('❌ Query root type description not found in schema types.');
     }
-    /**
-     * 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) {
+        var _a, _b, _c;
         let varCounter = opts.varCounter || 1;
         if (!opts || !opts.operation || !opts.table) {
             throw new Error('❌ operation and table must be specified in options');
@@ -50,213 +89,126 @@ function Generator(schema) {
         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`;
-        }
+        // --- Определение корневого типа и полей для поиска ---
+        let rootType = null; // Тип будет 'OBJECT' из __schema.types
+        let rootFields = []; // Массив полей из корневого типа
         if (operation === 'query') {
-            schemaSection = 'first_level_queries';
+            rootType = queryRoot;
+            rootFields = queryRoot.fields || [];
         }
         else if (operation === 'subscription') {
-            schemaSection = 'subscriptions';
+            if (!subscriptionRoot)
+                throw new Error('❌ Subscription operations not supported by the schema.');
+            rootType = subscriptionRoot;
+            rootFields = subscriptionRoot.fields || [];
         }
-        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.`);
+        else { // insert, update, delete
+            if (!mutationRoot)
+                throw new Error('❌ Mutation operations not supported by the schema.');
+            rootType = mutationRoot;
+            rootFields = mutationRoot.fields || [];
         }
-        // Special handling for update/delete by pk
+        // --- ---
+        // --- Логика определения имени операции (queryName) ---
+        let targetFieldName = table; // Имя поля, которое ищем в корневом типе
         let isByPkOperation = false;
-        if (['update', 'delete'].includes(operation) && opts.pk_columns) {
-            isByPkOperation = true;
-            tableName = `${operation}_${table}_by_pk`; // e.g., update_users_by_pk
+        let isAggregate = operation === 'query' && !!aggregate;
+        // Определяем префиксы и суффиксы для мутаций и by_pk запросов
+        const mutationPrefix = operation === 'insert' ? 'insert_' : operation === 'update' ? 'update_' : operation === 'delete' ? 'delete_' : '';
+        const pkSuffix = '_by_pk';
+        const aggregateSuffix = '_aggregate';
+        const oneSuffix = '_one';
+        // Формируем ожидаемые имена полей (улучшенная логика)
+        if (isAggregate) {
+            targetFieldName = `${table}${aggregateSuffix}`;
         }
-        else if (operation === 'query' && opts.pk_columns) {
-            isByPkOperation = true;
-            tableName = `${table}_by_pk`; // e.g., users_by_pk
+        else if (opts.pk_columns) {
+            if (operation === 'query') {
+                targetFieldName = `${table}${pkSuffix}`;
+                isByPkOperation = true;
+            }
+            else if (['update', 'delete'].includes(operation)) {
+                targetFieldName = `${mutationPrefix}${table}${pkSuffix}`;
+                isByPkOperation = true;
+            }
+            // pk_columns не влияет на insert
         }
         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
+            const oneFieldName = `${mutationPrefix}${table}${oneSuffix}`;
+            if (rootFields.find(f => f.name === oneFieldName)) {
+                targetFieldName = oneFieldName;
+                // Не ставим isByPkOperation в true для insert_one, т.к. аргументы другие
             }
             else {
-                tableName = `insert_${table}`; // Fallback to regular insert
+                targetFieldName = `${mutationPrefix}${table}`;
             }
         }
         else if (operation === 'insert') {
-            tableName = `insert_${table}`;
+            targetFieldName = `${mutationPrefix}${table}`;
         }
         else if (operation === 'update') {
-            tableName = `update_${table}`;
+            targetFieldName = `${mutationPrefix}${table}`; // Bulk update
         }
         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`;
+            targetFieldName = `${mutationPrefix}${table}`; // Bulk delete
         }
-        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];
+        // Для обычных query/subscription без pk_columns и aggregate, имя таблицы (targetFieldName) остается исходным 'table'
+        const queryInfo = rootFields.find(f => f.name === targetFieldName);
         if (!queryInfo) {
-            throw new Error(`❌ Query info for "${queryName}" not found in schema section "${schemaSection}"`);
+            // Fallback для случая, когда _by_pk/aggregate/etc не найдены, но базовый запрос есть
+            const fallbackQueryInfo = rootFields.find(f => f.name === table);
+            if (fallbackQueryInfo && ['query', 'subscription'].includes(operation) && !isAggregate && !isByPkOperation) {
+                console.warn(`[generator] ⚠️ Exact field "${targetFieldName}" not found, using fallback "${table}" in ${rootType.name}`);
+                targetFieldName = table; // Используем базовое имя
+                // queryInfo = fallbackQueryInfo; // Переприсваиваем для дальнейшего использования
+                throw new Error(`❌ Field "${targetFieldName}" not found in root type "${rootType.name}"`); // Упадем здесь, если все равно не нашли
+            }
+            else {
+                throw new Error(`❌ Field "${targetFieldName}" not found in root type "${rootType.name}"`);
+            }
         }
+        const queryName = queryInfo.name; // Имя поля GraphQL, которое будем использовать
+        // --- ---
         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;
+        // --- РЕФАКТОРИНГ getGqlType ---
+        const getGqlTypeFromSchema = (argType) => {
+            const info = getTypeInfo(argType);
+            if (!info.name) {
+                throw new Error(`Cannot determine base type name for argType: ${JSON.stringify(argType)}`);
             }
-            if (argName === '_set') {
-                finalType = `${baseTable}_set_input`;
-                finalIsList = false;
-                finalIsRequired = true;
+            let typeStr = info.name; // Now we know info.name is a string
+            if (info.isList) {
+                typeStr = `[${info.name}${info.isNonNullItem ? '!' : ''}]`;
             }
-            if (argName === 'where') {
-                finalType = `${baseTable}_bool_exp`;
-                finalIsList = false;
-                finalIsRequired = false;
+            if (info.isNonNull) {
+                typeStr += '!';
             }
-            // 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;
+            return typeStr;
         };
-        // Argument processing function (now relies on getGqlType for correctness)
-        const processArg = (argName, value, argSchema, isDirectPk = false) => {
-            if (value === undefined || value === null)
+        // --- ---
+        // --- РЕФАКТОРИНГ Цикла обработки аргументов (Top Level) ---
+        const processedArgs = new Set();
+        const addArgument = (argName, value, argDefinition) => {
+            if (processedArgs.has(argName))
                 return;
             const varName = `v${varCounter++}`;
             queryArgs.push(`${argName}: $${varName}`);
             variables[varName] = value;
-            const gqlType = getGqlType(argName, argSchema, value, 'String', isDirectPk);
-            varParts.push(`$${varName}: ${gqlType}`);
+            const gqlType = getGqlTypeFromSchema(argDefinition.type);
+            // Check if var already exists before pushing
+            if (!varParts.some(p => p.startsWith(`$${varName}:`))) {
+                varParts.push(`$${varName}: ${gqlType}`);
+            }
+            processedArgs.add(argName);
         };
-        // --- 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];
+        // 1. Обработка прямых аргументов поля (из queryInfo.args)
+        (_a = queryInfo.args) === null || _a === void 0 ? void 0 : _a.forEach((argDef) => {
+            const argName = argDef.name;
             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
-                }
+                value = opts.pk_columns;
             }
             else if (argName === '_set' && opts._set) {
                 value = opts._set;
@@ -265,269 +217,319 @@ function Generator(schema) {
                 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;
+                if (queryName.endsWith('_one')) {
+                    value = opts.object;
                 }
                 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
+                    value = [opts.object];
+                    if (!queryInfo.args.find((a) => a.name === 'objects')) {
+                        debug(`Passing single 'object' to bulk operation "%s" which might expect 'objects' array.`, queryName);
+                        const objectsArgDef = queryInfo.args.find((a) => a.name === 'objects');
+                        if (objectsArgDef) {
+                            addArgument('objects', value, objectsArgDef);
+                        }
+                        else {
+                            console.error(`[generator] Cannot determine correct argument ('object' or 'objects') for "${queryName}".`);
+                        }
+                        return;
+                    }
+                    else if (queryInfo.args.find((a) => a.name === 'object')) {
+                        return;
+                    }
+                    else {
+                        const objectsArgDef = queryInfo.args.find((a) => a.name === 'objects');
+                        if (objectsArgDef) {
+                            addArgument('objects', value, objectsArgDef);
+                        }
+                        return;
+                    }
                 }
             }
+            else if (isByPkOperation && opts.pk_columns && opts.pk_columns[argName] !== undefined) {
+                value = opts.pk_columns[argName];
+            }
             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);
-                    }
-                }
+                addArgument(argName, value, argDef);
             }
-        }
-        // --- End Argument Processing ---
+        });
+        // --- End Top Level Argument Processing ---
+        // --- Returning Field Processing (REWORKED) ---
         const returningFields = [];
-        function processReturningField(field, currentVarCounterRef) {
-            if (typeof field === 'string') {
+        const varCounterRef = { count: varCounter }; // Use ref for nested calls
+        // Helper to find type details from schema by name
+        const findTypeDetails = (typeName) => {
+            if (!typeName)
+                return null;
+            return schema.types.find((t) => t.name === typeName && (t.kind === 'OBJECT' || t.kind === 'INTERFACE'));
+        };
+        // Recursive function to process fields
+        function processReturningField(field, parentTypeName, currentVarCounterRef) {
+            var _a, _b;
+            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;
+                // Find the field definition in the parent type
+                const parentTypeDetails = findTypeDetails(parentTypeName);
+                const fieldInfo = (_a = parentTypeDetails === null || parentTypeDetails === void 0 ? void 0 : parentTypeDetails.fields) === null || _a === void 0 ? void 0 : _a.find((f) => f.name === fieldName);
+                if (!fieldInfo) {
+                    // Use debug instead of console.warn
+                    debug(`Field "%s" not found in type "%s". Skipping.`, fieldName, parentTypeName);
+                    return ''; // Skip if field not found in parent
                 }
-                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
+                // Determine the return type of this field
+                let fieldReturnTypeName = null;
+                let currentFieldType = fieldInfo.type;
+                while (currentFieldType.ofType)
+                    currentFieldType = currentFieldType.ofType; // Unwrap LIST/NON_NULL
+                fieldReturnTypeName = currentFieldType.name;
+                if (typeof subFieldsOrParams === 'boolean' && subFieldsOrParams)
+                    return fieldName;
+                if (typeof subFieldsOrParams === 'boolean' && !subFieldsOrParams)
+                    return ''; // Skip false
+                if (Array.isArray(subFieldsOrParams) || typeof subFieldsOrParams === 'string') {
+                    // Simple nested fields (array of strings/objects or single string)
+                    const nestedFields = Array.isArray(subFieldsOrParams) ? subFieldsOrParams : subFieldsOrParams.split(/\s+/).filter(Boolean);
+                    const nestedProcessed = nestedFields
+                        .map(sf => processReturningField(sf, fieldReturnTypeName, currentVarCounterRef)) // <<< Pass return type as new parent
+                        .filter(Boolean)
                         .join('\n        ');
-                    return subFieldsStr ? `${fieldName} {\n        ${subFieldsStr}\n      }` : '';
-                }
-                if (typeof subFieldsOrParams === 'string') {
-                    return `${fieldName} {\n        ${subFieldsOrParams}\n      }`;
+                    return nestedProcessed ? `${fieldName} {\n        ${nestedProcessed}\n      }` : fieldName; // Return just fieldName if no nested fields processed
                 }
-                // 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;
+                if (typeof subFieldsOrParams === 'object') { // Nested query with potential args
+                    const { returning: nestedReturning, alias } = subFieldsOrParams, nestedArgsInput = __rest(subFieldsOrParams, ["returning", "alias"]);
+                    const fieldAliasOrName = alias || fieldName;
+                    // Field definition might include alias
+                    const fieldDefinition = alias ? `${alias}: ${fieldName}` : fieldName;
+                    // --- Process Nested Arguments --- (IMPLEMENTED)
                     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);
+                    if (fieldInfo.args && Object.keys(nestedArgsInput).length > 0) {
+                        Object.entries(nestedArgsInput).forEach(([argName, argValue]) => {
+                            const argDef = fieldInfo.args.find((a) => a.name === argName);
+                            if (argDef && argValue !== undefined) {
+                                const varName = `v${currentVarCounterRef.count++}`;
+                                nestedArgs.push(`${argName}: $${varName}`);
+                                variables[varName] = argValue;
+                                const gqlType = getGqlTypeFromSchema(argDef.type); // Use existing helper
+                                // Check if var already exists before pushing
+                                if (!varParts.some(p => p.startsWith(`$${varName}:`))) {
+                                    varParts.push(`$${varName}: ${gqlType}`);
+                                }
+                            }
+                            else {
+                                // Use debug instead of console.warn
+                                debug(`Argument "%s" not found or value is undefined for field "%s"`, argName, fieldName);
+                            }
+                        });
+                    }
+                    const nestedArgsStr = nestedArgs.length > 0 ? `(${nestedArgs.join(', ')})` : '';
+                    // --- End Nested Arguments ---
+                    // --- Process Nested Returning Fields --- (Improved Default Logic)
+                    let finalNestedReturning = [];
+                    if (nestedReturning) {
+                        if (Array.isArray(nestedReturning)) {
+                            finalNestedReturning = nestedReturning;
                         }
-                        // Strip list markers if present, handle wrapping below
-                        if (gqlType.startsWith('[') && gqlType.endsWith(']')) {
-                            gqlType = gqlType.slice(1, -1);
+                        else if (typeof nestedReturning === 'string') {
+                            finalNestedReturning = nestedReturning.split(/\s+/).filter(Boolean);
                         }
-                        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;
+                        else if (typeof nestedReturning === 'object') {
+                            finalNestedReturning = Object.entries(nestedReturning)
+                                .filter(([_, v]) => v)
+                                .map(([k, v]) => (typeof v === 'boolean' ? k : { [k]: v }));
                         }
-                        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;
+                    // If no nested returning specified, try to add default 'id' or '__typename'
+                    if (finalNestedReturning.length === 0) {
+                        const nestedTypeDetails = findTypeDetails(fieldReturnTypeName);
+                        if ((_b = nestedTypeDetails === null || nestedTypeDetails === void 0 ? void 0 : nestedTypeDetails.fields) === null || _b === void 0 ? void 0 : _b.find((f) => f.name === 'id')) {
+                            finalNestedReturning.push('id');
                         }
-                        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 }));
+                        else if ((nestedTypeDetails === null || nestedTypeDetails === void 0 ? void 0 : nestedTypeDetails.kind) === 'OBJECT' || (nestedTypeDetails === null || nestedTypeDetails === void 0 ? void 0 : nestedTypeDetails.kind) === 'INTERFACE') {
+                            finalNestedReturning.push('__typename');
                         }
+                        // If it's a SCALAR/ENUM, no body needed
                     }
-                    const nestedFieldsStr = finalNestedReturning
-                        .map(f => processReturningField(f, currentVarCounterRef))
-                        .filter(Boolean) // Remove empty strings from skipped fields
+                    const nestedReturningStr = finalNestedReturning
+                        .map(f => processReturningField(f, fieldReturnTypeName, currentVarCounterRef)) // <<< Pass return type
+                        .filter(Boolean)
                         .join('\n        ');
-                    // Use alias in the field definition if present
-                    const fieldDefinition = alias ? `${relationName}: ${fieldAliasOrName}` : fieldAliasOrName;
-                    return nestedFieldsStr ? `${fieldDefinition}${nestedArgsStr} {\n        ${nestedFieldsStr}\n      }` : '';
+                    // --- End Nested Returning Fields ---
+                    // Only add body if there are fields to return AND the type is OBJECT/INTERFACE
+                    const nestedFieldTypeDetails = findTypeDetails(fieldReturnTypeName);
+                    const needsNestedBody = ((nestedFieldTypeDetails === null || nestedFieldTypeDetails === void 0 ? void 0 : nestedFieldTypeDetails.kind) === 'OBJECT' || (nestedFieldTypeDetails === null || nestedFieldTypeDetails === void 0 ? void 0 : nestedFieldTypeDetails.kind) === 'INTERFACE') && nestedReturningStr;
+                    const nestedBody = needsNestedBody ? ` {\n        ${nestedReturningStr}\n      }` : '';
+                    return `${fieldDefinition}${nestedArgsStr}${nestedBody}`;
                 }
-                return ''; // Skip invalid field types
             }
-            return ''; // Skip invalid field types
+            return ''; // Should not happen for valid input
         }
-        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
+        // --- Main Returning Logic (REWORKED) ---
+        let topLevelReturnTypeName = null;
+        let currentQueryType = queryInfo.type;
+        while (currentQueryType.ofType)
+            currentQueryType = currentQueryType.ofType;
+        topLevelReturnTypeName = currentQueryType.name;
+        let finalReturningFields = []; // Initialize final list
+        // Helper to generate base default fields
+        const baseGenerateDefaultFields = (parentTypeName) => {
+            var _a, _b, _c, _d, _e, _f, _g;
+            const defaults = [];
             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);
-                        }
-                    });
+                // Simplified default for aggregate
+                const aggregateFieldInfo = rootFields.find(f => f.name === queryName);
+                let aggReturnTypeName = null;
+                if (aggregateFieldInfo) {
+                    let currentAggType = aggregateFieldInfo.type;
+                    while (currentAggType.ofType)
+                        currentAggType = currentAggType.ofType;
+                    aggReturnTypeName = currentAggType.name;
                 }
-                // 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');
+                const aggTypeDetails = findTypeDetails(aggReturnTypeName);
+                if ((_a = aggTypeDetails === null || aggTypeDetails === void 0 ? void 0 : aggTypeDetails.fields) === null || _a === void 0 ? void 0 : _a.find((f) => f.name === 'aggregate')) {
+                    const aggregateNestedField = aggTypeDetails.fields.find((f) => f.name === 'aggregate');
+                    let aggregateNestedTypeName = null;
+                    if (aggregateNestedField) {
+                        let currentNestedType = aggregateNestedField.type;
+                        while (currentNestedType.ofType)
+                            currentNestedType = currentNestedType.ofType;
+                        aggregateNestedTypeName = currentNestedType.name;
+                    }
+                    const aggregateNestedTypeDetails = findTypeDetails(aggregateNestedTypeName);
+                    if ((_b = aggregateNestedTypeDetails === null || aggregateNestedTypeDetails === void 0 ? void 0 : aggregateNestedTypeDetails.fields) === null || _b === void 0 ? void 0 : _b.find((f) => f.name === 'count')) {
+                        defaults.push('aggregate { count }');
+                    }
+                    else {
+                        defaults.push('aggregate { __typename }');
+                    }
+                }
+                else {
+                    defaults.push('__typename');
                 }
             }
-            else { // Default for other mutations _by_pk (update) and query_by_pk
-                if (queryInfo.returning_fields) {
-                    returningFields.push('id'); // Default fallback
+            else {
+                const returnTypeDetails = findTypeDetails(parentTypeName);
+                if ((_c = returnTypeDetails === null || returnTypeDetails === void 0 ? void 0 : returnTypeDetails.fields) === null || _c === void 0 ? void 0 : _c.find((f) => f.name === 'id')) {
+                    defaults.push('id');
+                }
+                // Add other simple default fields like name, email if they exist?
+                // Example: Check if 'name' exists and add it
+                if ((_d = returnTypeDetails === null || returnTypeDetails === void 0 ? void 0 : returnTypeDetails.fields) === null || _d === void 0 ? void 0 : _d.find((f) => f.name === 'name')) {
+                    defaults.push('name');
+                }
+                if ((_e = returnTypeDetails === null || returnTypeDetails === void 0 ? void 0 : returnTypeDetails.fields) === null || _e === void 0 ? void 0 : _e.find((f) => f.name === 'email')) {
+                    defaults.push('email');
+                }
+                if ((_f = returnTypeDetails === null || returnTypeDetails === void 0 ? void 0 : returnTypeDetails.fields) === null || _f === void 0 ? void 0 : _f.find((f) => f.name === 'created_at')) {
+                    defaults.push('created_at');
+                }
+                if ((_g = returnTypeDetails === null || returnTypeDetails === void 0 ? void 0 : returnTypeDetails.fields) === null || _g === void 0 ? void 0 : _g.find((f) => f.name === 'updated_at')) {
+                    defaults.push('updated_at');
+                }
+                // Fallback __typename if still empty and it's an object/interface
+                if (defaults.length === 0 && ((returnTypeDetails === null || returnTypeDetails === void 0 ? void 0 : returnTypeDetails.kind) === 'OBJECT' || (returnTypeDetails === null || returnTypeDetails === void 0 ? void 0 : returnTypeDetails.kind) === 'INTERFACE')) {
+                    defaults.push('__typename');
                 }
             }
-            defaultFieldsGenerated = true;
+            return defaults;
         };
-        // 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
+            if (Array.isArray(returning)) {
+                finalReturningFields = returning
+                    .map(field => processReturningField(field, topLevelReturnTypeName, varCounterRef))
+                    .filter(Boolean);
+                // Defaults are fully overridden by array
+            }
+            else if (typeof returning === 'string') {
+                finalReturningFields = returning.split(/\s+/).filter(Boolean)
+                    .map(field => processReturningField(field, topLevelReturnTypeName, varCounterRef))
+                    .filter(Boolean);
+                // Defaults are fully overridden by string
+            }
+            else if (typeof returning === 'object' && returning !== null) {
+                // 1. Get default fields
+                let currentDefaults = baseGenerateDefaultFields(topLevelReturnTypeName);
+                const customFields = [];
+                // 2. Process fields from the returning object
                 Object.entries(returning).forEach(([key, value]) => {
-                    // Construct the object format processReturningField expects: { relationName: subOptions }
                     const fieldObject = { [key]: value };
-                    const processedField = processReturningField(fieldObject, varCounterRef);
+                    const processedField = processReturningField(fieldObject, topLevelReturnTypeName, varCounterRef);
                     if (processedField) {
-                        // Avoid adding duplicates if default already added it (less likely for relations)
-                        if (!returningFields.includes(processedField)) {
-                            returningFields.push(processedField);
-                        }
+                        // Determine base name (handle alias: "alias: realName" or just "realName")
+                        const baseNameMatch = processedField.match(/^([\w\d_]+)(?:\s*:\s*[\w\d_]+)?/);
+                        // If alias exists use the original field name (key), otherwise use the matched name
+                        const baseName = ((value === null || value === void 0 ? void 0 : value.alias) && typeof value === 'object') ? key : (baseNameMatch ? baseNameMatch[1] : key);
+                        // Remove default if it exists with the same base name
+                        currentDefaults = currentDefaults.filter(defaultField => {
+                            const defaultBaseNameMatch = defaultField.match(/^([\w\d_]+)/);
+                            return !(defaultBaseNameMatch && defaultBaseNameMatch[1] === baseName);
+                        });
+                        customFields.push(processedField); // Add the processed field
                     }
                 });
+                // 3. Combine remaining defaults and custom fields
+                finalReturningFields = [...currentDefaults, ...customFields];
             }
             else {
-                // Invalid returning type? Fallback to defaults.
-                generateDefaultFields();
+                // Invalid type or null, use defaults
+                finalReturningFields = baseGenerateDefaultFields(topLevelReturnTypeName);
             }
         }
-        else { // returning is null or undefined - Use defaults
-            generateDefaultFields();
+        else {
+            // No returning provided, use defaults
+            finalReturningFields = baseGenerateDefaultFields(topLevelReturnTypeName);
         }
-        // ---- 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      }`);
+        // --- End Returning ---
+        // --- Final Query String Assembly --- (Adjusted section)
+        // const returningStr = finalReturningFields.length > 0 ? finalReturningFields.join('\n      ') : ''; // Use the calculated finalReturningFields
+        // Логика для affected_rows
+        let assembledReturningFields = [...finalReturningFields]; // Start with the combined list
+        if (['insert', 'update', 'delete'].includes(operation) && !queryName.endsWith('_by_pk') && !queryName.endsWith('_one')) {
+            let directFieldReturnType = queryInfo.type;
+            while (directFieldReturnType.ofType)
+                directFieldReturnType = directFieldReturnType.ofType;
+            const returnTypeDetails = findTypeDetails(directFieldReturnType.name);
+            if (((_b = returnTypeDetails === null || returnTypeDetails === void 0 ? void 0 : returnTypeDetails.fields) === null || _b === void 0 ? void 0 : _b.find((f) => f.name === 'affected_rows')) && ((_c = returnTypeDetails === null || returnTypeDetails === void 0 ? void 0 : returnTypeDetails.fields) === null || _c === void 0 ? void 0 : _c.find((f) => f.name === 'returning'))) {
+                const fieldsForNestedReturning = assembledReturningFields.filter(f => !f.trim().startsWith('affected_rows'));
+                assembledReturningFields = ['affected_rows']; // Reset and start with affected_rows
+                if (fieldsForNestedReturning.length > 0) {
+                    const returningFieldsStr = fieldsForNestedReturning.join('\n        ');
+                    assembledReturningFields.push(`returning {\n        ${returningFieldsStr}\n      }`);
+                }
+            }
+            else {
+                debug(`Mutation "%s" does not seem to return standard affected_rows/returning fields.`, queryName);
             }
         }
-        // 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') {
+        if (operation === 'query')
             gqlOperationType = 'query';
-        }
-        else if (operation === 'subscription') {
+        else if (operation === 'subscription')
             gqlOperationType = 'subscription';
-        }
-        else { // insert, update, delete
+        else
             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 queryNamePascal = queryName.split('_').map((part) => part ? part.charAt(0).toUpperCase() + part.slice(1) : '').join('');
+        const operationName = `${opNamePrefix}${queryNamePascal}`;
         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 needsBody = currentQueryType.kind === 'OBJECT' || currentQueryType.kind === 'INTERFACE';
+        const returningStr = assembledReturningFields.length > 0 ? assembledReturningFields.join('\n      ') : '';
+        const bodyStr = needsBody && returningStr ? ` {\n          ${returningStr}\n        }` : '';
         const fragmentsStr = fragments.length > 0 ? `\n${fragments.join('\n')}` : '';
         const queryStr = `
       ${gqlOperationType} ${operationName}${varParts.length > 0 ? `(${varParts.join(', ')})` : ''} {
-        ${queryName}${argsStr}${returningStr ? ` {
-          ${returningStr}
-        }` : ''}
+        ${queryName}${argsStr}${bodyStr}
       }${fragmentsStr}
     `;
+        // --- End Assembly ---
         try {
+            // debug("Generated Query:", queryStr);
+            // debug("Generated Variables:", variables);
             const gqlQuery = (0, core_1.gql)(queryStr);
             return {
                 queryString: queryStr,
@@ -544,5 +546,5 @@ function Generator(schema) {
         }
     };
 }
-// Export the factory function
-exports.default = Generator;
+// Экспортируем Generator с уже загруженной схемой
+exports.default = Generator(schema);