Skip to main content


IndexedDB is a pure transactional database which means all the query is executed using the transaction.

JsStore provides - transaction api for executing transaction.

await connection.transaction({
tables: ['Customers'], // list of tables which will be used inside a transaction
method: "buyProducts" // name of method which implements transaction
data: any // pass any data , that will be used in runing transaction

How to implement a transaction

JsStore takes a method name in transaction api, which is called with a context.

The context is an object which contains following props -

  • start - start the transaction.

  • select

  • count

  • update

  • remove

  • insert

  • setResult - setResult accepts key and value. setResult is used to save the value which will be returned when transaction completes. The transaction returns an object, the object is in form of key and value which is set using setResult.

  • abort - abort is used to abort the transaction.

  • getResult - getResult is used to get the value setted by setResult.

  • data - value passed in transaction api as data.

The transaction method should be -

  • Accessible - so that it can be called.
  • Should not have any asychronous logic except calling context apis

Accessiblity in web worker

When using jsstore with a web worker - you can use importScripts to import your scripts which contains your transaction methods.

await importSripts("transaction.js");

after script is imported your method is now available inside the jsstore web worker.

Accessiblity without web worker

you can create a method anywhere and make it available on window.

function buyProducts(){


// if method not available on window, otherwise no need
window.buyProducts = buyProducts;

Let's see a example - Consider a situation where a customer buy some products and customer is new.

So the steps will be -

  1. Add new customer - insert in the table - "Customer"
  2. add new order - insert new order for the above customer
  3. Insert OrderDetails
  4. Update products - reduce the quantity of product available.
  5. Calculate total price
FileName -  transaction.js

async function buyProducts(ctx) {

ctx.start(); // start the transaction

const insertedCustomers = await ctx.insert({
into: 'customers',
values: [],
return: true

const newCustomer = insertedCustomers[0];

// insert order

const order = {
orderDate: new Date(),

const insertedOrders = await ctx.insert({
into: 'orders',
values: [order],
return: true

const newOrder = insertedOrders[0];

// insert orderDetail

const orderDetails = => {
value.orderId = newOrder.orderId
return value;

const insertedOrderDetails = await ctx.insert({
into: 'orderDetails',
values: orderDetails,

// update the product inventory and evaluate price

ctx.setResult('totalPrice', 0); //initiating totalPrice, index) => {
const where = {
productId: orderDetail.productId

const updateProduct = async () => {
const productUpdated = await ctx.update({
in: 'products',
where: where,
set: {
unit: {
'-': orderDetail.quantity
if (productUpdated < 0) {
ctx.abort("No orderDetails inserted");


const products = await{
from: 'products',
where: where

const product = results[0];
const price = product.price * orderDetail.quantity
ctx.setResult('totalPrice', ctx.getResult('totalPrice') + price);


If using web worker

// import scripts first, so that transaction methods becomes available

await connection.importScripts("./transaction.js");

Without web worker

window.buyProducts = buyProducts;
Now method is accessible and can be executed, let's call the transaction api -
var result = await connection.transaction({
tables: ['customers', 'orders', 'products', 'orderDetails'], // list of tables which will be used in transaction
method: "buyProducts"
data: { // the transaction logic will be called with supplying data
customer: {
customerName: 'ujjwal gupta',
address: 'bhubaneswar odisha',
city: 'bhubaneswar',
postalCode: 'asdf',
country: 'india',
email: ''
orderDetails: [{
productId: 1,
quantity: 2
}, {
productId: 2,
quantity: 4
const totalPrice = result.totalPrice;

Important points

Few important things to make sure you are using transaction in right way -

  • Transaction should be light weight. Dont write too many or heavy logics inside it. The reason is - the indexeddb transaction is asyc and automatically commited and so jsstore.

  • There may be situation where you have a heavy logic, in that case - calculate the result and put it in data option.