refactor(codegen): extract getSelectableScalarFields into shared utils

Move resolveInnerInputType, getWritableFieldNames, and new
getSelectableScalarFields helper into utils.ts as shared abstractions.

These helpers centralize the concept of 'real database columns vs
computed plugin fields' so any generator (CLI, docs, hooks, ORM) can
reuse them. getSelectableScalarFields composes getScalarFields +
getWritableFieldNames into a single call.

Remove duplicated resolveInnerInputType and getWritableFieldNames from
table-command-generator.ts — it now imports them from utils.

Author: pyramation

graphql/codegen/src/core/codegen/cli/table-command-generator.ts

@@ -6,7 +6,10 @@ import {
   getGeneratedFileHeader,
   getPrimaryKeyInfo,
   getScalarFields,
+  getSelectableScalarFields,
   getTableNames,
+  getWritableFieldNames,
+  resolveInnerInputType,
   ucFirst,
   lcFirst,
   getCreateInputTypeName,
@@ -151,10 +154,7 @@ function buildFieldSchemaObject(table: CleanTable): t.ObjectExpression {
 }
 
 function buildSelectObject(table: CleanTable, typeRegistry?: TypeRegistry): t.ObjectExpression {
-  const writableFields = getWritableFieldNames(table, typeRegistry);
-  const fields = getScalarFields(table).filter(
-    (f) => writableFields === null || writableFields.has(f.name),
-  );
+  const fields = getSelectableScalarFields(table, typeRegistry);
   return t.objectExpression(
     fields.map((f) =>
       t.objectProperty(t.identifier(f.name), t.booleanLiteral(true)),
@@ -426,38 +426,6 @@ function buildGetHandler(table: CleanTable, targetName?: string, typeRegistry?:
   );
 }
 
-/**
- * Get the set of field names that have defaults in the create input type.
- * Looks up the CreateXInput -> inner input type (e.g. DatabaseInput) in the
- * TypeRegistry and checks each field's defaultValue from introspection.
- */
-/**
- * Resolve the inner input type from a CreateXInput or UpdateXInput type.
- * The CreateXInput has an inner field (e.g. "database" of type DatabaseInput)
- * that contains the actual field definitions.
- */
-export function resolveInnerInputType(
-  inputTypeName: string,
-  typeRegistry: TypeRegistry,
-): { name: string; fields: Set<string> } | null {
-  const inputType = typeRegistry.get(inputTypeName);
-  if (!inputType?.inputFields) return null;
-
-  for (const inputField of inputType.inputFields) {
-    const innerTypeName = inputField.type.name
-      || inputField.type.ofType?.name
-      || inputField.type.ofType?.ofType?.name;
-    if (!innerTypeName) continue;
-
-    const innerType = typeRegistry.get(innerTypeName);
-    if (!innerType?.inputFields) continue;
-
-    const fields = new Set(innerType.inputFields.map((f) => f.name));
-    return { name: innerTypeName, fields };
-  }
-  return null;
-}
-
 export function getFieldsWithDefaults(
   table: CleanTable,
   typeRegistry?: TypeRegistry,
@@ -484,22 +452,6 @@ export function getFieldsWithDefaults(
   return fieldsWithDefaults;
 }
 
-/**
- * Get the set of field names that actually exist in the create/update input type.
- * Fields not in this set (e.g. computed fields like searchTsvRank, hashUuid)
- * should be excluded from the data object in create/update handlers.
- */
-function getWritableFieldNames(
-  table: CleanTable,
-  typeRegistry?: TypeRegistry,
-): Set<string> | null {
-  if (!typeRegistry) return null;
-
-  const createInputTypeName = getCreateInputTypeName(table);
-  const resolved = resolveInnerInputType(createInputTypeName, typeRegistry);
-  return resolved?.fields ?? null;
-}
-
 function buildMutationHandler(
   table: CleanTable,
   operation: 'create' | 'update' | 'delete',

graphql/codegen/src/core/codegen/utils.ts

@@ -7,6 +7,7 @@ import type {
   CleanField,
   CleanFieldType,
   CleanTable,
+  TypeRegistry,
 } from '../../types/schema';
 import { scalarToFilterType, scalarToTsType } from './scalars';
 
@@ -335,6 +336,68 @@ export function getScalarFields(table: CleanTable): CleanField[] {
   return table.fields.filter((f) => !isRelationField(f.name, table));
 }
 
+/**
+ * Resolve the inner input type from a CreateXInput.
+ * PostGraphile create inputs wrap the actual field definitions in an inner type
+ * (e.g. CreateUserInput -> { user: UserInput }) — this resolves that inner type
+ * and returns the set of field names it contains.
+ */
+export function resolveInnerInputType(
+  inputTypeName: string,
+  typeRegistry: TypeRegistry,
+): { name: string; fields: Set<string> } | null {
+  const inputType = typeRegistry.get(inputTypeName);
+  if (!inputType?.inputFields) return null;
+
+  for (const inputField of inputType.inputFields) {
+    const innerTypeName = inputField.type.name
+      || inputField.type.ofType?.name
+      || inputField.type.ofType?.ofType?.name;
+    if (!innerTypeName) continue;
+
+    const innerType = typeRegistry.get(innerTypeName);
+    if (!innerType?.inputFields) continue;
+
+    const fields = new Set(innerType.inputFields.map((f) => f.name));
+    return { name: innerTypeName, fields };
+  }
+  return null;
+}
+
+/**
+ * Get the set of field names that actually exist in the create input type.
+ * Fields not in this set (e.g. computed fields like searchTsvRank, hashUuid)
+ * are plugin-added computed fields that don't correspond to real database columns.
+ * Returns null when no typeRegistry is provided (caller should treat as "no filtering").
+ */
+export function getWritableFieldNames(
+  table: CleanTable,
+  typeRegistry?: TypeRegistry,
+): Set<string> | null {
+  if (!typeRegistry) return null;
+
+  const createInputTypeName = getCreateInputTypeName(table);
+  const resolved = resolveInnerInputType(createInputTypeName, typeRegistry);
+  return resolved?.fields ?? null;
+}
+
+/**
+ * Get scalar fields that represent actual database columns (not computed/plugin-added).
+ * When a TypeRegistry is provided, filters out fields that don't exist in the
+ * create input type — these are computed fields added by plugins (e.g. search scores,
+ * hash UUIDs) that aren't real columns and shouldn't appear in default selections.
+ * Without a TypeRegistry, falls back to all scalar fields.
+ */
+export function getSelectableScalarFields(
+  table: CleanTable,
+  typeRegistry?: TypeRegistry,
+): CleanField[] {
+  const writableFields = getWritableFieldNames(table, typeRegistry);
+  return getScalarFields(table).filter(
+    (f) => writableFields === null || writableFields.has(f.name),
+  );
+}
+
 /**
  * Primary key field information
  */