StorageAdapter

import type { StorageAdapter } from '@gluonic/client'

export interface StorageAdapter {
  // Required: Row operations
  getRow(t: string, id: string): Promise<WireRow | null>
  putRow(row: WireRow): Promise<void>
  deleteRow(t: string, id: string): Promise<void>
 
  // Optional: Bulk operations
  getRows?(t: string, ids: string[]): Promise<WireRow[]>
  putRows?(rows: WireRow[]): Promise<void>
  deleteRows?(items: Array<{ t: string, id: string }>): Promise<void>
  withTransaction?<T>(fn: () => Promise<T>): Promise<T>
 
  // Optional: Fast hydration
  listByType?(t: string): Promise<WireRow[]>
  listByIndex?(t: string, indexKey: string, indexVal: string): Promise<WireRow[]>
  
  // Required: Sync state
  getLastSyncId(): Promise<number>
  setLastSyncId(n: number): Promise<void>
  
  // Optional: Clear all
  clearAll?(): Promise<void>
  
  // Required: Transaction queue
  enqueueTx(op: { id: string, t: string, mid: string, patch: any, prev: any, op?: 'i' | 'u' | 'd' }): Promise<void>
  dequeueTx(id: string): Promise<void>
  listTx(): Promise<Array<{ id: string, t: string, mid: string, patch: any, prev: any, op?: 'i' | 'u' | 'd' }>>
}

getRow(t: string, id: string): Promise<WireRow | null>

const row = await storage.getRow('task', 'abc-123')
if (row) {
  console.log(row.p.title)
}

putRow(row: WireRow): Promise<void>

await storage.putRow({
  t: 'task',
  id: 'abc-123',
  v: 1,
  p: { title: 'My Task', done: false }
})

deleteRow(t: string, id: string): Promise<void>

await storage.deleteRow('task', 'abc-123')

getLastSyncId(): Promise<number>

const lastSyncId = await storage.getLastSyncId()
console.log(`Last synced at: ${lastSyncId}`)

setLastSyncId(n: number): Promise<void>

await storage.setLastSyncId(42)

enqueueTx(op: {
  id: string
  t: string
  mid: string
  patch: any
  prev: any
  op?: 'i' | 'u' | 'd'
}): Promise<void>

await storage.enqueueTx({
  id: 'tx-123',
  t: 'task',
  mid: 'abc-123',
  patch: { title: 'Updated' },
  prev: { title: 'Original' },
  op: 'u'
})

dequeueTx(id: string): Promise<void>

await storage.dequeueTx('tx-123')

listTx(): Promise<Array<{
  id: string
  t: string
  mid: string
  patch: any
  prev: any
  op?: 'i' | 'u' | 'd'
}>>

const pending = await storage.listTx()
console.log(`${pending.length} transactions pending`)

getRows?(t: string, ids: string[]): Promise<WireRow[]>

const rows = await storage.getRows('task', ['id-1', 'id-2', 'id-3'])

putRows?(rows: WireRow[]): Promise<void>

await storage.putRows([
  { t: 'task', id: '1', p: { title: 'A' } },
  { t: 'task', id: '2', p: { title: 'B' } }
])

deleteRows?(items: Array<{ t: string, id: string }>): Promise<void>

await storage.deleteRows([
  { t: 'task', id: '1' },
  { t: 'task', id: '2' }
])

withTransaction?<T>(fn: () => Promise<T>): Promise<T>

await storage.withTransaction(async () => {
  await storage.putRow(row1)
  await storage.putRow(row2)
  // Both succeed or both fail
})

listByType?(t: string): Promise<WireRow[]>

const allTasks = await storage.listByType('task')

listByIndex?(
  t: string,
  indexKey: string,
  indexVal: string
): Promise<WireRow[]>

// Get all tasks by author
const tasks = await storage.listByIndex('task', 'authorId', 'user-123')

clearAll?(): Promise<void>

// Clear on logout
await storage.clearAll()

import type { StorageAdapter, WireRow } from '@gluonic/client'
 
export class MyAdapter implements StorageAdapter {
  // Required
  async getRow(t: string, id: string): Promise<WireRow | null> {
    // Implementation
  }
  
  async putRow(row: WireRow): Promise<void> {
    // Implementation
  }
  
  async deleteRow(t: string, id: string): Promise<void> {
    // Implementation
  }
  
  async getLastSyncId(): Promise<number> {
    // Implementation
  }
  
  async setLastSyncId(n: number): Promise<void> {
    // Implementation
  }
  
  async enqueueTx(op: any): Promise<void> {
    // Implementation
  }
  
  async dequeueTx(id: string): Promise<void> {
    // Implementation
  }
  
  async listTx(): Promise<any[]> {
    // Implementation
  }
  
  // Optional (recommended)
  async listByType(t: string): Promise<WireRow[]> {
    // Fast type hydration
  }
  
  async listByIndex(t: string, key: string, val: string): Promise<WireRow[]> {
    // Fast collection loading
  }
}