@enfyra/mcp-server 0.1.19 → 0.1.21

package/dist/lib/table-tools.js

@@ -5,6 +5,9 @@ import { z } from 'zod';
 import { fetchAPI } from './fetch.js';
 import { jsonContent } from './response-format.js';
 import { assertGlobalRulesAck, globalRulesAckParam } from './required-knowledge.js';
+function bulkObjectArrayParam(z, label) {
+    return z.union([z.array(z.record(z.any())), z.string()]).describe(`${label} as a native JSON array of objects. JSON string is accepted only for older clients.`);
+}
 let schemaQueue = Promise.resolve();
 function withSchemaQueue(operation) {
     const run = schemaQueue.then(operation, operation);
@@ -127,6 +130,26 @@ function parseJsonArrayParam(name, value) {
     }
     return parsed;
 }
+function parseBulkItemsParam(name, value) {
+    const parsed = typeof value === 'string' ? JSON.parse(value) : value;
+    if (!Array.isArray(parsed)) {
+        throw new Error(`${name} must be a JSON array. Pass one object in the array for a single mutation.`);
+    }
+    if (parsed.length === 0) {
+        throw new Error(`${name} must include at least one item.`);
+    }
+    parsed.forEach((item, index) => {
+        if (!item || typeof item !== 'object' || Array.isArray(item)) {
+            throw new Error(`${name}[${index}] must be an object.`);
+        }
+    });
+    return parsed;
+}
+function assertBulkLimit(name, items, maxItems) {
+    if (items.length > maxItems) {
+        throw new Error(`${name} received ${items.length} items, above maxItems=${maxItems}. Split the batch deliberately.`);
+    }
+}
 function normalizeConstraintGroups(name, groups) {
     return groups.map((group, index) => {
         const value = Array.isArray(group) ? group : group?.value;
@@ -188,7 +211,7 @@ export function normalizeRelationForTablePatch(relation) {
 function assertNoForbiddenRelationKeys(args) {
     for (const key of FORBIDDEN_RELATION_KEYS) {
         if (Object.prototype.hasOwnProperty.call(args, key)) {
-            throw new Error(`create_relation must not include physical column field "${key}". Use sourceTableId/targetTableId and relation propertyName only; Enfyra derives FK and junction columns.`);
+            throw new Error(`create_relations must not include physical column field "${key}". Use sourceTableId/targetTableId and relation propertyName only; Enfyra derives FK and junction columns.`);
         }
     }
 }
@@ -483,7 +506,7 @@ export function registerTableTools(server, ENFYRA_API_URL) {
                                 targetColumn: target,
                                 preservedColumnIds: beforeIds.filter((id) => id !== String(columnId)),
                                 destructive: true,
-                                next: 'Call delete_column again with confirm=true to drop the physical column and metadata.',
+                                next: 'Call delete_columns again with the same one-item array and confirm=true to drop the physical column and metadata.',
                             }, null, 2) }],
                 };
             }
@@ -524,7 +547,7 @@ export function registerTableTools(server, ENFYRA_API_URL) {
                                 targetRelation: target,
                                 preservedRelationIds: beforeIds.filter((id) => id !== String(relationId)),
                                 destructive: true,
-                                next: 'Call delete_relation again with confirm=true to drop relation metadata and any derived FK/junction structures.',
+                                next: 'Call delete_relations again with the same one-item array and confirm=true to drop relation metadata and any derived FK/junction structures.',
                             }, null, 2) }],
                 };
             }
@@ -545,7 +568,7 @@ export function registerTableTools(server, ENFYRA_API_URL) {
         });
     }
     const columnCreateSchema = {
-        tableId: z.string().describe('Table definition ID (from get_all_tables or create_table).'),
+        tableId: z.string().describe('Table definition ID (from get_all_tables or create_tables).'),
         name: z.string().describe('Column name (e.g., "title", "webhook_secret"). Lowercase with underscores.'),
         type: z.string().describe('Column type from the live enfyra_column.type enum. Common valid types are int, varchar, text, boolean, uuid, ObjectId, bigint, date, datetime, timestamp, enum, simple-json, code, array-select, richtext, and float. The tool normalizes common aliases before sending: decimal/numeric/money/number -> float when decimal is not live-supported, longtext -> text, json/jsonb/object/array -> simple-json when live-supported, string -> varchar. Prefer relations instead of *_id columns.'),
         isNullable: z.boolean().optional().default(true).describe('Set to false if column cannot be null.'),
@@ -553,7 +576,7 @@ export function registerTableTools(server, ENFYRA_API_URL) {
         isPublished: z.boolean().optional().describe('Set column visibility baseline. Use false for secrets and internal fields.'),
         isUpdatable: z.boolean().optional().describe('Set false for immutable fields that cannot be updated after creation. Independent from isEncrypted.'),
         isEncrypted: z.boolean().optional().describe('Set true to encrypt this column at the Enfyra database-query layer. This does not change isUpdatable. Encrypted fields cannot be filtered or sorted.'),
-        isPrimary: z.boolean().optional().describe('Set true only for primary key columns; normally only create_table auto id uses this.'),
+        isPrimary: z.boolean().optional().describe('Set true only for primary key columns; normally only create_tables auto id uses this.'),
         isGenerated: z.boolean().optional().describe('Set true only for generated columns such as auto id.'),
         isSystem: z.boolean().optional().describe('Set true only for system-managed columns. Avoid for normal app fields.'),
         defaultValue: z.string().optional().describe('Default value as JSON string or backend-supported literal.'),
@@ -592,6 +615,175 @@ export function registerTableTools(server, ENFYRA_API_URL) {
         confirm: z.boolean().optional().default(false).describe('Required true to apply the destructive delete. Omit/false returns a preview only.'),
         globalRulesAckKey: globalRulesAckParam(z).optional().describe('Required when confirm=true. Use globalRulesAckKey from get_enfyra_required_knowledge.'),
     };
+    function arrayValue(name, value) {
+        if (value === undefined || value === null || value === '')
+            return [];
+        return Array.isArray(value) ? value : parseJsonArrayParam(name, value);
+    }
+    async function createOneTable(args) {
+        const idColumn = { name: 'id', type: 'int', isPrimary: true, isGenerated: true, isNullable: false };
+        const userColumns = arrayValue('columns', args.columns);
+        const metadata = await fetchAPI(ENFYRA_API_URL, '/metadata');
+        const supportedTypes = getSupportedColumnTypesFromMetadata(metadata);
+        const { columns: normalizedUserColumns, normalizations } = normalizeColumnsForLiveMetadata(userColumns, supportedTypes);
+        const indexes = normalizeConstraintGroupsValue('indexes', args.indexes ?? []);
+        const uniques = normalizeConstraintGroupsValue('uniques', args.uniques ?? []);
+        assertIndexesDoNotReferenceUniqueFields(indexes, uniques);
+        const body = { name: args.name, description: args.description, columns: [idColumn, ...normalizedUserColumns], relations: [] };
+        if (args.isSingleRecord !== undefined)
+            body.isSingleRecord = args.isSingleRecord;
+        if (args.indexes !== undefined)
+            body.indexes = indexes;
+        if (args.uniques !== undefined)
+            body.uniques = uniques;
+        const result = await fetchAPI(ENFYRA_API_URL, '/enfyra_table', {
+            method: 'POST',
+            body: JSON.stringify(body),
+        });
+        const createdTable = Array.isArray(result?.data) ? result.data[0] : result;
+        const createdTableId = createdTable?.id ?? createdTable?._id;
+        const liveMetadataAfterCreate = await fetchAPI(ENFYRA_API_URL, `/metadata/${encodeURIComponent(args.name)}`)
+            .catch((error) => ({ error: error?.message || String(error) }));
+        const liveTableAfterCreate = liveMetadataAfterCreate?.error
+            ? null
+            : liveMetadataAfterCreate?.data?.table || liveMetadataAfterCreate?.data || liveMetadataAfterCreate?.table || liveMetadataAfterCreate;
+        const liveSchema = summarizeCreatedTableSchema(liveTableAfterCreate, args.name);
+        const deferredRelations = arrayValue('relations', args.relations).map(normalizeRelationForTablePatch);
+        const routePath = `/${args.name}`;
+        return {
+            action: 'table_created',
+            table: { id: createdTableId, name: args.name, routePath },
+            summary: {
+                columnCount: normalizedUserColumns.length + 1,
+                createdColumnCount: normalizedUserColumns.length,
+                deferredRelationCount: deferredRelations.length,
+                indexGroupCount: indexes.length,
+                uniqueGroupCount: uniques.length,
+            },
+            schemaNormalization: normalizations,
+            schema: {
+                intended: {
+                    tableName: args.name,
+                    primaryKey: idColumn.name,
+                    fields: [idColumn.name, ...normalizedUserColumns.map((column) => column.name), ...deferredRelations.map((relation) => relation.propertyName)].filter(Boolean).sort(),
+                    columns: [idColumn.name, ...normalizedUserColumns.map((column) => column.name)].filter(Boolean),
+                    relations: deferredRelations.map((relation) => relation.propertyName).filter(Boolean),
+                },
+                live: liveSchema,
+                liveMetadataAvailable: Boolean(liveSchema),
+                liveMetadataError: liveMetadataAfterCreate?.error || undefined,
+            },
+            supportedColumnTypes: supportedTypes,
+            rest: {
+                base: apiBase,
+                routePath,
+                operations: ['GET /<table>', 'POST /<table>', 'PATCH /<table>/:id', 'DELETE /<table>/:id'],
+                noGetById: true,
+            },
+            deferredRelations,
+            result,
+        };
+    }
+    async function updateOneTable(args) {
+        const body = {};
+        if (args.name !== undefined)
+            body.name = args.name;
+        if (args.alias !== undefined)
+            body.alias = args.alias;
+        if (args.description !== undefined)
+            body.description = args.description;
+        if (args.isSingleRecord !== undefined)
+            body.isSingleRecord = args.isSingleRecord;
+        if (args.graphqlEnabled !== undefined)
+            body.graphqlEnabled = args.graphqlEnabled;
+        if (args.indexes !== undefined)
+            body.indexes = normalizeConstraintGroupsValue('indexes', args.indexes);
+        if (args.uniques !== undefined)
+            body.uniques = normalizeConstraintGroupsValue('uniques', args.uniques);
+        if (args.indexes !== undefined || args.uniques !== undefined) {
+            let indexes = body.indexes;
+            let uniques = body.uniques;
+            if (indexes === undefined || uniques === undefined) {
+                const existing = await fetchTableWithDetails(ENFYRA_API_URL, args.tableId);
+                if (indexes === undefined)
+                    indexes = normalizeConstraintGroupsValue('indexes', existing.indexes);
+                if (uniques === undefined)
+                    uniques = normalizeConstraintGroupsValue('uniques', existing.uniques);
+            }
+            assertIndexesDoNotReferenceUniqueFields(indexes ?? [], uniques ?? []);
+        }
+        const result = await patchTableAutoConfirm(ENFYRA_API_URL, args.tableId, body);
+        return {
+            action: 'table_updated',
+            tableId: args.tableId,
+            result,
+        };
+    }
+    async function deleteOneTable({ tableId, confirm }) {
+        const tableData = await fetchTableWithDetails(ENFYRA_API_URL, tableId);
+        if (!confirm) {
+            return {
+                action: 'delete_table_preview',
+                tableId,
+                tableName: tableData.name,
+                columnCount: (tableData.columns || []).length,
+                relationCount: (tableData.relations || []).length,
+                destructive: true,
+            };
+        }
+        const result = await fetchAPI(ENFYRA_API_URL, `/enfyra_table/${tableId}`, {
+            method: 'DELETE',
+        });
+        return {
+            action: 'table_deleted',
+            tableId,
+            result,
+        };
+    }
+    async function updateOneColumn({ tableId, columnId, name, type, isNullable, isPublished, isUpdatable, defaultValue, description, options }) {
+        const tableData = await fetchTableWithDetails(ENFYRA_API_URL, tableId);
+        if (!tableData) {
+            throw new Error(`Table with ID ${tableId} not found.`);
+        }
+        const existingColumns = getPatchableColumns(tableData.columns);
+        const beforeIds = existingColumns.map((column) => String(getId(column)));
+        if (!beforeIds.includes(String(columnId))) {
+            throw new Error(`Column ${columnId} was not found on table ${tableId}; refusing schema cascade patch.`);
+        }
+        const columns = existingColumns.map(col => {
+            const rest = normalizeColumnForTablePatch(col);
+            if (String(getId(col)) === String(columnId)) {
+                if (name !== undefined)
+                    rest.name = name;
+                if (type !== undefined)
+                    rest.type = type;
+                if (isNullable !== undefined)
+                    rest.isNullable = isNullable;
+                if (isPublished !== undefined)
+                    rest.isPublished = isPublished;
+                if (isUpdatable !== undefined)
+                    rest.isUpdatable = isUpdatable;
+                if (defaultValue !== undefined)
+                    rest.defaultValue = defaultValue;
+                if (description !== undefined)
+                    rest.description = description;
+                if (options !== undefined)
+                    rest.options = typeof options === 'string' ? JSON.parse(options) : options;
+            }
+            return rest;
+        });
+        const result = await patchTableAutoConfirm(ENFYRA_API_URL, tableId, { columns });
+        await verifyColumnCascade(ENFYRA_API_URL, tableId, beforeIds, {
+            action: 'update',
+            columnId,
+        });
+        return {
+            action: 'column_updated',
+            tableId,
+            columnId,
+            result,
+        };
+    }
     // ─── READ ───
     server.tool('get_all_tables', 'List table definitions from metadata. Every call must pass either limit or all=true. Use search to narrow by table name or alias.', {
         limit: z.number().int().positive().optional().describe('Maximum tables returned after search. Required unless all=true.'),
@@ -652,19 +844,19 @@ export function registerTableTools(server, ENFYRA_API_URL) {
         const primaryColumnTypes = [...new Set(primaryColumns.map((column) => column.type).filter(Boolean))];
         return jsonContent({
             action: 'schema_design_context',
-            stepZero: 'Read this response before create_table/create_column/create_relation. Use these live attributes and types, not SQL dialect guesses.',
+            stepZero: 'Read this response before create_tables/create_columns/create_relations. Use these live attributes and types, not SQL dialect guesses.',
             liveColumnTypes,
             primaryKeyContext: {
                 observedPrimaryColumnNames: primaryColumnNames,
                 observedPrimaryColumnTypes: primaryColumnTypes,
-                createTableDefault: 'This MCP create_table currently auto-includes an int id primary key for the default SQL path. If live metadata uses _id/ObjectId, stop and verify backend support before bulk schema creation.',
+                createTableDefault: 'This MCP create_tables currently auto-includes an int id primary key for the default SQL path. If live metadata uses _id/ObjectId, stop and verify backend support before bulk schema creation.',
             },
             createTableInput: {
                 directFields: ['name', 'description', 'isSingleRecord'],
                 cascadeFields: ['columns', 'relations'],
                 constraintFields: ['indexes', 'uniques'],
                 notAcceptedAtCreate: ['alias', 'graphqlEnabled'],
-                idColumn: 'create_table auto-includes an int id primary key; do not include your own id unless the user asks for custom primary-key behavior.',
+                idColumn: 'create_tables auto-includes an int id primary key; do not include your own id unless the user asks for custom primary-key behavior.',
             },
             columnDefinitionInput: {
                 allowedFields: ['name', 'type', 'isNullable', 'isUnique', 'isPublished', 'isUpdatable', 'isEncrypted', 'defaultValue', 'description', 'options'],
@@ -699,7 +891,7 @@ export function registerTableTools(server, ENFYRA_API_URL) {
                 '1. Name domain entities and decide which existing tables are reused, especially enfyra_user for users/owners/actors.',
                 '2. Create independent lookup/base tables first with scalar columns only.',
                 '3. Create dependent tables with scalar columns and relations whose target tables already exist.',
-                '4. Use create_relation after both tables exist when a relation could not be included during table creation.',
+                '4. Use create_relations after both tables exist when a relation could not be included during table creation.',
                 '5. Insert records using column names and relation propertyName values, never hidden FK columns.',
                 '6. Re-inspect each table with inspect_table before writing records or adding query examples.',
             ],
@@ -710,303 +902,206 @@ export function registerTableTools(server, ENFYRA_API_URL) {
             },
         });
     });
-    // ─── CREATE TABLE ───
-    server.tool('create_table', [
-        'Create a new table definition with an auto-included `id` primary key column.',
-        '**Not** for adding a custom API path or handler only — for that use **`create_route`** without `mainTableId`. Use **`create_table`** when the user needs new stored data (new entity).',
-        'PREFERRED: pass `columns` and `relations` params as JSON arrays to create a table WITH columns and relations in one call (cascade). Only use create_column/create_relation separately when adding to an existing table later.',
-        'Indexes and uniques are first-class table metadata. Use `indexes` for query performance and `uniques` for data integrity. Each entry is a logical field group such as [["member","isRead","conversation"]] or [{"value":["message","member"]}]. Relation property names are allowed; Enfyra resolves them to physical FK columns.',
-        'A field that appears in any `uniques` group must not appear in `indexes`; unique constraints already create indexed unique lookups.',
-        'Relations are supported in this same create_table call when the target table already exists. Each relation uses { targetTable, type, propertyName, inversePropertyName?, mappedBy?, isNullable?, onDelete? }; targetTable may be a table id, {id}, or an exact table name that MCP resolves to an id before mutation. Omit inversePropertyName unless a concrete parent-to-child query or UI surface needs it.',
-        'Do NOT provide physical FK/junction columns. Never include fkCol, fkColumn, foreignKeyColumn, sourceColumn, targetColumn, junctionSourceColumn, or junctionTargetColumn. Enfyra derives and hides those physical columns from relation propertyName/table metadata.',
-        'Schema operations (create/update/delete table, add column) must run one at a time — migration locks DB; parallel calls will fail.',
-        'Enfyra auto-creates a default REST route at path `/<table_name>` (same segment as `name`, not alias).',
-        'REST surface for that route (matches server route engine): 4 HTTP operations — GET `/<table>` (list/filter), POST `/<table>` (create), PATCH `/<table>/:id` (update), DELETE `/<table>/:id` (delete).',
-        'There is NO `GET /<table>/:id`. To fetch one row by id, use find_one_record or inspect metadata first and call GET `/<table>?filter={"<primaryKeyFromMetadata>":{"_eq":"<id>"}}&limit=1`.',
-        'Set `isSingleRecord: true` directly in create_table for settings/config tables that should keep only one record.',
-        `Full URLs: ${apiBase}/<table_name> (example table post: ${apiBase}/post).`,
-        'GraphQL is enabled separately per table through `enfyra_graphql` or `update_table` with `graphqlEnabled`; it is not controlled by route availableMethods.',
-        'Do not set alias during create_table. The create tool accepts name, description, isSingleRecord, columns, and relations only; use update_table later only if alias really needs to change.',
+    // ─── TABLE MUTATIONS ───
+    server.tool('create_tables', [
+        'Create one or more table definitions. Always pass items as a native JSON array; for one table, pass one item. JSON string arrays are accepted only for older MCP clients.',
+        'The tool creates tables sequentially, creates columns with each table, then creates all requested relations after every table in the batch exists. This avoids relation target races for weak agents.',
+        'Each item supports { name, description?, isSingleRecord?, columns?, relations?, indexes?, uniques? }. columns/relations/indexes/uniques may be arrays inside the item.',
+        'Use get_schema_design_context first for live column types and relation rules. Do not include physical FK fields.',
     ].join(' '), {
-        name: z.string().describe('Table name (e.g., "enfyra_user", "my_custom_table"). Must be unique, lowercase with underscores.'),
-        description: z.string().optional().describe('Description of what this table stores.'),
-        isSingleRecord: z.boolean().optional().describe('Set to true for single-record tables such as settings/config. This is passed directly to enfyra_table create.'),
-        columns: z.string().optional().describe('JSON array of column definitions to create with the table (cascade). Each column: { name, type, isNullable?, isUnique?, isPublished?, isUpdatable?, isEncrypted?, defaultValue?, description?, options? }. Type must come from live enfyra_column.type; common choices: varchar, text, boolean, int, bigint, float, date, datetime, timestamp, enum, simple-json, code, array-select, richtext. The tool normalizes common aliases: decimal/numeric/money/number -> float when decimal is not live-supported, longtext -> text, json/jsonb/object/array -> simple-json when live-supported, string -> varchar. Set isEncrypted=true for values encrypted at rest; set isUpdatable=false separately only when immutable. The `id` column is always auto-included. Prefer relations instead of *_id columns. Example: [{"name":"title","type":"varchar"},{"name":"metadata","type":"simple-json"},{"name":"price","type":"float"},{"name":"api_key","type":"varchar","isEncrypted":true,"isPublished":false}]'),
-        relations: z.string().optional().describe('JSON array of relation definitions to create with the table in the same cascade call. Each relation: { targetTable, type, propertyName, inversePropertyName?, mappedBy?, isNullable?, onDelete?, description? }. targetTable can be an id, {"id": <id>}, or an exact table name that MCP resolves to an id before mutation. Do not include physical FK/junction columns such as fkCol, foreignKeyColumn, sourceColumn, targetColumn, junctionSourceColumn, or junctionTargetColumn; Enfyra derives them and hides FK columns from app schema. Omit inversePropertyName unless a concrete response, UI, deep query, aggregate sort/count, or parent-to-child traversal needs the reverse field. Example only when parent posts are queried: [{"targetTable":2,"type":"many-to-one","propertyName":"author","inversePropertyName":"posts","isNullable":false,"onDelete":"CASCADE"}]'),
-        indexes: z.string().optional().describe('JSON array of logical non-unique index field groups. Each group can be ["fieldA","fieldB"] or {"value":["fieldA","fieldB"]}. Relation property names are allowed. Do not include any field that appears in uniques; unique constraints already create indexed unique lookups. Example: [["status","createdAt"]]'),
-        uniques: z.string().optional().describe('JSON array of logical unique field groups. Each group can be ["fieldA","fieldB"] or {"value":["fieldA","fieldB"]}. Example: [["message","member"]]'),
+        items: bulkObjectArrayParam(z, 'Table definitions').describe('Native JSON array of table definitions. Pass one object in the array for a single table.'),
+        maxItems: z.number().int().min(1).max(100).optional().default(100).describe('Safety cap for one schema batch. Default/max is 100; operations still run sequentially.'),
         globalRulesAckKey: globalRulesAckParam(z),
-    }, async ({ name, description, isSingleRecord, columns: columnsJson, relations: relationsJson, indexes: indexesJson, uniques: uniquesJson, globalRulesAckKey }) => withSchemaQueue(async () => {
+    }, async ({ items, maxItems, globalRulesAckKey }) => {
         assertGlobalRulesAck(globalRulesAckKey);
-        const idColumn = { name: 'id', type: 'int', isPrimary: true, isGenerated: true, isNullable: false };
-        const userColumns = parseJsonArrayParam('columns', columnsJson);
-        const parsedRelations = parseJsonArrayParam('relations', relationsJson).map(normalizeRelationForTablePatch);
-        const metadata = await fetchAPI(ENFYRA_API_URL, '/metadata');
-        const supportedTypes = getSupportedColumnTypesFromMetadata(metadata);
-        const { columns: normalizedUserColumns, normalizations } = normalizeColumnsForLiveMetadata(userColumns, supportedTypes);
-        const userRelations = resolveRelationTargetsFromMetadata(metadata, parsedRelations);
-        const indexes = parseConstraintGroupsParam('indexes', indexesJson);
-        const uniques = parseConstraintGroupsParam('uniques', uniquesJson);
-        assertIndexesDoNotReferenceUniqueFields(indexes, uniques);
-        const body = { name, description, columns: [idColumn, ...normalizedUserColumns], relations: userRelations };
-        if (isSingleRecord !== undefined)
-            body.isSingleRecord = isSingleRecord;
-        if (indexesJson !== undefined)
-            body.indexes = indexes;
-        if (uniquesJson !== undefined)
-            body.uniques = uniques;
-        const result = await fetchAPI(ENFYRA_API_URL, '/enfyra_table', {
-            method: 'POST',
-            body: JSON.stringify(body),
-        });
-        const createdTable = Array.isArray(result?.data) ? result.data[0] : result;
-        const createdTableId = createdTable?.id ?? createdTable?._id;
-        const liveMetadataAfterCreate = await fetchAPI(ENFYRA_API_URL, `/metadata/${encodeURIComponent(name)}`)
-            .catch((error) => ({ error: error?.message || String(error) }));
-        const liveTableAfterCreate = liveMetadataAfterCreate?.error
-            ? null
-            : liveMetadataAfterCreate?.data?.table || liveMetadataAfterCreate?.data || liveMetadataAfterCreate?.table || liveMetadataAfterCreate;
-        const liveSchema = summarizeCreatedTableSchema(liveTableAfterCreate, name);
-        const intendedSchema = {
-            tableName: name,
-            primaryKey: idColumn.name,
-            fields: [idColumn.name, ...normalizedUserColumns.map((column) => column.name), ...userRelations.map((relation) => relation.propertyName)].filter(Boolean).sort(),
-            columns: [idColumn.name, ...normalizedUserColumns.map((column) => column.name)].filter(Boolean),
-            relations: userRelations.map((relation) => relation.propertyName).filter(Boolean),
-        };
-        const base = ENFYRA_API_URL.replace(/\/$/, '');
-        const routePath = `/${name}`;
-        const restHint = [
-            `Auto route path: ${routePath} → full base for REST: ${base}${routePath}`,
-            `REST: GET+POST on ${routePath}; PATCH+DELETE on ${routePath}/:id only. No GET ${routePath}/:id.`,
-        ].join('\n');
-        const colHint = userColumns.length
-            ? `Table created with ${userColumns.length} column(s) + auto id.`
-            : `Table created. Use create_column to add columns (tableId: ${createdTableId}).`;
-        const relHint = userRelations.length
-            ? `Relation(s) created in same call: ${userRelations.length}.`
-            : `No relations were included in this create_table call.`;
-        const constraintHint = [
-            indexes.length ? `Index group(s): ${indexes.length}.` : null,
-            uniques.length ? `Unique group(s): ${uniques.length}.` : null,
-        ].filter(Boolean).join(' ');
+        const parsedItems = parseBulkItemsParam('items', items);
+        assertBulkLimit('create_tables', parsedItems, maxItems);
+        const created = [];
+        const deferredRelations = [];
+        for (const [index, item] of parsedItems.entries()) {
+            const result = await withSchemaQueue(() => createOneTable(item));
+            created.push({ index, ...result, deferredRelations: undefined });
+            for (const relation of result.deferredRelations || []) {
+                deferredRelations.push({ index, sourceTableId: result.table.id || result.table.name, ...relation });
+            }
+        }
+        const createdRelations = [];
+        for (const relation of deferredRelations) {
+            const relationResult = await appendRelationToTable({
+                sourceTableId: relation.sourceTableId,
+                targetTableId: relation.targetTable,
+                type: relation.type,
+                propertyName: relation.propertyName,
+                inversePropertyName: relation.inversePropertyName,
+                mappedBy: relation.mappedBy,
+                isNullable: relation.isNullable,
+                onDelete: relation.onDelete,
+                description: relation.description,
+                globalRulesAckKey,
+            });
+            createdRelations.push({ index: relation.index, ...JSON.parse(relationResult.content[0].text) });
+        }
         return jsonContent({
-            action: 'table_created',
-            table: { id: createdTableId, name, routePath },
-            summary: {
-                columnCount: normalizedUserColumns.length + 1,
-                createdColumnCount: normalizedUserColumns.length,
-                relationCount: userRelations.length,
-                indexGroupCount: indexes.length,
-                uniqueGroupCount: uniques.length,
-            },
-            schemaNormalization: normalizations,
-            schema: {
-                intended: intendedSchema,
-                live: liveSchema,
-                liveMetadataAvailable: Boolean(liveSchema),
-                liveMetadataError: liveMetadataAfterCreate?.error || undefined,
-                guidance: liveSchema
-                    ? 'Use schema.live.fields for record payload keys; relation property names are included with columns.'
-                    : 'Use schema.intended.fields for planning, then call inspect_table before writing records if the server reload is not visible yet.',
-            },
-            supportedColumnTypes: supportedTypes,
-            rest: {
-                base,
-                routePath,
-                operations: ['GET /<table>', 'POST /<table>', 'PATCH /<table>/:id', 'DELETE /<table>/:id'],
-                noGetById: true,
-            },
-            message: [colHint, relHint, constraintHint, restHint].filter(Boolean).join('\n'),
-            result,
+            action: 'tables_created',
+            requested: parsedItems.length,
+            createdCount: created.length,
+            deferredRelationCount: deferredRelations.length,
+            createdRelationCount: createdRelations.length,
+            sequential: true,
+            relationPhaseAfterTables: true,
+            created,
+            createdRelations,
         });
-    }));
-    // ─── UPDATE TABLE ───
-    server.tool('update_table', [
-        'Update table properties: name (rename), alias, description, isSingleRecord, graphqlEnabled, indexes, and uniques.',
-        'Does NOT modify columns or relations — use create_column, update_column, delete_column, create_relation for those.',
-        'When passing `indexes` or `uniques`, pass the complete desired array of logical field groups; omitted fields are preserved. Relation property names are allowed and are resolved by Enfyra. Example indexes: [["member","isRead","conversation"],["conversation","member","isRead"]].',
-        'A field that appears in any `uniques` group must not appear in `indexes`; unique constraints already create indexed unique lookups.',
-        'Run schema changes sequentially — migration locks DB per operation.',
-    ].join(' '), {
-        tableId: z.string().describe('Table definition ID.'),
-        name: z.string().optional().describe('New table name (rename). Lowercase with underscores.'),
-        alias: z.string().optional().describe('New table alias.'),
-        description: z.string().optional().describe('New description.'),
-        isSingleRecord: z.boolean().optional().describe('Set to true for single-record table (e.g., settings/config).'),
-        graphqlEnabled: z.boolean().optional().describe('Enable or disable GraphQL for this table by syncing enfyra_graphql.isEnabled. GraphQL table data still requires Bearer auth; anonymous root or schema probes may return 200.'),
-        indexes: z.string().optional().describe('Complete JSON array of logical non-unique index field groups to store on enfyra_table.indexes. Each group can be ["fieldA","fieldB"] or {"value":["fieldA","fieldB"]}. Omit to preserve current indexes; pass [] to clear. Do not include any field that appears in uniques; unique constraints already create indexed unique lookups.'),
-        uniques: z.string().optional().describe('Complete JSON array of logical unique field groups to store on enfyra_table.uniques. Each group can be ["fieldA","fieldB"] or {"value":["fieldA","fieldB"]}. Omit to preserve current uniques; pass [] to clear.'),
+    });
+    server.tool('update_tables', 'Update one or more table definitions. Always pass items as a native JSON array; for one table, pass one item. Items run sequentially through the schema queue. JSON string arrays are accepted only for older MCP clients.', {
+        items: bulkObjectArrayParam(z, 'Table update items').describe('Native JSON array of table update items: [{ tableId, name?, alias?, description?, isSingleRecord?, graphqlEnabled?, indexes?, uniques? }]. indexes/uniques may be arrays.'),
+        maxItems: z.number().int().min(1).max(100).optional().default(100).describe('Safety cap for one schema batch. Default/max is 100.'),
         globalRulesAckKey: globalRulesAckParam(z),
-    }, async ({ tableId, name, alias, description, isSingleRecord, graphqlEnabled, indexes: indexesJson, uniques: uniquesJson, globalRulesAckKey }) => withSchemaQueue(async () => {
+    }, async ({ items, maxItems, globalRulesAckKey }) => {
         assertGlobalRulesAck(globalRulesAckKey);
-        const body = {};
-        if (name !== undefined)
-            body.name = name;
-        if (alias !== undefined)
-            body.alias = alias;
-        if (description !== undefined)
-            body.description = description;
-        if (isSingleRecord !== undefined)
-            body.isSingleRecord = isSingleRecord;
-        if (graphqlEnabled !== undefined)
-            body.graphqlEnabled = graphqlEnabled;
-        if (indexesJson !== undefined)
-            body.indexes = parseConstraintGroupsParam('indexes', indexesJson);
-        if (uniquesJson !== undefined)
-            body.uniques = parseConstraintGroupsParam('uniques', uniquesJson);
-        if (indexesJson !== undefined || uniquesJson !== undefined) {
-            let indexes = body.indexes;
-            let uniques = body.uniques;
-            if (indexes === undefined || uniques === undefined) {
-                const existing = await fetchTableWithDetails(ENFYRA_API_URL, tableId);
-                if (indexes === undefined)
-                    indexes = normalizeConstraintGroupsValue('indexes', existing.indexes);
-                if (uniques === undefined)
-                    uniques = normalizeConstraintGroupsValue('uniques', existing.uniques);
-            }
-            assertIndexesDoNotReferenceUniqueFields(indexes ?? [], uniques ?? []);
+        const parsedItems = parseBulkItemsParam('items', items);
+        assertBulkLimit('update_tables', parsedItems, maxItems);
+        const updated = [];
+        for (const [index, item] of parsedItems.entries()) {
+            if (!item.tableId)
+                throw new Error(`items[${index}].tableId is required.`);
+            const result = await withSchemaQueue(() => updateOneTable(item));
+            updated.push({ index, ...result });
+        }
+        return jsonContent({ action: 'tables_updated', requested: parsedItems.length, updatedCount: updated.length, sequential: true, updated });
+    });
+    server.tool('delete_tables', 'Delete one or more table definitions. Always pass items as a native JSON array; for one table, pass one item. confirm=false previews every target; confirm=true deletes sequentially. JSON string arrays are accepted only for older MCP clients.', {
+        items: bulkObjectArrayParam(z, 'Table delete items').describe('Native JSON array of delete items: [{ tableId }].'),
+        maxItems: z.number().int().min(1).max(100).optional().default(100).describe('Safety cap for one schema batch. Default/max is 100.'),
+        confirm: z.boolean().optional().default(false).describe('Required true to apply destructive deletes. Omit/false returns previews only.'),
+        globalRulesAckKey: globalRulesAckParam(z).optional().describe('Required when confirm=true. Use globalRulesAckKey from get_enfyra_required_knowledge.'),
+    }, async ({ items, maxItems, confirm, globalRulesAckKey }) => {
+        const parsedItems = parseBulkItemsParam('items', items);
+        assertBulkLimit('delete_tables', parsedItems, maxItems);
+        if (confirm)
+            assertGlobalRulesAck(globalRulesAckKey);
+        const results = [];
+        for (const [index, item] of parsedItems.entries()) {
+            if (!item.tableId)
+                throw new Error(`items[${index}].tableId is required.`);
+            const result = await withSchemaQueue(() => deleteOneTable({ tableId: item.tableId, confirm }));
+            results.push({ index, ...result });
         }
-        const result = await patchTableAutoConfirm(ENFYRA_API_URL, tableId, body);
         return jsonContent({
-            action: 'table_updated',
-            tableId,
-            result,
+            action: confirm ? 'tables_deleted' : 'delete_tables_preview',
+            requested: parsedItems.length,
+            sequential: true,
+            destructive: true,
+            results,
+            next: confirm ? undefined : 'Call delete_tables again with the same items and confirm=true to delete sequentially.',
         });
-    }));
-    // ─── DELETE TABLE ───
-    server.tool('delete_table', [
-        'Delete a table and ALL associated data. This is DESTRUCTIVE and IRREVERSIBLE.',
-        'Deletes: table metadata, all columns, all relations (source + target), all routes, junction tables, FK columns from other tables, and the PHYSICAL DATABASE TABLE with ALL DATA.',
-        'Always confirm with the user before calling this tool.',
-    ].join(' '), {
-        tableId: z.string().describe('Table definition ID to delete.'),
-        confirm: z.boolean().optional().default(false).describe('Required true to apply the destructive delete. Omit/false returns a preview only.'),
-        globalRulesAckKey: globalRulesAckParam(z).optional().describe('Required when confirm=true. Use globalRulesAckKey from get_enfyra_required_knowledge.'),
-    }, async ({ tableId, confirm, globalRulesAckKey }) => withSchemaQueue(async () => {
-        const tableData = await fetchTableWithDetails(ENFYRA_API_URL, tableId);
-        if (!confirm) {
-            return {
-                content: [{ type: 'text', text: JSON.stringify({
-                            action: 'delete_table_preview',
-                            tableId,
-                            tableName: tableData.name,
-                            columnCount: (tableData.columns || []).length,
-                            relationCount: (tableData.relations || []).length,
-                            destructive: true,
-                            next: 'Call delete_table again with confirm=true to delete metadata, routes, derived FK/junction structures, the physical table, and all table data.',
-                        }, null, 2) }],
-            };
+    });
+    // ─── COLUMN MUTATIONS ───
+    server.tool('create_columns', 'Create one or more columns. Always pass items as a native JSON array; for one column, pass one item. Items run sequentially through the schema queue. JSON string arrays are accepted only for older MCP clients.', {
+        items: bulkObjectArrayParam(z, 'Column definitions').describe('Native JSON array of column definitions. Each item uses create_columns fields: { tableId, name, type, isNullable?, isUnique?, isPublished?, isUpdatable?, isEncrypted?, isPrimary?, isGenerated?, isSystem?, defaultValue?, description?, options? }.'),
+        maxItems: z.number().int().min(1).max(100).optional().default(100).describe('Safety cap for one schema batch. Default/max is 100.'),
+        globalRulesAckKey: globalRulesAckParam(z),
+    }, async ({ items, maxItems, globalRulesAckKey }) => {
+        assertGlobalRulesAck(globalRulesAckKey);
+        const parsedItems = parseBulkItemsParam('items', items);
+        assertBulkLimit('create_columns', parsedItems, maxItems);
+        const created = [];
+        for (const [index, item] of parsedItems.entries()) {
+            const result = await appendColumnToTable({ ...item, globalRulesAckKey });
+            created.push({ index, ...JSON.parse(result.content[0].text) });
         }
+        return jsonContent({ action: 'columns_created', requested: parsedItems.length, createdCount: created.length, sequential: true, created });
+    });
+    server.tool('update_columns', 'Update one or more columns. Always pass items as a native JSON array; for one column, pass one item. Items run sequentially through the schema queue. JSON string arrays are accepted only for older MCP clients.', {
+        items: bulkObjectArrayParam(z, 'Column update items').describe('Native JSON array of column update items: [{ tableId, columnId, name?, type?, isNullable?, isPublished?, isUpdatable?, defaultValue?, description?, options? }].'),
+        maxItems: z.number().int().min(1).max(100).optional().default(100).describe('Safety cap for one schema batch. Default/max is 100.'),
+        globalRulesAckKey: globalRulesAckParam(z),
+    }, async ({ items, maxItems, globalRulesAckKey }) => {
         assertGlobalRulesAck(globalRulesAckKey);
-        const result = await fetchAPI(ENFYRA_API_URL, `/enfyra_table/${tableId}`, {
-            method: 'DELETE',
-        });
+        const parsedItems = parseBulkItemsParam('items', items);
+        assertBulkLimit('update_columns', parsedItems, maxItems);
+        const updated = [];
+        for (const [index, item] of parsedItems.entries()) {
+            if (!item.tableId)
+                throw new Error(`items[${index}].tableId is required.`);
+            if (!item.columnId)
+                throw new Error(`items[${index}].columnId is required.`);
+            const result = await withSchemaQueue(() => updateOneColumn(item));
+            updated.push({ index, ...result });
+        }
+        return jsonContent({ action: 'columns_updated', requested: parsedItems.length, updatedCount: updated.length, sequential: true, updated });
+    });
+    server.tool('delete_columns', 'Delete one or more columns. Always pass items as a native JSON array; for one column, pass one item. confirm=false previews every target; confirm=true deletes sequentially. JSON string arrays are accepted only for older MCP clients.', {
+        items: bulkObjectArrayParam(z, 'Column delete items').describe('Native JSON array of delete items: [{ tableId, columnId }].'),
+        maxItems: z.number().int().min(1).max(100).optional().default(100).describe('Safety cap for one schema batch. Default/max is 100.'),
+        confirm: z.boolean().optional().default(false).describe('Required true to apply destructive deletes. Omit/false returns previews only.'),
+        globalRulesAckKey: globalRulesAckParam(z).optional().describe('Required when confirm=true. Use globalRulesAckKey from get_enfyra_required_knowledge.'),
+    }, async ({ items, maxItems, confirm, globalRulesAckKey }) => {
+        const parsedItems = parseBulkItemsParam('items', items);
+        assertBulkLimit('delete_columns', parsedItems, maxItems);
+        if (confirm)
+            assertGlobalRulesAck(globalRulesAckKey);
+        const results = [];
+        for (const [index, item] of parsedItems.entries()) {
+            if (!item.tableId)
+                throw new Error(`items[${index}].tableId is required.`);
+            if (!item.columnId)
+                throw new Error(`items[${index}].columnId is required.`);
+            const result = await removeColumnFromTable({ ...item, confirm, globalRulesAckKey });
+            results.push({ index, ...JSON.parse(result.content[0].text) });
+        }
         return jsonContent({
-            action: 'table_deleted',
-            tableId,
-            result,
+            action: confirm ? 'columns_deleted' : 'delete_columns_preview',
+            requested: parsedItems.length,
+            sequential: true,
+            destructive: true,
+            results,
+            next: confirm ? undefined : 'Call delete_columns again with the same items and confirm=true to delete sequentially.',
         });
-    }));
-    // ─── CREATE COLUMN ───
-    server.tool('create_column', [
-        'Add a column to an existing table via PATCH /enfyra_table/{tableId}.',
-        'Columns are managed through cascade with enfyra_table — there is NO direct /enfyra_column endpoint.',
-        'This tool reads full table metadata, keeps only persisted column rows with id/_id, appends the new one, PATCHes the table, and verifies unrelated columns survived.',
-        'Generated metadata projections such as createdAt, updatedAt, or relation-derived FK display fields without id are not valid cascade rows and are skipped.',
-        'Run schema changes sequentially — migration locks DB per operation.',
-    ].join(' '), {
-        ...columnCreateSchema,
-    }, appendColumnToTable);
-    // ─── UPDATE COLUMN ───
-    server.tool('update_column', [
-        'Update an existing column on a table via PATCH /enfyra_table/{tableId}.',
-        'Reads full table metadata, keeps only persisted rows with id/_id, modifies the target column, PATCHes the table, and verifies unrelated columns survived.',
-        'Generated metadata projections such as createdAt, updatedAt, or relation-derived FK display fields without id are skipped.',
-        'Run schema changes sequentially — migration locks DB per operation.',
-    ].join(' '), {
-        tableId: z.string().describe('Table definition ID.'),
-        columnId: z.string().describe('Column definition ID to update.'),
-        name: z.string().optional().describe('New column name.'),
-        type: z.string().optional().describe('New column type.'),
-        isNullable: z.boolean().optional().describe('Set nullable.'),
-        isPublished: z.boolean().optional().describe('Set column visibility baseline. false = unpublished (omitted from response unless allowed by field permission rules).'),
-        isUpdatable: z.boolean().optional().describe('Set false for immutable fields that should be stripped from update payloads.'),
-        defaultValue: z.string().optional().describe('New default value as JSON string.'),
-        description: z.string().optional().describe('New description.'),
-        options: z.string().optional().describe('New options as JSON string.'),
+    });
+    // ─── RELATION MUTATIONS ───
+    server.tool('create_relations', 'Create one or more relations. Always pass items as a native JSON array; for one relation, pass one item. Items run sequentially through the schema queue and table names/aliases are resolved internally. JSON string arrays are accepted only for older MCP clients.', {
+        items: bulkObjectArrayParam(z, 'Relation definitions').describe('Native JSON array of relation definitions. Each item uses { sourceTableId, targetTableId, type, propertyName, inversePropertyName?, mappedBy?, isNullable?, onDelete?, description? }. Do not send physical FK fields.'),
+        maxItems: z.number().int().min(1).max(100).optional().default(100).describe('Safety cap for one schema batch. Default/max is 100.'),
         globalRulesAckKey: globalRulesAckParam(z),
-    }, async ({ tableId, columnId, name, type, isNullable, isPublished, isUpdatable, defaultValue, description, options, globalRulesAckKey }) => withSchemaQueue(async () => {
+    }, async ({ items, maxItems, globalRulesAckKey }) => {
         assertGlobalRulesAck(globalRulesAckKey);
-        const tableData = await fetchTableWithDetails(ENFYRA_API_URL, tableId);
-        if (!tableData) {
-            throw new Error(`Table with ID ${tableId} not found.`);
+        const parsedItems = parseBulkItemsParam('items', items);
+        assertBulkLimit('create_relations', parsedItems, maxItems);
+        const created = [];
+        for (const [index, item] of parsedItems.entries()) {
+            const result = await appendRelationToTable({ ...item, globalRulesAckKey });
+            created.push({ index, ...JSON.parse(result.content[0].text) });
         }
-        const existingColumns = getPatchableColumns(tableData.columns);
-        const beforeIds = existingColumns.map((column) => String(getId(column)));
-        if (!beforeIds.includes(String(columnId))) {
-            throw new Error(`Column ${columnId} was not found on table ${tableId}; refusing schema cascade patch.`);
+        return jsonContent({ action: 'relations_created', requested: parsedItems.length, createdCount: created.length, sequential: true, created });
+    });
+    server.tool('delete_relations', 'Delete one or more relations. Always pass items as a native JSON array; for one relation, pass one item. confirm=false previews every target; confirm=true deletes sequentially. JSON string arrays are accepted only for older MCP clients.', {
+        items: bulkObjectArrayParam(z, 'Relation delete items').describe('Native JSON array of delete items: [{ tableId, relationId }].'),
+        maxItems: z.number().int().min(1).max(100).optional().default(100).describe('Safety cap for one schema batch. Default/max is 100.'),
+        confirm: z.boolean().optional().default(false).describe('Required true to apply destructive deletes. Omit/false returns previews only.'),
+        globalRulesAckKey: globalRulesAckParam(z).optional().describe('Required when confirm=true. Use globalRulesAckKey from get_enfyra_required_knowledge.'),
+    }, async ({ items, maxItems, confirm, globalRulesAckKey }) => {
+        const parsedItems = parseBulkItemsParam('items', items);
+        assertBulkLimit('delete_relations', parsedItems, maxItems);
+        if (confirm)
+            assertGlobalRulesAck(globalRulesAckKey);
+        const results = [];
+        for (const [index, item] of parsedItems.entries()) {
+            if (!item.tableId)
+                throw new Error(`items[${index}].tableId is required.`);
+            if (!item.relationId)
+                throw new Error(`items[${index}].relationId is required.`);
+            const result = await removeRelationFromTable({ ...item, confirm, globalRulesAckKey });
+            results.push({ index, ...JSON.parse(result.content[0].text) });
         }
-        const columns = existingColumns.map(col => {
-            const rest = normalizeColumnForTablePatch(col);
-            if (String(getId(col)) === String(columnId)) {
-                if (name !== undefined)
-                    rest.name = name;
-                if (type !== undefined)
-                    rest.type = type;
-                if (isNullable !== undefined)
-                    rest.isNullable = isNullable;
-                if (isPublished !== undefined)
-                    rest.isPublished = isPublished;
-                if (isUpdatable !== undefined)
-                    rest.isUpdatable = isUpdatable;
-                if (defaultValue !== undefined)
-                    rest.defaultValue = defaultValue;
-                if (description !== undefined)
-                    rest.description = description;
-                if (options !== undefined)
-                    rest.options = JSON.parse(options);
-            }
-            return rest;
-        });
-        const result = await patchTableAutoConfirm(ENFYRA_API_URL, tableId, { columns });
-        await verifyColumnCascade(ENFYRA_API_URL, tableId, beforeIds, {
-            action: 'update',
-            columnId,
-        });
         return jsonContent({
-            action: 'column_updated',
-            tableId,
-            columnId,
-            result,
+            action: confirm ? 'relations_deleted' : 'delete_relations_preview',
+            requested: parsedItems.length,
+            sequential: true,
+            destructive: true,
+            results,
+            next: confirm ? undefined : 'Call delete_relations again with the same items and confirm=true to delete sequentially.',
         });
-    }));
-    // ─── DELETE COLUMN ───
-    server.tool('delete_column', [
-        'Delete a column from a table via PATCH /enfyra_table/{tableId}.',
-        'Reads full table metadata, keeps only persisted rows with id/_id, removes the target, PATCHes the table, and verifies unrelated columns survived.',
-        'The physical column is dropped from the database. System columns (id, createdAt, updatedAt) cannot be deleted.',
-        'Run schema changes sequentially — migration locks DB per operation.',
-    ].join(' '), {
-        ...columnDeleteSchema,
-    }, removeColumnFromTable);
-    // ─── CREATE RELATION ───
-    server.tool('create_relation', [
-        'Create a relation between two tables (many-to-one, one-to-many, one-to-one, many-to-many).',
-        'sourceTableId and targetTableId may be table ids, exact table names, or aliases; MCP resolves them from metadata before mutation.',
-        'For many-to-one: a physical FK column is created on the source table. For one-to-many: the FK is on the target (inverse relation). This physical FK is derived by Enfyra and hidden from app schema/forms.',
-        'Never ask the user for physical FK column names and never send fkCol/fkColumn/foreignKeyColumn/sourceColumn/targetColumn/junction*Column. The public API uses relation propertyName only.',
-        'Run sequentially — DB migration locks per operation.',
-    ].join(' '), {
-        ...relationCreateSchema,
-    }, appendRelationToTable);
-    // ─── DELETE RELATION ───
-    server.tool('delete_relation', [
-        'Delete a relation from a table via PATCH /enfyra_table/{tableId}.',
-        'Fetches all relations, removes the target, and PATCHes the table.',
-        'Drops FK columns and junction tables (for many-to-many).',
-    ].join(' '), {
-        ...relationDeleteSchema,
-    }, removeRelationFromTable);
+    });
 }
 //# sourceMappingURL=table-tools.js.map