@constructive-io/graphql-query 3.2.5 → 3.3.0

package/esm/generators/field-selector.js

@@ -0,0 +1,381 @@
+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
+ */
+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) {
+    return getRelationalFieldSet(table).has(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 scalarFieldSet = new Set(scalarFields);
+    // Use Set for O(1) duplicate checking
+    const includedSet = new Set();
+    const included = [];
+    const push = (fieldName) => {
+        if (!fieldName)
+            return;
+        if (!scalarFieldSet.has(fieldName))
+            return;
+        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.
+    push('id');
+    push('rowId');
+    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.js

@@ -0,0 +1,13 @@
+/**
+ * Generators barrel export
+ *
+ * Re-exports all query/mutation generation functions and naming helpers.
+ */
+// SELECT, FindOne, Count query generators
+export { buildSelect, buildFindOne, buildCount, cleanTableToMetaObject, createASTQueryBuilder, generateIntrospectionSchema, toCamelCasePlural, toOrderByTypeName, } from './select';
+// Mutation generators (CREATE, UPDATE, DELETE)
+export { buildPostGraphileCreate, buildPostGraphileUpdate, buildPostGraphileDelete, } from './mutations';
+// Field selection utilities
+export { convertToSelectionOptions, isRelationalField, getAvailableRelations, validateFieldSelection, } from './field-selector';
+// Naming helpers (server-aware inflection)
+export { normalizeInflectionValue, toCamelCaseSingular, toCreateMutationName, toUpdateMutationName, toDeleteMutationName, toCreateInputTypeName, toUpdateInputTypeName, toDeleteInputTypeName, toFilterTypeName, toPatchFieldName, toOrderByEnumValue, } from './naming-helpers';

package/esm/generators/mutations.js

@@ -0,0 +1,200 @@
+/**
+ * Mutation generators for CREATE, UPDATE, and DELETE operations
+ * Uses AST-based approach for PostGraphile-compatible mutations
+ */
+import * as t from 'gql-ast';
+import { OperationTypeNode, print } from 'graphql';
+import { TypedDocumentString } from '../client/typed-document';
+import { getCustomAstForCleanField, requiresSubfieldSelection, } from '../custom-ast';
+import { isRelationalField } from './field-selector';
+import { toCamelCaseSingular, toCreateInputTypeName, toCreateMutationName, toDeleteInputTypeName, toDeleteMutationName, toUpdateInputTypeName, toUpdateMutationName, } from './naming-helpers';
+/**
+ * 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 = toCreateMutationName(table.name, table);
+    const singularName = toCamelCaseSingular(table.name, table);
+    const inputTypeName = 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: inputTypeName }),
+            }),
+        }),
+    ];
+    // 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: OperationTypeNode.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 = toUpdateMutationName(table.name, table);
+    const singularName = toCamelCaseSingular(table.name, table);
+    const inputTypeName = 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: inputTypeName }),
+            }),
+        }),
+    ];
+    // 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: OperationTypeNode.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 = toDeleteMutationName(table.name, table);
+    const inputTypeName = 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: inputTypeName }),
+            }),
+        }),
+    ];
+    // 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: OperationTypeNode.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,
+    });
+}