Client

import { createClient } from '@ondb/sdk';

const client = createClient({
  endpoint: 'https://api.ondb.io',
  appId: 'your-app-id',
  appKey: 'your-app-key',      // For writes (X-App-Key header)
  agentKey: 'your-agent-key',  // Optional: For agent payments (X-Agent-Key header)
  timeout: 30000,              // Request timeout (ms)
  retryCount: 3,               // Retry attempts
  retryDelay: 1000,            // Retry delay (ms)
});

const result = await client.store(
  { collection: 'users', data: [{ name: 'Alice' }] },
  async (quote) => {
    // quote contains: totalCost, brokerAddress, tokenSymbol, network, chainType
    const txHash = await processPayment(quote);
    return { txHash, network: quote.network, sender: walletAddress, chainType: quote.chainType, paymentMethod: 'native' };
  },
  true // waitForConfirmation
);

const result = await client.queryBuilder()
  .collection('users')
  .whereField('active').isTrue()
  .limit(10)
  .execute();

const health = await client.health();
console.log('Status:', health.status);

const result = await client.store(
  { collection: 'users', data: [{ name: 'Alice', email: 'alice@example.com' }] },
  paymentCallback
);

const doc = await client.queryBuilder()
  .collection('users')
  .whereField('email').equals('alice@example.com')
  .executeUnique();

const result = await client.queryBuilder()
  .collection('users')
  .whereField('active').isTrue()
  .orderBy('createdAt', 'DESC')
  .limit(10)
  .offset(0)
  .execute();
const docs = result.records;

const doc = await client.queryBuilder()
  .collection('users')
  .whereField('email').equals('alice@example.com')
  .executeUnique();
if (doc) {
  await client.store(
    { collection: 'users', data: [{ ...doc, name: 'Alice Smith' }] },
    paymentCallback
  );
}

const doc = await client.queryBuilder()
  .collection('users')
  .whereField('email').equals('alice@example.com')
  .executeUnique();
if (doc) {
  await client.store(
    { collection: 'users', data: [{ ...doc, deleted: true, deletedAt: new Date().toISOString() }] },
    paymentCallback
  );
}

const count = await client.queryBuilder()
  .collection('users')
  .whereField('active').isTrue()
  .count();

const builder = client.queryBuilder();

const users = await builder
  .collection('users')
  .whereField('active').isTrue()
  .orderBy('createdAt', 'DESC')
  .limit(10)
  .execute();

const status = await client.getTaskStatus(ticketId);
console.log('Status:', status.status);

const task = await client.waitForTaskCompletion(
  ticketId,
  2000,    // Poll every 2 seconds
  600000   // Max wait 10 minutes
);

const result = await client.sql(
  'SELECT * FROM my_app::users WHERE email = "alice@example.com"',
  { includeHistory: false }
);

console.log(result.data);    // Array of records
console.log(result.count);   // Total count

await client.sqlInsert(
  'INSERT INTO my_app::users (email, name) VALUES ("alice@example.com", "Alice")'
);

await client.createQuery({
  name: 'active_users',
  source_collection: 'users',
  base_query: {
    find: { status: { is: 'active' } },
    select: { email: true, name: true }
  },
  parameters: [
    { name: 'limit', field_path: 'limit', default: 10 },
    { name: 'country', field_path: 'country', required: true, description: 'Filter by country' }
  ],
  description: 'Get active users by country'
});

const result = await client.executeQuery('active_users', { country: 'US' }, 1);
// result: { success, query_name, data, count, query_time_ms }

const queries = await client.listQueries();
const query = await client.getQuery('active_users');
await client.deleteQuery('active_users');

await client.createCollection({
  name: 'users',
  fields: {
    email: { type: 'string', index: true, unique: true },
    name: { type: 'string', index: true },
    age: { type: 'number', indexType: 'btree' },
    'address.city': { type: 'string', index: true }
  },
  useBaseFields: true // Auto-index id, createdAt, updatedAt, deletedAt
});

await client.syncCollection({
  name: 'orderbook_snapshots',
  fields: {
    market: { type: 'string', index: true },
    timestamp: { type: 'number', index: true },
    mid_price: { type: 'number' }
  },
  sharding: {
    keys: [
      { field: 'market', type: 'discrete' },
      { field: 'timestamp', type: 'time_range', granularity: 'hour' }
    ],
    enforce_in_queries: true,
    max_shard_size: 50_000_000
  }
});

await client.setupSharding('orderbook_snapshots', {
  keys: [
    { field: 'market', type: 'discrete' },
    { field: 'timestamp', type: 'time_range', granularity: 'hour' }
  ],
  enforce_in_queries: true
});

await client.updateCollection('users', {
  public: true,
  description: 'User profiles',
  default_sort_column: 'createdAt',
  collection_type: 'local' // 'local' | 'offline' | 'api' | 'hybrid'
});

const info = await client.getCollectionInfo('collection-id');
// info: { id, name, namespace, document_count, size_kb, created_at, ... }

await client.deleteCollection('users');

// Get retention config
const config = await client.getRetention('users');
// config: { collection, retention_days, monthly_cost_per_kb, status }

// Set retention (null = permanent)
await client.setRetention('logs', { retention_days: 30 });

// Get cost estimates for all collections
const costs = await client.getRetentionCost();
// costs: { collections: [...], total_monthly_cost }

client.on('transaction:queued', (ticket) => { ... });
client.on('transaction:pending', (tx) => { ... });
client.on('transaction:confirmed', (tx) => { ... });
client.on('transaction:failed', (tx) => { ... });
client.on('error', (error) => { ... });