@lakutata/cli 1.0.36 → 2.1.0-alpha.4

package/src/lib/providers/Information.ts

@@ -0,0 +1,221 @@
+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

@@ -0,0 +1,82 @@
+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

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

package/tsconfig.json

@@ -1,37 +1,7 @@
 {
+  "extends": "../../tsconfig.json",
   "compilerOptions": {
-    "strict": true,
-    "module": "CommonJS",
-    "target": "ES2017",
-    "declaration": true,
-    "sourceMap": true,
-    "emitDecoratorMetadata": true,
-    "experimentalDecorators": true,
-    "removeComments": true,
-    "allowJs": true,
-    "pretty": true,
-    "noUnusedLocals": false,
-    "noImplicitAny": false,
-    "noUnusedParameters": false,
-    "outDir": "build",
     "rootDir": "src",
-    "moduleResolution": "Node",
-    "esModuleInterop": true,
-    "resolveJsonModule": false,
-    "strictPropertyInitialization": false,
-    "types": [
-      "reflect-metadata",
-      "node"
-    ],
-    "lib": [
-      "ESNext",
-      "ES2017",
-      "dom"
-    ]
-  },
-  "exclude": [
-    "node_modules",
-    "build",
-    "outputs"
-  ]
+    "outDir": "dist"
+  }
 }

package/.eslintrc.json

@@ -1,47 +0,0 @@
-{
-  "env": {
-    "browser": true,
-    "es6": true,
-    "node": true,
-    "mocha": true
-  },
-  "extends": [
-    "plugin:@typescript-eslint/recommended"
-  ],
-  "globals": {
-    "Atomics": "readonly",
-    "SharedArrayBuffer": "readonly"
-  },
-  "parserOptions": {
-    "ecmaVersion": 2018,
-    "sourceType": "module"
-  },
-  "plugins": [
-    "typescript",
-    "@typescript-eslint"
-  ],
-  "rules": {
-    "quotes": [
-      "error",
-      "single"
-    ],
-    "semi": [
-      "error",
-      "never"
-    ],
-    "comma-dangle": "error",
-    "prefer-spread": "off",
-    "strict": "off",
-    "prefer-rest-params": "off",
-    "no-duplicate-imports": "error",
-    "@typescript-eslint/no-explicit-any": "off",
-    "@typescript-eslint/explicit-function-return-type": "off",
-    "@typescript-eslint/no-namespace": "off",
-    "@typescript-eslint/no-empty-interface": "off",
-    "@typescript-eslint/no-unused-vars": "off",
-    "@typescript-eslint/no-inferrable-types": "off",
-    "@typescript-eslint/no-empty-function": "off",
-    "@typescript-eslint/ban-types": "off",
-    "@typescript-eslint/ban-ts-ignore": "off"
-  }
-}

package/.idea/codeStyles/Project.xml

@@ -1,18 +0,0 @@
-<component name="ProjectCodeStyleConfiguration">
-  <code_scheme name="Project" version="173">
-    <JSCodeStyleSettings version="0">
-      <option name="USE_SEMICOLON_AFTER_STATEMENT" value="false" />
-      <option name="FORCE_SEMICOLON_STYLE" value="true" />
-      <option name="USE_DOUBLE_QUOTES" value="false" />
-      <option name="FORCE_QUOTE_STYlE" value="true" />
-      <option name="ENFORCE_TRAILING_COMMA" value="Remove" />
-    </JSCodeStyleSettings>
-    <TypeScriptCodeStyleSettings version="0">
-      <option name="USE_SEMICOLON_AFTER_STATEMENT" value="false" />
-      <option name="FORCE_SEMICOLON_STYLE" value="true" />
-      <option name="USE_DOUBLE_QUOTES" value="false" />
-      <option name="FORCE_QUOTE_STYlE" value="true" />
-      <option name="ENFORCE_TRAILING_COMMA" value="Remove" />
-    </TypeScriptCodeStyleSettings>
-  </code_scheme>
-</component>

package/.idea/codeStyles/codeStyleConfig.xml

@@ -1,5 +0,0 @@
-<component name="ProjectCodeStyleConfiguration">
-  <state>
-    <option name="USE_PER_PROJECT_SETTINGS" value="true" />
-  </state>
-</component>