@constructive-io/graphql-codegen 4.5.3 → 4.6.1

package/esm/generators/select.js

@@ -3,33 +3,14 @@
  * Uses AST-based approach for all query generation
  */
 import * as t from 'gql-ast';
-import { OperationTypeNode, print } from 'graphql';
-import { camelize, pluralize } from 'inflekt';
+import { Kind, OperationTypeNode, print } from 'graphql';
 import { TypedDocumentString } from '../client/typed-document';
 import { getCustomAstForCleanField, requiresSubfieldSelection, } from '../core/custom-ast';
 import { QueryBuilder } from '../core/query-builder';
 import { convertToSelectionOptions, isRelationalField } from './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"
- */
-export function toCamelCasePlural(tableName) {
-    // First convert to camelCase (lowercase first letter)
-    const camelCase = camelize(tableName, true);
-    // Then pluralize properly
-    return pluralize(camelCase);
-}
-/**
- * Generate the PostGraphile OrderBy enum type name for a table
- * PostGraphile uses pluralized PascalCase: "Product" -> "ProductsOrderBy"
- * Example: "Product" -> "ProductsOrderBy", "Person" -> "PeopleOrderBy"
- */
-export function toOrderByTypeName(tableName) {
-    const plural = toCamelCasePlural(tableName); // "products", "people"
-    // Capitalize first letter for PascalCase
-    return `${plural.charAt(0).toUpperCase() + plural.slice(1)}OrderBy`;
-}
+import { normalizeInflectionValue, toCamelCasePlural, toCamelCaseSingular, toCreateInputTypeName, toCreateMutationName, toDeleteInputTypeName, toDeleteMutationName, toFilterTypeName, toOrderByTypeName, toPatchFieldName, toUpdateInputTypeName, toUpdateMutationName, } from './naming-helpers';
+// Re-export naming helpers for backwards compatibility
+export { toCamelCasePlural, toOrderByTypeName } from './naming-helpers';
 /**
  * Convert CleanTable to MetaObject format for QueryBuilder
  */
@@ -90,7 +71,7 @@ export function generateIntrospectionSchema(tables) {
     const schema = {};
     for (const table of tables) {
         const modelName = table.name;
-        const pluralName = toCamelCasePlural(modelName);
+        const pluralName = toCamelCasePlural(modelName, table);
         // Basic field selection for the model
         const selection = table.fields.map((field) => field.name);
         // Add getMany query
@@ -101,15 +82,23 @@ export function generateIntrospectionSchema(tables) {
             properties: convertFieldsToProperties(table.fields),
         };
         // Add getOne query (by ID)
-        const singularName = camelize(modelName, true);
+        const singularName = toCamelCaseSingular(modelName, table);
         schema[singularName] = {
             qtype: 'getOne',
             model: modelName,
             selection,
             properties: convertFieldsToProperties(table.fields),
         };
+        // Derive entity-specific names from introspection data
+        const patchFieldName = toPatchFieldName(modelName, table);
+        const createMutationName = toCreateMutationName(modelName, table);
+        const updateMutationName = toUpdateMutationName(modelName, table);
+        const deleteMutationName = toDeleteMutationName(modelName, table);
+        const createInputType = toCreateInputTypeName(modelName, table);
+        const patchType = normalizeInflectionValue(table.inflection?.patchType) ??
+            `${modelName}Patch`;
         // Add create mutation
-        schema[`create${modelName}`] = {
+        schema[createMutationName] = {
             qtype: 'mutation',
             mutationType: 'create',
             model: modelName,
@@ -117,13 +106,13 @@ export function generateIntrospectionSchema(tables) {
             properties: {
                 input: {
                     name: 'input',
-                    type: `Create${modelName}Input`,
+                    type: createInputType,
                     isNotNull: true,
                     isArray: false,
                     isArrayNotNull: false,
                     properties: {
-                        [camelize(modelName, true)]: {
-                            name: camelize(modelName, true),
+                        [singularName]: {
+                            name: singularName,
                             type: `${modelName}Input`,
                             isNotNull: true,
                             isArray: false,
@@ -135,7 +124,7 @@ export function generateIntrospectionSchema(tables) {
             },
         };
         // Add update mutation
-        schema[`update${modelName}`] = {
+        schema[updateMutationName] = {
             qtype: 'mutation',
             mutationType: 'patch',
             model: modelName,
@@ -143,14 +132,14 @@ export function generateIntrospectionSchema(tables) {
             properties: {
                 input: {
                     name: 'input',
-                    type: `Update${modelName}Input`,
+                    type: 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,
@@ -161,7 +150,7 @@ export function generateIntrospectionSchema(tables) {
             },
         };
         // Add delete mutation
-        schema[`delete${modelName}`] = {
+        schema[deleteMutationName] = {
             qtype: 'mutation',
             mutationType: 'delete',
             model: modelName,
@@ -169,7 +158,7 @@ export function generateIntrospectionSchema(tables) {
             properties: {
                 input: {
                     name: 'input',
-                    type: `Delete${modelName}Input`,
+                    type: toDeleteInputTypeName(modelName),
                     isNotNull: true,
                     isArray: false,
                     isArrayNotNull: false,
@@ -239,7 +228,7 @@ export 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 TypedDocumentString(queryString, {});
 }
 /**
@@ -262,10 +251,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 = 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 = [];
@@ -316,7 +305,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: toFilterTypeName(table.name, table) }),
         }));
         queryArgs.push(t.argument({
             name: 'filter',
@@ -330,7 +319,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: toOrderByTypeName(table.name, table) }),
                 }),
             }),
         }));
@@ -390,7 +379,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.)
@@ -409,6 +398,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);
@@ -418,7 +411,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) {
@@ -445,41 +438,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: Kind.NAME,
+            value: alias,
+        },
+    };
+}
 /**
  * Get relation information for a field
  */
@@ -549,7 +574,7 @@ function findRelatedTable(relationField, table, allTables) {
  * Generate FindOne query AST directly from CleanTable
  */
 function generateFindOneQueryAST(table) {
-    const singularName = camelize(table.name, true);
+    const singularName = toCamelCaseSingular(table.name, table);
     // Generate field selections (include all non-relational fields, including complex types)
     const fieldSelections = table.fields
         .filter((field) => !isRelationalField(field.name, table))
@@ -601,7 +626,7 @@ function generateFindOneQueryAST(table) {
  * Generate Count query AST directly from CleanTable
  */
 function generateCountQueryAST(table) {
-    const pluralName = toCamelCasePlural(table.name);
+    const pluralName = toCamelCasePlural(table.name, table);
     const ast = t.document({
         definitions: [
             t.operationDefinition({
@@ -610,7 +635,7 @@ function generateCountQueryAST(table) {
                 variableDefinitions: [
                     t.variableDefinition({
                         variable: t.variable({ name: 'filter' }),
-                        type: t.namedType({ type: `${table.name}Filter` }),
+                        type: t.namedType({ type: toFilterTypeName(table.name, table) }),
                     }),
                 ],
                 selectionSet: t.selectionSet({

package/esm/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/esm/types/config.js

@@ -60,6 +60,7 @@ export const DEFAULT_CONFIG = {
     },
     codegen: {
         skipQueryField: true,
+        comments: true,
     },
     orm: false,
     reactQuery: false,

package/esm/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/esm/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

package/generators/field-selector.js

@@ -4,6 +4,31 @@ exports.convertToSelectionOptions = convertToSelectionOptions;
 exports.isRelationalField = isRelationalField;
 exports.getAvailableRelations = getAvailableRelations;
 exports.validateFieldSelection = validateFieldSelection;
+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
  */
@@ -160,11 +185,7 @@ function getNonRelationalFields(table) {
  * Check if a field is relational using table metadata
  */
 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
@@ -233,16 +254,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/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/generators/mutations.js

@@ -42,10 +42,10 @@ exports.buildPostGraphileDelete = buildPostGraphileDelete;
  */
 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 field_selector_1 = require("./field-selector");
+const naming_helpers_1 = require("./naming-helpers");
 /**
  * Generate field selections for PostGraphile mutations using custom AST logic
  * This handles both scalar fields and complex types that require subfield selections
@@ -69,14 +69,15 @@ function generateFieldSelections(table) {
  * PostGraphile expects: mutation { createTableName(input: { tableName: TableNameInput! }) { tableName { ... } } }
  */
 function buildPostGraphileCreate(table, _allTables, _options = {}) {
-    const mutationName = `create${table.name}`;
-    const singularName = (0, inflekt_1.camelize)(table.name, true);
+    const mutationName = (0, naming_helpers_1.toCreateMutationName)(table.name, table);
+    const singularName = (0, naming_helpers_1.toCamelCaseSingular)(table.name, table);
+    const inputTypeName = (0, naming_helpers_1.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 }),
             }),
         }),
     ];
@@ -128,14 +129,15 @@ function buildPostGraphileCreate(table, _allTables, _options = {}) {
  * PostGraphile expects: mutation { updateTableName(input: { id: UUID!, patch: TableNamePatch! }) { tableName { ... } } }
  */
 function buildPostGraphileUpdate(table, _allTables, _options = {}) {
-    const mutationName = `update${table.name}`;
-    const singularName = (0, inflekt_1.camelize)(table.name, true);
+    const mutationName = (0, naming_helpers_1.toUpdateMutationName)(table.name, table);
+    const singularName = (0, naming_helpers_1.toCamelCaseSingular)(table.name, table);
+    const inputTypeName = (0, naming_helpers_1.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 }),
             }),
         }),
     ];
@@ -187,13 +189,14 @@ function buildPostGraphileUpdate(table, _allTables, _options = {}) {
  * PostGraphile expects: mutation { deleteTableName(input: { id: UUID! }) { clientMutationId } }
  */
 function buildPostGraphileDelete(table, _allTables, _options = {}) {
-    const mutationName = `delete${table.name}`;
+    const mutationName = (0, naming_helpers_1.toDeleteMutationName)(table.name, table);
+    const inputTypeName = (0, naming_helpers_1.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/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;