@constructive-io/graphql-codegen 2.19.0 → 2.20.0

package/generators/field-selector.js

@@ -0,0 +1,361 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertToSelectionOptions = convertToSelectionOptions;
+exports.isRelationalField = isRelationalField;
+exports.getAvailableRelations = getAvailableRelations;
+exports.validateFieldSelection = validateFieldSelection;
+/**
+ * Convert simplified field selection to QueryBuilder SelectionOptions
+ */
+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
+ */
+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
+ */
+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
+ */
+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/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/generators/index.js

@@ -0,0 +1,27 @@
+"use strict";
+/**
+ * Query and mutation generator exports
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildPostGraphileDelete = exports.buildPostGraphileUpdate = exports.buildPostGraphileCreate = exports.createASTQueryBuilder = exports.generateIntrospectionSchema = exports.cleanTableToMetaObject = exports.toOrderByTypeName = exports.toCamelCasePlural = exports.buildCount = exports.buildFindOne = exports.buildSelect = exports.validateFieldSelection = exports.getAvailableRelations = exports.isRelationalField = exports.convertToSelectionOptions = void 0;
+// Field selector utilities
+var field_selector_1 = require("./field-selector");
+Object.defineProperty(exports, "convertToSelectionOptions", { enumerable: true, get: function () { return field_selector_1.convertToSelectionOptions; } });
+Object.defineProperty(exports, "isRelationalField", { enumerable: true, get: function () { return field_selector_1.isRelationalField; } });
+Object.defineProperty(exports, "getAvailableRelations", { enumerable: true, get: function () { return field_selector_1.getAvailableRelations; } });
+Object.defineProperty(exports, "validateFieldSelection", { enumerable: true, get: function () { return field_selector_1.validateFieldSelection; } });
+// Query generators
+var select_1 = require("./select");
+Object.defineProperty(exports, "buildSelect", { enumerable: true, get: function () { return select_1.buildSelect; } });
+Object.defineProperty(exports, "buildFindOne", { enumerable: true, get: function () { return select_1.buildFindOne; } });
+Object.defineProperty(exports, "buildCount", { enumerable: true, get: function () { return select_1.buildCount; } });
+Object.defineProperty(exports, "toCamelCasePlural", { enumerable: true, get: function () { return select_1.toCamelCasePlural; } });
+Object.defineProperty(exports, "toOrderByTypeName", { enumerable: true, get: function () { return select_1.toOrderByTypeName; } });
+Object.defineProperty(exports, "cleanTableToMetaObject", { enumerable: true, get: function () { return select_1.cleanTableToMetaObject; } });
+Object.defineProperty(exports, "generateIntrospectionSchema", { enumerable: true, get: function () { return select_1.generateIntrospectionSchema; } });
+Object.defineProperty(exports, "createASTQueryBuilder", { enumerable: true, get: function () { return select_1.createASTQueryBuilder; } });
+// Mutation generators
+var mutations_1 = require("./mutations");
+Object.defineProperty(exports, "buildPostGraphileCreate", { enumerable: true, get: function () { return mutations_1.buildPostGraphileCreate; } });
+Object.defineProperty(exports, "buildPostGraphileUpdate", { enumerable: true, get: function () { return mutations_1.buildPostGraphileUpdate; } });
+Object.defineProperty(exports, "buildPostGraphileDelete", { enumerable: true, get: function () { return mutations_1.buildPostGraphileDelete; } });

package/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/generators/mutations.js

@@ -0,0 +1,235 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildPostGraphileCreate = buildPostGraphileCreate;
+exports.buildPostGraphileUpdate = buildPostGraphileUpdate;
+exports.buildPostGraphileDelete = buildPostGraphileDelete;
+/**
+ * Mutation generators for CREATE, UPDATE, and DELETE operations
+ * Uses AST-based approach for PostGraphile-compatible mutations
+ */
+const t = __importStar(require("gql-ast"));
+const graphql_1 = require("graphql");
+const inflection = __importStar(require("inflection"));
+const typed_document_1 = require("../client/typed-document");
+const custom_ast_1 = require("../core/custom-ast");
+const field_selector_1 = require("./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) => !(0, field_selector_1.isRelationalField)(field.name, table)) // Exclude relational fields
+        .map((field) => {
+        if ((0, custom_ast_1.requiresSubfieldSelection)(field)) {
+            // Use custom AST generation for complex types
+            return (0, custom_ast_1.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 { ... } } }
+ */
+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 = (0, graphql_1.print)(ast);
+    return new typed_document_1.TypedDocumentString(queryString, {
+        __ast: ast,
+    });
+}
+/**
+ * Build PostGraphile-style UPDATE mutation
+ * PostGraphile expects: mutation { updateTableName(input: { id: UUID!, patch: TableNamePatch! }) { tableName { ... } } }
+ */
+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 = (0, graphql_1.print)(ast);
+    return new typed_document_1.TypedDocumentString(queryString, {
+        __ast: ast,
+    });
+}
+/**
+ * Build PostGraphile-style DELETE mutation
+ * PostGraphile expects: mutation { deleteTableName(input: { id: UUID! }) { clientMutationId } }
+ */
+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 = (0, graphql_1.print)(ast);
+    return new typed_document_1.TypedDocumentString(queryString, {
+        __ast: ast,
+    });
+}