@constructive-io/graphql-codegen 3.3.2 → 4.0.1

package/esm/core/database/index.js

@@ -19,11 +19,10 @@ export 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 buildSchemaSDL({
         database,
         schemas,
-        graphile: { pgSettings: async () => ({ role: 'administrator' }) },
     });
     // Write schema to file
     const schemaPath = path.join(outDir, filename);
@@ -40,9 +39,9 @@ export async function buildSchemaFromDatabase(options) {
  */
 export async function buildSchemaSDLFromDatabase(options) {
     const { database, schemas } = options;
+    // PostGraphile v5 resolves role/settings via preset configuration.
     return buildSchemaSDL({
         database,
         schemas,
-        graphile: { pgSettings: async () => ({ role: 'administrator' }) },
     });
 }

package/esm/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/esm/core/index.js

@@ -11,8 +11,10 @@ export * from './types';
 export * from './ast';
 export * from './custom-ast';
 // Query builder
+/** @deprecated Legacy v4 query builder — use v5 ORM codegen instead */
 export { MetaObject, QueryBuilder } from './query-builder';
 // Meta object utilities
+/** @deprecated Legacy v4 meta-object utilities — v5 uses standard introspection */
 export { convertFromMetaSchema, validateMetaObject } from './meta-object';
 // Configuration loading and resolution
 export * from './config';

package/esm/core/introspect/infer-tables.js

@@ -83,20 +83,19 @@ export 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);
@@ -104,17 +103,17 @@ export 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
@@ -125,26 +124,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 = singularize(pluralName); // e.g., "User"
-            // Verify the entity type actually exists
-            if (typeNames.has(singularName)) {
-                entityNames.add(singularName);
+            const fallbackEntityName = 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 = 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 ||
@@ -154,16 +185,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 ?? lcFirst(pluralize(entityName)),
-        one: queryOps.one ?? lcFirst(entityName),
+        one: queryOps.one,
         create: mutationOps.create ?? `create${entityName}`,
         update: mutationOps.update,
         delete: mutationOps.delete,
+        patchFieldName,
     };
     return {
         table: {
@@ -184,7 +218,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;
@@ -197,7 +231,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
             }
         }
@@ -212,9 +246,8 @@ function extractEntityFields(entityType, typeMap) {
 /**
  * Check if a type name is an entity type (has a corresponding Connection)
  */
-function isEntityType(typeName, typeMap) {
-    const connectionName = `${pluralize(typeName)}Connection`;
-    return typeMap.has(connectionName);
+function isEntityType(typeName, entityToConnection) {
+    return entityToConnection.has(typeName);
 }
 /**
  * Convert IntrospectionTypeRef to CleanFieldType
@@ -235,7 +268,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 = [];
@@ -248,17 +281,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
@@ -276,11 +309,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 = 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 singularize(relatedPluralName);
+    })();
     // Check for manyToMany pattern in field name
     const isManyToMany = field.name.includes('By') && field.name.includes('And');
     if (isManyToMany) {
@@ -326,9 +361,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 = pluralize(entityName);
-    const connectionTypeName = `${pluralName}Connection`;
+    const connectionTypeName = entityToConnection.get(entityName) ?? `${pluralName}Connection`;
     let all = null;
     let one = null;
     for (const field of queryFields) {
@@ -412,21 +447,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) {
@@ -452,16 +484,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 = 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 = getBaseTypeName(f.type);
+        return baseName?.endsWith('Patch');
+    });
+    if (patchField)
+        return patchField.name;
+    // Fallback: compute from entity name (v5 default inflection)
+    return lcFirst(entityName) + 'Patch';
+}
 // ============================================================================
 // Inflection Building
 // ============================================================================
 /**
  * Build inflection map from discovered types
  */
-function buildInflection(entityName, typeMap) {
+function buildInflection(entityName, typeMap, entityToConnection) {
     const pluralName = pluralize(entityName);
     const singularFieldName = lcFirst(entityName);
     const pluralFieldName = 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`);
@@ -475,7 +561,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/esm/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/esm/core/introspect/transform-schema.js

@@ -228,7 +228,9 @@ export 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/generators/field-selector.js

@@ -241,6 +241,7 @@ function getRelatedTableScalarFields(relationField, table, allTables) {
     };
     // Always try to include stable identifiers first.
     push('id');
+    push('rowId');
     push('nodeId');
     for (const fieldName of preferred)
         push(fieldName);

package/esm/generators/index.d.ts

@@ -1,5 +1,8 @@
 /**
  * Query and mutation generator exports
+ *
+ * @deprecated Legacy v4 generators — use v5 ORM codegen pipeline instead.
+ * These are retained for backward compatibility with existing v4 consumers.
  */
 export { convertToSelectionOptions, getAvailableRelations, isRelationalField, validateFieldSelection, } from './field-selector';
 export { buildCount, buildFindOne, buildSelect, cleanTableToMetaObject, createASTQueryBuilder, generateIntrospectionSchema, toCamelCasePlural, toOrderByTypeName, } from './select';

package/esm/generators/index.js

@@ -1,5 +1,8 @@
 /**
  * Query and mutation generator exports
+ *
+ * @deprecated Legacy v4 generators — use v5 ORM codegen pipeline instead.
+ * These are retained for backward compatibility with existing v4 consumers.
  */
 // Field selector utilities
 export { convertToSelectionOptions, getAvailableRelations, isRelationalField, validateFieldSelection, } from './field-selector';

package/esm/generators/mutations.js

@@ -3,7 +3,7 @@
  * Uses AST-based approach for PostGraphile-compatible mutations
  */
 import * as t from 'gql-ast';
-import { print } from 'graphql';
+import { OperationTypeNode, print } from 'graphql';
 import { camelize } from 'inflekt';
 import { TypedDocumentString } from '../client/typed-document';
 import { getCustomAstForCleanField, requiresSubfieldSelection, } from '../core/custom-ast';
@@ -55,7 +55,7 @@ export function buildPostGraphileCreate(table, _allTables, _options = {}) {
     const ast = t.document({
         definitions: [
             t.operationDefinition({
-                operation: 'mutation',
+                operation: OperationTypeNode.MUTATION,
                 name: `${mutationName}Mutation`,
                 variableDefinitions,
                 selectionSet: t.selectionSet({
@@ -114,7 +114,7 @@ export function buildPostGraphileUpdate(table, _allTables, _options = {}) {
     const ast = t.document({
         definitions: [
             t.operationDefinition({
-                operation: 'mutation',
+                operation: OperationTypeNode.MUTATION,
                 name: `${mutationName}Mutation`,
                 variableDefinitions,
                 selectionSet: t.selectionSet({
@@ -172,7 +172,7 @@ export function buildPostGraphileDelete(table, _allTables, _options = {}) {
     const ast = t.document({
         definitions: [
             t.operationDefinition({
-                operation: 'mutation',
+                operation: OperationTypeNode.MUTATION,
                 name: `${mutationName}Mutation`,
                 variableDefinitions,
                 selectionSet: t.selectionSet({

package/esm/generators/select.js

@@ -3,7 +3,7 @@
  * Uses AST-based approach for all query generation
  */
 import * as t from 'gql-ast';
-import { print } from 'graphql';
+import { OperationTypeNode, print } from 'graphql';
 import { camelize, pluralize } from 'inflekt';
 import { TypedDocumentString } from '../client/typed-document';
 import { getCustomAstForCleanField, requiresSubfieldSelection, } from '../core/custom-ast';
@@ -368,7 +368,7 @@ function generateSelectQueryAST(table, allTables, selection, options) {
     const ast = t.document({
         definitions: [
             t.operationDefinition({
-                operation: 'query',
+                operation: OperationTypeNode.QUERY,
                 name: `${pluralName}Query`,
                 variableDefinitions,
                 selectionSet: t.selectionSet({
@@ -566,7 +566,7 @@ function generateFindOneQueryAST(table) {
     const ast = t.document({
         definitions: [
             t.operationDefinition({
-                operation: 'query',
+                operation: OperationTypeNode.QUERY,
                 name: `${singularName}Query`,
                 variableDefinitions: [
                     t.variableDefinition({
@@ -605,7 +605,7 @@ function generateCountQueryAST(table) {
     const ast = t.document({
         definitions: [
             t.operationDefinition({
-                operation: 'query',
+                operation: OperationTypeNode.QUERY,
                 name: `${pluralName}CountQuery`,
                 variableDefinitions: [
                     t.variableDefinition({

package/esm/index.d.ts

@@ -2,7 +2,7 @@
  * @constructive-io/graphql-codegen
  *
  * GraphQL SDK generator for Constructive databases.
- * Introspects via _meta query and generates typed queries, mutations,
+ * Introspects via standard GraphQL introspection and generates typed queries, mutations,
  * and React Query v5 hooks.
  */
 export * from './types';

package/esm/index.js

@@ -2,7 +2,7 @@
  * @constructive-io/graphql-codegen
  *
  * GraphQL SDK generator for Constructive databases.
- * Introspects via _meta query and generates typed queries, mutations,
+ * Introspects via standard GraphQL introspection and generates typed queries, mutations,
  * and React Query v5 hooks.
  */
 // Core types

package/esm/types/schema.d.ts

@@ -11,7 +11,7 @@ export interface CleanTable {
     relations: CleanRelations;
     /** PostGraphile inflection rules for this table */
     inflection?: TableInflection;
-    /** Query operation names from _meta */
+    /** Query operation names from introspection */
     query?: TableQueryNames;
     /** Constraint information */
     constraints?: TableConstraints;
@@ -66,19 +66,21 @@ export interface TableInflection {
     updatePayloadType: string | null;
 }
 /**
- * Query operation names from _meta.query
+ * Query operation names from introspection
  */
 export interface TableQueryNames {
     /** All rows query name */
     all: string;
     /** Single row query name */
-    one: string;
+    one: string | null;
     /** Create mutation name */
     create: string;
     /** Update mutation name */
     update: string | null;
     /** Delete mutation name */
     delete: string | null;
+    /** Patch field name in update mutation input (e.g., "userPatch" for UpdateUserInput) */
+    patchFieldName?: string;
 }
 /**
  * Table constraints

package/generators/field-selector.js

@@ -247,6 +247,7 @@ function getRelatedTableScalarFields(relationField, table, allTables) {
     };
     // Always try to include stable identifiers first.
     push('id');
+    push('rowId');
     push('nodeId');
     for (const fieldName of preferred)
         push(fieldName);

package/generators/index.d.ts

@@ -1,5 +1,8 @@
 /**
  * Query and mutation generator exports
+ *
+ * @deprecated Legacy v4 generators — use v5 ORM codegen pipeline instead.
+ * These are retained for backward compatibility with existing v4 consumers.
  */
 export { convertToSelectionOptions, getAvailableRelations, isRelationalField, validateFieldSelection, } from './field-selector';
 export { buildCount, buildFindOne, buildSelect, cleanTableToMetaObject, createASTQueryBuilder, generateIntrospectionSchema, toCamelCasePlural, toOrderByTypeName, } from './select';

package/generators/index.js

@@ -1,6 +1,9 @@
 "use strict";
 /**
  * Query and mutation generator exports
+ *
+ * @deprecated Legacy v4 generators — use v5 ORM codegen pipeline instead.
+ * These are retained for backward compatibility with existing v4 consumers.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildPostGraphileUpdate = exports.buildPostGraphileDelete = exports.buildPostGraphileCreate = exports.toOrderByTypeName = exports.toCamelCasePlural = exports.generateIntrospectionSchema = exports.createASTQueryBuilder = exports.cleanTableToMetaObject = exports.buildSelect = exports.buildFindOne = exports.buildCount = exports.validateFieldSelection = exports.isRelationalField = exports.getAvailableRelations = exports.convertToSelectionOptions = void 0;

package/generators/mutations.js

@@ -93,7 +93,7 @@ function buildPostGraphileCreate(table, _allTables, _options = {}) {
     const ast = t.document({
         definitions: [
             t.operationDefinition({
-                operation: 'mutation',
+                operation: graphql_1.OperationTypeNode.MUTATION,
                 name: `${mutationName}Mutation`,
                 variableDefinitions,
                 selectionSet: t.selectionSet({
@@ -152,7 +152,7 @@ function buildPostGraphileUpdate(table, _allTables, _options = {}) {
     const ast = t.document({
         definitions: [
             t.operationDefinition({
-                operation: 'mutation',
+                operation: graphql_1.OperationTypeNode.MUTATION,
                 name: `${mutationName}Mutation`,
                 variableDefinitions,
                 selectionSet: t.selectionSet({
@@ -210,7 +210,7 @@ function buildPostGraphileDelete(table, _allTables, _options = {}) {
     const ast = t.document({
         definitions: [
             t.operationDefinition({
-                operation: 'mutation',
+                operation: graphql_1.OperationTypeNode.MUTATION,
                 name: `${mutationName}Mutation`,
                 variableDefinitions,
                 selectionSet: t.selectionSet({

package/generators/select.js

@@ -411,7 +411,7 @@ function generateSelectQueryAST(table, allTables, selection, options) {
     const ast = t.document({
         definitions: [
             t.operationDefinition({
-                operation: 'query',
+                operation: graphql_1.OperationTypeNode.QUERY,
                 name: `${pluralName}Query`,
                 variableDefinitions,
                 selectionSet: t.selectionSet({
@@ -609,7 +609,7 @@ function generateFindOneQueryAST(table) {
     const ast = t.document({
         definitions: [
             t.operationDefinition({
-                operation: 'query',
+                operation: graphql_1.OperationTypeNode.QUERY,
                 name: `${singularName}Query`,
                 variableDefinitions: [
                     t.variableDefinition({
@@ -648,7 +648,7 @@ function generateCountQueryAST(table) {
     const ast = t.document({
         definitions: [
             t.operationDefinition({
-                operation: 'query',
+                operation: graphql_1.OperationTypeNode.QUERY,
                 name: `${pluralName}CountQuery`,
                 variableDefinitions: [
                     t.variableDefinition({