@constructive-io/graphql-codegen 3.3.1 → 4.0.0

package/core/codegen/types.js

@@ -38,6 +38,7 @@ exports.generateTypesFile = generateTypesFile;
  * Types generator - generates types.ts with entity interfaces using Babel AST
  */
 const t = __importStar(require("@babel/types"));
+const scalars_1 = require("./scalars");
 const babel_ast_1 = require("./babel-ast");
 const utils_1 = require("./utils");
 /** All filter type configurations - scalar and list filters */
@@ -187,12 +188,34 @@ function createInterfaceDeclaration(name, properties) {
     const interfaceDecl = t.tsInterfaceDeclaration(t.identifier(name), null, null, t.tsInterfaceBody(props));
     return t.exportNamedDeclaration(interfaceDecl);
 }
+function createTypeAlias(name, typeNode) {
+    const typeAlias = t.tsTypeAliasDeclaration(t.identifier(name), null, typeNode);
+    return t.exportNamedDeclaration(typeAlias);
+}
+function collectCustomScalarTypes(tables, excludedTypeNames) {
+    const customScalarTypes = new Set();
+    const tableTypeNames = new Set(tables.map((table) => table.name));
+    for (const table of tables) {
+        for (const field of (0, utils_1.getScalarFields)(table)) {
+            const cleanType = field.type.gqlType.replace(/!/g, '');
+            if (scalars_1.SCALAR_NAMES.has(cleanType))
+                continue;
+            if (excludedTypeNames.has(cleanType))
+                continue;
+            if (tableTypeNames.has(cleanType))
+                continue;
+            customScalarTypes.add(cleanType);
+        }
+    }
+    return Array.from(customScalarTypes).sort();
+}
 /**
  * Generate types.ts content with all entity interfaces and base filter types
  */
 function generateTypesFile(tables, options = {}) {
     const { enumsFromSchemaTypes = [] } = options;
     const enumSet = new Set(enumsFromSchemaTypes);
+    const customScalarTypes = collectCustomScalarTypes(tables, enumSet);
     const statements = [];
     // Collect which enums are actually used by entity fields
     const usedEnums = new Set();
@@ -215,6 +238,9 @@ function generateTypesFile(tables, options = {}) {
         importDecl.importKind = 'type';
         statements.push(importDecl);
     }
+    for (const scalarType of customScalarTypes) {
+        statements.push(createTypeAlias(scalarType, t.tsUnknownKeyword()));
+    }
     // Generate entity interfaces
     for (const table of tables) {
         const scalarFields = (0, utils_1.getScalarFields)(table);

package/core/codegen/utils.d.ts

@@ -72,7 +72,7 @@ export declare function getUpdateMutationFileName(table: CleanTable): string;
 export declare function getDeleteMutationFileName(table: CleanTable): string;
 /**
  * Get the GraphQL query name for fetching all rows
- * Uses inflection from _meta, falls back to convention
+ * Uses inflection from introspection, falls back to convention
  */
 export declare function getAllRowsQueryName(table: CleanTable): string;
 /**

package/core/codegen/utils.js

@@ -169,7 +169,7 @@ function getDeleteMutationFileName(table) {
 // ============================================================================
 /**
  * Get the GraphQL query name for fetching all rows
- * Uses inflection from _meta, falls back to convention
+ * Uses inflection from introspection, falls back to convention
  */
 function getAllRowsQueryName(table) {
     return (table.query?.all ||

package/core/custom-ast.js

@@ -42,6 +42,7 @@ exports.geometryAst = geometryAst;
 exports.intervalAst = intervalAst;
 exports.isIntervalType = isIntervalType;
 const t = __importStar(require("gql-ast"));
+const graphql_1 = require("graphql");
 /**
  * Get custom AST for MetaField type - handles PostgreSQL types that need subfield selections
  */
@@ -119,28 +120,28 @@ function geometryPointAst(name) {
 function geometryCollectionAst(name) {
     // Manually create inline fragment since gql-ast doesn't support it
     const inlineFragment = {
-        kind: 'InlineFragment',
+        kind: graphql_1.Kind.INLINE_FRAGMENT,
         typeCondition: {
-            kind: 'NamedType',
+            kind: graphql_1.Kind.NAMED_TYPE,
             name: {
-                kind: 'Name',
+                kind: graphql_1.Kind.NAME,
                 value: 'GeometryPoint',
             },
         },
         selectionSet: {
-            kind: 'SelectionSet',
+            kind: graphql_1.Kind.SELECTION_SET,
             selections: [
                 {
-                    kind: 'Field',
+                    kind: graphql_1.Kind.FIELD,
                     name: {
-                        kind: 'Name',
+                        kind: graphql_1.Kind.NAME,
                         value: 'x',
                     },
                 },
                 {
-                    kind: 'Field',
+                    kind: graphql_1.Kind.FIELD,
                     name: {
-                        kind: 'Name',
+                        kind: graphql_1.Kind.NAME,
                         value: 'y',
                     },
                 },

package/core/database/index.js

@@ -56,11 +56,10 @@ async function buildSchemaFromDatabase(options) {
     const { database, schemas, outDir, filename = 'schema.graphql' } = options;
     // Ensure output directory exists
     await fs.promises.mkdir(outDir, { recursive: true });
-    // Build schema SDL from database
+    // Build schema SDL from database (PostGraphile v5 preset-driven settings)
     const sdl = await (0, graphql_server_1.buildSchemaSDL)({
         database,
         schemas,
-        graphile: { pgSettings: async () => ({ role: 'administrator' }) },
     });
     // Write schema to file
     const schemaPath = path.join(outDir, filename);
@@ -77,9 +76,9 @@ async function buildSchemaFromDatabase(options) {
  */
 async function buildSchemaSDLFromDatabase(options) {
     const { database, schemas } = options;
+    // PostGraphile v5 resolves role/settings via preset configuration.
     return (0, graphql_server_1.buildSchemaSDL)({
         database,
         schemas,
-        graphile: { pgSettings: async () => ({ role: 'administrator' }) },
     });
 }

package/core/index.d.ts

@@ -9,7 +9,9 @@ export { generate } from './generate';
 export * from './types';
 export * from './ast';
 export * from './custom-ast';
+/** @deprecated Legacy v4 query builder — use v5 ORM codegen instead */
 export { MetaObject, QueryBuilder } from './query-builder';
+/** @deprecated Legacy v4 meta-object utilities — v5 uses standard introspection */
 export { convertFromMetaSchema, validateMetaObject } from './meta-object';
 export * from './config';
 export * from './codegen';

package/core/index.js

@@ -29,10 +29,12 @@ __exportStar(require("./types"), exports);
 __exportStar(require("./ast"), exports);
 __exportStar(require("./custom-ast"), exports);
 // Query builder
+/** @deprecated Legacy v4 query builder — use v5 ORM codegen instead */
 var query_builder_1 = require("./query-builder");
 Object.defineProperty(exports, "MetaObject", { enumerable: true, get: function () { return query_builder_1.MetaObject; } });
 Object.defineProperty(exports, "QueryBuilder", { enumerable: true, get: function () { return query_builder_1.QueryBuilder; } });
 // Meta object utilities
+/** @deprecated Legacy v4 meta-object utilities — v5 uses standard introspection */
 var meta_object_1 = require("./meta-object");
 Object.defineProperty(exports, "convertFromMetaSchema", { enumerable: true, get: function () { return meta_object_1.convertFromMetaSchema; } });
 Object.defineProperty(exports, "validateMetaObject", { enumerable: true, get: function () { return meta_object_1.validateMetaObject; } });

package/core/introspect/infer-tables.js

@@ -86,20 +86,19 @@ function inferTablesFromIntrospection(introspection, options = {}) {
     const { types, queryType, mutationType } = schema;
     // Build lookup maps for efficient access
     const typeMap = buildTypeMap(types);
+    const { entityNames, entityToConnection, connectionToEntity } = buildEntityConnectionMaps(types, typeMap);
     const queryFields = getTypeFields(typeMap.get(queryType.name));
     const mutationFields = mutationType
         ? getTypeFields(typeMap.get(mutationType.name))
         : [];
-    // Step 1: Detect entity types by finding Connection types
-    const entityNames = detectEntityTypes(types);
-    // Step 2: Build CleanTable for each entity
+    // Step 1: Build CleanTable for each inferred entity
     const tables = [];
     for (const entityName of entityNames) {
         const entityType = typeMap.get(entityName);
         if (!entityType)
             continue;
         // Infer all metadata for this entity
-        const { table, hasRealOperation } = buildCleanTable(entityName, entityType, typeMap, queryFields, mutationFields);
+        const { table, hasRealOperation } = buildCleanTable(entityName, entityType, typeMap, queryFields, mutationFields, entityToConnection, connectionToEntity);
         // Only include tables that have at least one real operation
         if (hasRealOperation) {
             tables.push(table);
@@ -107,17 +106,17 @@ function inferTablesFromIntrospection(introspection, options = {}) {
     }
     return tables;
 }
-// ============================================================================
-// Entity Detection
-// ============================================================================
 /**
- * Detect entity types by finding Connection types in the schema
+ * Infer entity <-> connection mappings from schema types.
  *
- * PostGraphile generates a {PluralName}Connection type for each table.
- * From this, we can derive the entity type name.
+ * Prefer deriving entity names from the `nodes` field of connection types.
+ * This is robust across v4/v5 naming variations (e.g. `UsersConnection` and
+ * `UserConnection`).
  */
-function detectEntityTypes(types) {
+function buildEntityConnectionMaps(types, typeMap) {
     const entityNames = new Set();
+    const entityToConnection = new Map();
+    const connectionToEntity = new Map();
     const typeNames = new Set(types.map((t) => t.name));
     for (const type of types) {
         // Skip internal types
@@ -128,26 +127,58 @@ function detectEntityTypes(types) {
         // Check for Connection pattern
         const connectionMatch = type.name.match(PATTERNS.connection);
         if (connectionMatch) {
-            const pluralName = connectionMatch[1]; // e.g., "Users" from "UsersConnection"
-            const singularName = (0, inflekt_1.singularize)(pluralName); // e.g., "User"
-            // Verify the entity type actually exists
-            if (typeNames.has(singularName)) {
-                entityNames.add(singularName);
+            const fallbackEntityName = (0, inflekt_1.singularize)(connectionMatch[1]);
+            const entityName = resolveEntityNameFromConnectionType(type, typeMap) ?? fallbackEntityName;
+            // Verify the entity type actually exists and is not a built-in/internal type.
+            if (typeNames.has(entityName) &&
+                !BUILTIN_TYPES.has(entityName) &&
+                !isInternalType(entityName)) {
+                entityNames.add(entityName);
+                entityToConnection.set(entityName, type.name);
+                connectionToEntity.set(type.name, entityName);
             }
         }
     }
-    return entityNames;
+    return {
+        entityNames,
+        entityToConnection,
+        connectionToEntity,
+    };
+}
+/**
+ * Attempt to resolve an entity name from a connection type by inspecting its
+ * `nodes` field.
+ */
+function resolveEntityNameFromConnectionType(connectionType, typeMap) {
+    if (!connectionType.fields)
+        return null;
+    const nodesField = connectionType.fields.find((field) => field.name === 'nodes');
+    if (!nodesField)
+        return null;
+    const nodeTypeName = (0, introspection_1.getBaseTypeName)(nodesField.type);
+    if (!nodeTypeName)
+        return null;
+    const nodeType = typeMap.get(nodeTypeName);
+    if (!nodeType || nodeType.kind !== 'OBJECT')
+        return null;
+    if (nodeTypeName.endsWith('Connection'))
+        return null;
+    if (BUILTIN_TYPES.has(nodeTypeName))
+        return null;
+    if (isInternalType(nodeTypeName))
+        return null;
+    return nodeTypeName;
 }
 /**
  * Build a complete CleanTable from an entity type
  */
-function buildCleanTable(entityName, entityType, typeMap, queryFields, mutationFields) {
+function buildCleanTable(entityName, entityType, typeMap, queryFields, mutationFields, entityToConnection, connectionToEntity) {
     // Extract scalar fields from entity type
-    const fields = extractEntityFields(entityType, typeMap);
+    const fields = extractEntityFields(entityType, typeMap, entityToConnection);
     // Infer relations from entity fields
-    const relations = inferRelations(entityType, typeMap);
+    const relations = inferRelations(entityType, entityToConnection, connectionToEntity);
     // Match query and mutation operations
-    const queryOps = matchQueryOperations(entityName, queryFields, typeMap);
+    const queryOps = matchQueryOperations(entityName, queryFields, entityToConnection);
     const mutationOps = matchMutationOperations(entityName, mutationFields);
     // Check if we found at least one real operation (not a fallback)
     const hasRealOperation = !!(queryOps.all ||
@@ -157,16 +188,19 @@ function buildCleanTable(entityName, entityType, typeMap, queryFields, mutationF
         mutationOps.delete);
     // Infer primary key from mutation inputs
     const constraints = inferConstraints(entityName, typeMap);
+    // Infer the patch field name from UpdateXxxInput (e.g., "userPatch")
+    const patchFieldName = inferPatchFieldName(entityName, typeMap);
     // Build inflection map from discovered types
-    const inflection = buildInflection(entityName, typeMap);
+    const inflection = buildInflection(entityName, typeMap, entityToConnection);
     // Combine query operations with fallbacks for UI purposes
     // (but hasRealOperation indicates if we should include this table)
     const query = {
         all: queryOps.all ?? (0, inflekt_1.lcFirst)((0, inflekt_1.pluralize)(entityName)),
-        one: queryOps.one ?? (0, inflekt_1.lcFirst)(entityName),
+        one: queryOps.one,
         create: mutationOps.create ?? `create${entityName}`,
         update: mutationOps.update,
         delete: mutationOps.delete,
+        patchFieldName,
     };
     return {
         table: {
@@ -187,7 +221,7 @@ function buildCleanTable(entityName, entityType, typeMap, queryFields, mutationF
  * Extract scalar fields from an entity type
  * Excludes relation fields (those returning other entity types or connections)
  */
-function extractEntityFields(entityType, typeMap) {
+function extractEntityFields(entityType, typeMap, entityToConnection) {
     const fields = [];
     if (!entityType.fields)
         return fields;
@@ -200,7 +234,7 @@ function extractEntityFields(entityType, typeMap) {
         if (fieldType?.kind === 'OBJECT') {
             // Check if it's a Connection type (hasMany) or entity type (belongsTo)
             if (baseTypeName.endsWith('Connection') ||
-                isEntityType(baseTypeName, typeMap)) {
+                isEntityType(baseTypeName, entityToConnection)) {
                 continue; // Skip relation fields
             }
         }
@@ -215,9 +249,8 @@ function extractEntityFields(entityType, typeMap) {
 /**
  * Check if a type name is an entity type (has a corresponding Connection)
  */
-function isEntityType(typeName, typeMap) {
-    const connectionName = `${(0, inflekt_1.pluralize)(typeName)}Connection`;
-    return typeMap.has(connectionName);
+function isEntityType(typeName, entityToConnection) {
+    return entityToConnection.has(typeName);
 }
 /**
  * Convert IntrospectionTypeRef to CleanFieldType
@@ -238,7 +271,7 @@ function convertToCleanFieldType(typeRef) {
 /**
  * Infer relations from entity type fields
  */
-function inferRelations(entityType, typeMap) {
+function inferRelations(entityType, entityToConnection, connectionToEntity) {
     const belongsTo = [];
     const hasMany = [];
     const manyToMany = [];
@@ -251,17 +284,17 @@ function inferRelations(entityType, typeMap) {
             continue;
         // Check for Connection type → hasMany or manyToMany
         if (baseTypeName.endsWith('Connection')) {
-            const relation = inferHasManyOrManyToMany(field, baseTypeName, typeMap);
-            if (relation.type === 'manyToMany') {
-                manyToMany.push(relation.relation);
+            const resolvedRelation = inferHasManyOrManyToMany(field, baseTypeName, connectionToEntity);
+            if (resolvedRelation.type === 'manyToMany') {
+                manyToMany.push(resolvedRelation.relation);
             }
             else {
-                hasMany.push(relation.relation);
+                hasMany.push(resolvedRelation.relation);
             }
             continue;
         }
         // Check for entity type → belongsTo
-        if (isEntityType(baseTypeName, typeMap)) {
+        if (isEntityType(baseTypeName, entityToConnection)) {
             belongsTo.push({
                 fieldName: field.name,
                 isUnique: false, // Can't determine from introspection alone
@@ -279,11 +312,13 @@ function inferRelations(entityType, typeMap) {
  * ManyToMany pattern: field name contains "By" and "And"
  * e.g., "productsByOrderItemOrderIdAndProductId"
  */
-function inferHasManyOrManyToMany(field, connectionTypeName, typeMap) {
-    // Extract the related entity name from Connection type
-    const match = connectionTypeName.match(PATTERNS.connection);
-    const relatedPluralName = match ? match[1] : connectionTypeName;
-    const relatedEntityName = (0, inflekt_1.singularize)(relatedPluralName);
+function inferHasManyOrManyToMany(field, connectionTypeName, connectionToEntity) {
+    // Resolve the related entity from discovered connection mappings first.
+    const relatedEntityName = connectionToEntity.get(connectionTypeName) ?? (() => {
+        const match = connectionTypeName.match(PATTERNS.connection);
+        const relatedPluralName = match ? match[1] : connectionTypeName;
+        return (0, inflekt_1.singularize)(relatedPluralName);
+    })();
     // Check for manyToMany pattern in field name
     const isManyToMany = field.name.includes('By') && field.name.includes('And');
     if (isManyToMany) {
@@ -329,9 +364,9 @@ function inferHasManyOrManyToMany(field, connectionTypeName, typeMap) {
  * - List query: returns {PluralName}Connection (e.g., users → UsersConnection)
  * - Single query: returns {EntityName} with id/nodeId arg (e.g., user → User)
  */
-function matchQueryOperations(entityName, queryFields, typeMap) {
+function matchQueryOperations(entityName, queryFields, entityToConnection) {
     const pluralName = (0, inflekt_1.pluralize)(entityName);
-    const connectionTypeName = `${pluralName}Connection`;
+    const connectionTypeName = entityToConnection.get(entityName) ?? `${pluralName}Connection`;
     let all = null;
     let one = null;
     for (const field of queryFields) {
@@ -415,21 +450,18 @@ function inferConstraints(entityName, typeMap) {
     const deleteInputName = `Delete${entityName}Input`;
     const updateInput = typeMap.get(updateInputName);
     const deleteInput = typeMap.get(deleteInputName);
-    // Check update input for id field
-    const inputToCheck = updateInput || deleteInput;
-    if (inputToCheck?.inputFields) {
-        const idField = inputToCheck.inputFields.find((f) => f.name === 'id' || f.name === 'nodeId');
-        if (idField) {
-            primaryKey.push({
-                name: 'primary',
-                fields: [
-                    {
-                        name: idField.name,
-                        type: convertToCleanFieldType(idField.type),
-                    },
-                ],
-            });
-        }
+    const keyInputField = inferPrimaryKeyFromInputObject(updateInput) ||
+        inferPrimaryKeyFromInputObject(deleteInput);
+    if (keyInputField) {
+        primaryKey.push({
+            name: 'primary',
+            fields: [
+                {
+                    name: keyInputField.name,
+                    type: convertToCleanFieldType(keyInputField.type),
+                },
+            ],
+        });
     }
     // If no PK found from inputs, try to find 'id' field in entity type
     if (primaryKey.length === 0) {
@@ -455,16 +487,70 @@ function inferConstraints(entityName, typeMap) {
         unique: [], // Would need constraint info to populate
     };
 }
+/**
+ * Infer a single-row lookup key from an Update/Delete input object.
+ *
+ * Priority:
+ * 1. Canonical keys: id, nodeId, rowId
+ * 2. Single non-patch/non-clientMutationId scalar-ish field
+ *
+ * If multiple possible key fields remain, return null to avoid guessing.
+ */
+function inferPrimaryKeyFromInputObject(inputType) {
+    const inputFields = inputType?.inputFields ?? [];
+    if (inputFields.length === 0)
+        return null;
+    const canonicalKey = inputFields.find((field) => field.name === 'id' || field.name === 'nodeId' || field.name === 'rowId');
+    if (canonicalKey)
+        return canonicalKey;
+    const candidates = inputFields.filter((field) => {
+        if (field.name === 'clientMutationId')
+            return false;
+        const baseTypeName = (0, introspection_1.getBaseTypeName)(field.type);
+        const lowerName = field.name.toLowerCase();
+        // Exclude patch payload fields (patch / fooPatch)
+        if (lowerName === 'patch' || lowerName.endsWith('patch'))
+            return false;
+        if (baseTypeName?.endsWith('Patch'))
+            return false;
+        return true;
+    });
+    return candidates.length === 1 ? candidates[0] : null;
+}
+/**
+ * Infer the patch field name from an Update input type.
+ *
+ * PostGraphile v5 uses entity-specific patch field names:
+ *   UpdateUserInput     → { id, userPatch: UserPatch }
+ *   UpdateDatabaseInput → { id, databasePatch: DatabasePatch }
+ *
+ * Pattern: {lcFirst(entityTypeName)}Patch
+ */
+function inferPatchFieldName(entityName, typeMap) {
+    const updateInputName = `Update${entityName}Input`;
+    const updateInput = typeMap.get(updateInputName);
+    const inputFields = updateInput?.inputFields ?? [];
+    // Find the field whose type name ends in 'Patch'
+    const patchField = inputFields.find((f) => {
+        const baseName = (0, introspection_1.getBaseTypeName)(f.type);
+        return baseName?.endsWith('Patch');
+    });
+    if (patchField)
+        return patchField.name;
+    // Fallback: compute from entity name (v5 default inflection)
+    return (0, inflekt_1.lcFirst)(entityName) + 'Patch';
+}
 // ============================================================================
 // Inflection Building
 // ============================================================================
 /**
  * Build inflection map from discovered types
  */
-function buildInflection(entityName, typeMap) {
+function buildInflection(entityName, typeMap, entityToConnection) {
     const pluralName = (0, inflekt_1.pluralize)(entityName);
     const singularFieldName = (0, inflekt_1.lcFirst)(entityName);
     const pluralFieldName = (0, inflekt_1.lcFirst)(pluralName);
+    const connectionTypeName = entityToConnection.get(entityName) ?? `${pluralName}Connection`;
     // Check which types actually exist in the schema
     const hasFilter = typeMap.has(`${entityName}Filter`);
     const hasPatch = typeMap.has(`${entityName}Patch`);
@@ -478,7 +564,7 @@ function buildInflection(entityName, typeMap) {
         allRows: pluralFieldName,
         allRowsSimple: pluralFieldName,
         conditionType: `${entityName}Condition`,
-        connection: `${pluralName}Connection`,
+        connection: connectionTypeName,
         createField: `create${entityName}`,
         createInputType: `Create${entityName}Input`,
         createPayloadType: `Create${entityName}Payload`,

package/core/introspect/transform-schema.d.ts

@@ -58,7 +58,7 @@ export declare function getTableOperationNames(tables: Array<{
     name: string;
     query?: {
         all: string;
-        one: string;
+        one: string | null;
         create: string;
         update: string | null;
         delete: string | null;

package/core/introspect/transform-schema.js

@@ -240,7 +240,9 @@ function getTableOperationNames(tables) {
         if (table.query) {
             // Add exact query names from _meta
             queries.add(table.query.all);
-            queries.add(table.query.one);
+            if (table.query.one) {
+                queries.add(table.query.one);
+            }
             // Add exact mutation names from _meta
             mutations.add(table.query.create);
             if (table.query.update)

package/esm/core/ast.js

@@ -1,4 +1,5 @@
 import * as t from 'gql-ast';
+import { OperationTypeNode } from 'graphql';
 import { camelize, singularize } from 'inflekt';
 import { getCustomAst } from './custom-ast';
 const NON_MUTABLE_PROPS = ['createdAt', 'createdBy', 'updatedAt', 'updatedBy'];
@@ -39,7 +40,7 @@ const createGqlMutation = ({ operationName, mutationName, selectArgs, selections
     return t.document({
         definitions: [
             t.operationDefinition({
-                operation: 'mutation',
+                operation: OperationTypeNode.MUTATION,
                 name: mutationName,
                 variableDefinitions,
                 selectionSet: t.selectionSet({ selections: opSel }),
@@ -68,7 +69,7 @@ export const getAll = ({ queryName, operationName, selection, }) => {
     const ast = t.document({
         definitions: [
             t.operationDefinition({
-                operation: 'query',
+                operation: OperationTypeNode.QUERY,
                 name: queryName,
                 selectionSet: t.selectionSet({ selections: opSel }),
             }),
@@ -111,7 +112,7 @@ export const getCount = ({ queryName, operationName, query, }) => {
     const ast = t.document({
         definitions: [
             t.operationDefinition({
-                operation: 'query',
+                operation: OperationTypeNode.QUERY,
                 name: queryName,
                 variableDefinitions,
                 selectionSet: t.selectionSet({ selections: opSel }),
@@ -210,7 +211,7 @@ export const getMany = ({ builder, queryName, operationName, query, selection, }
     const ast = t.document({
         definitions: [
             t.operationDefinition({
-                operation: 'query',
+                operation: OperationTypeNode.QUERY,
                 name: queryName,
                 variableDefinitions,
                 selectionSet: t.selectionSet({
@@ -266,7 +267,7 @@ export const getOne = ({ queryName, operationName, query, selection, }) => {
     const ast = t.document({
         definitions: [
             t.operationDefinition({
-                operation: 'query',
+                operation: OperationTypeNode.QUERY,
                 name: queryName,
                 variableDefinitions,
                 selectionSet: t.selectionSet({ selections: opSel }),