loki-hooks

Loki hooks integrates the member-hooks module into lokijs.
It adds a hooks options to the Loki class constructor options and the addCollection options.
The hooks option allows to add before and after hooks to Loki or collection methods.
Examples:
- set auto-increment or uuid field on insert
- add saved event to database
Furthermore it adds a loaded method to both the Loki and the Collection classes.
These methods can be ussed to hook into a database and collection load.

Installation

``javascript
yarn add loki-hooks
npm install loki-hooks
`

Usage

See member-hooks module the usage of hooks.
The createHooksLoki function exported by 'loki-hooks' returns a Loki and Collection class enhanced with a hooks option.

`typescript
import test from 'ava'
import sinon from 'sinon'
import Loki from 'lokijs'
import { v4 as uuid } from 'uuid'
import { Hooks, HookMethods } from 'member-hooks'
import { THooksLoki, createHooksLoki } from '.'

interface TSeqOptions {
field?: string,
key?: string
}

function seqHook(methods: HookMethods, options?: TSeqOptions): void {
const { field = 'seq', key = 'seq' } = { ...options }
methods.before('insert', 10, function (this: any, args: any[]): void {
const hooks = this.hooks
const store = hooks.store || (hooks.store = {})
const doc = args[0]
doc[field] = store[key] = (store[key] || 0) + 1
})
}

function loadedHook(methods: HookMethods): void {
methods.before('loaded', 10, function (this: any): void {
this.loadedCallCount = (this.loadedCallCount || 0) + 1
})
}

function saveHook(methods: HookMethods): void {
methods.before('saveDatabaseInternal', 10, function (this: Loki, args: any[]): void {
if (!this.events.saved) {
this.events.saved = []
}
const fn = args[0]
args[0] = (err: any) => {
fn(err)
if (!err) {
this.emit('saved')
}
}
})
}

const dbRegistry = new Hooks()
dbRegistry.register('saveDatabaseInternal', saveHook)

const collectionRegistry = new Hooks()
collectionRegistry.register('seq', seqHook)
collectionRegistry.register('loaded', loadedHook)

const HooksLoki = createHooksLoki(dbRegistry, collectionRegistry)

async function save(db: THooksLoki): Promise {
return new Promise(resolve => {
db.saveDatabase(resolve)
})
}

async function load(db: THooksLoki): Promise {
return new Promise(resolve => {
db.loadDatabase({}, resolve)
})
}

test('should add database hooks', async t => {
const dbName = uuid()
const db = new HooksLoki(dbName, {
adapter: new Loki.LokiMemoryAdapter(),
hooks: {
config: [['saveDatabaseInternal', {}]]
}
})
const saved = sinon.spy()
db.addListener('saved', saved)
await save(db)
t.assert(saved.calledOnce)
const dbLoaded = sinon.spy(db.loaded)
db.loaded = dbLoaded
await load(db)
t.assert(dbLoaded.callCount > 0)
})

test('should add collection hooks', async t => {
const dbName = uuid()
const db = new HooksLoki(dbName, { adapter: new Loki.LokiMemoryAdapter() })
const collection = db.addCollection('collection', {
disableMeta: true,
hooks: {
store: { seq: 10 },
config: [
['seq', { field: 'seq' }],
['loaded', {}]
]
}
})
t.deepEqual(collection.insert({ id: 'id1' }), { $loki: 1, id: 'id1', seq: 11 })
await save(db)
await load(db)
collection = db.getCollection('collection')
t.assert((collection as any).loadedCallCount > 0)
t.deepEqual(collection.insert({ id: 'id1' }), { $loki: 2, id: 'id1', seq: 12 })
db.removeCollection('collection')
const newCollection = db.addCollection('collection', { disableMeta: true })
t.deepEqual(newCollection.insert({ id: 'id1' }), { $loki: 1, id: 'id1' })
})
``