closer-cli 2.48.0 → 2.48.2

package/CHANGELOG.md

@@ -3,6 +3,22 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [2.48.2](https://code.hfarm.dev/closer/closer/compare/v2.48.1...v2.48.2) (2023-03-03)
+
+**Note:** Version bump only for package closer-cli
+
+
+
+
+
+## [2.48.1](https://code.hfarm.dev/closer/closer/compare/v2.48.0...v2.48.1) (2023-02-27)
+
+**Note:** Version bump only for package closer-cli
+
+
+
+
+
 # [2.48.0](https://code.hfarm.dev/closer/closer/compare/v2.47.0...v2.48.0) (2023-02-17)
 
 **Note:** Version bump only for package closer-cli

package/cmds/importData.js

@@ -1,61 +1,271 @@
-import { ALLOWED_CSV_FILES, getHumanTimestamp } from '../helpers.js'
-import * as ImportDataMultipleCmd from './importData_cmds/multiple.js'
-import * as ImportDataSingleCmd from './importData_cmds/single.js'
+/* eslint-disable no-await-in-loop */
+/* eslint-disable no-restricted-syntax */
+/* eslint-disable no-console */
+import chalk from 'chalk'
+import Ora from 'ora'
+import fs from 'fs'
+import path from 'path'
+import prompts from 'prompts'
+import axios from 'axios'
+import FormData from 'form-data'
+import qs from 'qs'
+import { deleteAsync } from 'del'
 
-export const command = 'import:data <command>'
-export const desc = 'Import CSV data to Closer'
+import {
+  getHumanTimestamp,
+  CsvType,
+  getGoogleSheetCsvUrl,
+  getCsvFilesFromDir,
+  download,
+  getImportDirName
+} from '../helpers.js'
+
+export const command = 'import:data'
+export const desc = 'Import data to Closer'
 
 export function builder(yargs) {
   yargs
-    // .commandDir('importData_cmds')
-    .option('type', {
-      alias: 't',
-      describe: 'CSV type to consider during import',
-      choices: Object.keys(ALLOWED_CSV_FILES),
-      array: true
+    .usage(`Usage: ${chalk.cyan('$0 import data')} [options]`)
+    .option('name', {
+      alias: 'n',
+      describe: 'Define import process name',
+      type: 'string',
+      default: getHumanTimestamp(new Date())
     })
     .option('mode', {
       alias: 'm',
-      describe: 'Import mode, if "full" all database records will be logically deleted',
+      describe: 'Import mode, if "full" old db records will be deleted (soft) based on Partitions',
       choices: ['full', 'incremental']
     })
+    .option('csvType', {
+      alias: 'c',
+      describe: 'CSV type to consider during import',
+      choices: CsvType,
+      array: true
+    })
+    .option('csvDelimiter', {
+      alias: 's',
+      describe: 'CSV Delimiter',
+      type: 'string',
+      default: ';'
+    })
     .option('non-interactive', {
       describe: '',
       type: 'bool'
     })
-    .option('out', {
-      alias: 'o',
-      describe: 'Directory path that will contain errored CSV files',
+    .option('fromDir', {
+      alias: 'd',
+      describe: 'Dir path that contains csv files to import',
       type: 'string'
     })
-    .option('skipTasksBeforeImport', {
-      describe: 'Skip tasks before start import process',
+    .option('fromGoogleDocId', {
+      alias: 'g',
+      describe: 'Google Doc ID that contains sheets to import',
+      type: 'string'
+    })
+    .option('keepFiles', {
+      describe: 'Keep csv files after import',
       type: 'bool'
     })
-    .option('csvDelimiter', {
-      describe: 'CSV Delimiter',
-      type: 'string',
-      default: ';'
+    .conflicts('fromDir', 'fromGoogleDocId')
+    .check(argv => {
+      if (!argv.fromDir && !argv.fromGoogleDocId) {
+        throw new Error('Missing required argument: fromDir OR fromGoogleDocId')
+      }
+
+      if (argv.fromDir) {
+        fs.accessSync(argv.fromDir, fs.constants.F_OK)
+      }
+
+      return true
     })
-    .option('n', {
-      alias: 'name',
-      describe: 'Define import process name',
-      type: 'string',
-      default: getHumanTimestamp(new Date())
+}
+
+export async function handler(argv) {
+  const spinner = new Ora()
+  const interactive = !argv.nonInteractive
+
+  // const ws = {
+  //   endpoint: argv.endpoint,
+  //   secret: argv.secret
+  // }
+
+  let csvChoices = []
+  if (argv.fromDir) {
+    const csvFilesFromDir = getCsvFilesFromDir(argv.fromDir)
+
+    csvChoices = CsvType.map(csvType => {
+      const fileName = csvFilesFromDir.find(filename => filename.endsWith(`${csvType}.csv`))
+
+      return {
+        title: csvType,
+        csvType,
+        value: {
+          file: fileName ? path.resolve(argv.fromDir, fileName) : null,
+          csvType
+        },
+        disabled: !fileName
+      }
     })
-    .implies('non-interactive', ['type', 'mode'])
-    .command(
-      ImportDataMultipleCmd.command,
-      ImportDataMultipleCmd.desc,
-      ImportDataMultipleCmd.builder,
-      ImportDataMultipleCmd.handler
+  } else {
+    csvChoices = CsvType.map(csvType => ({
+      title: csvType,
+      csvType,
+      value: {
+        url: getGoogleSheetCsvUrl(argv.fromGoogleDocId, csvType),
+        csvType
+      }
+    }))
+  }
+
+  let files
+  if (interactive && !argv.csvType) {
+    const answers = await prompts(
+      [
+        {
+          instructions: false,
+          name: 'files',
+          type: 'multiselect',
+          message: argv.fromDir ? 'Select Files' : 'Select Sheets',
+          warn: argv.fromDir && 'File not found',
+          choices: csvChoices,
+          min: 1
+        }
+      ],
+      { onCancel: () => process.exit() }
+    )
+
+    files = answers.files
+  }
+
+  if (!interactive && argv.fromDir) {
+    files = csvChoices.filter(csvChoice => !csvChoice.disabled).map(csvChoice => csvChoice.value)
+  }
+
+  let mode
+  if (interactive && !argv.mode) {
+    const answers = await prompts(
+      [
+        {
+          type: 'select',
+          name: 'mode',
+          message: 'Import Mode',
+          choices: [
+            {
+              title: 'Incremental',
+              value: 'incremental'
+            },
+            {
+              title: 'Full',
+              description: 'Old db records will be deleted (soft) based on Partitions',
+              value: 'full'
+            }
+          ],
+          hint: ' '
+        }
+      ],
+      { onCancel: () => process.exit() }
     )
-    .command(
-      ImportDataSingleCmd.command,
-      ImportDataSingleCmd.desc,
-      ImportDataSingleCmd.builder,
-      ImportDataSingleCmd.handler
+
+    mode = answers.mode
+  } else {
+    mode = argv.mode
+  }
+
+  const parsedFiles = []
+
+  if (argv.fromGoogleDocId) {
+    console.log('')
+    spinner.start('Downloading Google sheets...')
+    const dirName = getImportDirName(argv.endpoint)
+    const dirPath = path.resolve(dirName, argv.name)
+    if (!fs.existsSync(dirPath)) {
+      fs.mkdirSync(dirPath, { recursive: true })
+    }
+    for (const item of files) {
+      const filePath = await download(item.url, dirPath, `${argv.name}_${item.csvType}.csv`)
+      parsedFiles.push({ file: filePath, csvType: item.csvType })
+    }
+    spinner.succeed('Google sheets downloaded')
+  } else {
+    for (const file of files) {
+      parsedFiles.push({ file: file.file, csvType: file.csvType })
+    }
+  }
+
+  if (interactive) {
+    console.log('')
+    const { confirmed } = await prompts(
+      [
+        {
+          type: 'confirm',
+          name: 'confirmed',
+          message: 'Continue?',
+          initial: false
+        }
+      ],
+      { onCancel: () => process.exit() }
     )
-}
 
-export function handler() {}
+    if (!confirmed) {
+      process.exit()
+    }
+  }
+
+  const data = {
+    name: argv.name,
+    mode,
+    delimiter: argv.csvDelimiter,
+    files: parsedFiles
+  }
+
+  const formData = new FormData()
+
+  for (const file of data.files) {
+    formData.append(file.csvType, fs.createReadStream(file.file))
+  }
+
+  const query = qs.stringify(
+    {
+      name: data.name,
+      mode: data.mode,
+      delimiter: data.delimiter
+    },
+    { skipNulls: true }
+  )
+
+  const protocol =
+    argv.endpoint.includes('localhost') || argv.endpoint.includes('127.0.0.1') ? 'http' : 'https'
+
+  const url = `${protocol}://${argv.endpoint}/import/data?${query}`
+
+  try {
+    const response = await axios.post(url, formData, {
+      headers: { ...formData.getHeaders(), 'x-closer-secret': argv.secretKey }
+    })
+
+    if (response.data.error) {
+      console.error(response.data.message)
+      process.exit(1)
+    }
+  } catch (error) {
+    if (error.response?.data?.message) {
+      console.error(error.response.data.message)
+    }
+    console.error(error.message)
+    process.exit(1)
+  }
+
+  if (!argv.keepFiles) {
+    await deleteAsync(
+      data.files.map(file => file.file),
+      { force: true }
+    )
+  }
+
+  console.log('\n')
+  console.log('✅ Thank you for initiating the data import process!')
+  console.log('📫 You will receive an email notification once the import is completed.')
+
+  process.exit()
+}

package/cmds/importMedia.js

@@ -1,67 +1,61 @@
+/* eslint-disable no-console */
 import chalk from 'chalk'
-import Ora from 'ora'
-import {
-  importMedia,
-  flushMedia,
-  getExecutionTime,
-  callAfterMediaImportProcess
-} from '../helpers.js'
+import axios from 'axios'
+import qs from 'qs'
 
 export const command = 'import:media'
-export const desc = 'Import media (images, 360, videos) to Closer'
+export const desc = 'Import media to Closer'
 
 export function builder(yargs) {
   yargs
-    .usage(`Usage: ${chalk.cyan('$0 import:media')} [options]`)
-
+    .usage(`Usage: ${chalk.cyan('$0 import media')} [options]`)
     .option('flush', {
-      describe: 'Delete all before the import process (DB records and files from disk).',
+      describe: 'Truncate tables (ProductAssets, Assets) and delete files from disk',
       type: 'bool'
     })
-
     .option('reprocess', {
-      describe: 'Reprocess media that were already processed by previous import.',
+      describe: 'Reprocess medias already processed by previous import',
       type: 'bool'
     })
 }
 
 export async function handler(argv) {
-  const spinner = new Ora()
-  const hrstart = process.hrtime()
-
-  const report = {
-    start: new Date(),
-    end: null,
-    time: null,
-    endpoint: argv.endpoint,
-    flush: argv.flush,
-    reprocess: argv.reprocess,
-    result: null
-  }
-
-  const ws = {
-    endpoint: argv.endpoint,
-    secret: argv.secret
-  }
-
-  if (argv.flush) {
-    try {
-      await flushMedia(spinner, ws)
-    } catch (e) {
+  const query = qs.stringify(
+    {
+      flush: argv.flush,
+      reprocess: argv.reprocess
+    },
+    { skipNulls: true }
+  )
+
+  const protocol =
+    argv.endpoint.includes('localhost') || argv.endpoint.includes('127.0.0.1') ? 'http' : 'https'
+
+  const url = `${protocol}://${argv.endpoint}/import/media?${query}`
+
+  try {
+    const response = await axios.post(
+      url,
+      {},
+      {
+        headers: { 'x-closer-secret': argv.secretKey }
+      }
+    )
+
+    if (response.data.error) {
+      console.error(response.data.message)
       process.exit(1)
     }
+  } catch (error) {
+    if (error.response?.data?.message) {
+      console.error(error.response.data.message)
+    }
+    console.error(error.message)
+    process.exit(1)
   }
 
-  const result = await importMedia(argv.reprocess, spinner, ws)
-
-  //
-  // Report
-  //
-  report.end = new Date()
-  report.time = getExecutionTime(hrstart)
-  report.result = result
-
-  await callAfterMediaImportProcess(spinner, ws, report)
+  console.log('✅ Thank you for initiating the media import process!')
+  console.log('📫 You will receive an email notification once the import is completed.')
 
   process.exit()
 }