closer-cli 2.48.0 → 2.48.2

package/helpers.js

@@ -1,57 +1,32 @@
+/* eslint-disable max-len */
 /* eslint-disable no-console */
 /* eslint-disable no-param-reassign */
 /* eslint-disable implicit-arrow-linebreak */
-import {
-  readdirSync,
-  existsSync,
-  mkdirSync,
-  copyFileSync,
-  createWriteStream,
-  createReadStream,
-  rename,
-  statSync
-} from 'fs'
+import { readdirSync, existsSync, mkdirSync, createWriteStream } from 'fs'
 import path from 'path'
-import WebSocket from 'ws'
-import chalk from 'chalk'
-import { parse } from 'csv-parse/sync'
-import { stringify } from 'csv-stringify/sync'
 import got from 'got'
 import slugify from 'slugify'
-import { deleteAsync } from 'del'
-import eventStream from 'event-stream'
 
-const { split, mapSync } = eventStream
 const { stream } = got
 
-export function createSocketConnection(endpoint, secret) {
-  const protocol = endpoint.includes('localhost') || endpoint.includes('127.0.0.1') ? 'ws' : 'wss'
-  const url = `${protocol}://${endpoint}/import`
-  const socket = new WebSocket(url, {
-    headers: { 'x-closer-secret': secret }
-  })
-
-  return socket
-}
-
-export const ALLOWED_CSV_FILES = {
-  product: 'products.csv',
-  localizedProduct: 'localizedProducts.csv',
-  localizedFilter: 'localizedFilters.csv',
-  localizedVariant: 'localizedVariants.csv',
-  price: 'prices.csv',
-  group: 'groups.csv',
-  lookup: 'lookups.csv',
-  user: 'users.csv',
-  customer: 'customers.csv',
-  label: 'labels.csv',
-  filterPosition: 'filterPosition.csv',
-  fieldConfiguration: 'fieldConfigurations.csv',
-  stockAvailability: 'stockAvailability.csv',
-  configuration: 'configurations.csv',
-  userCustomer: 'userCustomers.csv',
-  team: 'teams.csv'
-}
+export const CsvType = [
+  'products',
+  'localizedProducts',
+  'localizedFilters',
+  'localizedVariants',
+  'prices',
+  'groups',
+  'lookups',
+  'users',
+  'customers',
+  'labels',
+  'filterPosition',
+  'fieldConfigurations',
+  'stockAvailability',
+  'configurations',
+  'userCustomers',
+  'teams'
+]
 
 export function getCsvFilesFromDir(dir) {
   return readdirSync(dir).filter(file => path.extname(file).toLowerCase() === '.csv')
@@ -61,519 +36,6 @@ export function getGoogleSheetCsvUrl(docId, sheet) {
   return `https://docs.google.com/spreadsheets/d/${docId}/gviz/tq?tqx=out:csv&sheet=${sheet}`
 }
 
-export function importCsvFromFile({
-  file,
-  csvType,
-  outputDir,
-  spinner,
-  ws,
-  delimiter = ';',
-  importProcess
-}) {
-  return new Promise(resolve => {
-    const socket = createSocketConnection(ws.endpoint, ws.secret)
-
-    const hrstart = process.hrtime()
-    const importFileStart = new Date()
-
-    let readStream = null
-
-    const dirPathProcessing = path.resolve(outputDir, '_processing')
-
-    if (!existsSync(dirPathProcessing)) {
-      mkdirSync(dirPathProcessing, { recursive: true })
-    }
-
-    const filename = path.basename(file)
-    const filepath = path.resolve(dirPathProcessing, filename)
-
-    copyFileSync(file, filepath)
-
-    const errorCsvFile = path.resolve(outputDir, `${importProcess.name}_${csvType}_errors.csv`)
-    const errorFileStream = createWriteStream(errorCsvFile)
-
-    const skippedCsvFile = path.resolve(outputDir, `${importProcess.name}_${csvType}_skipped.csv`)
-    const skippedFileStream = createWriteStream(skippedCsvFile)
-
-    let header = ''
-    let lineNumber = 0
-    let countImported = 0
-    let countFailed = 0
-    let countSkipped = 0
-    const partitions = new Set()
-
-    spinner.start('Loading...')
-
-    const importRowSuccess = csvRow => {
-      partitions.add(csvRow.Partition || '')
-
-      countImported += 1
-
-      spinner.text = printImportProcessResult({
-        csvType,
-        countImported,
-        countFailed,
-        countSkipped,
-        importFileStart,
-        importFileEnd: new Date(),
-        executionTime: getExecutionTime(hrstart),
-        name: filename
-      })
-
-      readStream.resume()
-    }
-
-    const importRowError = csvRow => {
-      partitions.add(csvRow.Partition || '')
-
-      countFailed += 1
-
-      spinner.text = printImportProcessResult({
-        csvType,
-        countImported,
-        countFailed,
-        countSkipped,
-        importFileStart,
-        importFileEnd: new Date(),
-        executionTime: getExecutionTime(hrstart),
-        name: filename
-      })
-
-      errorFileStream.write(
-        stringify([csvRow], {
-          header: countFailed === 1,
-          quoted: true,
-          delimiter: ';'
-        })
-      )
-
-      readStream.resume()
-    }
-
-    const importFatal = (csvRow, errorMessage) => {
-      partitions.add(csvRow.Partition || '')
-
-      spinner.fail(
-        printImportProcessResult({
-          csvType,
-          countImported,
-          countFailed,
-          countSkipped,
-          importFileStart,
-          importFileEnd: new Date(),
-          executionTime: getExecutionTime(hrstart),
-          name: filename,
-          fatalError: errorMessage
-        })
-      )
-
-      resolve({
-        csvType,
-        countImported,
-        countFailed,
-        countSkipped,
-        executionTime: getExecutionTime(hrstart),
-        importFileStart,
-        importFileEnd: new Date(),
-        inputFile: file,
-        fatalError: `FATAL: ${errorMessage}`,
-        partitions
-      })
-
-      readStream.destroy()
-      errorFileStream.end()
-      skippedFileStream.end()
-    }
-
-    const importSuccess = () => {
-      if (countFailed > 0 || countSkipped > 0) {
-        spinner.warn()
-      } else {
-        spinner.succeed()
-      }
-
-      errorFileStream.end()
-      skippedFileStream.end()
-
-      deleteAsync(filepath)
-
-      resolve({
-        csvType,
-        countImported,
-        countFailed,
-        countSkipped,
-        importFileStart,
-        importFileEnd: new Date(),
-        executionTime: getExecutionTime(hrstart),
-        inputFile: file,
-        partitions
-      })
-    }
-
-    socket.on('open', () => {
-      readStream = createReadStream(file)
-        .pipe(split())
-        .pipe(
-          mapSync(line => {
-            readStream.pause()
-
-            if (lineNumber === 0) {
-              header = line
-              readStream.resume()
-            } else {
-              try {
-                const rows = parse(`${header}\n${line}`, {
-                  columns: true,
-                  skip_empty_lines: true,
-                  skipLinesWithEmptyValues: true,
-                  delimiter
-                })
-
-                if (rows.length > 0) {
-                  const packet = {
-                    type: 'importCsvRow',
-                    payload: {
-                      csvRow: rows[0],
-                      csvType,
-                      lineNumber,
-                      importProcess
-                    }
-                  }
-                  socket.send(JSON.stringify(packet))
-                } else {
-                  readStream.resume()
-                }
-              } catch (e) {
-                countSkipped += 1
-                skippedFileStream.write(`${line},${e.message}`)
-                readStream.resume()
-              }
-            }
-
-            lineNumber += 1
-          })
-        )
-        .on('error', e => importFatal(e.message))
-        .on('end', importSuccess)
-    })
-
-    socket.on('message', packet => {
-      const { type, payload } = JSON.parse(packet)
-
-      switch (type) {
-        case 'importRowSuccess':
-          importRowSuccess(payload.csvRow)
-          break
-        case 'importRowError':
-          importRowError(payload.csvRow)
-          break
-        case 'importRowFatal':
-          importFatal(payload.csvRow, payload.error)
-          break
-        default:
-          break
-      }
-    })
-
-    socket.on('error', e => {
-      importFatal(e.message)
-    })
-  })
-}
-
-export function sendImportErrorMail(ws, importProcess, csvReport) {
-  const socket = createSocketConnection(ws.endpoint, ws.secret)
-
-  socket.on('open', () => {
-    socket.send(
-      JSON.stringify({
-        type: 'sendImportErrorMail',
-        payload: { csvReport, importProcess }
-      })
-    )
-  })
-}
-
-export function validateCsvFromFile(file, csvType, ws, delimiter, importProcess) {
-  return new Promise(resolve => {
-    const socket = createSocketConnection(ws.endpoint, ws.secret)
-    const hrstart = process.hrtime()
-
-    let readStream = null
-
-    let header = ''
-    let lineNumber = 0
-    const filename = path.basename(file)
-
-    socket.on('open', () => {
-      readStream = createReadStream(file)
-        .pipe(split())
-        .pipe(
-          mapSync(line => {
-            readStream.pause()
-
-            if (lineNumber === 0) {
-              header = line
-              readStream.resume()
-            }
-
-            if (lineNumber === 1) {
-              if (line === '') {
-                resolve({
-                  csvType,
-                  executionTime: getExecutionTime(hrstart),
-                  inputFile: filename
-                })
-              } else {
-                const rows = parse(`${header}\n${line}`, {
-                  columns: true,
-                  skip_empty_lines: true,
-                  skipLinesWithEmptyValues: true,
-                  delimiter
-                })
-
-                const packet = {
-                  type: 'validateCsvHeaderRequest',
-                  payload: {
-                    csvColumns: Object.keys(rows[0]),
-                    csvType,
-                    importProcess
-                  }
-                }
-
-                socket.send(JSON.stringify(packet))
-              }
-
-              readStream.destroy()
-            }
-
-            lineNumber += 1
-          })
-        )
-        .on('error', e => {
-          resolve({
-            csvType,
-            executionTime: getExecutionTime(hrstart),
-            inputFile: filename,
-            error: e.message
-          })
-        })
-    })
-
-    socket.on('message', packet => {
-      const { type, payload } = JSON.parse(packet)
-      switch (type) {
-        case 'validateCsvHeaderResponse': {
-          const result = {
-            csvType,
-            executionTime: getExecutionTime(hrstart),
-            inputFile: filename
-          }
-
-          if (payload.error) {
-            result.error = payload.error
-          }
-
-          resolve(result)
-          break
-        }
-        default:
-          break
-      }
-    })
-
-    socket.on('error', e => {
-      resolve({
-        csvType,
-        executionTime: getExecutionTime(hrstart),
-        inputFile: file,
-        error: e.message
-      })
-    })
-  })
-}
-
-export function getExecutionTime(importProcessStart) {
-  const hrend = process.hrtime(importProcessStart)
-  return ((hrend[0] * 1e9 + hrend[1]) / 1e9).toFixed(1)
-}
-
-export function printValidationProcessHeader() {
-  console.log('\n=== Validation Process Result ===\n')
-}
-
-export function printImportProcessHeader() {
-  console.log('\n=== Import Process Result ===\n')
-}
-
-export function printValidationProcessResult({
-  inputFile,
-  error
-  // eslint-disable-next-line consistent-return
-}) {
-  let message = ''
-  const filename = path.basename(inputFile)
-
-  if (error) {
-    message = `[${chalk.red(filename)}] not valid ${chalk.gray(`[${error}]`)}`
-  } else {
-    message = `[${chalk.green(filename)}] valid`
-  }
-
-  console.log(message)
-}
-
-export function printImportProcessResult({
-  countImported,
-  countFailed,
-  countSkipped,
-  executionTime,
-  name,
-  fatalError
-  // eslint-disable-next-line consistent-return
-}) {
-  let message = ''
-
-  if (fatalError) {
-    message = `[${chalk.red(name)}] ${chalk.red(fatalError)}`
-    return message
-  }
-
-  message = `[${colorByResult(
-    name,
-    countImported,
-    countFailed,
-    countSkipped
-  )}] imported ${colorGreaterThanZero(countImported, 'green')} items`
-
-  if (countFailed) {
-    message += `, failed ${colorGreaterThanZero(countFailed, 'red')} items`
-  }
-
-  if (countSkipped) {
-    message += `, skipped ${colorGreaterThanZero(countSkipped, 'red')} items`
-  }
-
-  message += ` ${chalk.gray(`[${executionTime}s]`)}`
-
-  return message
-}
-
-export function colorByResult(value, countImported, countFailed, countSkipped) {
-  let color = 'green'
-
-  if (countImported > 0 && (countFailed > 0 || countSkipped > 0)) {
-    color = 'yellow'
-  }
-
-  if (countImported === 0 && (countFailed > 0 || countSkipped > 0)) {
-    color = 'red'
-  }
-
-  return chalk[color](value)
-}
-
-export function colorGreaterThanZero(value, color) {
-  if (value > 0) {
-    return chalk[color](value)
-  }
-
-  return value
-}
-
-export function refreshOrders(spinner, ws, importProcess) {
-  return new Promise(resolve => {
-    const hrstart = process.hrtime()
-
-    const socket = createSocketConnection(ws.endpoint, ws.secret)
-
-    spinner.start('Refreshing orders (draft, template)...')
-
-    socket.on('open', () => {
-      socket.send(JSON.stringify({ type: 'refreshOrdersRequest', payload: { importProcess } }))
-    })
-
-    socket.on('message', packet => {
-      const { type, payload } = JSON.parse(packet)
-      switch (type) {
-        case 'refreshOrdersResponse': {
-          spinner.text = printRefreshedOrders({
-            ...payload,
-            executionTime: getExecutionTime(hrstart)
-          })
-          spinner.succeed()
-          resolve({
-            totalCount: payload.totalCount,
-            refreshed: payload.refreshed,
-            errored: payload.errored,
-            name: importProcess.name,
-            executionTime: getExecutionTime(hrstart)
-          })
-          break
-        }
-        default:
-          break
-      }
-    })
-
-    socket.on('error', e => {
-      resolve({ error: e.message })
-    })
-  })
-}
-
-// eslint-disable-next-line consistent-return
-export function printRefreshedOrders({ refreshed, errored, executionTime }) {
-  let message = ''
-
-  const stringRefreshed = colorGreaterThanZero(refreshed.length, 'green')
-  const stringErrored = colorGreaterThanZero(errored.length, 'red')
-
-  message += `Refreshed ${stringRefreshed} orders (draft, template)`
-
-  if (errored.length) {
-    message += `, refresh failed for ${stringErrored} orders.`
-  }
-
-  message += ` ${chalk.gray(`[${executionTime}s]`)}`
-
-  return message
-}
-
-export function deleteRowsBeforeImportDate(importProcess, partitionsForCsvType, spinner, ws) {
-  return new Promise(resolve => {
-    const socket = createSocketConnection(ws.endpoint, ws.secret)
-
-    spinner.start('Deleting old database records for chosen partitions...')
-
-    socket.on('open', () => {
-      socket.send(
-        JSON.stringify({
-          type: 'deleteRowsBeforeImportDateRequest',
-          payload: { importProcess, partitionsForCsvType }
-        })
-      )
-    })
-
-    socket.on('message', packet => {
-      const { type } = JSON.parse(packet)
-      switch (type) {
-        case 'deleteRowsBeforeImportDateResponse': {
-          spinner.succeed('Database records deleted (soft)')
-          resolve()
-          break
-        }
-        default:
-          break
-      }
-    })
-
-    socket.on('error', e => {
-      resolve({ error: e.message })
-    })
-  })
-}
-
 export async function download(url, destPath, fileName) {
   return new Promise((resolve, reject) => {
     const filePath = path.resolve(destPath, fileName)
@@ -601,210 +63,7 @@ export async function download(url, destPath, fileName) {
   })
 }
 
-export function callBeforeDataImportProcess(spinner, ws, importProcess) {
-  return new Promise((resolve, reject) => {
-    const socket = createSocketConnection(ws.endpoint, ws.secret)
-
-    spinner.start('Executing tasks before start...')
-
-    socket.on('open', () => {
-      socket.send(
-        JSON.stringify({ type: 'callBeforeDataImportProcessRequest', payload: { importProcess } })
-      )
-    })
-
-    socket.on('message', packet => {
-      const { type, payload } = JSON.parse(packet)
-      switch (type) {
-        case 'callBeforeDataImportProcessResponse': {
-          if (payload.error) {
-            spinner.fail(payload.error)
-            reject()
-          } else {
-            spinner.succeed('Tasks executed before start')
-            resolve()
-          }
-          break
-        }
-        default:
-          break
-      }
-    })
-
-    socket.on('error', e => {
-      resolve({ error: e.message })
-    })
-  })
-}
-
-export function callAfterDataImportProcess(spinner, ws, importProcess) {
-  return new Promise(resolve => {
-    const socket = createSocketConnection(ws.endpoint, ws.secret)
-
-    spinner.start('Executing tasks after the end process...')
-
-    socket.on('open', () => {
-      socket.send(
-        JSON.stringify({ type: 'callAfterDataImportProcessRequest', payload: { importProcess } })
-      )
-    })
-
-    socket.on('message', packet => {
-      const { type } = JSON.parse(packet)
-      switch (type) {
-        case 'callAfterDataImportProcessResponse': {
-          spinner.succeed('Tasks executed after the end process')
-          resolve()
-          break
-        }
-        default:
-          break
-      }
-    })
-
-    socket.on('error', e => {
-      resolve({ error: e.message })
-    })
-  })
-}
-
-export function callAfterMediaImportProcess(spinner, ws, report) {
-  return new Promise(resolve => {
-    const socket = createSocketConnection(ws.endpoint, ws.secret)
-
-    spinner.start('Executing tasks after the end process...')
-
-    socket.on('open', () => {
-      socket.send(JSON.stringify({ type: 'callAfterMediaImportProcessRequest', payload: report }))
-    })
-
-    socket.on('message', packet => {
-      const { type } = JSON.parse(packet)
-      switch (type) {
-        case 'callAfterMediaImportProcessResponse': {
-          spinner.succeed('Tasks executed after the end process')
-          resolve()
-          break
-        }
-        default:
-          break
-      }
-    })
-
-    socket.on('error', e => {
-      resolve({ error: e.message })
-    })
-  })
-}
-
-export function importMedia(reprocess, spinner, ws) {
-  return new Promise(resolve => {
-    const hrstart = process.hrtime()
-    const socket = createSocketConnection(ws.endpoint, ws.secret)
-
-    let countAssetImported = 0
-    let countAssetSkipped = 0
-    let countAssetFailed = 0
-    let countProductAssetImported = 0
-
-    const updateSpinnerText = () => {
-      spinner.text = printImportProcessResult({
-        countImported: countAssetImported,
-        countSkipped: countAssetSkipped,
-        countFailed: countAssetFailed,
-        executionTime: getExecutionTime(hrstart),
-        name: 'Asset'
-      })
-    }
-
-    socket.on('open', () => {
-      socket.send(JSON.stringify({ type: 'import.images', payload: { reprocess } }))
-    })
-
-    socket.on('message', packet => {
-      const { type, payload } = JSON.parse(packet)
-
-      switch (type) {
-        case 'import.images.start':
-          spinner.start('[Asset] Importing Assets...')
-          break
-        case 'import.images.imageAsset.success':
-          countAssetImported += 1
-          updateSpinnerText()
-          break
-        case 'import.images.imageAsset.skipped':
-          countAssetSkipped += 1
-          updateSpinnerText()
-          break
-        case 'import.images.imageAsset.failed':
-          countAssetFailed += 1
-          updateSpinnerText()
-          break
-        case 'import.images.productAssets.start':
-          countProductAssetImported = payload.count
-          spinner.succeed()
-          spinner.start(`[ProductAsset] Importing ${countProductAssetImported} Product Assets...`)
-          break
-        case 'import.images.productAssets.end':
-          spinner.succeed(
-            printImportProcessResult({
-              countImported: payload.count,
-              countFailed: 0,
-              executionTime: getExecutionTime(hrstart),
-              name: 'ProductAsset'
-            })
-          )
-          break
-        case 'import.images.end':
-          resolve({
-            countAssetImported,
-            countAssetSkipped,
-            countAssetFailed,
-            countProductAssetImported
-          })
-          break
-        default:
-          break
-      }
-    })
-
-    socket.on('error', e => {
-      resolve({ error: e.message })
-    })
-  })
-}
-
-export function flushMedia(spinner, ws) {
-  return new Promise((resolve, reject) => {
-    const socket = createSocketConnection(ws.endpoint, ws.secret)
-
-    spinner.start('Flushing... ')
-
-    socket.on('open', () => {
-      socket.send(JSON.stringify({ type: 'flush.media.request' }))
-    })
-
-    socket.on('message', packet => {
-      const { type } = JSON.parse(packet)
-      switch (type) {
-        case 'flush.media.response': {
-          spinner.succeed('Flushing completed')
-          resolve()
-          break
-        }
-        default:
-          break
-      }
-    })
-
-    socket.on('error', e => {
-      spinner.fail(e.message)
-      reject(e)
-    })
-  })
-}
-
-export function getArchiveFolder(instanceEndpoint) {
+export function getImportDirName(instanceEndpoint) {
   const prefix = 'closer'
   const instance = slugify(instanceEndpoint.split('/')[0], {
     lower: true,
@@ -813,30 +72,6 @@ export function getArchiveFolder(instanceEndpoint) {
   return `${prefix}_${instance}`
 }
 
-export function renameWithTimestamp(dirPath) {
-  const ts = getTimestampForFilename()
-
-  const files = getCsvFilesFromDir(dirPath).map(filename => {
-    const oldPath = path.resolve(dirPath, filename)
-    const [name, ext] = oldPath.split('.')
-    const newPath = `${name}_${ts}.${ext}`
-    return {
-      oldPath,
-      newPath
-    }
-  })
-
-  files.forEach(file => rename(file.oldPath, file.newPath, () => {}))
-}
-
-const getTimestampForFilename = () => {
-  const date = new Date()
-  const [isoDateString, isoTimeString] = date.toISOString().split('T')
-  const dateString = isoDateString.split('-').join('')
-  const timeString = isoTimeString.split(':').join('').split('.')[0]
-  return `${dateString}_${timeString}`.split(':').join('')
-}
-
 export function getHumanTimestamp(date) {
   const [isoDateString, isoTimeString] = date.toISOString().split('T')
   const dateString = isoDateString.split('-').join('')
@@ -844,18 +79,52 @@ export function getHumanTimestamp(date) {
   return `${dateString}_${timeString}`.split(':').join('')
 }
 
-export async function readImportDir(dirpath) {
-  const allFiles = readdirSync(dirpath)
-  const csvFiles = allFiles.filter(file => path.extname(file) === '.csv')
+// export function createSocketConnection(endpoint, secret) {
+//   const protocol = endpoint.includes('localhost') || endpoint.includes('127.0.0.1') ? 'ws' : 'wss'
+//   const url = `${protocol}://${endpoint}/import`
+//   const socket = new WebSocket(url, {
+//     headers: { 'x-closer-secret': secret }
+//   })
 
-  if (csvFiles.length === 0) {
-    return []
-  }
+//   return socket
+// }
 
-  const files = csvFiles.map(file => {
-    const stat = statSync(path.resolve(dirpath, file))
-    return { filename: file, mtimeMS: stat.mtimeMs, mtime: stat.mtime, size: stat.size }
-  })
+// export function colorByResult(value, countImported, countFailed, countSkipped) {
+//   let color = 'green'
 
-  return files
-}
+//   if (countImported > 0 && (countFailed > 0 || countSkipped > 0)) {
+//     color = 'yellow'
+//   }
+
+//   if (countImported === 0 && (countFailed > 0 || countSkipped > 0)) {
+//     color = 'red'
+//   }
+
+//   return chalk[color](value)
+// }
+
+// export function colorGreaterThanZero(value, color) {
+//   if (value > 0) {
+//     return chalk[color](value)
+//   }
+
+//   return value
+// }
+
+// eslint-disable-next-line consistent-return
+// export function printRefreshedOrders({ refreshed, errored, executionTime }) {
+//   let message = ''
+
+//   const stringRefreshed = colorGreaterThanZero(refreshed.length, 'green')
+//   const stringErrored = colorGreaterThanZero(errored.length, 'red')
+
+//   message += `Refreshed ${stringRefreshed} orders (draft, template)`
+
+//   if (errored.length) {
+//     message += `, refresh failed for ${stringErrored} orders.`
+//   }
+
+//   message += ` ${chalk.gray(`[${executionTime}s]`)}`
+
+//   return message
+// }