@gadmin2n/cli 0.0.73

package/actions/new.action.js

@@ -0,0 +1,294 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exit = exports.retrieveCols = exports.NewAction = void 0;
+const chalk = require("chalk");
+const child_process_1 = require("child_process");
+const fs = require("fs");
+const inquirer = require("inquirer");
+const path_1 = require("path");
+const util_1 = require("util");
+const commands_1 = require("../commands");
+const defaults_1 = require("../lib/configuration/defaults");
+const package_managers_1 = require("../lib/package-managers");
+const questions_1 = require("../lib/questions/questions");
+const git_runner_1 = require("../lib/runners/git.runner");
+const schematics_1 = require("../lib/schematics");
+const ui_1 = require("../lib/ui");
+const formatting_1 = require("../lib/utils/formatting");
+const abstract_action_1 = require("./abstract.action");
+class NewAction extends abstract_action_1.AbstractAction {
+    handle(inputs, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const directoryOption = options.find((option) => option.name === 'directory');
+            const dryRunOption = options.find((option) => option.name === 'dry-run');
+            const isDryRunEnabled = dryRunOption && dryRunOption.value;
+            yield askForMissingInformation(inputs, options);
+            console.info();
+            yield generateApplicationFiles(inputs, options).catch(exports.exit);
+            const shouldSkipInstall = options.some((option) => option.name === 'skip-install' && option.value === true);
+            const shouldSkipGit = options.some((option) => option.name === 'skip-git' && option.value === true);
+            const projectDirectory = getProjectDirectory(getApplicationNameInput(inputs), directoryOption);
+            if (!shouldSkipInstall) {
+                if (options.find(option => option.name === 'server-framework' && option.value === 'nest')) {
+                    console.info('Begin to install server dependence ...');
+                    yield installPackages(options, isDryRunEnabled, (0, path_1.join)(projectDirectory, 'server'));
+                    console.info();
+                }
+                if (options.find(option => option.name === 'with-web' && option.value === true)) {
+                    console.info('Begin to install web dependence ...');
+                    yield installPackages(options, isDryRunEnabled, (0, path_1.join)(projectDirectory, 'web'));
+                    console.info();
+                }
+            }
+            if (!isDryRunEnabled) {
+                if (!shouldSkipGit) {
+                    yield initializeGitRepository(projectDirectory);
+                    yield createGitIgnoreFile(projectDirectory);
+                }
+                const inputPackageManager = (options.find((option) => option.name === 'package-manager').value || 'yarn').toLowerCase();
+                console.info();
+                console.info(ui_1.MESSAGES.PACKAGE_MANAGER_INSTALLATION_SUCCEED(projectDirectory));
+                console.info(ui_1.MESSAGES.GET_STARTED_INFORMATION);
+                console.info();
+                console.info(chalk.gray(ui_1.MESSAGES.CHANGE_DIR_COMMAND(projectDirectory)));
+                if (shouldSkipInstall) {
+                    console.info('#Install dependence: ');
+                    if (options.find(option => option.name === 'server-framework' && option.value === 'nest')) {
+                        if (inputPackageManager === 'yarn') {
+                            if (options.find(option => option.name === 'with-web' && option.value === true)) {
+                                console.info(chalk.gray(`cd server && ${inputPackageManager}; cd ../web && ${inputPackageManager}; cd ..`));
+                            }
+                            else {
+                                console.info(chalk.gray(`cd server && ${inputPackageManager}; cd ..`));
+                            }
+                        }
+                        else {
+                            if (options.find(option => option.name === 'with-web' && option.value === true)) {
+                                console.info(chalk.gray(`cd server && ${inputPackageManager} install; cd ../web && ${inputPackageManager} install; cd ..`));
+                            }
+                            else {
+                                console.info(chalk.gray(`cd server && ${inputPackageManager} install; cd ..`));
+                            }
+                        }
+                    }
+                    else { // go iris
+                        if (inputPackageManager === 'yarn') {
+                            if (options.find(option => option.name === 'with-web' && option.value === true)) {
+                                console.info(chalk.gray(`cd server && go get && cd bin/prisma-parse && ${inputPackageManager}; cd ../../web && ${inputPackageManager}; cd ..`));
+                            }
+                            else {
+                                console.info(chalk.gray(`cd server && go get && cd bin/prisma-parse && ${inputPackageManager}; cd ../..`));
+                            }
+                        }
+                        else {
+                            if (options.find(option => option.name === 'with-web' && option.value === true)) {
+                                console.info(chalk.gray(`cd server && go get && cd bin/prisma-parse && ${inputPackageManager} install; cd ../../web && ${inputPackageManager} install; cd ..`));
+                            }
+                            else {
+                                console.info(chalk.gray(`cd server && go get && cd bin/prisma-parse && ${inputPackageManager} install; cd ../..`));
+                            }
+                        }
+                    }
+                    console.info();
+                }
+                console.info("#Generate code by config/schema.prisma in project root dir:");
+                console.info(chalk.gray("gadmin2 g prisma:dev"));
+                console.info();
+                if (options.find(option => option.name === 'server-framework' && option.value === 'nest')) {
+                    console.info('#Start server devServer:');
+                    console.info(chalk.gray('cd server'));
+                    if (inputPackageManager === 'yarn') {
+                        console.info(chalk.gray(`${inputPackageManager} seed    (only run once)`));
+                        console.info(chalk.gray(`${inputPackageManager} start:dev`));
+                    }
+                    else {
+                        console.info(chalk.gray(`${inputPackageManager} run seed    (only run once)`));
+                        console.info(chalk.gray(`${inputPackageManager} run start:dev`));
+                    }
+                }
+                else {
+                    console.info(chalk.gray(`swag init -g main.go && go run main.go`));
+                }
+                if (options.find(option => option.name === 'with-web' && option.value === true)) {
+                    console.info();
+                    console.info('#Start web devServer (In anthor terminal): ');
+                    console.info(chalk.gray('cd web'));
+                    if (inputPackageManager === 'yarn') {
+                        console.info(chalk.gray(`${inputPackageManager} dev`));
+                    }
+                    else {
+                        console.info(chalk.gray(`${inputPackageManager} run dev`));
+                    }
+                }
+                printCollective();
+            }
+            process.exit(0);
+        });
+    }
+}
+exports.NewAction = NewAction;
+const getApplicationNameInput = (inputs) => inputs.find((input) => input.name === 'name');
+const getOptionByName = (inputs, option) => { var _a; return (_a = inputs.find((input) => input.name === option)) === null || _a === void 0 ? void 0 : _a.value; };
+const getProjectDirectory = (applicationName, directoryOption) => {
+    return ((directoryOption && directoryOption.value) ||
+        (0, formatting_1.normalizeToKebabOrSnakeCase)(applicationName.value));
+};
+const askForMissingInformation = (inputs, options) => __awaiter(void 0, void 0, void 0, function* () {
+    console.info(ui_1.MESSAGES.PROJECT_INFORMATION_START);
+    console.info();
+    const prompt = inquirer.createPromptModule();
+    const nameInput = getApplicationNameInput(inputs);
+    if (!nameInput.value) {
+        const message = 'What name would you like to use for the new project?';
+        const questions = [(0, questions_1.generateInput)('name', message)('gadmin-app')];
+        const answers = yield prompt(questions);
+        replaceInputMissingInformation(inputs, answers);
+    }
+    // 默认使用 gadmin2-game-angle-demo 模板、nest + react(antd) 技术栈
+    replaceInputMissingInformation(options, { 'template': commands_1.Template.GameAngle });
+    replaceInputMissingInformation(options, { 'server-framework': 'nest' });
+    if (getOptionByName(options, 'with-web') === undefined) {
+        const answers = yield askForWithWeb();
+        answers['with-web'] = answers['with-web'] === 'yes';
+        replaceInputMissingInformation(options, answers);
+    }
+});
+const askForWithWeb = () => __awaiter(void 0, void 0, void 0, function* () {
+    const questions = [
+        (0, questions_1.generateSelect)('with-web')(ui_1.MESSAGES.WITH_WEB_QUESTION)([
+            commands_1.WithWeb.Yes,
+            commands_1.WithWeb.No,
+        ]),
+    ];
+    const prompt = inquirer.createPromptModule();
+    return yield prompt(questions);
+});
+const replaceInputMissingInformation = (inputs, answers) => {
+    return inputs.map((input) => (input.value =
+        input.value !== undefined ? input.value : answers[input.name]));
+};
+const generateApplicationFiles = (args, options) => __awaiter(void 0, void 0, void 0, function* () {
+    const collectionName = options.find((option) => option.name === 'collection' && option.value != null).value;
+    const collection = schematics_1.CollectionFactory.create(collectionName || schematics_1.Collection.GADMIN_GENERATOR);
+    const schematicOptions = mapSchematicOptions(args.concat(options));
+    yield collection.execute('application', schematicOptions);
+    console.info();
+});
+const mapSchematicOptions = (options) => {
+    return options.reduce((schematicOptions, option) => {
+        if (option.name !== 'skip-install' &&
+            option.value !== 'package-manager') {
+            schematicOptions.push(new schematics_1.SchematicOption(option.name, option.value));
+        }
+        return schematicOptions;
+    }, []);
+};
+const installPackages = (options, dryRunMode, installDirectory) => __awaiter(void 0, void 0, void 0, function* () {
+    const inputPackageManager = options.find((option) => option.name === 'package-manager').value;
+    let packageManager;
+    if (dryRunMode) {
+        console.info();
+        console.info(chalk.green(ui_1.MESSAGES.DRY_RUN_MODE));
+        console.info();
+        return;
+    }
+    if (inputPackageManager !== undefined) {
+        try {
+            packageManager = package_managers_1.PackageManagerFactory.create(inputPackageManager);
+            yield packageManager.install(installDirectory, inputPackageManager);
+        }
+        catch (error) {
+            if (error && error.message) {
+                console.error(chalk.red(error.message));
+            }
+        }
+    }
+    else {
+        packageManager = yield selectPackageManager();
+        yield packageManager.install(installDirectory, packageManager.name.toLowerCase());
+        options.find((option) => option.name === 'package-manager').value = packageManager.name.toLowerCase();
+    }
+});
+const selectPackageManager = () => __awaiter(void 0, void 0, void 0, function* () {
+    const answers = yield askForPackageManager();
+    return package_managers_1.PackageManagerFactory.create(answers['package-manager']);
+});
+const askForPackageManager = () => __awaiter(void 0, void 0, void 0, function* () {
+    const questions = [
+        (0, questions_1.generateSelect)('package-manager')(ui_1.MESSAGES.PACKAGE_MANAGER_QUESTION)([
+            package_managers_1.PackageManager.YARN,
+            package_managers_1.PackageManager.NPM,
+            package_managers_1.PackageManager.PNPM,
+        ]),
+    ];
+    const prompt = inquirer.createPromptModule();
+    return yield prompt(questions);
+});
+const initializeGitRepository = (dir) => __awaiter(void 0, void 0, void 0, function* () {
+    const runner = new git_runner_1.GitRunner();
+    yield runner.run('init', true, (0, path_1.join)(process.cwd(), dir)).catch(() => {
+        console.error(chalk.red(ui_1.MESSAGES.GIT_INITIALIZATION_ERROR));
+    });
+});
+/**
+ * Write a file `.gitignore` in the root of the newly created project.
+ * `.gitignore` available in `@gadmin2/schematics` cannot be published to
+ * NPM (needs to be investigated).
+ *
+ * @param dir Relative path to the project.
+ * @param content (optional) Content written in the `.gitignore`.
+ *
+ * @return Resolves when succeeds, or rejects with any error from `fn.writeFile`.
+ */
+const createGitIgnoreFile = (dir, content) => {
+    const fileContent = content || defaults_1.defaultGitIgnore;
+    const filePath = (0, path_1.join)(process.cwd(), dir, '.gitignore');
+    return (0, util_1.promisify)(fs.writeFile)(filePath, fileContent);
+};
+const printCollective = () => {
+    const dim = print('dim');
+    const yellow = print('yellow');
+    const emptyLine = print();
+    emptyLine();
+    yellow(`Thanks for using Gadmin2 ${ui_1.EMOJIS.ROCKET}`);
+    // dim('Please consider donating to our open collective');
+    // dim('to help us maintain this package.');
+    emptyLine();
+    emptyLine();
+    print()(`${chalk.bold(`${ui_1.EMOJIS.WINE}  More info:`)} ${chalk.underline('https://ptc.coding.intlgame.com/p/gadmin2/wiki/1')}`);
+    emptyLine();
+};
+const print = (color = null) => (str = '') => {
+    const terminalCols = (0, exports.retrieveCols)();
+    const strLength = str.replace(/\u001b\[[0-9]{2}m/g, '').length;
+    const leftPaddingLength = Math.floor((terminalCols - strLength) / 2);
+    const leftPadding = ' '.repeat(Math.max(leftPaddingLength, 0));
+    if (color) {
+        str = chalk[color](str);
+    }
+    console.log(leftPadding, str);
+};
+const retrieveCols = () => {
+    const defaultCols = 80;
+    try {
+        const terminalCols = (0, child_process_1.execSync)('tput cols', {
+            stdio: ['pipe', 'pipe', 'ignore'],
+        });
+        return parseInt(terminalCols.toString(), 10) || defaultCols;
+    }
+    catch (_a) {
+        return defaultCols;
+    }
+};
+exports.retrieveCols = retrieveCols;
+const exit = () => process.exit(1);
+exports.exit = exit;

package/actions/prisma.action.d.ts

@@ -0,0 +1,5 @@
+import { Input } from '../commands';
+import { AbstractAction } from './abstract.action';
+export declare class PrismaAction extends AbstractAction {
+    handle(inputs: Input[], options: Input[]): Promise<void>;
+}

package/actions/prisma.action.js

@@ -0,0 +1,153 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrismaAction = void 0;
+const chalk = require("chalk");
+const fs = require("fs");
+const abstract_action_1 = require("./abstract.action");
+const shell = require("shelljs");
+const readline = require("readline");
+// 暂时没用上
+function replaceFileContent(filePath, match, src, dest) {
+    // 创建可读流和可写流
+    const readStream = fs.createReadStream(filePath);
+    const writeStream = fs.createWriteStream(filePath + '.tmp');
+    // 创建接口
+    const rl = readline.createInterface({
+        input: readStream,
+        output: writeStream,
+        terminal: false,
+    });
+    // 逐行读取文件并处理
+    rl.on('line', (line) => {
+        if (line.match(match)) {
+            const newLine = line.replace(src, dest);
+            writeStream.write(newLine + ''); // 将替换后的行写入临时文件
+        }
+        else {
+            writeStream.write(line + ''); // 将原始行写入临时文件
+        }
+    });
+    rl.on('close', () => {
+        // 关闭可写流
+        writeStream.end();
+        // 重命名临时文件为目标文件
+        fs.rename(filePath + '.tmp', filePath, (err) => {
+            if (err) {
+                console.error('Error renaming file:', err);
+            }
+        });
+    });
+}
+class PrismaAction extends abstract_action_1.AbstractAction {
+    handle(inputs, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // 检查 prisma schema 配置是否存在
+            const hasPrismaConfig = shell.test('-e', 'config/schema.prisma') ||
+                shell.test('-d', 'config/prisma');
+            if (!hasPrismaConfig) {
+                console.error(`${chalk.red('This command must run in project root dir.')}`);
+                console.error(`${chalk.red('Missing: config/schema.prisma or config/prisma/ directory')}`);
+                process.exit(-1);
+            }
+            const devMode = options.find((option) => option.name === 'dev');
+            shell
+                .cat('server/prisma/.generator.prisma')
+                .to('server/prisma/schema.prisma');
+            let schemaStr = '';
+            if (shell.test('-d', 'config/prisma')) {
+                schemaStr = shell.cat('config/prisma/*.prisma');
+            }
+            else {
+                schemaStr = shell.cat('config/schema.prisma');
+            }
+            const schemaRegex = /([\s\S]*?model\s\w*\s*\{)([^\}]*)(\})/gim; // https://regex101.com/
+            // const subst = `$1\n  id Int @id @default(autoincrement())$2  createdAt DateTime @default(now())\n  updatedAt DateTime @updatedAt\n$3`;
+            let m, result = '';
+            while ((m = schemaRegex.exec(schemaStr)) !== null) {
+                // This is necessary to avoid infinite loops with zero-width matches
+                if (m.index === schemaRegex.lastIndex) {
+                    schemaRegex.lastIndex++;
+                }
+                // The result can be accessed through the `m`-variable.
+                // m.forEach((match, groupIndex) => {
+                // console.log(`Found match, group ${groupIndex}: ${match}`);
+                // });
+                let ignore = !!m[1].match(/\/\/\/\s*@IgnoreAutoField/);
+                result += m[1];
+                if (!ignore) {
+                    result += '\n  id Int @id @default(autoincrement())';
+                }
+                result += m[2];
+                if (!ignore) {
+                    result +=
+                        '  creator String @default("") @db.VarChar(128)\n  createdAt DateTime @default(now())\n  updatedAt DateTime @updatedAt @default(now())\n';
+                }
+                result += m[3];
+            }
+            //const result = schemaStr.replace(schemaRegex, subst);
+            new shell.ShellString(result).toEnd('server/prisma/schema.prisma');
+            fs.rmSync('server/src/generated', { recursive: true, force: true });
+            fs.rmSync('web/src/generated', { recursive: true, force: true });
+            /*
+            const {code} = shell.cd('config/').exec('tsc ui.config.ts');
+            if(code !== 0){
+              process.exit(code);
+            }
+            shell.cd('../');
+            */
+            const { code } = shell
+                .cd('server/')
+                .exec(devMode ? 'npm run generate:dev' : 'npm run generate');
+            if (code !== 0) {
+                process.exit(code);
+            }
+            shell.cd('../');
+            fs.cpSync('server/src/generated/.react', 'web/src/generated', {
+                recursive: true,
+                force: true,
+            });
+            fs.rmSync('server/src/generated/.react', { recursive: true, force: true });
+            shell.cd('server/src/generated/');
+            const models = shell
+                .ls('-d', '*')
+                .filter((file) => shell.test('-d', file))
+                .filter((dir) => shell.test('-e', `${dir}/dto/${dir}.form.validator.ts`));
+            shell.cd('../../..');
+            models.forEach((modelName) => {
+                shell.mv('-f', `server/src/generated/${modelName}/dto/${modelName}.form.validator.ts`, `web/src/generated/props/${modelName}/form.validator.ts`);
+                fs.cpSync(`server/src/generated/${modelName}`, `server/src/modules/${modelName}`, { recursive: true, force: false });
+                shell.rm('-f', `server/src/generated/${modelName}/*.ts`);
+                fs.rmSync(`server/src/modules/${modelName}/dto`, {
+                    recursive: true,
+                    force: true,
+                });
+                fs.rmSync(`server/src/modules/${modelName}/entities`, {
+                    recursive: true,
+                    force: true,
+                });
+            });
+            fs.cpSync('web/src/generated/pages', 'web/src/pages', {
+                recursive: true,
+                force: false,
+            });
+            fs.rmSync('web/src/generated/pages', { recursive: true, force: true });
+            fs.mkdirSync('web/src/generated/types');
+            fs.copyFileSync('server/node_modules/.prisma/client/index.d.ts', 'web/src/generated/types/prisma.types.d.ts');
+            const prismaRegex = new RegExp("import \\* as runtime from '@prisma/client/runtime/index';");
+            shell.sed('-i', prismaRegex, 'declare const runtime : any', 'web/src/generated/types/prisma.types.d.ts');
+            shell.sed('-i', new RegExp('bigint', 'g'), 'number', 'web/src/generated/types/prisma.types.d.ts');
+            fs.copyFileSync('config/.types.d.ts', 'web/src/generated/types/config.types.d.ts');
+            process.exit(0);
+        });
+    }
+}
+exports.PrismaAction = PrismaAction;

package/actions/start.action.d.ts

@@ -0,0 +1,9 @@
+import { Input } from '../commands';
+import { Configuration } from '../lib/configuration';
+import { BuildAction } from './build.action';
+export declare class StartAction extends BuildAction {
+    handle(inputs: Input[], options: Input[]): Promise<void>;
+    createOnSuccessHook(configuration: Required<Configuration>, appName: string, debugFlag: boolean | string | undefined, outDirName: string, binaryToRun?: string): () => void;
+    private spawnChildProcess;
+    private isSourceMapSupportPkgAvailable;
+}

package/actions/start.action.js

@@ -0,0 +1,115 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StartAction = void 0;
+const chalk = require("chalk");
+const child_process_1 = require("child_process");
+const fs = require("fs");
+const path_1 = require("path");
+const killProcess = require("tree-kill");
+const tree_kill_1 = require("../lib/utils/tree-kill");
+const get_value_or_default_1 = require("../lib/compiler/helpers/get-value-or-default");
+const defaults_1 = require("../lib/configuration/defaults");
+const ui_1 = require("../lib/ui");
+const build_action_1 = require("./build.action");
+class StartAction extends build_action_1.BuildAction {
+    handle(inputs, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const configFileName = options.find((option) => option.name === 'config')
+                    .value;
+                const configuration = yield this.loader.load(configFileName);
+                const appName = inputs.find((input) => input.name === 'app')
+                    .value;
+                const pathToTsconfig = (0, get_value_or_default_1.getValueOrDefault)(configuration, 'compilerOptions.tsConfigPath', appName, 'path', options);
+                const binaryToRunOption = options.find((option) => option.name === 'exec');
+                const debugModeOption = options.find((option) => option.name === 'debug');
+                const watchModeOption = options.find((option) => option.name === 'watch');
+                const isWatchEnabled = !!(watchModeOption && watchModeOption.value);
+                const watchAssetsModeOption = options.find((option) => option.name === 'watchAssets');
+                const isWatchAssetsEnabled = !!(watchAssetsModeOption && watchAssetsModeOption.value);
+                const debugFlag = debugModeOption && debugModeOption.value;
+                const binaryToRun = binaryToRunOption && binaryToRunOption.value;
+                const { options: tsOptions } = this.tsConfigProvider.getByConfigFilename(pathToTsconfig);
+                const outDir = tsOptions.outDir || defaults_1.defaultOutDir;
+                const onSuccess = this.createOnSuccessHook(configuration, appName, debugFlag, outDir, binaryToRun);
+                yield this.runBuild(inputs, options, isWatchEnabled, isWatchAssetsEnabled, !!debugFlag, onSuccess);
+            }
+            catch (err) {
+                if (err instanceof Error) {
+                    console.log(`\n${ui_1.ERROR_PREFIX} ${err.message}\n`);
+                }
+                else {
+                    console.error(`\n${chalk.red(err)}\n`);
+                }
+            }
+        });
+    }
+    createOnSuccessHook(configuration, appName, debugFlag, outDirName, binaryToRun = 'node') {
+        const sourceRoot = (0, get_value_or_default_1.getValueOrDefault)(configuration, 'sourceRoot', appName);
+        const entryFile = (0, get_value_or_default_1.getValueOrDefault)(configuration, 'entryFile', appName);
+        let childProcessRef;
+        process.on('exit', () => childProcessRef && (0, tree_kill_1.treeKillSync)(childProcessRef.pid));
+        return () => {
+            if (childProcessRef) {
+                childProcessRef.removeAllListeners('exit');
+                childProcessRef.on('exit', () => {
+                    childProcessRef = this.spawnChildProcess(entryFile, sourceRoot, debugFlag, outDirName, binaryToRun);
+                    childProcessRef.on('exit', () => (childProcessRef = undefined));
+                });
+                childProcessRef.stdin && childProcessRef.stdin.pause();
+                killProcess(childProcessRef.pid);
+            }
+            else {
+                childProcessRef = this.spawnChildProcess(entryFile, sourceRoot, debugFlag, outDirName, binaryToRun);
+                childProcessRef.on('exit', (code) => {
+                    process.exitCode = code;
+                    childProcessRef = undefined;
+                });
+            }
+        };
+    }
+    spawnChildProcess(entryFile, sourceRoot, debug, outDirName, binaryToRun) {
+        let outputFilePath = (0, path_1.join)(outDirName, sourceRoot, entryFile);
+        if (!fs.existsSync(outputFilePath + '.js')) {
+            outputFilePath = (0, path_1.join)(outDirName, entryFile);
+        }
+        let childProcessArgs = [];
+        const argsStartIndex = process.argv.indexOf('--');
+        if (argsStartIndex >= 0) {
+            childProcessArgs = process.argv.slice(argsStartIndex + 1);
+        }
+        outputFilePath =
+            outputFilePath.indexOf(' ') >= 0 ? `"${outputFilePath}"` : outputFilePath;
+        const processArgs = [outputFilePath, ...childProcessArgs];
+        if (debug) {
+            const inspectFlag = typeof debug === 'string' ? `--inspect=${debug}` : '--inspect';
+            processArgs.unshift(inspectFlag);
+        }
+        if (this.isSourceMapSupportPkgAvailable()) {
+            processArgs.unshift('-r source-map-support/register');
+        }
+        return (0, child_process_1.spawn)(binaryToRun, processArgs, {
+            stdio: 'inherit',
+            shell: true,
+        });
+    }
+    isSourceMapSupportPkgAvailable() {
+        try {
+            require.resolve('source-map-support');
+            return true;
+        }
+        catch (_a) {
+            return false;
+        }
+    }
+}
+exports.StartAction = StartAction;

package/actions/update.action.d.ts

@@ -0,0 +1,5 @@
+import { Input } from '../commands';
+import { AbstractAction } from './abstract.action';
+export declare class UpdateAction extends AbstractAction {
+    handle(inputs: Input[], options: Input[]): Promise<void>;
+}

package/actions/update.action.js

@@ -0,0 +1,26 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateAction = void 0;
+const dependency_managers_1 = require("../lib/dependency-managers");
+const package_managers_1 = require("../lib/package-managers");
+const abstract_action_1 = require("./abstract.action");
+class UpdateAction extends abstract_action_1.AbstractAction {
+    handle(inputs, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const force = options.find((option) => option.name === 'force');
+            const tag = options.find((option) => option.name === 'tag');
+            const manager = new dependency_managers_1.NestDependencyManager(yield package_managers_1.PackageManagerFactory.find());
+            yield manager.update(force.value, tag.value);
+        });
+    }
+}
+exports.UpdateAction = UpdateAction;

package/bin/gadmin.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/bin/gadmin.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander = require("commander");
+const commands_1 = require("../commands");
+const local_binaries_1 = require("../lib/utils/local-binaries");
+const bootstrap = () => {
+    const program = commander;
+    program
+        .version(require('../package.json').version, '-v, --version', 'Output the current version.')
+        .usage('<command> [options]')
+        .helpOption('-h, --help', 'Output usage information.');
+    if ((0, local_binaries_1.localBinExists)()) {
+        const localCommandLoader = (0, local_binaries_1.loadLocalBinCommandLoader)();
+        localCommandLoader.load(program);
+    }
+    else {
+        commands_1.CommandLoader.load(program);
+    }
+    commander.parse(process.argv);
+    if (!process.argv.slice(2).length) {
+        program.outputHelp();
+    }
+};
+bootstrap();

package/commands/abstract.command.d.ts

@@ -0,0 +1,7 @@
+import { CommanderStatic } from 'commander';
+import { AbstractAction } from '../actions/abstract.action';
+export declare abstract class AbstractCommand {
+    protected action: AbstractAction;
+    constructor(action: AbstractAction);
+    abstract load(program: CommanderStatic): void;
+}

package/commands/abstract.command.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractCommand = void 0;
+class AbstractCommand {
+    constructor(action) {
+        this.action = action;
+    }
+}
+exports.AbstractCommand = AbstractCommand;