@constructive-io/graphql-query 3.2.4 → 3.3.0

package/esm/types/introspection.js

@@ -0,0 +1,54 @@
+/**
+ * GraphQL Introspection Types
+ *
+ * Standard types for GraphQL schema introspection via __schema query.
+ * These mirror the GraphQL introspection spec.
+ */
+// ============================================================================
+// Type Guards
+// ============================================================================
+/**
+ * Check if type kind is a wrapper (LIST or NON_NULL)
+ */
+export function isWrapperType(kind) {
+    return kind === 'LIST' || kind === 'NON_NULL';
+}
+/**
+ * Check if type kind is a named type (has a name)
+ */
+export function isNamedType(kind) {
+    return !isWrapperType(kind);
+}
+/**
+ * Unwrap a type reference to get the base named type
+ */
+export function unwrapType(typeRef) {
+    let current = typeRef;
+    while (current.ofType) {
+        current = current.ofType;
+    }
+    return current;
+}
+/**
+ * Get the base type name from a possibly wrapped type
+ */
+export function getBaseTypeName(typeRef) {
+    return unwrapType(typeRef).name;
+}
+/**
+ * Check if a type reference is non-null (required)
+ */
+export function isNonNull(typeRef) {
+    return typeRef.kind === 'NON_NULL';
+}
+/**
+ * Check if a type reference is a list
+ */
+export function isList(typeRef) {
+    if (typeRef.kind === 'LIST')
+        return true;
+    if (typeRef.kind === 'NON_NULL' && typeRef.ofType) {
+        return typeRef.ofType.kind === 'LIST';
+    }
+    return false;
+}

package/esm/types/mutation.js

@@ -0,0 +1,4 @@
+/**
+ * Mutation-related types
+ */
+export {};

package/esm/types/query.js

@@ -0,0 +1,4 @@
+/**
+ * Query-related types for building GraphQL operations
+ */
+export {};

package/esm/types/schema.js

@@ -0,0 +1,5 @@
+/**
+ * Core schema types for representing PostGraphile table metadata
+ * These are "clean" versions that remove nullable/undefined complexity
+ */
+export {};

package/esm/types/selection.js

@@ -0,0 +1,4 @@
+/**
+ * Field selection types for controlling which fields are included in queries
+ */
+export {};

package/esm/utils.js

@@ -0,0 +1,69 @@
+/**
+ * Utility functions for GraphQL query generation
+ */
+/**
+ * PostGraphile boilerplate description prefixes that should be suppressed
+ */
+const POSTGRAPHILE_BOILERPLATE = [
+    'The exclusive input argument for this mutation.',
+    'An arbitrary string value with no semantic meaning.',
+    'The exact same `clientMutationId` that was provided in the mutation input,',
+    'The output of our',
+    'All input for the',
+    'A cursor for use in pagination.',
+    'An edge for our',
+    'Information to aid in pagination.',
+    'Reads and enables pagination through a set of',
+    'A list of edges which contains the',
+    'The count of *all* `',
+    'A list of `',
+    'Our root query field',
+    'Reads a single',
+    'The root query type',
+    'The root mutation type',
+];
+/**
+ * Check if a description is generic PostGraphile boilerplate that should be suppressed.
+ */
+function isBoilerplateDescription(description) {
+    const trimmed = description.trim();
+    return POSTGRAPHILE_BOILERPLATE.some((bp) => trimmed.startsWith(bp));
+}
+/**
+ * Strip PostGraphile smart comments and boilerplate from a description string.
+ *
+ * Smart comments are lines starting with `@` (e.g., `@omit`, `@name newName`).
+ * Boilerplate descriptions are generic PostGraphile-generated text that repeats
+ * on every mutation input, clientMutationId field, etc.
+ *
+ * This returns only the meaningful human-readable portion of the comment,
+ * or undefined if the result is empty or boilerplate.
+ *
+ * @param description - Raw description from GraphQL introspection
+ * @returns Cleaned description, or undefined if empty/boilerplate
+ */
+export function stripSmartComments(description, enabled = true) {
+    if (!enabled)
+        return undefined;
+    if (!description)
+        return undefined;
+    // Check if entire description is boilerplate
+    if (isBoilerplateDescription(description))
+        return undefined;
+    const lines = description.split('\n');
+    const cleanLines = [];
+    for (const line of lines) {
+        const trimmed = line.trim();
+        // Skip lines that start with @ (smart comment directives)
+        if (trimmed.startsWith('@'))
+            continue;
+        cleanLines.push(line);
+    }
+    const result = cleanLines.join('\n').trim();
+    if (result.length === 0)
+        return undefined;
+    // Re-check after stripping smart comments
+    if (isBoilerplateDescription(result))
+        return undefined;
+    return result;
+}

package/generators/field-selector.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Simplified field selection system
+ * Converts user-friendly selection options to internal SelectionOptions format
+ */
+import type { QuerySelectionOptions } from '../types';
+import type { CleanTable } from '../types/schema';
+import type { FieldSelection } from '../types/selection';
+/**
+ * Convert simplified field selection to QueryBuilder SelectionOptions
+ */
+export declare function convertToSelectionOptions(table: CleanTable, allTables: CleanTable[], selection?: FieldSelection): QuerySelectionOptions | null;
+/**
+ * Check if a field is relational using table metadata
+ */
+export declare function isRelationalField(fieldName: string, table: CleanTable): boolean;
+/**
+ * Get all available relation fields from a table
+ */
+export declare function getAvailableRelations(table: CleanTable): Array<{
+    fieldName: string;
+    type: 'belongsTo' | 'hasOne' | 'hasMany' | 'manyToMany';
+    referencedTable?: string;
+}>;
+/**
+ * Validate field selection against table schema
+ */
+export declare function validateFieldSelection(selection: FieldSelection, table: CleanTable): {
+    isValid: boolean;
+    errors: string[];
+};

package/generators/field-selector.js

@@ -0,0 +1,387 @@
+"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,
+    };
+}

package/generators/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Generators barrel export
+ *
+ * Re-exports all query/mutation generation functions and naming helpers.
+ */
+export { buildSelect, buildFindOne, buildCount, cleanTableToMetaObject, createASTQueryBuilder, generateIntrospectionSchema, toCamelCasePlural, toOrderByTypeName, } from './select';
+export { buildPostGraphileCreate, buildPostGraphileUpdate, buildPostGraphileDelete, } from './mutations';
+export { convertToSelectionOptions, isRelationalField, getAvailableRelations, validateFieldSelection, } from './field-selector';
+export { normalizeInflectionValue, toCamelCaseSingular, toCreateMutationName, toUpdateMutationName, toDeleteMutationName, toCreateInputTypeName, toUpdateInputTypeName, toDeleteInputTypeName, toFilterTypeName, toPatchFieldName, toOrderByEnumValue, } from './naming-helpers';

package/generators/index.js

@@ -0,0 +1,42 @@
+"use strict";
+/**
+ * Generators barrel export
+ *
+ * Re-exports all query/mutation generation functions and naming helpers.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toOrderByEnumValue = exports.toPatchFieldName = exports.toFilterTypeName = exports.toDeleteInputTypeName = exports.toUpdateInputTypeName = exports.toCreateInputTypeName = exports.toDeleteMutationName = exports.toUpdateMutationName = exports.toCreateMutationName = exports.toCamelCaseSingular = exports.normalizeInflectionValue = exports.validateFieldSelection = exports.getAvailableRelations = exports.isRelationalField = exports.convertToSelectionOptions = exports.buildPostGraphileDelete = exports.buildPostGraphileUpdate = exports.buildPostGraphileCreate = exports.toOrderByTypeName = exports.toCamelCasePlural = exports.generateIntrospectionSchema = exports.createASTQueryBuilder = exports.cleanTableToMetaObject = exports.buildCount = exports.buildFindOne = exports.buildSelect = void 0;
+// SELECT, FindOne, Count 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, "cleanTableToMetaObject", { enumerable: true, get: function () { return select_1.cleanTableToMetaObject; } });
+Object.defineProperty(exports, "createASTQueryBuilder", { enumerable: true, get: function () { return select_1.createASTQueryBuilder; } });
+Object.defineProperty(exports, "generateIntrospectionSchema", { enumerable: true, get: function () { return select_1.generateIntrospectionSchema; } });
+Object.defineProperty(exports, "toCamelCasePlural", { enumerable: true, get: function () { return select_1.toCamelCasePlural; } });
+Object.defineProperty(exports, "toOrderByTypeName", { enumerable: true, get: function () { return select_1.toOrderByTypeName; } });
+// Mutation generators (CREATE, UPDATE, DELETE)
+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; } });
+// Field selection 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; } });
+// Naming helpers (server-aware inflection)
+var naming_helpers_1 = require("./naming-helpers");
+Object.defineProperty(exports, "normalizeInflectionValue", { enumerable: true, get: function () { return naming_helpers_1.normalizeInflectionValue; } });
+Object.defineProperty(exports, "toCamelCaseSingular", { enumerable: true, get: function () { return naming_helpers_1.toCamelCaseSingular; } });
+Object.defineProperty(exports, "toCreateMutationName", { enumerable: true, get: function () { return naming_helpers_1.toCreateMutationName; } });
+Object.defineProperty(exports, "toUpdateMutationName", { enumerable: true, get: function () { return naming_helpers_1.toUpdateMutationName; } });
+Object.defineProperty(exports, "toDeleteMutationName", { enumerable: true, get: function () { return naming_helpers_1.toDeleteMutationName; } });
+Object.defineProperty(exports, "toCreateInputTypeName", { enumerable: true, get: function () { return naming_helpers_1.toCreateInputTypeName; } });
+Object.defineProperty(exports, "toUpdateInputTypeName", { enumerable: true, get: function () { return naming_helpers_1.toUpdateInputTypeName; } });
+Object.defineProperty(exports, "toDeleteInputTypeName", { enumerable: true, get: function () { return naming_helpers_1.toDeleteInputTypeName; } });
+Object.defineProperty(exports, "toFilterTypeName", { enumerable: true, get: function () { return naming_helpers_1.toFilterTypeName; } });
+Object.defineProperty(exports, "toPatchFieldName", { enumerable: true, get: function () { return naming_helpers_1.toPatchFieldName; } });
+Object.defineProperty(exports, "toOrderByEnumValue", { enumerable: true, get: function () { return naming_helpers_1.toOrderByEnumValue; } });

package/generators/mutations.d.ts

@@ -0,0 +1,30 @@
+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 { ... } } }
+ */
+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;
+    };
+}>;