graphile-bulk-mutations 0.2.0

package/esm/plugins/BulkRelationalPlugin.js

@@ -0,0 +1,127 @@
+import '../augmentations';
+import { discoverNestedRelations } from '../utils/relations';
+const version = '0.1.0';
+/**
+ * BulkRelationalPlugin
+ *
+ * Adds relational/nested insert support to bulk mutations. When enabled
+ * via `bulkRelational: true`, parent values item input types gain optional
+ * fields for each "has many" relation, allowing creation of parent and
+ * child rows in a single mutation.
+ *
+ * Example:
+ *   mutation {
+ *     bulkCreateCategories(input: {
+ *       values: [{
+ *         name: "Electronics"
+ *         products: [
+ *           { name: "Laptop", price: "999.99" }
+ *         ]
+ *       }]
+ *     }) { affectedCount }
+ *   }
+ *
+ * The FK column on the child table (e.g. category_id) is automatically
+ * populated from the parent's returned primary key. Nested input types
+ * exclude FK columns so the user does not need to provide them.
+ *
+ * Limitations:
+ * - ON CONFLICT cannot be used with nested inserts (throws an error)
+ * - Only one level of nesting is supported in the initial implementation
+ */
+export const BulkRelationalPlugin = {
+    name: 'BulkRelationalPlugin',
+    version,
+    description: 'Adds relational/nested insert support to bulk mutations',
+    after: ['BulkTypesPlugin', 'BulkInsertPlugin'],
+    schema: {
+        hooks: {
+            init(_, build) {
+                const { inflection, sql, options: { bulkRelational: enableRelational = false } } = build;
+                if (!enableRelational)
+                    return _;
+                const pgRegistry = build.input.pgRegistry;
+                for (const [_resourceName, resource] of Object.entries(pgRegistry.pgResources)) {
+                    if (resource.parameters)
+                        continue;
+                    if (!resource.codec.attributes)
+                        continue;
+                    if (resource.codec.polymorphism)
+                        continue;
+                    if (resource.codec.isAnonymous)
+                        continue;
+                    if (!resource.uniques?.length)
+                        continue;
+                    if (!build.behavior.pgResourceMatches(resource, 'bulkInsert'))
+                        continue;
+                    const parentTypeName = inflection.tableType(resource.codec);
+                    const nestedRelations = discoverNestedRelations(resource, pgRegistry, inflection, sql);
+                    for (const rel of nestedRelations) {
+                        const childTypeName = inflection.tableType(rel.remoteResource.codec);
+                        const nestedInputTypeName = inflection.bulkNestedValuesItemType(parentTypeName, childTypeName);
+                        // FK columns to exclude from nested input type
+                        const fkAttrSet = new Set(rel.remoteAttributes);
+                        build.registerInputObjectType(nestedInputTypeName, { isBulkRelationalNestedInput: true }, () => ({
+                            description: `A row to nest-create for ${childTypeName} when bulk creating ${parentTypeName}. FK columns are auto-populated from the parent.`,
+                            fields: () => {
+                                const result = {};
+                                for (const [attrName, attr] of Object.entries(rel.remoteResource.codec.attributes)) {
+                                    if (attr.extensions?.isInsertable === false)
+                                        continue;
+                                    // Exclude FK columns — they are auto-filled from parent PK
+                                    if (fkAttrSet.has(attrName))
+                                        continue;
+                                    const fieldName = inflection.attribute({
+                                        attributeName: attrName,
+                                        codec: rel.remoteResource.codec
+                                    });
+                                    const inputType = build.getGraphQLTypeByPgCodec(attr.codec, 'input');
+                                    if (!inputType)
+                                        continue;
+                                    const isRequired = !!attr.notNull && !attr.hasDefault;
+                                    result[fieldName] = {
+                                        description: `Value for ${attrName}`,
+                                        type: isRequired
+                                            ? new build.graphql.GraphQLNonNull(inputType)
+                                            : inputType
+                                    };
+                                }
+                                return result;
+                            }
+                        }), `Nested input for ${childTypeName} in ${parentTypeName}`);
+                    }
+                }
+                return _;
+            },
+            // Add nested relation fields to existing values item input types
+            GraphQLInputObjectType_fields(fields, build, context) {
+                const { scope: { isBulkMutationValuesItem, bulkMutationResourceName } } = context;
+                if (!isBulkMutationValuesItem || !bulkMutationResourceName)
+                    return fields;
+                const { inflection, sql, options: { bulkRelational: enableRelational = false } } = build;
+                if (!enableRelational)
+                    return fields;
+                const pgRegistry = build.input.pgRegistry;
+                const resource = pgRegistry.pgResources[bulkMutationResourceName];
+                if (!resource)
+                    return fields;
+                const parentTypeName = inflection.tableType(resource.codec);
+                const nestedRelations = discoverNestedRelations(resource, pgRegistry, inflection, sql);
+                for (const rel of nestedRelations) {
+                    const childTypeName = inflection.tableType(rel.remoteResource.codec);
+                    const nestedInputTypeName = inflection.bulkNestedValuesItemType(parentTypeName, childTypeName);
+                    const nestedInputType = build.getTypeByName(nestedInputTypeName);
+                    if (!nestedInputType)
+                        continue;
+                    fields = build.extend(fields, {
+                        [rel.fieldName]: {
+                            description: `Nested ${childTypeName} rows to create for this ${parentTypeName}.`,
+                            type: new build.graphql.GraphQLList(new build.graphql.GraphQLNonNull(nestedInputType))
+                        }
+                    }, `Adding nested field ${rel.fieldName} to ${parentTypeName} values item`);
+                }
+                return fields;
+            }
+        }
+    }
+};

package/esm/plugins/BulkTypesPlugin.d.ts

@@ -0,0 +1,18 @@
+import '../augmentations';
+import type { GraphileConfig } from 'graphile-config';
+/**
+ * BulkTypesPlugin
+ *
+ * Registers all shared types for bulk mutations:
+ * 1. ConflictAction enum (IGNORE)
+ * 2. Per-table unique constraint enums (e.g. UserUniqueConstraint)
+ * 3. Per-table column enums (e.g. UserColumn)
+ * 4. Per-table ON CONFLICT input types
+ * 5. Per-table values item input types
+ * 6. Per-table input types (wrapping values + onConflict)
+ * 7. Per-table payload types (affectedCount + returning)
+ *
+ * Behavior: OFF by default. Tables must opt in via smart tags:
+ *   @behavior +bulkInsert +bulkUpsert +bulkUpdate +bulkDelete
+ */
+export declare const BulkTypesPlugin: GraphileConfig.Plugin;

package/esm/plugins/BulkTypesPlugin.js

@@ -0,0 +1,391 @@
+import '../augmentations';
+import { pgSelectFromRecords } from '@dataplan/pg';
+import { access } from 'grafast';
+const version = '0.1.0';
+/**
+ * Checks if a resource is suitable for bulk mutations:
+ * - Must have attributes (is a table)
+ * - Must not be polymorphic
+ * - Must not be anonymous
+ * - Must have at least one unique constraint (for ON CONFLICT)
+ * - Must not have parameters (not a function)
+ */
+function isBulkMutationCandidate(resource) {
+    return (!resource.parameters &&
+        !!resource.codec.attributes &&
+        !resource.codec.polymorphism &&
+        !resource.codec.isAnonymous &&
+        !!resource.uniques?.length);
+}
+/**
+ * BulkTypesPlugin
+ *
+ * Registers all shared types for bulk mutations:
+ * 1. ConflictAction enum (IGNORE)
+ * 2. Per-table unique constraint enums (e.g. UserUniqueConstraint)
+ * 3. Per-table column enums (e.g. UserColumn)
+ * 4. Per-table ON CONFLICT input types
+ * 5. Per-table values item input types
+ * 6. Per-table input types (wrapping values + onConflict)
+ * 7. Per-table payload types (affectedCount + returning)
+ *
+ * Behavior: OFF by default. Tables must opt in via smart tags:
+ *   @behavior +bulkInsert +bulkUpsert +bulkUpdate +bulkDelete
+ */
+export const BulkTypesPlugin = {
+    name: 'BulkTypesPlugin',
+    version,
+    description: 'Registers bulk mutation types (enums, inputs, payloads)',
+    after: ['PgMutationCreatePlugin', 'PgMutationUpdateDeletePlugin', 'BulkInflectionPlugin'],
+    schema: {
+        behaviorRegistry: {
+            add: {
+                bulkInsert: {
+                    description: 'Enable bulk insert mutation for this resource',
+                    entities: ['pgResource']
+                },
+                bulkUpsert: {
+                    description: 'Enable bulk upsert mutation for this resource',
+                    entities: ['pgResource']
+                },
+                bulkUpdate: {
+                    description: 'Enable bulk update mutation for this resource',
+                    entities: ['pgResource']
+                },
+                bulkDelete: {
+                    description: 'Enable bulk delete mutation for this resource',
+                    entities: ['pgResource']
+                }
+            }
+        },
+        // Default: OFF. Tables must explicitly opt in via smart tags.
+        entityBehavior: {
+            pgResource: {
+                inferred(behavior) {
+                    return [behavior, '-bulkInsert -bulkUpsert -bulkUpdate -bulkDelete'];
+                }
+            }
+        },
+        hooks: {
+            init(_, build) {
+                const { inflection, options: { bulkInsert: enableInsert = true, bulkUpsert: enableUpsert = true, bulkUpdate: enableUpdate = true, bulkDelete: enableDelete = true } } = build;
+                // Register the ConflictAction enum (shared across all tables)
+                build.registerEnumType('ConflictAction', {}, () => ({
+                    description: 'Action to take when a conflict occurs during bulk insert.',
+                    values: {
+                        IGNORE: {
+                            value: 'IGNORE',
+                            description: 'Skip the conflicting row (ON CONFLICT DO NOTHING).'
+                        }
+                    }
+                }), 'ConflictAction enum for bulk mutations');
+                // Iterate over all resources to register per-table types
+                const pgRegistry = build.input.pgRegistry;
+                for (const [resourceName, resource] of Object.entries(pgRegistry.pgResources)) {
+                    if (!isBulkMutationCandidate(resource))
+                        continue;
+                    const hasInsert = enableInsert &&
+                        build.behavior.pgResourceMatches(resource, 'bulkInsert');
+                    const hasUpsert = enableUpsert &&
+                        build.behavior.pgResourceMatches(resource, 'bulkUpsert');
+                    const hasUpdate = enableUpdate &&
+                        build.behavior.pgResourceMatches(resource, 'bulkUpdate');
+                    const hasDelete = enableDelete &&
+                        build.behavior.pgResourceMatches(resource, 'bulkDelete');
+                    if (!hasInsert && !hasUpsert && !hasUpdate && !hasDelete)
+                        continue;
+                    const typeName = inflection.tableType(resource.codec);
+                    // Per-table unique constraint enum
+                    if (hasInsert || hasUpsert) {
+                        const constraintEnumName = inflection.uniqueConstraintEnumType(typeName);
+                        const values = {};
+                        for (const unique of resource.uniques) {
+                            // Use column-based conflict targeting (ON CONFLICT (col1, col2))
+                            // rather than constraint names, since PgResourceUnique doesn't
+                            // store the actual PostgreSQL constraint name.
+                            const enumKey = unique.isPrimary
+                                ? `${resourceName}_pkey`
+                                : `${resourceName}_${unique.attributes.join('_')}_key`;
+                            const enumValue = inflection
+                                .constantCase(enumKey)
+                                .toUpperCase();
+                            // Store comma-separated column list as the enum value
+                            values[enumValue] = {
+                                value: unique.attributes.join(','),
+                                description: unique.isPrimary
+                                    ? `Primary key constraint on ${resourceName}`
+                                    : `Unique constraint on (${unique.attributes.join(', ')})`
+                            };
+                        }
+                        build.registerEnumType(constraintEnumName, { isBulkMutationConstraintEnum: true }, () => ({
+                            description: `Unique constraints on ${typeName} for ON CONFLICT targeting.`,
+                            values
+                        }), `Unique constraint enum for ${typeName}`);
+                    }
+                    // Per-table column enum
+                    if (hasUpsert) {
+                        const columnEnumName = inflection.columnEnumType(typeName);
+                        const values = {};
+                        for (const [attrName, attr] of Object.entries(resource.codec.attributes)) {
+                            if (attr.extensions?.isInsertable === false)
+                                continue;
+                            const enumValue = inflection
+                                .constantCase(attrName)
+                                .toUpperCase();
+                            values[enumValue] = {
+                                value: attrName,
+                                description: `Column ${attrName}`
+                            };
+                        }
+                        build.registerEnumType(columnEnumName, { isBulkMutationColumnEnum: true }, () => ({
+                            description: `Columns of ${typeName} available for upsert SET clause.`,
+                            values
+                        }), `Column enum for ${typeName}`);
+                    }
+                    // Per-table ON CONFLICT input for insert
+                    if (hasInsert) {
+                        const onConflictName = inflection.bulkInsertOnConflictInputType(typeName);
+                        const constraintEnumName = inflection.uniqueConstraintEnumType(typeName);
+                        build.registerInputObjectType(onConflictName, { isBulkMutationOnConflictInput: true }, () => ({
+                            description: `ON CONFLICT options for bulk creating ${typeName}.`,
+                            fields: ({ fieldWithHooks }) => ({
+                                constraint: fieldWithHooks({ fieldName: 'constraint' }, () => ({
+                                    description: 'The unique constraint to use for conflict detection.',
+                                    type: build.getTypeByName(constraintEnumName)
+                                })),
+                                action: fieldWithHooks({ fieldName: 'action' }, () => ({
+                                    description: 'The action to take on conflict.',
+                                    type: new build.graphql.GraphQLNonNull(build.getTypeByName('ConflictAction'))
+                                }))
+                            })
+                        }), `ON CONFLICT input for bulk insert ${typeName}`);
+                    }
+                    // Per-table ON CONFLICT input for upsert
+                    if (hasUpsert) {
+                        const onConflictName = inflection.bulkUpsertOnConflictInputType(typeName);
+                        const constraintEnumName = inflection.uniqueConstraintEnumType(typeName);
+                        const columnEnumName = inflection.columnEnumType(typeName);
+                        build.registerInputObjectType(onConflictName, { isBulkMutationOnConflictInput: true }, () => ({
+                            description: `ON CONFLICT options for bulk upserting ${typeName}.`,
+                            fields: ({ fieldWithHooks }) => ({
+                                constraint: fieldWithHooks({ fieldName: 'constraint' }, () => ({
+                                    description: 'The unique constraint to use for conflict detection.',
+                                    type: new build.graphql.GraphQLNonNull(build.getTypeByName(constraintEnumName))
+                                })),
+                                updateColumns: fieldWithHooks({ fieldName: 'updateColumns' }, () => ({
+                                    description: 'Columns to update on conflict. If omitted, all non-key columns are updated.',
+                                    type: new build.graphql.GraphQLList(new build.graphql.GraphQLNonNull(build.getTypeByName(columnEnumName)))
+                                }))
+                            })
+                        }), `ON CONFLICT input for bulk upsert ${typeName}`);
+                    }
+                    // Per-table values item input type (for insert)
+                    if (hasInsert || hasUpsert) {
+                        const itemTypeName = hasInsert
+                            ? inflection.bulkInsertValuesItemType(typeName)
+                            : inflection.bulkUpsertValuesItemType(typeName);
+                        build.registerInputObjectType(itemTypeName, {
+                            isBulkMutationValuesItem: true,
+                            bulkMutationResourceName: resourceName
+                        }, () => ({
+                            description: `A single row to insert for ${typeName}.`,
+                            fields: () => {
+                                const result = {};
+                                for (const [attrName, attr] of Object.entries(resource.codec.attributes)) {
+                                    if (attr.extensions?.isInsertable === false)
+                                        continue;
+                                    const fieldName = inflection.attribute({
+                                        attributeName: attrName,
+                                        codec: resource.codec
+                                    });
+                                    const inputType = build.getGraphQLTypeByPgCodec(attr.codec, 'input');
+                                    if (!inputType)
+                                        continue;
+                                    const isRequired = !!attr.notNull && !attr.hasDefault;
+                                    result[fieldName] = {
+                                        description: `Value for ${attrName}`,
+                                        type: isRequired
+                                            ? new build.graphql.GraphQLNonNull(inputType)
+                                            : inputType
+                                    };
+                                }
+                                return result;
+                            }
+                        }), `Values item input for bulk insert ${typeName}`);
+                        // Register upsert item separately if both exist
+                        if (hasInsert && hasUpsert) {
+                            const upsertItemTypeName = inflection.bulkUpsertValuesItemType(typeName);
+                            build.registerInputObjectType(upsertItemTypeName, {
+                                isBulkMutationValuesItem: true,
+                                bulkMutationResourceName: resourceName
+                            }, () => ({
+                                description: `A single row to upsert for ${typeName}.`,
+                                fields: () => {
+                                    const result = {};
+                                    for (const [attrName, attr] of Object.entries(resource.codec.attributes)) {
+                                        if (attr.extensions?.isInsertable === false)
+                                            continue;
+                                        const fieldName = inflection.attribute({
+                                            attributeName: attrName,
+                                            codec: resource.codec
+                                        });
+                                        const inputType = build.getGraphQLTypeByPgCodec(attr.codec, 'input');
+                                        if (!inputType)
+                                            continue;
+                                        const isRequired = !!attr.notNull && !attr.hasDefault;
+                                        result[fieldName] = {
+                                            description: `Value for ${attrName}`,
+                                            type: isRequired
+                                                ? new build.graphql.GraphQLNonNull(inputType)
+                                                : inputType
+                                        };
+                                    }
+                                    return result;
+                                }
+                            }), `Values item input for bulk upsert ${typeName}`);
+                        }
+                    }
+                    // Per-table wrapper input types
+                    if (hasInsert) {
+                        const inputName = inflection.bulkInsertInputType(typeName);
+                        const itemTypeName = inflection.bulkInsertValuesItemType(typeName);
+                        const onConflictName = inflection.bulkInsertOnConflictInputType(typeName);
+                        build.registerInputObjectType(inputName, { isBulkMutationInput: true }, () => ({
+                            description: `Input for bulk creating ${typeName} rows.`,
+                            fields: ({ fieldWithHooks }) => ({
+                                values: fieldWithHooks({ fieldName: 'values' }, () => ({
+                                    description: 'The rows to insert.',
+                                    type: new build.graphql.GraphQLNonNull(new build.graphql.GraphQLList(new build.graphql.GraphQLNonNull(build.getTypeByName(itemTypeName))))
+                                })),
+                                onConflict: fieldWithHooks({ fieldName: 'onConflict' }, () => ({
+                                    description: 'Optional ON CONFLICT handling for duplicate keys.',
+                                    type: build.getTypeByName(onConflictName)
+                                }))
+                            })
+                        }), `Input for bulk insert ${typeName}`);
+                    }
+                    if (hasUpsert) {
+                        const inputName = inflection.bulkUpsertInputType(typeName);
+                        const itemTypeName = inflection.bulkUpsertValuesItemType(typeName);
+                        const onConflictName = inflection.bulkUpsertOnConflictInputType(typeName);
+                        build.registerInputObjectType(inputName, { isBulkMutationInput: true }, () => ({
+                            description: `Input for bulk upserting ${typeName} rows.`,
+                            fields: ({ fieldWithHooks }) => ({
+                                values: fieldWithHooks({ fieldName: 'values' }, () => ({
+                                    description: 'The rows to upsert.',
+                                    type: new build.graphql.GraphQLNonNull(new build.graphql.GraphQLList(new build.graphql.GraphQLNonNull(build.getTypeByName(itemTypeName))))
+                                })),
+                                onConflict: fieldWithHooks({ fieldName: 'onConflict' }, () => ({
+                                    description: 'The unique constraint to target and which columns to update.',
+                                    type: new build.graphql.GraphQLNonNull(build.getTypeByName(onConflictName))
+                                }))
+                            })
+                        }), `Input for bulk upsert ${typeName}`);
+                    }
+                    if (hasUpdate) {
+                        const inputName = inflection.bulkUpdateInputType(typeName);
+                        const patchTypeName = inflection.patchType(typeName);
+                        build.registerInputObjectType(inputName, { isBulkMutationInput: true }, () => ({
+                            description: `Input for bulk updating ${typeName} rows.`,
+                            fields: ({ fieldWithHooks }) => ({
+                                where: fieldWithHooks({ fieldName: 'where' }, () => {
+                                    // Try to use connection-filter type if available
+                                    const filterTypeName = `${typeName}Filter`;
+                                    const filterType = build.getTypeByName(filterTypeName);
+                                    // Fall back to PostGraphile's built-in condition type
+                                    const conditionTypeName = inflection.conditionType(typeName);
+                                    const conditionType = build.getTypeByName(conditionTypeName);
+                                    const whereType = filterType || conditionType;
+                                    return {
+                                        description: 'Condition to select which rows to update.',
+                                        type: whereType
+                                            ? new build.graphql.GraphQLNonNull(whereType)
+                                            : build.graphql.GraphQLString
+                                    };
+                                }),
+                                patch: fieldWithHooks({ fieldName: 'patch' }, () => ({
+                                    description: 'The fields to update.',
+                                    type: new build.graphql.GraphQLNonNull(build.getTypeByName(patchTypeName))
+                                }))
+                            })
+                        }), `Input for bulk update ${typeName}`);
+                    }
+                    if (hasDelete) {
+                        const inputName = inflection.bulkDeleteInputType(typeName);
+                        build.registerInputObjectType(inputName, { isBulkMutationInput: true }, () => ({
+                            description: `Input for bulk deleting ${typeName} rows.`,
+                            fields: ({ fieldWithHooks }) => ({
+                                where: fieldWithHooks({ fieldName: 'where' }, () => {
+                                    const filterTypeName = `${typeName}Filter`;
+                                    const filterType = build.getTypeByName(filterTypeName);
+                                    const conditionTypeName = inflection.conditionType(typeName);
+                                    const conditionType = build.getTypeByName(conditionTypeName);
+                                    const whereType = filterType || conditionType;
+                                    return {
+                                        description: 'Condition to select which rows to delete.',
+                                        type: whereType
+                                            ? new build.graphql.GraphQLNonNull(whereType)
+                                            : build.graphql.GraphQLString
+                                    };
+                                })
+                            })
+                        }), `Input for bulk delete ${typeName}`);
+                    }
+                    // Payload types
+                    const registerPayload = (payloadName, description, payloadResource) => {
+                        build.registerObjectType(payloadName, { isBulkMutationPayload: true }, () => ({
+                            description,
+                            fields: ({ fieldWithHooks }) => {
+                                const outputType = build.getTypeByName(typeName);
+                                const fields = {
+                                    clientMutationId: fieldWithHooks({ fieldName: 'clientMutationId' }, () => ({
+                                        description: 'The exact same clientMutationId that was provided in the mutation input.',
+                                        type: build.graphql.GraphQLString
+                                    })),
+                                    affectedCount: fieldWithHooks({
+                                        fieldName: 'affectedCount',
+                                        isBulkMutationPayloadAffectedCountField: true
+                                    }, () => ({
+                                        description: 'The number of rows affected by the mutation.',
+                                        type: new build.graphql.GraphQLNonNull(build.graphql.GraphQLInt)
+                                    }))
+                                };
+                                if (outputType) {
+                                    fields.returning = fieldWithHooks({
+                                        fieldName: 'returning',
+                                        isBulkMutationPayloadReturningField: true
+                                    }, () => ({
+                                        description: 'The rows affected by the mutation.',
+                                        type: new build.graphql.GraphQLNonNull(new build.graphql.GraphQLList(new build.graphql.GraphQLNonNull(outputType))),
+                                        plan($parent) {
+                                            const $records = access($parent, 'returning');
+                                            return pgSelectFromRecords(payloadResource, $records);
+                                        }
+                                    }));
+                                }
+                                fields.query = fieldWithHooks({ fieldName: 'query' }, () => ({
+                                    description: 'Access the root query type. Useful for re-fetching data after a mutation.',
+                                    type: build.getTypeByName('Query')
+                                }));
+                                return fields;
+                            }
+                        }), `${description} payload`);
+                    };
+                    if (hasInsert) {
+                        registerPayload(inflection.bulkInsertPayloadType(typeName), `The output of the bulk create ${typeName} mutation.`, resource);
+                    }
+                    if (hasUpsert) {
+                        registerPayload(inflection.bulkUpsertPayloadType(typeName), `The output of the bulk upsert ${typeName} mutation.`, resource);
+                    }
+                    if (hasUpdate) {
+                        registerPayload(inflection.bulkUpdatePayloadType(typeName), `The output of the bulk update ${typeName} mutation.`, resource);
+                    }
+                    if (hasDelete) {
+                        registerPayload(inflection.bulkDeletePayloadType(typeName), `The output of the bulk delete ${typeName} mutation.`, resource);
+                    }
+                }
+                return _;
+            }
+        }
+    }
+};

package/esm/plugins/BulkUpdatePlugin.d.ts

@@ -0,0 +1,13 @@
+import '../augmentations';
+import type { GraphileConfig } from 'graphile-config';
+/**
+ * BulkUpdatePlugin
+ *
+ * Registers `bulkUpdateX` mutation fields for each resource with the
+ * `bulkUpdate` behavior. Uses UPDATE ... SET ... WHERE with conditions
+ * from graphile-connection-filter (or PostGraphile's built-in condition type).
+ *
+ * Uses `RETURNING <pk_columns>` (not `RETURNING *`) + follow-up SELECT
+ * to respect column-level SELECT grants.
+ */
+export declare const BulkUpdatePlugin: GraphileConfig.Plugin;