@constructive-io/graphql-query 3.2.4 → 3.3.0

package/esm/generators/select.js

@@ -0,0 +1,661 @@
+/**
+ * Query generators for SELECT, FindOne, and Count operations
+ * Uses AST-based approach for all query generation
+ */
+import * as t from 'gql-ast';
+import { Kind, OperationTypeNode, print } from 'graphql';
+import { TypedDocumentString } from '../client/typed-document';
+import { getCustomAstForCleanField, requiresSubfieldSelection, } from '../custom-ast';
+import { QueryBuilder } from '../query-builder';
+import { convertToSelectionOptions, isRelationalField } from './field-selector';
+import { normalizeInflectionValue, toCamelCasePlural, toCamelCaseSingular, toCreateInputTypeName, toCreateMutationName, toDeleteInputTypeName, toDeleteMutationName, toFilterTypeName, toOrderByTypeName, toPatchFieldName, toUpdateInputTypeName, toUpdateMutationName, } from './naming-helpers';
+// Re-export naming helpers for backwards compatibility
+export { toCamelCasePlural, toOrderByTypeName } from './naming-helpers';
+/**
+ * Convert CleanTable to MetaObject format for QueryBuilder
+ */
+export function cleanTableToMetaObject(tables) {
+    return {
+        tables: tables.map((table) => ({
+            name: table.name,
+            fields: table.fields.map((field) => ({
+                name: field.name,
+                type: {
+                    gqlType: field.type.gqlType,
+                    isArray: field.type.isArray,
+                    modifier: field.type.modifier,
+                    pgAlias: field.type.pgAlias,
+                    pgType: field.type.pgType,
+                    subtype: field.type.subtype,
+                    typmod: field.type.typmod,
+                },
+            })),
+            primaryConstraints: [], // Would need to be derived from schema
+            uniqueConstraints: [], // Would need to be derived from schema
+            foreignConstraints: table.relations.belongsTo.map((rel) => ({
+                refTable: rel.referencesTable,
+                fromKey: {
+                    name: rel.fieldName || '',
+                    type: {
+                        gqlType: 'UUID', // Default, should be derived from actual field
+                        isArray: false,
+                        modifier: null,
+                        pgAlias: null,
+                        pgType: null,
+                        subtype: null,
+                        typmod: null,
+                    },
+                    alias: rel.fieldName || '',
+                },
+                toKey: {
+                    name: 'id',
+                    type: {
+                        gqlType: 'UUID',
+                        isArray: false,
+                        modifier: null,
+                        pgAlias: null,
+                        pgType: null,
+                        subtype: null,
+                        typmod: null,
+                    },
+                },
+            })),
+        })),
+    };
+}
+/**
+ * Generate basic IntrospectionSchema from CleanTable array
+ * This creates a minimal schema for AST generation
+ */
+export function generateIntrospectionSchema(tables) {
+    const schema = {};
+    for (const table of tables) {
+        const modelName = table.name;
+        const pluralName = toCamelCasePlural(modelName, table);
+        // Basic field selection for the model
+        const selection = table.fields.map((field) => field.name);
+        // Add getMany query
+        schema[pluralName] = {
+            qtype: 'getMany',
+            model: modelName,
+            selection,
+            properties: convertFieldsToProperties(table.fields),
+        };
+        // Add getOne query (by ID)
+        const singularName = toCamelCaseSingular(modelName, table);
+        schema[singularName] = {
+            qtype: 'getOne',
+            model: modelName,
+            selection,
+            properties: convertFieldsToProperties(table.fields),
+        };
+        // Derive entity-specific names from introspection data
+        const patchFieldName = toPatchFieldName(modelName, table);
+        const createMutationName = toCreateMutationName(modelName, table);
+        const updateMutationName = toUpdateMutationName(modelName, table);
+        const deleteMutationName = toDeleteMutationName(modelName, table);
+        const createInputType = toCreateInputTypeName(modelName, table);
+        const patchType = normalizeInflectionValue(table.inflection?.patchType) ??
+            `${modelName}Patch`;
+        // Add create mutation
+        schema[createMutationName] = {
+            qtype: 'mutation',
+            mutationType: 'create',
+            model: modelName,
+            selection,
+            properties: {
+                input: {
+                    name: 'input',
+                    type: createInputType,
+                    isNotNull: true,
+                    isArray: false,
+                    isArrayNotNull: false,
+                    properties: {
+                        [singularName]: {
+                            name: singularName,
+                            type: `${modelName}Input`,
+                            isNotNull: true,
+                            isArray: false,
+                            isArrayNotNull: false,
+                            properties: convertFieldsToNestedProperties(table.fields),
+                        },
+                    },
+                },
+            },
+        };
+        // Add update mutation
+        schema[updateMutationName] = {
+            qtype: 'mutation',
+            mutationType: 'patch',
+            model: modelName,
+            selection,
+            properties: {
+                input: {
+                    name: 'input',
+                    type: toUpdateInputTypeName(modelName),
+                    isNotNull: true,
+                    isArray: false,
+                    isArrayNotNull: false,
+                    properties: {
+                        [patchFieldName]: {
+                            name: patchFieldName,
+                            type: patchType,
+                            isNotNull: true,
+                            isArray: false,
+                            isArrayNotNull: false,
+                            properties: convertFieldsToNestedProperties(table.fields),
+                        },
+                    },
+                },
+            },
+        };
+        // Add delete mutation
+        schema[deleteMutationName] = {
+            qtype: 'mutation',
+            mutationType: 'delete',
+            model: modelName,
+            selection,
+            properties: {
+                input: {
+                    name: 'input',
+                    type: toDeleteInputTypeName(modelName),
+                    isNotNull: true,
+                    isArray: false,
+                    isArrayNotNull: false,
+                    properties: {
+                        id: {
+                            name: 'id',
+                            type: 'UUID',
+                            isNotNull: true,
+                            isArray: false,
+                            isArrayNotNull: false,
+                        },
+                    },
+                },
+            },
+        };
+    }
+    return schema;
+}
+/**
+ * Convert CleanTable fields to QueryBuilder properties
+ */
+function convertFieldsToProperties(fields) {
+    const properties = {};
+    fields.forEach((field) => {
+        properties[field.name] = {
+            name: field.name,
+            type: field.type.gqlType,
+            isNotNull: !field.type.gqlType.endsWith('!'),
+            isArray: field.type.isArray,
+            isArrayNotNull: false,
+        };
+    });
+    return properties;
+}
+/**
+ * Convert fields to nested properties for mutations
+ */
+function convertFieldsToNestedProperties(fields) {
+    const properties = {};
+    fields.forEach((field) => {
+        properties[field.name] = {
+            name: field.name,
+            type: field.type.gqlType,
+            isNotNull: false, // Mutations typically allow optional fields
+            isArray: field.type.isArray,
+            isArrayNotNull: false,
+        };
+    });
+    return properties;
+}
+/**
+ * Create AST-based query builder for a table
+ */
+export function createASTQueryBuilder(tables) {
+    const metaObject = cleanTableToMetaObject(tables);
+    const introspectionSchema = generateIntrospectionSchema(tables);
+    return new QueryBuilder({
+        meta: metaObject,
+        introspection: introspectionSchema,
+    });
+}
+/**
+ * Build a SELECT query for a table with optional filtering, sorting, and pagination
+ * Uses direct AST generation without intermediate conversions
+ */
+export function buildSelect(table, allTables, options = {}) {
+    const tableList = Array.from(allTables);
+    const selection = convertFieldSelectionToSelectionOptions(table, tableList, options.fieldSelection);
+    // Generate query directly using AST
+    const queryString = generateSelectQueryAST(table, tableList, selection, options, options.relationFieldMap);
+    return new TypedDocumentString(queryString, {});
+}
+/**
+ * Build a single row query by primary key or unique field
+ */
+export function buildFindOne(table, _pkField = 'id') {
+    const queryString = generateFindOneQueryAST(table);
+    return new TypedDocumentString(queryString, {});
+}
+/**
+ * Build a count query for a table
+ */
+export function buildCount(table) {
+    const queryString = generateCountQueryAST(table);
+    return new TypedDocumentString(queryString, {});
+}
+function convertFieldSelectionToSelectionOptions(table, allTables, options) {
+    return convertToSelectionOptions(table, allTables, options);
+}
+/**
+ * Generate SELECT query AST directly from CleanTable
+ */
+function generateSelectQueryAST(table, allTables, selection, options, relationFieldMap) {
+    const pluralName = toCamelCasePlural(table.name, table);
+    // Generate field selections
+    const fieldSelections = generateFieldSelectionsFromOptions(table, allTables, selection, relationFieldMap);
+    // Build the query AST
+    const variableDefinitions = [];
+    const queryArgs = [];
+    // Add pagination variables if needed
+    const limitValue = options.limit ?? options.first;
+    if (limitValue !== undefined) {
+        variableDefinitions.push(t.variableDefinition({
+            variable: t.variable({ name: 'first' }),
+            type: t.namedType({ type: 'Int' }),
+        }));
+        queryArgs.push(t.argument({
+            name: 'first',
+            value: t.variable({ name: 'first' }),
+        }));
+    }
+    if (options.offset !== undefined) {
+        variableDefinitions.push(t.variableDefinition({
+            variable: t.variable({ name: 'offset' }),
+            type: t.namedType({ type: 'Int' }),
+        }));
+        queryArgs.push(t.argument({
+            name: 'offset',
+            value: t.variable({ name: 'offset' }),
+        }));
+    }
+    // Add cursor-based pagination variables if needed (for infinite scroll)
+    if (options.after !== undefined) {
+        variableDefinitions.push(t.variableDefinition({
+            variable: t.variable({ name: 'after' }),
+            type: t.namedType({ type: 'Cursor' }),
+        }));
+        queryArgs.push(t.argument({
+            name: 'after',
+            value: t.variable({ name: 'after' }),
+        }));
+    }
+    if (options.before !== undefined) {
+        variableDefinitions.push(t.variableDefinition({
+            variable: t.variable({ name: 'before' }),
+            type: t.namedType({ type: 'Cursor' }),
+        }));
+        queryArgs.push(t.argument({
+            name: 'before',
+            value: t.variable({ name: 'before' }),
+        }));
+    }
+    // Add filter variables if needed
+    if (options.where) {
+        variableDefinitions.push(t.variableDefinition({
+            variable: t.variable({ name: 'filter' }),
+            type: t.namedType({ type: toFilterTypeName(table.name, table) }),
+        }));
+        queryArgs.push(t.argument({
+            name: 'filter',
+            value: t.variable({ name: 'filter' }),
+        }));
+    }
+    // Add orderBy variables if needed
+    if (options.orderBy && options.orderBy.length > 0) {
+        variableDefinitions.push(t.variableDefinition({
+            variable: t.variable({ name: 'orderBy' }),
+            // PostGraphile expects [ProductsOrderBy!] - list of non-null enum values
+            type: t.listType({
+                type: t.nonNullType({
+                    type: t.namedType({ type: toOrderByTypeName(table.name, table) }),
+                }),
+            }),
+        }));
+        queryArgs.push(t.argument({
+            name: 'orderBy',
+            value: t.variable({ name: 'orderBy' }),
+        }));
+    }
+    // Build connection selections: totalCount, nodes, and optionally pageInfo
+    const connectionSelections = [
+        t.field({ name: 'totalCount' }),
+        t.field({
+            name: 'nodes',
+            selectionSet: t.selectionSet({
+                selections: fieldSelections,
+            }),
+        }),
+    ];
+    // Add pageInfo if requested (for cursor-based pagination / infinite scroll)
+    if (options.includePageInfo ||
+        options.after !== undefined ||
+        options.before !== undefined) {
+        connectionSelections.push(t.field({
+            name: 'pageInfo',
+            selectionSet: t.selectionSet({
+                selections: [
+                    t.field({ name: 'hasNextPage' }),
+                    t.field({ name: 'hasPreviousPage' }),
+                    t.field({ name: 'startCursor' }),
+                    t.field({ name: 'endCursor' }),
+                ],
+            }),
+        }));
+    }
+    const ast = t.document({
+        definitions: [
+            t.operationDefinition({
+                operation: OperationTypeNode.QUERY,
+                name: `${pluralName}Query`,
+                variableDefinitions,
+                selectionSet: t.selectionSet({
+                    selections: [
+                        t.field({
+                            name: pluralName,
+                            args: queryArgs,
+                            selectionSet: t.selectionSet({
+                                selections: connectionSelections,
+                            }),
+                        }),
+                    ],
+                }),
+            }),
+        ],
+    });
+    return print(ast);
+}
+/**
+ * Generate field selections from SelectionOptions
+ */
+function generateFieldSelectionsFromOptions(table, allTables, selection, relationFieldMap) {
+    const DEFAULT_NESTED_RELATION_FIRST = 20;
+    if (!selection) {
+        // Default to all non-relational fields (includes complex fields like JSON, geometry, etc.)
+        return table.fields
+            .filter((field) => !isRelationalField(field.name, table))
+            .map((field) => {
+            if (requiresSubfieldSelection(field)) {
+                // For complex fields that require subfield selection, use custom AST generation
+                return getCustomAstForCleanField(field);
+            }
+            else {
+                // For simple fields, use basic field selection
+                return t.field({ name: field.name });
+            }
+        });
+    }
+    const fieldSelections = [];
+    Object.entries(selection).forEach(([fieldName, fieldOptions]) => {
+        const resolvedField = resolveSelectionFieldName(fieldName, relationFieldMap);
+        if (!resolvedField) {
+            return; // Field mapped to null — omit it
+        }
+        if (fieldOptions === true) {
+            // Check if this field requires subfield selection
+            const field = table.fields.find((f) => f.name === fieldName);
+            if (field && requiresSubfieldSelection(field)) {
+                // Use custom AST generation for complex fields
+                fieldSelections.push(getCustomAstForCleanField(field));
+            }
+            else {
+                // Simple field selection for scalar fields
+                fieldSelections.push(createFieldSelectionNode(resolvedField.name, resolvedField.alias));
+            }
+        }
+        else if (typeof fieldOptions === 'object' && fieldOptions.select) {
+            // Nested field selection (for relation fields)
+            const nestedSelections = [];
+            // Find the related table to check for complex fields
+            const relatedTable = findRelatedTable(fieldName, table, allTables);
+            Object.entries(fieldOptions.select).forEach(([nestedField, include]) => {
+                if (include) {
+                    // Check if this nested field requires subfield selection
+                    const nestedFieldDef = relatedTable?.fields.find((f) => f.name === nestedField);
+                    if (nestedFieldDef && requiresSubfieldSelection(nestedFieldDef)) {
+                        // Use custom AST generation for complex nested fields
+                        nestedSelections.push(getCustomAstForCleanField(nestedFieldDef));
+                    }
+                    else {
+                        // Simple field selection for scalar nested fields
+                        nestedSelections.push(t.field({ name: nestedField }));
+                    }
+                }
+            });
+            // Check if this is a hasMany relation that uses Connection pattern
+            const relationInfo = getRelationInfo(fieldName, table);
+            if (relationInfo &&
+                (relationInfo.type === 'hasMany' || relationInfo.type === 'manyToMany')) {
+                // For hasMany/manyToMany relations, wrap selections in nodes { ... }
+                fieldSelections.push(createFieldSelectionNode(resolvedField.name, resolvedField.alias, [
+                    t.argument({
+                        name: 'first',
+                        value: t.intValue({
+                            value: DEFAULT_NESTED_RELATION_FIRST.toString(),
+                        }),
+                    }),
+                ], t.selectionSet({
+                    selections: [
+                        t.field({
+                            name: 'nodes',
+                            selectionSet: t.selectionSet({
+                                selections: nestedSelections,
+                            }),
+                        }),
+                    ],
+                })));
+            }
+            else {
+                // For belongsTo/hasOne relations, use direct selection
+                fieldSelections.push(createFieldSelectionNode(resolvedField.name, resolvedField.alias, undefined, t.selectionSet({
+                    selections: nestedSelections,
+                })));
+            }
+        }
+    });
+    return fieldSelections;
+}
+// ---------------------------------------------------------------------------
+// Field aliasing helpers (back-ported from Dashboard query-generator.ts)
+// ---------------------------------------------------------------------------
+/**
+ * Resolve a field name through the optional relationFieldMap.
+ * Returns `null` if the field should be omitted (mapped to null).
+ * Returns `{ name, alias? }` where alias is set when the mapped name differs.
+ */
+function resolveSelectionFieldName(fieldName, relationFieldMap) {
+    if (!relationFieldMap || !(fieldName in relationFieldMap)) {
+        return { name: fieldName };
+    }
+    const mappedFieldName = relationFieldMap[fieldName];
+    if (!mappedFieldName) {
+        return null; // mapped to null → omit
+    }
+    if (mappedFieldName === fieldName) {
+        return { name: fieldName };
+    }
+    return { name: mappedFieldName, alias: fieldName };
+}
+/**
+ * Create a field AST node with optional alias support.
+ * When alias is provided and differs from name, a GraphQL alias is emitted:
+ * `alias: name { … }` instead of `name { … }`
+ */
+function createFieldSelectionNode(name, alias, args, selectionSet) {
+    const node = t.field({ name, args, selectionSet });
+    if (!alias || alias === name) {
+        return node;
+    }
+    return {
+        ...node,
+        alias: {
+            kind: Kind.NAME,
+            value: alias,
+        },
+    };
+}
+/**
+ * Get relation information for a field
+ */
+function getRelationInfo(fieldName, table) {
+    const { belongsTo, hasOne, hasMany, manyToMany } = table.relations;
+    // Check belongsTo relations
+    const belongsToRel = belongsTo.find((rel) => rel.fieldName === fieldName);
+    if (belongsToRel) {
+        return { type: 'belongsTo', relation: belongsToRel };
+    }
+    // Check hasOne relations
+    const hasOneRel = hasOne.find((rel) => rel.fieldName === fieldName);
+    if (hasOneRel) {
+        return { type: 'hasOne', relation: hasOneRel };
+    }
+    // Check hasMany relations
+    const hasManyRel = hasMany.find((rel) => rel.fieldName === fieldName);
+    if (hasManyRel) {
+        return { type: 'hasMany', relation: hasManyRel };
+    }
+    // Check manyToMany relations
+    const manyToManyRel = manyToMany.find((rel) => rel.fieldName === fieldName);
+    if (manyToManyRel) {
+        return { type: 'manyToMany', relation: manyToManyRel };
+    }
+    return null;
+}
+/**
+ * Find the related table for a given relation field
+ */
+function findRelatedTable(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) {
+        return null;
+    }
+    // Find the related table in allTables
+    return allTables.find((tbl) => tbl.name === referencedTableName) || null;
+}
+/**
+ * Generate FindOne query AST directly from CleanTable
+ */
+function generateFindOneQueryAST(table) {
+    const singularName = toCamelCaseSingular(table.name, table);
+    // Generate field selections (include all non-relational fields, including complex types)
+    const fieldSelections = table.fields
+        .filter((field) => !isRelationalField(field.name, table))
+        .map((field) => {
+        if (requiresSubfieldSelection(field)) {
+            // For complex fields that require subfield selection, use custom AST generation
+            return getCustomAstForCleanField(field);
+        }
+        else {
+            // For simple fields, use basic field selection
+            return t.field({ name: field.name });
+        }
+    });
+    const ast = t.document({
+        definitions: [
+            t.operationDefinition({
+                operation: OperationTypeNode.QUERY,
+                name: `${singularName}Query`,
+                variableDefinitions: [
+                    t.variableDefinition({
+                        variable: t.variable({ name: 'id' }),
+                        type: t.nonNullType({
+                            type: t.namedType({ type: 'UUID' }),
+                        }),
+                    }),
+                ],
+                selectionSet: t.selectionSet({
+                    selections: [
+                        t.field({
+                            name: singularName,
+                            args: [
+                                t.argument({
+                                    name: 'id',
+                                    value: t.variable({ name: 'id' }),
+                                }),
+                            ],
+                            selectionSet: t.selectionSet({
+                                selections: fieldSelections,
+                            }),
+                        }),
+                    ],
+                }),
+            }),
+        ],
+    });
+    return print(ast);
+}
+/**
+ * Generate Count query AST directly from CleanTable
+ */
+function generateCountQueryAST(table) {
+    const pluralName = toCamelCasePlural(table.name, table);
+    const ast = t.document({
+        definitions: [
+            t.operationDefinition({
+                operation: OperationTypeNode.QUERY,
+                name: `${pluralName}CountQuery`,
+                variableDefinitions: [
+                    t.variableDefinition({
+                        variable: t.variable({ name: 'filter' }),
+                        type: t.namedType({ type: toFilterTypeName(table.name, table) }),
+                    }),
+                ],
+                selectionSet: t.selectionSet({
+                    selections: [
+                        t.field({
+                            name: pluralName,
+                            args: [
+                                t.argument({
+                                    name: 'filter',
+                                    value: t.variable({ name: 'filter' }),
+                                }),
+                            ],
+                            selectionSet: t.selectionSet({
+                                selections: [t.field({ name: 'totalCount' })],
+                            }),
+                        }),
+                    ],
+                }),
+            }),
+        ],
+    });
+    return print(ast);
+}

package/esm/index.js

@@ -1,4 +1,34 @@
+/**
+ * @constructive-io/graphql-query
+ *
+ * Browser-safe GraphQL query generation core.
+ * Contains the pure-function query builders, AST generators, naming helpers,
+ * introspection utilities, and client execution layer.
+ *
+ * This package is the canonical source for runtime query generation logic.
+ * @constructive-io/graphql-codegen depends on this for the core and adds
+ * Node.js-only build-time features (CLI, file output, watch mode, etc.).
+ */
+// QueryBuilder class (runtime query builder)
 export { QueryBuilder } from './query-builder';
+// QueryExecutor (server-side execution via PostGraphile)
 export { QueryExecutor, createExecutor } from './executor';
+// AST builders (getAll, getMany, getOne, createOne, patchOne, deleteOne)
+export * from './ast';
+// Custom AST (geometry, interval, etc.)
+export * from './custom-ast';
+// All types (core + codegen-style schema/introspection/query/mutation/selection)
 export * from './types';
+// Meta object utilities (convert, validate)
 export * as MetaObject from './meta-object';
+// Also export meta-object functions directly for codegen backward compatibility
+export { convertFromMetaSchema } from './meta-object/convert';
+export { validateMetaObject } from './meta-object/validate';
+// Generators (buildSelect, buildFindOne, buildCount, mutations, field-selector, naming-helpers)
+export * from './generators';
+// Client utilities (TypedDocumentString, error handling, execute)
+export * from './client';
+// Introspection utilities (infer-tables, transform, transform-schema, schema-query)
+export * from './introspect';
+// Utility functions
+export { stripSmartComments } from './utils';