Operateable

const transactable = new Transactable('baleada')

transactable.open({
  version: 1,
  upgradeEffect: db => {
    db.createObjectStore('ingredients', { keyPath: 'id' })
  },
})

// Asynchronously, transactable status will change to 'opened'.
// Later in the application's lifecycle, you can run database
// transactions, like this transaction in `readwrite` mode:
transactable.readwrite(
  // Pass a callback to perform side effects when the
  // transaction is open:
  transaction => {
    // Inside of transaction effect callbacks, construct an
    // Operateable instance around an object store:
    const operateable = new Operateable(transaction.objectStore('ingredients'))

    // Easily run sequences of database operations without
    // closing the transaction:
    operateable.operate([
      { operation: 'add', value: { id: 1, name: 'Tortilla' } },
      { operation: 'add', value: { id: 2, name: 'Beans' } },
      {
        operation: 'getAll',
        effect: ingredients => {
          console.log(ingredients)
        },
      },
    ])
    
    // Or, synchronously request individual operations, which
    // the browser will run independently and asynchronously:
    operateable.add({ value: { id: 3, name: 'Egg' } })
    operateable.openCursor({ effect: cursor => {
      // Handle database cursor
    }})
  },
  { storeNames: ['ingredients'] }
)

import { Operateable, createDefineObjectStore } from '@baleada/logic'

// Define a TypeScript type for your database, where the keys
// are store names and the indexed types are object schemas:
type MyDatabase = {
  ingredients: { id?: number, name: string },
  ...
}

// Create your type inference helper:
const defineObjectStore = createDefineObjectStore<MyDatabase>()

// Use your type inference helper when retrieving the object
// store that you'll pass to `Operateable`:
transactable.readwrite(
  transaction => {
    // `ingredientsObjectStore` is now strongly typed.
    // TypeScipt knows the exact shape of stored objects.
    const ingredientsObjectStore = defineObjectStore(transaction, 'ingredients')
    
    // Pass the store to `Operateable`, which will infer its type:
    const operateable = new Operateable(ingredientsObjectStore)
    
    // Now, all of Operateable's methods are type-safe:
    operateable
      .operate([
        {
          operation: 'add',
          value: {
            id: 1,
            // Type error: `title` does not exist on this type
            // (should be `name` instead)
            title: 'Tortilla'
          }
        },
      ])
      .openCursor({
        effect: cursor => {
          // Type error: `title` does not exist on this type
          // (should be `name` instead)
          console.log(cursor.value.title)
          
          // `cursor.value.name` is strongly typed as `string`
          console.log(cursor.value.name)
        }
      })
  },
  { storeNames: ['ingredients'] }
)