Delete Column

Remove columns from tables while ensuring data integrity and proper cleanup procedures.

⚠️ Warning: Deleting a column permanently removes all data in that column. This operation cannot be undone.

delete()

Delete a column from a table.

client.columns.delete(tableName: string, columnName: string): Promise<BolticSuccessResponse<{ success: boolean, message?: string }> | BolticErrorResponse>

Parameters

Parameter	Type	Required	Description
tableName	string	✅	Name of the target table
columnName	string	✅	Name of the column to delete

Basic Usage

const { data, error } = await client.columns.delete("products", "old_field");

if (error) {
    console.error("Failed to delete column:", error.message);
} else {
    console.log("Column deleted successfully:", data.message);
}

Response Format

{
    data: {
        message: "Field Deleted";
    }
}

Safety Considerations

Protected Columns

System columns cannot be deleted:

• id - Primary key
• created_at - Creation timestamp
• updated_at - Modification timestamp

// ❌ This will fail
const { error } = await client.columns.delete("products", "id");
// Error: Cannot delete system column 'id'

Bulk Column Deletion

Safe Bulk Deletion

async function deleteMultipleColumns(tableName: string, columnNames: string[]) {
    const results = [];

    for (const columnName of columnNames) {
        console.log(`\nProcessing column: ${columnName}`);

        // Validate each column
        const analysis = await analyzeColumnBeforeDelete(tableName, columnName);

        if (analysis.canDelete) {
            const { data, error } = await client.columns.delete(tableName, columnName);

            results.push({
                column: columnName,
                success: !error,
                error: error?.message,
                warnings: analysis.warnings,
            });

            if (error) {
                console.error(`❌ Failed to delete ${columnName}:`, error.message);
            } else {
                console.log(`✅ Deleted ${columnName}`);
            }
        } else {
            results.push({
                column: columnName,
                success: false,
                error: analysis.reason,
                skipped: true,
            });

            console.log(`⏭️  Skipped ${columnName}: ${analysis.reason}`);
        }
    }

    return results;
}

// Usage
const columnsToDelete = ["temp_field", "old_status", "beta_feature"];
const results = await deleteMultipleColumns("products", columnsToDelete);

console.log("\nDeletion Summary:");
results.forEach((result) => {
    const status = result.success ? "✅" : "❌";
    console.log(`${status} ${result.column}: ${result.error || "Success"}`);
});

Conditional Deletion

async function deleteColumnsWithConditions(tableName: string, conditions: any) {
    // Find columns matching conditions
    const { data: columns } = await client.columns.findAll(tableName, {
        where: conditions,
        fields: ["name", "type", "is_nullable", "description"],
    });

    if (!columns || columns.length === 0) {
        console.log("No columns match deletion criteria");
        return;
    }

    console.log(`Found ${columns.length} columns matching criteria:`);
    columns.forEach((col) => {
        console.log(`- ${col.name} (${col.type}): ${col.description || "No description"}`);
    });

    // Delete each matching column
    for (const column of columns) {
        const { data, error } = await client.columns.delete(tableName, column.name);

        if (error) {
            console.error(`Failed to delete ${column.name}:`, error.message);
        } else {
            console.log(`Deleted ${column.name}`);
        }
    }
}

// Examples
// Delete all nullable text columns without descriptions
await deleteColumnsWithConditions("products", {
    type: "text",
    is_nullable: true,
    description: { $null: true },
});

// Delete all temporary columns
await deleteColumnsWithConditions("users", {
    name: { $like: "temp_%" },
});