dobo 1.0.13 → 1.0.14

package/bajo/init.js

@@ -6,7 +6,7 @@ import collectSchemas from '../lib/collect-schemas.js'
 async function checkType (item, items) {
   const { filter } = this.app.bajo.lib._
   const existing = filter(items, { type: 'dobo:memory' })
-  if (existing.length > 1) this.fatal('There could only be one connection type \'%s\'', item.type)
+  if (existing.length > 1) this.fatal('onlyOneConnType%s', item.type)
 }
 
 async function init () {
@@ -21,7 +21,7 @@ async function init () {
     })
   }
   this.connections = await buildCollections({ ns: this.name, container: 'connections', handler: collectConnections, dupChecks: ['name', checkType] })
-  if (this.connections.length === 0) this.log.warn('No %s found!', this.print.write('connection'))
+  if (this.connections.length === 0) this.log.warn('notFound%s', this.print.write('connection'))
   await collectFeature.call(this)
   await collectSchemas.call(this)
 }

package/bajo/method/attachment/copy-uploaded.js

@@ -5,11 +5,11 @@ async function copyUploaded (name, id, { req, setField, setFile, mimeType, stats
   name = this.attachmentPreCheck(name)
   if (!name) {
     if (silent) return
-    throw this.error('Name must be provided')
+    throw this.error('isMissing%s', this.print.write('field.name'))
   }
   if (!this.bajoWeb) {
     if (silent) return
-    throw this.error('Plugin \'%s\' is missing')
+    throw this.error('missingPlugin%s')
   }
   const { dir, files } = await this.bajoWeb.getUploadedFiles(req.id, false, true)
   const result = []

package/bajo/method/attachment/create.js

@@ -5,7 +5,7 @@ async function create (name, id, options = {}) {
   name = this.attachmentPreCheck(name)
   if (!name) return
   const { source, field, file } = options
-  if (!source) throw this.error('Invalid source')
+  if (!source) throw this.error('isMissing%s', this.print.write('field.source'))
   const baseDir = await this.attachmentGetPath(name, id, field, file, { dirOnly: true })
   const { fullPath, stats, mimeType, req } = options
 
@@ -20,7 +20,7 @@ async function create (name, id, options = {}) {
     file
   }
   await mergeAttachmentInfo.call(this, rec, dest, { mimeType, fullPath, stats })
-  if (req && req.flash) req.flash('notify', req.t('Attachment successfully uploaded'))
+  if (req && req.flash) req.flash('notify', req.t('attachmentUploaded'))
   return rec
 }
 

package/bajo/method/attachment/remove.js

@@ -5,7 +5,7 @@ async function remove (name, id, field, file, options = {}) {
   const path = await this.attachmentGetPath(name, id, field, file)
   const { req } = options
   await fs.remove(path)
-  if (req && req.flash) req.flash('notify', req.t('Attachment successfully removed'))
+  if (req && req.flash) req.flash('notify', req.t('attachmentRemoved'))
 }
 
 export default remove

package/bajo/method/get-schema.js

@@ -3,7 +3,7 @@ function getSchema (input, cloned = true) {
   let name = isPlainObject(input) ? input.name : input
   name = this.app.bajo.pascalCase(name)
   const schema = find(this.schemas, { name })
-  if (!schema) throw this.error('Unknown model/schema \'%s\'', name)
+  if (!schema) throw this.error('unknownModelSchema%s', name)
   return cloned ? cloneDeep(schema) : schema
 }
 

package/bajo/method/model/exists.js

@@ -16,7 +16,7 @@ async function exists (name, thrown, options = {}) {
     await runHook(`${this.name}.${camelCase(name)}:afterModelExists`, exist, options)
     await runHook(`${this.name}:afterModelExists`, schema, exist, options)
   }
-  if (!exist && thrown) throw this.error('Model doesn\'t exist yet. Please do model rebuild first')
+  if (!exist && thrown) throw this.error('modelNotExists%s')
   cache[name] = exist
   return exist
 }

package/bajo/method/prep-pagination.js

@@ -42,7 +42,7 @@ function buildSort (input, schema, allowSortUnindexed) {
     if (schema) {
       const items = keys(sort)
       each(items, i => {
-        if (!schema.sortables.includes(i) && !allowSortUnindexed) throw this.error('Sort on unindexed field: \'%s@%s\'', i, schema.name)
+        if (!schema.sortables.includes(i) && !allowSortUnindexed) throw this.error('sortOnUnindexedField%s%s', i, schema.name)
         // if (schema.fullText.fields.includes(i)) throw this.error('Can\'t sort on full-text index: \'%s@%s\'', i, schema.name)
       })
     }

package/bajo/method/record/create.js

@@ -50,7 +50,7 @@ async function create (name, input, opts = {}) {
   record = await handler.call(this.app[driver.ns], { schema, body: nbody, options })
   if (options.req) {
     if (options.req.file) await handleAttachmentUpload.call(this, { name: schema.name, id: body.id, body, options, action: 'create' })
-    if (options.req.flash && !options.noFlash) options.req.flash('notify', options.req.t('Record successfully created'))
+    if (options.req.flash && !options.noFlash) options.req.flash('notify', options.req.t('recordCreated'))
   }
   if (!noFeatureHook) await execFeatureHook.call(this, 'afterCreate', { schema, body, record })
   if (!noHook) {

package/bajo/method/record/remove.js

@@ -20,7 +20,7 @@ async function remove (name, id, opts = {}) {
   const record = await handler.call(this.app[driver.ns], { schema, id, options })
   if (options.req) {
     if (options.req.file) await handleAttachmentUpload.call(this, { name: schema.name, id, options, action: 'remove' })
-    if (options.req.flash && !options.noFlash) options.req.flash('notify', options.req.t('Record successfully removed'))
+    if (options.req.flash && !options.noFlash) options.req.flash('notify', options.req.t('recordRemoved'))
   }
   if (!noHook) {
     await runHook(`${this.name}.${camelCase(name)}:afterRecordRemove`, id, options, record)

package/bajo/method/record/update.js

@@ -40,7 +40,7 @@ async function update (name, id, input, opts = {}) {
   const record = await handler.call(this.app[driver.ns], { schema, id, body: nbody, options })
   if (options.req) {
     if (options.req.file) await handleAttachmentUpload.call(this, { name: schema.name, id, body, options, action: 'update' })
-    if (options.req.flash && !options.noFlash) options.req.flash('notify', options.req.t('Record successfully updated'))
+    if (options.req.flash && !options.noFlash) options.req.flash('notify', options.req.t('recordUpdated'))
   }
   if (!noFeatureHook) await execFeatureHook.call(this, 'afterUpdate', { schema, body: nbody, record })
   if (!noHook) {

package/bajo/method/sanitize/date.js

@@ -5,7 +5,7 @@ function sanitizeDate (value, { input, output, silent = true } = {}) {
   const dt = dayjs(value, input)
   if (!dt.isValid()) {
     if (silent) return -1
-    throw this.error('Invalid date')
+    throw this.error('invalidDate')
   }
   if (output === 'native' || !output) return dt.toDate()
   return dt.format(output)

package/bajo/method/stat/histogram.js

@@ -6,7 +6,7 @@ async function histogram (name, filter = {}, options = {}) {
   const { runHook, join } = this.app.bajo
   const { dataOnly = true, noHook, type } = options
   options.dataOnly = false
-  if (!types.includes(type)) throw this.error('Histogram type must be one of these: %s', join(types))
+  if (!types.includes(type)) throw this.error('histogramTypeMusBe%s', join(types))
   await this.modelExists(name, true)
   const { handler, schema, driver } = await resolveMethod.call(this, name, 'stat-histogram', options)
   filter.query = await this.buildQuery({ filter, schema, options }) ?? {}

package/bajo/method/validate.js

@@ -150,7 +150,7 @@ async function validate (value, joiSchema, { ns, fields, extFields, params } = {
   try {
     return await joiSchema.validateAsync(value, params)
   } catch (err) {
-    throw this.error('Validation Error', { details: err.details, values: err.values, ns, statusCode: 422, code: 'DB_VALIDATION' })
+    throw this.error('validationError', { details: err.details, values: err.values, ns, statusCode: 422, code: 'DB_VALIDATION' })
   }
 }
 

package/bajo/start.js

@@ -12,7 +12,7 @@ async function start (conns = 'all', noRebuild = true) {
     const schemas = filter(this.schemas, { connection: c.name })
     const mod = c.type === 'dobo:memory' ? memDbInstantiate : await importModule(`${ns}:/${this.name}/boot/instantiate.js`)
     await mod.call(this.app[ns], { connection: c, noRebuild, schemas })
-    this.log.trace('- Driver \'%s:%s\' instantiated', c.driver, c.name)
+    this.log.trace('driverInstantiated%s%s', c.driver, c.name)
   }
   await memDbStart.call(this)
 }

package/bajoCli/applet/connection.js

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

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/bajoI18N/resource/en-US.json

@@ -1,4 +1,122 @@
 {
+  "isConnected%s%s": "[%s] '%s' is connected",
+  "errorOn%s%s": "[%s] Error on '%s': %s",
+  "isDestroyed%s%s": "[%s] '%s' is destroyed",
+  "loadedSchemas%s": "[%s] Loaded schemas: %s",
+  "loadSchema%s%s%d": "[%s] Load schema: %s (%d)",
+  "loadedConns%s%s": "[%s] Loaded connections: %s",
+  "unsupportedPropTypeIn%s%s": "Unsupported property type '%s' in '%s'",
+  "noSchemaFound": "No schema found!",
+  "enterSchemaName": "Enter schema name, separated by space:",
+  "noSchemaMatched": "No schema matched",
+  "schema%d": "Schema (%d)",
+  "schemasWillBeRebuiltContinue": "The above mentioned schema(s) will be rebuilt as model. Continue?",
+  "rebuilding%s": "Rebuilding '%s'...",
+  "noDbConn%s%s": "No DB connection '%s' for '%s'. Aborted!",
+  "errorDroppingModel%s%s": "Error dropping model '%s': %s",
+  "modelExistsNeedForce%s": "Model '%s' exists already. Can't rebuild without --force",
+  "modelCreated%s": "Model '%s' successfully created",
+  "modelCreatedWithFixture%s%s%s": "Model '%s' successfully created, with fixture: added %s, rejected: %s",
+  "errorCreatingModel%s%s": "Error creating model '%s': %s",
+  "modelDropped%s": "Model '%s' successfully dropped",
+  "memoryDbSkipped%s%s": "DB '%s' for '%s' is a memory DB, skipped",
+  "modelBuiltOnthefly%s%s%s": "[%s] Model '%s@%s' successfully built on the fly",
+  "unableToBuildModel%s%s%s": "Unable to re-build model '%s' in '%s': %s",
+  "unknownSchema%s": "Unknown schema '%s'",
+  "payloadMustBeJson": "Payload must be a valid JSON",
+  "selectSchema": "Please select a schema:",
+  "enterJsonPayload": "Enter JSON payload:",
+  "payloadRequired": "Payload is required",
+  "invalidPayloadSyntax": "Invalid payload syntax",
+  "creatingRecord": "Creating record",
+  "enterRecordId:": "Enter record ID:",
+  "idIsRequired": "ID is required",
+  "gettingRecord": "Getting record",
+  "removingRecord": "Deleting record",
+  "cantFindSchema%s": "Can't find schema named %s",
+  "cantFind%s%s": "Can't find %s named %s",
+  "recordNotFound%s%s": "Record '%s@%s' not found",
+  "invalidSchema%s": "Invalid schema '%s'",
+  "noPropsFoundOnSchema%s": "Schema '%s' doesn't have any property at all",
+  "fieldIdReserved%s": "Field 'id@%s' is a reserved column and should not added manually",
+  "missingPropType%s%s": "Property type for '%s@%s' is missing",
+  "unsupportedPropType%s%s%s": "Unsupported property type '%s@%s' in '%s'",
+  "unknownConn%s%s": "Unknown connection '%s@%s'",
+  "fieldIsRequired%s%s": "Column '%s@%s' is required",
+  "keyIsRequired%s": "Key '%s' is required",
+  "enterQueryIfAny": "Please enter your query (if any):",
+  "findingRecords": "Finding records",
+  "recordExists%s%s": "Record '%s@%s' exists already",
+  "fieldGroupAggregateMissing": "Field to group aggregate is missing",
+  "fieldCalcAggregateMissing": "Field to calculate aggregate is missing",
+  "baseFieldForHistogramMissing": "Base field for histogram must be provided",
+  "unknownBaseFieldForHistogram%s": "Unknown base field for histogram '%s'",
+  "fieldTypeMustBeDatetime%s%s": "Field type '%s@%s' must be a datetime field",
+  "groupFieldToAggregateMissing": "Group field to aggregate is missing",
+  "unknownGroupField%s%s": "Unknown group field '%s@%s'",
+  "grupFieldMustBeNumber": "Group field must be of type integer, smallint or float",
+  "unsupportedAggregateType%s": "Unsupported aggregate type: '%s'",
+  "keyIsRequired%s%s": "'%s@%s' key is required",
+  "fulltextNeedIntegerId%s%s": "Full text index need integer type primary id in '%s@%s'",
+  "unsupportedAggregate%s": "Unsupported aggregate '%s'",
+  "unsupportedAllowedChoices%s%s%s%s%s": "Unsupported %s '%s' for '%s@%s'. Allowed choices: %s",
+  "methodIsDisabled%s%s": "Method '%s@%s' is disabled",
+  "invalidModelForPersistence%s": "Invalid model for persistence: %s",
+  "cantLoad%s%s": "Can't load %s: %s",
+  "noRecordFound": "No record found",
+  "recordsFound%d": "%d record(s) found",
+  "add": "Add",
+  "edit": "Edit",
+  "delete": "Delete",
+  "export": "Export",
+  "query": "Query",
+  "queryBuilder": "Query Builder",
+  "list": "List",
+  "submitQuery": "Submit Query",
+  "dataExport": "Data Export",
+  "recordCreated": "Record successfully created",
+  "recordRemoved": "Record successfully removed",
+  "recordUpdated": "Record successfully updated",
+  "attachmentUploaded": "Attachment successfully uploaded",
+  "attachmentRemoved": "Attachment successfully removed",
+  "unknownModelSchema%s": "Unknown model/schema '%s'",
+  "sortOnUnindexedField%s%s": "Sort on unindexed field: '%s@%s'",
+  "modelNotExists%s": "Model '%s' doesn't exist yet. Please do model rebuild first",
+  "invalidDate": "Invalid date",
+  "histogramTypeMusBe%s": "Histogram type must be one of these: %s",
+  "methodUnsupported%s%s": "Method '%s@%s' is unsupported",
+  "uniqueConstraintError": "Unique constraint error",
+  "taskMustHaveModel%s": "Task must have %s model",
+  "driverNotInstalled%s": "Problem with '%s' driver file. Not installed yet?",
+  "generalDbError": "General Database Error",
+  "dbConstrainError": "Database Constraint Error",
+  "onlySupportThese%s": "Only support one of these: %s",
+  "isMissing%s": "%s is missing",
+  "notFound%s": "No %s found!",
+  "clientInstanceNotConnected%s": "Client instance not connected '%s@%s'. Skipped!",
+  "proxiedConnBound%s": "'%s' is bound to a proxied connection, skipped!'",
+  "addingMemoryPersistenceIgnored": "'%s' is a memory persistence model. Adding records from fixture is ignored!",
+  "onlyOneConnType%s": "There could only be one connection type '%s'",
+  "mustValidDbType": "Connection must have a valid DB type",
+  "unsupportedDbType%s": "Unsupported DB type '%s'",
+  "driverMustProvideDbType": "A DB driver must provide at least one database type",
+  "driverMustHaveName": "A DB driver must have a driver name",
+  "dbTypeAlreadySupportedByDriver%s%s": "Database type '%s' already supported by driver '%s'",
+  "featureNotAsync%s": "Feature '%s' should be an async function",
+  "unsupportedIndexType%s%s%s%s": "Unsupported index type %s for '%s@%s'. Allowed choices: %s",
+  "unknownFeature%s%s": "'Unknown feature '%s@%s'",
+  "onlyAccepFields%s%s": "Only accept array of field names or single string of field name '%s@%s'",
+  "invalidFieldName%s%s": "Invalid field name '%s@%s'",
+  "error%s": "Error: %s",
+  "succeedFailSkip%d%d%d": "Done! Succeded: %d, failed: %s, skipped: %d",
+  "chooseConn": "Please choose a connection:",
+  "sureContinue": "Are you sure to continue?",
+  "loadingDbFeature": "Loading DB feature",
+  "totalLoadedFeatures%d": "Total loaded features: %d",
+  "loadingDbSchemas": "Loading DB schemas",
+  "addingFixtureToMemDb": "Adding fixture for memory database",
+  "recordsAdded%s%d%d": "%s: %d of %d records added",
+  "driverInstantiated%s%s": "- Driver '%s:%s' instantiated",
   "field": {
     "id": "ID",
     "code": "Kode",
@@ -61,32 +179,37 @@
     "cycle": "Cycle",
     "default": "Default"
   },
+  "validationError": "Kesalahan Validasi",
   "validation": {
-    "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"
+    "any": {
+      "required": "Required",
+      "only": "Must match with {{ref}}"
+    },
+    "string": {
+      "alphanum": "Must only contain alpha-numeric characters",
+      "base": "Must be a string",
+      "base64": "Must be a valid base64 string",
+      "creditCard": "Must be a credit card",
+      "dataUri": "Must be a valid dataUri string",
+      "domain": "Must contain a valid domain name",
+      "email": "Must be a valid email",
+      "empty": "Required",
+      "guid": "Must be a valid GUID",
+      "hex": "Must only contain hexadecimal characters",
+      "hexAlign": "Hex decoded representation must be byte aligned",
+      "hostname": "Must be a valid hostname",
+      "ip": "must be a valid ip address with a {{cidr}} CIDR",
+      "ipVersion": "Must be a valid ip address of one of the following versions {{version}} with a {{cidr}} CIDR",
+      "isoDate": "Must be in iso format",
+      "isoDuration": "Must be a valid ISO 8601 duration",
+      "length": "Length must be {{limit}} characters long",
+      "lowercase": "Must only contain lowercase characters",
+      "max": "Length must be less than or equal to {{limit}} characters long",
+      "min": "Length must be at least {{limit}} characters long",
+      "token": "Must only contain alpha-numeric and underscore characters",
+      "trim": "Must not have leading or trailing whitespace",
+      "uri": "Must be a valid uri",
+      "uppercase": "Must only contain uppercase characters"
+    }
   }
 }

package/bajoI18N/resource/id.json

@@ -1,77 +1,120 @@
 {
-  "[%s] '%s' is connected": "[%s] '%s' telah tersambung",
-  "[%s] Error on '%s': %s": "[%s] Kesalahan pada '%s': %s",
-  "[%s] '%s' is destroyed": "[%s] '%s' telah dimusnahkan",
-  "[%s] Loaded schemas: %s": "[%s] Skema termuat: %s",
-  "[%s] Load schema: %s (%d)": "[%s] Muat skema: %s (%d)",
-  "[%s] Loaded connections: %s": "[%s] Koneksi termuat: %s",
-  "Unsupported property type '%s' in '%s'": "Tipe properti '%s' di '%s' tidak didukung",
-  "No schema found!": "Tidak ditemukan skema!",
-  "Enter schema name(s), separated by space:": "Masukkan nama skema, dipisah dengan spasi:",
-  "No schema matched": "Tidak ditemukan skema yang cocok",
-  "Schema (%d)": "Skema (%d)",
-  "The above mentioned schema(s) will be rebuilt & modeled. Continue?": "Semua skema tersebut diatas akan dibuat ulang sebagai model. Anda yakin?",
-  "Rebuilding '%s'...": "Pembuatan ulang '%s'...",
-  "No database connection '%s' for '%s'. Aborted!'": "Tidak ada koneksi database '%s' untuk '%s'. Batalkan!",
-  "Error on dropping model '%s': %s": "Gagal menghapus model '%s': %s",
-  "Model '%s' exists. Won't rebuild without --force": "Model '%s' telah ada. Tidak dilakukan pembuatan ulang tanpa --force",
-  "Model '%s' successfully created": "Model '%s' sukses dibuat",
-  "Error on creating model '%s': %s": "Gagal membuat model '%s': %s",
-  "Model '%s' successfully dropped": "Model '%s' sukses dihapus",
-  "Db '%s' for '%s' is a memory database, skipped": "Db '%s' untuk '%s' adalah database memori, lewati",
-  "[%s] Model '%s@%s' successfully built on the fly": "[%s] Model '%s@%s' sukses dibuat ulang on the fly",
-  "Unable to build model '%s@%s': %s": "Gagal membuat ulang model '%s' di '%s': %s",
-  "Unknown schema '%s'": "Skema '%s' tidak dikenal",
-  "Payload must be a valid JSON object": "Data harus berupa obyek JSON yang valid",
-  "Please select a schema:": "Silahkan masukkan sebuah skema:",
-  "Enter JSON payload:": "Masukkan data JSON:",
-  "Payload is required": "Data harus diisi",
-  "Invalid payload syntax": "Sintak data tidak valid",
-  "Creating record": "Pembuatan data",
-  "Enter record ID:": "Masukkan ID data:",
-  "ID is required": "ID harus diisi",
-  "Getting record": "Mengambil data",
-  "Removing record": "Menghapus data",
-  "Can't find schema named %s": "Tidak bisa menemukan skema dengan nama %s",
-  "Record '%s@%s' not found!": "Data '%s@%s' tidak ditemukan",
-  "Invalid schema '%s'": "Skema '%s' tidak valid",
-  "Schema '%s' doesn't have properties at all": "Skema '%s' tidak memiliki properti sama sekali",
-  "Field 'id@%s' is a reserved field and should not be added manually": "Kolom 'id@%s' adalah kolom ter-reservasi dan seharusnya tidak ditambahkan secara manual",
-  "Missing property type for '%s@%s'": "Tipe properti untuk '%s@%s' tidak ditemukan",
-  "Unsupported property type '%s@%s' in '%s'": "Tipe properti '%s@%s' di '%s' tidak didukung",
-  "Unknown connection '%s@%s'": "Koneksi '%s@%s' tidak dikenal",
-  "Field '%s@%s' is required": "Kolom '%s@%s' harus diisi",
-  "'%s' key is required": "Kunci '%s' harus diisi",
-  "Please enter a query (if any):": "Silahkan masukkan kueri (jika ada):",
-  "Finding record(s)": "Temukan data",
-  "Record '%s@%s' exists already!": "Data '%s@%s' sudah ada",
-  "Field to group aggregate is missing": "Field to group aggregate is missing",
-  "Field to calculate aggregate is missing": "Field to calculate aggregate is missing",
-  "Base field for histogram must be provided": "Base field for histogram must be provided",
-  "Unknown base field for histogram '%s'": "Unknown base field for histogram '%s'",
-  "Field type '%s@%s' must be a datetime field": "Field type '%s@%s' must be a datetime field",
-  "Group field to aggregate is missing": "Group field to aggregate is missing",
-  "Unknown group field '%s@%s'": "Unknown group field '%s@%s'",
-  "Group field must be of type integer, smallint or float": "Group field must be of type integer, smallint or float",
-  "Unsupported aggregate type: '%s'": "Unsupported aggregate type: '%s'",
-  "'%s@%s' key is required": "'%s@%s' key is required",
-  "Full text index need integer type primary id in '%s@%s'": "Full text index need integer type primary id in '%s@%s'",
-  "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",
+  "isConnected%s%s": "[%s] '%s' telah tersambung",
+  "errorOn%s%s": "[%s] Kesalahan pada '%s': %s",
+  "isDestroyed%s%s": "[%s] '%s' telah dimusnahkan",
+  "loadedSchemas%s": "[%s] Skema termuat: %s",
+  "loadSchema%s%s%d": "[%s] Muat skema: %s (%d)",
+  "loadedConns%s%s": "[%s] Koneksi termuat: %s",
+  "unsupportedPropTypeIn%s%s": "Tipe properti '%s' di '%s' tidak didukung",
+  "noSchemaFound": "Tidak ditemukan skema!",
+  "enterSchemaName": "Masukkan nama skema, dipisah dengan spasi:",
+  "noSchemaMatched": "Tidak ditemukan skema yang cocok",
+  "schema%d": "Skema (%d)",
+  "schemasWillBeRebuiltContinue": "Semua skema tersebut diatas akan dibuat ulang sebagai model. Anda yakin?",
+  "rebuilding%s": "Pembuatan ulang '%s'...",
+  "noDbConn%s%s": "Tidak ada koneksi database '%s' untuk '%s'. Batalkan!",
+  "errorDroppingModel%s%s": "Gagal menghapus model '%s': %s",
+  "modelExistsNeedForce%s": "Model '%s' telah ada. Tidak dilakukan pembuatan ulang tanpa --force",
+  "modelCreated%s": "Model '%s' sukses dibuat",
+  "errorCreatingModel%s%s": "Gagal membuat model '%s': %s",
+  "modelDropped%s": "Model '%s' sukses dihapus",
+  "memoryDbSkipped%s%s": "Db '%s' untuk '%s' adalah database memori, lewati",
+  "modelBuiltOnthefly%s%s%s": "[%s] Model '%s@%s' sukses dibuat ulang on the fly",
+  "unableToBuildModel%s%s%s": "Gagal membuat ulang model '%s' di '%s': %s",
+  "unknownSchema%s": "Skema '%s' tidak dikenal",
+  "payloadMustBeJson": "Data harus berupa obyek JSON yang valid",
+  "selectSchema": "Silahkan masukkan sebuah skema:",
+  "enterJsonPayload": "Masukkan data JSON:",
+  "payloadRequired": "Data harus diisi",
+  "invalidPayloadSyntax": "Sintak data tidak valid",
+  "creatingRecord": "Pembuatan data",
+  "enterRecordId:": "Masukkan ID data:",
+  "idIsRequired": "ID harus diisi",
+  "gettingRecord": "Mengambil data",
+  "removingRecord": "Menghapus data",
+  "cantFindSchema%s": "Tidak bisa menemukan skema dengan nama %s",
+  "recordNotFound%s%s": "Data '%s@%s' tidak ditemukan",
+  "invalidSchema%s": "Skema '%s' tidak valid",
+  "noPropsFoundOnSchema%s": "Skema '%s' tidak memiliki properti sama sekali",
+  "fieldIdReserved%s": "Kolom 'id@%s' adalah kolom ter-reservasi dan seharusnya tidak ditambahkan secara manual",
+  "missingPropType%s%s": "Tipe properti untuk '%s@%s' tidak ditemukan",
+  "unsupportedPropType%s%s%s": "Tipe properti '%s@%s' di '%s' tidak didukung",
+  "unknownConn%s%s": "Koneksi '%s@%s' tidak dikenal",
+  "fieldIsRequired%s%s": "Kolom '%s@%s' harus diisi",
+  "keyIsRequired%s": "Kunci '%s' harus diisi",
+  "enterQueryIfAny": "Silahkan masukkan kueri (jika ada):",
+  "findingRecords": "Temukan data",
+  "recordExists%s%s": "Data '%s@%s' sudah ada",
+  "fieldGroupAggregateMissing": "Field to group aggregate is missing",
+  "fieldCalcAggregateMissing": "Field to calculate aggregate is missing",
+  "baseFieldForHistogramMissing": "Base field for histogram must be provided",
+  "unknownBaseFieldForHistogram%s": "Unknown base field for histogram '%s'",
+  "fieldTypeMustBeDatetime%s%s": "Field type '%s@%s' must be a datetime field",
+  "groupFieldToAggregateMissing": "Group field to aggregate is missing",
+  "unknownGroupField%s%s": "Unknown group field '%s@%s'",
+  "grupFieldMustBeNumber": "Group field must be of type integer, smallint or float",
+  "unsupportedAggregateType%s": "Unsupported aggregate type: '%s'",
+  "keyIsRequired%s%s": "'%s@%s' key is required",
+  "fulltextNeedIntegerId%s%s": "Full text index need integer type primary id in '%s@%s'",
+  "unsupportedAggregate%s": "Unsupported aggregate '%s'",
+  "unsupportedAllowedChoices%s%s%s%s%s": "Unsupported %s '%s' for '%s@%s'. Allowed choices: %s",
+  "methodIsDisabled%s%sMethod": "Metode '%s@%s' dinonaktifkan",
+  "invalidModelForPersistence%s": "Model untuk penyimpanan tidak valid: %s",
+  "cantLoad%s%s": "Tidak bisa memuat %s: %s",
+  "noRecordFound": "Tidak ditemukan data",
+  "recordsFound%d": "Ditemukan %d data",
+  "add": "Tambah",
+  "edit": "Ubah",
+  "delete": "Hapus",
+  "export": "Ekspor",
+  "query": "Kueri",
+  "queryBuilder": "Pembuat Kueri",
+  "list": "Daftar",
+  "submitQuery": "Kirim Kueri",
+  "dataExport": "Ekspor Data",
+  "recordCreated": "Record successfully created",
+  "recordRemoved": "Record successfully removed",
+  "recordUpdated": "Record successfully updated",
+  "attachmentUploaded": "Attachment successfully uploaded",
+  "attachmentRemoved": "Attachment successfully removed",
+  "unknownModelSchema%s": "Unknown model/schema '%s'",
+  "sortOnUnindexedField%s%s": "Sort on unindexed field: '%s@%s'",
+  "modelNotExists%s": "Model '%s' doesn't exist yet. Please do model rebuild first",
+  "invalidDate": "Invalid date",
+  "histogramTypeMusBe%s": "Histogram type must be one of these: %s",
+  "methodUnsupported%s%s": "Method '%s@%s' is unsupported",
+  "uniqueConstraintError": "Unique constraint error",
+  "taskMustHaveModel%s": "Task must have %s model",
+  "driverNotInstalled%s": "Problem with '%s' driver file. Not installed yet?",
+  "generalDbError": "General Database Error",
+  "dbConstrainError": "Database Constraint Error",
+  "onlySupportThese%s": "Only support one of these: %s",
+  "isMissing%s": "%s is missing",
+  "notFound%s": "No %s found!",
+  "clientInstanceNotConnected%s": "Client instance not connected '%s@%s'. Skipped!",
+  "proxiedConnBound%s": "'%s' is bound to a proxied connection, skipped!'",
+  "addingMemoryPersistenceIgnored": "'%s' is a memory persistence model. Adding records from fixture is ignored!",
+  "onlyOneConnType%s": "There could only be one connection type '%s'",
+  "mustValidDbType": "Connection must have a valid DB type",
+  "unsupportedDbType%s": "Unsupported DB type '%s'",
+  "driverMustProvideDbType": "A DB driver must provide at least one database type",
+  "driverMustHaveName": "A DB driver must have a driver name",
+  "dbTypeAlreadySupportedByDriver%s%s": "Database type '%s' already supported by driver '%s'",
+  "featureNotAsync%s": "Feature '%s' should be an async function",
+  "unsupportedIndexType%s%s%s%s": "Unsupported index type %s for '%s@%s'. Allowed choices: %s",
+  "unknownFeature%s%s": "'Unknown feature '%s@%s'",
+  "onlyAccepFields%s%s": "Only accept array of field names or single string of field name '%s@%s'",
+  "invalidFieldName%s%s": "Invalid field name '%s@%s'",
+  "error%s": "Error: %s",
+  "succeedFailSkip%d%d%d": "Done! Succeded: %d, failed: %s, skipped: %d",
+  "chooseConn": "Please choose a connection:",
+  "sureContinue": "Are you sure to continue?",
+  "loadingDbFeature": "Loading DB feature",
+  "totalLoadedFeatures%d": "Total loaded features: %d",
+  "loadingDbSchemas": "Loading DB schemas",
+  "addingFixtureToMemDb": "Adding fixture for memory database",
+  "recordsAdded%s%d%d": "%s: %d of %d records added",
+  "driverInstantiated%s%s": "- Driver '%s:%s' instantiated",
   "field": {
     "id": "ID",
     "code": "Kode",
@@ -134,7 +177,7 @@
     "cycle": "Cycle",
     "default": "Default"
   },
-  "Validation Error": "Kesalahan Validasi",
+  "validationError": "Kesalahan Validasi",
   "validation": {
     "any": {
       "required": "Harus diisi/dipilih",

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.14",
   "description": "Database ORM/ODM for Bajo Framework",
   "main": "index.js",
   "scripts": {