Database API

1
import { AthenaIntelligenceClient } from '@athenaintel/sdk';
2
3
const client = new AthenaIntelligenceClient({
4
  apiKey: process.env.ATHENA_API_KEY,
5
});
6
7
// Basic select - get all rows
8
const response = await client.databases.select(
9
  "your-database-asset-id",
10
  "users"
11
);
12
13
// With pagination and ordering options
14
const paginatedResponse = await client.databases.select(
15
  "your-database-asset-id",
16
  "users",
17
  {
18
    select: "id,name,email",           // Columns to return
19
    order: "created_at.desc",          // Sort by created_at descending
20
    limit: 50,                         // Max 50 rows
21
    offset: 0,                         // Skip 0 rows (for pagination)
22
  }
23
);
24
25
// With filters - pass filter conditions via queryParams
26
const filteredResponse = await client.databases.select(
27
  "your-database-asset-id",
28
  "users",
29
  {
30
    select: "id,name,email",
31
    limit: 50,
32
  },
33
  {
34
    queryParams: {
35
      status: "eq.active",             // Filter: status = 'active'
36
      age: "gt.21",                    // Filter: age > 21
37
    }
38
  }
39
);
40
41
console.log(filteredResponse.data);
42
// [{ id: 1, name: "John", email: "john@example.com" }, ...]

1
// Insert a single row
2
const response = await client.databases.insert(
3
  "your-database-asset-id",
4
  "users",
5
  {
6
    data: {
7
      name: "John Doe",
8
      email: "john@example.com",
9
      status: "active",
10
    },
11
    returnRepresentation: true, // Return the inserted row
12
  }
13
);
14
15
console.log(response.data);
16
// [{ id: 1, name: "John Doe", email: "john@example.com", status: "active" }]
17
18
// Insert multiple rows
19
const bulkResponse = await client.databases.insert(
20
  "your-database-asset-id",
21
  "users",
22
  {
23
    data: [
24
      { name: "Alice", email: "alice@example.com", status: "active" },
25
      { name: "Bob", email: "bob@example.com", status: "pending" },
26
    ],
27
    returnRepresentation: true,
28
  }
29
);

1
// Update rows matching a filter - pass filter conditions via queryParams
2
const response = await client.databases.update(
3
  "your-database-asset-id",
4
  "users",
5
  {
6
    data: {
7
      status: "inactive",
8
      updated_at: new Date().toISOString(),
9
    },
10
    return_representation: true,
11
  },
12
  {
13
    // Filter: update users where status is 'pending' and created more than 30 days ago
14
    queryParams: {
15
      status: "eq.pending",
16
      created_at: "lt.2024-01-01",
17
    }
18
  }
19
);
20
21
console.log(`Updated ${response.data?.length} rows`);
22
23
// Update all rows (requires force=true)
24
const allResponse = await client.databases.update(
25
  "your-database-asset-id",
26
  "users",
27
  {
28
    force: true,
29
    data: { last_sync: new Date().toISOString() },
30
  }
31
);

1
// Delete rows matching a filter - pass filter conditions via queryParams
2
const response = await client.databases.delete(
3
  "your-database-asset-id",
4
  "users",
5
  {
6
    body: { return_representation: true }, // Return deleted rows
7
  },
8
  {
9
    // Filter: delete users where status is 'deleted' and older than 90 days
10
    queryParams: {
11
      status: "eq.deleted",
12
      deleted_at: "lt.2024-01-01",
13
    }
14
  }
15
);
16
17
console.log(`Deleted ${response.data?.length} rows`);
18
19
// Delete a specific row by ID
20
const singleDelete = await client.databases.delete(
21
  "your-database-asset-id",
22
  "users",
23
  {},
24
  {
25
    queryParams: { id: "eq.123" }
26
  }
27
);
28
29
// Delete all rows (requires force=true) - USE WITH CAUTION!
30
const allDelete = await client.databases.delete(
31
  "your-database-asset-id",
32
  "temp_logs",
33
  { force: true }
34
);

1
const pageSize = 20;
2
let page = 0;
3
let hasMore = true;
4
5
while (hasMore) {
6
  const response = await client.databases.select(
7
    "your-database-asset-id",
8
    "users",
9
    {
10
      limit: pageSize,
11
      offset: page * pageSize,
12
      order: "id.asc",
13
    }
14
  );
15
16
  console.log(`Page ${page + 1}:`, response.data);
17
18
  hasMore = response.data.length === pageSize;
19
  page++;
20
}

1
const tables = await client.databases.listTables("your-database-asset-id");
2
console.log(tables.tables);
3
// [{ name: "users", schema_name: "public", row_count: 1000 }, ...]

1
const schema = await client.databases.getTableSchema(
2
  "your-database-asset-id",
3
  "users"
4
);
5
console.log(schema.columns);
6
// [{ name: "id", data_type: "integer", is_nullable: false }, ...]

1
const status = await client.databases.getStatus("your-database-asset-id");
2
console.log(status.status); // "running", "suspended", "starting", etc.

1
import { AthenaIntelligenceError } from '@athenaintel/sdk';
2
3
try {
4
  const response = await client.databases.select(
5
    "your-database-asset-id",
6
    "users",
7
    {},
8
    { queryParams: { id: "eq.invalid" } }
9
  );
10
} catch (error) {
11
  if (error instanceof AthenaIntelligenceError) {
12
    switch (error.statusCode) {
13
      case 400:
14
        console.error("Bad request - check your filter syntax");
15
        break;
16
      case 403:
17
        console.error("Access denied to this database");
18
        break;
19
      case 404:
20
        console.error("Database or table not found");
21
        break;
22
      case 503:
23
        console.error("Database is starting up - retry in a moment");
24
        break;
25
      default:
26
        console.error("API error:", error.message);
27
    }
28
  }
29
}