Dexie.js table.name isn't working even though the table is under the tables property

Question

I'm wanting to fetch all items from a table into a collection but am getting an error that the table name is undefined. Here is my store:

db.version(1).stores({
  users: '++id,',
  orgs: '++id,',
  applications: '++id'
})

Then later here is my call:

db.orgs.toCollection().count(function (count) {
   console.log(count)
})

It gives the following error:

TypeError: Cannot read property 'toCollection' of undefined

But when I stop the debugger at the call and type in db.tables sure enough:

1:Table {name: "orgs", schema: TableSchema, _tx: undefined, …}
_tx:undefined
hook:function rv(eventName, subscriber) { … }
name:"orgs"

Any help is appreciated - thanks.

UPDATE

I noticed that when I seeded the database on initial creation I could fetch the data out. So I copied in that code into my template. It still fails however, so there must be something simple I'm missing, here is that code:

import Dexie from '@/dexie.es.js'

export default {
  name: 'ListOrgs',
  data: () => {
    return {
      orgs: []
    }
  },
  methods: {
    populateOrgs: async function () {
      let db = await new Dexie('myDatabase').open()
      db.orgs.toCollection().count(function (count) {
        console.log(count)
      })
    }
  },
  mounted () {
    this.populateOrgs()
  }
}

Answer 1

Dexie has two modes

• Static - the most common one used in most samples.
• Dynamic - Schema is not specified in code.

Static Mode

//
// Static Mode
//
const db = new Dexie('myDatabase');
db.version(1).stores({myTable1: '++'});
db.version(2).stores({myTable1: '++, foo'});
db.myTable1.add({foo: 'bar'}); // OK - dexie knows about myTable1!

Dynamic Mode

//
// Dynamic Mode
//
const db = new Dexie('myDatabase');
// FAIL: db.myTable1.add({foo: 'bar'}); // myTable1 is unknown to the API.
// Here, you must wait for db to open, and then access tables using db.table() method:
db.open().then(db => {
  const myTable = db.table('myTable');
  if (myTable) {
    myTable.add({foo: 'bar'});
  }
}).catch(error => {
  console.error(error);
});

If omitting any version() specification, Dexie will just try to open any existing database with the same name, no matter version or schema. But it won't create the implicit table properties onto the db instance.

When Dynamic Mode is Useful

Dynamic mode can be useful when building an arbritary database utility that should adapt to any indexedDB database - such as a DB explorer. Dynamic mode can also be useful when the javascript code is by design not aware of the schema (what tables are expected to be queried and what indexes there are).

Benefits with Static Mode

• No need to wait for db.open() to complete.
• Automatic DB creation when neeeded. No complex app code to deal with database versioning.
• Automatic DB population when needed.

Design Patterns in Static Mode

db.js

import Dexie from 'dexie';

//
// Let this module do several things:
//
//  * Create the singleton Dexie instance for your application.
//  * Declare it's schema (and version history / migrations)
//  * (Populate default data http://dexie.org/docs/Dexie/Dexie.on.populate)
// 

export const db = new Dexie('myDatabase');

db.version(1).stores({
  users: '++id,',
  orgs: '++id,',
  applications: '++id'
});

db.on('populate', () => {
  return db.orgs.bulkAdd([
    {'foo': 'bar'},
  ]);
});

app.js

import {db} from './db';

// Wherever you use the database, include your own db module
// instead of creating a new Dexie(). This way your code will
// always make sure to create or upgrade your database whichever
// of your modules that comes first in accessing the database.
//
// You will not have to take care of creation or upgrading scenarios.
//
// Let Dexie do that for you instead.
// 

async function countOrgs() {
  return await db.orgs.count();
}