@constructive-io/graphql-query 3.2.5 → 3.3.0

package/generators/select.js

@@ -0,0 +1,705 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toOrderByTypeName = exports.toCamelCasePlural = void 0;
+exports.cleanTableToMetaObject = cleanTableToMetaObject;
+exports.generateIntrospectionSchema = generateIntrospectionSchema;
+exports.createASTQueryBuilder = createASTQueryBuilder;
+exports.buildSelect = buildSelect;
+exports.buildFindOne = buildFindOne;
+exports.buildCount = buildCount;
+/**
+ * Query generators for SELECT, FindOne, and Count operations
+ * Uses AST-based approach for all query generation
+ */
+const t = __importStar(require("gql-ast"));
+const graphql_1 = require("graphql");
+const typed_document_1 = require("../client/typed-document");
+const custom_ast_1 = require("../custom-ast");
+const query_builder_1 = require("../query-builder");
+const field_selector_1 = require("./field-selector");
+const naming_helpers_1 = require("./naming-helpers");
+// Re-export naming helpers for backwards compatibility
+var naming_helpers_2 = require("./naming-helpers");
+Object.defineProperty(exports, "toCamelCasePlural", { enumerable: true, get: function () { return naming_helpers_2.toCamelCasePlural; } });
+Object.defineProperty(exports, "toOrderByTypeName", { enumerable: true, get: function () { return naming_helpers_2.toOrderByTypeName; } });
+/**
+ * Convert CleanTable to MetaObject format for QueryBuilder
+ */
+function cleanTableToMetaObject(tables) {
+    return {
+        tables: tables.map((table) => ({
+            name: table.name,
+            fields: table.fields.map((field) => ({
+                name: field.name,
+                type: {
+                    gqlType: field.type.gqlType,
+                    isArray: field.type.isArray,
+                    modifier: field.type.modifier,
+                    pgAlias: field.type.pgAlias,
+                    pgType: field.type.pgType,
+                    subtype: field.type.subtype,
+                    typmod: field.type.typmod,
+                },
+            })),
+            primaryConstraints: [], // Would need to be derived from schema
+            uniqueConstraints: [], // Would need to be derived from schema
+            foreignConstraints: table.relations.belongsTo.map((rel) => ({
+                refTable: rel.referencesTable,
+                fromKey: {
+                    name: rel.fieldName || '',
+                    type: {
+                        gqlType: 'UUID', // Default, should be derived from actual field
+                        isArray: false,
+                        modifier: null,
+                        pgAlias: null,
+                        pgType: null,
+                        subtype: null,
+                        typmod: null,
+                    },
+                    alias: rel.fieldName || '',
+                },
+                toKey: {
+                    name: 'id',
+                    type: {
+                        gqlType: 'UUID',
+                        isArray: false,
+                        modifier: null,
+                        pgAlias: null,
+                        pgType: null,
+                        subtype: null,
+                        typmod: null,
+                    },
+                },
+            })),
+        })),
+    };
+}
+/**
+ * Generate basic IntrospectionSchema from CleanTable array
+ * This creates a minimal schema for AST generation
+ */
+function generateIntrospectionSchema(tables) {
+    const schema = {};
+    for (const table of tables) {
+        const modelName = table.name;
+        const pluralName = (0, naming_helpers_1.toCamelCasePlural)(modelName, table);
+        // Basic field selection for the model
+        const selection = table.fields.map((field) => field.name);
+        // Add getMany query
+        schema[pluralName] = {
+            qtype: 'getMany',
+            model: modelName,
+            selection,
+            properties: convertFieldsToProperties(table.fields),
+        };
+        // Add getOne query (by ID)
+        const singularName = (0, naming_helpers_1.toCamelCaseSingular)(modelName, table);
+        schema[singularName] = {
+            qtype: 'getOne',
+            model: modelName,
+            selection,
+            properties: convertFieldsToProperties(table.fields),
+        };
+        // Derive entity-specific names from introspection data
+        const patchFieldName = (0, naming_helpers_1.toPatchFieldName)(modelName, table);
+        const createMutationName = (0, naming_helpers_1.toCreateMutationName)(modelName, table);
+        const updateMutationName = (0, naming_helpers_1.toUpdateMutationName)(modelName, table);
+        const deleteMutationName = (0, naming_helpers_1.toDeleteMutationName)(modelName, table);
+        const createInputType = (0, naming_helpers_1.toCreateInputTypeName)(modelName, table);
+        const patchType = (0, naming_helpers_1.normalizeInflectionValue)(table.inflection?.patchType) ??
+            `${modelName}Patch`;
+        // Add create mutation
+        schema[createMutationName] = {
+            qtype: 'mutation',
+            mutationType: 'create',
+            model: modelName,
+            selection,
+            properties: {
+                input: {
+                    name: 'input',
+                    type: createInputType,
+                    isNotNull: true,
+                    isArray: false,
+                    isArrayNotNull: false,
+                    properties: {
+                        [singularName]: {
+                            name: singularName,
+                            type: `${modelName}Input`,
+                            isNotNull: true,
+                            isArray: false,
+                            isArrayNotNull: false,
+                            properties: convertFieldsToNestedProperties(table.fields),
+                        },
+                    },
+                },
+            },
+        };
+        // Add update mutation
+        schema[updateMutationName] = {
+            qtype: 'mutation',
+            mutationType: 'patch',
+            model: modelName,
+            selection,
+            properties: {
+                input: {
+                    name: 'input',
+                    type: (0, naming_helpers_1.toUpdateInputTypeName)(modelName),
+                    isNotNull: true,
+                    isArray: false,
+                    isArrayNotNull: false,
+                    properties: {
+                        [patchFieldName]: {
+                            name: patchFieldName,
+                            type: patchType,
+                            isNotNull: true,
+                            isArray: false,
+                            isArrayNotNull: false,
+                            properties: convertFieldsToNestedProperties(table.fields),
+                        },
+                    },
+                },
+            },
+        };
+        // Add delete mutation
+        schema[deleteMutationName] = {
+            qtype: 'mutation',
+            mutationType: 'delete',
+            model: modelName,
+            selection,
+            properties: {
+                input: {
+                    name: 'input',
+                    type: (0, naming_helpers_1.toDeleteInputTypeName)(modelName),
+                    isNotNull: true,
+                    isArray: false,
+                    isArrayNotNull: false,
+                    properties: {
+                        id: {
+                            name: 'id',
+                            type: 'UUID',
+                            isNotNull: true,
+                            isArray: false,
+                            isArrayNotNull: false,
+                        },
+                    },
+                },
+            },
+        };
+    }
+    return schema;
+}
+/**
+ * Convert CleanTable fields to QueryBuilder properties
+ */
+function convertFieldsToProperties(fields) {
+    const properties = {};
+    fields.forEach((field) => {
+        properties[field.name] = {
+            name: field.name,
+            type: field.type.gqlType,
+            isNotNull: !field.type.gqlType.endsWith('!'),
+            isArray: field.type.isArray,
+            isArrayNotNull: false,
+        };
+    });
+    return properties;
+}
+/**
+ * Convert fields to nested properties for mutations
+ */
+function convertFieldsToNestedProperties(fields) {
+    const properties = {};
+    fields.forEach((field) => {
+        properties[field.name] = {
+            name: field.name,
+            type: field.type.gqlType,
+            isNotNull: false, // Mutations typically allow optional fields
+            isArray: field.type.isArray,
+            isArrayNotNull: false,
+        };
+    });
+    return properties;
+}
+/**
+ * Create AST-based query builder for a table
+ */
+function createASTQueryBuilder(tables) {
+    const metaObject = cleanTableToMetaObject(tables);
+    const introspectionSchema = generateIntrospectionSchema(tables);
+    return new query_builder_1.QueryBuilder({
+        meta: metaObject,
+        introspection: introspectionSchema,
+    });
+}
+/**
+ * Build a SELECT query for a table with optional filtering, sorting, and pagination
+ * Uses direct AST generation without intermediate conversions
+ */
+function buildSelect(table, allTables, options = {}) {
+    const tableList = Array.from(allTables);
+    const selection = convertFieldSelectionToSelectionOptions(table, tableList, options.fieldSelection);
+    // Generate query directly using AST
+    const queryString = generateSelectQueryAST(table, tableList, selection, options, options.relationFieldMap);
+    return new typed_document_1.TypedDocumentString(queryString, {});
+}
+/**
+ * Build a single row query by primary key or unique field
+ */
+function buildFindOne(table, _pkField = 'id') {
+    const queryString = generateFindOneQueryAST(table);
+    return new typed_document_1.TypedDocumentString(queryString, {});
+}
+/**
+ * Build a count query for a table
+ */
+function buildCount(table) {
+    const queryString = generateCountQueryAST(table);
+    return new typed_document_1.TypedDocumentString(queryString, {});
+}
+function convertFieldSelectionToSelectionOptions(table, allTables, options) {
+    return (0, field_selector_1.convertToSelectionOptions)(table, allTables, options);
+}
+/**
+ * Generate SELECT query AST directly from CleanTable
+ */
+function generateSelectQueryAST(table, allTables, selection, options, relationFieldMap) {
+    const pluralName = (0, naming_helpers_1.toCamelCasePlural)(table.name, table);
+    // Generate field selections
+    const fieldSelections = generateFieldSelectionsFromOptions(table, allTables, selection, relationFieldMap);
+    // Build the query AST
+    const variableDefinitions = [];
+    const queryArgs = [];
+    // Add pagination variables if needed
+    const limitValue = options.limit ?? options.first;
+    if (limitValue !== undefined) {
+        variableDefinitions.push(t.variableDefinition({
+            variable: t.variable({ name: 'first' }),
+            type: t.namedType({ type: 'Int' }),
+        }));
+        queryArgs.push(t.argument({
+            name: 'first',
+            value: t.variable({ name: 'first' }),
+        }));
+    }
+    if (options.offset !== undefined) {
+        variableDefinitions.push(t.variableDefinition({
+            variable: t.variable({ name: 'offset' }),
+            type: t.namedType({ type: 'Int' }),
+        }));
+        queryArgs.push(t.argument({
+            name: 'offset',
+            value: t.variable({ name: 'offset' }),
+        }));
+    }
+    // Add cursor-based pagination variables if needed (for infinite scroll)
+    if (options.after !== undefined) {
+        variableDefinitions.push(t.variableDefinition({
+            variable: t.variable({ name: 'after' }),
+            type: t.namedType({ type: 'Cursor' }),
+        }));
+        queryArgs.push(t.argument({
+            name: 'after',
+            value: t.variable({ name: 'after' }),
+        }));
+    }
+    if (options.before !== undefined) {
+        variableDefinitions.push(t.variableDefinition({
+            variable: t.variable({ name: 'before' }),
+            type: t.namedType({ type: 'Cursor' }),
+        }));
+        queryArgs.push(t.argument({
+            name: 'before',
+            value: t.variable({ name: 'before' }),
+        }));
+    }
+    // Add filter variables if needed
+    if (options.where) {
+        variableDefinitions.push(t.variableDefinition({
+            variable: t.variable({ name: 'filter' }),
+            type: t.namedType({ type: (0, naming_helpers_1.toFilterTypeName)(table.name, table) }),
+        }));
+        queryArgs.push(t.argument({
+            name: 'filter',
+            value: t.variable({ name: 'filter' }),
+        }));
+    }
+    // Add orderBy variables if needed
+    if (options.orderBy && options.orderBy.length > 0) {
+        variableDefinitions.push(t.variableDefinition({
+            variable: t.variable({ name: 'orderBy' }),
+            // PostGraphile expects [ProductsOrderBy!] - list of non-null enum values
+            type: t.listType({
+                type: t.nonNullType({
+                    type: t.namedType({ type: (0, naming_helpers_1.toOrderByTypeName)(table.name, table) }),
+                }),
+            }),
+        }));
+        queryArgs.push(t.argument({
+            name: 'orderBy',
+            value: t.variable({ name: 'orderBy' }),
+        }));
+    }
+    // Build connection selections: totalCount, nodes, and optionally pageInfo
+    const connectionSelections = [
+        t.field({ name: 'totalCount' }),
+        t.field({
+            name: 'nodes',
+            selectionSet: t.selectionSet({
+                selections: fieldSelections,
+            }),
+        }),
+    ];
+    // Add pageInfo if requested (for cursor-based pagination / infinite scroll)
+    if (options.includePageInfo ||
+        options.after !== undefined ||
+        options.before !== undefined) {
+        connectionSelections.push(t.field({
+            name: 'pageInfo',
+            selectionSet: t.selectionSet({
+                selections: [
+                    t.field({ name: 'hasNextPage' }),
+                    t.field({ name: 'hasPreviousPage' }),
+                    t.field({ name: 'startCursor' }),
+                    t.field({ name: 'endCursor' }),
+                ],
+            }),
+        }));
+    }
+    const ast = t.document({
+        definitions: [
+            t.operationDefinition({
+                operation: graphql_1.OperationTypeNode.QUERY,
+                name: `${pluralName}Query`,
+                variableDefinitions,
+                selectionSet: t.selectionSet({
+                    selections: [
+                        t.field({
+                            name: pluralName,
+                            args: queryArgs,
+                            selectionSet: t.selectionSet({
+                                selections: connectionSelections,
+                            }),
+                        }),
+                    ],
+                }),
+            }),
+        ],
+    });
+    return (0, graphql_1.print)(ast);
+}
+/**
+ * Generate field selections from SelectionOptions
+ */
+function generateFieldSelectionsFromOptions(table, allTables, selection, relationFieldMap) {
+    const DEFAULT_NESTED_RELATION_FIRST = 20;
+    if (!selection) {
+        // Default to all non-relational fields (includes complex fields like JSON, geometry, etc.)
+        return table.fields
+            .filter((field) => !(0, field_selector_1.isRelationalField)(field.name, table))
+            .map((field) => {
+            if ((0, custom_ast_1.requiresSubfieldSelection)(field)) {
+                // For complex fields that require subfield selection, use custom AST generation
+                return (0, custom_ast_1.getCustomAstForCleanField)(field);
+            }
+            else {
+                // For simple fields, use basic field selection
+                return t.field({ name: field.name });
+            }
+        });
+    }
+    const fieldSelections = [];
+    Object.entries(selection).forEach(([fieldName, fieldOptions]) => {
+        const resolvedField = resolveSelectionFieldName(fieldName, relationFieldMap);
+        if (!resolvedField) {
+            return; // Field mapped to null — omit it
+        }
+        if (fieldOptions === true) {
+            // Check if this field requires subfield selection
+            const field = table.fields.find((f) => f.name === fieldName);
+            if (field && (0, custom_ast_1.requiresSubfieldSelection)(field)) {
+                // Use custom AST generation for complex fields
+                fieldSelections.push((0, custom_ast_1.getCustomAstForCleanField)(field));
+            }
+            else {
+                // Simple field selection for scalar fields
+                fieldSelections.push(createFieldSelectionNode(resolvedField.name, resolvedField.alias));
+            }
+        }
+        else if (typeof fieldOptions === 'object' && fieldOptions.select) {
+            // Nested field selection (for relation fields)
+            const nestedSelections = [];
+            // Find the related table to check for complex fields
+            const relatedTable = findRelatedTable(fieldName, table, allTables);
+            Object.entries(fieldOptions.select).forEach(([nestedField, include]) => {
+                if (include) {
+                    // Check if this nested field requires subfield selection
+                    const nestedFieldDef = relatedTable?.fields.find((f) => f.name === nestedField);
+                    if (nestedFieldDef && (0, custom_ast_1.requiresSubfieldSelection)(nestedFieldDef)) {
+                        // Use custom AST generation for complex nested fields
+                        nestedSelections.push((0, custom_ast_1.getCustomAstForCleanField)(nestedFieldDef));
+                    }
+                    else {
+                        // Simple field selection for scalar nested fields
+                        nestedSelections.push(t.field({ name: nestedField }));
+                    }
+                }
+            });
+            // Check if this is a hasMany relation that uses Connection pattern
+            const relationInfo = getRelationInfo(fieldName, table);
+            if (relationInfo &&
+                (relationInfo.type === 'hasMany' || relationInfo.type === 'manyToMany')) {
+                // For hasMany/manyToMany relations, wrap selections in nodes { ... }
+                fieldSelections.push(createFieldSelectionNode(resolvedField.name, resolvedField.alias, [
+                    t.argument({
+                        name: 'first',
+                        value: t.intValue({
+                            value: DEFAULT_NESTED_RELATION_FIRST.toString(),
+                        }),
+                    }),
+                ], t.selectionSet({
+                    selections: [
+                        t.field({
+                            name: 'nodes',
+                            selectionSet: t.selectionSet({
+                                selections: nestedSelections,
+                            }),
+                        }),
+                    ],
+                })));
+            }
+            else {
+                // For belongsTo/hasOne relations, use direct selection
+                fieldSelections.push(createFieldSelectionNode(resolvedField.name, resolvedField.alias, undefined, t.selectionSet({
+                    selections: nestedSelections,
+                })));
+            }
+        }
+    });
+    return fieldSelections;
+}
+// ---------------------------------------------------------------------------
+// Field aliasing helpers (back-ported from Dashboard query-generator.ts)
+// ---------------------------------------------------------------------------
+/**
+ * Resolve a field name through the optional relationFieldMap.
+ * Returns `null` if the field should be omitted (mapped to null).
+ * Returns `{ name, alias? }` where alias is set when the mapped name differs.
+ */
+function resolveSelectionFieldName(fieldName, relationFieldMap) {
+    if (!relationFieldMap || !(fieldName in relationFieldMap)) {
+        return { name: fieldName };
+    }
+    const mappedFieldName = relationFieldMap[fieldName];
+    if (!mappedFieldName) {
+        return null; // mapped to null → omit
+    }
+    if (mappedFieldName === fieldName) {
+        return { name: fieldName };
+    }
+    return { name: mappedFieldName, alias: fieldName };
+}
+/**
+ * Create a field AST node with optional alias support.
+ * When alias is provided and differs from name, a GraphQL alias is emitted:
+ * `alias: name { … }` instead of `name { … }`
+ */
+function createFieldSelectionNode(name, alias, args, selectionSet) {
+    const node = t.field({ name, args, selectionSet });
+    if (!alias || alias === name) {
+        return node;
+    }
+    return {
+        ...node,
+        alias: {
+            kind: graphql_1.Kind.NAME,
+            value: alias,
+        },
+    };
+}
+/**
+ * Get relation information for a field
+ */
+function getRelationInfo(fieldName, table) {
+    const { belongsTo, hasOne, hasMany, manyToMany } = table.relations;
+    // Check belongsTo relations
+    const belongsToRel = belongsTo.find((rel) => rel.fieldName === fieldName);
+    if (belongsToRel) {
+        return { type: 'belongsTo', relation: belongsToRel };
+    }
+    // Check hasOne relations
+    const hasOneRel = hasOne.find((rel) => rel.fieldName === fieldName);
+    if (hasOneRel) {
+        return { type: 'hasOne', relation: hasOneRel };
+    }
+    // Check hasMany relations
+    const hasManyRel = hasMany.find((rel) => rel.fieldName === fieldName);
+    if (hasManyRel) {
+        return { type: 'hasMany', relation: hasManyRel };
+    }
+    // Check manyToMany relations
+    const manyToManyRel = manyToMany.find((rel) => rel.fieldName === fieldName);
+    if (manyToManyRel) {
+        return { type: 'manyToMany', relation: manyToManyRel };
+    }
+    return null;
+}
+/**
+ * Find the related table for a given relation field
+ */
+function findRelatedTable(relationField, table, allTables) {
+    // Find the related table name
+    let referencedTableName;
+    // Check belongsTo relations
+    const belongsToRel = table.relations.belongsTo.find((rel) => rel.fieldName === relationField);
+    if (belongsToRel) {
+        referencedTableName = belongsToRel.referencesTable;
+    }
+    // Check hasOne relations
+    if (!referencedTableName) {
+        const hasOneRel = table.relations.hasOne.find((rel) => rel.fieldName === relationField);
+        if (hasOneRel) {
+            referencedTableName = hasOneRel.referencedByTable;
+        }
+    }
+    // Check hasMany relations
+    if (!referencedTableName) {
+        const hasManyRel = table.relations.hasMany.find((rel) => rel.fieldName === relationField);
+        if (hasManyRel) {
+            referencedTableName = hasManyRel.referencedByTable;
+        }
+    }
+    // Check manyToMany relations
+    if (!referencedTableName) {
+        const manyToManyRel = table.relations.manyToMany.find((rel) => rel.fieldName === relationField);
+        if (manyToManyRel) {
+            referencedTableName = manyToManyRel.rightTable;
+        }
+    }
+    if (!referencedTableName) {
+        return null;
+    }
+    // Find the related table in allTables
+    return allTables.find((tbl) => tbl.name === referencedTableName) || null;
+}
+/**
+ * Generate FindOne query AST directly from CleanTable
+ */
+function generateFindOneQueryAST(table) {
+    const singularName = (0, naming_helpers_1.toCamelCaseSingular)(table.name, table);
+    // Generate field selections (include all non-relational fields, including complex types)
+    const fieldSelections = table.fields
+        .filter((field) => !(0, field_selector_1.isRelationalField)(field.name, table))
+        .map((field) => {
+        if ((0, custom_ast_1.requiresSubfieldSelection)(field)) {
+            // For complex fields that require subfield selection, use custom AST generation
+            return (0, custom_ast_1.getCustomAstForCleanField)(field);
+        }
+        else {
+            // For simple fields, use basic field selection
+            return t.field({ name: field.name });
+        }
+    });
+    const ast = t.document({
+        definitions: [
+            t.operationDefinition({
+                operation: graphql_1.OperationTypeNode.QUERY,
+                name: `${singularName}Query`,
+                variableDefinitions: [
+                    t.variableDefinition({
+                        variable: t.variable({ name: 'id' }),
+                        type: t.nonNullType({
+                            type: t.namedType({ type: 'UUID' }),
+                        }),
+                    }),
+                ],
+                selectionSet: t.selectionSet({
+                    selections: [
+                        t.field({
+                            name: singularName,
+                            args: [
+                                t.argument({
+                                    name: 'id',
+                                    value: t.variable({ name: 'id' }),
+                                }),
+                            ],
+                            selectionSet: t.selectionSet({
+                                selections: fieldSelections,
+                            }),
+                        }),
+                    ],
+                }),
+            }),
+        ],
+    });
+    return (0, graphql_1.print)(ast);
+}
+/**
+ * Generate Count query AST directly from CleanTable
+ */
+function generateCountQueryAST(table) {
+    const pluralName = (0, naming_helpers_1.toCamelCasePlural)(table.name, table);
+    const ast = t.document({
+        definitions: [
+            t.operationDefinition({
+                operation: graphql_1.OperationTypeNode.QUERY,
+                name: `${pluralName}CountQuery`,
+                variableDefinitions: [
+                    t.variableDefinition({
+                        variable: t.variable({ name: 'filter' }),
+                        type: t.namedType({ type: (0, naming_helpers_1.toFilterTypeName)(table.name, table) }),
+                    }),
+                ],
+                selectionSet: t.selectionSet({
+                    selections: [
+                        t.field({
+                            name: pluralName,
+                            args: [
+                                t.argument({
+                                    name: 'filter',
+                                    value: t.variable({ name: 'filter' }),
+                                }),
+                            ],
+                            selectionSet: t.selectionSet({
+                                selections: [t.field({ name: 'totalCount' })],
+                            }),
+                        }),
+                    ],
+                }),
+            }),
+        ],
+    });
+    return (0, graphql_1.print)(ast);
+}