@constructive-io/graphql-query 3.2.4 → 3.3.0

package/generators/mutations.js

@@ -0,0 +1,238 @@
+"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 typed_document_1 = require("../client/typed-document");
+const custom_ast_1 = require("../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,
+    });
+}

package/generators/naming-helpers.d.ts

@@ -0,0 +1,48 @@
+import type { CleanTable } from '../types/schema';
+/**
+ * Safely normalise a server-provided inflection value.
+ * Returns `null` for null, undefined, or whitespace-only strings.
+ */
+export declare function normalizeInflectionValue(value: string | null | undefined): string | null;
+/**
+ * Convert PascalCase table name to camelCase plural for GraphQL queries.
+ * Prefers server-provided `table.query.all` / `table.inflection.allRows`
+ * when available, with guards against naive pluralisation drift and
+ * missing camelCase boundaries.
+ *
+ * Example: "ActionGoal" -> "actionGoals", "User" -> "users", "Person" -> "people"
+ */
+export declare function toCamelCasePlural(tableName: string, table?: CleanTable | null): string;
+/**
+ * Convert PascalCase table name to camelCase singular field name.
+ * Prefers server-provided names when available.
+ */
+export declare function toCamelCaseSingular(tableName: string, table?: CleanTable | null): string;
+export declare function toCreateMutationName(tableName: string, table?: CleanTable | null): string;
+export declare function toUpdateMutationName(tableName: string, table?: CleanTable | null): string;
+export declare function toDeleteMutationName(tableName: string, table?: CleanTable | null): string;
+export declare function toCreateInputTypeName(tableName: string, table?: CleanTable | null): string;
+export declare function toUpdateInputTypeName(tableName: string): string;
+export declare function toDeleteInputTypeName(tableName: string): string;
+export declare function toFilterTypeName(tableName: string, table?: CleanTable | null): string;
+/**
+ * Resolve PostGraphile patch field name.
+ * In v5 this is typically entity-specific: e.g. "userPatch", "contactPatch".
+ * Prefers the value discovered from the schema (`table.query.patchFieldName`
+ * or `table.inflection.patchField`), falls back to `${singularName}Patch`.
+ */
+export declare function toPatchFieldName(tableName: string, table?: CleanTable | null): string;
+/**
+ * Convert camelCase field name to SCREAMING_SNAKE_CASE for PostGraphile
+ * orderBy enums.
+ *
+ * "displayName" -> "DISPLAY_NAME_ASC"
+ * "createdAt"   -> "CREATED_AT_DESC"
+ * "id"          -> "ID_ASC"
+ */
+export declare function toOrderByEnumValue(fieldName: string, direction: 'asc' | 'desc'): string;
+/**
+ * Generate the PostGraphile OrderBy enum type name for a table.
+ * Prefers server-provided `table.inflection.orderByType` when available.
+ */
+export declare function toOrderByTypeName(tableName: string, table?: CleanTable | null): string;

package/generators/naming-helpers.js

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeInflectionValue = normalizeInflectionValue;
+exports.toCamelCasePlural = toCamelCasePlural;
+exports.toCamelCaseSingular = toCamelCaseSingular;
+exports.toCreateMutationName = toCreateMutationName;
+exports.toUpdateMutationName = toUpdateMutationName;
+exports.toDeleteMutationName = toDeleteMutationName;
+exports.toCreateInputTypeName = toCreateInputTypeName;
+exports.toUpdateInputTypeName = toUpdateInputTypeName;
+exports.toDeleteInputTypeName = toDeleteInputTypeName;
+exports.toFilterTypeName = toFilterTypeName;
+exports.toPatchFieldName = toPatchFieldName;
+exports.toOrderByEnumValue = toOrderByEnumValue;
+exports.toOrderByTypeName = toOrderByTypeName;
+/**
+ * Server-aware naming helpers for GraphQL query/mutation generation.
+ *
+ * These functions prefer names already discovered from the GraphQL schema
+ * (stored on `table.query` and `table.inflection` by `infer-tables.ts`)
+ * and fall back to local inflection when introspection data is unavailable.
+ *
+ * Back-ported from Dashboard's `packages/data/src/query-generator.ts`.
+ */
+const inflekt_1 = require("inflekt");
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+/**
+ * Safely normalise a server-provided inflection value.
+ * Returns `null` for null, undefined, or whitespace-only strings.
+ */
+function normalizeInflectionValue(value) {
+    if (typeof value !== 'string')
+        return null;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+// ---------------------------------------------------------------------------
+// Plural / Singular
+// ---------------------------------------------------------------------------
+/**
+ * Convert PascalCase table name to camelCase plural for GraphQL queries.
+ * Prefers server-provided `table.query.all` / `table.inflection.allRows`
+ * when available, with guards against naive pluralisation drift and
+ * missing camelCase boundaries.
+ *
+ * Example: "ActionGoal" -> "actionGoals", "User" -> "users", "Person" -> "people"
+ */
+function toCamelCasePlural(tableName, table) {
+    const singular = (0, inflekt_1.camelize)(tableName, true);
+    const inflectedPlural = (0, inflekt_1.pluralize)(singular);
+    const serverPluralCandidates = [
+        table?.query?.all,
+        table?.inflection?.allRows,
+    ];
+    for (const candidateRaw of serverPluralCandidates) {
+        const candidate = normalizeInflectionValue(candidateRaw);
+        if (!candidate)
+            continue;
+        // Guard against known fallback drift:
+        // 1. Naive pluralisation: "activitys" instead of "activities"
+        const isNaivePlural = candidate === `${singular}s` && candidate !== inflectedPlural;
+        // 2. Missing camelCase boundaries: "deliveryzones" instead of "deliveryZones"
+        const isMiscased = candidate !== inflectedPlural &&
+            candidate.toLowerCase() === inflectedPlural.toLowerCase();
+        if (isNaivePlural || isMiscased)
+            continue;
+        return candidate;
+    }
+    return inflectedPlural;
+}
+/**
+ * Convert PascalCase table name to camelCase singular field name.
+ * Prefers server-provided names when available.
+ */
+function toCamelCaseSingular(tableName, table) {
+    const localSingular = (0, inflekt_1.camelize)(tableName, true);
+    for (const candidateRaw of [
+        table?.query?.one,
+        table?.inflection?.tableFieldName,
+    ]) {
+        const candidate = normalizeInflectionValue(candidateRaw);
+        if (!candidate)
+            continue;
+        // Reject miscased versions: "deliveryzone" vs "deliveryZone"
+        if (candidate !== localSingular &&
+            candidate.toLowerCase() === localSingular.toLowerCase())
+            continue;
+        return candidate;
+    }
+    return localSingular;
+}
+// ---------------------------------------------------------------------------
+// Mutation names
+// ---------------------------------------------------------------------------
+function toCreateMutationName(tableName, table) {
+    return (normalizeInflectionValue(table?.query?.create) ?? `create${tableName}`);
+}
+function toUpdateMutationName(tableName, table) {
+    return (normalizeInflectionValue(table?.query?.update) ?? `update${tableName}`);
+}
+function toDeleteMutationName(tableName, table) {
+    return (normalizeInflectionValue(table?.query?.delete) ?? `delete${tableName}`);
+}
+// ---------------------------------------------------------------------------
+// Input / type names
+// ---------------------------------------------------------------------------
+function toCreateInputTypeName(tableName, table) {
+    return (normalizeInflectionValue(table?.inflection?.createInputType) ??
+        `Create${tableName}Input`);
+}
+function toUpdateInputTypeName(tableName) {
+    return `Update${tableName}Input`;
+}
+function toDeleteInputTypeName(tableName) {
+    return `Delete${tableName}Input`;
+}
+function toFilterTypeName(tableName, table) {
+    return (normalizeInflectionValue(table?.inflection?.filterType) ??
+        `${tableName}Filter`);
+}
+// ---------------------------------------------------------------------------
+// Patch field name
+// ---------------------------------------------------------------------------
+/**
+ * Resolve PostGraphile patch field name.
+ * In v5 this is typically entity-specific: e.g. "userPatch", "contactPatch".
+ * Prefers the value discovered from the schema (`table.query.patchFieldName`
+ * or `table.inflection.patchField`), falls back to `${singularName}Patch`.
+ */
+function toPatchFieldName(tableName, table) {
+    // First check the patch field name discovered from UpdateXxxInput
+    const introspectedPatch = normalizeInflectionValue(table?.query?.patchFieldName);
+    if (introspectedPatch)
+        return introspectedPatch;
+    // Then check the inflection table
+    const explicitPatchField = normalizeInflectionValue(table?.inflection?.patchField);
+    if (explicitPatchField)
+        return explicitPatchField;
+    return `${toCamelCaseSingular(tableName, table)}Patch`;
+}
+// ---------------------------------------------------------------------------
+// OrderBy helpers
+// ---------------------------------------------------------------------------
+/**
+ * Convert camelCase field name to SCREAMING_SNAKE_CASE for PostGraphile
+ * orderBy enums.
+ *
+ * "displayName" -> "DISPLAY_NAME_ASC"
+ * "createdAt"   -> "CREATED_AT_DESC"
+ * "id"          -> "ID_ASC"
+ */
+function toOrderByEnumValue(fieldName, direction) {
+    const screaming = fieldName
+        .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
+        .toUpperCase();
+    return `${screaming}_${direction.toUpperCase()}`;
+}
+/**
+ * Generate the PostGraphile OrderBy enum type name for a table.
+ * Prefers server-provided `table.inflection.orderByType` when available.
+ */
+function toOrderByTypeName(tableName, table) {
+    if (table?.inflection?.orderByType)
+        return table.inflection.orderByType;
+    const plural = toCamelCasePlural(tableName, table);
+    return `${plural.charAt(0).toUpperCase() + plural.slice(1)}OrderBy`;
+}

package/generators/select.d.ts

@@ -0,0 +1,39 @@
+import { TypedDocumentString } from '../client/typed-document';
+import { QueryBuilder } from '../query-builder';
+import type { MetaObject, QueryIntrospectionSchema } from '../types';
+import type { QueryOptions } from '../types/query';
+import type { CleanTable } from '../types/schema';
+export { toCamelCasePlural, toOrderByTypeName } from './naming-helpers';
+/**
+ * Convert CleanTable to MetaObject format for QueryBuilder
+ */
+export declare function cleanTableToMetaObject(tables: CleanTable[]): MetaObject;
+/**
+ * Generate basic IntrospectionSchema from CleanTable array
+ * This creates a minimal schema for AST generation
+ */
+export declare function generateIntrospectionSchema(tables: CleanTable[]): QueryIntrospectionSchema;
+/**
+ * Create AST-based query builder for a table
+ */
+export declare function createASTQueryBuilder(tables: CleanTable[]): QueryBuilder;
+/**
+ * Build a SELECT query for a table with optional filtering, sorting, and pagination
+ * Uses direct AST generation without intermediate conversions
+ */
+export declare function buildSelect(table: CleanTable, allTables: readonly CleanTable[], options?: QueryOptions): TypedDocumentString<Record<string, unknown>, QueryOptions>;
+/**
+ * Build a single row query by primary key or unique field
+ */
+export declare function buildFindOne(table: CleanTable, _pkField?: string): TypedDocumentString<Record<string, unknown>, Record<string, unknown>>;
+/**
+ * Build a count query for a table
+ */
+export declare function buildCount(table: CleanTable): TypedDocumentString<{
+    [key: string]: {
+        totalCount: number;
+    };
+}, {
+    condition?: Record<string, unknown>;
+    filter?: Record<string, unknown>;
+}>;