@constructive-io/graphql-codegen 4.5.3 → 4.6.1

package/generators/naming-helpers.js

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeInflectionValue = normalizeInflectionValue;
+exports.toCamelCasePlural = toCamelCasePlural;
+exports.toCamelCaseSingular = toCamelCaseSingular;
+exports.toCreateMutationName = toCreateMutationName;
+exports.toUpdateMutationName = toUpdateMutationName;
+exports.toDeleteMutationName = toDeleteMutationName;
+exports.toCreateInputTypeName = toCreateInputTypeName;
+exports.toUpdateInputTypeName = toUpdateInputTypeName;
+exports.toDeleteInputTypeName = toDeleteInputTypeName;
+exports.toFilterTypeName = toFilterTypeName;
+exports.toPatchFieldName = toPatchFieldName;
+exports.toOrderByEnumValue = toOrderByEnumValue;
+exports.toOrderByTypeName = toOrderByTypeName;
+/**
+ * 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`.
+ */
+const inflekt_1 = require("inflekt");
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+/**
+ * Safely normalise a server-provided inflection value.
+ * Returns `null` for null, undefined, or whitespace-only strings.
+ */
+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"
+ */
+function toCamelCasePlural(tableName, table) {
+    const singular = (0, inflekt_1.camelize)(tableName, true);
+    const inflectedPlural = (0, inflekt_1.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.
+ */
+function toCamelCaseSingular(tableName, table) {
+    const localSingular = (0, inflekt_1.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
+// ---------------------------------------------------------------------------
+function toCreateMutationName(tableName, table) {
+    return (normalizeInflectionValue(table?.query?.create) ?? `create${tableName}`);
+}
+function toUpdateMutationName(tableName, table) {
+    return (normalizeInflectionValue(table?.query?.update) ?? `update${tableName}`);
+}
+function toDeleteMutationName(tableName, table) {
+    return (normalizeInflectionValue(table?.query?.delete) ?? `delete${tableName}`);
+}
+// ---------------------------------------------------------------------------
+// Input / type names
+// ---------------------------------------------------------------------------
+function toCreateInputTypeName(tableName, table) {
+    return (normalizeInflectionValue(table?.inflection?.createInputType) ??
+        `Create${tableName}Input`);
+}
+function toUpdateInputTypeName(tableName) {
+    return `Update${tableName}Input`;
+}
+function toDeleteInputTypeName(tableName) {
+    return `Delete${tableName}Input`;
+}
+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`.
+ */
+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"
+ */
+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.
+ */
+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/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
  */

package/generators/select.js

@@ -33,8 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.toCamelCasePlural = toCamelCasePlural;
-exports.toOrderByTypeName = toOrderByTypeName;
+exports.toOrderByTypeName = exports.toCamelCasePlural = void 0;
 exports.cleanTableToMetaObject = cleanTableToMetaObject;
 exports.generateIntrospectionSchema = generateIntrospectionSchema;
 exports.createASTQueryBuilder = createASTQueryBuilder;
@@ -47,32 +46,15 @@ exports.buildCount = buildCount;
  */
 const t = __importStar(require("gql-ast"));
 const graphql_1 = require("graphql");
-const inflekt_1 = require("inflekt");
 const typed_document_1 = require("../client/typed-document");
 const custom_ast_1 = require("../core/custom-ast");
 const query_builder_1 = require("../core/query-builder");
 const field_selector_1 = require("./field-selector");
-/**
- * Convert PascalCase table name to camelCase plural for GraphQL queries
- * Uses the inflection library for proper pluralization
- * Example: "ActionGoal" -> "actionGoals", "User" -> "users", "Person" -> "people"
- */
-function toCamelCasePlural(tableName) {
-    // First convert to camelCase (lowercase first letter)
-    const camelCase = (0, inflekt_1.camelize)(tableName, true);
-    // Then pluralize properly
-    return (0, inflekt_1.pluralize)(camelCase);
-}
-/**
- * Generate the PostGraphile OrderBy enum type name for a table
- * PostGraphile uses pluralized PascalCase: "Product" -> "ProductsOrderBy"
- * Example: "Product" -> "ProductsOrderBy", "Person" -> "PeopleOrderBy"
- */
-function toOrderByTypeName(tableName) {
-    const plural = toCamelCasePlural(tableName); // "products", "people"
-    // Capitalize first letter for PascalCase
-    return `${plural.charAt(0).toUpperCase() + plural.slice(1)}OrderBy`;
-}
+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
  */
@@ -133,7 +115,7 @@ function generateIntrospectionSchema(tables) {
     const schema = {};
     for (const table of tables) {
         const modelName = table.name;
-        const pluralName = toCamelCasePlural(modelName);
+        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
@@ -144,15 +126,23 @@ function generateIntrospectionSchema(tables) {
             properties: convertFieldsToProperties(table.fields),
         };
         // Add getOne query (by ID)
-        const singularName = (0, inflekt_1.camelize)(modelName, true);
+        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[`create${modelName}`] = {
+        schema[createMutationName] = {
             qtype: 'mutation',
             mutationType: 'create',
             model: modelName,
@@ -160,13 +150,13 @@ function generateIntrospectionSchema(tables) {
             properties: {
                 input: {
                     name: 'input',
-                    type: `Create${modelName}Input`,
+                    type: createInputType,
                     isNotNull: true,
                     isArray: false,
                     isArrayNotNull: false,
                     properties: {
-                        [(0, inflekt_1.camelize)(modelName, true)]: {
-                            name: (0, inflekt_1.camelize)(modelName, true),
+                        [singularName]: {
+                            name: singularName,
                             type: `${modelName}Input`,
                             isNotNull: true,
                             isArray: false,
@@ -178,7 +168,7 @@ function generateIntrospectionSchema(tables) {
             },
         };
         // Add update mutation
-        schema[`update${modelName}`] = {
+        schema[updateMutationName] = {
             qtype: 'mutation',
             mutationType: 'patch',
             model: modelName,
@@ -186,14 +176,14 @@ function generateIntrospectionSchema(tables) {
             properties: {
                 input: {
                     name: 'input',
-                    type: `Update${modelName}Input`,
+                    type: (0, naming_helpers_1.toUpdateInputTypeName)(modelName),
                     isNotNull: true,
                     isArray: false,
                     isArrayNotNull: false,
                     properties: {
-                        patch: {
-                            name: 'patch',
-                            type: `${modelName}Patch`,
+                        [patchFieldName]: {
+                            name: patchFieldName,
+                            type: patchType,
                             isNotNull: true,
                             isArray: false,
                             isArrayNotNull: false,
@@ -204,7 +194,7 @@ function generateIntrospectionSchema(tables) {
             },
         };
         // Add delete mutation
-        schema[`delete${modelName}`] = {
+        schema[deleteMutationName] = {
             qtype: 'mutation',
             mutationType: 'delete',
             model: modelName,
@@ -212,7 +202,7 @@ function generateIntrospectionSchema(tables) {
             properties: {
                 input: {
                     name: 'input',
-                    type: `Delete${modelName}Input`,
+                    type: (0, naming_helpers_1.toDeleteInputTypeName)(modelName),
                     isNotNull: true,
                     isArray: false,
                     isArrayNotNull: false,
@@ -282,7 +272,7 @@ 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);
+    const queryString = generateSelectQueryAST(table, tableList, selection, options, options.relationFieldMap);
     return new typed_document_1.TypedDocumentString(queryString, {});
 }
 /**
@@ -305,10 +295,10 @@ function convertFieldSelectionToSelectionOptions(table, allTables, options) {
 /**
  * Generate SELECT query AST directly from CleanTable
  */
-function generateSelectQueryAST(table, allTables, selection, options) {
-    const pluralName = toCamelCasePlural(table.name);
+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);
+    const fieldSelections = generateFieldSelectionsFromOptions(table, allTables, selection, relationFieldMap);
     // Build the query AST
     const variableDefinitions = [];
     const queryArgs = [];
@@ -359,7 +349,7 @@ function generateSelectQueryAST(table, allTables, selection, options) {
     if (options.where) {
         variableDefinitions.push(t.variableDefinition({
             variable: t.variable({ name: 'filter' }),
-            type: t.namedType({ type: `${table.name}Filter` }),
+            type: t.namedType({ type: (0, naming_helpers_1.toFilterTypeName)(table.name, table) }),
         }));
         queryArgs.push(t.argument({
             name: 'filter',
@@ -373,7 +363,7 @@ function generateSelectQueryAST(table, allTables, selection, options) {
             // PostGraphile expects [ProductsOrderBy!] - list of non-null enum values
             type: t.listType({
                 type: t.nonNullType({
-                    type: t.namedType({ type: toOrderByTypeName(table.name) }),
+                    type: t.namedType({ type: (0, naming_helpers_1.toOrderByTypeName)(table.name, table) }),
                 }),
             }),
         }));
@@ -433,7 +423,7 @@ function generateSelectQueryAST(table, allTables, selection, options) {
 /**
  * Generate field selections from SelectionOptions
  */
-function generateFieldSelectionsFromOptions(table, allTables, selection) {
+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.)
@@ -452,6 +442,10 @@ function generateFieldSelectionsFromOptions(table, allTables, selection) {
     }
     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);
@@ -461,7 +455,7 @@ function generateFieldSelectionsFromOptions(table, allTables, selection) {
             }
             else {
                 // Simple field selection for scalar fields
-                fieldSelections.push(t.field({ name: fieldName }));
+                fieldSelections.push(createFieldSelectionNode(resolvedField.name, resolvedField.alias));
             }
         }
         else if (typeof fieldOptions === 'object' && fieldOptions.select) {
@@ -488,41 +482,73 @@ function generateFieldSelectionsFromOptions(table, allTables, selection) {
             if (relationInfo &&
                 (relationInfo.type === 'hasMany' || relationInfo.type === 'manyToMany')) {
                 // For hasMany/manyToMany relations, wrap selections in nodes { ... }
-                fieldSelections.push(t.field({
-                    name: fieldName,
-                    args: [
-                        t.argument({
-                            name: 'first',
-                            value: t.intValue({
-                                value: DEFAULT_NESTED_RELATION_FIRST.toString(),
+                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,
                             }),
                         }),
                     ],
-                    selectionSet: t.selectionSet({
-                        selections: [
-                            t.field({
-                                name: 'nodes',
-                                selectionSet: t.selectionSet({
-                                    selections: nestedSelections,
-                                }),
-                            }),
-                        ],
-                    }),
-                }));
+                })));
             }
             else {
                 // For belongsTo/hasOne relations, use direct selection
-                fieldSelections.push(t.field({
-                    name: fieldName,
-                    selectionSet: t.selectionSet({
-                        selections: nestedSelections,
-                    }),
-                }));
+                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
  */
@@ -592,7 +618,7 @@ function findRelatedTable(relationField, table, allTables) {
  * Generate FindOne query AST directly from CleanTable
  */
 function generateFindOneQueryAST(table) {
-    const singularName = (0, inflekt_1.camelize)(table.name, true);
+    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))
@@ -644,7 +670,7 @@ function generateFindOneQueryAST(table) {
  * Generate Count query AST directly from CleanTable
  */
 function generateCountQueryAST(table) {
-    const pluralName = toCamelCasePlural(table.name);
+    const pluralName = (0, naming_helpers_1.toCamelCasePlural)(table.name, table);
     const ast = t.document({
         definitions: [
             t.operationDefinition({
@@ -653,7 +679,7 @@ function generateCountQueryAST(table) {
                 variableDefinitions: [
                     t.variableDefinition({
                         variable: t.variable({ name: 'filter' }),
-                        type: t.namedType({ type: `${table.name}Filter` }),
+                        type: t.namedType({ type: (0, naming_helpers_1.toFilterTypeName)(table.name, table) }),
                     }),
                 ],
                 selectionSet: t.selectionSet({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@constructive-io/graphql-codegen",
-  "version": "4.5.3",
+  "version": "4.6.1",
   "description": "GraphQL SDK generator for Constructive databases with React Query hooks",
   "keywords": [
     "graphql",
@@ -58,12 +58,12 @@
     "@babel/types": "^7.28.6",
     "@constructive-io/graphql-types": "^3.1.1",
     "@inquirerer/utils": "^3.2.3",
-    "@pgpmjs/core": "^6.3.1",
+    "@pgpmjs/core": "^6.3.2",
     "ajv": "^8.17.1",
     "deepmerge": "^4.3.1",
     "find-and-require-package-json": "^0.9.0",
     "gql-ast": "^3.1.0",
-    "graphile-schema": "^1.2.3",
+    "graphile-schema": "^1.2.5",
     "graphql": "^16.9.0",
     "inflekt": "^0.3.1",
     "inquirerer": "^4.4.0",
@@ -72,8 +72,8 @@
     "oxfmt": "^0.26.0",
     "pg-cache": "^3.1.0",
     "pg-env": "^1.5.0",
-    "pgsql-client": "^3.2.2",
-    "pgsql-seed": "^2.2.2",
+    "pgsql-client": "^3.2.3",
+    "pgsql-seed": "^2.2.3",
     "undici": "^7.19.0"
   },
   "peerDependencies": {
@@ -100,5 +100,5 @@
     "tsx": "^4.21.0",
     "typescript": "^5.9.3"
   },
-  "gitHead": "0deec313ff9af77b02cb749be9ef34e236e8cab8"
+  "gitHead": "c9364ffbc4d4a6b1b3750f0a5e347a7290d8d4ce"
 }

package/types/config.d.ts

@@ -279,6 +279,12 @@ export interface GraphQLSDKConfigTarget {
     codegen?: {
         /** Skip 'query' field on mutation payloads (default: true) */
         skipQueryField?: boolean;
+        /**
+         * Include PostgreSQL COMMENT descriptions as JSDoc comments in generated code.
+         * PostGraphile smart comments and boilerplate descriptions are automatically stripped.
+         * @default true
+         */
+        comments?: boolean;
     };
     /**
      * Whether to generate ORM client

package/types/config.js

@@ -69,6 +69,7 @@ exports.DEFAULT_CONFIG = {
     },
     codegen: {
         skipQueryField: true,
+        comments: true,
     },
     orm: false,
     reactQuery: false,

package/types/query.d.ts

@@ -39,6 +39,15 @@ export interface QueryOptions {
     orderBy?: OrderByItem[];
     /** Field selection options */
     fieldSelection?: FieldSelection;
+    /**
+     * Maps requested relation field names to actual schema field names (or null to omit).
+     * When the mapped name differs from the key, a GraphQL alias is emitted so the
+     * consumer sees a stable field name regardless of the server-side name.
+     *
+     * Example: `{ contact: 'contactByOwnerId' }` emits `contact: contactByOwnerId { … }`
+     * Pass `null` to suppress a relation entirely: `{ internalNotes: null }`
+     */
+    relationFieldMap?: Record<string, string | null>;
     /** Include pageInfo in response */
     includePageInfo?: boolean;
 }

package/types/schema.d.ts

@@ -7,6 +7,8 @@
  */
 export interface CleanTable {
     name: string;
+    /** Description from PostgreSQL COMMENT (smart comments stripped) */
+    description?: string;
     fields: CleanField[];
     relations: CleanRelations;
     /** PostGraphile inflection rules for this table */
@@ -103,7 +105,13 @@ export interface ForeignKeyConstraint extends ConstraintInfo {
  */
 export interface CleanField {
     name: string;
+    /** Description from PostgreSQL COMMENT (smart comments stripped) */
+    description?: string;
     type: CleanFieldType;
+    /** Whether the column has a NOT NULL constraint (inferred from NON_NULL wrapper on entity type field) */
+    isNotNull?: boolean | null;
+    /** Whether the column has a DEFAULT value (inferred by comparing entity vs CreateInput field nullability) */
+    hasDefault?: boolean | null;
 }
 /**
  * Field type information from PostGraphile introspection