dobo 1.0.1 → 1.0.3

package/bajoI18N/resource/en-US.json

@@ -49,34 +49,35 @@
     "siteId": "Site ID",
     "theme": "Theme",
     "token": "Token",
-    "field": "Field"
+    "field": "Field",
+    "agree": "Agreement"
   },
   "validation": {
-    "any.required": "Harus diisi",
-    "any.only": "Harus sesuai dengan {{ref}}",
-    "string.alphanum": "Harus berupa alfa numerik karakter saja",
-    "string.base": "Harus berupa string",
-    "string.base64": "Harus berupa string base64 yang valid",
-    "string.creditCard": "Harus berupa nomor kartu kredit",
-    "string.dataUri": "Harus berupa string dataUri yang valid",
-    "string.domain": "Harus mengandung nama domain yang valid",
-    "string.email": "Harus berupa surel yang valid",
-    "string.empty": "Tidak boleh dibiarkan kosong",
-    "string.guid": "Harus berupa GUID yang valid",
-    "string.hex": "Harus mengandung hexadesimal karakter yang valid saja",
-    "string.hexAlign": "Representasi hex yang terdekode harus byte aligned",
-    "string.hostname": "Harus berupa nama host yang valid",
-    "string.ip": "Harus berupa alamat ip yang valid dengan CIDR {{cidr}}",
-    "string.ipVersion": "Harus berupa alamat ip yang valid dengan versi {{version}} dan CIDR {{cidr}}",
-    "string.isoDate": "Harus dalam format ISO",
-    "string.isoDuration": "Harus berupa durasi ISO 8601 yang valid",
-    "string.length": "Panjang harus pas {{limit}} karakter",
-    "string.lowercase": "Hanya boleh mengandung huruf kecil saja",
-    "string.max": "Panjang karakter harus lebih kecil atau sama dengan {{limit}} karakter",
-    "string.min": "Panjang karakter harus setidaknya {{limit}} karakter",
-    "string.token": "Hanya boleh terdiri atas karakter alfanumerik dan garis bawah saja",
-    "string.trim": "Tidak boleh memiliki spasi didepan atau dibelakang",
-    "string.uri": "Harus berupa URI yang valid",
-    "string.uppercase": "Hanya boleh mengandung huruf besar saja"
+    "any.required": "Required",
+    "any.only": "Must match with {{ref}}",
+    "string.alphanum": "Must only contain alpha-numeric characters",
+    "string.base": "Must be a string",
+    "string.base64": "Must be a valid base64 string",
+    "string.creditCard": "Must be a credit card",
+    "string.dataUri": "Must be a valid dataUri string",
+    "string.domain": "Must contain a valid domain name",
+    "string.email": "Must be a valid email",
+    "string.empty": "Required",
+    "string.guid": "Must be a valid GUID",
+    "string.hex": "Must only contain hexadecimal characters",
+    "string.hexAlign": "Hex decoded representation must be byte aligned",
+    "string.hostname": "Must be a valid hostname",
+    "string.ip": "must be a valid ip address with a {{cidr}} CIDR",
+    "string.ipVersion": "Must be a valid ip address of one of the following versions {{version}} with a {{cidr}} CIDR",
+    "string.isoDate": "Must be in iso format",
+    "string.isoDuration": "Must be a valid ISO 8601 duration",
+    "string.length": "Length must be {{limit}} characters long",
+    "string.lowercase": "Must only contain lowercase characters",
+    "string.max": "Length must be less than or equal to {{limit}} characters long",
+    "string.min": "Length must be at least {{limit}} characters long",
+    "string.token": "Must only contain alpha-numeric and underscore characters",
+    "string.trim": "Must not have leading or trailing whitespace",
+    "string.uri": "Must be a valid uri",
+    "string.uppercase": "Must only contain uppercase characters"
   }
 }

package/bajoI18N/resource/id.json

@@ -59,6 +59,19 @@
   "Unsupported aggregate '%s'": "Unsupported aggregate '%s'",
   "Unsupported %s '%s' for '%s@%s'. Allowed choices: %s": "Unsupported %s '%s' for '%s@%s'. Allowed choices: %s",
   "Method '%s@%s' is disabled": "Metode '%s@%s' dinonaktifkan",
+  "Invalid model for persistence: %s": "Model untuk penyimpanan tidak valid: %s",
+  "Can't load %s: %s": "Tidak bisa memuat %s: %s",
+  "No record found": "Tidak ditemukan data",
+  "%d record(s) found": "Ditemukan %d data",
+  "Add": "Tambah",
+  "Edit": "Ubah",
+  "Delete": "Hapus",
+  "Export": "Ekspor",
+  "Query": "Kueri",
+  "Query Builder": "Pembuat Kueri",
+  "List": "Daftar",
+  "Submit Query": "Kirim Kueri",
+  "Data Export": "Ekspor Data",
   "field": {
     "id": "ID",
     "name": "Nama",
@@ -109,35 +122,55 @@
     "siteId": "ID Situs",
     "theme": "Tema",
     "token": "Token",
-    "field": "Field"
+    "field": "Field",
+    "agree": "Persetujuan"
   },
   "Validation Error": "Kesalahan Validasi",
   "validation": {
-    "any.required": "Harus diisi",
-    "any.only": "Harus sesuai dengan {{ref}}",
-    "string.alphanum": "Harus berupa alfa numerik karakter saja",
-    "string.base": "Harus berupa string",
-    "string.base64": "Harus berupa string base64 yang valid",
-    "string.creditCard": "Harus berupa nomor kartu kredit",
-    "string.dataUri": "Harus berupa string dataUri yang valid",
-    "string.domain": "Harus mengandung nama domain yang valid",
-    "string.email": "Harus berupa surel yang valid",
-    "string.empty": "Tidak boleh dibiarkan kosong",
-    "string.guid": "Harus berupa GUID yang valid",
-    "string.hex": "Harus mengandung hexadesimal karakter yang valid saja",
-    "string.hexAlign": "Representasi hex yang terdekode harus byte aligned",
-    "string.hostname": "Harus berupa nama host yang valid",
-    "string.ip": "Harus berupa alamat ip yang valid dengan CIDR {{cidr}}",
-    "string.ipVersion": "Harus berupa alamat ip yang valid dengan versi {{version}} dan CIDR {{cidr}}",
-    "string.isoDate": "Harus dalam format ISO",
-    "string.isoDuration": "Harus berupa durasi ISO 8601 yang valid",
-    "string.length": "Panjang harus pas {{limit}} karakter",
-    "string.lowercase": "Hanya boleh mengandung huruf kecil saja",
-    "string.max": "Panjang karakter harus lebih kecil atau sama dengan {{limit}} karakter",
-    "string.min": "Panjang karakter harus setidaknya {{limit}} karakter",
-    "string.token": "Hanya boleh terdiri atas karakter alfanumerik dan garis bawah saja",
-    "string.trim": "Tidak boleh memiliki spasi didepan atau dibelakang",
-    "string.uri": "Harus berupa URI yang valid",
-    "string.uppercase": "Hanya boleh mengandung huruf besar saja"
+    "any": {
+      "required": "Harus diisi/dipilih",
+      "only": "Harus sesuai dengan {{ref}}"
+    },
+    "string": {
+      "alphanum": "Harus berupa alfa numerik karakter saja",
+      "base": "Harus berupa string",
+      "base64": "Harus berupa string base64 yang valid",
+      "creditCard": "Harus berupa nomor kartu kredit",
+      "dataUri": "Harus berupa string dataUri yang valid",
+      "domain": "Harus mengandung nama domain yang valid",
+      "email": "Harus berupa surel yang valid",
+      "empty": "Harus diisi/dipilih",
+      "guid": "Harus berupa GUID yang valid",
+      "hex": "Harus mengandung hexadesimal karakter yang valid saja",
+      "hexAlign": "Representasi hex yang terdekode harus byte aligned",
+      "hostname": "Harus berupa nama host yang valid",
+      "ip": "Harus berupa alamat ip yang valid dengan CIDR {{cidr}}",
+      "ipVersion": "Harus berupa alamat ip yang valid dengan versi {{version}} dan CIDR {{cidr}}",
+      "isoDate": "Harus dalam format ISO",
+      "isoDuration": "Harus berupa durasi ISO 8601 yang valid",
+      "length": "Panjang harus pas {{limit}} karakter",
+      "lowercase": "Hanya boleh mengandung huruf kecil saja",
+      "max": "Panjang karakter harus lebih kecil atau sama dengan {{limit}} karakter",
+      "min": "Panjang karakter harus setidaknya {{limit}} karakter",
+      "token": "Hanya boleh terdiri atas karakter alfanumerik dan garis bawah saja",
+      "trim": "Tidak boleh memiliki spasi didepan atau dibelakang",
+      "uri": "Harus berupa URI yang valid",
+      "uppercase": "Hanya boleh mengandung huruf besar saja"
+    },
+    "number": {
+      "base": "Harus berupa angka",
+      "greater": "Harus lebih besar dari {{limit}}",
+      "infinity": "Tidak bisa tak terbatas",
+      "integer": "Harus berupa integer",
+      "less": "Harus lebih kecil dari {{limit}}",
+      "max": "Harus lebih kecil atau sama dengan {{limit}}",
+      "min": "Harus lebih besar atau sama dengan {{limit}}",
+      "multiple": "Harus kelipatan dari {{multiple}}",
+      "negative": "Harus berupa angka negatif",
+      "port": "Harus berupa nomor port yang valid",
+      "positive": "Harus berupa angka positif",
+      "precision": "Harus memiliki tidak lebih dari {{limit}} tempat desimal",
+      "unsafe": "Harus berupa nomor yang aman"
+    }
   }
 }

package/lib/add-fixtures.js

@@ -1,6 +1,6 @@
 import path from 'path'
 
-async function addFixture (name, spin) {
+async function addFixture (name, { spinner } = {}) {
   const { resolvePath, readConfig, eachPlugins, getPluginDataDir } = this.app.bajo
   const { isEmpty, isArray } = this.app.bajo.lib._
   const { schema, connection } = this.getInfo(name)
@@ -15,12 +15,12 @@ async function addFixture (name, spin) {
   let items = await readConfig(pattern, { ns: schema.ns, ignoreError: true })
   if (isEmpty(items)) items = []
   // override
-  const overrides = await readConfig(`${getPluginDataDir(this.name)}/fixture/override/${schema.name}.*`, { ns: this.name, ignoreError: true })
+  const overrides = await readConfig(`${getPluginDataDir(this.name)}/override/fixture/${schema.name}.*`, { ns: this.name, ignoreError: true })
   if (isArray(overrides) && !isEmpty(overrides)) items = overrides
   // extend
   const me = this
   await eachPlugins(async function ({ dir, ns }) {
-    const extend = await readConfig(`${dir}/${me.name}/fixture/extend/${schema.name}.*`, { ns, ignoreError: true })
+    const extend = await readConfig(`${dir}/${me.name}/extend/fixture/${schema.name}.*`, { ns, ignoreError: true })
     if (isArray(extend) && !isEmpty(extend)) items.push(...extend)
   })
   if (isEmpty(items)) return result
@@ -39,7 +39,7 @@ async function addFixture (name, spin) {
       }
       await this.recordCreate(schema.name, item, { force: true })
       result.success++
-      if (spin) spin.setText('%s: %d of %d records added', schema.name, result.success, items.length)
+      if (spinner) spinner.setText('%s: %d of %d records added', schema.name, result.success, items.length)
     } catch (err) {
       err.model = schema.name
       if (this.app.bajo.applet) this.print.fail(this.validationErrorMessage(err))

package/lib/check-unique.js

@@ -2,7 +2,7 @@ async function checkUnique ({ schema, body, id }) {
   const { isSet } = this.app.bajo
   const { filter, map, set } = this.app.bajo.lib._
   const singles = map(filter(schema.properties, p => (p.index ?? {}).type === 'unique'), 'name')
-  const opts = { noHook: true, noCache: true, thrownNotFound: false }
+  const opts = { noHook: true, noCache: true, thrownNotFound: false, force: true }
   let old = {}
   if (id) old = (await this.recordGet(schema.name, id, opts)) ?? {}
   for (const s of singles) {
@@ -26,7 +26,7 @@ async function checkUnique ({ schema, body, id }) {
       query[f] = body[f]
     }
     if (empty || same) continue
-    const resp = await this.recordFind(schema.name, { query, limit: 1 }, { noHook: true, noCache: true })
+    const resp = await this.recordFind(schema.name, { query, limit: 1 }, { noHook: true, noCache: true, force: true })
     if (resp.length !== 0) {
       const details = map(m.fields, f => {
         return { field: f, error: 'Unique constraint error' }

package/lib/collect-connections.js

@@ -1,7 +1,5 @@
 async function defSanitizer (item) {
-  // if (!item.connection) fatal('\'%s@%s\' key is required', 'connection', item.name, { payload: item })
-  const { merge } = this.app.bajo.lib._
-  return merge({}, item)
+  return item
 }
 
 async function collectConnections ({ item, index, options }) {
@@ -9,10 +7,11 @@ async function collectConnections ({ item, index, options }) {
   const { importModule, breakNsPath } = this.app.bajo
   const { has, find } = this.app.bajo.lib._
   if (!has(conn, 'type')) this.fatal('Connection must have a valid DB type')
-  const [ns, type] = breakNsPath(conn.type)
+  const { ns, path: type } = breakNsPath(conn.type)
   const driver = find(this.drivers, { ns, type })
   if (!driver) this.fatal('Unsupported DB type \'%s\'', conn.type)
   let file = `${ns}:/${this.name}/lib/${type}/conn-sanitizer.js`
+  if (conn.type === 'dobo:memory') file = `${ns}:/lib/mem-db/conn-sanitizer.js`
   if (driver.provider) file = `${driver.provider}:/${ns}/lib/${type}/conn-sanitizer.js`
   let sanitizer = await importModule(file)
   if (!sanitizer) sanitizer = defSanitizer

package/lib/collect-drivers.js

@@ -1,15 +1,23 @@
 async function collectDrivers () {
   const { eachPlugins, readConfig, runHook } = this.app.bajo
-  const { isString, find, pick, merge } = this.app.bajo.lib._
+  const { isString, find, pick, merge, cloneDeep } = this.app.bajo.lib._
   const me = this
   me.drivers = []
+  // built-in memory driver
+  me.drivers.push({
+    type: 'memory',
+    ns: me.name,
+    driver: 'memory',
+    idField: merge(cloneDeep(me.config.default.idField), { name: 'id' })
+  })
+  // others
   await runHook(`${this.name}:beforeCollectDrivers`)
   await eachPlugins(async function ({ file, ns }) {
     const info = await readConfig(file, { ns })
     if (!info.type) this.fatal('A DB driver must provide at least one database type')
     if (!info.driver) this.fatal('A DB driver must have a driver name')
     if (isString(info.type)) info.type = [info.type]
-    if (!info.idField) info.idField = me.config.defaults.idField
+    if (!info.idField) info.idField = cloneDeep(me.config.default.idField)
     info.idField.name = 'id'
     for (const t of info.type) {
       const [type, provider] = t.split('@')
@@ -25,7 +33,7 @@ async function collectDrivers () {
       }
       me.drivers.push(merge(ext, driver))
     }
-  }, { glob: 'boot/driver.*', baseNs: this.name })
+  }, { glob: 'boot/driver.*', prefix: this.name })
   await runHook(`${this.name}:afterCollectDrivers`)
 }
 

package/lib/collect-feature.js

@@ -3,20 +3,21 @@ import path from 'path'
 async function handler ({ file, alias, ns }) {
   const { importModule } = this.app.bajo
   const { camelCase, isFunction } = this.app.bajo.lib._
+  const me = this.app.dobo
+
   let name = camelCase(path.basename(file, '.js'))
-  if (ns !== this.name) name = `${ns}:${name}`
+  if (ns !== me.name) name = `${ns}.${name}`
   const mod = await importModule(file)
   if (!isFunction(mod)) this.fatal('Feature \'%s\' should be an async function', name)
-  this.feature = this.feature ?? {}
-  this.feature[name] = mod
-  this.log.trace('- %s', name)
+  me.feature[name] = mod
+  me.log.trace('- %s', name)
 }
 
 async function collectFeature () {
   const { eachPlugins } = this.app.bajo
   this.feature = {}
   this.log.trace('Loading DB feature')
-  await eachPlugins(handler, { glob: 'feature/*.js', baseNs: this.ns })
+  await eachPlugins(handler, { glob: 'feature/*.js', prefix: this.name })
   this.log.debug('Total loaded features: %d', Object.keys(this.feature).length)
 }
 

package/lib/collect-schemas.js

@@ -3,15 +3,17 @@ import sanitizeSchema from './sanitize-schema.js'
 
 async function handler ({ file, alias, ns }) {
   const { readConfig, pascalCase, eachPlugins } = this.app.bajo
-  const { isPlainObject, each, find, has, isArray, forOwn, isString, merge } = this.app.bajo.lib._
+  const { get, isPlainObject, each, find, has, isArray, forOwn, isString, merge } = this.app.bajo.lib._
   const { fastGlob } = this.app.bajo.lib
 
-  const defName = pascalCase(`${alias} ${path.basename(file, path.extname(file))}`)
+  const base = path.basename(file, path.extname(file))
+  const defName = pascalCase(`${alias} ${base}`)
   const mod = await readConfig(file, { ns, ignoreError: true })
   if (!isPlainObject(mod)) this.fatal('Invalid schema \'%s\'', defName)
-  mod.name = mod.name ?? defName
-  mod.modelName = mod.modelName ?? mod.name
+  const forcedConn = get(this, `app.${ns}.config.dobo.schemaConnection.${base}`)
+  if (forcedConn) mod.connection = forcedConn
   if (!mod.connection) mod.connection = 'default'
+  mod.name = mod.name ?? defName
   mod.file = file
   mod.ns = ns
   mod.attachment = mod.attachment ?? true
@@ -32,7 +34,7 @@ async function handler ({ file, alias, ns }) {
   // schema extender
   const me = this
   await eachPlugins(async function (opts) {
-    const glob = `${opts.dir}/${me.name}/schema/extend/${mod.name}.*`
+    const glob = `${opts.dir}/${me.name}/extend/schema/${mod.name}.*`
     const files = await fastGlob(glob)
     for (const file of files) {
       const extender = await readConfig(file, { ns: opts.ns, ignoreError: true })
@@ -55,7 +57,7 @@ async function handler ({ file, alias, ns }) {
       }
       if (feats.length > 0) mod.feature.push(...feats)
       if (opts.plugin === this.app.bajo.mainNs) {
-        each(['connection', 'modelName'], i => {
+        each(['connection', 'name'], i => {
           if (has(extender, i)) mod[i] = extender[i]
         })
       }
@@ -69,7 +71,7 @@ async function handler ({ file, alias, ns }) {
 async function collectSchemas () {
   const { eachPlugins } = this.app.bajo
   const { isEmpty } = this.app.bajo.lib._
-  const result = await eachPlugins(handler, { glob: 'schema/*.*', baseNs: this.name })
+  const result = await eachPlugins(handler, { glob: 'schema/*.*', prefix: this.name })
   if (isEmpty(result)) this.log.warn('No %s found!', this.print.write('schema'))
   else await sanitizeSchema.call(this, result)
 }

package/lib/exec-validation.js

@@ -1,25 +1,19 @@
-async function execValidation ({ noHook, name, body, options, partial }) {
+async function execValidation ({ name, body, options, partial }) {
   const { runHook } = this.app.bajo
-  const { get, keys } = this.app.bajo.lib._
+  const { keys, camelCase } = this.app.bajo.lib._
+  const { noHook } = options
   if (!noHook) {
-    await runHook(`${this.name}:onBeforeRecordValidation`, name, body, options)
-    await runHook(`${this.name}.${name}:onBeforeRecordValidation`, body, options)
+    await runHook(`${this.name}:beforeRecordValidation`, name, body, options)
+    await runHook(`${this.name}.${camelCase(name)}:beforeRecordValidation`, body, options)
   }
   const { validation = {} } = options
   if (partial) {
     validation.fields = keys(body)
   }
-  try {
-    body = await this.validate(body, name, validation)
-  } catch (err) {
-    if (err.code === 'DB_VALIDATION' && get(options, 'req.flash')) {
-      options.req.flash('validation', err)
-    }
-    throw err
-  }
+  body = await this.validate(body, name, validation)
   if (!noHook) {
-    await runHook(`${this.name}:onAfterRecordValidation`, name, body, options)
-    await runHook(`${this.name}.${name}:onAfterRecordValidation`, body, options)
+    await runHook(`${this.name}:afterRecordValidation`, name, body, options)
+    await runHook(`${this.name}.${camelCase(name)}:afterRecordValidation`, body, options)
   }
   return body
 }

package/lib/generic-prop-sanitizer.js

@@ -23,7 +23,7 @@ async function genericPropSanitizer ({ prop, schema, driver }) {
       delete prop[p]
       return undefined
     }
-    prop[p] = get(prop, p, get(this.config, `defaults.property.${prop.type}.${p}`, def[p]))
+    prop[p] = get(prop, p, get(this.config, `default.property.${prop.type}.${p}`, def[p]))
     if (def.choices && !def.choices.includes(prop[p])) {
       this.fatal('Unsupported %s \'%s\' for \'%s@%s\'. Allowed choices: %s',
         p, prop[p], prop.name, schema.name, join(def.choices))

package/lib/mem-db/conn-sanitizer.js

@@ -0,0 +1,8 @@
+async function connSanitizer (connection) {
+  const { pick } = this.app.bajo.lib._
+  const result = pick(connection, ['type', 'name', 'driver'])
+  result.memory = true
+  return result
+}
+
+export default connSanitizer

package/lib/mem-db/instantiate.js

@@ -0,0 +1,41 @@
+let saving = false
+
+async function instantiate ({ connection, schemas, noRebuild }) {
+  const { getPluginDataDir } = this.app.bajo
+  const { fs } = this.app.bajo.lib
+  const { pick } = this.app.bajo.lib._
+  this.memDb = this.memDb ?? {}
+  this.memDb.storage = this.memDb.storage ?? {}
+  this.memDb.instances = this.memDb.instances ?? []
+  const instance = pick(connection, ['name', 'type'])
+  this.memDb.instances.push(instance)
+  // if (noRebuild) return
+  const pdir = `${getPluginDataDir(this.name)}/memDb/data` // persistence dir
+  fs.ensureDirSync(pdir)
+  const persistence = []
+  for (const schema of schemas) {
+    this.memDb.storage[schema.name] = this.memDb.storage[schema.name] ?? [] // init empty model
+    if (!schema.persistence) continue
+    persistence.push(schema.name)
+    // load if persistence
+    const file = `${pdir}/${schema.name}.json`
+    if (!fs.existsSync(file)) continue
+    try {
+      const data = fs.readFileSync(file, 'utf8')
+      this.memDb.storage[schema.name] = JSON.parse(data)
+    } catch (err) {
+      this.fatal('Can\'t load %s: %s', schema.name, err.message)
+    }
+  }
+  setInterval(() => {
+    if (saving) return
+    saving = true
+    for (const item of persistence) {
+      const data = this.memDb.storage[item]
+      fs.writeFileSync(`${pdir}/${item}.json`, JSON.stringify(data), 'utf8')
+    }
+    saving = false
+  }, this.config.memDb.persistence.syncPeriod * 1000)
+}
+
+export default instantiate

package/lib/mem-db/method/model/clear.js

@@ -0,0 +1,6 @@
+async function clear ({ schema, options = {} }) {
+  this.memDb.storage[schema.name].splice(0)
+  return true
+}
+
+export default clear

package/lib/mem-db/method/model/create.js

@@ -0,0 +1,5 @@
+async function exists ({ schema, options = {} }) {
+  this.memDb.storage[schema.name] = []
+}
+
+export default exists

package/lib/mem-db/method/model/drop.js

@@ -0,0 +1,5 @@
+async function exists ({ schema, options = {} }) {
+  this.memDb.storage[schema.name].splice(0)
+}
+
+export default exists

package/lib/mem-db/method/model/exists.js

@@ -0,0 +1,5 @@
+async function exists ({ schema, options = {} }) {
+  return true
+}
+
+export default exists

package/lib/mem-db/method/record/create.js

@@ -0,0 +1,12 @@
+import getRecord from './get.js'
+
+async function create ({ schema, body, options = {} }) {
+  const { noResult } = options
+  const exist = await getRecord.call(this, { schema, id: body.id, options: { thrownNotFound: false } })
+  if (exist.data) throw this.error('Record \'%s@%s\' exists already!', body.id, schema.name)
+  this.memDb.storage[schema.name].push(body)
+  if (noResult) return
+  return { data: body }
+}
+
+export default create

package/lib/mem-db/method/record/find.js

@@ -0,0 +1,20 @@
+import { Query } from 'mingo'
+
+async function find ({ schema, filter = {}, options = {} }) {
+  const { prepPagination } = this.app.dobo
+  const { omit } = this.app.bajo.lib._
+  const { limit, skip, sort, page } = await prepPagination(filter, schema)
+  const criteria = filter.query ?? {}
+  const q = new Query(criteria, { idKey: 'id' })
+  let cursor = q.find(this.memDb.storage[schema.name])
+  let count = 0
+  if (options.count && !options.dataOnly) count = cursor.count()
+  cursor = q.find(this.memDb.storage[schema.name])
+  if (sort) cursor.sort(sort)
+  if (!options.noLimit) cursor.skip(skip).limit(limit)
+  let result = { data: cursor.all(), page, limit, count, pages: Math.ceil(count / limit) }
+  if (!options.count) result = omit(result, ['count', 'pages'])
+  return result
+}
+
+export default find

package/lib/mem-db/method/record/get.js

@@ -0,0 +1,9 @@
+async function get ({ schema, id, options = {} }) {
+  const { thrownNotFound = true } = options
+  const { find } = this.app.bajo.lib._
+  const result = find(this.memDb.storage[schema.name], { id })
+  if (!result && thrownNotFound) throw this.error('Record \'%s@%s\' not found!', id, schema.name, { statusCode: 404 })
+  return { data: result }
+}
+
+export default get

package/lib/mem-db/method/record/remove.js

@@ -0,0 +1,13 @@
+import getRecord from './get.js'
+
+async function remove ({ schema, id, options = {} }) {
+  const { noResult } = options
+  const { findIndex, pullAt } = this.app.bajo.lib._
+  const rec = noResult ? undefined : await getRecord.call(this, { schema, id })
+  const idx = findIndex(this.memDb.storage[schema.name], { id })
+  pullAt(this.memDb.storage[schema.name], [idx])
+  if (noResult) return
+  return { oldData: rec.data }
+}
+
+export default remove

package/lib/mem-db/method/record/update.js

@@ -0,0 +1,15 @@
+import getRecord from './get.js'
+
+async function update ({ schema, id, body, options }) {
+  const { noResult } = options
+  const { findIndex, merge } = this.app.bajo.lib._
+  const old = noResult ? undefined : await getRecord.call(this, { schema, id })
+  const idx = findIndex(this.memDb.storage[schema.name], { id })
+  const current = this.memDb.storage[schema.name][idx]
+  this.memDb.storage[schema.name][idx] = merge(current, body)
+  if (noResult) return
+  const result = this.memDb.storage[schema.name][idx]
+  return { oldData: old.data, data: result }
+}
+
+export default update

package/lib/mem-db/method/stat/count.js

@@ -0,0 +1,11 @@
+import { Query } from 'mingo'
+
+async function count ({ schema, filter = {}, options = {} }) {
+  const criteria = filter.query ?? {}
+  const q = new Query(criteria, { idKey: 'id' })
+  const cursor = q.find(this.memDb.storage[schema.name])
+  const count = cursor.count()
+  return { data: count }
+}
+
+export default count

package/lib/mem-db/start.js

@@ -0,0 +1,25 @@
+import addFixtures from '../add-fixtures.js'
+
+async function start () {
+  const { filter, map } = this.app.bajo.lib._
+
+  const conns = filter(this.connections, { type: 'dobo:memory' })
+  const schemas = filter(this.schemas, s => {
+    const names = map(conns, 'name')
+    return names.includes(s.connection)
+  })
+  if (schemas.length === 0) return
+  this.log.debug('Adding fixture for memory database')
+  for (const schema of schemas) {
+    if (schema.persistence) {
+      this.log.warn('\'%s\' is a memory persistence model. Adding records from fixture is ignored!', schema.name)
+      continue
+    }
+    let { success, error } = await addFixtures.call(this, schema.name)
+    success = success ?? 0
+    error = error ?? 0
+    this.log.trace('- %s@%s (%d/%d)', schema.name, schema.connection, success, success + error)
+  }
+}
+
+export default start

package/lib/resolve-method.js

@@ -3,10 +3,11 @@ async function resolveMethod (name, method, options = {}) {
   const { fs } = this.app.bajo.lib
   const { camelCase } = this.app.bajo.lib._
   const { schema, driver, connection } = this.getInfo(name)
-  if (!options.force && (schema.disabled ?? []).includes(method)) throw this.error('Method \'%s@%s\' is disabled', camelCase(method), name)
-  const cfg = this.app[driver.ns].config
   const [group, action] = method.split('-')
-  const file = `${cfg.dir.pkg}/${this.name}/method/${group}/${action}.js`
+  if (!options.force && (schema.disabled ?? []).includes(action)) throw this.error('Method \'%s@%s\' is disabled', camelCase(method), name)
+  let file
+  if (connection.name === 'memory') file = `${this.app[driver.ns].dir.pkg}/lib/mem-db/method/${group}/${action}.js`
+  else file = `${this.app[driver.ns].dir.pkg}/${this.name}/method/${group}/${action}.js`
   if (!fs.existsSync(file)) throw this.error('Method \'%s@%s\' is unsupported', camelCase(method), name)
   const handler = await importModule(file)
   return { handler, schema, driver, connection }