@constructive-io/graphql-codegen 4.5.3 → 4.6.1

package/esm/core/codegen/utils.js

@@ -323,6 +323,92 @@ export function getQueryKeyPrefix(table) {
     return lcFirst(table.name);
 }
 // ============================================================================
+// Smart Comment Utilities
+// ============================================================================
+/**
+ * PostGraphile smart comment tags that should be stripped from descriptions.
+ * Smart comments start with `@` and control PostGraphile behavior
+ * (e.g., `@omit`, `@name`, `@foreignKey`, etc.)
+ *
+ * A PostgreSQL COMMENT may contain both human-readable text and smart comments:
+ *   COMMENT ON TABLE users IS 'User accounts for the application\n@omit delete';
+ *
+ * PostGraphile's introspection already separates these: the GraphQL `description`
+ * field contains only the human-readable part. So in most cases, the description
+ * we receive from introspection is already clean.
+ *
+ * However, as a safety measure, this utility strips any remaining `@`-prefixed
+ * lines that may have leaked through.
+ */
+/**
+ * PostGraphile auto-generated boilerplate descriptions that add no value.
+ * These are generic descriptions PostGraphile puts on every mutation input,
+ * clientMutationId field, etc. We filter them out to keep generated code clean.
+ */
+const POSTGRAPHILE_BOILERPLATE = [
+    'The exclusive input argument for this mutation.',
+    'An arbitrary string value with no semantic meaning.',
+    'The exact same `clientMutationId` that was provided in the mutation input,',
+    'The output of our',
+    'All input for the',
+    'A cursor for use in pagination.',
+    'An edge for our',
+    'Information to aid in pagination.',
+    'Reads and enables pagination through a set of',
+    'A list of edges which contains the',
+    'The count of *all* `',
+    'A list of `',
+    'Our root query field',
+    'Reads a single',
+    'The root query type',
+    'The root mutation type',
+];
+/**
+ * Check if a description is generic PostGraphile boilerplate that should be suppressed.
+ */
+function isBoilerplateDescription(description) {
+    const trimmed = description.trim();
+    return POSTGRAPHILE_BOILERPLATE.some((bp) => trimmed.startsWith(bp));
+}
+/**
+ * Strip PostGraphile smart comments and boilerplate from a description string.
+ *
+ * Smart comments are lines starting with `@` (e.g., `@omit`, `@name newName`).
+ * Boilerplate descriptions are generic PostGraphile-generated text that repeats
+ * on every mutation input, clientMutationId field, etc.
+ *
+ * This returns only the meaningful human-readable portion of the comment,
+ * or undefined if the result is empty or boilerplate.
+ *
+ * @param description - Raw description from GraphQL introspection
+ * @returns Cleaned description, or undefined if empty/boilerplate
+ */
+export function stripSmartComments(description, enabled = true) {
+    if (!enabled)
+        return undefined;
+    if (!description)
+        return undefined;
+    // Check if entire description is boilerplate
+    if (isBoilerplateDescription(description))
+        return undefined;
+    const lines = description.split('\n');
+    const cleanLines = [];
+    for (const line of lines) {
+        const trimmed = line.trim();
+        // Skip lines that start with @ (smart comment directives)
+        if (trimmed.startsWith('@'))
+            continue;
+        cleanLines.push(line);
+    }
+    const result = cleanLines.join('\n').trim();
+    if (result.length === 0)
+        return undefined;
+    // Re-check after stripping smart comments
+    if (isBoilerplateDescription(result))
+        return undefined;
+    return result;
+}
+// ============================================================================
 // Code generation helpers
 // ============================================================================
 /**

package/esm/core/introspect/infer-tables.d.ts

@@ -25,6 +25,11 @@ export interface InferTablesOptions {
      * Custom pattern overrides (for non-standard PostGraphile configurations)
      */
     patterns?: Partial<typeof PATTERNS>;
+    /**
+     * Include PostgreSQL COMMENT descriptions on tables and fields.
+     * @default true
+     */
+    comments?: boolean;
 }
 /**
  * Infer CleanTable[] from GraphQL introspection by recognizing PostGraphile patterns

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

@@ -13,7 +13,8 @@
  * - Mutation operations: create{Name}, update{Name}, delete{Name}
  */
 import { lcFirst, pluralize, singularize, ucFirst } from 'inflekt';
-import { getBaseTypeName, isList, unwrapType } from '../../types/introspection';
+import { stripSmartComments } from '../codegen/utils';
+import { getBaseTypeName, isList, isNonNull, unwrapType } from '../../types/introspection';
 // ============================================================================
 // Pattern Matching Constants
 // ============================================================================
@@ -81,6 +82,7 @@ function isInternalType(name) {
 export function inferTablesFromIntrospection(introspection, options = {}) {
     const { __schema: schema } = introspection;
     const { types, queryType, mutationType } = schema;
+    const commentsEnabled = options.comments !== false;
     // Build lookup maps for efficient access
     const typeMap = buildTypeMap(types);
     const { entityNames, entityToConnection, connectionToEntity } = buildEntityConnectionMaps(types, typeMap);
@@ -95,7 +97,7 @@ export function inferTablesFromIntrospection(introspection, options = {}) {
         if (!entityType)
             continue;
         // Infer all metadata for this entity
-        const { table, hasRealOperation } = buildCleanTable(entityName, entityType, typeMap, queryFields, mutationFields, entityToConnection, connectionToEntity);
+        const { table, hasRealOperation } = buildCleanTable(entityName, entityType, typeMap, queryFields, mutationFields, entityToConnection, connectionToEntity, commentsEnabled);
         // Only include tables that have at least one real operation
         if (hasRealOperation) {
             tables.push(table);
@@ -169,9 +171,9 @@ function resolveEntityNameFromConnectionType(connectionType, typeMap) {
 /**
  * Build a complete CleanTable from an entity type
  */
-function buildCleanTable(entityName, entityType, typeMap, queryFields, mutationFields, entityToConnection, connectionToEntity) {
+function buildCleanTable(entityName, entityType, typeMap, queryFields, mutationFields, entityToConnection, connectionToEntity, commentsEnabled) {
     // Extract scalar fields from entity type
-    const fields = extractEntityFields(entityType, typeMap, entityToConnection);
+    const fields = extractEntityFields(entityType, typeMap, entityToConnection, commentsEnabled);
     // Infer relations from entity fields
     const relations = inferRelations(entityType, entityToConnection, connectionToEntity);
     // Match query and mutation operations
@@ -199,9 +201,12 @@ function buildCleanTable(entityName, entityType, typeMap, queryFields, mutationF
         delete: mutationOps.delete,
         patchFieldName,
     };
+    // Extract description from entity type (PostgreSQL COMMENT), strip smart comments
+    const description = commentsEnabled ? stripSmartComments(entityType.description) : undefined;
     return {
         table: {
             name: entityName,
+            ...(description ? { description } : {}),
             fields,
             relations,
             inflection,
@@ -218,10 +223,14 @@ 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, entityToConnection) {
+function extractEntityFields(entityType, typeMap, entityToConnection, commentsEnabled) {
     const fields = [];
     if (!entityType.fields)
         return fields;
+    // Build a lookup of CreateXxxInput fields to infer hasDefault.
+    // If a field is NOT NULL on the entity but NOT required in CreateXxxInput,
+    // then it likely has a server-side default (serial, uuid_generate_v4, now(), etc.).
+    const createInputRequiredFields = buildCreateInputRequiredFieldSet(entityType.name, typeMap);
     for (const field of entityType.fields) {
         const baseTypeName = getBaseTypeName(field.type);
         if (!baseTypeName)
@@ -235,14 +244,55 @@ function extractEntityFields(entityType, typeMap, entityToConnection) {
                 continue; // Skip relation fields
             }
         }
+        // Infer isNotNull from the NON_NULL wrapper on the entity type field
+        const fieldIsNotNull = isNonNull(field.type);
+        // Infer hasDefault: if a field is NOT NULL on the entity but NOT required
+        // in CreateXxxInput, it likely has a default value.
+        // Also: if it's absent from CreateInput entirely, it's likely computed/generated.
+        let fieldHasDefault = null;
+        if (createInputRequiredFields !== null) {
+            if (fieldIsNotNull && !createInputRequiredFields.has(field.name)) {
+                fieldHasDefault = true;
+            }
+            else {
+                fieldHasDefault = false;
+            }
+        }
         // Include scalar, enum, and other non-relation fields
+        const fieldDescription = commentsEnabled ? stripSmartComments(field.description) : undefined;
         fields.push({
             name: field.name,
+            ...(fieldDescription ? { description: fieldDescription } : {}),
             type: convertToCleanFieldType(field.type),
+            isNotNull: fieldIsNotNull,
+            hasDefault: fieldHasDefault,
         });
     }
     return fields;
 }
+/**
+ * Build a set of field names that are required (NON_NULL) in the CreateXxxInput type.
+ * Returns null if the CreateXxxInput type doesn't exist (no create mutation).
+ */
+function buildCreateInputRequiredFieldSet(entityName, typeMap) {
+    const createInputName = `Create${entityName}Input`;
+    const createInput = typeMap.get(createInputName);
+    if (!createInput?.inputFields)
+        return null;
+    // The CreateXxxInput typically has a single field like { user: UserInput! }
+    // We need to look inside the actual entity input type (e.g., UserInput)
+    const entityInputName = `${entityName}Input`;
+    const entityInput = typeMap.get(entityInputName);
+    if (!entityInput?.inputFields)
+        return null;
+    const requiredFields = new Set();
+    for (const inputField of entityInput.inputFields) {
+        if (isNonNull(inputField.type)) {
+            requiredFields.add(inputField.name);
+        }
+    }
+    return requiredFields;
+}
 /**
  * Check if a type name is an entity type (has a corresponding Connection)
  */

package/esm/core/pipeline/index.js

@@ -23,7 +23,8 @@ export async function runCodegenPipeline(options) {
     const { introspection } = await source.fetch();
     // 2. Infer tables from introspection (replaces _meta)
     log('Inferring table metadata from schema...');
-    let tables = inferTablesFromIntrospection(introspection);
+    const commentsEnabled = config.codegen?.comments !== false;
+    let tables = inferTablesFromIntrospection(introspection, { comments: commentsEnabled });
     const totalTables = tables.length;
     log(`  Found ${totalTables} tables`);
     // 3. Filter tables by config (combine exclude and systemExclude)

package/esm/generators/field-selector.js

@@ -1,3 +1,28 @@
+const relationalFieldSetCache = new WeakMap();
+function getRelationalFieldSet(table) {
+    const cached = relationalFieldSetCache.get(table);
+    if (cached)
+        return cached;
+    const set = new Set();
+    for (const rel of table.relations.belongsTo) {
+        if (rel.fieldName)
+            set.add(rel.fieldName);
+    }
+    for (const rel of table.relations.hasOne) {
+        if (rel.fieldName)
+            set.add(rel.fieldName);
+    }
+    for (const rel of table.relations.hasMany) {
+        if (rel.fieldName)
+            set.add(rel.fieldName);
+    }
+    for (const rel of table.relations.manyToMany) {
+        if (rel.fieldName)
+            set.add(rel.fieldName);
+    }
+    relationalFieldSetCache.set(table, set);
+    return set;
+}
 /**
  * Convert simplified field selection to QueryBuilder SelectionOptions
  */
@@ -154,11 +179,7 @@ function getNonRelationalFields(table) {
  * Check if a field is relational using table metadata
  */
 export function isRelationalField(fieldName, table) {
-    const { belongsTo, hasOne, hasMany, manyToMany } = table.relations;
-    return (belongsTo.some((rel) => rel.fieldName === fieldName) ||
-        hasOne.some((rel) => rel.fieldName === fieldName) ||
-        hasMany.some((rel) => rel.fieldName === fieldName) ||
-        manyToMany.some((rel) => rel.fieldName === fieldName));
+    return getRelationalFieldSet(table).has(fieldName);
 }
 /**
  * Get scalar fields for a related table to include in relation queries
@@ -227,16 +248,20 @@ function getRelatedTableScalarFields(relationField, table, allTables) {
         'createdAt',
         'updatedAt',
     ];
+    const scalarFieldSet = new Set(scalarFields);
+    // Use Set for O(1) duplicate checking
+    const includedSet = new Set();
     const included = [];
     const push = (fieldName) => {
         if (!fieldName)
             return;
-        if (!scalarFields.includes(fieldName))
+        if (!scalarFieldSet.has(fieldName))
             return;
-        if (included.includes(fieldName))
+        if (includedSet.has(fieldName))
             return;
         if (included.length >= MAX_RELATED_FIELDS)
             return;
+        includedSet.add(fieldName);
         included.push(fieldName);
     };
     // Always try to include stable identifiers first.

package/esm/generators/mutations.d.ts

@@ -17,8 +17,7 @@ export declare function buildPostGraphileCreate(table: CleanTable, _allTables: C
 export declare function buildPostGraphileUpdate(table: CleanTable, _allTables: CleanTable[], _options?: MutationOptions): TypedDocumentString<Record<string, unknown>, {
     input: {
         id: string | number;
-        patch: Record<string, unknown>;
-    };
+    } & Record<string, unknown>;
 }>;
 /**
  * Build PostGraphile-style DELETE mutation

package/esm/generators/mutations.js

@@ -4,10 +4,10 @@
  */
 import * as t from 'gql-ast';
 import { OperationTypeNode, print } from 'graphql';
-import { camelize } from 'inflekt';
 import { TypedDocumentString } from '../client/typed-document';
 import { getCustomAstForCleanField, requiresSubfieldSelection, } from '../core/custom-ast';
 import { isRelationalField } from './field-selector';
+import { toCamelCaseSingular, toCreateInputTypeName, toCreateMutationName, toDeleteInputTypeName, toDeleteMutationName, toUpdateInputTypeName, toUpdateMutationName, } from './naming-helpers';
 /**
  * Generate field selections for PostGraphile mutations using custom AST logic
  * This handles both scalar fields and complex types that require subfield selections
@@ -31,14 +31,15 @@ function generateFieldSelections(table) {
  * PostGraphile expects: mutation { createTableName(input: { tableName: TableNameInput! }) { tableName { ... } } }
  */
 export function buildPostGraphileCreate(table, _allTables, _options = {}) {
-    const mutationName = `create${table.name}`;
-    const singularName = camelize(table.name, true);
+    const mutationName = toCreateMutationName(table.name, table);
+    const singularName = toCamelCaseSingular(table.name, table);
+    const inputTypeName = toCreateInputTypeName(table.name, table);
     // Create the variable definition for $input
     const variableDefinitions = [
         t.variableDefinition({
             variable: t.variable({ name: 'input' }),
             type: t.nonNullType({
-                type: t.namedType({ type: `Create${table.name}Input` }),
+                type: t.namedType({ type: inputTypeName }),
             }),
         }),
     ];
@@ -90,14 +91,15 @@ export function buildPostGraphileCreate(table, _allTables, _options = {}) {
  * PostGraphile expects: mutation { updateTableName(input: { id: UUID!, patch: TableNamePatch! }) { tableName { ... } } }
  */
 export function buildPostGraphileUpdate(table, _allTables, _options = {}) {
-    const mutationName = `update${table.name}`;
-    const singularName = camelize(table.name, true);
+    const mutationName = toUpdateMutationName(table.name, table);
+    const singularName = toCamelCaseSingular(table.name, table);
+    const inputTypeName = toUpdateInputTypeName(table.name);
     // Create the variable definition for $input
     const variableDefinitions = [
         t.variableDefinition({
             variable: t.variable({ name: 'input' }),
             type: t.nonNullType({
-                type: t.namedType({ type: `Update${table.name}Input` }),
+                type: t.namedType({ type: inputTypeName }),
             }),
         }),
     ];
@@ -149,13 +151,14 @@ export function buildPostGraphileUpdate(table, _allTables, _options = {}) {
  * PostGraphile expects: mutation { deleteTableName(input: { id: UUID! }) { clientMutationId } }
  */
 export function buildPostGraphileDelete(table, _allTables, _options = {}) {
-    const mutationName = `delete${table.name}`;
+    const mutationName = toDeleteMutationName(table.name, table);
+    const inputTypeName = toDeleteInputTypeName(table.name);
     // Create the variable definition for $input
     const variableDefinitions = [
         t.variableDefinition({
             variable: t.variable({ name: 'input' }),
             type: t.nonNullType({
-                type: t.namedType({ type: `Delete${table.name}Input` }),
+                type: t.namedType({ type: inputTypeName }),
             }),
         }),
     ];

package/esm/generators/naming-helpers.d.ts

@@ -0,0 +1,48 @@
+import type { CleanTable } from '../types/schema';
+/**
+ * Safely normalise a server-provided inflection value.
+ * Returns `null` for null, undefined, or whitespace-only strings.
+ */
+export declare function normalizeInflectionValue(value: string | null | undefined): string | null;
+/**
+ * Convert PascalCase table name to camelCase plural for GraphQL queries.
+ * Prefers server-provided `table.query.all` / `table.inflection.allRows`
+ * when available, with guards against naive pluralisation drift and
+ * missing camelCase boundaries.
+ *
+ * Example: "ActionGoal" -> "actionGoals", "User" -> "users", "Person" -> "people"
+ */
+export declare function toCamelCasePlural(tableName: string, table?: CleanTable | null): string;
+/**
+ * Convert PascalCase table name to camelCase singular field name.
+ * Prefers server-provided names when available.
+ */
+export declare function toCamelCaseSingular(tableName: string, table?: CleanTable | null): string;
+export declare function toCreateMutationName(tableName: string, table?: CleanTable | null): string;
+export declare function toUpdateMutationName(tableName: string, table?: CleanTable | null): string;
+export declare function toDeleteMutationName(tableName: string, table?: CleanTable | null): string;
+export declare function toCreateInputTypeName(tableName: string, table?: CleanTable | null): string;
+export declare function toUpdateInputTypeName(tableName: string): string;
+export declare function toDeleteInputTypeName(tableName: string): string;
+export declare function toFilterTypeName(tableName: string, table?: CleanTable | null): string;
+/**
+ * Resolve PostGraphile patch field name.
+ * In v5 this is typically entity-specific: e.g. "userPatch", "contactPatch".
+ * Prefers the value discovered from the schema (`table.query.patchFieldName`
+ * or `table.inflection.patchField`), falls back to `${singularName}Patch`.
+ */
+export declare function toPatchFieldName(tableName: string, table?: CleanTable | null): string;
+/**
+ * Convert camelCase field name to SCREAMING_SNAKE_CASE for PostGraphile
+ * orderBy enums.
+ *
+ * "displayName" -> "DISPLAY_NAME_ASC"
+ * "createdAt"   -> "CREATED_AT_DESC"
+ * "id"          -> "ID_ASC"
+ */
+export declare function toOrderByEnumValue(fieldName: string, direction: 'asc' | 'desc'): string;
+/**
+ * Generate the PostGraphile OrderBy enum type name for a table.
+ * Prefers server-provided `table.inflection.orderByType` when available.
+ */
+export declare function toOrderByTypeName(tableName: string, table?: CleanTable | null): string;

package/esm/generators/naming-helpers.js

@@ -0,0 +1,154 @@
+/**
+ * Server-aware naming helpers for GraphQL query/mutation generation.
+ *
+ * These functions prefer names already discovered from the GraphQL schema
+ * (stored on `table.query` and `table.inflection` by `infer-tables.ts`)
+ * and fall back to local inflection when introspection data is unavailable.
+ *
+ * Back-ported from Dashboard's `packages/data/src/query-generator.ts`.
+ */
+import { camelize, pluralize } from 'inflekt';
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+/**
+ * Safely normalise a server-provided inflection value.
+ * Returns `null` for null, undefined, or whitespace-only strings.
+ */
+export function normalizeInflectionValue(value) {
+    if (typeof value !== 'string')
+        return null;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+// ---------------------------------------------------------------------------
+// Plural / Singular
+// ---------------------------------------------------------------------------
+/**
+ * Convert PascalCase table name to camelCase plural for GraphQL queries.
+ * Prefers server-provided `table.query.all` / `table.inflection.allRows`
+ * when available, with guards against naive pluralisation drift and
+ * missing camelCase boundaries.
+ *
+ * Example: "ActionGoal" -> "actionGoals", "User" -> "users", "Person" -> "people"
+ */
+export function toCamelCasePlural(tableName, table) {
+    const singular = camelize(tableName, true);
+    const inflectedPlural = pluralize(singular);
+    const serverPluralCandidates = [
+        table?.query?.all,
+        table?.inflection?.allRows,
+    ];
+    for (const candidateRaw of serverPluralCandidates) {
+        const candidate = normalizeInflectionValue(candidateRaw);
+        if (!candidate)
+            continue;
+        // Guard against known fallback drift:
+        // 1. Naive pluralisation: "activitys" instead of "activities"
+        const isNaivePlural = candidate === `${singular}s` && candidate !== inflectedPlural;
+        // 2. Missing camelCase boundaries: "deliveryzones" instead of "deliveryZones"
+        const isMiscased = candidate !== inflectedPlural &&
+            candidate.toLowerCase() === inflectedPlural.toLowerCase();
+        if (isNaivePlural || isMiscased)
+            continue;
+        return candidate;
+    }
+    return inflectedPlural;
+}
+/**
+ * Convert PascalCase table name to camelCase singular field name.
+ * Prefers server-provided names when available.
+ */
+export function toCamelCaseSingular(tableName, table) {
+    const localSingular = camelize(tableName, true);
+    for (const candidateRaw of [
+        table?.query?.one,
+        table?.inflection?.tableFieldName,
+    ]) {
+        const candidate = normalizeInflectionValue(candidateRaw);
+        if (!candidate)
+            continue;
+        // Reject miscased versions: "deliveryzone" vs "deliveryZone"
+        if (candidate !== localSingular &&
+            candidate.toLowerCase() === localSingular.toLowerCase())
+            continue;
+        return candidate;
+    }
+    return localSingular;
+}
+// ---------------------------------------------------------------------------
+// Mutation names
+// ---------------------------------------------------------------------------
+export function toCreateMutationName(tableName, table) {
+    return (normalizeInflectionValue(table?.query?.create) ?? `create${tableName}`);
+}
+export function toUpdateMutationName(tableName, table) {
+    return (normalizeInflectionValue(table?.query?.update) ?? `update${tableName}`);
+}
+export function toDeleteMutationName(tableName, table) {
+    return (normalizeInflectionValue(table?.query?.delete) ?? `delete${tableName}`);
+}
+// ---------------------------------------------------------------------------
+// Input / type names
+// ---------------------------------------------------------------------------
+export function toCreateInputTypeName(tableName, table) {
+    return (normalizeInflectionValue(table?.inflection?.createInputType) ??
+        `Create${tableName}Input`);
+}
+export function toUpdateInputTypeName(tableName) {
+    return `Update${tableName}Input`;
+}
+export function toDeleteInputTypeName(tableName) {
+    return `Delete${tableName}Input`;
+}
+export function toFilterTypeName(tableName, table) {
+    return (normalizeInflectionValue(table?.inflection?.filterType) ??
+        `${tableName}Filter`);
+}
+// ---------------------------------------------------------------------------
+// Patch field name
+// ---------------------------------------------------------------------------
+/**
+ * Resolve PostGraphile patch field name.
+ * In v5 this is typically entity-specific: e.g. "userPatch", "contactPatch".
+ * Prefers the value discovered from the schema (`table.query.patchFieldName`
+ * or `table.inflection.patchField`), falls back to `${singularName}Patch`.
+ */
+export function toPatchFieldName(tableName, table) {
+    // First check the patch field name discovered from UpdateXxxInput
+    const introspectedPatch = normalizeInflectionValue(table?.query?.patchFieldName);
+    if (introspectedPatch)
+        return introspectedPatch;
+    // Then check the inflection table
+    const explicitPatchField = normalizeInflectionValue(table?.inflection?.patchField);
+    if (explicitPatchField)
+        return explicitPatchField;
+    return `${toCamelCaseSingular(tableName, table)}Patch`;
+}
+// ---------------------------------------------------------------------------
+// OrderBy helpers
+// ---------------------------------------------------------------------------
+/**
+ * Convert camelCase field name to SCREAMING_SNAKE_CASE for PostGraphile
+ * orderBy enums.
+ *
+ * "displayName" -> "DISPLAY_NAME_ASC"
+ * "createdAt"   -> "CREATED_AT_DESC"
+ * "id"          -> "ID_ASC"
+ */
+export function toOrderByEnumValue(fieldName, direction) {
+    const screaming = fieldName
+        .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
+        .toUpperCase();
+    return `${screaming}_${direction.toUpperCase()}`;
+}
+/**
+ * Generate the PostGraphile OrderBy enum type name for a table.
+ * Prefers server-provided `table.inflection.orderByType` when available.
+ */
+export function toOrderByTypeName(tableName, table) {
+    if (table?.inflection?.orderByType)
+        return table.inflection.orderByType;
+    const plural = toCamelCasePlural(tableName, table);
+    return `${plural.charAt(0).toUpperCase() + plural.slice(1)}OrderBy`;
+}

package/esm/generators/select.d.ts

@@ -3,18 +3,7 @@ import { QueryBuilder } from '../core/query-builder';
 import type { IntrospectionSchema, MetaObject } from '../core/types';
 import type { QueryOptions } from '../types/query';
 import type { CleanTable } from '../types/schema';
-/**
- * Convert PascalCase table name to camelCase plural for GraphQL queries
- * Uses the inflection library for proper pluralization
- * Example: "ActionGoal" -> "actionGoals", "User" -> "users", "Person" -> "people"
- */
-export declare function toCamelCasePlural(tableName: string): string;
-/**
- * Generate the PostGraphile OrderBy enum type name for a table
- * PostGraphile uses pluralized PascalCase: "Product" -> "ProductsOrderBy"
- * Example: "Product" -> "ProductsOrderBy", "Person" -> "PeopleOrderBy"
- */
-export declare function toOrderByTypeName(tableName: string): string;
+export { toCamelCasePlural, toOrderByTypeName } from './naming-helpers';
 /**
  * Convert CleanTable to MetaObject format for QueryBuilder
  */