@constructive-io/graphql-codegen 2.18.0 → 2.20.0

package/esm/generators/field-selector.js

@@ -0,0 +1,355 @@
+/**
+ * Convert simplified field selection to QueryBuilder SelectionOptions
+ */
+export function convertToSelectionOptions(table, allTables, selection) {
+    if (!selection) {
+        return convertPresetToSelection(table, 'display');
+    }
+    if (typeof selection === 'string') {
+        return convertPresetToSelection(table, selection);
+    }
+    return convertCustomSelectionToOptions(table, allTables, selection);
+}
+/**
+ * Convert preset to selection options
+ */
+function convertPresetToSelection(table, preset) {
+    const options = {};
+    switch (preset) {
+        case 'minimal': {
+            // Just id and first display field
+            const minimalFields = getMinimalFields(table);
+            minimalFields.forEach((field) => {
+                options[field] = true;
+            });
+            break;
+        }
+        case 'display': {
+            // Common display fields
+            const displayFields = getDisplayFields(table);
+            displayFields.forEach((field) => {
+                options[field] = true;
+            });
+            break;
+        }
+        case 'all': {
+            // All non-relational fields (includes complex fields like JSON, geometry, etc.)
+            const allFields = getNonRelationalFields(table);
+            allFields.forEach((field) => {
+                options[field] = true;
+            });
+            break;
+        }
+        case 'full':
+            // All fields including basic relations
+            table.fields.forEach((field) => {
+                options[field.name] = true;
+            });
+            break;
+        default: {
+            // Default to display
+            const defaultFields = getDisplayFields(table);
+            defaultFields.forEach((field) => {
+                options[field] = true;
+            });
+        }
+    }
+    return options;
+}
+/**
+ * Convert custom selection to options
+ */
+function convertCustomSelectionToOptions(table, allTables, selection) {
+    const options = {};
+    // Start with selected fields or all non-relational fields (including complex types)
+    let fieldsToInclude;
+    if (selection.select) {
+        fieldsToInclude = selection.select;
+    }
+    else {
+        fieldsToInclude = getNonRelationalFields(table);
+    }
+    // Add basic fields
+    fieldsToInclude.forEach((field) => {
+        if (table.fields.some((f) => f.name === field)) {
+            options[field] = true;
+        }
+    });
+    // Handle includeRelations (simple API for relation fields)
+    if (selection.includeRelations) {
+        selection.includeRelations.forEach((relationField) => {
+            if (isRelationalField(relationField, table)) {
+                // Include with dynamically determined scalar fields from the related table
+                options[relationField] = {
+                    select: getRelatedTableScalarFields(relationField, table, allTables),
+                    variables: {},
+                };
+            }
+        });
+    }
+    // Handle includes (relations) - more detailed API
+    if (selection.include) {
+        Object.entries(selection.include).forEach(([relationField, relationSelection]) => {
+            if (isRelationalField(relationField, table)) {
+                if (relationSelection === true) {
+                    // Include with dynamically determined scalar fields from the related table
+                    options[relationField] = {
+                        select: getRelatedTableScalarFields(relationField, table, allTables),
+                        variables: {},
+                    };
+                }
+                else if (Array.isArray(relationSelection)) {
+                    // Include with specific fields
+                    const selectObj = {};
+                    relationSelection.forEach((field) => {
+                        selectObj[field] = true;
+                    });
+                    options[relationField] = {
+                        select: selectObj,
+                        variables: {},
+                    };
+                }
+            }
+        });
+    }
+    // Handle excludes
+    if (selection.exclude) {
+        selection.exclude.forEach((field) => {
+            delete options[field];
+        });
+    }
+    return options;
+}
+/**
+ * Get minimal fields - completely schema-driven, no hardcoded assumptions
+ */
+function getMinimalFields(table) {
+    // Get all non-relational fields from the actual schema
+    const nonRelationalFields = getNonRelationalFields(table);
+    // Return the first few fields from the schema (typically includes primary key and basic fields)
+    // This is completely dynamic based on what the schema actually provides
+    return nonRelationalFields.slice(0, 3); // Limit to first 3 fields for minimal selection
+}
+/**
+ * Get display fields - completely schema-driven, no hardcoded field names
+ */
+function getDisplayFields(table) {
+    // Get all non-relational fields from the actual schema
+    const nonRelationalFields = getNonRelationalFields(table);
+    // Return a reasonable subset for display purposes (first half of available fields)
+    // This is completely dynamic based on what the schema actually provides
+    const maxDisplayFields = Math.max(5, Math.floor(nonRelationalFields.length / 2));
+    return nonRelationalFields.slice(0, maxDisplayFields);
+}
+/**
+ * Get all non-relational fields (includes both scalar and complex fields)
+ * Complex fields like JSON, geometry, images should be included by default
+ */
+function getNonRelationalFields(table) {
+    return table.fields
+        .filter((field) => !isRelationalField(field.name, table))
+        .map((field) => field.name);
+}
+/**
+ * Check if a field is relational using table metadata
+ */
+export function isRelationalField(fieldName, table) {
+    const { belongsTo, hasOne, hasMany, manyToMany } = table.relations;
+    return (belongsTo.some((rel) => rel.fieldName === fieldName) ||
+        hasOne.some((rel) => rel.fieldName === fieldName) ||
+        hasMany.some((rel) => rel.fieldName === fieldName) ||
+        manyToMany.some((rel) => rel.fieldName === fieldName));
+}
+/**
+ * Get scalar fields for a related table to include in relation queries
+ * Uses only the _meta query data - no hardcoded field names or assumptions
+ */
+function getRelatedTableScalarFields(relationField, table, allTables) {
+    // Find the related table name
+    let referencedTableName;
+    // Check belongsTo relations
+    const belongsToRel = table.relations.belongsTo.find((rel) => rel.fieldName === relationField);
+    if (belongsToRel) {
+        referencedTableName = belongsToRel.referencesTable;
+    }
+    // Check hasOne relations
+    if (!referencedTableName) {
+        const hasOneRel = table.relations.hasOne.find((rel) => rel.fieldName === relationField);
+        if (hasOneRel) {
+            referencedTableName = hasOneRel.referencedByTable;
+        }
+    }
+    // Check hasMany relations
+    if (!referencedTableName) {
+        const hasManyRel = table.relations.hasMany.find((rel) => rel.fieldName === relationField);
+        if (hasManyRel) {
+            referencedTableName = hasManyRel.referencedByTable;
+        }
+    }
+    // Check manyToMany relations
+    if (!referencedTableName) {
+        const manyToManyRel = table.relations.manyToMany.find((rel) => rel.fieldName === relationField);
+        if (manyToManyRel) {
+            referencedTableName = manyToManyRel.rightTable;
+        }
+    }
+    if (!referencedTableName) {
+        // No related table found - return empty selection
+        return {};
+    }
+    // Find the related table in allTables
+    const relatedTable = allTables.find((t) => t.name === referencedTableName);
+    if (!relatedTable) {
+        // Related table not found in schema - return empty selection
+        return {};
+    }
+    // Get ALL scalar fields from the related table (non-relational fields)
+    // This is completely dynamic based on the actual schema
+    const scalarFields = relatedTable.fields
+        .filter((field) => !isRelationalField(field.name, relatedTable))
+        .map((field) => field.name);
+    // Perf guardrail: select a small, display-oriented subset.
+    const MAX_RELATED_FIELDS = 8;
+    const preferred = [
+        'displayName',
+        'fullName',
+        'preferredName',
+        'nickname',
+        'firstName',
+        'lastName',
+        'username',
+        'email',
+        'name',
+        'title',
+        'label',
+        'slug',
+        'code',
+        'createdAt',
+        'updatedAt',
+    ];
+    const included = [];
+    const push = (fieldName) => {
+        if (!fieldName)
+            return;
+        if (!scalarFields.includes(fieldName))
+            return;
+        if (included.includes(fieldName))
+            return;
+        if (included.length >= MAX_RELATED_FIELDS)
+            return;
+        included.push(fieldName);
+    };
+    // Always try to include stable identifiers first.
+    push('id');
+    push('nodeId');
+    for (const fieldName of preferred)
+        push(fieldName);
+    for (const fieldName of scalarFields)
+        push(fieldName);
+    const selection = {};
+    for (const fieldName of included)
+        selection[fieldName] = true;
+    return selection;
+}
+/**
+ * Get all available relation fields from a table
+ */
+export function getAvailableRelations(table) {
+    const relations = [];
+    // Add belongsTo relations
+    table.relations.belongsTo.forEach((rel) => {
+        if (rel.fieldName) {
+            relations.push({
+                fieldName: rel.fieldName,
+                type: 'belongsTo',
+                referencedTable: rel.referencesTable || undefined,
+            });
+        }
+    });
+    // Add hasOne relations
+    table.relations.hasOne.forEach((rel) => {
+        if (rel.fieldName) {
+            relations.push({
+                fieldName: rel.fieldName,
+                type: 'hasOne',
+                referencedTable: rel.referencedByTable || undefined,
+            });
+        }
+    });
+    // Add hasMany relations
+    table.relations.hasMany.forEach((rel) => {
+        if (rel.fieldName) {
+            relations.push({
+                fieldName: rel.fieldName,
+                type: 'hasMany',
+                referencedTable: rel.referencedByTable || undefined,
+            });
+        }
+    });
+    // Add manyToMany relations
+    table.relations.manyToMany.forEach((rel) => {
+        if (rel.fieldName) {
+            relations.push({
+                fieldName: rel.fieldName,
+                type: 'manyToMany',
+                referencedTable: rel.rightTable || undefined,
+            });
+        }
+    });
+    return relations;
+}
+/**
+ * Validate field selection against table schema
+ */
+export function validateFieldSelection(selection, table) {
+    const errors = [];
+    if (typeof selection === 'string') {
+        // Presets are always valid
+        return { isValid: true, errors: [] };
+    }
+    const tableFieldNames = table.fields.map((f) => f.name);
+    // Validate select fields
+    if (selection.select) {
+        selection.select.forEach((field) => {
+            if (!tableFieldNames.includes(field)) {
+                errors.push(`Field '${field}' does not exist in table '${table.name}'`);
+            }
+        });
+    }
+    // Validate includeRelations fields
+    if (selection.includeRelations) {
+        selection.includeRelations.forEach((field) => {
+            if (!isRelationalField(field, table)) {
+                errors.push(`Field '${field}' is not a relational field in table '${table.name}'`);
+            }
+        });
+    }
+    // Validate include fields
+    if (selection.include) {
+        Object.keys(selection.include).forEach((field) => {
+            if (!isRelationalField(field, table)) {
+                errors.push(`Field '${field}' is not a relational field in table '${table.name}'`);
+            }
+        });
+    }
+    // Validate exclude fields
+    if (selection.exclude) {
+        selection.exclude.forEach((field) => {
+            if (!tableFieldNames.includes(field)) {
+                errors.push(`Exclude field '${field}' does not exist in table '${table.name}'`);
+            }
+        });
+    }
+    // Validate maxDepth
+    if (selection.maxDepth !== undefined) {
+        if (typeof selection.maxDepth !== 'number' ||
+            selection.maxDepth < 0 ||
+            selection.maxDepth > 5) {
+            errors.push('maxDepth must be a number between 0 and 5');
+        }
+    }
+    return {
+        isValid: errors.length === 0,
+        errors,
+    };
+}

package/esm/generators/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Query and mutation generator exports
+ */
+export { convertToSelectionOptions, isRelationalField, getAvailableRelations, validateFieldSelection, } from './field-selector';
+export { buildSelect, buildFindOne, buildCount, toCamelCasePlural, toOrderByTypeName, cleanTableToMetaObject, generateIntrospectionSchema, createASTQueryBuilder, } from './select';
+export { buildPostGraphileCreate, buildPostGraphileUpdate, buildPostGraphileDelete, } from './mutations';

package/esm/generators/index.js

@@ -0,0 +1,9 @@
+/**
+ * Query and mutation generator exports
+ */
+// Field selector utilities
+export { convertToSelectionOptions, isRelationalField, getAvailableRelations, validateFieldSelection, } from './field-selector';
+// Query generators
+export { buildSelect, buildFindOne, buildCount, toCamelCasePlural, toOrderByTypeName, cleanTableToMetaObject, generateIntrospectionSchema, createASTQueryBuilder, } from './select';
+// Mutation generators
+export { buildPostGraphileCreate, buildPostGraphileUpdate, buildPostGraphileDelete, } from './mutations';

package/esm/generators/mutations.d.ts

@@ -0,0 +1,31 @@
+import { TypedDocumentString } from '../client/typed-document';
+import type { CleanTable } from '../types/schema';
+import type { MutationOptions } from '../types/mutation';
+/**
+ * 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>, {
+    input: {
+        [key: string]: Record<string, unknown>;
+    };
+}>;
+/**
+ * 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>, {
+    input: {
+        id: string | number;
+        patch: Record<string, unknown>;
+    };
+}>;
+/**
+ * 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>, {
+    input: {
+        id: string | number;
+    };
+}>;

package/esm/generators/mutations.js

@@ -0,0 +1,197 @@
+/**
+ * Mutation generators for CREATE, UPDATE, and DELETE operations
+ * Uses AST-based approach for PostGraphile-compatible mutations
+ */
+import * as t from 'gql-ast';
+import { print } from 'graphql';
+import * as inflection from 'inflection';
+import { TypedDocumentString } from '../client/typed-document';
+import { getCustomAstForCleanField, requiresSubfieldSelection, } from '../core/custom-ast';
+import { isRelationalField } from './field-selector';
+/**
+ * Generate field selections for PostGraphile mutations using custom AST logic
+ * This handles both scalar fields and complex types that require subfield selections
+ */
+function generateFieldSelections(table) {
+    return table.fields
+        .filter((field) => !isRelationalField(field.name, table)) // Exclude relational fields
+        .map((field) => {
+        if (requiresSubfieldSelection(field)) {
+            // Use custom AST generation for complex types
+            return getCustomAstForCleanField(field);
+        }
+        else {
+            // Use simple field selection for scalar types
+            return t.field({ name: field.name });
+        }
+    });
+}
+/**
+ * Build PostGraphile-style CREATE mutation
+ * PostGraphile expects: mutation { createTableName(input: { tableName: TableNameInput! }) { tableName { ... } } }
+ */
+export function buildPostGraphileCreate(table, _allTables, _options = {}) {
+    const mutationName = `create${table.name}`;
+    const singularName = inflection.camelize(table.name, true);
+    // 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` }),
+            }),
+        }),
+    ];
+    // Create the mutation arguments
+    const mutationArgs = [
+        t.argument({
+            name: 'input',
+            value: t.variable({ name: 'input' }),
+        }),
+    ];
+    // Get the field selections for the return value using custom AST logic
+    const fieldSelections = generateFieldSelections(table);
+    // Build the mutation AST
+    const ast = t.document({
+        definitions: [
+            t.operationDefinition({
+                operation: 'mutation',
+                name: `${mutationName}Mutation`,
+                variableDefinitions,
+                selectionSet: t.selectionSet({
+                    selections: [
+                        t.field({
+                            name: mutationName,
+                            args: mutationArgs,
+                            selectionSet: t.selectionSet({
+                                selections: [
+                                    t.field({
+                                        name: singularName,
+                                        selectionSet: t.selectionSet({
+                                            selections: fieldSelections,
+                                        }),
+                                    }),
+                                ],
+                            }),
+                        }),
+                    ],
+                }),
+            }),
+        ],
+    });
+    // Print the AST to get the query string
+    const queryString = print(ast);
+    return new TypedDocumentString(queryString, {
+        __ast: ast,
+    });
+}
+/**
+ * Build PostGraphile-style UPDATE mutation
+ * PostGraphile expects: mutation { updateTableName(input: { id: UUID!, patch: TableNamePatch! }) { tableName { ... } } }
+ */
+export function buildPostGraphileUpdate(table, _allTables, _options = {}) {
+    const mutationName = `update${table.name}`;
+    const singularName = inflection.camelize(table.name, true);
+    // 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` }),
+            }),
+        }),
+    ];
+    // Create the mutation arguments
+    const mutationArgs = [
+        t.argument({
+            name: 'input',
+            value: t.variable({ name: 'input' }),
+        }),
+    ];
+    // Get the field selections for the return value using custom AST logic
+    const fieldSelections = generateFieldSelections(table);
+    // Build the mutation AST
+    const ast = t.document({
+        definitions: [
+            t.operationDefinition({
+                operation: 'mutation',
+                name: `${mutationName}Mutation`,
+                variableDefinitions,
+                selectionSet: t.selectionSet({
+                    selections: [
+                        t.field({
+                            name: mutationName,
+                            args: mutationArgs,
+                            selectionSet: t.selectionSet({
+                                selections: [
+                                    t.field({
+                                        name: singularName,
+                                        selectionSet: t.selectionSet({
+                                            selections: fieldSelections,
+                                        }),
+                                    }),
+                                ],
+                            }),
+                        }),
+                    ],
+                }),
+            }),
+        ],
+    });
+    // Print the AST to get the query string
+    const queryString = print(ast);
+    return new TypedDocumentString(queryString, {
+        __ast: ast,
+    });
+}
+/**
+ * Build PostGraphile-style DELETE mutation
+ * PostGraphile expects: mutation { deleteTableName(input: { id: UUID! }) { clientMutationId } }
+ */
+export function buildPostGraphileDelete(table, _allTables, _options = {}) {
+    const mutationName = `delete${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` }),
+            }),
+        }),
+    ];
+    // Create the mutation arguments
+    const mutationArgs = [
+        t.argument({
+            name: 'input',
+            value: t.variable({ name: 'input' }),
+        }),
+    ];
+    // PostGraphile delete mutations typically return clientMutationId
+    const fieldSelections = [t.field({ name: 'clientMutationId' })];
+    // Build the mutation AST
+    const ast = t.document({
+        definitions: [
+            t.operationDefinition({
+                operation: 'mutation',
+                name: `${mutationName}Mutation`,
+                variableDefinitions,
+                selectionSet: t.selectionSet({
+                    selections: [
+                        t.field({
+                            name: mutationName,
+                            args: mutationArgs,
+                            selectionSet: t.selectionSet({
+                                selections: fieldSelections,
+                            }),
+                        }),
+                    ],
+                }),
+            }),
+        ],
+    });
+    // Print the AST to get the query string
+    const queryString = print(ast);
+    return new TypedDocumentString(queryString, {
+        __ast: ast,
+    });
+}

package/esm/generators/select.d.ts

@@ -0,0 +1,50 @@
+import { TypedDocumentString } from '../client/typed-document';
+import { QueryBuilder } from '../core/query-builder';
+import type { IntrospectionSchema, MetaObject } from '../core/types';
+import type { CleanTable } from '../types/schema';
+import type { QueryOptions } from '../types/query';
+/**
+ * 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;
+/**
+ * Convert CleanTable to MetaObject format for QueryBuilder
+ */
+export declare function cleanTableToMetaObject(tables: CleanTable[]): MetaObject;
+/**
+ * Generate basic IntrospectionSchema from CleanTable array
+ * This creates a minimal schema for AST generation
+ */
+export declare function generateIntrospectionSchema(tables: CleanTable[]): IntrospectionSchema;
+/**
+ * Create AST-based query builder for a table
+ */
+export declare function createASTQueryBuilder(tables: CleanTable[]): 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>;
+/**
+ * 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>>;
+/**
+ * Build a count query for a table
+ */
+export declare function buildCount(table: CleanTable): TypedDocumentString<{
+    [key: string]: {
+        totalCount: number;
+    };
+}, {
+    condition?: Record<string, unknown>;
+    filter?: Record<string, unknown>;
+}>;