const Ingest = require('ingestdb')
var db = new Ingest('social-profiles')

const DatArchive = require('node-dat-archive')
const Ingest = require('ingestdb')
var db = new Ingest('social-profiles', {DatArchive})

db.schema({
  version: 1,
  broadcasts: {
    primaryKey: 'createdAt',
    index: [
      'createdAt',
      '_origin+createdAt' // compound index. '_origin' is an autogenerated attribute which represents the URL of the authoring archive
    ],
    validator: record => {
      assert(typeof record.text === 'string')
      assert(typeof record.createdAt === 'number')
      return record
    }
  },
  likes: {
    primaryKey: 'createdAt',
    index: 'targetUrl',
    validator: record => {
      assert(typeof record.targetUrl === 'string')
      return record
    }
  },
  profile: {
    singular: true,
    index: 'name',
    validator: record => {
      assert(typeof record.name === 'string')
      return {
        name: record.name,
        description: isString(record.description) ? record.description : '',
        avatarUrl: isString(record.avatarUrl) ? record.avatarUrl : ''
      }
    }
  }
})

await db.open()

await db.addArchives([alicesUrl, bobsUrl, carlasDatArchive])

// get the first profile record where name === 'bob'
var bobProfile = await db.profiles.get('name', 'bob')

// get all profile records which match this query
var bobProfiles = await db.profiles
  .where('name')
  .equalsIgnoreCase('bob')
  .toArray()

// get the 30 latest broadcasts from all source archives
var recentBroadcasts = await db.broadcasts
  .orderBy('createdAt')
  .reverse() // most recent first
  .limit(30)
  .toArray()

// get the 30 latest broadcasts by a specific archive (bob)
// - this uses a compound index to filter by origin, and then sort by createdAt
var bobsRecentBroadcasts = await db.broadcasts
  .where('_origin+createdAt')
  .between([bobsUrl, ''], [bobsUrl, '\uffff'])
  .reverse() // most recent first
  .limit(30)
  .toArray()

// get the # of likes for a broadcast
var numLikes = await db.likes
  .where('targetUrl').equals(bobsRecentBroadcasts[0]._url) // _url is an autogenerated attribute which represents the URL of the record
  .count()

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

// publish a new broadcast for bob
var broadcastUrl = await db.broadcasts.add(bobsUrl, {
  text: 'Hello!',
  createdAt: Date.now()
})

// modify the broadcast
await db.broadcasts.update(broadcastUrl, {text: 'Hello world!'})

// like the broadcast
await db.likes.add(bobsUrl, {
  targetUrl: broadcastUrl,
  createdAt: Date.now()
})

// delete the broadcast
await db.broadcasts.delete(broadcastUrl)

// delete all likes on the broadcast (that we control)
await db.likes
  .where({targetUrl: broadcastUrl})
  .delete()

var db = new IngestDB(name)
IngestDB.list() => Promise<Void>
IngestDB.delete(name) => Promise<Void>
db.open() => Promise<Void>
db.close() => Promise<Void>
db.schema(Object) => Promise<Void>
db.addArchive(url|DatArchive, {prepare: Boolean}) => Promise<Void>
db.addArchives(Array<url|DatArchive>, {prepare: Boolean}) => Promise<Void>
db.removeArchive(url|DatArchive) => Promise<Void>
db.prepareArchive(url|DatArchive)
db.listArchives() => Promise<url>
db 'open' ()
db 'open-failed' (error)
db 'versionchange' ()
db 'indexes-updated' (archive, archiveVersion)

db.{table} => IngestTable
IngestTable#add(archive, record) => Promise<url>
IngestTable#count() => Promise<Number>
IngestTable#delete(url) => Promise<url>
IngestTable#each(Function) => Promise<Void>
IngestTable#filter(Function) => IngestQuery
IngestTable#get(url) => Promise<Object>
IngestTable#get(archive) => Promise<Object>
IngestTable#get(archive, key) => Promise<Object>
IngestTable#get(index, value) => Promise<Object>
IngestTable#isRecordFile(String) => Boolean
IngestTable#limit(Number) => IngestQuery
IngestTable#listRecordFiles(Archive) => Promise<Object>
IngestTable#name => String
IngestTable#offset(Number) => IngestQuery
IngestTable#orderBy(index) => IngestQuery
IngestTable#put(url, record) => Promise<url>
IngestTable#query() => IngestQuery
IngestTable#reverse() => IngestQuery
IngestTable#schema => Object
IngestTable#toArray() => Promise<Array>
IngestTable#toCollection() => IngestQuery
IngestTable#update(record) => Promise<Number>
IngestTable#update(url, updates|function) => Promise<Number>
IngestTable#update(archive, updates|function) => Promise<Number>
IngestTable#update(archive, key, updates|function) => Promise<Number>
IngestTable#upsert(url|archive, record|function) => Promise<Void | url>
IngestTable#where(index) => IngestWhereClause
IngestTable 'index-updated' (archive, archiveVersion)

IngestWhereClause#above(lowerBound) => IngestQuery
IngestWhereClause#aboveOrEqual(lowerBound) => IngestQuery
IngestWhereClause#anyOf(Array|...args) => IngestQuery
IngestWhereClause#anyOfIgnoreCase(Array|...args) => IngestQuery
IngestWhereClause#below(upperBound) => IngestQuery
IngestWhereClause#belowOrEqual(upperBound) => IngestQuery
IngestWhereClause#between(lowerBound, upperBound, {includeUpper, includeLower}) => IngestQuery
IngestWhereClause#equals(value) => IngestQuery
IngestWhereClause#equalsIgnoreCase(value) => IngestQuery
IngestWhereClause#noneOf(Array|...args) => IngestQuery
IngestWhereClause#notEqual(value) => IngestQuery
IngestWhereClause#startsWith(value) => IngestQuery
IngestWhereClause#startsWithAnyOf(Array|...args) => IngestQuery
IngestWhereClause#startsWithAnyOfIgnoreCase(Array|...args) => IngestQuery
IngestWhereClause#startsWithIgnoreCase(value) => IngestQuery

IngestQuery#clone() => IngestQuery
IngestQuery#count() => Promise<Number>
IngestQuery#delete() => Promise<Number>
IngestQuery#each(Function) => Promise<Void>
IngestQuery#eachKey(Function) => Promise<Void>
IngestQuery#eachUrl(Function) => Promise<Void>
IngestQuery#filter(Function) => IngestQuery
IngestQuery#first() => Promise<Object>
IngestQuery#keys() => Promise<Array<String>>
IngestQuery#last() => Promise<Object>
IngestQuery#limit(Number) => IngestQuery
IngestQuery#offset(Number) => IngestQuery
IngestQuery#or(index) => IngestWhereClause
IngestQuery#orderBy(index) => IngestQuery
IngestQuery#put(Object) => Promise<Number>
IngestQuery#urls() => Promise<Array<String>>
IngestQuery#reverse() => IngestQuery
IngestQuery#toArray() => Promise<Array<Object>>
IngestQuery#uniqueKeys() => Promise<Array<String>>
IngestQuery#until(Function) => IngestQuery
IngestQuery#update(Object|Function) => Promise<Number>
IngestQuery#where(index) => IngestWhereClause

{
  version: Number, // the version # of the schema, should increment by 1 on each change

  [tableName]: {
    // is there only one record-file per archive?
    // - if true, will look for the file at `/${tableName}.json`
    // - if false, will look for files at `/${tableName}/*.json`
    singular: Boolean,

    // attribute to build filenames for newly-created records
    // ie `/${tableName}/${record[primaryKey]}.json`
    // only required if !singular
    primaryKey: String, 

    // specify which fields are indexed for querying (optional)
    // each is a keypath, see https://www.w3.org/TR/IndexedDB/#dfn-key-path
    // can specify compound indexes with a + separator in the keypath
    // eg one index               - index: 'firstName' 
    // eg two indexes             - index: ['firstName', 'lastName']
    // eg add a compound index    - index: ['firstName', 'lastName', 'firstName+lastName']
    // eg index an array's values - index: ['firstName', '*favoriteFruits']
    index: String|Array<String>,

    // validator & sanitizer (optional)
    // takes the ingested file (must be valid json)
    // returns the record to be stored
    // returns falsy or throws to not store the record
    validator: Function(Object) => Object

    // file-creator (optional)
    // takes the record
    // returns the object to be stored to the file
    // returns falsy or throws to not write the file
    toFile: Function(Object) => Object
  }
}