@spark-ui/cli-utils 2.14.0 → 2.15.0

package/CHANGELOG.md

@@ -3,6 +3,28 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [2.15.0](https://github.com/adevinta/spark/compare/@spark-ui/cli-utils@2.14.0...@spark-ui/cli-utils@2.15.0) (2024-07-03)
+
+### Bug Fixes
+
+- **cli-utils:** add some feedback when not loading a given config file ([1231fe6](https://github.com/adevinta/spark/commit/1231fe6cb94c15643a11278c3210836e81059364))
+- **cli-utils:** fix config merge method to allow proper option override ([8b6a124](https://github.com/adevinta/spark/commit/8b6a124c6e70f05769305bf6ca84137c7a05510c))
+- **cli-utils:** fix logger issue on generate script after changes ([083c9b0](https://github.com/adevinta/spark/commit/083c9b043d1837a807b159a8143fd16bf8d7087e))
+- **cli-utils:** merge values ([a7e8129](https://github.com/adevinta/spark/commit/a7e81292d452d4ee026f3d4705198ac4ecc6363e))
+- **cli-utils:** merging configs ([aeb6251](https://github.com/adevinta/spark/commit/aeb6251d23bc506674e4545ebad928081292f520))
+- **cli-utils:** missalignment on the default config values nesting ([79729f7](https://github.com/adevinta/spark/commit/79729f722f4ecf6f0c671e2c1c1d5929a87d98c9))
+- **cli-utils:** output file creates new content ([973ffa8](https://github.com/adevinta/spark/commit/973ffa85e6987dbd87a119e9253db57556a705d4))
+- **cli-utils:** remove betta tagging ([96cafae](https://github.com/adevinta/spark/commit/96cafae45e4a4759ef9ff4a763963f26cb898cb6))
+- **cli-utils:** remove extra logs ([f588649](https://github.com/adevinta/spark/commit/f588649eb299fc42ef9d6dbf8f8f4eebd0cfd6a9))
+- **cli-utils:** remove unnecesary log ([614d834](https://github.com/adevinta/spark/commit/614d834d5d7a0f3084b3097e2dee5436b369fbb6))
+- log config setted ([190a058](https://github.com/adevinta/spark/commit/190a0581ab6219591c5d3a3ecde2ee46d504d7ca))
+- priority of commands ([ed178a5](https://github.com/adevinta/spark/commit/ed178a51a8cea0255c96467b0d8760daf8f851dd))
+
+### Features
+
+- **cli-utils:** exoposes all configuration parameters as a build argument ([3e88a99](https://github.com/adevinta/spark/commit/3e88a998c05da026cd196b3dd54a2ad50506266c))
+- mixing parameters ([da1bf1d](https://github.com/adevinta/spark/commit/da1bf1d838df2c577755eb3c651cd0bba8d07203))
+
 # [2.14.0](https://github.com/adevinta/spark/compare/@spark-ui/cli-utils@2.13.8...@spark-ui/cli-utils@2.14.0) (2024-06-14)
 
 ### Features

package/bin/spark-generate.mjs

@@ -6,7 +6,7 @@ import { TemplateGenerator } from '../src/generate/generators/index.mjs'
 import { Logger, System } from '../src/core/index.mjs'
 import { DescriptionValidator, NameValidator } from '../src/generate/validators/index.mjs'
 
-const logger = new Logger()
+const logger = new Logger({ verbose: true })
 const system = new System({ logger })
 const generator = new TemplateGenerator({ system })
 

package/bin/spark-scan.mjs

@@ -1,15 +1,21 @@
 #! /usr/bin/env node
 
 import { Command } from 'commander'
-import { adoption } from '../src/scan/index.mjs'
+import { adoption, config } from '../src/scan/index.mjs'
 
 const program = new Command()
 
 program
   .command('adoption')
   .description('Scan @spark-ui adoption for .tsx files with given imports')
-  .option('-c, --configuration <path>', 'configuration file route', '.spark-ui.cjs')
-  .option('-o, --output <path>', 'output file route')
+  .option('-c, --configuration <config>', 'configuration file route')
+  .option('-o, --output <output>', 'output file route')
+  .option('-v, --verbose', 'output log information', false)
+  .option('-d, --details', 'output information about each match', config.details)
+  .option('-s, --sort <sort>', 'sort results (count or alphabetical)', config.sort)
+  .option('-dir, --directory <directory>', 'directory to parse', config.directory)
+  .option('-ext, --extensions <extensions...>', 'file extensions to parse', config.extensions)
+  .option('-i, --imports <imports...>', 'import patterns to identify', config.imports)
   .action(adoption)
 
 program.parse(process.argv)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spark-ui/cli-utils",
-  "version": "2.14.0",
+  "version": "2.15.0",
   "description": "Spark CLI utils",
   "publishConfig": {
     "access": "public"
@@ -45,5 +45,5 @@
   "devDependencies": {
     "@types/fs-extra": "11.0.4"
   },
-  "gitHead": "70cbe1732252c1a1eac56af3d212fe2d33e4dcdc"
+  "gitHead": "8a312bf6a9f20c8dd0cc3cc10649359c4313a2a7"
 }

package/src/core/Logger.mjs

@@ -1,20 +1,50 @@
-/* eslint-disable no-console */
 import chalk from 'chalk'
 
 export class Logger {
-  success(message) {
-    console.log(chalk.green(message))
+  #force = false
+
+  constructor({ verbose } = {}) {
+    this.verbose = verbose
+
+    if (typeof Logger.instance === 'object') {
+      return Logger.instance
+    }
+
+    Logger.instance = this
+
+    return this
+  }
+
+  #log({ type = v => v, force, verbose }, ...args) {
+    if (force || verbose) {
+      console.log(type(...args)) // eslint-disable-line no-console
+    }
+    this.#force = false
+  }
+
+  force() {
+    this.#force = true
+
+    return this
+  }
+
+  error(...args) {
+    this.#log({ type: chalk.red, force: this.#force, verbose: this.verbose }, ...args)
+  }
+
+  warning(...args) {
+    this.#log({ type: chalk.yellow, force: this.#force, verbose: this.verbose }, ...args)
   }
 
-  error(message) {
-    console.log(chalk.red(message))
+  info(...args) {
+    this.#log({ type: chalk.cyan, force: this.#force, verbose: this.verbose }, ...args)
   }
 
-  info(message) {
-    console.log(chalk.yellow(message))
+  success(...args) {
+    this.#log({ type: chalk.green, force: this.#force, verbose: this.verbose }, ...args)
   }
 
-  warning(message) {
-    console.log(chalk.green(message))
+  break() {
+    this.#log({ type: chalk.green, force: this.#force, verbose: this.verbose }, '')
   }
 }

package/src/scan/config.mjs

@@ -0,0 +1,7 @@
+export const details = false
+export const sort = 'count'
+export const imports = ['@spark-ui']
+export const extensions = ['.tsx', '.ts']
+export const directory = '.'
+export const verbose = false
+export const output = null

package/src/scan/index.mjs

@@ -1,49 +1,41 @@
+/* eslint-disable complexity */
+/* eslint-disable max-lines-per-function */
 import * as process from 'node:process'
 
-import { appendFileSync, existsSync } from 'fs'
+import { existsSync, mkdirSync, writeFileSync } from 'fs'
 import path from 'path'
 
+import { Logger } from '../core/index.mjs'
+import * as defaultConfig from './config.mjs'
+import { loadConfig } from './loadConfig.mjs'
 import { scanCallback } from './scanCallback.mjs'
-import { logger, scanDirectories } from './utils/index.mjs'
+import { scanDirectories } from './utils/index.mjs'
 
-const DEFAULT_CONFIG = {
-  adoption: {
-    details: false,
-    sort: 'count',
-    imports: ['@spark-ui'],
-    extensions: ['.tsx', '.ts'],
-    directory: '.',
-  },
-}
+export async function adoption(options = {}) {
+  const { configuration, ...optionsConfig } = options
 
-export async function adoption(options) {
-  let config = DEFAULT_CONFIG
+  const logger = new Logger({ verbose: optionsConfig.verbose })
+  let config = await loadConfig(configuration, { logger })
 
-  const configFileRoute = path.join(process.cwd(), options.configuration || '.spark-ui.cjs')
-  try {
-    if (existsSync(configFileRoute)) {
-      logger.info('ℹ️ Loading spark-ui custom configuration file')
-      const { default: customConfig } = await import(
-        path.join(process.cwd(), options.configuration)
-      )
-      config = structuredClone(customConfig, DEFAULT_CONFIG)
-    } else {
-      logger.warn('⚠️ No custom configuration file found')
-      logger.info('ℹ️ Loading default configuration')
-    }
-  } catch (error) {
-    logger.error('💥 Something went wrong loading the custom configuration file')
+  config = {
+    adoption: {
+      ...config.adoption,
+      ...optionsConfig,
+      imports: optionsConfig.imports || config.adoption.imports,
+      extensions: optionsConfig.extensions || config.adoption.extensions,
+    },
   }
 
-  const extensions = config.adoption.extensions
-
   let importCount = 0
   const importResults = {}
   let importsUsed = {}
   let importsCount = {}
-  config.adoption.imports.forEach(moduleName => {
+
+  const { details, directory, extensions, imports, sort, output } = config.adoption
+
+  imports.forEach(moduleName => {
     logger.info(`ℹ️ Scanning adoption for ${moduleName}`)
-    const directoryPath = path.join(process.cwd(), config.adoption.directory)
+    const directoryPath = path.join(process.cwd(), directory)
 
     const response = scanDirectories(directoryPath, moduleName, extensions, scanCallback, {
       importCount,
@@ -56,7 +48,7 @@ export async function adoption(options) {
         `🎉 Found ${response.importCount - importCount} imports with "${moduleName}" modules across directory ${directoryPath}.`
       )
     } else {
-      logger.warn(
+      logger.warning(
         `⚠️ No files found with "${moduleName}" imports across directory ${directoryPath}.`
       )
     }
@@ -64,7 +56,7 @@ export async function adoption(options) {
   })
 
   // Sort importsUsed by alphabet
-  if (config.adoption.sort === 'alphabetical') {
+  if (sort === 'alphabetical') {
     importsUsed = Object.fromEntries(
       Object.entries(importsUsed)
         .sort(([pkgNameA], [pkgNameB]) => pkgNameA.localeCompare(pkgNameB))
@@ -83,7 +75,7 @@ export async function adoption(options) {
           ]
         })
     )
-  } else if (config.adoption.sort === 'count') {
+  } else if (sort === 'count') {
     // Sort importsUsed by most used
     importsUsed = Object.fromEntries(
       Object.entries(importsUsed)
@@ -110,17 +102,25 @@ export async function adoption(options) {
   const result = Object.fromEntries(
     Object.entries(importsUsed).map(([pkgName, value]) => [
       pkgName,
-      { ...value, ...(config.adoption.details && { results: importResults[pkgName] }) },
+      { ...value, ...(details && { results: importResults[pkgName] }) },
     ])
   )
 
-  if (options.output) {
+  if (output) {
     try {
-      appendFileSync(`${options.output}`, JSON.stringify(result, null, 2))
-    } catch (err) {
-      logger.error(`💥 Error writing file: ${err}`)
+      const { dir } = path.parse(path.join(process.cwd(), output))
+      if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true })
+      }
+      writeFileSync(`${path.join(process.cwd(), output)}`, JSON.stringify(result, null, 2))
+    } catch (error) {
+      logger.error(`💥 Error writing file: ${error}`)
+      process.exit(1)
     }
   } else {
-    logger.info(JSON.stringify(result, null, 2))
+    logger.force().info(JSON.stringify(result, null, 2))
+    process.exit(0)
   }
 }
+
+export const config = { ...defaultConfig }

package/src/scan/loadConfig.mjs

@@ -0,0 +1,40 @@
+import process from 'node:process'
+
+import { existsSync } from 'fs'
+import path from 'path'
+
+import * as defaultConfig from './config.mjs'
+
+export async function loadConfig(configuration, { logger }) {
+  try {
+    const configFileRoute = path.join(process.cwd(), configuration || '.spark-ui.cjs')
+    if (existsSync(configFileRoute)) {
+      logger.info('ℹ️ Loading spark-ui custom configuration file')
+      const { default: customConfig } = await import(configFileRoute)
+
+      const config = {
+        adoption: {
+          ...defaultConfig,
+          ...customConfig.adoption,
+          imports: customConfig.adoption.imports || defaultConfig.imports,
+          extensions: customConfig.adoption.extensions || defaultConfig.extensions,
+        },
+      }
+
+      return config
+    } else {
+      if (configuration) {
+        logger.error('⚠️ No custom configuration file found:', configFileRoute)
+        process.exit(1)
+      }
+      logger.warning('⚠️ No custom configuration file found')
+      logger.info('ℹ️ Loading default configuration')
+
+      return { ...defaultConfig }
+    }
+  } catch (error) {
+    logger.error('💥 Something went wrong loading the custom configuration file', error)
+
+    return { ...defaultConfig }
+  }
+}

package/src/scan/utils/index.mjs

@@ -1,5 +1,4 @@
 export { extractImports } from './extract-imports.mjs'
 export { fileContainsImport } from './file-contains-import.mjs'
 export { getFormatedTimestamp } from './get-formated-timestamp.mjs'
-export { logger } from './logger.mjs'
 export { scanDirectories } from './scan-directories.mjs'

package/test/spark-generate.test.ts

@@ -12,21 +12,28 @@ const cliPath = path.join(__dirname, '../../bin/spark.mjs')
 const cliProcess = cmd.create(cliPath)
 
 describe('CLI `spark generate` (component package)', () => {
-  it('should properly generate package from CLI when arguments are valid', async () => {
-    // GIVEN a package definition
-    const packageName = 'bar'
-    const packageType = 'component'
+  const packageType = 'component'
+
+  const contextPath = TemplateGenerator.CONTEXTS[packageType] as string
+
+  const packagePath = path.join(process.cwd(), 'packages', contextPath, 'bar')
+  const invalidPackagePath = path.join(process.cwd(), 'packages', contextPath, '123')
+
+  beforeEach(() => {
+    if (fse.existsSync(packagePath)) fse.removeSync(packagePath)
+  })
+
+  afterAll(() => {
+    if (fse.existsSync(packagePath)) fse.removeSync(packagePath)
+  })
 
-    // WHEN we execute the `spark generate` command
+  it('should properly generate package from CLI when arguments are valid', async () => {
     const response = await cliProcess.execute(
       ['generate'],
-      [packageName, ENTER, packageType, ENTER, 'This is my foo component', ENTER]
+      ['bar', ENTER, packageType, ENTER, 'This is my foo component', ENTER]
     )
-    const contextPath = TemplateGenerator.CONTEXTS[packageType] as string
-    const packagePath = path.join(process.cwd(), 'packages', contextPath, packageName)
 
-    // THEN each file is created and the user is informed about it
-    const expectedFiles = [
+    ;[
       '/.npmignore',
       '/package.json',
       '/src/index.ts',
@@ -37,33 +44,19 @@ describe('CLI `spark generate` (component package)', () => {
       '/src/Bar.test.tsx',
       '/src/Bar.stories.tsx',
       '/tsconfig.json',
-    ]
-
-    const assertExpectedFiles = (filePath: string) => {
+    ].forEach((filePath: string) => {
       expect(response).toContain(`Created ${packagePath}${filePath}`)
       expect(fse.pathExistsSync(`${packagePath}${filePath}`)).toBe(true)
-    }
-
-    expectedFiles.forEach(assertExpectedFiles)
-
-    // Finally we clean up the generated component package
-    fse.removeSync(packagePath)
+    })
   })
 
   it('should prevent generating package when argument are invalid', async () => {
-    // GIVEN the package name is not using kebab-case notation
-    const packageName = '123'
-    const packageType = 'component'
-
-    // WHEN we try to create it
-    const response = await cliProcess.execute(['generate'], [packageName, ENTER])
-    const contextPath = TemplateGenerator.CONTEXTS[packageType] as string
-    const packagePath = path.join(process.cwd(), 'packages', contextPath, packageName)
+    const response = await cliProcess.execute(['generate'], ['123', ENTER])
 
-    // THEN it throws an error and fails to create files for this package
     expect(response).toContain(
       'Name name must contain letters and dash symbols only (ex: "my-package")'
     )
-    expect(fse.pathExistsSync(packagePath)).toBe(false)
+
+    expect(fse.pathExistsSync(invalidPackagePath)).toBe(false)
   })
 })

package/src/scan/utils/logger.mjs

@@ -1,19 +0,0 @@
-import chalk from 'chalk'
-
-export const logger = {
-  error(...args) {
-    console.log(chalk.red(...args))
-  },
-  warn(...args) {
-    console.log(chalk.yellow(...args))
-  },
-  info(...args) {
-    console.log(chalk.cyan(...args))
-  },
-  success(...args) {
-    console.log(chalk.green(...args))
-  },
-  break() {
-    console.log('')
-  },
-}