@newlogic-digital/cli 1.2.2 → 1.3.0

package/index.mjs

@@ -5,8 +5,58 @@ import cms from './src/commands/cms/index.mjs'
 import pc from 'picocolors'
 import { version, name } from './src/utils.mjs'
 
-const args = process.argv.slice(2)
-const command = args[0]
+function normalizeOptionName(name) {
+    return name.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase())
+}
+
+function parseCommandArgs(args) {
+    const positionals = []
+    const options = {}
+
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i]
+
+        if (arg === '-y') {
+            options.y = true
+            continue
+        }
+
+        if (!arg.startsWith('--')) {
+            positionals.push(arg)
+            continue
+        }
+
+        if (arg.startsWith('--no-')) {
+            options[normalizeOptionName(arg.slice(5))] = false
+            continue
+        }
+
+        if (arg.includes('=')) {
+            const splitIndex = arg.indexOf('=')
+            const key = normalizeOptionName(arg.slice(2, splitIndex))
+            const value = arg.slice(splitIndex + 1)
+
+            options[key] = value || true
+            continue
+        }
+
+        const key = normalizeOptionName(arg.slice(2))
+        const nextArg = args[i + 1]
+
+        if (nextArg && !nextArg.startsWith('-')) {
+            options[key] = nextArg
+            i++
+            continue
+        }
+
+        options[key] = true
+    }
+
+    return { positionals, options }
+}
+
+const rawArgs = process.argv.slice(2)
+const command = rawArgs[0]
 
 if (!command) {
     console.log(`
@@ -21,6 +71,9 @@ if (!command) {
         ${pc.green('newlogic init ui')} ${pc.yellow('<directory>')} - Creates a new ${pc.blue('@newlogic-digital/ui')} project in new directory with the name ${pc.yellow('<directory>')}
         ${pc.green('newlogic init cms')} - Creates a new ${pc.blue('@newlogic-digital/cms')} project in current directory
         ${pc.green('newlogic init cms')} ${pc.yellow('<directory>')} - Creates a new ${pc.blue('@newlogic-digital/cms')} project in new directory with the name ${pc.yellow('<directory>')}
+        ${pc.green('newlogic init ui')} ${pc.yellow('<directory>')} ${pc.cyan('--branch=dev --clone=https --git --remote=<git-url> --install')}
+        ${pc.green('newlogic init cms')} ${pc.yellow('<directory>')} ${pc.cyan('--branch=dev --clone=https --variant=cms-web --install --prepare --dev --migrations')}
+        ${pc.green('newlogic init ui')} ${pc.yellow('<directory>')} ${pc.cyan('-y')} - Runs with default options without prompts
         
         -- cms --
         ${pc.green('newlogic cms prepare')} - Copies templates and components from ${pc.blue('@newlogic-digital/ui')} project to ${pc.blue('@newlogic-digital/cms')}
@@ -34,15 +87,17 @@ if (!command) {
 }
 
 if (command === 'init') {
-    const action = args[1]
-    const name = args[2]
+    const { positionals, options } = parseCommandArgs(rawArgs.slice(1))
+    const action = positionals[0]
+    const name = positionals[1]
 
-    await init(action, name)
+    await init(action, name, options)
 }
 
 if (command === 'cms') {
-    const action = args[1]
-    const name = args[2]
+    const { positionals } = parseCommandArgs(rawArgs.slice(1))
+    const action = positionals[0]
+    const name = positionals[1]
 
     await cms(action, name)
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@newlogic-digital/cli",
-  "version": "1.2.2",
+  "version": "1.3.0",
   "main": "index.mjs",
   "bin": {
     "newlogic-cli": "index.mjs",
@@ -10,12 +10,12 @@
     "eslint": "eslint '**/*.mjs' --fix"
   },
   "dependencies": {
-    "lodash": "^4.17.21",
+    "lodash": "^4.17.23",
     "prompts": "^2.4.2",
-    "fs-extra": "^11.2.0",
+    "fs-extra": "^11.3.3",
     "picocolors": "^1.1.1",
-    "fast-glob": "^3.3.2",
-    "dedent": "^1.5.3"
+    "fast-glob": "^3.3.3",
+    "dedent": "^1.7.1"
   },
   "devDependencies": {
     "eslint-config-standard": "^17.1.0"

package/src/commands/init/cms.mjs

@@ -5,6 +5,7 @@ import os from 'os'
 import pc from 'picocolors'
 import fse from 'fs-extra'
 import prompts from 'prompts'
+import { isAutoYes, normalizeEnum, normalizeYesNo } from './options.mjs'
 
 const tempDir = join(os.tmpdir(), 'newlogic-cms-web')
 
@@ -12,57 +13,74 @@ async function move(path, options = {}) {
     await fse.move(join(tempDir, path), resolve(process.cwd(), path), options).catch(err => console.log(`${pc.red(err)} - ${path}`))
 }
 
-async function clone(path, { variant, branch }) {
+async function clone(path, { variant, branch, clone: cloneOption, y, yes } = {}) {
     if (variant === 'cms-web') {
         variant = 'newlogic-cms-next-web'
     } else if (variant === 'cms-eshop') {
         variant = 'newlogic-cms-next-eshop'
     }
 
-    const { clone } = await prompts([
-        {
-            type: 'select',
-            name: 'clone',
-            message: 'Clone with SSH or HTTPS?',
-            choices: [
-                { title: 'SSH', value: 'ssh' },
-                { title: 'HTTPS', value: 'https' }
-            ]
+    let cloneMethod = normalizeEnum(cloneOption, ['ssh', 'https'])
+    const autoYes = isAutoYes({ y, yes })
+
+    if (!cloneMethod) {
+        if (autoYes) {
+            cloneMethod = 'https'
+        } else {
+            const response = await prompts([
+                {
+                    type: 'select',
+                    name: 'clone',
+                    message: 'Clone with SSH or HTTPS?',
+                    choices: [
+                        { title: 'SSH', value: 'ssh' },
+                        { title: 'HTTPS', value: 'https' }
+                    ]
+                }
+            ])
+
+            cloneMethod = response.clone
         }
-    ])
+    }
 
     let url = ''
 
-    if (clone === 'ssh') {
+    if (cloneMethod === 'ssh') {
         url = 'git@git.newlogic.cz:newlogic-digital'
-    } else if (clone === 'https') {
+    } else if (cloneMethod === 'https') {
         url = 'https://git.newlogic.cz/newlogic-digital'
     }
 
     execSync(`git clone -b ${branch} --single-branch --depth 1 ${url}/${variant}.git ${path}`)
 }
 
-async function install(name, branch) {
-    const { install } = await prompts([
-        {
-            type: 'select',
-            name: 'install',
-            message: 'Install project?',
-            choices: [
-                { title: 'yes', value: 'yes' },
-                { title: 'no', value: 'no' }
-            ]
+async function install(name, branch, { install: installOption, y, yes } = {}) {
+    let install = normalizeYesNo(installOption)
+    const autoYes = isAutoYes({ y, yes })
+
+    if (!install) {
+        if (autoYes) {
+            install = 'yes'
+        } else {
+            const response = await prompts([
+                {
+                    type: 'select',
+                    name: 'install',
+                    message: 'Install project?',
+                    choices: [
+                        { title: 'yes', value: 'yes' },
+                        { title: 'no', value: 'no' }
+                    ]
+                }
+            ])
+
+            install = response.install
         }
-    ])
+    }
 
     if (install === 'yes') {
         execSync(`cd ${name || '.'} && composer install`)
-
-        if (fs.existsSync(resolve(join(process.cwd(), name || ''), 'Makefile'))) {
-            execSync(`cd ${name || '.'} && make install ${branch || ''}`)
-        } else {
-            execSync(`cd ${name || '.'} && composer install-${branch || ''}`)
-        }
+        execSync(`cd ${name || '.'} && composer install-${branch || ''}`)
 
         if (fs.existsSync(resolve(process.cwd(), 'package.json'))) {
             execSync(`cd ${name || '.'} && npm i && npx vite build`)
@@ -70,67 +88,103 @@ async function install(name, branch) {
     }
 }
 
-async function dev(name) {
-    const { install } = await prompts([
-        {
-            type: 'select',
-            name: 'install',
-            message: 'Start dev server?',
-            choices: [
-                { title: 'yes', value: 'yes' },
-                { title: 'no', value: 'no' }
-            ]
+async function dev(name, { dev: devOption, y, yes } = {}) {
+    let shouldStartDev = normalizeYesNo(devOption)
+    const autoYes = isAutoYes({ y, yes })
+
+    if (!shouldStartDev) {
+        if (autoYes) {
+            shouldStartDev = 'no'
+        } else {
+            const response = await prompts([
+                {
+                    type: 'select',
+                    name: 'install',
+                    message: 'Start dev server?',
+                    choices: [
+                        { title: 'yes', value: 'yes' },
+                        { title: 'no', value: 'no' }
+                    ]
+                }
+            ])
+
+            shouldStartDev = response.install
         }
-    ])
+    }
 
-    if (install === 'yes') {
+    if (shouldStartDev === 'yes') {
         execSync(`cd ${name || '.'} && composer dev-headless`)
     }
 }
 
-async function migrations(name) {
-    const { install } = await prompts([
-        {
-            type: 'select',
-            name: 'install',
-            message: 'Init phinx migrations and seed?',
-            choices: [
-                { title: 'yes', value: 'yes' },
-                { title: 'no', value: 'no' }
-            ]
+async function migrations(name, { migrations: migrationsOption, y, yes } = {}) {
+    let shouldInitMigrations = normalizeYesNo(migrationsOption)
+    const autoYes = isAutoYes({ y, yes })
+
+    if (!shouldInitMigrations) {
+        if (autoYes) {
+            shouldInitMigrations = 'no'
+        } else {
+            const response = await prompts([
+                {
+                    type: 'select',
+                    name: 'install',
+                    message: 'Init phinx migrations and seed?',
+                    choices: [
+                        { title: 'yes', value: 'yes' },
+                        { title: 'no', value: 'no' }
+                    ]
+                }
+            ])
+
+            shouldInitMigrations = response.install
         }
-    ])
+    }
 
-    if (install === 'yes') {
+    if (shouldInitMigrations === 'yes') {
         execSync(`cd ${name || '.'} && composer phinx-init`)
     }
 }
 
-async function prepare() {
-    const { install } = await prompts([
-        {
-            type: 'select',
-            name: 'install',
-            message: 'Prepare project with templates from frontend?',
-            choices: [
-                { title: 'yes', value: 'yes' },
-                { title: 'no', value: 'no' }
-            ]
+async function prepare({ prepare: prepareOption, y, yes } = {}) {
+    let shouldPrepare = normalizeYesNo(prepareOption)
+    const autoYes = isAutoYes({ y, yes })
+
+    if (!shouldPrepare) {
+        if (autoYes) {
+            shouldPrepare = 'no'
+        } else {
+            const response = await prompts([
+                {
+                    type: 'select',
+                    name: 'install',
+                    message: 'Prepare project with templates from frontend?',
+                    choices: [
+                        { title: 'yes', value: 'yes' },
+                        { title: 'no', value: 'no' }
+                    ]
+                }
+            ])
+
+            shouldPrepare = response.install
         }
-    ])
+    }
 
-    if (install === 'yes') {
+    if (shouldPrepare === 'yes') {
         execSync('newlogic cms prepare')
     }
 }
 
-export default async function cms(name, { variant, branch }) {
+export default async function cms(name, { variant, branch, ...options } = {}) {
     if (name) {
-        await clone(name, { variant, branch })
-        await install(name, branch)
-        await prepare()
-        await dev()
-        await migrations()
+        if (!fs.existsSync(resolve(process.cwd(), name))) {
+            await clone(name, { variant, branch, clone: options.clone, y: options.y, yes: options.yes })
+        }
+
+        await install(name, branch, { install: options.install, y: options.y, yes: options.yes })
+        await prepare({ prepare: options.prepare, y: options.y, yes: options.yes })
+        await dev(name, { dev: options.dev, y: options.y, yes: options.yes })
+        await migrations(name, { migrations: options.migrations, y: options.y, yes: options.yes })
         return
     }
 
@@ -139,7 +193,7 @@ export default async function cms(name, { variant, branch }) {
             fse.removeSync(tempDir)
         }
 
-        await clone(tempDir, { variant, branch })
+        await clone(tempDir, { variant, branch, clone: options.clone, y: options.y, yes: options.yes })
 
         await move('.docker')
         await move('app')
@@ -168,8 +222,8 @@ export default async function cms(name, { variant, branch }) {
         console.log(pc.yellow('Project files already exist in the directory, skipping copy step (delete composer.json to force)'))
     }
 
-    await install(name, branch)
-    await prepare()
-    await dev()
-    await migrations()
+    await install(name, branch, { install: options.install, y: options.y, yes: options.yes })
+    await prepare({ prepare: options.prepare, y: options.y, yes: options.yes })
+    await dev(name, { dev: options.dev, y: options.y, yes: options.yes })
+    await migrations(name, { migrations: options.migrations, y: options.y, yes: options.yes })
 }

package/src/commands/init/index.mjs

@@ -1,72 +1,99 @@
 import prompts from 'prompts'
 import ui from './ui.mjs'
 import cms from './cms.mjs'
+import { isAutoYes, normalizeEnum } from './options.mjs'
 
-async function init(project, name) {
+async function init(project, name, options = {}) {
     const nameAsProject = (project && !project.match(/^(ui|cms)$/))
+    const autoYes = isAutoYes(options)
+
+    name = nameAsProject ? project : name
 
     if (!project || nameAsProject) {
-        const response = await prompts([
-            {
-                type: 'select',
-                name: 'project',
-                message: 'Select a project to init',
-                choices: [
-                    { title: 'ui', value: 'ui' },
-                    { title: 'cms', value: 'cms' }
-                ],
-                onState: (state) => {
-                    if (state.aborted) {
-                        process.exit(1)
+        if (autoYes) {
+            project = 'ui'
+        } else {
+            const response = await prompts([
+                {
+                    type: 'select',
+                    name: 'project',
+                    message: 'Select a project to init',
+                    choices: [
+                        { title: 'ui', value: 'ui' },
+                        { title: 'cms', value: 'cms' }
+                    ],
+                    onState: (state) => {
+                        if (state.aborted) {
+                            process.exit(1)
+                        }
                     }
                 }
-            }
-        ])
+            ])
 
-        name = nameAsProject ? project : name
-        project = response.project
+            project = response.project
+        }
     }
 
-    const { branch } = await prompts([
-        {
-            type: 'select',
-            name: 'branch',
-            message: 'Select a git branch',
-            choices: [
-                { title: 'main', value: 'main' },
-                { title: 'dev', value: 'dev' }
-            ],
-            onState: (state) => {
-                if (state.aborted) {
-                    process.exit(1)
+    let branch = normalizeEnum(options.branch, ['main', 'dev'])
+
+    if (!branch) {
+        if (autoYes) {
+            branch = 'main'
+        } else {
+            const response = await prompts([
+                {
+                    type: 'select',
+                    name: 'branch',
+                    message: 'Select a git branch',
+                    choices: [
+                        { title: 'main', value: 'main' },
+                        { title: 'dev', value: 'dev' }
+                    ],
+                    onState: (state) => {
+                        if (state.aborted) {
+                            process.exit(1)
+                        }
+                    }
                 }
-            }
+            ])
+
+            branch = response.branch
         }
-    ])
+    }
 
     if (project === 'ui') {
-        await ui(name, { branch })
+        await ui(name, { ...options, branch })
     }
 
     if (project === 'cms') {
-        const { variant } = await prompts([
-            {
-                type: 'select',
-                name: 'variant',
-                message: 'Select a variant to install',
-                choices: [
-                    { title: 'cms-web', value: 'cms-web' },
-                    { title: 'cms-eshop', value: 'cms-eshop' }
-                ],
-                onState: (state) => {
-                    if (state.aborted) {
-                        process.exit(1)
+        let variant = normalizeEnum(options.variant, ['cms-web', 'cms-eshop'])
+
+        if (!variant) {
+            if (autoYes) {
+                variant = 'cms-web'
+            } else {
+                const response = await prompts([
+                    {
+                        type: 'select',
+                        name: 'variant',
+                        message: 'Select a variant to install',
+                        choices: [
+                            { title: 'cms-web', value: 'cms-web' },
+                            { title: 'cms-eshop', value: 'cms-eshop' }
+                        ],
+                        onState: (state) => {
+                            if (state.aborted) {
+                                process.exit(1)
+                            }
+                        }
                     }
-                }
+                ])
+
+                variant = response.variant
             }
-        ])
+        }
 
-        await cms(name, { branch, variant })
+        await cms(name, { ...options, branch, variant })
     }
 }
 

package/src/commands/init/options.mjs

@@ -0,0 +1,47 @@
+function normalizeEnum(value, allowed = []) {
+    if (typeof value !== 'string') {
+        return undefined
+    }
+
+    const normalized = value.trim().toLowerCase()
+
+    if (!allowed.includes(normalized)) {
+        return undefined
+    }
+
+    return normalized
+}
+
+function normalizeYesNo(value) {
+    if (typeof value === 'boolean') {
+        return value ? 'yes' : 'no'
+    }
+
+    if (typeof value !== 'string') {
+        return undefined
+    }
+
+    const normalized = value.trim().toLowerCase()
+
+    if (['yes', 'y', 'true', '1'].includes(normalized)) {
+        return 'yes'
+    }
+
+    if (['no', 'n', 'false', '0'].includes(normalized)) {
+        return 'no'
+    }
+
+    return undefined
+}
+
+function isAutoYes(options = {}) {
+    const values = [normalizeYesNo(options.y), normalizeYesNo(options.yes)]
+
+    if (values.includes('no')) {
+        return false
+    }
+
+    return values.includes('yes')
+}
+
+export { normalizeEnum, normalizeYesNo, isAutoYes }

package/src/commands/init/ui.mjs

@@ -2,19 +2,31 @@ import { execSync } from '../../utils.mjs'
 import fse from 'fs-extra'
 import prompts from 'prompts'
 import { join, resolve } from 'path'
+import { isAutoYes, normalizeEnum, normalizeYesNo } from './options.mjs'
 
-export default async function ui(name, { branch }) {
-    const { clone } = await prompts([
-        {
-            type: 'select',
-            name: 'clone',
-            message: 'Clone with SSH or HTTPS?',
-            choices: [
-                { title: 'SSH', value: 'ssh' },
-                { title: 'HTTPS', value: 'https' }
-            ]
+export default async function ui(name, { branch, ...options } = {}) {
+    const autoYes = isAutoYes(options)
+    let clone = normalizeEnum(options.clone, ['ssh', 'https'])
+
+    if (!clone) {
+        if (autoYes) {
+            clone = 'https'
+        } else {
+            const response = await prompts([
+                {
+                    type: 'select',
+                    name: 'clone',
+                    message: 'Clone with SSH or HTTPS?',
+                    choices: [
+                        { title: 'SSH', value: 'ssh' },
+                        { title: 'HTTPS', value: 'https' }
+                    ]
+                }
+            ])
+
+            clone = response.clone
         }
-    ])
+    }
 
     let url = ''
 
@@ -30,43 +42,71 @@ export default async function ui(name, { branch }) {
 
     fse.removeSync(gitPath)
 
-    const { git } = await prompts([
-        {
-            type: 'select',
-            name: 'git',
-            message: 'Init as git repository?',
-            choices: [
-                { title: 'yes', value: 'yes' },
-                { title: 'no', value: 'no' }
-            ]
+    let git = normalizeYesNo(options.git)
+
+    if (!git) {
+        if (autoYes) {
+            git = 'no'
+        } else {
+            const response = await prompts([
+                {
+                    type: 'select',
+                    name: 'git',
+                    message: 'Init as git repository?',
+                    choices: [
+                        { title: 'yes', value: 'yes' },
+                        { title: 'no', value: 'no' }
+                    ]
+                }
+            ])
+
+            git = response.git
         }
-    ])
+    }
 
     if (git === 'yes') {
         execSync(`git init ${name || ''}`)
 
-        const { remote } = await prompts([
-            {
-                type: 'text',
-                name: 'remote',
-                message: 'Set remote for git repository'
-            }
-        ])
+        let remote = (typeof options.remote === 'string' && options.remote.trim()) ? options.remote.trim() : undefined
+
+        if (!remote && !autoYes) {
+            const response = await prompts([
+                {
+                    type: 'text',
+                    name: 'remote',
+                    message: 'Set remote for git repository'
+                }
+            ])
 
-        execSync(`cd ${name || '.'} && git remote add origin ${remote} ${name ? '&& cd ..' : ''}`)
+            remote = response.remote
+        }
+
+        if (remote) {
+            execSync(`cd ${name || '.'} && git remote add origin ${remote} ${name ? '&& cd ..' : ''}`)
+        }
     }
 
-    const { install } = await prompts([
-        {
-            type: 'select',
-            name: 'install',
-            message: 'Install project?',
-            choices: [
-                { title: 'yes', value: 'yes' },
-                { title: 'no', value: 'no' }
-            ]
+    let install = normalizeYesNo(options.install)
+
+    if (!install) {
+        if (autoYes) {
+            install = 'yes'
+        } else {
+            const response = await prompts([
+                {
+                    type: 'select',
+                    name: 'install',
+                    message: 'Install project?',
+                    choices: [
+                        { title: 'yes', value: 'yes' },
+                        { title: 'no', value: 'no' }
+                    ]
+                }
+            ])
+
+            install = response.install
         }
-    ])
+    }
 
     if (install === 'yes') {
         execSync(`cd ${name || '.'} && npm i`)