dobo 2.0.1 → 2.2.0

package/method/record/remove.js

@@ -1,72 +0,0 @@
-import resolveMethod from '../../lib/resolve-method.js'
-import handleAttachmentUpload from '../../lib/handle-attachment-upload.js'
-import execFeatureHook from '../../lib/exec-feature-hook.js'
-
-/**
- * @typedef {Object} TRecordRemoveOptions
- * @see Dobo#recordRemove
- * @property {boolean} [dataOnly=true] - If ```true``` (default) returns deleted record. Otherwise {@link TRecordRemoveResult}
- * @property {boolean} [noHook=false] - If ```true```, no model's hook will be executed
- * @property {boolean} [noFeatureHook=false] - If ```true```, no model's feature hook will be executed
- * @property {boolean} [noResult=false] - If ```true```, returns nothing
- * @property {boolean} [fields=[]] - If not empty, return only these fields EXCLUDING hidden fields
- * @property {boolean} [hidden=[]] - Additional fields to hide, in addition the one set in model's schema
- * @property {boolean} [forceNoHidden=false] - If ```true```, hidden fields will be ignored and ALL fields will be returned
- */
-
-/**
- * Remove existing record by it's ID. All attachments bound to this record will also be removed forever.
- *
- * Example:
- * ```javascript
- * const { recordRemove } = this.app.dobo
- * const result = await recordRemove('CdbCountry', 'ID')
- * ```
- *
- * @method
- * @memberof Dobo
- * @async
- * @instance
- * @name recordRemove
- * @param {string} name - Model's name
- * @param {(string|number)} id - Record's ID
- * @param {TRecordRemoveOptions} [options={}]
- * @returns {(TRecordRemoveResult|Object)} Return the removed record if ```options.dataOnly``` is set. {@link TRecordRemoveResult} otherwise
- */
-async function remove (name, id, opts = {}) {
-  const { runHook } = this.app.bajo
-  const { clearModel } = this.cache ?? {}
-  const { cloneDeep, camelCase, omit } = this.app.lib._
-  delete opts.record
-  const options = cloneDeep(omit(opts, ['req', 'reply']))
-  options.req = opts.req
-  options.reply = opts.reply
-  options.dataOnly = options.dataOnly ?? true
-  const { fields, dataOnly, noHook, noResult, noFeatureHook, hidden, forceNoHidden } = options
-  options.dataOnly = false
-  await this.modelExists(name, true)
-  const { handler, schema, driver } = await resolveMethod.call(this, name, 'record-remove', options)
-  id = this.sanitizeId(id, schema)
-  if (!noHook) {
-    await runHook(`${this.ns}:beforeRecordRemove`, name, id, options)
-    await runHook(`${this.ns}.${camelCase(name)}:beforeRecordRemove`, id, options)
-  }
-  if (!noFeatureHook) await execFeatureHook.call(this, 'beforeRemove', { schema, id, options })
-  const record = options.record ?? (await handler.call(this.app[driver.ns], { schema, id, options }))
-  delete options.record
-  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('recordRemoved'))
-  }
-  if (clearModel) await clearModel({ model: name, id, options, record })
-  if (noResult) return
-  record.oldData = options.record ? options.record.oldData : (await this.pickRecord({ record: record.oldData, fields, schema, hidden, forceNoHidden }))
-  if (!noHook) {
-    await runHook(`${this.ns}.${camelCase(name)}:afterRecordRemove`, id, options, record)
-    await runHook(`${this.ns}:afterRecordRemove`, name, id, options, record)
-  }
-  if (!noFeatureHook) await execFeatureHook.call(this, 'afterRemove', { schema, id, options, record })
-  return dataOnly ? record.oldData : record
-}
-
-export default remove

package/method/record/update.js

@@ -1,104 +0,0 @@
-import resolveMethod from '../../lib/resolve-method.js'
-import checkUnique from '../../lib/check-unique.js'
-import handleAttachmentUpload from '../../lib/handle-attachment-upload.js'
-import execValidation from '../../lib/exec-validation.js'
-import execFeatureHook from '../../lib/exec-feature-hook.js'
-import singleRelRows from '../../lib/single-rel-rows.js'
-
-/**
- * @typedef {Object} TRecordUpdateOptions
- * @see Dobo#recordUpdate
- * @property {boolean} [dataOnly=true] - If ```true``` (default) returns record's object. Otherwise {@link TRecordUpdateResult}
- * @property {boolean} [noHook=false] - If ```true```, no model's hook will be executed
- * @property {boolean} [noFeatureHook=false] - If ```true```, no model's feature hook will be executed
- * @property {boolean} [noValidation=false] - If ```true```, no validation of data payload performed
- * @property {boolean} [noCheckUnique=false] - If ```true```, no unique validation for ID performed
- * @property {boolean} [noSanitize=false] - If ```true```, accept data payload as is without sanitization
- * @property {boolean} [noResult=false] - If ```true```, returns nothing
- * @property {boolean} [truncateString=true] - If ```true``` (default), string is truncated to its schema's ```maxLemngth```
- * @property {boolean} [partial=true] - If ```true``` (default), only updated values are saved. Otherwise replace all existing values with given payload
- * @property {boolean} [fields=[]] - If not empty, return only these fields EXCLUDING hidden fields
- * @property {boolean} [hidden=[]] - Additional fields to hide, in addition the one set in model's schema
- * @property {boolean} [forceNoHidden=false] - If ```true```, hidden fields will be ignored and ALL fields will be returned
- */
-
-/**
- * Update a record by it's ID and body payload
- *
- * Example:
- * ```javascript
- * const { recordUpdate } = this.app.dobo
- * const { body } = {
- *   name: 'Republic of Indonesia',
- *   phoneCode: '+62'
- * }
- * const result = await recordUpdate('CdbCountry', 'ID', body)
- * ```
- *
- * @method
- * @memberof Dobo
- * @async
- * @instance
- * @name recordUpdate
- * @param {string} name - Model's name
- * @param {(string|number)} id - Record's ID
- * @param {Object} body - Body payload
- * @param {TRecordUpdateOptions} [options={}]
- * @returns {(TRecordUpdateResult|Object)} Returns updated record if ```options.dataOnly``` is set. {@link TRecordUpdateResult} otherwise
- */
-async function update (name, id, input, opts = {}) {
-  const { isSet } = this.app.lib.aneka
-  const { runHook } = this.app.bajo
-  const { clearModel } = this.cache ?? {}
-  const { forOwn, find, cloneDeep, camelCase, omit, get } = this.app.lib._
-  delete opts.record
-  const options = cloneDeep(omit(opts, ['req', 'reply']))
-  options.req = opts.req
-  options.reply = opts.reply
-  options.dataOnly = options.dataOnly ?? true
-  input = cloneDeep(input)
-  const { fields, dataOnly, noHook, noValidation, noCheckUnique, noFeatureHook, noResult, noSanitize, partial = true, hidden, forceNoHidden } = options
-  options.dataOnly = true
-  options.truncateString = options.truncateString ?? true
-  await this.modelExists(name, true)
-  const { handler, schema, driver } = await resolveMethod.call(this, name, 'record-update', options)
-  id = this.sanitizeId(id, schema)
-  const extFields = get(options, 'validation.extFields', [])
-  let body = noSanitize ? input : await this.sanitizeBody({ body: input, schema, partial, strict: true, extFields })
-  delete body.id
-  if (!noHook) {
-    await runHook(`${this.ns}:beforeRecordUpdate`, name, id, body, options)
-    await runHook(`${this.ns}.${camelCase(name)}:beforeRecordUpdate`, id, body, options)
-  }
-  if (!noValidation) body = await execValidation.call(this, { name, body, options, partial })
-  if (!noCheckUnique) await checkUnique.call(this, { schema, body, id })
-  const nbody = {}
-  forOwn(body, (v, k) => {
-    if (v === undefined) return undefined
-    const prop = find(schema.properties, { name: k })
-    if (!prop) return undefined
-    if (options.truncateString && isSet(v) && ['string', 'text'].includes(prop.type)) v = v.slice(0, prop.maxLength)
-    nbody[k] = v
-  })
-  delete nbody.id
-  if (!noFeatureHook) await execFeatureHook.call(this, 'beforeUpdate', { schema, body: nbody, options })
-  const record = options.record ?? (await handler.call(this.app[driver.ns], { schema, id, body: nbody, options }))
-  delete options.record
-  if (isSet(options.rels)) await singleRelRows.call(this, { schema, record: record.data, 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('recordUpdated'))
-  }
-  if (clearModel) await clearModel({ model: name, id, body: nbody, options, record })
-  if (noResult) return
-  record.oldData = await this.pickRecord({ record: record.oldData, fields, schema, hidden, forceNoHidden })
-  record.data = await this.pickRecord({ record: record.data, fields, schema, hidden, forceNoHidden })
-  if (!noHook) {
-    await runHook(`${this.ns}.${camelCase(name)}:afterRecordUpdate`, id, nbody, options, record)
-    await runHook(`${this.ns}:afterRecordUpdate`, name, id, nbody, options, record)
-  }
-  if (!noFeatureHook) await execFeatureHook.call(this, 'afterUpdate', { schema, body: nbody, record })
-  return dataOnly ? record.data : record
-}
-
-export default update

package/method/record/upsert.js

@@ -1,51 +0,0 @@
-/**
- * Update a record by payload's ID. If no record is found by given ID, a new one will be created instead.
- *
- * Missing ID in payload always results a new record creation.
- * ```
- *
- * @method
- * @memberof Dobo
- * @async
- * @instance
- * @name recordUpsert
- * @param {string} name - Model's name
- * @param {Object} body - Body payload
- * @param {TRecordUpsertOptions} [options={}]
- * @returns {(TRecordUpdateResult|TRecordCreateResult|Object)} Returns updated/newly created record if ```options.dataOnly``` is set. {@link TRecordUpdateResult} or {@link TRecordCreateResult} otherwise
- */
-async function upsert (name, input, opts = {}) {
-  const { generateId } = this.app.bajo
-  const { find } = this.app.lib._
-  const { cloneDeep, omit, merge } = this.app.lib._
-  const { query, omitOnUpdate = [], omitOnCreate = [] } = opts
-  const options = cloneDeep(omit(opts, ['req', 'reply', 'query', 'omitOnUpdate', 'omitOnCreate']))
-  options.req = opts.req
-  options.reply = opts.reply
-  options.dataOnly = options.dataOnly ?? true
-  await this.modelExists(name, true)
-  const { schema } = this.getInfo(name)
-  const idField = find(schema.properties, { name: 'id' })
-  let id
-  if (idField.type === 'string') id = input.id ?? generateId()
-  else if (idField.type === 'integer') id = input.id ?? generateId('int')
-  id = this.sanitizeId(id, schema)
-  let old
-  let body
-  const o = { dataOnly: true, noHook: true, noCache: true, hidden: options.hidden, forceNoHidden: options.forceNoHidden }
-  if (query) {
-    old = await this.recordFindOne(name, { query }, o)
-  } else {
-    o.thrownNotFound = false
-    old = await this.recordGet(name, id, o)
-  }
-  if (old) {
-    body = merge(omit(old, ['id', 'createdAt', 'updatedAt', 'removedAt']), omit(input, omitOnUpdate))
-    return await this.recordUpdate(name, old.id, body, options)
-  }
-  if (!query) input.id = id
-  body = omit(input, omitOnCreate)
-  return await this.recordCreate(name, body, options)
-}
-
-export default upsert

package/method/sanitize/body.js

@@ -1,85 +0,0 @@
-/**
- * Sanitize payload body against schema
- *
- * @method
- * @memberof Dobo
- * @async
- * @param {Object} [options={}]
- * @param {Object} [options.body={}]
- * @param {Object} [options.schema={}]
- * @param {boolean} [options.partial=false]
- * @param {boolean} [options.strict=false]
- * @param {Array} [options.extFields=[]]
- * @returns {Object}
- */
-
-async function sanitizeBody ({ body = {}, schema = {}, partial, strict, extFields = [] }) {
-  const { isSet } = this.app.lib.aneka
-  const { dayjs } = this.app.lib
-  const { callHandler } = this.app.bajo
-  const { has, isString, isNumber, concat, isNaN } = this.app.lib._
-  const result = {}
-  for (const p of concat(schema.properties, extFields)) {
-    if (partial && !has(body, p.name)) continue
-    if (['object', 'array'].includes(p.type)) {
-      if (isString(body[p.name])) {
-        try {
-          result[p.name] = JSON.parse(body[p.name])
-        } catch (err) {
-          result[p.name] = null
-        }
-      } else {
-        try {
-          result[p.name] = JSON.parse(JSON.stringify(body[p.name]))
-        } catch (err) {}
-      }
-    } else result[p.name] = body[p.name]
-    if (isSet(body[p.name])) {
-      if (p.type === 'boolean') result[p.name] = result[p.name] === null ? null : (['true', true].includes(result[p.name]))
-      if (['float', 'double'].includes(p.type)) {
-        if (isNumber(body[p.name])) result[p.name] = body[p.name]
-        else if (strict) {
-          result[p.name] = Number(body[p.name])
-        } else {
-          result[p.name] = parseFloat(body[p.name]) || null
-        }
-      }
-      if (['integer', 'smallint'].includes(p.type)) {
-        if (isNumber(body[p.name])) result[p.name] = body[p.name]
-        else if (strict) {
-          result[p.name] = Number(body[p.name])
-        } else {
-          result[p.name] = parseInt(body[p.name]) || null
-        }
-      }
-      if (p.type === 'timestamp') {
-        if (!isNumber(body[p.name])) result[p.name] = -1
-        else {
-          const dt = dayjs.unix(body[p.name])
-          result[p.name] = dt.isValid() ? dt.unix() : -1
-        }
-      } else {
-        for (const t of ['datetime', 'date|YYYY-MM-DD', 'time|HH:mm:ss']) {
-          const [type, input] = t.split('|')
-          if (p.type === type) result[p.name] = this.sanitizeDate(body[p.name], { input })
-        }
-      }
-      if (['string', 'text'].includes(p.type)) result[p.name] = body[p.name] + ''
-    } else {
-      if (isSet(p.default)) {
-        result[p.name] = p.default
-        if (isString(p.default) && p.default.startsWith('handler:')) {
-          const [, ...args] = p.default.split(':')
-          if (args.length > 0) result[p.name] = await callHandler(args.join(':'))
-        } else {
-          if (['float', 'double'].includes(p.type)) result[p.name] = parseFloat(result[p.name])
-          if (['integer', 'smallint'].includes(p.type)) result[p.name] = parseInt(result[p.name])
-          if (isNaN(result[p.name])) result[p.name] = null
-        }
-      }
-    }
-  }
-  return result
-}
-
-export default sanitizeBody

package/method/sanitize/date.js

@@ -1,27 +0,0 @@
-/**
- * Sanitize value as a date/time value. Parse/format string using {@link https://day.js.org/docs/en/display/format|dayjs format}
- *
- * @method
- * @memberof Dobo
- * @param {(number|string)} value - Value to sanitize
- * @param {Object} [options={}] - Options object
- * @param {boolean} [options.silent=true] - If ```true``` (default) and value isn't valid, returns empty
- * @param {string} [options.inputFormat] - If provided, parse value using this option
- * @param {string} [options.outputFormat] - If not provided or ```native```, returns Javascript Date. Otherwise returns formatted date/time string
- * @returns {(string|Date)}
- */
-
-function sanitizeDate (value, { inputFormat, outputFormat, silent = true } = {}) {
-  const { dayjs } = this.app.lib
-  if (value === 0) return null
-  if (!outputFormat) outputFormat = inputFormat
-  const dt = dayjs(value, inputFormat)
-  if (!dt.isValid()) {
-    if (silent) return null
-    throw this.error('invalidDate')
-  }
-  if (outputFormat === 'native' || !outputFormat) return dt.toDate()
-  return dt.format(outputFormat)
-}
-
-export default sanitizeDate

package/method/sanitize/id.js

@@ -1,17 +0,0 @@
-/**
- * Sanitize id according it's schema
- *
- * @method
- * @memberof Dobo
- * @param {(number|string)} id
- * @param {Object} schema
- * @returns {(number|string)}
- */
-
-function sanitizeId (id, schema) {
-  const prop = schema.properties.find(p => p.name === 'id')
-  if (prop.type === 'integer') id = parseInt(id)
-  return id
-}
-
-export default sanitizeId

package/method/stat/aggregate.js

@@ -1,23 +0,0 @@
-import resolveMethod from '../../lib/resolve-method.js'
-
-async function aggregate (name, filter = {}, options = {}) {
-  const { runHook } = this.app.bajo
-  const { dataOnly = true, noHook, aggregate } = options
-  options.dataOnly = false
-  await this.modelExists(name, true)
-  const { handler, schema, driver } = await resolveMethod.call(this, name, 'stat-aggregate', options)
-  if (!noHook) {
-    await runHook(`${this.ns}:beforeStatAggregate`, name, aggregate, filter, options)
-    await runHook(`${this.ns}.${name}:beforeStatAggregate`, aggregate, filter, options)
-  }
-  filter.query = this.buildQuery({ filter, schema, options }) ?? {}
-  filter.match = this.buildMatch({ input: filter.match, schema, options }) ?? {}
-  const rec = await handler.call(this.app[driver.ns], { schema, filter, options })
-  if (!noHook) {
-    await runHook(`${this.ns}.${name}:afterStatAggregate`, aggregate, filter, options, rec)
-    await runHook(`${this.ns}:afterStatAggregate`, name, aggregate, filter, options, rec)
-  }
-  return dataOnly ? rec.data : rec
-}
-
-export default aggregate

package/method/stat/histogram.js

@@ -1,26 +0,0 @@
-import resolveMethod from '../../lib/resolve-method.js'
-
-const types = ['daily', 'monthly', 'yearly']
-
-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('histogramTypeMusBe%s', join(types))
-  await this.modelExists(name, true)
-  const { handler, schema, driver } = await resolveMethod.call(this, name, 'stat-histogram', options)
-  filter.query = this.buildQuery({ filter, schema, options }) ?? {}
-  filter.match = this.buildMatch({ input: filter.match, schema, options }) ?? {}
-  if (!noHook) {
-    await runHook(`${this.ns}:beforeStatHistogram`, name, type, filter, options)
-    await runHook(`${this.ns}.${name}:beforeStatHistogram`, type, filter, options)
-  }
-  const rec = await handler.call(this.app[driver.ns], { schema, type, filter, options })
-  if (!noHook) {
-    await runHook(`${this.ns}.${name}:afterStatHistogram`, type, filter, options, rec)
-    await runHook(`${this.ns}:afterStatHistogram`, name, type, filter, options, rec)
-  }
-  return dataOnly ? rec.data : rec
-}
-
-export default histogram