Giter Site home page Giter Site logo

webdb's Introduction

WebDB

A database that reads and writes records on dat:// websites. How it works

Example

Instantiate:

// in the browser
const WebDB = require('@beaker/webdb')
var webdb = new WebDB('webdb-example')

// in nodejs
const DatArchive = require('node-dat-archive')
const WebDB = require('@beaker/webdb')
var webdb = new WebDB('./webdb-example', {DatArchive})

Define your table:

webdb.define('people', {
  // validate required attributes before indexing
  validate(record) {
    assert(record.firstName && typeof record.firstName === 'string')
    assert(record.lastName && typeof record.lastName === 'string')
    return true
  },

  // secondary indexes for fast queries (optional)
  index: ['lastName', 'lastName+firstName', 'age'],

  // files to index
  filePattern: [
    '/person.json',
    '/people/*.json'
  ]
})

Then open the DB:

await webdb.open()

Next we add archives to be indexed into the database.

await webdb.indexArchive('dat://alice.com')
await webdb.indexArchive(['dat://bob.com', 'dat://carla.com'])

Now we can begin querying the database for records.

// get any person record where lastName === 'Roberts'
var mrRoberts = await webdb.people.get('lastName', 'Roberts')

// response attributes:
console.log(mrRoberts.lastName)          // => 'Roberts'
console.log(mrRoberts)                   // => {lastName: 'Roberts', ...}
console.log(mrRoberts.getRecordURL())    // => 'dat://foo.com/bar.json'
console.log(mrRoberts.getRecordOrigin()) // => 'dat://foo.com'
console.log(mrRoberts.getIndexedAt())    // => 1511913554723

// get any person record named Bob Roberts
var mrRoberts = await webdb.people.get('lastName+firstName', ['Roberts', 'Bob'])

// get all person records with the 'Roberts' lastname
var robertsFamily = await webdb.people
  .where('lastName')
  .equalsIgnoreCase('roberts')
  .toArray()

// get all person records with the 'Roberts' lastname
// and a firstname that starts with 'B'
// - this uses a compound index
var robertsFamilyWithaBName = await webdb.people
  .where('lastName+firstName')
  .between(['Roberts', 'B'], ['Roberts', 'B\uffff'])
  .toArray()

// get all person records on a given origin
// - `:origin` is an auto-generated attribute
var personsOnBobsSite = await webdb.people
  .where(':origin')
  .equals('dat://bob.com')
  .toArray()

// get the 30 oldest people indexed
var oldestPeople = await webdb.people
  .orderBy('age')
  .reverse() // oldest first
  .limit(30)
  .toArray()

// count the # of young people
var oldestPeople = await webdb.people
  .where('age')
  .belowOrEqual(18)
  .count()

We can also use WebDB to create, modify, and delete records (and their matching files).

// set the record
await webdb.people.put('dat://bob.com/person.json', {
  firstName: 'Bob',
  lastName: 'Roberts',
  age: 31
})

// update the record if it exists
await webdb.people.update('dat://bob.com/person.json', {
  age: 32
})

// update or create the record
await webdb.people.upsert('dat://bob.com/person.json', {
  age: 32
})

// delete the record
await webdb.people.delete('dat://bob.com/person.json')

// update the spelling of all Roberts records
await webdb.people
  .where('lastName')
  .equals('Roberts')
  .update({lastName: 'Robertos'})

// increment the age of all people under 18
var oldestPeople = await webdb.people
  .where('age')
  .belowOrEqual(18)
  .update(record => {
    record.age = record.age + 1
  })

// delete the 30 oldest people
var oldestPeople = await webdb.people
  .orderBy('age')
  .reverse() // oldest first
  .limit(30)
  .delete()

Table of Contents

How to use WebDB

Table definitions

Use the define() method to define your tables, and then call webdb.open() to create them.

Indexing sites

Use indexArchive() and unindexArchive() to control which sites will be indexed. Indexed data will persist in the database until unindexArchive() is called. However, indexArchive() should always be called on load to get the latest data.

If you only want to index the current state of a site, and do not want to watch for updates, call indexArchive() with the {watch: false} option.

You can index and de-index individual files using indexFile() and unindexFile().

Creating queries

Queries are created with a chained function API. You can create a query from the table object using .query(), .where(), or .orderBy(). The where() method returns an object with multiple filter functions that you can use.

var myQuery = webdb.query().where('foo').equals('bar')
var myQuery = webdb.where('foo').equals('bar') // equivalent
var myQuery = webdb.where('foo').startsWith('ba')
var myQuery = webdb.where('foo').between('bar', 'baz', {includeLower: true, includeUpper: false})

Each query has a primary key. By default, this is the url attribute, but it can be changed using .where() or .orderBy(). In this example, the primary key becomes 'foo':

var myQuery = webdb.orderBy('foo')

At this time, the primary key must be one of the indexed attributes. There are 2 indexes created automatically for every record: url and origin. The other indexes are specified in your table's define() call using the index option.

Applying linear-scan filters

After the primary key index is applied, you can apply additional filters using filter(fn) and until(fn). These methods are called "linear scan" filters because they require each record to be loaded and then filtered out. (Until stops when it hits the first false response.)

var myQuery = webdb.query()
  .where('foo').equals('bar')
  .filter(record => record.beep == 'boop') // additional filter

Applying query modifiers

You can apply the following modifiers to your query to alter the output:

Executing 'read' queries

Once your query has been defined, you can execute and read the results using one of these methods:

Executing 'write' queries

Once your query has been defined, you can execute and modify the results using one of these methods:

If you try to modify rows in archives that are not writable, WebDB will throw an error.

Table helper methods

The following methods exist on the table object for query reads and writes:

Record methods

record.getRecordURL()    // => 'dat://foo.com/bar.json'
record.getRecordOrigin() // => 'dat://foo.com'
record.getIndexedAt()    // => 1511913554723

Every record is emitted in a wrapper object with the following methods:

  • getRecordURL() The URL of the record.
  • getRecordOrigin() The URL of the site the record was found on.
  • getIndexedAt() The timestamp of when the record was indexed.

These attributes can be used in indexes with the following IDs:

  • :url
  • :origin
  • :indexedAt

For instance:

webdb.define('things', {
  // ...
  index: [
    ':indexedAt', // ordered by time the record was indexed
    ':origin+createdAt' // ordered by origin and declared create timestamp (a record attribute)
  ],
  // ...
})
await webdb.open()
webdb.things.where(':indexedAt').above(Date.now() - ms('1 week'))
webdb.things.where(':origin+createdAt').between(['dat://bob.com', 0], ['dat://bob.com', Infinity])

Handling multiple schemas

Since the Web is a complex place, you'll frequently have to deal with multiple schemas which are slightly different. To deal with this, you can use a definition object to support multiple attribute names under one index.

webdb.define('places', {
  // ...

  index: [
    // a simple index definition:
    'name',

    // an object index definition:
    {name: 'zipCode', def: ['zipCode', 'zip_code']}
  ]

  // ...
})

Now, when you run queries on the 'zipCode' key, you will search against both 'zipCode' and 'zip_code'. Note, however, that the records emitted from the query will not be changed by WebDB and so they may differ.

For example:

webdb.places.where('zipCode').equals('78705').each(record => {
  console.log(record.zipCode) // may be '78705' or undefined
  console.log(record.zip_code) // may be '78705' or undefined
})

To solve this, you can preprocess records.

Preprocessing records

Sometimes, you need to modify records before they're stored in the database. This can be for a number of reasons:

  • Normalization. Small differences in accepted record schemas may need to be merged (see handling multiple schemas).
  • Indexing. WebDB's index spec only supports toplevel attributes. If the data is embedded in a sub-object, you'll need to place the data at the top-level.
  • Computed attributes.

For these cases, you can use the preprocess(record) function in the table definition:

webdb.define('places', {
  // ...

  preprocess(record) {
    // normalize zipCode and zip_code
    if (record.zip_code) {
      record.zipCode = record.zip_code
    }

    // move an attribute to the root object for indexing
    record.title = record.info.title

    // compute an attribute
    record.location = `${record.address} ${record.city}, ${record.state} ${record.zipCode}`

    return record
  }

  // ...
})

These attributes will be stored in the WebDB table.

Serializing records

When records are updated by WebDB, they are published to a Dat site as a file. Since these files are distributed on the Web, it's wise to avoid adding noise to the record.

To control the exact record that will be published, you can set the serialize(record) function in the table definition:

webdb.define('places', {
  // ...

  serialize(record) {
    // write the following object to the dat site:
    return {
      info: record.info,
      city: record.city,
      state: record.state,
      zipCode: record.zipCode
    }
  }

  // ...
})

Using JSON-Schema to validate

The default way to validate records is to provide a validator function. If the function throws an error or returns falsy, the record will not be indexed.

It can be tedious to write validation functions, so you might want to use JSON-Schema:

const Ajv = require('ajv')
webdb.define('people', {
  validate: (new Ajv()).compile({
    type: 'object',
    properties: {
      firstName: {
        type: 'string'
      },
      lastName: {
        type: 'string'
      },
      age: {
        description: 'Age in years',
        type: 'integer',
        minimum: 0
      }
    },
    required: ['firstName', 'lastName']
  }),

  // ...
})

Helper tables

Sometimes you need internal storage to help you maintain application state. This may be for interfaces, or data which is private, or for special kinds of indexes.

For instance, in the Fritter app, we needed an index for notifications. This index was conditional: it needed to contain posts which were replies to the user, or likes which were on the user's post. For cases like this, you can use a "helper table."

webdb.define('notifications', {
  helperTable: true,
  index: ['createdAt'],
  preprocess (record) {
    record.createdAt = Date.now()
  }
})

When the helperTable attribute is set to true in a table definition, the table will not be used to index Dat archives. Instead, it will exist purely in the local data cache, and only contain data which is .put() there. In all other respects, it behaves like a normal table.

In Fritter, the helper table is used with events to track notifications:

// track reply notifications
webdb.posts.on('put', async ({record, url, origin}) => {
  if (origin === userUrl) return // dont index the user's own posts
  if (isAReplyToUser(record) === false) return // only index replies to the user
  if (await isNotificationIndexed(url)) return // don't index if already indexed
  await db.notifications.put(url, {type: 'reply', url})
})
webdb.posts.on('del', async ({url}) => {
  if (await isNotificationIndexed(url)) {
    await db.notifications.delete(url)
  }
})

Class: WebDB

new WebDB([name, opts])

var webdb = new WebDB('mydb')
  • name String. Defaults to 'webdb'. If run in the browser, this will be the name of the IndexedDB instance. If run in NodeJS, this will be the path of the LevelDB folder.
  • opts Object.
    • DatArchive Constructor. The class constructor for dat archive instances. If in node, you should specify node-dat-archive.

Create a new WebDB instance. The given name will control where the indexes are saved. You can specify different names to run multiple WebDB instances at once.

WebDB.delete([name])

await WebDB.delete('mydb')
  • name String. Defaults to 'webdb'. If run in the browser, this will be the name of the IndexedDB instance. If run in NodeJS, this will be the path of the LevelDB folder.
  • Returns Promise<Void>.

Deletes the indexes and metadata for the given WebDB.

Instance: WebDB

webdb.open()

await webdb.open()
  • Returns Promise<Object>.
    • rebuilds Array<String>. The tables which were built or rebuilt during setup.

Runs final setup for the WebDB instance. This must be run after .define() to create the table instances.

webdb.close()

await webdb.close()
  • Returns Promise<Void>.

Closes the WebDB instance.

webdb.delete()

await webdb.delete()
  • Returns Promise<Void>.

Closes and destroys all indexes in the WebDB instance.

You can .delete() and then .open() a WebDB to recreate its indexes.

await webdb.delete()
await webdb.open()

webdb.define(name, definition)

  • name String. The name of the table.
  • definition Object.
    • index Array<String or Object>. A list of attributes which should have secondary indexes produced for querying. Each index value is a keypath (see https://www.w3.org/TR/IndexedDB/#dfn-key-path) or an object definition (see below).
    • filePattern String or Array<String>. An anymatch list of files to index.
    • helperTable Boolean. If true, the table will be used for storing internal data and will not be used to index Dat archives. See helper tables
    • validate Function. A method to accept or reject a file from indexing based on its content. If the method returns falsy or throws an error, the file will not be indexed.
      • record Object.
      • Returns Boolean.
    • preprocess Function. A method to modify the record after read from the dat site. See preprocessing records.
      • record Object.
      • Returns Object.
    • serialize Function. A method to modify the record before write to the dat site. See serializing records.
      • record Object.
      • Returns Object.
  • Returns Void.

Creates a new table on the webdb object. The table will be set at webdb.{name} and be the WebDBTable type. This method must be called before open()

Indexed attributes may either be defined as a keypath string or an object definition. The object definition has the following values:

  • name String. The name of the index.
  • def String or Array<String>. The definition of the index.

If the value of def is an array, it supports each definition. This is useful when supporting multiple schemas (learn more here).

In the index definition, you can specify compound indexes with a + separator in the keypath. You can also index each value of an array using the * sigil at the start of the name. Some example index definitions:

a simple index           - 'firstName'
as an object def         - {name: 'firstName', def: 'firstName'}
a compound index         - 'firstName+lastName'
index an array's values  - '*favoriteFruits'
many keys                - {name: 'firstName', def: ['firstName', 'first_name']}
many keys, compound      - {name: 'firstName+lastName', def: ['firstName+lastName', 'first_name+last_name']}

You can specify which files should be processed into the table using the filePattern option. If unspecified, it will default to all json files on the site ('*.json').

Example:

webdb.define('people', {
  validate(record) {
    assert(record.firstName && typeof record.firstName === 'string')
    assert(record.lastName && typeof record.lastName === 'string')
    return true
  },
  index: ['lastName', 'lastName+firstName', 'age'],
  filePattern: [
    '/person.json',
    '/people/*.json'
  ]
})

await webdb.open()
// the new table will now be defined at webdb.people

webdb.indexArchive(url[, opts])

await webdb.indexArchive('dat://foo.com')
  • url String or DatArchive or Array<String or DatArchive>. The sites to index.
  • opts Object.
    • watch Boolean. Should WebDB watch the archive for changes, and index them immediately? Defaults to true.
  • Returns Promise<Void>.

Add one or more dat:// sites to be indexed. The method will return when the site has been fully indexed. This will add the given archive to the "sources" list.

webdb.unindexArchive(url)

await webdb.unindexArchive('dat://foo.com')
  • url String or DatArchive. The site to deindex.
  • Returns Promise<Void>.

Remove a dat:// site from the dataset. The method will return when the site has been fully de-indexed. This will remove the given archive from the "sources" list.

webdb.indexFile(archive, filepath)

await webdb.indexFile(fooArchive, '/bar.json')
  • archive DatArchive. The site containing the file to index.
  • filepath String. The path of the file to index.
  • Returns Promise<Void>.

Add a single file to the index. The method will return when the file has been indexed.

This will not add the file or its archive to the "sources" list. Unlike indexArchive, WebDB will not watch the file after this call.

webdb.indexFile(url)

await webdb.indexFile('dat://foo.com/bar.json')
  • url String. The url of the file to index.
  • Returns Promise<Void>.

Add a single file to the index. The method will return when the file has been indexed.

This will not add the file or its archive to the "sources" list.

webdb.unindexFile(archive, filepath)

await webdb.unindexFile(fooArchive, '/bar.json')
  • archive DatArchive. The site containing the file to deindex.
  • filepath String. The path of the file to deindex.
  • Returns Promise<Void>.

Remove a single file from the dataset. The method will return when the file has been de-indexed.

webdb.unindexFile(url)

await webdb.unindexFile('dat://foo.com')
  • url String. The url of the file to deindex.
  • Returns Promise<Void>.

Remove a single file from the dataset. The method will return when the file has been de-indexed.

webdb.listSources()

var urls = await webdb.listSources()
  • Returns Array<String>.

Lists the URLs of the dat:// sites which are included in the dataset.

webdb.isSource(url)

var urls = await webdb.isSource('dat://foo.com')
  • Returns Boolean.

Is the given dat:// URL included in the dataset?

Event: 'open'

webdb.on('open', () => {
  console.log('WebDB is ready for use')
})

Emitted when the WebDB instance has been opened using open().

Event: 'open-failed'

webdb.on('open-failed', (err) => {
  console.log('WebDB failed to open', err)
})
  • error Error.

Emitted when the WebDB instance fails to open during open().

Event: 'indexes-reset'

webdb.on('indexes-reset', () => {
  console.log('WebDB detected a change in schemas and reset all indexes')
})

Emitted when the WebDB instance detects a change in the schemas and has to reindex the dataset. All indexes are cleared and will be reindexed as sources are added.

Event: 'indexes-updated'

webdb.on('indexes-updated', (url, version) => {
  console.log('Tables were updated for', url, 'at version', version)
})
  • url String. The archive that was updated.
  • version Number. The version which was updated to.

Emitted when the WebDB instance has updated the stored data for a archive.

Event: 'source-indexing'

webdb.on('source-indexing', (url, startVersion, targetVersion) => {
  console.log('Tables are updating for', url, 'from version', startVersion, 'to', targetVersion)
})
  • url String. The archive that was updated.
  • startVersion Number. The version which is being indexed from.
  • targetVersion Number. The version which is being indexed to.

Emitted when the WebDB instance has started to index the given archive.

Event: 'source-index-progress'

webdb.on('source-index-progress', (url, tick, total) => {
  console.log('Update for', url, 'is', Math.round(tick / total * 100), '% complete')
})
  • url String. The archive that was updated.
  • tick Number. The current update being applied.
  • total Number. The total number of updates being applied.

Emitted when an update has been applied during an indexing process.

Event: 'source-indexed'

webdb.on('source-indexed', (url, version) => {
  console.log('Tables were updated for', url, 'at version', version)
})
  • url String. The archive that was updated.
  • version Number. The version which was updated to.

Emitted when the WebDB instance has indexed the given archive. This is similar to 'indexes-updated', but it fires every time a source is indexed, whether or not it results in updates to the indexes.

Event: 'source-missing'

webdb.on('source-missing', (url) => {
  console.log('WebDB couldnt find', url, '- now searching')
})

Emitted when a source's data was not locally available or found on the network. When this occurs, WebDB will continue searching for the data, and emit 'source-found' on success.

Event: 'source-found'

webdb.on('source-found', (url) => {
  console.log('WebDB has found and indexed', url)
})

Emitted when a source's data was found after originally not being found during indexing. This event will only be emitted after 'source-missing' is emitted.

Event: 'source-error'

webdb.on('source-error', (url, err) => {
  console.log('WebDB failed to index', url, err)
})

Emitted when a source fails to load.

Instance: WebDBTable

table.count()

var numRecords = await webdb.mytable.count()
  • Returns Promise<Number>.

Count the number of records in the table.

table.delete(url)

await webdb.mytable.delete('dat://foo.com/bar.json')
  • Returns Promise<Number>. The number of deleted records (should be 0 or 1).

Delete the record at the given URL.

table.each(fn)

await webdb.mytable.each(record => {
  console.log(record)
})
  • fn Function.
    • record Object.
    • Returns Void.
  • Returns Promise<Void>.

Iterate over all records in the table with the given function.

table.filter(fn)

var records = await webdb.mytable.filter(record => {
  return (record.foo == 'bar')
})
  • fn Function.
    • record Object.
    • Returns Boolean.
  • Returns WebDBQuery.

Start a new query and apply the given filter function to the resultset.

table.get(url)

var record = await webdb.mytable.get('dat://foo.com/myrecord.json')
  • url String. The URL of the record to fetch.
  • Returns Promise<Object>.

Get the record at the given URL.

table.get(key, value)

var record = await webdb.mytable.get('foo', 'bar')
  • key String. The keyname to search against.
  • value Any. The value to match against.
  • Promise<Object>.

Get the record first record to match the given key/value query.

table.isRecordFile(url)

var isRecord = webdb.mytable.isRecordFile('dat://foo.com/myrecord.json')
  • url String.
  • Returns Boolean.

Tells you whether the given URL matches the table's file pattern.

table.limit(n)

var query = webdb.mytable.limit(10)
  • n Number.
  • Returns WebDBQuery.

Creates a new query with the given limit applied.

table.listRecordFiles(url)

var recordFiles = await webdb.mytable.listRecordFiles('dat://foo.com')
  • url String.
  • Returns Promise<Array<Object>>. On each object:
    • recordUrl String.
    • table WebDBTable.

Lists all files on the given URL which match the table's file pattern.

table.name

  • String.

The name of the table.

table.offset(n)

var query = webdb.mytable.offset(5)
  • n Number.
  • Returns WebDBQuery.

Creates a new query with the given offset applied.

table.orderBy(key)

var query = webdb.mytable.orderBy('foo')
  • key String.
  • Returns WebDBQuery.

Creates a new query ordered by the given key.

table.put(url, record)

await webdb.mytable.put('dat://foo.com/myrecord.json', {foo: 'bar'})
  • url String.
  • record Object.
  • Returns Promise<String>. The URL of the written record.

Replaces or creates the record at the given URL with the record.

table.query()

var query = webdb.mytable.query()
  • Returns WebDBQuery.

Creates a new query.

table.reverse()

var query = webdb.mytable.reverse()
  • Returns WebDBQuery.

Creates a new query with reverse-order applied.

table.schema

  • Object.

The schema definition for the table.

table.toArray()

var records = await webdb.mytable.toArray()
  • Returns Promise<Array<Object>>.

Returns an array of all records in the table.

table.update(url, updates)

var wasUpdated = await webdb.mytable.update('dat://foo.com/myrecord.json', {foo: 'bar'})
  • url String. The record to update.
  • updates Object. The new values to set on the record.
  • Returns Promise<Number>. The number of records updated.

Updates the target record with the given key values, if it exists.

table.update(url, fn)

var wasUpdated = await webdb.mytable.update('dat://foo.com/myrecord.json', record => {
  record.foo = 'bar'
  return record
})
  • url String. The record to update.
  • fn Function. A method to modify the record.
    • record Object. The record to modify.
    • Returns Object.
  • Returns Promise<Number>. The number of records updated.

Updates the target record with the given function, if it exists.

table.upsert(url, updates)

var didCreateNew = await webdb.mytable.upsert('dat://foo.com/myrecord.json', {foo: 'bar'})
  • url String. The record to update.
  • updates Object. The new values to set on the record.
  • Returns Promise<Number>. The number of records updated.

If a record exists at the target URL, will update it with the given key values. If a record does not exist, will create the record.

table.upsert(url, fn)

var didCreateNew = await webdb.mytable.upsert('dat://foo.com/myrecord.json', record => {
  if (record) {
    // update
    record.foo = 'bar'
    return record
  }
  // create
  return {foo: 'bar'}
})
  • url String. The record to update.
  • fn Function. A method to modify the record.
    • record Object. The record to modify. Will be falsy if the record does ot previously exist
    • Returns Object.
  • Returns Promise<Number>. The number of records updated.

Updates the target record with the given function, if it exists. If a record does not exist, will give a falsy value to the method.

table.where(key)

var whereClause = webdb.mytable.where('foo')
  • key String.
  • Returns WebDBWhereClause.

Creates a new where-clause using the given key.

Event: 'put-record'

webdb.mytable.on('put-record', ({url, origin, indexedAt, record}) => {
  console.log('Table was updated for', url, '(origin:', origin, ') at ', indexedAt)
  console.log('Record data:', record)
})
  • url String. The url of the record that was updated.
  • origin String. The url origin of the record that was updated.
  • indexedAt Number. The timestamp of the index update.
  • record Object. The content of the updated record.

Emitted when the table has updated the stored data for a record.

Event: 'del-record'

webdb.mytable.on('del-record', ({url, origin, indexedAt}) => {
  console.log('Table was updated for', url, '(origin:', origin, ') at ', indexedAt)
})
  • url String. The url of the record that was deleted.
  • origin String. The url origin of the record that was deleted.
  • indexedAt Number. The timestamp of the index update.

Emitted when the table has deleted the stored data for a record. This can happen because the record has been deleted, or because a new version of the record fails validation.

Instance: WebDBQuery

query.clone()

var query = webdb.mytable.query().clone()
  • Returns WebDBQuery.

Creates a copy of the query.

query.count()

var numRecords = await webdb.mytable.query().count()
  • Returns Promise<Number>. The number of found records.

Gives the count of records which match the query.

query.delete()

var numDeleted = await webdb.mytable.query().delete()
  • Returns Promise<Number>. The number of deleted records.

Deletes all records which match the query.

query.each(fn)

await webdb.mytable.query().each(record => {
  console.log(record)
})
  • fn Function.
    • record Object.
    • Returns Void.
  • Returns Promise<Void>.

Calls the given function with all records which match the query.

query.eachKey(fn)

await webdb.mytable.query().eachKey(url => {
  console.log('URL =', url)
})
  • fn Function.
    • key String.
    • Returns Void.
  • Returns Promise<Void>.

Calls the given function with the value of the query's primary key for each matching record.

The key is determined by the index being used. By default, this is the url attribute, but it can be changed by using where() or orderBy().

Example:

await webdb.mytable.orderBy('age').eachKey(age => {
  console.log('Age =', age)
})

query.eachUrl(fn)

await webdb.mytable.query().eachUrl(url => {
  console.log('URL =', url)
})
  • fn Function.
    • url String.
    • Returns Void.
  • Returns Promise<Void>.

Calls the given function with the URL of each matching record.

query.filter(fn)

var query = webdb.mytable.query().filter(record => {
  return record.foo == 'bar'
})
  • fn Function.
    • record Object.
    • Returns Boolean.
  • Returns WebDBQuery.

Applies an additional filter on the query.

query.first()

var record = await webdb.mytable.query().first()
  • Returns Promise<Object>.

Returns the first result in the query.

query.keys()

var keys = await webdb.mytable.query().keys()
  • Returns Promise<Array<String>>.

Returns the value of the primary key for each matching record.

The key is determined by the index being used. By default, this is the url attribute, but it can be changed by using where() or orderBy().

var ages = await webdb.mytable.orderBy('age').keys()

query.last()

var record = await webdb.mytable.query().last()
  • Returns Promise<Object>.

Returns the last result in the query.

query.limit(n)

var query = webdb.mytable.query().limit(10)
  • n Number.
  • Returns WebDBQuery.

Limits the number of matching record to the given number.

query.offset(n)

var query = webdb.mytable.query().offset(10)
  • n Number.
  • Returns WebDBQuery.

Skips the given number of matching records.

query.orderBy(key)

var query = webdb.mytable.query().orderBy('foo')
  • key String.
  • Returns WebDBQuery.

Sets the primary key and sets the resulting order to match its values.

query.put(record)

var numWritten = await webdb.mytable.query().put({foo: 'bar'})
  • record Object.
  • Returns Promise<Number>. The number of written records.

Replaces each matching record with the given value.

query.urls()

var urls = await webdb.mytable.query().urls()
  • Returns Promise<Array<String>>.

Returns the url of each matching record.

query.reverse()

var query = webdb.mytable.query().reverse()
  • Returns WebDBQuery.

Reverses the order of the results.

query.toArray()

var records = await webdb.mytable.query().toArray()
  • Returns Promise<Array<Object>>.

Returns the value of each matching record.

query.uniqueKeys()

var keys = await webdb.mytable.query().uniqueKeys()
  • Returns Promise<Array<String>>.

Returns the value of the primary key for each matching record, with duplicates filtered out.

The key is determined by the index being used. By default, this is the url attribute, but it can be changed by using where() or orderBy().

Example:

var ages = await webdb.mytable.orderBy('age').uniqueKeys()

query.until(fn)

var query = webdb.mytable.query().until(record => {
  return record.foo == 'bar'
})
  • fn Function.
    • record Object.
    • Returns Boolean.
  • Returns WebDBQuery.

Stops emitting matching records when the given function returns true.

query.update(updates)

var numUpdated = await webdb.mytable.query().update({foo: 'bar'})
  • updates Object. The new values to set on the record.
  • Returns Promise<Number>. The number of updated records.

Updates all matching record with the given values.

query.update(fn)

var numUpdated = await webdb.mytable.query().update(record => {
  record.foo = 'bar'
  return record
})
  • fn Function. A method to modify the record.
    • record Object. The record to modify.
    • Returns Object.
  • Returns Promise<Number>. The number of updated records.

Updates all matching record with the given function.

query.where(key)

var whereClause = webdb.mytable.query().where('foo')
  • key String. The attribute to query against.
  • Returns WebDBWhereClause.

Creates a new where clause.

Instance: WebDBWhereClause

where.above(value)

var query = webdb.mytable.query().where('foo').above('bar')
var query = webdb.mytable.query().where('age').above(18)
  • value Any. The lower bound of the query.
  • Returns WebDBQuery.

where.aboveOrEqual(value)

var query = webdb.mytable.query().where('foo').aboveOrEqual('bar')
var query = webdb.mytable.query().where('age').aboveOrEqual(18)
  • value Any. The lower bound of the query.
  • Returns WebDBQuery.

where.anyOf(values)

var query = webdb.mytable.query().where('foo').anyOf(['bar', 'baz'])
  • values Array<Any>.
  • Returns WebDBQuery.

Does not work on compound indexes.

where.anyOfIgnoreCase(values)

var query = webdb.mytable.query().where('foo').anyOfIgnoreCase(['bar', 'baz'])
  • values Array<Any>.
  • Returns WebDBQuery.

Does not work on compound indexes.

where.below(value)

var query = webdb.mytable.query().where('foo').below('bar')
var query = webdb.mytable.query().where('age').below(18)
  • value Any. The upper bound of the query.
  • Returns WebDBQuery.

where.belowOrEqual(value)

var query = webdb.mytable.query().where('foo').belowOrEqual('bar')
var query = webdb.mytable.query().where('age').belowOrEqual(18)
  • value Any. The upper bound of the query.
  • Returns WebDBQuery.

where.between(lowerValue, upperValue[, options])

var query = webdb.mytable.query().where('foo').between('bar', 'baz', {includeUpper: true, includeLower: true})
var query = webdb.mytable.query().where('age').between(18, 55, {includeLower: true})
  • lowerValue Any.
  • upperValue Any.
  • options Object.
    • includeUpper Boolean.
    • includeLower Boolean.
  • Returns WebDBQuery.

where.equals(value)

var query = webdb.mytable.query().where('foo').equals('bar')
  • value Any.
  • Returns WebDBQuery.

where.equalsIgnoreCase(value)

var query = webdb.mytable.query().where('foo').equalsIgnoreCase('bar')
  • value Any.
  • Returns WebDBQuery.

Does not work on compound indexes.

where.noneOf(values)

var query = webdb.mytable.query().where('foo').noneOf(['bar', 'baz'])
  • values Array<Any>.
  • Returns WebDBQuery.

Does not work on compound indexes.

where.notEqual(value)

var query = webdb.mytable.query().where('foo').notEqual('bar')
  • value Any.
  • Returns WebDBQuery.

Does not work on compound indexes.

where.startsWith(value)

var query = webdb.mytable.query().where('foo').startsWith('ba')
  • value Any.
  • Returns WebDBQuery.

Does not work on compound indexes.

where.startsWithAnyOf(values)

var query = webdb.mytable.query().where('foo').startsWithAnyOf(['ba', 'bu'])
  • values Array<Any>.
  • Returns WebDBQuery.

Does not work on compound indexes.

where.startsWithAnyOfIgnoreCase(values)

var query = webdb.mytable.query().where('foo').startsWithAnyOfIgnoreCase(['ba', 'bu'])
  • values Array<Any>.
  • Returns WebDBQuery.

Does not work on compound indexes.

where.startsWithIgnoreCase(value)

var query = webdb.mytable.query().where('foo').startsWithIgnoreCase('ba')
  • value Any.
  • Returns WebDBQuery.

Does not work on compound indexes.

How it works

WebDB abstracts over the DatArchive API to provide a simple database-like interface. It's inspired by Dexie.js and built using LevelDB. (In the browser, it runs on IndexedDB using level.js.

WebDB scans a set of source Dat archives for files that match a path pattern. Web DB caches and indexes those files so they can be queried easily and quickly. WebDB also provides a simple interface for adding, editing, and removing records from archives.

WebDB sits on top of Dat archives. It duplicates ingested data into IndexedDB, which acts as a throwaway cache. The cached data can be reconstructed at any time from the source Dat archives.

WebDB treats individual files in the Dat archive as individual records in a table. As a result, there's a direct mapping for each table to a folder of JSON files. For instance, if you had a posts table, it might map to the /posts/*.json files. WebDB's mutators, e.g., put, add, update, simply writes records as JSON files in the posts/ directory. WebDB's readers and query-ers, like get() and where(), read from the IndexedDB cache.

WebDB watches its source archives for changes to the JSON files that compose its records. When the files change, it syncs and reads the changes, then updates IndexedDB, keeping query results up-to-date. Roughly, the flow is: put() -> archive/posts/12345.json -> indexer -> indexeddb -> get().

Why not put all records in one file?

Storing records in one file—posts.json for example—is an intuitive way to manage data on the peer-to-peer Web, but putting each record in an individual file is a much better choice for performance and linkability.

Performance

The dat:// protocol doesn't support partial updates at the file-level, which means that with multiple records in a single file, every time a user adds a record, anyone who follows that user must sync and re-download the entire file. As the file continues to grow, performance will degrade. Putting each record in an individual file is much more efficient: when a record is created, peers in the network will only download the newly-created file.

Linkability

Putting each record in an individual file also makes each record linkable! This isn't as important as performance, but it's a nice feature to have. See Dog Legs McBoot's status update as an example:

dat://232ac2ce8ad4ed80bd1b6de4cbea7d7b0cad1441fa62312c57a6088394717e41/posts/0jbdviucy.json

Changelog

A quick overview of the notable changes to WebDB:

4.1.0

Added "helper tables," which make it possible to track private state and build more sophisticated indexes.

4.0.0

Replaced JSON-Schema validation with an open validate function. This was done to reduce the output bundle size (by 200kb!) and to improve overall flexibility (JSON-Schema and JSON-LD do not work together very well).

3.0.0

The addSource() and removeSource() methods were replaced with indexArchive(), indexFile(), unindexArchive(), and unindexFile(). The indexArchive() method also provides an option to disable watching.

This change was made as we found controlling the index was an important part of using WebDB. Frequently we'd want to index an archive temporarily, for instance to view a user's profile on first visit.

This new API gives better control for those use-cases, and no longer assumes you want to continue watching an archive after indexing it once.

webdb's People

Contributors

ansont avatar austinfrey avatar garbados avatar jakofranko avatar lachenmayer avatar pfrazee avatar piusnyakoojo avatar rh0 avatar taravancil avatar webdesserts avatar

Stargazers

avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar

Watchers

avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar

Forkers

puppycodes ansont composition4 millette songzcn jimpick doctorzhivago alexxnica kryndex cryptixcoder garbados kustomzone safrmo paul90 codeaudit gozala vijo fireindark707 thdtjsdn rh0 jakofranko lachenmayer keyzf astute-paradox piusnyakoojo ugommirikwe isabella232 unllamas forky-mcforkface yaserotb iq-scm

webdb's Issues

Question about the README examples: do they modify another's Dat?

In the CRUD examples on bobsUrl, is another person's dat being modified? I assume not, but it's not clear to me.

Take for example:

await db.profiles.update(bobsUrl, {name: 'robert'})

What is this doing? Is it updating a profile json file on a Dat from another source?

required is not defined

const WebDB = require('@beaker/webdb')
var webdb = new WebDB('webdb-example')

when i try to instansiate webdb inside an async function in order to use it like it is written in the example you published here, the debugger responds with: require is not defined. what i'm doing wrong here?

Do i have to import module.js ?
or how to import browserify?

Per-table reindexing

Currently a rebuild event (triggered by a table definition change) will cause all indexes to be rebuilt. We can update this to only rebuild the affected tables.

`all-indexes-updated` event

As I understood it, WebDB instances emit indexes-updated events to let others know that they have updated records in all indexes from a single archive. I would love to have the same for all archives it currently keeps track of.

Emit some information when validation fails

I've been playing around with this trying to learn it (very exciting!!!), and was really struggling to get any records to show up in my test DB. As I drilled into things, I realized that I had a copy/paste error in my code:

await db.define('people', {
      // validate required attributes before indexing
      validate(record) {
        assert(record.name && typeof record.name === 'string')
        assert(record.bio && typeof record.bio === 'string')
        return true
      },
    ...

assert is not defined and thus a Reference Error was getting thrown, but the try/catch block in indexer.js just sets isValid = false; and ditches the error, so I had no idea what the problem was. What are your thoughts of throwing the error if it catches one? It'll be a simple enough fix, so you may see a PR from me later 😬 .

Here's the snippet from indexer.js I'm talking about:

async function readAndIndexFile (db, archive, filepath, version=false) {
     ...
    // index on the first matching table
    for (var i = 0; i < tables.length; i++) {
      let table = tables[i]
      if (table.isRecordFile(filepath)) {
        // validate
        let isValid = true
        if (table.schema.validate) {
          try { isValid = table.schema.validate(record) }
          catch (e) { isValid = false } <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
        }

Best way to handle ids/file names.

I'm looking to add many records for a table, so people/*.json. Should I manually define the id, like:

import { v4 } from 'uuid';

await webdb.people.put(`dat://myaccount.hashbase.io/people/${v4()}.json`, {
  firstName: 'Bob',
  lastName: 'Roberts',
  age: 31
});

Or is there a better way to do that? Also, how do you automatically create the folder?

"Cannot .delete() databases" error.

When calling .delete() from the browser I recieve:

Error: Cannot .delete() databases outside of the browser environment. You should just delete the files manually.

I had a nagging feeling that I misconfigured something in my project (so level-browserify is pulling the wrong level), but after a bit of sleuthing, nothing obvious is standing out to me.

NotFoundError when an indexed file is removed

After WebDB has indexed a file, if that file is then removed (outside of webdb), a NotFoundError is thrown. The record for that file seems to remain in the database.

This may be a "works as designed" situation, as I may not be thinking of all use cases. However, it seems like it would be a good idea to handle this error and unindex the file, when that indexed file is removed from the archive. This would probably be a catch (maybe emitting a 'index-file-missing' event or something) on archive.download() in the following line:
archive.fileEvents.addEventListener('invalidated', ({path}) => archive.download(path))
https://github.com/beakerbrowser/webdb/blob/master/lib/indexer.js#L48

I'm happy to submit a PR, but thought I'd open an issue to be sure I'm not missing something.

live-updating DB queries

Hey!

What do you think about having live-updating DB queries, as a more user-friendly interface on top of the WebDBTable events put-record and del-record?

An example:

const query = webdb.people.where('lastName').equalsIgnoreCase('roberts')

query.on('put', console.log) // {url, origin, indexedAt, record}
query.on('del', console.log) // {url, origin, indexedAt}

Trailing "/" inconsistency for dat URLs

When indexing DBs, if you do:

async () => {
    await webdb.indexArchive('dat://232ac2ce8ad4ed80bd1b6de4cbea7d7b0cad1441fa62312c57a6088394717e41/');
console.log(await webdb.listSources());
}

You will see ["dat://232ac2ce8ad4ed80bd1b6de4cbea7d7b0cad1441fa62312c57a6088394717e41"] in your console (note, no trailing /).

If you do this:

...
console.log(webdb.isSource('dat://232ac2ce8ad4ed80bd1b6de4cbea7d7b0cad1441fa62312c57a6088394717e41/');
...

You will see false, because the / at the end is missing. It seems like isSource does an exact string match, when the thing that's important is the dat hash.

A little thing, but it was throwing me off for a bit :)

Any thoughts? It's simple enough, I might make another PR for this unless you have any objections...

Constructor signature mismatch

In the api docs the constructor has the signature new WebDB([name]). However, in the initial nodejs example it has what looks to be the signature new WebDB(path[, options]). I see a mention of the path, but I don't see anything about the options. Also is the path still optional in node?

Side Note: these types of environment dependent dynamic signatures are kind of a pain in the ass to work with in typed pre-processors like Typescript & Flow (edit: specifically if name is optional and path is required in this specific case).

Bundle size is a bit too big

A design tradeoff for WebDB that I didn't consider enough was bundle size.

  • In the most recent release, JSON-Schema was added for validation. Turns out my module choice (ajv) adds 200kb to the output bundle (unminified).
  • The level.js choice probably adds another 300-400kb.

It'd be relatively easily to remove JSON Schema and replace it with a validation function. That function could even be implemented downstream using JSON Schema! But it'd be up to the app dev. EDIT done.

Removing level.js would be significantly harder.

QueryError: Unable to put(): the given archive is not owned by this user

Sorry if this is a rather silly question, but I'm trying out the examples - I've got a /data directory and I've ran dat create and dat share in it. But I get "QueryError: Unable to put(): the given archive is not owned by this user" when I run:

const DatArchive = require("node-dat-archive");
const WebDB = require("@beaker/webdb");
const assert = require("assert");
var webdb = new WebDB("./data", { DatArchive });

webdb.define("people", {
  // validate required attributes before indexing
  validate(record) {
    assert(record.firstName && typeof record.firstName === "string");
    assert(record.lastName && typeof record.lastName === "string");
    return true;
  },

  // secondary indexes for fast queries (optional)
  index: ["lastName", "lastName+firstName", "age"],

  // files to index
  filePattern: ["/person.json", "/people/*.json"]
});

const doStuff = async () => {
  await webdb.open();
  await webdb.indexArchive('dat://<urlFromDatShare>')

  await webdb.people.upsert(
    "dat://<UrlFromDatShare>/bob.json",
    {
      firstName: "Bob",
      lastName: "Roberts",
      age: 32
    }
  );

  var mrRoberts = await webdb.people.get("lastName", "Roberts");
};

doStuff();

How do I specify that I own this dat? What silly thing am I doing wrong?

Enhancement: Add ability to pass in custom parser.

Curious to know if 'WebDB' would be open to a pull request allowing for the ability to pass in a custom file parser. Specifically, I'd like to use smarkt, but it looks like anything that implements a stringify method that can consume JSON and a parse method that spits out JSON, should work correctly. Happy to help if it's a useful idea, no worries if not :)

i.e.

var db = new WebDB('dat:// 494898...', { parser: require('smarkt') })

Recommend Projects

  • React photo React

    A declarative, efficient, and flexible JavaScript library for building user interfaces.

  • Vue.js photo Vue.js

    🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.

  • Typescript photo Typescript

    TypeScript is a superset of JavaScript that compiles to clean JavaScript output.

  • TensorFlow photo TensorFlow

    An Open Source Machine Learning Framework for Everyone

  • Django photo Django

    The Web framework for perfectionists with deadlines.

  • D3 photo D3

    Bring data to life with SVG, Canvas and HTML. 📊📈🎉

Recommend Topics

  • javascript

    JavaScript (JS) is a lightweight interpreted programming language with first-class functions.

  • web

    Some thing interesting about web. New door for the world.

  • server

    A server is a program made to process requests and deliver data to clients.

  • Machine learning

    Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.

  • Game

    Some thing interesting about game, make everyone happy.

Recommend Org

  • Facebook photo Facebook

    We are working to build community through open source technology. NB: members must have two-factor auth.

  • Microsoft photo Microsoft

    Open source projects and samples from Microsoft.

  • Google photo Google

    Google ❤️ Open Source for everyone.

  • D3 photo D3

    Data-Driven Documents codes.