dobo 1.0.13 → 1.0.15

package/bajoCli/applet/lib/post-process.js

@@ -9,12 +9,12 @@ async function postProcess ({ handler, params, path, processMsg, noConfirmation
   params.push({ fields: this.config.fields, dataOnly: !this.config.full })
 
   const schema = find(this.schemas, { name: params[0] })
-  if (!schema) return this.print.fatal('No schema found!')
+  if (!schema) return this.print.fatal('notFound%s', this.print.write('field.schema'))
   let cont = true
   if (!noConfirmation) {
-    const answer = await confirm({ message: this.print.write('Are you sure to continue?'), default: false })
+    const answer = await confirm({ message: this.print.write('sureContinue'), default: false })
     if (!answer) {
-      this.print.fail('Aborted!')
+      this.print.fail('aborted')
       cont = false
     }
   }
@@ -27,7 +27,7 @@ async function postProcess ({ handler, params, path, processMsg, noConfirmation
   }
   try {
     const resp = await this[handler](...params)
-    spin.succeed('Done!')
+    spin.succeed('done')
     const result = this.config.pretty ? (await prettyPrint(resp)) : JSON.stringify(resp, null, 2)
     if (this.config.save) {
       const id = resp.id ?? get(resp, 'data.id') ?? get(resp, 'oldData.id')
@@ -39,7 +39,7 @@ async function postProcess ({ handler, params, path, processMsg, noConfirmation
     if (this.config.log.applet) {
       spin.stop()
       console.error(err)
-    } else spin.fail('Error: %s', err.message)
+    } else spin.fail('error%s', err.message)
   }
   process.exit()
 }

package/bajoCli/applet/model-clear.js

@@ -3,7 +3,7 @@ import postProcess from './lib/post-process.js'
 async function modelClear (...args) {
   const { print } = this.app.bajo
   const { isEmpty } = this.app.bajo.lib._
-  if (isEmpty(this.schemas)) return print.fail('No schema found!', { exit: this.app.bajo.applet })
+  if (isEmpty(this.schemas)) return print.fail('notFound%s', 'schema', { exit: this.app.bajo.applet })
   const [schema] = args
   await postProcess.call(this, { handler: 'modelClear', params: [schema], path: 'modelClear', processMsg: 'Clear records' })
 }

package/bajoCli/applet/model-rebuild.js

@@ -8,10 +8,10 @@ async function modelRebuild (...args) {
     'bajoCli:@inquirer/confirm', 'bajoCli:boxen')
   const schemas = map(this.schemas, 'name')
   let names = args.join(' ')
-  if (isEmpty(schemas)) return this.print.fail('No schema found!', { exit: this.app.bajo.applet })
+  if (isEmpty(schemas)) return this.print.fail('notFound%s', 'schema', { exit: this.app.bajo.applet })
   if (isEmpty(names)) {
     names = await input({
-      message: this.print.write('Enter schema name(s), separated by space:'),
+      message: this.print.write('enterSchemaName'),
       default: '*'
     })
   }
@@ -19,12 +19,12 @@ async function modelRebuild (...args) {
   names = schemas.filter(isMatch)
   if (names.length === 0) return this.print.fail('No schema matched', true, { exit: this.app.bajo.applet })
   names = names.sort()
-  console.log(boxen(names.join(' '), { title: this.print.write('Schema (%d)', names.length), padding: 0.5, borderStyle: 'round' }))
+  console.log(boxen(names.join(' '), { title: this.print.write('schema%d', names.length), padding: 0.5, borderStyle: 'round' }))
   const answer = await confirm({
-    message: this.print.write('The above mentioned schema(s) will be rebuilt as model. Continue?'),
+    message: this.print.write('schemasWillBeRebuiltContinue'),
     default: false
   })
-  if (!answer) return this.print.fail('Aborted!', { exit: this.app.bajo.applet })
+  if (!answer) return this.print.fail('aborted', { exit: this.app.bajo.applet })
   /*
   const conns = []
   for (const s of names) {
@@ -36,9 +36,9 @@ async function modelRebuild (...args) {
   const result = { succed: 0, failed: 0, skipped: 0 }
   for (const s of names) {
     const { schema, instance, connection } = this.getInfo(s)
-    const spin = this.print.spinner({ showCounter: true }).start('Rebuilding \'%s\'...', schema.name)
+    const spin = this.print.spinner({ showCounter: true }).start('rebuilding%s', schema.name)
     if (!instance) {
-      spin.warn('Client instance not connected \'%s@%s\'. Skipped!', schema.connection, schema.name)
+      spin.warn('clientInstanceNotConnected%s', schema.connection, schema.name)
       result.skipped++
       continue
     }
@@ -47,33 +47,33 @@ async function modelRebuild (...args) {
       if (this.app.bajo.config.force) {
         try {
           await this.modelDrop(schema.name, { spinner: spin })
-          spin.setText('Model \'%s\' successfully dropped', schema.name)
+          spin.setText('modelDropped%s', schema.name)
         } catch (err) {
-          spin.fail('Error on dropping model \'%s\': %s', schema.name, err.message)
+          spin.fail('errorDroppingModel%s%s', schema.name, err.message)
           result.failed++
           continue
         }
       } else {
-        spin.fail('Model \'%s\' exists. Won\'t rebuild without --force', schema.name)
+        spin.fail('modelExistsNeedForce%s', schema.name)
         result.failed++
         continue
       }
     }
     try {
       await this.modelCreate(schema.name, { spinner: spin })
-      if (connection.memory) spin.succeed('Model \'%s\' successfully created', schema.name)
+      if (connection.memory) spin.succeed('modelCreated%s', schema.name)
       else {
         const fixture = await addFixtures.call(this, schema.name, { spinner: spin })
-        spin.succeed('Model \'%s\' successfully created, with fixture: added %d, rejected: %s', schema.name, fixture.success, fixture.failed)
+        spin.succeed('modelCreatedWithFixture%s%s%s', schema.name, fixture.success, fixture.failed)
       }
       result.succed++
     } catch (err) {
       if (this.app.bajo.config.log.applet && this.app.bajo.config.log.level === 'trace') console.error(err)
-      spin.fail('Error on creating \'%s\': %s', schema.name, err.message)
+      spin.fail('errorCreatingModel%s%s', schema.name, err.message)
       result.failed++
     }
   }
-  this.print.info('Done! Succeded: %d, failed: %s, skipped: %d', result.succed, result.failed, result.skipped)
+  this.print.info('succeedFailSkip%d%d%d', result.succed, result.failed, result.skipped)
   process.exit()
 }
 

package/bajoCli/applet/record-create.js

@@ -5,24 +5,24 @@ async function createRecord (path, ...args) {
   const { isEmpty, map, isPlainObject } = this.app.bajo.lib._
   const [input, select, boxen] = await importPkg('bajoCli:@inquirer/input',
     'bajoCli:@inquirer/select', 'bajoCli:boxen')
-  if (isEmpty(this.schemas)) return this.print.fail('No schema found!', { exit: this.app.bajo.applet })
+  if (isEmpty(this.schemas)) return this.print.fail('notFound%s', this.print.write('field.schema'), { exit: this.app.bajo.applet })
   let [schema, body] = args
   if (isEmpty(schema)) {
     schema = await select({
-      message: this.print.write('Please select a schema:'),
+      message: this.print.write('selectSchema'),
       choices: map(this.schemas, s => ({ value: s.name }))
     })
   }
   if (isEmpty(body)) {
     body = await input({
-      message: this.print.write('Enter JSON payload:'),
+      message: this.print.write('enterJsonPayload'),
       validate: text => {
-        if (isEmpty(text)) return this.print.write('Payload is required')
+        if (isEmpty(text)) return this.print.write('payloadRequired')
         try {
           const parsed = JSON.parse(text)
           if (!isPlainObject(parsed)) throw new Error()
         } catch (err) {
-          return this.print.write('Payload must be a valid JSON object')
+          return this.print.write('payloadMustBeJson')
         }
         return true
       }
@@ -32,7 +32,7 @@ async function createRecord (path, ...args) {
   try {
     payload = JSON.parse(body)
   } catch (err) {
-    return this.print.fail('Invalid payload syntax', { exit: this.app.bajo.applet })
+    return this.print.fail('invalidPayloadSyntax', { exit: this.app.bajo.applet })
   }
   console.log(boxen(JSON.stringify(payload, null, 2), { title: schema, padding: 0.5, borderStyle: 'round' }))
   await postProcess.call(this, { handler: 'recordCreate', params: [schema, payload], path, processMsg: 'Creating record' })

package/bajoCli/applet/record-find.js

@@ -4,17 +4,17 @@ async function findRecord (path, ...args) {
   const { importPkg } = this.app.bajo
   const { isEmpty, map, pick } = this.app.bajo.lib._
   const [select, input] = await importPkg('bajoCli:@inquirer/select', 'bajoCli:@inquirer/input')
-  if (isEmpty(this.schemas)) return this.print.fail('No schema found!', { exit: this.app.bajo.applet })
+  if (isEmpty(this.schemas)) return this.print.fail('notFound%s', this.print.write('field.schema'), { exit: this.app.bajo.applet })
   let [schema, query] = args
   if (isEmpty(schema)) {
     schema = await select({
-      message: this.print.write('Please select a schema:'),
+      message: this.print.write('selectSchema'),
       choices: map(this.schemas, s => ({ value: s.name }))
     })
   }
   if (isEmpty(query)) {
     query = await input({
-      message: this.print.write('Please enter a query (if any):')
+      message: this.print.write('enterQueryIfAny')
     })
   }
   if (isEmpty(query)) query = {}

package/bajoCli/applet/record-get.js

@@ -4,7 +4,7 @@ async function getRecord (path, ...args) {
   const { importPkg } = this.app.bajo
   const { isEmpty, map } = this.app.bajo.lib._
   const [input, select] = await importPkg('bajoCli:@inquirer/input', 'bajoCli:@inquirer/select')
-  if (isEmpty(this.schemas)) return this.print.fail('No schema found!', { exit: this.app.bajo.applet })
+  if (isEmpty(this.schemas)) return this.print.fail('notFound%s', this.print.write('field.schema'), { exit: this.app.bajo.applet })
   let [schema, id] = args
   if (isEmpty(schema)) {
     schema = await select({

package/bajoCli/applet/record-remove.js

@@ -4,7 +4,7 @@ async function removeRecord (path, ...args) {
   const { importPkg } = this.app.bajo
   const { isEmpty, map } = this.app.bajo.lib._
   const [input, select] = await importPkg('bajoCli:@inquirer/input', 'bajoCli:@inquirer/select')
-  if (isEmpty(this.schemas)) return this.print.fail('No schema found!', { exit: this.app.bajo.applet })
+  if (isEmpty(this.schemas)) return this.print.fail('notFound%s', this.print.write('field.schema'), { exit: this.app.bajo.applet })
   let [schema, id] = args
   if (isEmpty(schema)) {
     schema = await select({

package/bajoCli/applet/record-update.js

@@ -5,30 +5,30 @@ async function updateRecord (path, ...args) {
   const { isEmpty, map, isPlainObject } = this.app.bajo.lib._
   const [input, select, boxen] = await importPkg('bajoCli:@inquirer/input',
     'bajoCli:@inquirer/select', 'bajoCli:boxen')
-  if (isEmpty(this.schemas)) return this.print.fail('No schema found!', { exit: this.app.bajo.applet })
+  if (isEmpty(this.schemas)) return this.print.fail('notFound%s', this.print.write('field.schema'), { exit: this.app.bajo.applet })
   let [schema, id, body] = args
   if (isEmpty(schema)) {
     schema = await select({
-      message: this.print.write('Please select a schema:'),
+      message: this.print.write('selectSchema'),
       choices: map(this.schemas, s => ({ value: s.name }))
     })
   }
   if (isEmpty(id)) {
     id = await input({
-      message: this.print.write('Enter record ID:'),
-      validate: text => isEmpty(text) ? this.print.write('ID is required') : true
+      message: this.print.write('enterRecordId'),
+      validate: text => isEmpty(text) ? this.print.write('idIsRequired') : true
     })
   }
   if (isEmpty(body)) {
     body = await input({
-      message: this.print.write('Enter JSON payload:'),
+      message: this.print.write('enterJsonPayload'),
       validate: text => {
-        if (isEmpty(text)) return this.print.write('Payload is required')
+        if (isEmpty(text)) return this.print.write('payloadRequired')
         try {
           const parsed = JSON.parse(text)
           if (!isPlainObject(parsed)) throw new Error()
         } catch (err) {
-          return this.print.write('Payload must be a valid JSON object')
+          return this.print.write('payloadMustBeJson')
         }
         return true
       }
@@ -38,7 +38,7 @@ async function updateRecord (path, ...args) {
   try {
     payload = JSON.parse(body)
   } catch (err) {
-    return this.print.fail('Invalid payload syntax', { exit: this.app.bajo.applet })
+    return this.print.fail('invalidPayloadSyntax', { exit: this.app.bajo.applet })
   }
   console.log(boxen(JSON.stringify(payload, null, 2), { title: schema, padding: 0.5, borderStyle: 'round' }))
   await postProcess.call(this, { handler: 'recordUpdate', params: [schema, id, payload], path, processMsg: 'Updating record' })

package/bajoCli/applet/schema.js

@@ -4,18 +4,18 @@ async function schema (path, ...args) {
   const { getOutputFormat, writeOutput } = this.app.bajoCli
   const select = await importPkg('bajoCli:@inquirer/select')
   const format = getOutputFormat()
-  if (isEmpty(this.schemas)) return this.print.fail('No schema found!', { exit: this.app.bajo.applet })
+  if (isEmpty(this.schemas)) return this.print.fail('notFound%s', this.print.write('field.schema'), { exit: this.app.bajo.applet })
   let name = args[0]
   if (isEmpty(name)) {
     const choices = map(this.schemas, s => ({ value: s.name }))
     name = await select({
-      message: this.print.write('Please choose a schema:'),
+      message: this.print.write('selectSchema'),
       choices
     })
   }
   const result = find(this.schemas, { name })
-  if (!result) return this.print.fail('Can\'t find %s named \'%s\'', this.print.write('schema'), name, { exit: this.app.bajo.applet })
-  this.print.info('Done!')
+  if (!result) return this.print.fail('cantFindSchema%s', this.print.write('schema'), name, { exit: this.app.bajo.applet })
+  this.print.info('done')
   await writeOutput(result, path, format)
 }
 

package/bajoCli/applet/stat-count.js

@@ -4,17 +4,17 @@ async function statCount (path, ...args) {
   const { importPkg } = this.app.bajo
   const { isEmpty, map } = this.app.bajo.lib._
   const [select, input] = await importPkg('bajoCli:@inquirer/select', 'bajoCli:@inquirer/input')
-  if (isEmpty(this.schemas)) return this.print.fail('No schema found!', { exit: this.app.bajo.applet })
+  if (isEmpty(this.schemas)) return this.print.fail('notFound%s', this.print.write('field.schema'), { exit: this.app.bajo.applet })
   let [schema, query] = args
   if (isEmpty(schema)) {
     schema = await select({
-      message: this.print.write('Please select a schema:'),
+      message: this.print.write('selectSchema'),
       choices: map(this.schemas, s => ({ value: s.name }))
     })
   }
   if (isEmpty(query)) {
     query = await input({
-      message: this.print.write('Please enter a query (if any):')
+      message: this.print.write('enterQueryIfAny')
     })
   }
   const filter = { query }

package/lib/add-fixtures.js

@@ -1,11 +1,11 @@
 import path from 'path'
 
 async function addFixture (name, { spinner } = {}) {
-  const { resolvePath, readConfig, eachPlugins, getPluginDataDir } = this.app.bajo
+  const { resolvePath, readConfig, eachPlugins } = this.app.bajo
   const { isEmpty, isArray } = this.app.bajo.lib._
   const { schema, connection } = this.getInfo(name)
   if (connection.proxy) {
-    this.log.warn('\'%s\' is bound to a proxied connection, skipped!', schema.name)
+    this.log.warn('proxiedConnBound%s', schema.name)
     return
   }
   const result = { success: 0, failed: 0 }
@@ -39,12 +39,11 @@ async function addFixture (name, { spinner } = {}) {
       }
       await this.recordCreate(schema.name, item, { force: true })
       result.success++
-      if (spinner) spinner.setText('%s: %d of %d records added', schema.name, result.success, items.length)
+      if (spinner) spinner.setText('recordsAdded%s%d%d', schema.name, result.success, items.length)
     } catch (err) {
       console.log(err)
       err.model = schema.name
       if (this.app.bajo.applet) this.print.fail(this.validationErrorMessage(err))
-      // else this.log.error('Add fixture \'%s@%s\' error: %s', schema.name, schema.connection, err.message)
       result.failed++
     }
   }

package/lib/build-bulk-action.js

@@ -2,9 +2,9 @@ async function buildBulkAction (name, action, options = {}) {
   const { fs, importModule } = this.app.bajo
   const { camelCase } = this.app.bajo.lib._
   const { schema, driver, connection } = await this.getInfo(name)
-  if (!options.force && (schema.disabled ?? []).includes(action)) throw this.error('Method \'%s:%s\' is disabled', camelCase('bulk ' + action), name)
+  if (!options.force && (schema.disabled ?? []).includes(action)) throw this.error('methodIsDisabled%s%s', camelCase('bulk ' + action), name)
   const file = `${driver.plugin}:/${this.name}/method/bulk/${action}.js`
-  if (!fs.existsSync(file)) throw this.error('Method \'%s:%s\' is unsupported', camelCase('bulk ' + action), name)
+  if (!fs.existsSync(file)) throw this.error('methodUnsupported%s%s', camelCase('bulk ' + action), name)
   const handler = await importModule(file)
   return { handler, schema, driver, connection }
 }

package/lib/check-unique.js

@@ -11,8 +11,8 @@ async function checkUnique ({ schema, body, id }) {
     const query = set({}, s, body[s])
     const resp = await this.recordFind(schema.name, { query, limit: 1 }, opts)
     if (resp.length !== 0) {
-      const details = [{ field: s, error: 'Unique constraint error', value: id }]
-      throw this.error('Unique constraint error', { details })
+      const details = [{ field: s, error: 'uniqueConstraintError', value: id }]
+      throw this.error('uniqueConstraintError', { details })
     }
   }
   const multis = filter(schema.indexes, i => i.type === 'unique')

package/lib/collect-connections.js

@@ -6,10 +6,10 @@ async function collectConnections ({ item, index, options }) {
   const conn = item
   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')
+  if (!has(conn, 'type')) this.fatal('mustValidDbType')
   const { ns, path: type } = breakNsPath(conn.type)
   const driver = find(this.drivers, { ns, type })
-  if (!driver) this.fatal('Unsupported DB type \'%s\'', conn.type)
+  if (!driver) this.fatal('unsupportedDbType%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`

package/lib/collect-drivers.js

@@ -14,15 +14,15 @@ async function collectDrivers () {
   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 (!info.type) this.fatal('driverMustProvideDbType')
+    if (!info.driver) this.fatal('driverMustHaveName')
     if (isString(info.type)) info.type = [info.type]
     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('@')
       const exists = find(me.drivers, { type, ns })
-      if (exists) this.fatal('Database type \'%s\' already supported by driver \'%s\'', type, info.driver)
+      if (exists) this.fatal('dbTypeAlreadySupportedByDriver%s%s', type, info.driver)
       const driver = pick(find(me.app[ns].drivers, { name: type }) ?? {}, ['dialect', 'idField', 'lowerCaseColl', 'returning'])
       const ext = {
         type,

package/lib/collect-feature.js

@@ -8,7 +8,7 @@ async function handler ({ file, alias, ns }) {
   let name = camelCase(path.basename(file, '.js'))
   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)
+  if (!isFunction(mod)) this.fatal('featureNotAsync%s', name)
   me.feature[name] = mod
   me.log.trace('- %s', name)
 }
@@ -16,9 +16,9 @@ async function handler ({ file, alias, ns }) {
 async function collectFeature () {
   const { eachPlugins } = this.app.bajo
   this.feature = {}
-  this.log.trace('Loading DB feature')
+  this.log.trace('loadingDbFeature')
   await eachPlugins(handler, { glob: 'feature/*.js', prefix: this.name })
-  this.log.debug('Total loaded features: %d', Object.keys(this.feature).length)
+  this.log.debug('totalLoadedFeatures%d', Object.keys(this.feature).length)
 }
 
 export default collectFeature

package/lib/collect-schemas.js

@@ -9,7 +9,7 @@ async function handler ({ file, alias, ns }) {
   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)
+  if (!isPlainObject(mod)) this.fatal('invalidSchema%s', defName)
   const forcedConn = get(this, `app.${ns}.config.dobo.schemaConnection.${base}`)
   if (forcedConn) mod.connection = forcedConn
   if (!mod.connection) mod.connection = 'default'
@@ -30,7 +30,7 @@ async function handler ({ file, alias, ns }) {
     })
   }
   mod.feature = feats
-  if ((mod.properties ?? []).length === 0) this.fatal('Schema \'%s\' doesn\'t have properties at all', mod.name)
+  if ((mod.properties ?? []).length === 0) this.fatal('noPropsFoundOnSchema%s', mod.name)
   // schema extender
   await eachPlugins(async function (opts) {
     const glob = `${opts.dir}/dobo/extend/${mod.ns}/schema/${base}.*`
@@ -71,7 +71,7 @@ async function collectSchemas () {
   const { eachPlugins } = this.app.bajo
   const { isEmpty } = this.app.bajo.lib._
   const result = await eachPlugins(handler, { glob: 'schema/*.*', prefix: this.name })
-  if (isEmpty(result)) this.log.warn('No %s found!', this.print.write('schema'))
+  if (isEmpty(result)) this.log.warn('notFound%s', this.print.write('schema'))
   else await sanitizeSchema.call(this, result)
 }
 

package/lib/generic-prop-sanitizer.js

@@ -5,11 +5,6 @@ async function genericPropSanitizer ({ prop, schema, driver }) {
   const { has, get, each } = this.app.bajo.lib._
   const def = this.propType[prop.type]
   // detect from drivers
-  /*
-  if (prop.name === 'id' && ['smallint', 'integer'].includes(prop.type) && driver.driver !== 'knex') {
-    fatal('Integer types of ID only supported by knex driver')
-  }
-  */
   if (prop.type === 'string') {
     def.minLength = prop.minLength ?? 0
     def.maxLength = prop.maxLength ?? 255
@@ -25,13 +20,11 @@ async function genericPropSanitizer ({ prop, schema, driver }) {
     }
     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))
+      this.fatal('unsupportedAllowedChoices%s%s%s%s%s', p, prop[p], prop.name, schema.name, join(def.choices))
     }
   })
   if (prop.index && !indexTypes.includes(prop.index.type)) {
-    this.fatal('Unsupported index type %s for \'%s@%s\'. Allowed choices: %s',
-      prop.index.type, prop.name, schema.name, join(indexTypes))
+    this.fatal('unsupportedIndexType%s%s%s%s', prop.index.type, prop.name, schema.name, join(indexTypes))
   }
 }
 

package/lib/mem-db/instantiate.js

@@ -24,7 +24,7 @@ async function instantiate ({ connection, schemas, noRebuild }) {
       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)
+      this.fatal('cantLoad%s%s', schema.name, err.message)
     }
   }
   setInterval(() => {

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

@@ -3,7 +3,7 @@ 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)
+  if (exist.data) throw this.error('recordExists%s%s', body.id, schema.name)
   this.memDb.storage[schema.name].push(body)
   if (noResult) return
   return { data: body }

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

@@ -2,7 +2,7 @@ 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 })
+  if (!result && thrownNotFound) throw this.error('recordNotFound%s%s', id, schema.name, { statusCode: 404 })
   return { data: result }
 }
 

package/lib/mem-db/start.js

@@ -9,10 +9,10 @@ async function start () {
     return names.includes(s.connection)
   })
   if (schemas.length === 0) return
-  this.log.debug('Adding fixture for memory database')
+  this.log.debug('addingFixtureToMemDb')
   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)
+      this.log.warn('addingMemoryPersistenceIgnored', schema.name)
       continue
     }
     let { success, error } = await addFixtures.call(this, schema.name)

package/lib/resolve-method.js

@@ -4,11 +4,11 @@ async function resolveMethod (name, method, options = {}) {
   const { camelCase } = this.app.bajo.lib._
   const { schema, driver, connection } = this.getInfo(name)
   const [group, action] = method.split('-')
-  if (!options.force && (schema.disabled ?? []).includes(action)) throw this.error('Method \'%s@%s\' is disabled', camelCase(method), name)
+  if (!options.force && (schema.disabled ?? []).includes(action)) throw this.error('methodIsDisabled%s%s', 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)
+  if (!fs.existsSync(file)) throw this.error('methodUnsupported%s%s', camelCase(method), name)
   const handler = await importModule(file)
   return { handler, schema, driver, connection }
 }

package/lib/sanitize-schema.js

@@ -4,7 +4,7 @@ async function sanitizeFeature (item) {
   const { get, isPlainObject, mergeWith, isArray } = this.app.bajo.lib._
   for (const f of item.feature) {
     const feature = get(this.feature, f.name) // source from collectFeature
-    if (!feature) this.fatal('Unknown feature \'%s@%s\'', f.name, item.name)
+    if (!feature) this.fatal('unknownFeature%s%s', f.name, item.name)
     let [ns, path] = f.name.split('.')
     if (!path) ns = this.name
     const input = await feature.call(this.app[ns], f)
@@ -22,14 +22,14 @@ async function sanitizeFeature (item) {
 
 async function sanitizeIndexes (item) {
   for (const idx of item.indexes) {
-    if (!(typeof idx.fields === 'string' || Array.isArray(idx.fields))) this.fatal('Only accept array of field names or single string of field name \'%s@%s\'', 'indexes', item.name)
+    if (!(typeof idx.fields === 'string' || Array.isArray(idx.fields))) this.fatal('onlyAccepFields%s%s', 'indexes', item.name)
   }
 }
 
 async function sanitizeFullText (item) {
   for (const f of item.fullText.fields ?? []) {
     const prop = item.properties.find(p => p.name === f)
-    if (!prop) this.fatal('Invalid field name \'%s@%s\'', f, item.name)
+    if (!prop) this.fatal('invalidFieldName%s%s', f, item.name)
     // if (prop.type !== 'text') fatal.call(this, 'Fulltext index only available for field type \'text\' in \'%s@%s\'', f, item.name)
   }
 }
@@ -39,7 +39,7 @@ async function sanitizeSchema (items) {
   const { map, keys, findIndex, find, each, isString, get, isPlainObject, camelCase, uniq, filter } = this.app.bajo.lib._
   const propTypes = keys(this.propType)
   const schemas = []
-  this.log.debug('Loading DB schemas')
+  this.log.debug('loadingDbSchemas')
   for (const k in items) {
     this.log.trace('- %s (%d)', k, keys(items[k]).length)
     for (const f in items[k]) {
@@ -187,7 +187,7 @@ async function sanitizeSchema (items) {
   }
   this.schemas = schemas
   freeze(this.schemas)
-  this.log.debug('Loaded schemas: %s', join(map(this.schemas, 'name')))
+  this.log.debug('loadedSchemas%s', join(map(this.schemas, 'name')))
 }
 
 export default sanitizeSchema

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dobo",
-  "version": "1.0.13",
+  "version": "1.0.15",
   "description": "Database ORM/ODM for Bajo Framework",
   "main": "index.js",
   "scripts": {