@gadmin2n/cli 0.0.73

package/lib/compiler/watch-compiler.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WatchCompiler = void 0;
+const errors_1 = require("../ui/errors");
+const get_value_or_default_1 = require("./helpers/get-value-or-default");
+const tsconfig_paths_hook_1 = require("./hooks/tsconfig-paths.hook");
+class WatchCompiler {
+    constructor(pluginsLoader, tsConfigProvider, typescriptLoader) {
+        this.pluginsLoader = pluginsLoader;
+        this.tsConfigProvider = tsConfigProvider;
+        this.typescriptLoader = typescriptLoader;
+    }
+    run(configuration, configFilename, appName, tsCompilerOptions, onSuccess) {
+        const tsBin = this.typescriptLoader.load();
+        const configPath = tsBin.findConfigFile(process.cwd(), tsBin.sys.fileExists, configFilename);
+        if (!configPath) {
+            throw new Error(errors_1.CLI_ERRORS.MISSING_TYPESCRIPT(configFilename));
+        }
+        const { projectReferences } = this.tsConfigProvider.getByConfigFilename(configFilename);
+        const createProgram = tsBin.createEmitAndSemanticDiagnosticsBuilderProgram;
+        const origDiagnosticReporter = tsBin.createDiagnosticReporter(tsBin.sys, true);
+        const origWatchStatusReporter = tsBin.createWatchStatusReporter(tsBin.sys, true);
+        const host = tsBin.createWatchCompilerHost(configPath, tsCompilerOptions, tsBin.sys, createProgram, this.createDiagnosticReporter(origDiagnosticReporter), this.createWatchStatusChanged(origWatchStatusReporter, onSuccess));
+        const pluginsConfig = (0, get_value_or_default_1.getValueOrDefault)(configuration, 'compilerOptions.plugins', appName);
+        const plugins = this.pluginsLoader.load(pluginsConfig);
+        const origCreateProgram = host.createProgram;
+        host.createProgram = (rootNames, options, 
+        // tslint:disable-next-line:no-shadowed-variable
+        host, oldProgram) => {
+            const tsconfigPathsPlugin = options ? (0, tsconfig_paths_hook_1.tsconfigPathsBeforeHookFactory)(options) : null;
+            const program = origCreateProgram(rootNames, options, host, oldProgram, undefined, projectReferences);
+            const origProgramEmit = program.emit;
+            program.emit = (targetSourceFile, writeFile, cancellationToken, emitOnlyDtsFiles, customTransformers) => {
+                let transforms = customTransformers;
+                transforms = typeof transforms !== 'object' ? {} : transforms;
+                const before = plugins.beforeHooks.map((hook) => hook(program.getProgram()));
+                const after = plugins.afterHooks.map((hook) => hook(program.getProgram()));
+                const afterDeclarations = plugins.afterDeclarationsHooks.map((hook) => hook(program.getProgram()));
+                if (tsconfigPathsPlugin) {
+                    before.unshift(tsconfigPathsPlugin);
+                }
+                transforms.before = before.concat(transforms.before || []);
+                transforms.after = after.concat(transforms.after || []);
+                transforms.afterDeclarations = afterDeclarations.concat(transforms.afterDeclarations || []);
+                return origProgramEmit(targetSourceFile, writeFile, cancellationToken, emitOnlyDtsFiles, transforms);
+            };
+            return program;
+        };
+        tsBin.createWatchProgram(host);
+    }
+    createDiagnosticReporter(diagnosticReporter) {
+        return function (diagnostic, ...args) {
+            return diagnosticReporter.call(this, diagnostic, ...args);
+        };
+    }
+    createWatchStatusChanged(watchStatusReporter, onSuccess) {
+        return function (diagnostic, ...args) {
+            const messageText = diagnostic && diagnostic.messageText;
+            const noErrorsMessage = '0 errors';
+            if (messageText &&
+                messageText.includes &&
+                messageText.includes(noErrorsMessage) &&
+                onSuccess) {
+                onSuccess();
+            }
+            return watchStatusReporter.call(this, diagnostic, ...args);
+        };
+    }
+}
+exports.WatchCompiler = WatchCompiler;

package/lib/compiler/webpack-compiler.d.ts

@@ -0,0 +1,9 @@
+import { Configuration } from '../configuration';
+import { AssetsManager } from './assets-manager';
+import { PluginsLoader } from './plugins-loader';
+import webpack = require('webpack');
+export declare class WebpackCompiler {
+    private readonly pluginsLoader;
+    constructor(pluginsLoader: PluginsLoader);
+    run(configuration: Required<Configuration>, webpackConfigFactoryOrConfig: (config: webpack.Configuration, webpackRef: typeof webpack) => webpack.Configuration, tsConfigPath: string, appName: string, isDebugEnabled: boolean | undefined, watchMode: boolean | undefined, assetsManager: AssetsManager, onSuccess?: () => void): void;
+}

package/lib/compiler/webpack-compiler.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebpackCompiler = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const ui_1 = require("../ui");
+const webpack_defaults_1 = require("./defaults/webpack-defaults");
+const get_value_or_default_1 = require("./helpers/get-value-or-default");
+const webpack = require("webpack");
+class WebpackCompiler {
+    constructor(pluginsLoader) {
+        this.pluginsLoader = pluginsLoader;
+    }
+    run(configuration, webpackConfigFactoryOrConfig, tsConfigPath, appName, isDebugEnabled = false, watchMode = false, assetsManager, onSuccess) {
+        const cwd = process.cwd();
+        const configPath = (0, path_1.join)(cwd, tsConfigPath);
+        if (!(0, fs_1.existsSync)(configPath)) {
+            throw new Error(`Could not find TypeScript configuration file "${tsConfigPath}".`);
+        }
+        const pluginsConfig = (0, get_value_or_default_1.getValueOrDefault)(configuration, 'compilerOptions.plugins', appName);
+        const plugins = this.pluginsLoader.load(pluginsConfig);
+        const relativeRootPath = (0, path_1.dirname)((0, path_1.relative)(cwd, configPath));
+        const sourceRoot = (0, get_value_or_default_1.getValueOrDefault)(configuration, 'sourceRoot', appName);
+        const pathToSource = (0, path_1.normalize)(sourceRoot).indexOf((0, path_1.normalize)(relativeRootPath)) >= 0
+            ? (0, path_1.join)(cwd, sourceRoot)
+            : (0, path_1.join)(cwd, relativeRootPath, sourceRoot);
+        const entryFile = (0, get_value_or_default_1.getValueOrDefault)(configuration, 'entryFile', appName);
+        const entryFileRoot = (0, get_value_or_default_1.getValueOrDefault)(configuration, 'root', appName) || '';
+        const defaultOptions = (0, webpack_defaults_1.webpackDefaultsFactory)(pathToSource, entryFileRoot, entryFile, isDebugEnabled, tsConfigPath, plugins);
+        const projectWebpackOptions = typeof webpackConfigFactoryOrConfig !== 'function'
+            ? webpackConfigFactoryOrConfig
+            : webpackConfigFactoryOrConfig(defaultOptions, webpack);
+        const webpackConfiguration = Object.assign(Object.assign(Object.assign({}, defaultOptions), { mode: watchMode ? 'development' : defaultOptions.mode }), projectWebpackOptions);
+        const compiler = webpack(webpackConfiguration);
+        const afterCallback = (err, stats) => {
+            if (err && stats === undefined) {
+                // Could not complete the compilation
+                // The error caught is most likely thrown by underlying tasks
+                console.log(err);
+                return process.exit(1);
+            }
+            const statsOutput = stats.toString({
+                chunks: false,
+                colors: true,
+                modules: false,
+                assets: false,
+            });
+            if (!err && !stats.hasErrors()) {
+                if (!onSuccess) {
+                    assetsManager.closeWatchers();
+                }
+                else {
+                    onSuccess();
+                }
+            }
+            else if (!watchMode && !webpackConfiguration.watch) {
+                console.log(statsOutput);
+                return process.exit(1);
+            }
+            console.log(statsOutput);
+        };
+        if (watchMode || webpackConfiguration.watch) {
+            compiler.hooks.watchRun.tapAsync('Rebuild info', (params, callback) => {
+                console.log(`\n${ui_1.INFO_PREFIX} Webpack is building your sources...\n`);
+                callback();
+            });
+            compiler.watch(webpackConfiguration.watchOptions || {}, afterCallback);
+        }
+        else {
+            compiler.run(afterCallback);
+        }
+    }
+}
+exports.WebpackCompiler = WebpackCompiler;

package/lib/compiler/workspace-utils.d.ts

@@ -0,0 +1,4 @@
+import { Configuration } from '../configuration';
+export declare class WorkspaceUtils {
+    deleteOutDirIfEnabled(configuration: Required<Configuration>, appName: string, dirPath: string): Promise<void>;
+}

package/lib/compiler/workspace-utils.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.WorkspaceUtils = void 0;
+const rimraf = require("rimraf");
+const get_value_or_default_1 = require("./helpers/get-value-or-default");
+class WorkspaceUtils {
+    deleteOutDirIfEnabled(configuration, appName, dirPath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const isDeleteEnabled = (0, get_value_or_default_1.getValueOrDefault)(configuration, 'compilerOptions.deleteOutDir', appName);
+            if (!isDeleteEnabled) {
+                return;
+            }
+            yield new Promise((resolve, reject) => rimraf(dirPath, (err) => (err ? reject(err) : resolve())));
+        });
+    }
+}
+exports.WorkspaceUtils = WorkspaceUtils;

package/lib/configuration/configuration.d.ts

@@ -0,0 +1,52 @@
+export declare type Asset = 'string' | AssetEntry;
+export interface AssetEntry {
+    glob: string;
+    include?: string;
+    flat?: boolean;
+    exclude?: string;
+    outDir?: string;
+    watchAssets?: boolean;
+}
+export interface ActionOnFile {
+    action: 'change' | 'unlink';
+    item: AssetEntry;
+    path: string;
+    sourceRoot: string;
+    watchAssetsMode: boolean;
+}
+interface CompilerOptions {
+    tsConfigPath?: string;
+    webpack?: boolean;
+    webpackConfigPath?: string;
+    plugins?: string[] | PluginOptions[];
+    assets?: string[];
+    deleteOutDir?: boolean;
+}
+interface PluginOptions {
+    name: string;
+    options: Record<string, any>[];
+}
+interface GenerateOptions {
+    spec?: boolean | Record<string, boolean>;
+}
+export interface ProjectConfiguration {
+    type?: string;
+    root?: string;
+    entryFile?: string;
+    sourceRoot?: string;
+    compilerOptions?: CompilerOptions;
+}
+export interface Configuration {
+    [key: string]: any;
+    language?: string;
+    collection?: string;
+    sourceRoot?: string;
+    entryFile?: string;
+    monorepo?: boolean;
+    compilerOptions?: CompilerOptions;
+    generateOptions?: GenerateOptions;
+    projects?: {
+        [key: string]: ProjectConfiguration;
+    };
+}
+export {};

package/lib/configuration/configuration.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/configuration/configuration.loader.d.ts

@@ -0,0 +1,4 @@
+import { Configuration } from './configuration';
+export interface ConfigurationLoader {
+    load(name?: string): Required<Configuration> | Promise<Required<Configuration>>;
+}

package/lib/configuration/configuration.loader.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/configuration/defaults.d.ts

@@ -0,0 +1,4 @@
+import { Configuration } from './configuration';
+export declare const defaultConfiguration: Required<Configuration>;
+export declare const defaultOutDir = "dist";
+export declare const defaultGitIgnore = "# compiled output\ndist/\nnode_modules/\n\n# Logs\nlogs/\n*.log\nnpm-debug.log*\npnpm-debug.log*\nyarn-debug.log*\nyarn-error.log*\nlerna-debug.log*\n\n# OS\n.DS_Store\n\n# Tests\ncoverage\n.nyc_output\n\n# IDEs and editors\n.idea\n.project\n.classpath\n.c9/\n*.launch\n.settings/\n*.sublime-workspace\n\n# IDE - VSCode\n.vscode/*\n!.vscode/settings.json\n!.vscode/tasks.json\n!.vscode/launch.json\n!.vscode/extensions.json";

package/lib/configuration/defaults.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultGitIgnore = exports.defaultOutDir = exports.defaultConfiguration = void 0;
+const schematics_1 = require("../schematics");
+exports.defaultConfiguration = {
+    language: 'ts',
+    sourceRoot: 'src',
+    collection: schematics_1.Collection.GADMIN_GENERATOR,
+    entryFile: 'main',
+    projects: {},
+    monorepo: false,
+    compilerOptions: {
+        tsConfigPath: 'tsconfig.build.json',
+        webpack: false,
+        webpackConfigPath: 'webpack.config.js',
+        plugins: [],
+        assets: [],
+    },
+    generateOptions: {},
+};
+exports.defaultOutDir = 'dist';
+exports.defaultGitIgnore = `# compiled output
+dist/
+node_modules/
+
+# Logs
+logs/
+*.log
+npm-debug.log*
+pnpm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+lerna-debug.log*
+
+# OS
+.DS_Store
+
+# Tests
+coverage
+.nyc_output
+
+# IDEs and editors
+.idea
+.project
+.classpath
+.c9/
+*.launch
+.settings/
+*.sublime-workspace
+
+# IDE - VSCode
+.vscode/*
+!.vscode/settings.json
+!.vscode/tasks.json
+!.vscode/launch.json
+!.vscode/extensions.json`;

package/lib/configuration/gadmin-configuration.loader.d.ts

@@ -0,0 +1,8 @@
+import { Reader } from '../readers';
+import { Configuration } from './configuration';
+import { ConfigurationLoader } from './configuration.loader';
+export declare class GadminConfigurationLoader implements ConfigurationLoader {
+    private readonly reader;
+    constructor(reader: Reader);
+    load(name?: string): Promise<Required<Configuration>>;
+}

package/lib/configuration/gadmin-configuration.loader.js

@@ -0,0 +1,39 @@
+"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.GadminConfigurationLoader = void 0;
+const defaults_1 = require("./defaults");
+class GadminConfigurationLoader {
+    constructor(reader) {
+        this.reader = reader;
+    }
+    load(name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const content = name
+                ? yield this.reader.read(name)
+                : yield this.reader.readAnyOf([
+                    '.gadmincli.json',
+                    '.gadmin-cli.json',
+                    'gadmin-cli.json',
+                    'gadmin.json',
+                ]);
+            if (!content) {
+                return defaults_1.defaultConfiguration;
+            }
+            const fileConfig = JSON.parse(content);
+            if (fileConfig.compilerOptions) {
+                return Object.assign(Object.assign(Object.assign({}, defaults_1.defaultConfiguration), fileConfig), { compilerOptions: Object.assign(Object.assign({}, defaults_1.defaultConfiguration.compilerOptions), fileConfig.compilerOptions) });
+            }
+            return Object.assign(Object.assign({}, defaults_1.defaultConfiguration), fileConfig);
+        });
+    }
+}
+exports.GadminConfigurationLoader = GadminConfigurationLoader;

package/lib/configuration/index.d.ts

@@ -0,0 +1,3 @@
+export * from './configuration.loader';
+export * from './gadmin-configuration.loader';
+export * from './configuration';

package/lib/configuration/index.js

@@ -0,0 +1,19 @@
+"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("./configuration.loader"), exports);
+__exportStar(require("./gadmin-configuration.loader"), exports);
+__exportStar(require("./configuration"), exports);

package/lib/dependency-managers/index.d.ts

@@ -0,0 +1 @@
+export * from './nest.dependency-manager';

package/lib/dependency-managers/index.js

@@ -0,0 +1,17 @@
+"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("./nest.dependency-manager"), exports);

package/lib/dependency-managers/nest.dependency-manager.d.ts

@@ -0,0 +1,7 @@
+import { AbstractPackageManager } from '../package-managers';
+export declare class NestDependencyManager {
+    private packageManager;
+    constructor(packageManager: AbstractPackageManager);
+    read(): Promise<string[]>;
+    update(force: boolean, tag?: string): Promise<void>;
+}

package/lib/dependency-managers/nest.dependency-manager.js

@@ -0,0 +1,48 @@
+"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.NestDependencyManager = void 0;
+const ora = require("ora");
+const ui_1 = require("../ui");
+class NestDependencyManager {
+    constructor(packageManager) {
+        this.packageManager = packageManager;
+    }
+    read() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const production = yield this.packageManager.getProduction();
+            return production
+                .filter((dependency) => dependency.name.indexOf('@nestjs') > -1)
+                .map((dependency) => dependency.name);
+        });
+    }
+    update(force, tag = 'latest') {
+        return __awaiter(this, void 0, void 0, function* () {
+            const spinner = ora({
+                spinner: {
+                    interval: 120,
+                    frames: ['▹▹▹▹▹', '▸▹▹▹▹', '▹▸▹▹▹', '▹▹▸▹▹', '▹▹▹▸▹', '▹▹▹▹▸'],
+                },
+                text: ui_1.MESSAGES.PACKAGE_MANAGER_UPDATE_IN_PROGRESS,
+            });
+            spinner.start();
+            const dependencies = yield this.read();
+            if (force) {
+                yield this.packageManager.upgradeProduction(dependencies, tag);
+            }
+            else {
+                yield this.packageManager.updateProduction(dependencies);
+            }
+            spinner.succeed();
+        });
+    }
+}
+exports.NestDependencyManager = NestDependencyManager;

package/lib/package-managers/abstract.package-manager.d.ts

@@ -0,0 +1,25 @@
+import { AbstractRunner } from '../runners/abstract.runner';
+import { PackageManagerCommands } from './package-manager-commands';
+import { ProjectDependency } from './project.dependency';
+export declare abstract class AbstractPackageManager {
+    protected runner: AbstractRunner;
+    constructor(runner: AbstractRunner);
+    install(directory: string, packageManager: string): Promise<void>;
+    version(): Promise<string>;
+    addProduction(dependencies: string[], tag: string): Promise<boolean>;
+    addDevelopment(dependencies: string[], tag: string): Promise<void>;
+    private add;
+    getProduction(): Promise<ProjectDependency[]>;
+    getDevelopment(): Promise<ProjectDependency[]>;
+    private readPackageJson;
+    updateProduction(dependencies: string[]): Promise<void>;
+    updateDevelopment(dependencies: string[]): Promise<void>;
+    private update;
+    upgradeProduction(dependencies: string[], tag: string): Promise<void>;
+    upgradeDevelopment(dependencies: string[], tag: string): Promise<void>;
+    deleteProduction(dependencies: string[]): Promise<void>;
+    deleteDevelopment(dependencies: string[]): Promise<void>;
+    delete(commandArguments: string): Promise<void>;
+    abstract get name(): string;
+    abstract get cli(): PackageManagerCommands;
+}