Skip to main content

Delete Records

Remove records from your Boltic Tables safely and efficiently. The SDK provides a unified delete system that supports both individual record deletion by ID and bulk deletion using filters.

Delete Operations​

The SDK provides two approaches for deleting records:

delete() - Unified Delete Method​

The primary delete method that supports both record IDs and filter-based deletion.

client.records.delete(tableName: string, options: RecordDeleteOptions): Promise<ApiResponse<{ deleted_count: number; deleted_records: RecordWithId[] }>>

deleteById() - Single Record Delete​

Delete a specific record by its ID (convenience method).

client.records.deleteById(tableName: string, recordId: string): Promise<ApiResponse<{ deleted_count: number; deleted_records: RecordWithId[] }>>

RecordDeleteOptions Interface​

interface RecordDeleteOptions {
    // Either record_ids or filters must be provided, but not both
    record_ids?: string[]; // Delete by record IDs
    filters?: ApiFilter[] | Record<string, unknown>; // Delete by filter criteria
}

Delete by Record IDs​

Single Record Deletion (Direct Approach)​

import { createClient } from "@boltic/sdk";

const client = createClient("your-api-key");

// Delete a specific record by ID using unified method
const recordId = "rec_123456789";

const { data: result, error } = await client.records.delete("users", {
    record_ids: [recordId],
});

// Or using the convenience method
// const { data: result, error } = await client.records.deleteById('users', recordId);

if (error) {
    console.error("Delete failed:", error.message);
} else {
    console.log(`Deleted ${result.deleted_count} record(s)`);
}

Multiple Records by ID​

// Delete multiple specific records
const recordIds = ["rec_123456789", "rec_987654321", "rec_456789123"];

const { data: result, error } = await client.records.delete("users", {
    record_ids: recordIds,
});

if (error) {
    console.error("Bulk delete failed:", error.message);
} else {
    console.log(`Successfully deleted ${result.deletedCount} out of ${recordIds.length} records`);
}

Convenience Method for Single Record​

// Using the convenience method for single record deletion
const { data: result, error } = await client.records.deleteById("users", recordId);

if (error) {
    console.error("Delete failed:", error.message);
} else {
    console.log(`Record deleted: ${result.deletedCount === 1 ? "Success" : "Failed"}`);
}

Delete by Filters​

Simple Filter Deletion​

// Delete records matching simple criteria
const { data: result, error } = await client.records.delete("users", {
    filters: {
        status: "inactive",
        last_login: { $lt: "2022-01-01T00:00:00Z" },
    },
});

console.log(`Deleted ${result.deletedCount} inactive users`);

Complex Filter Deletion​

import { createFilter } from "@boltic/sdk";

// Delete using FilterBuilder
const deleteFilters = createFilter()
    .equals("status", "draft")
    .lessThan("created_at", "2023-01-01T00:00:00Z")
    .equals("author_id", "user_123")
    .build();

const { data: result } = await client.records.delete("blog_posts", {
    filters: deleteFilters,
});

console.log(`Deleted ${result.deletedCount} old draft posts`);

ApiFilter Format Deletion​

// Delete using direct ApiFilter format
const { data: result } = await client.records.delete("products", {
    filters: [
        { field: "stock_count", operator: "=", values: [0] },
        { field: "is_discontinued", operator: "=", values: [true] },
        { field: "last_updated", operator: "<", values: ["2023-06-01T00:00:00Z"] },
    ],
});

console.log(`Deleted ${result.deletedCount} discontinued products`);

Delete with Different Filter Types​

Text Field Filters​

// Delete by text field criteria
const { data: result } = await client.records.delete("comments", {
    filters: {
        content: { $like: "%spam%" },
        author_email: { $ilike: "%@suspicious-domain.com" },
    },
});

// Delete by text patterns
const { data: testResult } = await client.records.delete("users", {
    filters: [
        { field: "email", operator: "STARTS WITH", values: ["test_"] },
        { field: "name", operator: "LIKE", values: ["%dummy%"] },
    ],
});

Numeric Field Filters​

// Delete by numeric criteria
const { data: result } = await client.records.delete("products", {
    filters: {
        price: { $eq: 0 },
        stock_count: { $lte: 0 },
        view_count: { $lt: 10 },
    },
});

// Delete by range
const { data: rangeResult } = await client.records.delete("analytics_events", {
    filters: {
        session_duration: { $between: [0, 5] }, // Very short sessions
        bounce_rate: { $gt: 0.9 }, // High bounce rate
    },
});

Boolean Field Filters​

// Delete by boolean criteria
const { data: result } = await client.records.delete("users", {
    filters: {
        is_verified: false,
        is_active: false,
        newsletter_subscribed: false,
    },
});

Date Field Filters​

// Delete by date criteria
const { data: result } = await client.records.delete("events", {
    filters: [
        { field: "event_date", operator: "<", values: [new Date().toISOString()] },
        { field: "is_cancelled", operator: "=", values: [true] },
    ],
});

// Delete using date periods
const { data: periodResult } = await client.records.delete("user_sessions", {
    filters: [{ field: "created_at", operator: "WITHIN", values: ["last-30-days"] }],
});

JSON Field Filters​

// Delete by JSON field criteria
const { data: result } = await client.records.delete("user_settings", {
    filters: {
        preferences: { $eq: null },
        metadata: { $isEmpty: true },
    },
});

Response Format​

Successful Delete Response​

interface BolticSuccessResponse<{ deleted_count: number; deleted_records: RecordWithId[] }> {
  data: {
    deleted_count: number;        // Number of records actually deleted
    deleted_records: RecordWithId[]; // Array of deleted record data
  };
  error: null;
}

Error Response​

interface BolticErrorResponse {
    data: null;
    error: {
        message: string; // Human-readable error message
        meta?: string[];
    };
}

Next Steps​

After understanding delete operations, you might want to:

  1. Implement comprehensive filtering for precise deletions
  2. Set up data retention policies for automated cleanup
  3. Create backup strategies for critical data
  4. Monitor and audit delete operations