@constructive-io/graphql-codegen 4.6.1 → 4.7.1

package/generators/field-selector.js

@@ -1,387 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertToSelectionOptions = convertToSelectionOptions;
-exports.isRelationalField = isRelationalField;
-exports.getAvailableRelations = getAvailableRelations;
-exports.validateFieldSelection = validateFieldSelection;
-const relationalFieldSetCache = new WeakMap();
-function getRelationalFieldSet(table) {
-    const cached = relationalFieldSetCache.get(table);
-    if (cached)
-        return cached;
-    const set = new Set();
-    for (const rel of table.relations.belongsTo) {
-        if (rel.fieldName)
-            set.add(rel.fieldName);
-    }
-    for (const rel of table.relations.hasOne) {
-        if (rel.fieldName)
-            set.add(rel.fieldName);
-    }
-    for (const rel of table.relations.hasMany) {
-        if (rel.fieldName)
-            set.add(rel.fieldName);
-    }
-    for (const rel of table.relations.manyToMany) {
-        if (rel.fieldName)
-            set.add(rel.fieldName);
-    }
-    relationalFieldSetCache.set(table, set);
-    return set;
-}
-/**
- * Convert simplified field selection to QueryBuilder SelectionOptions
- */
-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) {
-    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
- */
-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,
-    };
-}
+exports.validateFieldSelection = exports.getAvailableRelations = exports.isRelationalField = exports.convertToSelectionOptions = void 0;
+/**
+ * Re-export field selector utilities from @constructive-io/graphql-query.
+ *
+ * The canonical implementations of convertToSelectionOptions, isRelationalField,
+ * getAvailableRelations, and validateFieldSelection now live in graphql-query.
+ */
+var graphql_query_1 = require("@constructive-io/graphql-query");
+Object.defineProperty(exports, "convertToSelectionOptions", { enumerable: true, get: function () { return graphql_query_1.convertToSelectionOptions; } });
+Object.defineProperty(exports, "isRelationalField", { enumerable: true, get: function () { return graphql_query_1.isRelationalField; } });
+Object.defineProperty(exports, "getAvailableRelations", { enumerable: true, get: function () { return graphql_query_1.getAvailableRelations; } });
+Object.defineProperty(exports, "validateFieldSelection", { enumerable: true, get: function () { return graphql_query_1.validateFieldSelection; } });

package/generators/mutations.d.ts

@@ -1,30 +1,7 @@
-import { TypedDocumentString } from '../client/typed-document';
-import type { MutationOptions } from '../types/mutation';
-import type { CleanTable } from '../types/schema';
 /**
- * Build PostGraphile-style CREATE mutation
- * PostGraphile expects: mutation { createTableName(input: { tableName: TableNameInput! }) { tableName { ... } } }
+ * Re-export mutation generators from @constructive-io/graphql-query.
+ *
+ * The canonical implementations of buildPostGraphileCreate, buildPostGraphileUpdate,
+ * and buildPostGraphileDelete now live in graphql-query.
  */
-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;
-    } & 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;
-    };
-}>;
+export { buildPostGraphileCreate, buildPostGraphileUpdate, buildPostGraphileDelete, } from '@constructive-io/graphql-query';

package/generators/mutations.js

@@ -1,238 +1,13 @@
 "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;
+exports.buildPostGraphileDelete = exports.buildPostGraphileUpdate = exports.buildPostGraphileCreate = void 0;
 /**
- * Mutation generators for CREATE, UPDATE, and DELETE operations
- * Uses AST-based approach for PostGraphile-compatible mutations
+ * Re-export mutation generators from @constructive-io/graphql-query.
+ *
+ * The canonical implementations of buildPostGraphileCreate, buildPostGraphileUpdate,
+ * and buildPostGraphileDelete now live in graphql-query.
  */
-const t = __importStar(require("gql-ast"));
-const graphql_1 = require("graphql");
-const typed_document_1 = require("../client/typed-document");
-const custom_ast_1 = require("../core/custom-ast");
-const field_selector_1 = require("./field-selector");
-const naming_helpers_1 = require("./naming-helpers");
-/**
- * Generate field selections for PostGraphile mutations using custom AST logic
- * This handles both scalar fields and complex types that require subfield selections
- */
-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 = (0, naming_helpers_1.toCreateMutationName)(table.name, table);
-    const singularName = (0, naming_helpers_1.toCamelCaseSingular)(table.name, table);
-    const inputTypeName = (0, naming_helpers_1.toCreateInputTypeName)(table.name, table);
-    // Create the variable definition for $input
-    const variableDefinitions = [
-        t.variableDefinition({
-            variable: t.variable({ name: 'input' }),
-            type: t.nonNullType({
-                type: t.namedType({ type: 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: graphql_1.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 = (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 = (0, naming_helpers_1.toUpdateMutationName)(table.name, table);
-    const singularName = (0, naming_helpers_1.toCamelCaseSingular)(table.name, table);
-    const inputTypeName = (0, naming_helpers_1.toUpdateInputTypeName)(table.name);
-    // Create the variable definition for $input
-    const variableDefinitions = [
-        t.variableDefinition({
-            variable: t.variable({ name: 'input' }),
-            type: t.nonNullType({
-                type: t.namedType({ type: 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: graphql_1.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 = (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 = (0, naming_helpers_1.toDeleteMutationName)(table.name, table);
-    const inputTypeName = (0, naming_helpers_1.toDeleteInputTypeName)(table.name);
-    // Create the variable definition for $input
-    const variableDefinitions = [
-        t.variableDefinition({
-            variable: t.variable({ name: 'input' }),
-            type: t.nonNullType({
-                type: t.namedType({ type: 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: graphql_1.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 = (0, graphql_1.print)(ast);
-    return new typed_document_1.TypedDocumentString(queryString, {
-        __ast: ast,
-    });
-}
+var graphql_query_1 = require("@constructive-io/graphql-query");
+Object.defineProperty(exports, "buildPostGraphileCreate", { enumerable: true, get: function () { return graphql_query_1.buildPostGraphileCreate; } });
+Object.defineProperty(exports, "buildPostGraphileUpdate", { enumerable: true, get: function () { return graphql_query_1.buildPostGraphileUpdate; } });
+Object.defineProperty(exports, "buildPostGraphileDelete", { enumerable: true, get: function () { return graphql_query_1.buildPostGraphileDelete; } });