@gadmin2n/cli 0.0.73

package/actions/build.action.js

@@ -0,0 +1,108 @@
+"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.BuildAction = void 0;
+const chalk = require("chalk");
+const path_1 = require("path");
+const assets_manager_1 = require("../lib/compiler/assets-manager");
+const compiler_1 = require("../lib/compiler/compiler");
+const get_value_or_default_1 = require("../lib/compiler/helpers/get-value-or-default");
+const tsconfig_provider_1 = require("../lib/compiler/helpers/tsconfig-provider");
+const plugins_loader_1 = require("../lib/compiler/plugins-loader");
+const typescript_loader_1 = require("../lib/compiler/typescript-loader");
+const watch_compiler_1 = require("../lib/compiler/watch-compiler");
+const webpack_compiler_1 = require("../lib/compiler/webpack-compiler");
+const workspace_utils_1 = require("../lib/compiler/workspace-utils");
+const configuration_1 = require("../lib/configuration");
+const defaults_1 = require("../lib/configuration/defaults");
+const readers_1 = require("../lib/readers");
+const ui_1 = require("../lib/ui");
+const abstract_action_1 = require("./abstract.action");
+class BuildAction extends abstract_action_1.AbstractAction {
+    constructor() {
+        super(...arguments);
+        this.pluginsLoader = new plugins_loader_1.PluginsLoader();
+        this.tsLoader = new typescript_loader_1.TypeScriptBinaryLoader();
+        this.tsConfigProvider = new tsconfig_provider_1.TsConfigProvider(this.tsLoader);
+        this.compiler = new compiler_1.Compiler(this.pluginsLoader, this.tsConfigProvider, this.tsLoader);
+        this.webpackCompiler = new webpack_compiler_1.WebpackCompiler(this.pluginsLoader);
+        this.watchCompiler = new watch_compiler_1.WatchCompiler(this.pluginsLoader, this.tsConfigProvider, this.tsLoader);
+        this.fileSystemReader = new readers_1.FileSystemReader(process.cwd());
+        this.loader = new configuration_1.GadminConfigurationLoader(this.fileSystemReader);
+        this.assetsManager = new assets_manager_1.AssetsManager();
+        this.workspaceUtils = new workspace_utils_1.WorkspaceUtils();
+    }
+    handle(inputs, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const watchModeOption = options.find((option) => option.name === 'watch');
+                const watchMode = !!(watchModeOption && watchModeOption.value);
+                const watchAssetsModeOption = options.find((option) => option.name === 'watchAssets');
+                const watchAssetsMode = !!(watchAssetsModeOption && watchAssetsModeOption.value);
+                yield this.runBuild(inputs, options, watchMode, watchAssetsMode);
+            }
+            catch (err) {
+                if (err instanceof Error) {
+                    console.log(`\n${ui_1.ERROR_PREFIX} ${err.message}\n`);
+                }
+                else {
+                    console.error(`\n${chalk.red(err)}\n`);
+                }
+                process.exit(1);
+            }
+        });
+    }
+    runBuild(inputs, options, watchMode, watchAssetsMode, isDebugEnabled = false, onSuccess) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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 { options: tsOptions } = this.tsConfigProvider.getByConfigFilename(pathToTsconfig);
+            const outDir = tsOptions.outDir || defaults_1.defaultOutDir;
+            const isWebpackEnabled = (0, get_value_or_default_1.getValueOrDefault)(configuration, 'compilerOptions.webpack', appName, 'webpack', options);
+            yield this.workspaceUtils.deleteOutDirIfEnabled(configuration, appName, outDir);
+            this.assetsManager.copyAssets(configuration, appName, outDir, watchAssetsMode);
+            if (isWebpackEnabled) {
+                const webpackPath = (0, get_value_or_default_1.getValueOrDefault)(configuration, 'compilerOptions.webpackConfigPath', appName, 'webpackPath', options);
+                const webpackConfigFactoryOrConfig = this.getWebpackConfigFactoryByPath(webpackPath, configuration.compilerOptions.webpackConfigPath);
+                return this.webpackCompiler.run(configuration, webpackConfigFactoryOrConfig, pathToTsconfig, appName, isDebugEnabled, watchMode, this.assetsManager, onSuccess);
+            }
+            if (watchMode) {
+                const tsCompilerOptions = {};
+                const isPreserveWatchOutputEnabled = options.find((option) => option.name === 'preserveWatchOutput' && option.value === true);
+                if (isPreserveWatchOutputEnabled) {
+                    tsCompilerOptions.preserveWatchOutput = true;
+                }
+                this.watchCompiler.run(configuration, pathToTsconfig, appName, tsCompilerOptions, onSuccess);
+            }
+            else {
+                this.compiler.run(configuration, pathToTsconfig, appName, onSuccess);
+                this.assetsManager.closeWatchers();
+            }
+        });
+    }
+    getWebpackConfigFactoryByPath(webpackPath, defaultPath) {
+        const pathToWebpackFile = (0, path_1.join)(process.cwd(), webpackPath);
+        try {
+            return require(pathToWebpackFile);
+        }
+        catch (err) {
+            if (webpackPath !== defaultPath) {
+                throw err;
+            }
+            return ({}) => ({});
+        }
+    }
+}
+exports.BuildAction = BuildAction;

package/actions/generate.action.d.ts

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

package/actions/generate.action.js

@@ -0,0 +1,95 @@
+"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.GenerateAction = void 0;
+const chalk = require("chalk");
+const get_value_or_default_1 = require("../lib/compiler/helpers/get-value-or-default");
+const schematics_1 = require("../lib/schematics");
+const ui_1 = require("../lib/ui");
+const load_configuration_1 = require("../lib/utils/load-configuration");
+const project_utils_1 = require("../lib/utils/project-utils");
+const abstract_action_1 = require("./abstract.action");
+class GenerateAction extends abstract_action_1.AbstractAction {
+    handle(inputs, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield generateFiles(inputs.concat(options));
+        });
+    }
+}
+exports.GenerateAction = GenerateAction;
+const generateFiles = (inputs) => __awaiter(void 0, void 0, void 0, function* () {
+    const configuration = yield (0, load_configuration_1.loadConfiguration)();
+    const collectionOption = inputs.find((option) => option.name === 'collection').value;
+    const schematic = inputs.find((option) => option.name === 'schematic')
+        .value;
+    const appName = inputs.find((option) => option.name === 'project')
+        .value;
+    const spec = inputs.find((option) => option.name === 'spec');
+    const collection = schematics_1.CollectionFactory.create(collectionOption || configuration.collection || schematics_1.Collection.GADMIN_GENERATOR);
+    const schematicOptions = mapSchematicOptions(inputs);
+    schematicOptions.push(new schematics_1.SchematicOption('language', configuration.language));
+    const configurationProjects = configuration.projects;
+    let sourceRoot = appName
+        ? (0, get_value_or_default_1.getValueOrDefault)(configuration, 'sourceRoot', appName)
+        : configuration.sourceRoot;
+    const specValue = spec.value;
+    const specOptions = spec.options;
+    let generateSpec = (0, project_utils_1.shouldGenerateSpec)(configuration, schematic, appName, specValue, specOptions.passedAsInput);
+    // If you only add a `lib` we actually don't have monorepo: true BUT we do have "projects"
+    // Ensure we don't run for new app/libs schematics
+    if ((0, project_utils_1.shouldAskForProject)(schematic, configurationProjects, appName)) {
+        const defaultLabel = ' [ Default ]';
+        let defaultProjectName = configuration.sourceRoot + defaultLabel;
+        for (const property in configurationProjects) {
+            if (configurationProjects[property].sourceRoot === configuration.sourceRoot) {
+                defaultProjectName = property + defaultLabel;
+                break;
+            }
+        }
+        const projects = (0, project_utils_1.moveDefaultProjectToStart)(configuration, defaultProjectName, defaultLabel);
+        const answers = yield (0, project_utils_1.askForProjectName)(ui_1.MESSAGES.PROJECT_SELECTION_QUESTION, projects);
+        const project = answers.appName.replace(defaultLabel, '');
+        if (project !== configuration.sourceRoot) {
+            sourceRoot = configurationProjects[project].sourceRoot;
+        }
+        if (answers.appName !== defaultProjectName) {
+            // Only overwrite if the appName is not the default- as it has already been loaded above
+            generateSpec = (0, project_utils_1.shouldGenerateSpec)(configuration, schematic, answers.appName, specValue, specOptions.passedAsInput);
+        }
+    }
+    schematicOptions.push(new schematics_1.SchematicOption('sourceRoot', sourceRoot));
+    schematicOptions.push(new schematics_1.SchematicOption('spec', generateSpec));
+    try {
+        const schematicInput = inputs.find((input) => input.name === 'schematic');
+        if (!schematicInput) {
+            throw new Error('Unable to find a schematic for this configuration');
+        }
+        yield collection.execute(schematicInput.value, schematicOptions);
+    }
+    catch (error) {
+        if (error && error.message) {
+            console.error(chalk.red(error.message));
+        }
+    }
+});
+const mapSchematicOptions = (inputs) => {
+    const excludedInputNames = ['schematic', 'spec'];
+    const options = [];
+    inputs.forEach((input) => {
+        if (!excludedInputNames.includes(input.name) && input.value !== undefined) {
+            const keepInputName = input.options
+                ? 'keepInputNameFormat' in input.options
+                : false;
+            options.push(new schematics_1.SchematicOption(input.name, input.value, keepInputName));
+        }
+    });
+    return options;
+};

package/actions/index.d.ts

@@ -0,0 +1,8 @@
+export * from './abstract.action';
+export * from './build.action';
+export * from './generate.action';
+export * from './info.action';
+export * from './new.action';
+export * from './update.action';
+export * from './start.action';
+export * from './add.action';

package/actions/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./abstract.action"), exports);
+__exportStar(require("./build.action"), exports);
+__exportStar(require("./generate.action"), exports);
+__exportStar(require("./info.action"), exports);
+__exportStar(require("./new.action"), exports);
+__exportStar(require("./update.action"), exports);
+__exportStar(require("./start.action"), exports);
+__exportStar(require("./add.action"), exports);

package/actions/info.action.d.ts

@@ -0,0 +1,28 @@
+import { AbstractAction } from './abstract.action';
+interface LockfileDependency {
+    version: string;
+}
+interface PackageJsonDependencies {
+    [key: string]: LockfileDependency;
+}
+interface GadminDependency {
+    name: string;
+    value: string;
+}
+export declare class InfoAction extends AbstractAction {
+    private manager;
+    handle(): Promise<void>;
+    private displayBanner;
+    private displaySystemInformation;
+    displayPackageManagerVersion(): Promise<void>;
+    displayGadminInformation(): Promise<void>;
+    displayGadminInformationFromPackage(): Promise<void>;
+    displayCliVersion(): void;
+    readProjectPackageDependencies(): PackageJsonDependencies;
+    displayGadminVersions(dependencies: PackageJsonDependencies): void;
+    buildGadminVersionsMessage(dependencies: PackageJsonDependencies): GadminDependency[];
+    collectGadminDependencies(dependencies: PackageJsonDependencies): GadminDependency[];
+    format(dependencies: GadminDependency[]): GadminDependency[];
+    rightPad(name: string, length: number): string;
+}
+export {};

package/actions/info.action.js

@@ -0,0 +1,129 @@
+"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.InfoAction = void 0;
+const chalk = require("chalk");
+const fs_1 = require("fs");
+const os_1 = require("os");
+const osName = require("os-name");
+const path_1 = require("path");
+const package_managers_1 = require("../lib/package-managers");
+const ui_1 = require("../lib/ui");
+const abstract_action_1 = require("./abstract.action");
+class InfoAction extends abstract_action_1.AbstractAction {
+    handle() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.manager = yield package_managers_1.PackageManagerFactory.find();
+            this.displayBanner();
+            yield this.displaySystemInformation();
+            yield this.displayGadminInformation();
+        });
+    }
+    displayBanner() {
+        console.info(chalk.red(ui_1.BANNER));
+    }
+    displaySystemInformation() {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.info(chalk.green('[System Information]'));
+            console.info('OS Version     :', chalk.blue(osName((0, os_1.platform)(), (0, os_1.release)())));
+            console.info('NodeJS Version :', chalk.blue(process.version));
+            yield this.displayPackageManagerVersion();
+        });
+    }
+    displayPackageManagerVersion() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const version = yield this.manager.version();
+                console.info(`${this.manager.name} Version    :`, chalk.blue(version), '\n');
+            }
+            catch (_a) {
+                console.error(`${this.manager.name} Version    :`, chalk.red('Unknown'), '\n');
+            }
+        });
+    }
+    displayGadminInformation() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.displayCliVersion();
+            console.info(chalk.green('[Gadmin Platform Information]'));
+            yield this.displayGadminInformationFromPackage();
+        });
+    }
+    displayGadminInformationFromPackage() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const dependencies = this.readProjectPackageDependencies();
+                this.displayGadminVersions(dependencies);
+            }
+            catch (err) {
+                console.error(chalk.red(ui_1.MESSAGES.GADMIN_INFORMATION_PACKAGE_MANAGER_FAILED));
+            }
+        });
+    }
+    displayCliVersion() {
+        console.info(chalk.green('[Gadmin CLI]'));
+        console.info('Gadmin CLI Version :', chalk.blue(JSON.parse((0, fs_1.readFileSync)((0, path_1.join)(__dirname, '../package.json')).toString())
+            .version), '\n');
+    }
+    readProjectPackageDependencies() {
+        const buffer = (0, fs_1.readFileSync)((0, path_1.join)(process.cwd(), 'package.json'));
+        const pack = JSON.parse(buffer.toString());
+        const dependencies = Object.assign(Object.assign({}, pack.dependencies), pack.devDependencies);
+        Object.keys(dependencies).forEach((key) => {
+            dependencies[key] = {
+                version: dependencies[key],
+            };
+        });
+        return dependencies;
+    }
+    displayGadminVersions(dependencies) {
+        this.buildGadminVersionsMessage(dependencies).forEach((dependency) => console.info(dependency.name, chalk.blue(dependency.value)));
+    }
+    buildGadminVersionsMessage(dependencies) {
+        const gadminDependencies = this.collectGadminDependencies(dependencies);
+        return this.format(gadminDependencies);
+    }
+    collectGadminDependencies(dependencies) {
+        const gadminDependencies = [];
+        Object.keys(dependencies).forEach((key) => {
+            if (key.indexOf('@gadminjs') > -1) {
+                const depPackagePath = require.resolve(key + '/package.json', {
+                    paths: [process.cwd()],
+                });
+                const depPackage = (0, fs_1.readFileSync)(depPackagePath).toString();
+                const value = JSON.parse(depPackage).version;
+                gadminDependencies.push({
+                    name: `${key.replace(/@gadminjs\//, '').replace(/@.*/, '')} version`,
+                    value: value || dependencies[key].version,
+                });
+            }
+        });
+        return gadminDependencies;
+    }
+    format(dependencies) {
+        const sorted = dependencies.sort((dependencyA, dependencyB) => dependencyB.name.length - dependencyA.name.length);
+        const length = sorted[0].name.length;
+        sorted.forEach((dependency) => {
+            if (dependency.name.length < length) {
+                dependency.name = this.rightPad(dependency.name, length);
+            }
+            dependency.name = dependency.name.concat(' :');
+            dependency.value = dependency.value.replace(/(\^|\~)/, '');
+        });
+        return sorted;
+    }
+    rightPad(name, length) {
+        while (name.length < length) {
+            name = name.concat(' ');
+        }
+        return name;
+    }
+}
+exports.InfoAction = InfoAction;

package/actions/new.action.d.ts

@@ -0,0 +1,7 @@
+import { Input } from '../commands';
+import { AbstractAction } from './abstract.action';
+export declare class NewAction extends AbstractAction {
+    handle(inputs: Input[], options: Input[]): Promise<void>;
+}
+export declare const retrieveCols: () => number;
+export declare const exit: () => never;