@constructive-io/graphql-query 3.7.0 → 3.8.1

package/custom-ast.d.ts

@@ -1,18 +1,18 @@
 import type { FieldNode } from 'graphql';
-import type { CleanField } from './types/schema';
+import type { Field } from './types/schema';
 import type { MetaField } from './types';
 /**
  * Get custom AST for MetaField type - handles PostgreSQL types that need subfield selections
  */
 export declare function getCustomAst(fieldDefn?: MetaField): FieldNode | null;
 /**
- * Generate custom AST for CleanField type - handles GraphQL types that need subfield selections
+ * Generate custom AST for Field type - handles GraphQL types that need subfield selections
  */
-export declare function getCustomAstForCleanField(field: CleanField): FieldNode;
+export declare function getCustomAstForCleanField(field: Field): FieldNode;
 /**
- * Check if a CleanField requires subfield selection based on its GraphQL type
+ * Check if a Field requires subfield selection based on its GraphQL type
  */
-export declare function requiresSubfieldSelection(field: CleanField): boolean;
+export declare function requiresSubfieldSelection(field: Field): boolean;
 /**
  * Generate AST for GeometryPoint type
  */

package/custom-ast.js

@@ -62,7 +62,7 @@ function getCustomAst(fieldDefn) {
     });
 }
 /**
- * Generate custom AST for CleanField type - handles GraphQL types that need subfield selections
+ * Generate custom AST for Field type - handles GraphQL types that need subfield selections
  */
 function getCustomAstForCleanField(field) {
     const { name, type } = field;
@@ -90,7 +90,7 @@ function getCustomAstForCleanField(field) {
     });
 }
 /**
- * Check if a CleanField requires subfield selection based on its GraphQL type
+ * Check if a Field requires subfield selection based on its GraphQL type
  */
 function requiresSubfieldSelection(field) {
     const { gqlType } = field.type;

package/esm/custom-ast.js

@@ -19,7 +19,7 @@ export function getCustomAst(fieldDefn) {
     });
 }
 /**
- * Generate custom AST for CleanField type - handles GraphQL types that need subfield selections
+ * Generate custom AST for Field type - handles GraphQL types that need subfield selections
  */
 export function getCustomAstForCleanField(field) {
     const { name, type } = field;
@@ -47,7 +47,7 @@ export function getCustomAstForCleanField(field) {
     });
 }
 /**
- * Check if a CleanField requires subfield selection based on its GraphQL type
+ * Check if a Field requires subfield selection based on its GraphQL type
  */
 export function requiresSubfieldSelection(field) {
     const { gqlType } = field.type;

package/esm/generators/select.js

@@ -12,7 +12,7 @@ import { normalizeInflectionValue, toCamelCasePlural, toCamelCaseSingular, toCre
 // Re-export naming helpers for backwards compatibility
 export { toCamelCasePlural, toOrderByTypeName } from './naming-helpers';
 /**
- * Convert CleanTable to MetaObject format for QueryBuilder
+ * Convert Table to MetaObject format for QueryBuilder
  */
 export function cleanTableToMetaObject(tables) {
     return {
@@ -64,7 +64,7 @@ export function cleanTableToMetaObject(tables) {
     };
 }
 /**
- * Generate basic IntrospectionSchema from CleanTable array
+ * Generate basic IntrospectionSchema from Table array
  * This creates a minimal schema for AST generation
  */
 export function generateIntrospectionSchema(tables) {
@@ -178,7 +178,7 @@ export function generateIntrospectionSchema(tables) {
     return schema;
 }
 /**
- * Convert CleanTable fields to QueryBuilder properties
+ * Convert Table fields to QueryBuilder properties
  */
 function convertFieldsToProperties(fields) {
     const properties = {};
@@ -249,7 +249,7 @@ function convertFieldSelectionToSelectionOptions(table, allTables, options) {
     return convertToSelectionOptions(table, allTables, options);
 }
 /**
- * Generate SELECT query AST directly from CleanTable
+ * Generate SELECT query AST directly from Table
  */
 function generateSelectQueryAST(table, allTables, selection, options, relationFieldMap) {
     const pluralName = toCamelCasePlural(table.name, table);
@@ -571,7 +571,7 @@ function findRelatedTable(relationField, table, allTables) {
     return allTables.find((tbl) => tbl.name === referencedTableName) || null;
 }
 /**
- * Generate FindOne query AST directly from CleanTable
+ * Generate FindOne query AST directly from Table
  */
 function generateFindOneQueryAST(table) {
     const singularName = toCamelCaseSingular(table.name, table);
@@ -623,7 +623,7 @@ function generateFindOneQueryAST(table) {
     return print(ast);
 }
 /**
- * Generate Count query AST directly from CleanTable
+ * Generate Count query AST directly from Table
  */
 function generateCountQueryAST(table) {
     const pluralName = toCamelCasePlural(table.name, table);

package/esm/introspect/index.js

@@ -1,7 +1,7 @@
 /**
  * Introspection barrel export
  *
- * Re-exports introspection utilities for converting GraphQL schemas to CleanTable format.
+ * Re-exports introspection utilities for converting GraphQL schemas to Table format.
  */
 export * from './infer-tables';
 export * from './transform';

package/esm/introspect/infer-tables.js

@@ -73,11 +73,11 @@ function isInternalType(name) {
     return name.startsWith('__');
 }
 /**
- * Infer CleanTable[] from GraphQL introspection by recognizing PostGraphile patterns
+ * Infer Table[] from GraphQL introspection by recognizing PostGraphile patterns
  *
  * @param introspection - Standard GraphQL introspection response
  * @param options - Optional configuration
- * @returns Array of CleanTable objects compatible with existing generators
+ * @returns Array of Table objects compatible with existing generators
  */
 export function inferTablesFromIntrospection(introspection, options = {}) {
     const { __schema: schema } = introspection;
@@ -90,7 +90,7 @@ export function inferTablesFromIntrospection(introspection, options = {}) {
     const mutationFields = mutationType
         ? getTypeFields(typeMap.get(mutationType.name))
         : [];
-    // Step 1: Build CleanTable for each inferred entity
+    // Step 1: Build Table for each inferred entity
     const tables = [];
     for (const entityName of entityNames) {
         const entityType = typeMap.get(entityName);
@@ -169,7 +169,7 @@ function resolveEntityNameFromConnectionType(connectionType, typeMap) {
     return nodeTypeName;
 }
 /**
- * Build a complete CleanTable from an entity type
+ * Build a complete Table from an entity type
  */
 function buildCleanTable(entityName, entityType, typeMap, queryFields, mutationFields, entityToConnection, connectionToEntity, commentsEnabled) {
     // Extract scalar fields from entity type
@@ -300,7 +300,7 @@ function isEntityType(typeName, entityToConnection) {
     return entityToConnection.has(typeName);
 }
 /**
- * Convert IntrospectionTypeRef to CleanFieldType
+ * Convert IntrospectionTypeRef to FieldType
  */
 function convertToCleanFieldType(typeRef) {
     const baseType = unwrapType(typeRef);

package/esm/introspect/transform-schema.js

@@ -55,7 +55,7 @@ export function buildTypeRegistry(types) {
     return registry;
 }
 /**
- * Transform field to CleanObjectField without resolving nested types
+ * Transform field to ObjectField without resolving nested types
  * (shallow transformation to avoid circular refs)
  */
 function transformFieldToCleanObjectFieldShallow(field) {
@@ -66,7 +66,7 @@ function transformFieldToCleanObjectFieldShallow(field) {
     };
 }
 /**
- * Transform input value to CleanArgument without resolving nested types
+ * Transform input value to Argument without resolving nested types
  */
 function transformInputValueToCleanArgumentShallow(inputValue) {
     return {
@@ -117,7 +117,7 @@ export function transformSchemaToOperations(response) {
 // Field to Operation Transformation
 // ============================================================================
 /**
- * Transform an introspection field to a CleanOperation
+ * Transform an introspection field to a Operation
  */
 function transformFieldToCleanOperation(field, kind, types) {
     return {
@@ -131,7 +131,7 @@ function transformFieldToCleanOperation(field, kind, types) {
     };
 }
 /**
- * Transform an input value to CleanArgument
+ * Transform an input value to Argument
  */
 function transformInputValueToCleanArgument(inputValue, types) {
     return {
@@ -145,7 +145,7 @@ function transformInputValueToCleanArgument(inputValue, types) {
 // Type Reference Transformation
 // ============================================================================
 /**
- * Transform an introspection TypeRef to CleanTypeRef
+ * Transform an introspection TypeRef to TypeRef
  * Recursively handles wrapper types (LIST, NON_NULL)
  *
  * NOTE: We intentionally do NOT resolve nested fields here to avoid

package/esm/introspect/transform.js

@@ -1,5 +1,5 @@
 /**
- * Get table names from CleanTable array
+ * Get table names from Table array
  */
 export function getTableNames(tables) {
     return tables.map((t) => t.name);

package/esm/types/index.js

@@ -6,7 +6,7 @@
  */
 // Original QueryBuilder runtime types
 export * from './core';
-// Codegen-style schema types (CleanTable, CleanField, etc.)
+// Codegen-style schema types (Table, Field, etc.)
 export * from './schema';
 // Introspection types
 export * from './introspection';

package/generators/field-selector.d.ts

@@ -3,20 +3,20 @@
  * Converts user-friendly selection options to internal SelectionOptions format
  */
 import type { QuerySelectionOptions } from '../types';
-import type { CleanTable } from '../types/schema';
+import type { Table } from '../types/schema';
 import type { FieldSelection } from '../types/selection';
 /**
  * Convert simplified field selection to QueryBuilder SelectionOptions
  */
-export declare function convertToSelectionOptions(table: CleanTable, allTables: CleanTable[], selection?: FieldSelection): QuerySelectionOptions | null;
+export declare function convertToSelectionOptions(table: Table, allTables: Table[], selection?: FieldSelection): QuerySelectionOptions | null;
 /**
  * Check if a field is relational using table metadata
  */
-export declare function isRelationalField(fieldName: string, table: CleanTable): boolean;
+export declare function isRelationalField(fieldName: string, table: Table): boolean;
 /**
  * Get all available relation fields from a table
  */
-export declare function getAvailableRelations(table: CleanTable): Array<{
+export declare function getAvailableRelations(table: Table): Array<{
     fieldName: string;
     type: 'belongsTo' | 'hasOne' | 'hasMany' | 'manyToMany';
     referencedTable?: string;
@@ -24,7 +24,7 @@ export declare function getAvailableRelations(table: CleanTable): Array<{
 /**
  * Validate field selection against table schema
  */
-export declare function validateFieldSelection(selection: FieldSelection, table: CleanTable): {
+export declare function validateFieldSelection(selection: FieldSelection, table: Table): {
     isValid: boolean;
     errors: string[];
 };

package/generators/mutations.d.ts

@@ -1,11 +1,11 @@
 import { TypedDocumentString } from '../client/typed-document';
 import type { MutationOptions } from '../types/mutation';
-import type { CleanTable } from '../types/schema';
+import type { Table } from '../types/schema';
 /**
  * Build PostGraphile-style CREATE mutation
  * PostGraphile expects: mutation { createTableName(input: { tableName: TableNameInput! }) { tableName { ... } } }
  */
-export declare function buildPostGraphileCreate(table: CleanTable, _allTables: CleanTable[], _options?: MutationOptions): TypedDocumentString<Record<string, unknown>, {
+export declare function buildPostGraphileCreate(table: Table, _allTables: Table[], _options?: MutationOptions): TypedDocumentString<Record<string, unknown>, {
     input: {
         [key: string]: Record<string, unknown>;
     };
@@ -14,7 +14,7 @@ export declare function buildPostGraphileCreate(table: CleanTable, _allTables: C
  * Build PostGraphile-style UPDATE mutation
  * PostGraphile expects: mutation { updateTableName(input: { id: UUID!, patch: TableNamePatch! }) { tableName { ... } } }
  */
-export declare function buildPostGraphileUpdate(table: CleanTable, _allTables: CleanTable[], _options?: MutationOptions): TypedDocumentString<Record<string, unknown>, {
+export declare function buildPostGraphileUpdate(table: Table, _allTables: Table[], _options?: MutationOptions): TypedDocumentString<Record<string, unknown>, {
     input: {
         id: string | number;
     } & Record<string, unknown>;
@@ -23,7 +23,7 @@ export declare function buildPostGraphileUpdate(table: CleanTable, _allTables: C
  * Build PostGraphile-style DELETE mutation
  * PostGraphile expects: mutation { deleteTableName(input: { id: UUID! }) { clientMutationId } }
  */
-export declare function buildPostGraphileDelete(table: CleanTable, _allTables: CleanTable[], _options?: MutationOptions): TypedDocumentString<Record<string, unknown>, {
+export declare function buildPostGraphileDelete(table: Table, _allTables: Table[], _options?: MutationOptions): TypedDocumentString<Record<string, unknown>, {
     input: {
         id: string | number;
     };

package/generators/naming-helpers.d.ts

@@ -1,4 +1,4 @@
-import type { CleanTable } from '../types/schema';
+import type { Table } from '../types/schema';
 /**
  * Safely normalise a server-provided inflection value.
  * Returns `null` for null, undefined, or whitespace-only strings.
@@ -12,26 +12,26 @@ export declare function normalizeInflectionValue(value: string | null | undefine
  *
  * Example: "ActionGoal" -> "actionGoals", "User" -> "users", "Person" -> "people"
  */
-export declare function toCamelCasePlural(tableName: string, table?: CleanTable | null): string;
+export declare function toCamelCasePlural(tableName: string, table?: Table | 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 toCamelCaseSingular(tableName: string, table?: Table | null): string;
+export declare function toCreateMutationName(tableName: string, table?: Table | null): string;
+export declare function toUpdateMutationName(tableName: string, table?: Table | null): string;
+export declare function toDeleteMutationName(tableName: string, table?: Table | null): string;
+export declare function toCreateInputTypeName(tableName: string, table?: Table | 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;
+export declare function toFilterTypeName(tableName: string, table?: Table | 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;
+export declare function toPatchFieldName(tableName: string, table?: Table | null): string;
 /**
  * Convert camelCase field name to SCREAMING_SNAKE_CASE for PostGraphile
  * orderBy enums.
@@ -45,4 +45,4 @@ export declare function toOrderByEnumValue(fieldName: string, direction: 'asc' |
  * 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;
+export declare function toOrderByTypeName(tableName: string, table?: Table | null): string;

package/generators/select.d.ts

@@ -2,34 +2,34 @@ import { TypedDocumentString } from '../client/typed-document';
 import { QueryBuilder } from '../query-builder';
 import type { MetaObject, QueryIntrospectionSchema } from '../types';
 import type { QueryOptions } from '../types/query';
-import type { CleanTable } from '../types/schema';
+import type { Table } from '../types/schema';
 export { toCamelCasePlural, toOrderByTypeName } from './naming-helpers';
 /**
- * Convert CleanTable to MetaObject format for QueryBuilder
+ * Convert Table to MetaObject format for QueryBuilder
  */
-export declare function cleanTableToMetaObject(tables: CleanTable[]): MetaObject;
+export declare function cleanTableToMetaObject(tables: Table[]): MetaObject;
 /**
- * Generate basic IntrospectionSchema from CleanTable array
+ * Generate basic IntrospectionSchema from Table array
  * This creates a minimal schema for AST generation
  */
-export declare function generateIntrospectionSchema(tables: CleanTable[]): QueryIntrospectionSchema;
+export declare function generateIntrospectionSchema(tables: Table[]): QueryIntrospectionSchema;
 /**
  * Create AST-based query builder for a table
  */
-export declare function createASTQueryBuilder(tables: CleanTable[]): QueryBuilder;
+export declare function createASTQueryBuilder(tables: Table[]): QueryBuilder;
 /**
  * Build a SELECT query for a table with optional filtering, sorting, and pagination
  * Uses direct AST generation without intermediate conversions
  */
-export declare function buildSelect(table: CleanTable, allTables: readonly CleanTable[], options?: QueryOptions): TypedDocumentString<Record<string, unknown>, QueryOptions>;
+export declare function buildSelect(table: Table, allTables: readonly Table[], options?: QueryOptions): TypedDocumentString<Record<string, unknown>, QueryOptions>;
 /**
  * Build a single row query by primary key or unique field
  */
-export declare function buildFindOne(table: CleanTable, _pkField?: string): TypedDocumentString<Record<string, unknown>, Record<string, unknown>>;
+export declare function buildFindOne(table: Table, _pkField?: string): TypedDocumentString<Record<string, unknown>, Record<string, unknown>>;
 /**
  * Build a count query for a table
  */
-export declare function buildCount(table: CleanTable): TypedDocumentString<{
+export declare function buildCount(table: Table): TypedDocumentString<{
     [key: string]: {
         totalCount: number;
     };

package/generators/select.js

@@ -56,7 +56,7 @@ 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
+ * Convert Table to MetaObject format for QueryBuilder
  */
 function cleanTableToMetaObject(tables) {
     return {
@@ -108,7 +108,7 @@ function cleanTableToMetaObject(tables) {
     };
 }
 /**
- * Generate basic IntrospectionSchema from CleanTable array
+ * Generate basic IntrospectionSchema from Table array
  * This creates a minimal schema for AST generation
  */
 function generateIntrospectionSchema(tables) {
@@ -222,7 +222,7 @@ function generateIntrospectionSchema(tables) {
     return schema;
 }
 /**
- * Convert CleanTable fields to QueryBuilder properties
+ * Convert Table fields to QueryBuilder properties
  */
 function convertFieldsToProperties(fields) {
     const properties = {};
@@ -293,7 +293,7 @@ function convertFieldSelectionToSelectionOptions(table, allTables, options) {
     return (0, field_selector_1.convertToSelectionOptions)(table, allTables, options);
 }
 /**
- * Generate SELECT query AST directly from CleanTable
+ * Generate SELECT query AST directly from Table
  */
 function generateSelectQueryAST(table, allTables, selection, options, relationFieldMap) {
     const pluralName = (0, naming_helpers_1.toCamelCasePlural)(table.name, table);
@@ -615,7 +615,7 @@ function findRelatedTable(relationField, table, allTables) {
     return allTables.find((tbl) => tbl.name === referencedTableName) || null;
 }
 /**
- * Generate FindOne query AST directly from CleanTable
+ * Generate FindOne query AST directly from Table
  */
 function generateFindOneQueryAST(table) {
     const singularName = (0, naming_helpers_1.toCamelCaseSingular)(table.name, table);
@@ -667,7 +667,7 @@ function generateFindOneQueryAST(table) {
     return (0, graphql_1.print)(ast);
 }
 /**
- * Generate Count query AST directly from CleanTable
+ * Generate Count query AST directly from Table
  */
 function generateCountQueryAST(table) {
     const pluralName = (0, naming_helpers_1.toCamelCasePlural)(table.name, table);

package/introspect/index.d.ts

@@ -1,7 +1,7 @@
 /**
  * Introspection barrel export
  *
- * Re-exports introspection utilities for converting GraphQL schemas to CleanTable format.
+ * Re-exports introspection utilities for converting GraphQL schemas to Table format.
  */
 export * from './infer-tables';
 export * from './transform';

package/introspect/index.js

@@ -2,7 +2,7 @@
 /**
  * Introspection barrel export
  *
- * Re-exports introspection utilities for converting GraphQL schemas to CleanTable format.
+ * Re-exports introspection utilities for converting GraphQL schemas to Table format.
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;

package/introspect/infer-tables.d.ts

@@ -1,5 +1,5 @@
 import type { IntrospectionQueryResponse } from '../types/introspection';
-import type { CleanTable } from '../types/schema';
+import type { Table } from '../types/schema';
 /**
  * PostGraphile naming patterns for type detection
  */
@@ -32,11 +32,11 @@ export interface InferTablesOptions {
     comments?: boolean;
 }
 /**
- * Infer CleanTable[] from GraphQL introspection by recognizing PostGraphile patterns
+ * Infer Table[] from GraphQL introspection by recognizing PostGraphile patterns
  *
  * @param introspection - Standard GraphQL introspection response
  * @param options - Optional configuration
- * @returns Array of CleanTable objects compatible with existing generators
+ * @returns Array of Table objects compatible with existing generators
  */
-export declare function inferTablesFromIntrospection(introspection: IntrospectionQueryResponse, options?: InferTablesOptions): CleanTable[];
+export declare function inferTablesFromIntrospection(introspection: IntrospectionQueryResponse, options?: InferTablesOptions): Table[];
 export {};

package/introspect/infer-tables.js

@@ -76,11 +76,11 @@ function isInternalType(name) {
     return name.startsWith('__');
 }
 /**
- * Infer CleanTable[] from GraphQL introspection by recognizing PostGraphile patterns
+ * Infer Table[] from GraphQL introspection by recognizing PostGraphile patterns
  *
  * @param introspection - Standard GraphQL introspection response
  * @param options - Optional configuration
- * @returns Array of CleanTable objects compatible with existing generators
+ * @returns Array of Table objects compatible with existing generators
  */
 function inferTablesFromIntrospection(introspection, options = {}) {
     const { __schema: schema } = introspection;
@@ -93,7 +93,7 @@ function inferTablesFromIntrospection(introspection, options = {}) {
     const mutationFields = mutationType
         ? getTypeFields(typeMap.get(mutationType.name))
         : [];
-    // Step 1: Build CleanTable for each inferred entity
+    // Step 1: Build Table for each inferred entity
     const tables = [];
     for (const entityName of entityNames) {
         const entityType = typeMap.get(entityName);
@@ -172,7 +172,7 @@ function resolveEntityNameFromConnectionType(connectionType, typeMap) {
     return nodeTypeName;
 }
 /**
- * Build a complete CleanTable from an entity type
+ * Build a complete Table from an entity type
  */
 function buildCleanTable(entityName, entityType, typeMap, queryFields, mutationFields, entityToConnection, connectionToEntity, commentsEnabled) {
     // Extract scalar fields from entity type
@@ -303,7 +303,7 @@ function isEntityType(typeName, entityToConnection) {
     return entityToConnection.has(typeName);
 }
 /**
- * Convert IntrospectionTypeRef to CleanFieldType
+ * Convert IntrospectionTypeRef to FieldType
  */
 function convertToCleanFieldType(typeRef) {
     const baseType = (0, introspection_1.unwrapType)(typeRef);

package/introspect/transform-schema.d.ts

@@ -1,12 +1,12 @@
 /**
  * Transform GraphQL introspection data to clean operation types
  *
- * This module converts raw introspection responses into the CleanOperation
+ * This module converts raw introspection responses into the Operation
  * format used by code generators.
  */
 import type { IntrospectionQueryResponse, IntrospectionType } from '../types/introspection';
 import { getBaseTypeName, isNonNull, unwrapType } from '../types/introspection';
-import type { CleanOperation, TypeRegistry } from '../types/schema';
+import type { Operation, TypeRegistry } from '../types/schema';
 /**
  * Build a type registry from introspection types
  * Maps type names to their full resolved definitions
@@ -17,8 +17,8 @@ import type { CleanOperation, TypeRegistry } from '../types/schema';
  */
 export declare function buildTypeRegistry(types: IntrospectionType[]): TypeRegistry;
 export interface TransformSchemaResult {
-    queries: CleanOperation[];
-    mutations: CleanOperation[];
+    queries: Operation[];
+    mutations: Operation[];
     typeRegistry: TypeRegistry;
 }
 /**
@@ -29,7 +29,7 @@ export declare function transformSchemaToOperations(response: IntrospectionQuery
  * Filter operations by include/exclude patterns
  * Uses glob-like patterns (supports * wildcard)
  */
-export declare function filterOperations(operations: CleanOperation[], include?: string[], exclude?: string[]): CleanOperation[];
+export declare function filterOperations(operations: Operation[], include?: string[], exclude?: string[]): Operation[];
 /**
  * Result type for table operation names lookup
  */
@@ -72,7 +72,7 @@ export declare function getTableOperationNames(tables: Array<{
  * 2. All other operations (including update*By*, delete*By*) become custom operations
  * 3. 100% schema coverage is guaranteed
  */
-export declare function isTableOperation(operation: CleanOperation, tableOperationNames: TableOperationNames): boolean;
+export declare function isTableOperation(operation: Operation, tableOperationNames: TableOperationNames): boolean;
 /**
  * Get only custom operations (not covered by table generators)
  *
@@ -82,5 +82,5 @@ export declare function isTableOperation(operation: CleanOperation, tableOperati
  * - Unique constraint mutations (update*By*, delete*By*)
  * - True custom operations (login, register, bootstrapUser, etc.)
  */
-export declare function getCustomOperations(operations: CleanOperation[], tableOperationNames: TableOperationNames): CleanOperation[];
+export declare function getCustomOperations(operations: Operation[], tableOperationNames: TableOperationNames): Operation[];
 export { getBaseTypeName, isNonNull, unwrapType };

package/introspect/transform-schema.js

@@ -67,7 +67,7 @@ function buildTypeRegistry(types) {
     return registry;
 }
 /**
- * Transform field to CleanObjectField without resolving nested types
+ * Transform field to ObjectField without resolving nested types
  * (shallow transformation to avoid circular refs)
  */
 function transformFieldToCleanObjectFieldShallow(field) {
@@ -78,7 +78,7 @@ function transformFieldToCleanObjectFieldShallow(field) {
     };
 }
 /**
- * Transform input value to CleanArgument without resolving nested types
+ * Transform input value to Argument without resolving nested types
  */
 function transformInputValueToCleanArgumentShallow(inputValue) {
     return {
@@ -129,7 +129,7 @@ function transformSchemaToOperations(response) {
 // Field to Operation Transformation
 // ============================================================================
 /**
- * Transform an introspection field to a CleanOperation
+ * Transform an introspection field to a Operation
  */
 function transformFieldToCleanOperation(field, kind, types) {
     return {
@@ -143,7 +143,7 @@ function transformFieldToCleanOperation(field, kind, types) {
     };
 }
 /**
- * Transform an input value to CleanArgument
+ * Transform an input value to Argument
  */
 function transformInputValueToCleanArgument(inputValue, types) {
     return {
@@ -157,7 +157,7 @@ function transformInputValueToCleanArgument(inputValue, types) {
 // Type Reference Transformation
 // ============================================================================
 /**
- * Transform an introspection TypeRef to CleanTypeRef
+ * Transform an introspection TypeRef to TypeRef
  * Recursively handles wrapper types (LIST, NON_NULL)
  *
  * NOTE: We intentionally do NOT resolve nested fields here to avoid

package/introspect/transform.d.ts

@@ -1,20 +1,20 @@
 /**
- * Table utility functions for CleanTable[]
+ * Table utility functions for Table[]
  *
  * Note: The _meta transform functions have been removed.
  * Tables are now inferred from standard GraphQL introspection
  * using inferTablesFromIntrospection() in ./infer-tables.ts
  */
-import type { CleanTable } from '../types/schema';
+import type { Table } from '../types/schema';
 /**
- * Get table names from CleanTable array
+ * Get table names from Table array
  */
-export declare function getTableNames(tables: CleanTable[]): string[];
+export declare function getTableNames(tables: Table[]): string[];
 /**
  * Find a table by name
  */
-export declare function findTable(tables: CleanTable[], name: string): CleanTable | undefined;
+export declare function findTable(tables: Table[], name: string): Table | undefined;
 /**
  * Filter tables by name pattern (glob-like)
  */
-export declare function filterTables(tables: CleanTable[], include?: string[], exclude?: string[]): CleanTable[];
+export declare function filterTables(tables: Table[], include?: string[], exclude?: string[]): Table[];

package/introspect/transform.js

@@ -4,7 +4,7 @@ exports.getTableNames = getTableNames;
 exports.findTable = findTable;
 exports.filterTables = filterTables;
 /**
- * Get table names from CleanTable array
+ * Get table names from Table array
  */
 function getTableNames(tables) {
     return tables.map((t) => t.name);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@constructive-io/graphql-query",
-  "version": "3.7.0",
+  "version": "3.8.1",
   "description": "Constructive GraphQL Query",
   "author": "Constructive <developers@constructive.io>",
   "main": "index.js",
@@ -34,7 +34,7 @@
     "grafast": "1.0.0-rc.9",
     "graphile-build-pg": "5.0.0-rc.8",
     "graphile-config": "1.0.0-rc.6",
-    "graphile-settings": "^4.11.0",
+    "graphile-settings": "^4.12.1",
     "graphql": "16.13.0",
     "inflection": "^3.0.0",
     "inflekt": "^0.3.3",
@@ -51,5 +51,5 @@
   "devDependencies": {
     "makage": "^0.1.10"
   },
-  "gitHead": "d7ad4d8a95a9ab73c9eee919e0cdfcc2334845af"
+  "gitHead": "b0ff4ed0025af0e5df91d8e3535c347e4cde6438"
 }

package/types/core.d.ts

@@ -1,5 +1,5 @@
 import type { DocumentNode, FieldNode, SelectionSetNode, VariableDefinitionNode } from 'graphql';
-import type { CleanField } from './schema';
+import type { Field } from './schema';
 export type ASTNode = DocumentNode | FieldNode | SelectionSetNode | VariableDefinitionNode;
 export interface NestedProperties {
     [key: string]: QueryProperty | NestedProperties;
@@ -71,7 +71,7 @@ export interface GraphQLVariables {
 export interface QueryFieldSelection {
     name: string;
     isObject: boolean;
-    fieldDefn?: MetaField | CleanField;
+    fieldDefn?: MetaField | Field;
     selection?: QueryFieldSelection[];
     variables?: GraphQLVariables;
     isBelongTo?: boolean;

package/types/index.js

@@ -22,7 +22,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 // Original QueryBuilder runtime types
 __exportStar(require("./core"), exports);
-// Codegen-style schema types (CleanTable, CleanField, etc.)
+// Codegen-style schema types (Table, Field, etc.)
 __exportStar(require("./schema"), exports);
 // Introspection types
 __exportStar(require("./introspection"), exports);

package/types/schema.d.ts

@@ -5,12 +5,12 @@
 /**
  * Represents a database table with its fields and relations
  */
-export interface CleanTable {
+export interface Table {
     name: string;
     /** Description from PostgreSQL COMMENT (smart comments stripped) */
     description?: string;
-    fields: CleanField[];
-    relations: CleanRelations;
+    fields: Field[];
+    relations: Relations;
     /** PostGraphile inflection rules for this table */
     inflection?: TableInflection;
     /** Query operation names from introspection */
@@ -94,20 +94,20 @@ export interface TableConstraints {
 }
 export interface ConstraintInfo {
     name: string;
-    fields: CleanField[];
+    fields: Field[];
 }
 export interface ForeignKeyConstraint extends ConstraintInfo {
     refTable: string;
-    refFields: CleanField[];
+    refFields: Field[];
 }
 /**
  * Represents a field/column in a table
  */
-export interface CleanField {
+export interface Field {
     name: string;
     /** Description from PostgreSQL COMMENT (smart comments stripped) */
     description?: string;
-    type: CleanFieldType;
+    type: FieldType;
     /** 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) */
@@ -116,7 +116,7 @@ export interface CleanField {
 /**
  * Field type information from PostGraphile introspection
  */
-export interface CleanFieldType {
+export interface FieldType {
     /** GraphQL type name (e.g., "String", "UUID", "Int") */
     gqlType: string;
     /** Whether this is an array type */
@@ -135,64 +135,72 @@ export interface CleanFieldType {
 /**
  * All relation types for a table
  */
-export interface CleanRelations {
-    belongsTo: CleanBelongsToRelation[];
-    hasOne: CleanHasOneRelation[];
-    hasMany: CleanHasManyRelation[];
-    manyToMany: CleanManyToManyRelation[];
+export interface Relations {
+    belongsTo: BelongsToRelation[];
+    hasOne: HasOneRelation[];
+    hasMany: HasManyRelation[];
+    manyToMany: ManyToManyRelation[];
 }
 /**
  * BelongsTo relation (foreign key on this table)
  */
-export interface CleanBelongsToRelation {
+export interface BelongsToRelation {
     fieldName: string | null;
     isUnique: boolean;
     referencesTable: string;
     type: string | null;
-    keys: CleanField[];
+    keys: Field[];
 }
 /**
  * HasOne relation (foreign key on other table, unique)
  */
-export interface CleanHasOneRelation {
+export interface HasOneRelation {
     fieldName: string | null;
     isUnique: boolean;
     referencedByTable: string;
     type: string | null;
-    keys: CleanField[];
+    keys: Field[];
 }
 /**
  * HasMany relation (foreign key on other table, not unique)
  */
-export interface CleanHasManyRelation {
+export interface HasManyRelation {
     fieldName: string | null;
     isUnique: boolean;
     referencedByTable: string;
     type: string | null;
-    keys: CleanField[];
+    keys: Field[];
 }
 /**
  * ManyToMany relation (through junction table)
  */
-export interface CleanManyToManyRelation {
+export interface ManyToManyRelation {
     fieldName: string | null;
     rightTable: string;
     junctionTable: string;
     type: string | null;
+    /** Junction FK field names pointing to the left table */
+    junctionLeftKeyFields?: string[];
+    /** Junction FK field names pointing to the right table */
+    junctionRightKeyFields?: string[];
+    /** Left table key fields (usually just 'id') */
+    leftKeyFields?: string[];
+    /** Right table key fields (usually just 'id') */
+    rightKeyFields?: string[];
 }
 /**
  * Clean representation of a GraphQL operation (query or mutation)
  * Derived from introspection data
  */
-export interface CleanOperation {
+export interface Operation {
     /** Operation name (e.g., "login", "currentUser", "cars") */
     name: string;
     /** Operation kind */
     kind: 'query' | 'mutation';
     /** Arguments/variables for the operation */
-    args: CleanArgument[];
+    args: Argument[];
     /** Return type */
-    returnType: CleanTypeRef;
+    returnType: TypeRef;
     /** Description from schema */
     description?: string;
     /** Whether this is deprecated */
@@ -203,11 +211,11 @@ export interface CleanOperation {
 /**
  * Clean representation of an operation argument
  */
-export interface CleanArgument {
+export interface Argument {
     /** Argument name */
     name: string;
     /** Argument type */
-    type: CleanTypeRef;
+    type: TypeRef;
     /** Default value (as string) */
     defaultValue?: string;
     /** Description from schema */
@@ -216,30 +224,30 @@ export interface CleanArgument {
 /**
  * Clean type reference - simplified from introspection TypeRef
  */
-export interface CleanTypeRef {
+export interface TypeRef {
     /** Type kind */
     kind: 'SCALAR' | 'OBJECT' | 'INPUT_OBJECT' | 'ENUM' | 'LIST' | 'NON_NULL';
     /** Type name (null for LIST and NON_NULL wrappers) */
     name: string | null;
     /** Inner type for LIST and NON_NULL wrappers */
-    ofType?: CleanTypeRef;
+    ofType?: TypeRef;
     /** Resolved TypeScript type string */
     tsType?: string;
     /** Fields for OBJECT types */
-    fields?: CleanObjectField[];
+    fields?: ObjectField[];
     /** Input fields for INPUT_OBJECT types */
-    inputFields?: CleanArgument[];
+    inputFields?: Argument[];
     /** Values for ENUM types */
     enumValues?: string[];
 }
 /**
  * Field on an object type
  */
-export interface CleanObjectField {
+export interface ObjectField {
     /** Field name */
     name: string;
     /** Field type */
-    type: CleanTypeRef;
+    type: TypeRef;
     /** Description */
     description?: string;
 }
@@ -255,9 +263,9 @@ export interface ResolvedType {
     name: string;
     description?: string;
     /** Fields for OBJECT types */
-    fields?: CleanObjectField[];
+    fields?: ObjectField[];
     /** Input fields for INPUT_OBJECT types */
-    inputFields?: CleanArgument[];
+    inputFields?: Argument[];
     /** Values for ENUM types */
     enumValues?: string[];
     /** Possible types for UNION types */