jdb(name, version)

Returns a builder with .open(config), plus .isClientMode() and .requiresLogin() for opting into those modes before opening.

jdb('myapp', 1)
    .open({ storage: 'indexeddb' })
    .onCreate(function (e, next) {
        e.result.createTbl('users', [{ id: { type: 'NUMBER', AUTO_INCREMENT: 1 }, name: { type: 'VARCHAR' } }]);
        next();
    })
    .onUpgrade(function (e, next) {
        next();
    })
    .onSuccess(function (e) {
        var db = e.result; // DatabaseInstance
    })
    .onError(function (e) {
        console.error(e.message);
    });

onCreate fires the first time a database is opened; onUpgrade fires when an existing database is opened with a higher version. Both receive next() to call once setup is done. onSuccess/onError (or .then(success, error)) resolve with { result, message, type }, where result is the DatabaseInstance you'll use for everything else.

Config options

isClientMode()

Marks the connection as client-facing (production) before .open(), disabling debugging affordances.

jdb('myapp', 1).isClientMode().open({ storage: 'indexeddb' });

requiresLogin()

Opens in a restricted login mode: the resolved instance only exposes api(), close() and jQl() until the app authenticates and re-opens normally.

jdb('myapp', 1).requiresLogin().open({ serviceHost: 'https://api.example.com' });

jDB promises

.open() returns a jDB Promise: .onSuccess(fn), .onError(fn), .then(success, error), .catch(fn) and .finally(fn), plus the .onCreate/.onUpgrade event hooks shown above. Most instance methods (transaction, jQl, batchTransaction, storeProc().execute) return standard native Promises instead — check the signature on each method below.

db.createTbl(name, columns, additionalConfig, ignoreInstance)

db.createTbl('users', [{
    id: { type: 'NUMBER', AUTO_INCREMENT: 1 },
    email: { type: 'VARCHAR' }
}]);

db.table(name)

Looks up an existing table. See Table instance below.

db.transaction(table, mode)

Read-mode transactions expose select/qsl; write-mode transactions expose insert/insertReplace/update/delete. See Transaction instance below.

db.transaction('users', 'writeonly')
    .insert({ name: 'Ada' })
    .execute()
    .then(res => console.log(res));

db.jQl(query, params)

Runs a query in jDB's own query language. Full syntax, every command, and the field-type system live on the jQL reference page.

db.batchTransaction(transactions, rollBackOnError)

db.batchTransaction([
    { type: 'insert', table: 'users', data: { name: 'Ada' } },
    { type: 'update', table: 'users', query: { id: 1 }, data: { role: 'admin' } }
], true);

db.export(table, type, title)

db.export('users', 'json').initialize();

db.import(table, isSchema, handler)

db.import('users', false).selectFile()
    .then(res => console.log(res.result.message));

db.sync(config)

db.syncAll(stopOnFailedTransaction)

Pushes every table's pending (unsynced) changes to the configured serviceHost in one request. Resolves immediately with { message: 'Nothing to Sync' } if there's nothing pending.

db.schema

db.env

db.clientService

db.storeProc()

const proc = db.storeProc();
proc.create('activeAdmins', 'select -* -users -where(role~admin)');
proc.execute('activeAdmins').then(res => console.log(res.getResult()));

Other instance methods

db.table(name)

db.table(name).alter

db.table('users').alter.add.column('fullName', { type: 'VARCHAR', defaultValue: 'Foo Bar' });
db.table('users').alter.drop('fullName');

.insert(data, hardInsert, tableName)

Write-mode only. data is an object or array of objects. hardInsert bypasses soft-insert de-duplication.

.insertReplace(records, updateRef)

Upserts by updateRef (defaults to the table's primary key).

.update(updateRecords)

updateRecords is an array of [condition, data] pairs — one update per pair.

.delete(query, tableName)

query is a condition object; omit it to delete every row.

.select(fields, definition)

Read-mode only. definition is { where, join, limit, orderBy, groupBy, ... } — the same shape jQl's select command builds internally from its clause syntax.

.qsl()

Quick Search Language: returns dynamically generated findBy<Column>(value, fields) finders for every column on a single-table transaction, or findByColumn(columnName, value, fields) for a multi-table one.

db.transaction('users').qsl().findByEmail('ada@example.com');

.execute(disablePushToServer, fromBatch, rollbackOnError)

Runs every queued operation on the transaction (insert/update/delete/select calls can be chained before calling .execute() once). Also available: .dataProcessing(boolean) to toggle validation/default-value generation before inserting.