@mixd-id/web-scaffold 0.2.240706 → 0.2.250801010

package/src/utils/helpers.cjs

@@ -0,0 +1,635 @@
+const ceil = (num, precision = 0) => {
+  var p = Math.pow(10, precision)
+  var n = (num * p) * (1 + Number.EPSILON)
+  return Math.ceil(n) / p
+}
+
+const floor = (num, precision = 0) => {
+  var p = Math.pow(10, precision)
+  var n = (num * p) * (1 + Number.EPSILON)
+  return Math.floor(n) / p
+}
+
+const ftWildcard = (key) => {
+  if(key.indexOf('/') >= 0) return key
+
+  const term = key.replace(/[\-\+\*\<\>\@\(\)\~]/, ' ', 'gi')
+
+  const searchTerms = []
+  term.split(' ').forEach((txt) => {
+    if(txt.length >= 3){
+      searchTerms.push(`+${txt}*`)
+    }
+  })
+  return searchTerms.join(' ')
+}
+
+const moveFile = function(oldPath, newPath, callback) {
+  const fs = require("fs");
+
+  fs.rename(oldPath, newPath, function (err) {
+    if (err) {
+      if (err.code === 'EXDEV') {
+        copy();
+      } else {
+        callback(err);
+      }
+      return;
+    }
+    callback();
+  });
+
+  function copy() {
+    const fs = require("fs");
+
+    var readStream = fs.createReadStream(oldPath);
+    var writeStream = fs.createWriteStream(newPath);
+
+    readStream.on('error', callback);
+    writeStream.on('error', callback);
+
+    readStream.on('close', function () {
+      fs.unlink(oldPath, callback);
+    });
+
+    readStream.pipe(writeStream);
+  }
+}
+
+const round = (num, precision = 0) => {
+  var p = Math.pow(10, precision)
+  var n = (num * p) * (1 + Number.EPSILON)
+  return Math.round(n) / p
+}
+
+const sanitizeMobileNumber = (mobileNumber) => {
+  if(typeof mobileNumber !== 'string') return mobileNumber
+
+  if(mobileNumber.length > 0){
+    mobileNumber = mobileNumber.replace(/[\- ]/g, '')
+    if(mobileNumber.substring(0, 1) === '0') mobileNumber = '+62' + mobileNumber.substring(1)
+    if(mobileNumber.substring(0, 1) !== '+'){
+      if(mobileNumber.substring(0, 2) === '62')
+        mobileNumber = '+' + mobileNumber
+      else
+        mobileNumber = '+62' + mobileNumber
+    }
+    if(mobileNumber.length > 0){
+      mobileNumber = mobileNumber[0] + mobileNumber.slice(1).replace(/\D/g, '')
+    }
+  }
+
+  return mobileNumber
+}
+
+const saveBase64 = async(data, dir = '/storage/files/images') => {
+  if(data.indexOf(',') >= 0){
+    data = data.substring(data.indexOf(',') + 1)
+  }
+  const buffer = Buffer.from(data, 'base64');
+  return await saveBuffer(buffer, dir)
+}
+
+const saveBuffer = async(buffer, dir = '/storage/files/images') => {
+
+  const fs = require("fs");
+  const md5 = require('md5')
+
+  const { fileTypeFromBuffer } = await import('file-type')
+
+  const type = await fileTypeFromBuffer(buffer)
+
+  const storagePath = process.env.ROOT_PATH + dir
+  const ext = type && type.ext ? '.' + type.ext : ''
+  const filename = md5(buffer) + ext
+  const to = storagePath + '/' + filename
+
+  fs.writeFileSync(to, buffer)
+
+  return filename
+}
+
+const saveFromUrl = async(url, dir = '/storage/files/images') => {
+  const axios = require('axios')
+
+  const res = await axios({
+    method: 'GET',
+    url,
+    responseType: 'arraybuffer',
+  })
+  const buffer = Buffer.from(res.data)
+  return await saveBuffer(buffer, dir)
+}
+
+const sleep = ms => new Promise(r => setTimeout(r, ms))
+
+const strSlug = (title, separator) => {
+  if (typeof separator == 'undefined') separator = '-';
+
+  // Convert all dashes/underscores into separator
+  var flip = separator === '-' ? '_' : '-';
+  title = title.replace(flip, separator);
+
+  // Remove all characters that are not the separator, letters, numbers, or whitespace.
+  title = title.toLowerCase()
+    .replace(new RegExp('[^a-z0-9' + separator + '\\s]', 'g'), '');
+
+  // Replace all separator characters and whitespace by a single separator
+  title = title.replace(new RegExp('[' + separator + '\\s]+', 'g'), separator);
+
+  return title.replace(new RegExp('^[' + separator + '\\s]+|[' + separator + '\\s]+$', 'g'),'');
+}
+
+const strVars = (text, vars, opt = { emptyUndefined:true }) => {
+
+  (text.match(/\{.*?(?=\})\}/gi) ?? []).forEach((match) => {
+    const key = match.substring(1, match.length - 1)
+    const value = vars[key] ?? (opt?.emptyUndefined ? '' : `{${key}}`)
+    text = text.replace(match, value)
+  })
+
+  return text
+}
+
+const writeStorage = (path, content, append = false) => {
+
+  const fs = require("fs");
+
+  if(path.startsWith('/')) path = path.substring(1)
+
+  if(append){
+    fs.appendFileSync(process.env.ROOT_PATH + `/storage/${path}`, content)
+  }
+  else{
+    fs.writeFileSync(process.env.ROOT_PATH + `/storage/${path}`, content)
+  }
+}
+
+const bufferToStream = (buffer) => {
+  const { Duplex } = require('stream')
+  let stream = new Duplex()
+  stream.push(buffer)
+  stream.push(null)
+  return stream
+}
+
+const sequelizeChunk = async (model, opt, callback, chunkSize = 5000) => {
+
+  let offset = 0
+  let iter = 0
+  while(true){
+    const items = await model.findAll({
+      ...opt,
+      offset,
+      limit: chunkSize
+    })
+
+    if(items.length > 0){
+      await callback(items, iter)
+      offset += chunkSize
+      iter++
+    }
+    else{
+      break
+    }
+  }
+}
+
+const getPresetSortWhereParams = (order, afterItem) => {
+
+  const { Op } = require('sequelize')
+
+  if(order.filter((_) => _[0] === 'id').length <= 0){
+    order.push([ 'id', 'desc' ])
+  }
+
+  const opOr = []
+  for(let i = 0 ; i < order.length ; i++){
+
+    const obj = order[i]
+
+    if(obj.length !== 2) continue
+
+    const exp = {}
+    for(let j = 0 ; j < i ; j++){
+      exp[order[j][0]] = afterItem[order[j][0]]
+    }
+    exp[obj[0]] = obj[1] === 'desc' ? { [Op.lt]:afterItem[obj[0]] } : { [Op.gt]:afterItem[obj[0]] }
+
+    if(Object.keys(exp).length === 1){
+      opOr.push(exp)
+    }
+    else{
+      opOr.push({
+        [Op.and]: exp
+      })
+    }
+  }
+
+  let sortWhere = {}
+  if(opOr.length > 0){
+    sortWhere = {
+      [Op.or]: opOr
+    }
+  }
+  return sortWhere
+}
+
+const unflatten = (flatObject) => {
+  const nestedObject = {};
+
+  for (const key in flatObject) {
+    if (Object.prototype.hasOwnProperty.call(flatObject, key)) {
+      const value = flatObject[key];
+      const keys = key.split('.');
+
+      let currentObj = nestedObject;
+      for (let i = 0; i < keys.length; i++) {
+        const currentKey = keys[i];
+
+        if (!currentObj[currentKey]) {
+          currentObj[currentKey] = {};
+        }
+
+        if (i === keys.length - 1) {
+          currentObj[currentKey] = value;
+        } else {
+          currentObj = currentObj[currentKey];
+        }
+      }
+    }
+  }
+
+  return nestedObject;
+}
+
+const accessNestedObject = function(obj, path) {
+  if(!obj || typeof path !== 'string') return undefined
+
+  const keys = path.split('.');
+  let nestedObj = obj;
+
+  for (let key of keys) {
+    if (nestedObj && nestedObj.hasOwnProperty(key)) {
+      nestedObj = nestedObj[key];
+    } else {
+      // Return undefined if any key in the path is missing
+      return undefined;
+    }
+  }
+
+  return nestedObj;
+}
+
+const createObjectFromPath = (obj, path, value) => {
+  const keys = path.split('.');
+
+  let current = obj;
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    const indexMatch = key.match(/^(\d+)$/);
+    const isArrayIndex = indexMatch !== null;
+
+    const nextIsArrayIndex = !!(keys[i + 1] ?? '').match(/^(\d+)$/);
+    const isLast = i === keys.length - 1
+
+    if(isArrayIndex) {
+      const index = parseInt(indexMatch[1], 10);
+      if (!Array.isArray(current)) {
+        current = [];
+      }
+      if (typeof current[index] === 'undefined') {
+        current[index] = isLast ? value : nextIsArrayIndex ? [] : {};
+      }
+      current = current[index]
+    }
+    else{
+      if(typeof current[key] !== 'object' || current[key] === null) {
+        current[key] = isLast ? value : nextIsArrayIndex ? [] : {};
+      }
+      current = current[key];
+    }
+  }
+
+  return obj;
+}
+
+const cssDict = {
+  'Global': '*',
+  'Font': 'font-family',
+  'Impact': "'Impact', 'Arial Black', 'Arial Bold', Gadget, sans-serif",
+}
+
+const generateStylesheet = (styleObj) => {
+
+  return `*{ font-family: Impact; }`
+
+}
+
+const hexToRgb = (hex) => {
+  var result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+  return result ? {
+    r: parseInt(result[1], 16),
+    g: parseInt(result[2], 16),
+    b: parseInt(result[3], 16)
+  } : null;
+}
+
+const compClasses = [
+  'aspectRatio',
+  'bdSize', 'bdColor', 'bdRadius', 'bdStyle',
+  'bgColors', 'bgSize', 'bgPosition', 'bgRepeat',
+  'gap',
+  'padding', 'margin',
+  'direction', 'columns', 'display',
+  'width', 'minWidth', 'maxWidth',
+  'height', 'minHeight', 'maxHeight',
+  'fontFamily', 'fontSize', 'fontWeight', 'textColor', 'lineHeight', 'overflow',
+  'boxShadow', 'opacity',
+  'colSpan'
+]
+
+const containerClasses = [
+  'containerVariant', 'containerGridColumn', 'containerGap'
+]
+
+const itemClasses = [
+  'itemMinWidth', 'itemRatio', 'itemVariant'
+]
+
+const createComponentInstance = function(component){
+
+  if(!component.instance)
+    component.instance = {}
+
+  const compUid = '_' + component.uid.substring(0, 4) + ' '
+
+  Object.assign(component.instance, {
+    type: component.type,
+    uid: component.uid,
+
+    class: compUid + compClasses.map(key => {
+      return Array.isArray(component.props[key]) ? component.props[key].join(' ') : ''
+    })
+      .filter(_ => _)
+      .join(' '),
+
+    containerClass: containerClasses.map(key => {
+      return Array.isArray(component.props[key]) ? component.props[key].join(' ') : ''
+    })
+      .filter(_ => _)
+      .join(' '),
+
+    itemClass: itemClasses.map(key => {
+      return Array.isArray(component.props[key]) ? component.props[key].join(' ') : ''
+    })
+      .filter(_ => _)
+      .join(' ')
+  })
+
+  for(let key in component.props){
+    if(!compClasses.includes(key) && ![ 'enabled' ].includes(key)){
+      component.instance[key] = component.props[key]
+    }
+  }
+
+  if(Array.isArray(component.items)){
+    component.instance.items = component.items.map((_) => createComponentInstance(_))
+  }
+
+  if(component.props && Array.isArray(component.props.items)){
+    component.instance.items = component.props.items
+  }
+
+  return component
+}
+
+const deepObjectContainsObject = (outerObject, innerObject) => {
+  for (const key in innerObject) {
+    if (innerObject.hasOwnProperty(key)) {
+      if (typeof innerObject[key] === 'object' && typeof outerObject[key] === 'object') {
+        // If both properties are objects, recursively check them
+        if (!deepObjectContainsObject(outerObject[key], innerObject[key])) {
+          return false; // Nested objects do not match
+        }
+      } else {
+        if (outerObject[key] !== innerObject[key]) {
+          return false; // Property in innerObject doesn't exist in outerObject or values don't match
+        }
+      }
+    }
+  }
+  return true; // All properties and values in innerObject exist in outerObject
+}
+
+const removeStyleFromTag = (html) => {
+  const regex = /<[^>]+style="[^"]*"[^>]*>/g;
+
+  return html.replace(regex, (match) => {
+    return match.replace(/style="[^"]*"/, '');
+  });
+}
+
+const datasourceGet = async ({ Models }) => {
+
+  const models = []
+  for(let key in Models){
+
+    const columns = []
+    const attributes = Models[key].getAttributes()
+    for(let key in attributes){
+
+      let type
+      const fieldType = attributes[key].type.toString()
+
+      if(fieldType.startsWith('VARCHAR')){
+        type = 'string'
+      }
+      else if(fieldType.startsWith('INTEGER') || fieldType.startsWith('TINYINT')){
+        type = 'number'
+      }
+      else if(fieldType.startsWith('DATETIME')){
+        type = 'date'
+      }
+
+      if(type){
+        columns.push({
+          name: attributes[key].fieldName,
+          type,
+        })
+      }
+    }
+
+    models.push({
+      name: key,
+      columns
+    })
+  }
+
+  return {
+    models
+  }
+
+}
+
+const datasourceLoad = async ({ datasource, Models }) => {
+
+  const obj = {}
+
+  if(Array.isArray(datasource)){
+    for(let _datasource of datasource){
+
+      const Model = Models[_datasource.model]
+
+      const where = {}
+      if(Array.isArray(_datasource.filters)){
+        for(let filter of _datasource.filters){
+
+          switch(filter.operator){
+
+            case '=':
+              where[filter.key] = filter.value
+              break
+
+          }
+        }
+      }
+
+      const rows = await Model.findAll({
+        where,
+        limit: 20
+      })
+
+      obj[_datasource.key] = rows.length === 1 ? rows[0].toJSON() :
+        (rows.length === 0 ? {} : rows.map(_ => _.toJSON()))
+    }
+  }
+
+  return obj
+}
+
+const dayTimeRange = (params, value) => {
+  const dayjs = require('dayjs')
+
+  /*params = {
+    '*': [ [ '08:00', '12:00' ], [ '13:00', '18:00' ] ],
+    'sat': [ [ '08:00', '12:00' ], [ '13:00', '14:00' ] ],
+  }
+  value = '2023-02-06 17:59:00'*/
+
+  if(!value)
+    value = dayjs().format('YYYY-MM-DD HH:mm:ss')
+
+  const curDay = dayjs(value).format('ddd').toLowerCase()
+  const curTime = dayjs(value).format('HH:mm')
+  const ranges = params[curDay] ?? params['*']
+
+  return (ranges ?? []).some((range) => {
+    return curTime >= range[0] && curTime <= range[1]
+  })
+}
+
+function capitalize(str) {
+  return (str ?? '').toLowerCase().replace(/\b\w/g, function(char) {
+    return char.toUpperCase();
+  });
+}
+
+const removeUnderscoredKey = (obj) => {
+  if (Array.isArray(obj)) {
+    return obj.map(removeUnderscoredKey);
+  }
+  else if (obj !== null && typeof obj === 'object') {
+    for(let key in obj){
+      if(key.startsWith('_')){
+        delete obj[key]
+      }
+      else if(Array.isArray(obj[key]) || (obj[key] !== null && typeof obj[key] === 'object')){
+        removeUnderscoredKey(obj[key])
+      }
+    }
+  }
+  return obj;
+}
+
+const hashMake = async (text) => {
+  const bcrypt = require('bcrypt')
+
+  return bcrypt.hash(text + (process.env.APP_KEY ?? ''), 10)
+}
+
+const hashCheck = (text, hash) => {
+  const bcrypt = require('bcrypt')
+
+  return bcrypt.compare(text + (process.env.APP_KEY ?? ''), hash)
+}
+
+const transactionWithRetry = async (sequelize, callback, opt = {}) => {
+  const { maxRetries = 99, delay = 1000 } = opt
+
+  let retries = 0
+  while(retries < maxRetries){
+    try{
+      return await sequelize.transaction(callback)
+    }
+    catch(e){
+      if(e.name === 'SequelizeConnectionAcquireTimeoutError' ||
+        (e.name === 'SequelizeDatabaseError' && [ 'ER_LOCK_DEADLOCK', '40001' ].includes(e.original.code))){
+        retries++
+
+        if(retries >= maxRetries){
+          throw e
+        }
+
+        await new Promise((resolve) => setTimeout(resolve, delay))
+      }
+
+      else{
+        throw e
+      }
+    }
+  }
+}
+
+const groupBy = (arr, key) => {
+  return arr.reduce((acc, item) => {
+    (acc[item[key]] = acc[item[key]] || []).push(item);
+    return acc;
+  }, {});
+}
+
+module.exports = {
+  capitalize,
+  ceil,
+  floor,
+  ftWildcard,
+  moveFile,
+  round,
+  sanitizeMobileNumber,
+  saveBase64,
+  saveBuffer,
+  saveFromUrl,
+  sleep,
+  strSlug,
+  strVars,
+  writeStorage,
+  bufferToStream,
+  sequelizeChunk,
+  getPresetSortWhereParams,
+  unflatten,
+  accessNestedObject,
+  createObjectFromPath,
+  generateStylesheet,
+  hexToRgb,
+  createComponentInstance,
+  deepObjectContainsObject,
+  removeStyleFromTag,
+  datasourceGet,
+  datasourceLoad,
+  dayTimeRange,
+  removeUnderscoredKey,
+  hashMake,
+  hashCheck,
+  transactionWithRetry,
+  groupBy
+}