<!-- Local file -->
<script src="https://cdn.jsdelivr.net/npm/ark-indexdb@latest/ark-indexdb.js"></script>

<!-- Or inline if bundling is not available -->
<script>
  // paste ark-indexdb.js content here
</script>

// If you add export statements to ark-indexdb.js:
import { ArkIndexdb } from './ark-indexdb.js';

// 1. Create the library instance
const ark = new ArkIndexdb();

// 2. Open (or create) the database — await until ready
await ark.open('MyAppDB', 1, {
  users: {
    keyPath: 'id',
    indexes: [
      { name: 'by_email', keyPath: 'email', unique: true  },
      { name: 'by_role',  keyPath: 'role',  unique: false },
    ]
  }
});

// 3. INSERT — UUID id is generated automatically
const key = await ark.insert('users', {
  name:  'Alice Chen',
  email: 'alice@example.com',
  role:  'admin',
});

// 4. READ
const user = await ark.findById('users', key);

// 5. UPDATE (partial merge)
await ark.update('users', key, { role: 'superadmin' });

// 6. DELETE
await ark.delete('users', key);

const schema = {
  // Store name → definition
  posts: {
    keyPath:       'id',      // primary key field (default: 'id')
    autoIncrement: false,    // set true for auto numeric keys
    indexes: [
      // { name, keyPath, unique }
      { name: 'by_author',   keyPath: 'authorId', unique: false },
      { name: 'by_category', keyPath: 'category', unique: false },
      { name: 'by_slug',     keyPath: 'slug',     unique: true  },
    ]
  },
  comments: {
    keyPath: 'id',
    indexes: [
      { name: 'by_post', keyPath: 'postId', unique: false },
    ]
  },
  settings: {
    keyPath: 'key',    // any field can be the key
  }
};

await ark.open('BlogDB', 1, schema);

const key = await ark.insert('users', {
  name:  'Bob',
  email: 'bob@example.com',
  role:  'user',
  tags:  ['beta', 'early-adopter'],
});
// returns the new record's primary key (UUID string)

const keys = await ark.insertMany('products', [
  { name: 'Widget A', price: 9.99,  category: 'widgets' },
  { name: 'Widget B', price: 14.99, category: 'widgets' },
  { name: 'Gadget X', price: 49.99, category: 'gadgets' },
]);
// returns string[] of inserted keys

const user = await ark.findById('users', 'abc-123');
// returns the record object, or null if not found

const { data, total } = await ark.findAll('users', {
  filter: { role: 'admin', age: { $gte: 18 } },
  sort:   'name',
  order:  'asc',
  limit:  10,
  offset: 0,
});
// data: matching records array   total: count before pagination

// Uses the native 'by_role' IDB index
const { data } = await ark.findByIndex('users', 'by_role', 'admin');

// Combine with additional in-memory filtering
const { data } = await ark.findByIndex(
  'users', 'by_role', 'admin',
  { filter: { status: 'active' }, sort: 'name' }
);

// Products priced between $10 and $50
const { data } = await ark.findByRange(
  'products', 'by_price',
  { lower: 10, upper: 50 }
);

// Open bounds (exclusive): price > 10
const { data } = await ark.findByRange(
  'products', 'by_price',
  { lower: 10, lowerOpen: true }
);

const result = await ark.paginate('users', 1, 10, {
  filter: { status: 'active' },
  sort: 'name', order: 'asc'
});

result.data        // current page records
result.total       // total matching records
result.totalPages  // total page count
result.hasNext     // boolean
result.hasPrev     // boolean

await ark.update('users', id, {
  name: 'Alice Smith',    // update these fields
  city: 'Berlin',
});
// all other fields (email, role, etc.) are untouched
// _updatedAt is set automatically

await ark.patch('users', id, {
  $set:    { city: 'Tokyo' },         // set field
  $inc:    { loginCount: 1 },          // increment by 1
  $dec:    { credits: 5 },             // decrement by 5
  $toggle: { isVerified: true },       // flip boolean
  $push:   { tags: 'vip' },            // append to array
  $pull:   { tags: 'beta' },           // remove from array
  $mul:    { score: 1.5 },             // multiply
  $unset:  ['temporaryField'],         // delete field
});

// Always works — creates if missing, replaces if key exists
await ark.upsert('settings', { id: 'theme', value: 'dark' });
await ark.upsert('settings', { id: 'theme', value: 'light' }); // overwrites

// Deactivate all users with role 'guest'
const updated = await ark.updateWhere(
  'users',
  { role: 'guest' },
  { status: 'inactive' }
);
// returns array of all updated records

// Delete by primary key
await ark.delete('users', id);

// Delete all matching a filter
const n = await ark.deleteWhere('sessions', {
  expiresAt: { $lt: new Date().toISOString() }
});
console.log(`Pruned ${n} expired sessions`);

// Clear ALL records (keeps store structure)
await ark.clear('logs');

// Chained query
const { data } = await ark
  .query('users')
  .where({ role: 'admin', status: { $ne: 'inactive' } })
  .sortBy('name', 'asc')
  .limit(10)
  .offset(0)
  .exec();

// Count without fetching records
const n = await ark.query('users')
  .where({ status: 'active' })
  .count();

// First matching record
const admin = await ark.query('users')
  .where({ email: 'alice@example.com' })
  .first();

// Paginate via builder
const { data } = await ark.query('posts')
  .where({ category: 'tech' })
  .sortBy('_createdAt', 'desc')
  .page(2, 20)   // page 2, 20 per page
  .exec();

await ark.transaction(
  ['users', 'orders'],  // stores involved
  'readwrite',
  async (stores) => {
    // Both operations succeed or both roll back
    const userId = crypto.randomUUID();
    await stores.users.add({
      id: userId,
      name: 'Dave',
      _createdAt: new Date().toISOString()
    });
    await stores.orders.add({
      id: crypto.randomUUID(),
      userId,
      total: 149.99,
    });
  }
);

// Subscribe to insert events
const off = ark.on('insert', ({ storeName, key, data }) => {
  console.log(`Inserted into ${storeName}: key=${key}`);
});

// Wildcard — catches everything
ark.on('*', e => console.log('[Ark]', e.event, e));

// Unsubscribe
off();

// All available events:
// 'open'  'upgrade'  'insert'  'insertMany'  'update'
// 'updateMany'  'upsert'  'delete'  'deleteMany'
// 'clear'  'import'  'transaction'  'error'  'versionchange'

// Export one store as JSON string
const json = await ark.exportStore('users');

// Export ALL stores
const fullBackup = await ark.exportAll();

// Trigger browser file download
await ark.downloadStore('users');
// → browser saves "users_1700000000.json"

// Import from JSON string (e.g., after fetch or file read)
const json = await fetch('/backup/users.json').then(r => r.text());
const n = await ark.importStore('users', json);
console.log(`Imported ${n} records`);