@lakutata/cli 2.1.0-alpha.4 → 2.2.0

package/src/lib/components/Spinner.ts

@@ -1,48 +0,0 @@
-import {type Spinner as CliSpinner, dots} from 'cli-spinners'
-import {Configurable, Singleton} from 'lakutata/decorator/di'
-import {Component} from 'lakutata'
-import {As} from 'lakutata/helper'
-
-@Singleton()
-export class Spinner extends Component {
-
-    @Configurable()
-    protected readonly style: CliSpinner = dots
-
-    protected spinnerInterval: NodeJS.Timeout | null = null
-
-    protected logUpdate: any
-
-    /**
-     * Initializer
-     * @protected
-     */
-    protected async init(): Promise<void> {
-        this.logUpdate = As(await import('log-update'))
-    }
-
-    /**
-     * Start spinner
-     * @param description
-     */
-    public start(description?: string | (() => string)): void {
-        this.stop()
-        let i: number = 0
-        this.spinnerInterval = setInterval((): void => {
-            const {frames} = this.style
-            const text: string = description ? `${frames[i = ++i % frames.length]} ${typeof description === 'function' ? description() : description}` : frames[i = ++i % frames.length]
-            this.logUpdate(text)
-        }, dots.interval)
-    }
-
-    /**
-     * Stop spinner
-     */
-    public stop(): void {
-        if (this.spinnerInterval) {
-            clearInterval(this.spinnerInterval)
-            this.spinnerInterval = null
-            this.logUpdate.clear()
-        }
-    }
-}

package/src/lib/providers/Creator.ts

@@ -1,125 +0,0 @@
-import {Information} from './Information.js'
-import {DeGitPuller} from '../components/DeGitPuller.js'
-import {Spinner} from '../components/Spinner.js'
-import {CreateProjectOptions} from '../../options/CreateProjectOptions.js'
-import {ProjectTypeConfig} from '../ProjectTypeConfig.js'
-import path from 'node:path'
-import {mkdir, readdir, stat} from 'node:fs/promises'
-import {Stats} from 'node:fs'
-import {charCheck, charCross} from '../SpecialChar.js'
-import {Application, Provider} from 'lakutata'
-import {Inject} from 'lakutata/decorator/di'
-import {Logger} from 'lakutata/com/logger'
-import {IsExists} from 'lakutata/helper'
-import {Accept} from 'lakutata/decorator/dto'
-import ansis from 'ansis'
-import CLITable from 'cli-table3'
-
-export class Creator extends Provider {
-
-    @Inject(Application)
-    protected readonly app: Application
-
-    @Inject('log')
-    protected readonly log: Logger
-
-    @Inject('spinner')
-    protected readonly spinner: Spinner
-
-    @Inject('puller')
-    protected readonly puller: DeGitPuller
-
-    @Inject('info')
-    protected readonly frameworkInfo: Information
-
-    /**
-     * Check if the target path exists
-     * @param targetDirectory
-     * @param initOnly
-     * @protected
-     */
-    protected async checkTargetPathExistence(targetDirectory: string, initOnly: boolean): Promise<void> {
-        const exists: boolean = await IsExists(targetDirectory)
-        if (!exists && initOnly) {
-            this.log.error(`${charCross} The target path does not exist.`)
-            return this.app.exit(1)
-        }
-        await mkdir(targetDirectory, {recursive: true})
-        this.log.info(`${charCheck} The target path does not exist.`)
-    }
-
-    /**
-     * Check target path is a valid directory
-     * @param targetDirectory
-     * @protected
-     */
-    protected async checkTargetPathIsDirectory(targetDirectory: string): Promise<void> {
-        const targetInfo: Stats = await stat(targetDirectory)
-        if (!targetInfo.isDirectory()) {
-            this.log.error(`${charCross} The target path is not a valid directory.`)
-            return this.app.exit(1)
-        }
-        this.log.info(`${charCheck} The target path is a valid directory.`)
-    }
-
-    /**
-     * Check target directory is empty, if the target directory is not empty, throw error and exit
-     * @param targetDirectory
-     * @protected
-     */
-    protected async checkTargetDirectoryIsEmpty(targetDirectory: string): Promise<void> {
-        const files: string[] = await readdir(targetDirectory)
-        if (files.length) {
-            this.log.error(`${charCross} The target directory is not empty.`)
-            return this.app.exit(1)
-        }
-        this.log.info(`${charCheck} The target directory is empty.`)
-    }
-
-    /**
-     * Exec create
-     * @param options
-     */
-    @Accept(CreateProjectOptions.required())
-    public async create(options: CreateProjectOptions): Promise<void> {
-        const appName: string = options.name
-        const appId: string = options.id
-        const appDescription: string = options.description
-        const packageName: string = appId
-        const authorName: string = options.author
-        const licenseName: string = options.license
-        const appType: string = options.type
-        const targetPath: string = options.initOnly ? path.resolve(options.path) : path.resolve(options.path, options.name)
-        const {branch} = ProjectTypeConfig[appType]
-        const table: CLITable.Table = new CLITable()
-        table.push(
-            [{content: ansis.bold.cyan('Project Creation Information'), colSpan: 2, hAlign: 'center'}],
-            [ansis.blue('APP ID & Project Name'), appId],
-            [ansis.blue('APP Name'), appName],
-            [ansis.blue('APP Description'), appDescription],
-            [ansis.blue('Project Create Target Path'), targetPath],
-            [ansis.blue('Project Create Mode'), options.initOnly ? ansis.yellow('Initialize project in an existing directory') : ansis.green('Create a new folder for the project')],
-            [ansis.blue('Project Author Name'), authorName],
-            [ansis.blue('Project License'), licenseName],
-            [ansis.blue('Project Template Branch'), this.puller.getGitSource(branch)]
-        )
-        console.log(table.toString())
-        await new Promise<void>(resolve => {
-            let timeLeft: number = 15
-            const interval: NodeJS.Timeout = setInterval((): void => {
-                timeLeft -= 1
-                if (!timeLeft) {
-                    clearInterval(interval)
-                    this.spinner.stop()
-                    return resolve()
-                }
-            }, 1000)
-            this.spinner.start((): string => `Please confirm the project creation information; the creation process will commence in ${timeLeft} seconds.`)
-        })
-        await this.checkTargetPathExistence(targetPath, options.initOnly)
-        await this.checkTargetPathIsDirectory(targetPath)
-        await this.checkTargetDirectoryIsEmpty(targetPath)
-        this.log.info('Begin project creation')
-        //TODO
-    }
-}

package/src/lib/providers/Information.ts

@@ -1,221 +0,0 @@
-import ansis from 'ansis'
-import {dirname, resolve} from 'node:path'
-import {readFile} from 'node:fs/promises'
-import {DTO, Provider, Time} from 'lakutata'
-import {Configurable} from 'lakutata/decorator/di'
-import {DevNull} from 'lakutata/helper'
-
-export class Information extends Provider {
-
-    @Configurable(DTO.String().required())
-    protected readonly name: string
-
-    @Configurable(DTO.String().required())
-    protected readonly version: string
-
-    @Configurable(DTO.String().required())
-    protected readonly description: string
-
-    @Configurable(DTO.String().required())
-    protected readonly license: string
-
-    @Configurable(DTO.String().required())
-    protected readonly currentDirectory: string
-
-    @Configurable(DTO.String().required())
-    protected readonly workingDirectory: string
-
-    protected packageDirectory: (options?: any) => Promise<string | undefined>
-
-    protected installPath: string
-
-    protected projectRoot: string | null
-
-    /**
-     * Initializer
-     * @protected
-     */
-    protected async init(): Promise<void> {
-        const {packageDirectory} = await import('pkg-dir')
-        this.packageDirectory = packageDirectory
-        const installPath: string | undefined = await packageDirectory({cwd: this.currentDirectory})
-        this.installPath = installPath ? installPath : 'UNKNOWN'
-
-        const projectRoot: string | null = await this.findProjectRoot(this.workingDirectory)
-        if (projectRoot) {
-            const packageJsonPath: string = resolve(projectRoot, './package.json')
-            try {
-                const packageJson = JSON.parse(await readFile(packageJsonPath, {encoding: 'utf-8'}))
-                const dependenciesKeyRegExp: RegExp = new RegExp('dependencies'.toUpperCase())
-                Object.keys(packageJson).forEach((key: string): void => {
-                    if (dependenciesKeyRegExp.test(key.toUpperCase())) {
-                        Object.keys(packageJson[key]).forEach((dependencyName: string) => {
-                            if (dependencyName === this.name) {
-                                this.projectRoot = projectRoot
-                            }
-                        })
-                    }
-                })
-            } catch (e) {
-                DevNull(e)
-            }
-        }
-    }
-
-    /**
-     * To find the root path of the project where the working directory is located
-     * @param path
-     * @private
-     */
-    private async findProjectRoot(path: string): Promise<string | null> {
-        let localRootPath: string | null = null
-        while (true) {
-            const _localRootPath: string | null = await this.findLocalRoot(localRootPath ? dirname(localRootPath) : path)
-            if (!_localRootPath)
-                break
-            else
-                localRootPath = _localRootPath
-        }
-        return localRootPath
-    }
-
-    /**
-     * To locate the root path containing the package.json file
-     * @param path
-     * @private
-     */
-    private async findLocalRoot(path: string): Promise<string | null> {
-        try {
-            const dir: string | undefined = await this.packageDirectory({cwd: path})
-            return dir ? dir : null
-        } catch (e) {
-            return null
-        }
-    }
-
-    /**
-     * Convert string first char to upper case
-     * @param str
-     * @private
-     */
-    private stringFirstCharUpperCase(str: string): string {
-        return str.charAt(0).toUpperCase() + str.slice(1)
-    }
-
-    /**
-     * Format framework ascii logo
-     * @protected
-     */
-    protected formatFrameworkAsciiLogo(): string {
-        const asciiLogo: string = '' +
-            ' _                               _             _            \n' +
-            '| |               _             | |           | |           \n' +
-            '| |        __ _  | | _   _   _  | |_    __ _  | |_    __ _  \n' +
-            '| |       / _` | | |/ / | | | | | __|  / _` | | __|  / _` | \n' +
-            '| |____  | (_| | |   <  | |_| | \\ |_  | (_| | \\ |_  | (_| | \n' +
-            '|______|  \\__,_| |_|\\_\\  \\__,_|  \\__|  \\__,_|  \\__|  \\__,_| \n' +
-            '                                                            '
-        return `${ansis.yellow(asciiLogo)}`
-    }
-
-    /**
-     * Format framework description
-     * @protected
-     */
-    protected formatFrameworkDescription(): string {
-        return `${ansis.bold(this.stringFirstCharUpperCase(this.name))} is ${ansis.blue(this.description)}`
-    }
-
-    /**
-     * Format version text
-     * @protected
-     */
-    protected formatVersionText(): string {
-        return `The current version is ${ansis.bold(this.version)}`
-    }
-
-    /**
-     * Format framework installation path
-     * @protected
-     */
-    protected formatInstallationPath(): string {
-        return `The installation directory path is ${ansis.underline(this.getInstallPath())}`
-    }
-
-    /**
-     * Format current running level
-     * @protected
-     */
-    protected formatRunningLevel(): string {
-        return `Currently running at ${ansis.bold(this.getLevel())} level`
-    }
-
-    /**
-     * Format license
-     * @protected
-     */
-    protected formatLicense(): string {
-        return `${this.stringFirstCharUpperCase(this.name)} is ${ansis.cyan(this.license)} licensed.`
-    }
-
-    /**
-     * Format copyright
-     * @protected
-     */
-    protected formatCopyright(): string {
-        return `Copyright (c) ${new Time().format('YYYY')} ${ansis.bold(this.stringFirstCharUpperCase(this.name))}. All rights reserved.`
-    }
-
-    /**
-     * To retrieve the hierarchy level of the project containing the package under the current command
-     */
-    public getLevel(): 'PROJECT' | 'GLOBAL' {
-        return this.projectRoot ? 'PROJECT' : 'GLOBAL'
-    }
-
-    /**
-     * Locate the root path of the project
-     */
-    public getRoot(): string | null {
-        return this.projectRoot
-    }
-
-    /**
-     * Locate the installation directory
-     */
-    public getInstallPath(): string {
-        return this.installPath
-    }
-
-    /**
-     * Retrieve the framework installation version at the project level
-     */
-    public async getProjectLevelInstalledFrameworkVersion(): Promise<string | null> {
-        const projectRoot: string | null = this.getRoot()
-        if (projectRoot) {
-            try {
-                const version: string = JSON.parse(await readFile(resolve(projectRoot, './node_modules', `./${this.name}/package.json`), {encoding: 'utf-8'})).version
-                return version ? version : null
-            } catch (e) {
-                return null
-            }
-        }
-        return null
-    }
-
-    /**
-     * Print infos
-     */
-    public async print(): Promise<void> {
-        const texts: string[] = [
-            this.formatFrameworkAsciiLogo(),
-            this.formatFrameworkDescription(),
-            this.formatVersionText(),
-            this.formatInstallationPath(),
-            this.formatRunningLevel(),
-            this.formatLicense(),
-            this.formatCopyright()
-        ]
-        console.info(texts.join('\n'))
-    }
-}

package/src/options/CreateProjectOptions.ts

@@ -1,82 +0,0 @@
-import {ProjectTypeConfig} from '../lib/ProjectTypeConfig'
-import {DTO} from 'lakutata'
-import {Expect} from 'lakutata/decorator/dto'
-
-/**
- * Create project options
- */
-export class CreateProjectOptions extends DTO {
-
-    @Expect(
-        DTO
-            .String()
-            .required()
-            .pattern(/^(\w+\.?)*\w+$/)
-            .description('specify the name of the project and application')
-    )
-    public name: string
-
-    @Expect(
-        DTO
-            .String()
-            .required()
-            .pattern(/^(@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/)//Match package json name regex
-            .description('specify the ID of the application')
-    )
-    public id: string
-
-    @Expect(
-        DTO
-            .String()
-            .required()
-            .valid(...Object.keys(ProjectTypeConfig))
-            .description(`select the type of the project (choices: ${Object.keys(ProjectTypeConfig).map((type: string): string => `"${type}"`).join(',')})`)
-    )
-    public type: string
-
-    @Expect(
-        DTO
-            .String()
-            .optional()
-            .default(process.cwd())
-            .description(`specify the path for creating the project (default: "${process.cwd()}")`)
-    )
-    public path: string
-
-    @Expect(
-        DTO
-            .Boolean()
-            .strict(false)
-            .optional()
-            .default(false)
-            .description('initialize project only in specified directory without creating a new folder (default: false)')
-    )
-    public initOnly: boolean
-
-    @Expect(
-        DTO
-            .String()
-            .optional()
-            .default('none')
-            .description('specify the description of the application (default: "none")')
-    )
-    public description: string
-
-    @Expect(
-        DTO
-            .String()
-            .optional()
-            .default('Anonymous')
-            .description('specify the name of the author of the application (default: "Anonymous")')
-    )
-    public author: string
-
-    @Expect(
-        DTO
-            .String()
-            .optional()
-            .default('UNLICENSED')
-            .description('specify the name of the license for the application (default: "UNLICENSED")')
-    )
-    public license: string
-}

package/src/options/LakutataInfoOptions.ts

@@ -1,4 +0,0 @@
-import {DTO} from 'lakutata'
-
-export class LakutataInfoOptions extends DTO {
-}