@depup/nestjs__cli 11.0.16-depup.1

package/lib/package-managers/project.dependency.js

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

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

@@ -0,0 +1,7 @@
+import { AbstractPackageManager } from './abstract.package-manager';
+import { PackageManagerCommands } from './package-manager-commands';
+export declare class YarnPackageManager extends AbstractPackageManager {
+    constructor();
+    get name(): string;
+    get cli(): PackageManagerCommands;
+}

package/lib/package-managers/yarn.package-manager.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.YarnPackageManager = void 0;
+const runners_1 = require("../runners");
+const abstract_package_manager_1 = require("./abstract.package-manager");
+const package_manager_1 = require("./package-manager");
+class YarnPackageManager extends abstract_package_manager_1.AbstractPackageManager {
+    constructor() {
+        super(runners_1.RunnerFactory.create(runners_1.Runner.YARN));
+    }
+    get name() {
+        return package_manager_1.PackageManager.YARN.toUpperCase();
+    }
+    get cli() {
+        return {
+            install: 'install',
+            add: 'add',
+            update: 'upgrade',
+            remove: 'remove',
+            saveFlag: '',
+            saveDevFlag: '-D',
+            silentFlag: '--silent',
+        };
+    }
+}
+exports.YarnPackageManager = YarnPackageManager;

package/lib/questions/questions.d.ts

@@ -0,0 +1,9 @@
+export declare const generateInput: (name: string, message: string) => (defaultAnswer: string) => any;
+export declare const generateSelect: (name: string) => (message: string) => (choices: string[]) => {
+    name: string;
+    message: string;
+    choices: {
+        name: string;
+        value: string;
+    }[];
+};

package/lib/questions/questions.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSelect = exports.generateInput = void 0;
+const generateInput = (name, message) => {
+    return (defaultAnswer) => ({
+        name,
+        message,
+        default: defaultAnswer,
+    });
+};
+exports.generateInput = generateInput;
+const generateSelect = (name) => {
+    return (message) => {
+        return (choices) => {
+            const choicesFormatted = choices.map((choice) => ({
+                name: choice,
+                value: choice,
+            }));
+            return {
+                name,
+                message,
+                choices: choicesFormatted,
+            };
+        };
+    };
+};
+exports.generateSelect = generateSelect;

package/lib/readers/file-system.reader.d.ts

@@ -0,0 +1,8 @@
+import { Reader, ReaderFileLackPermissionsError } from './reader';
+export declare class FileSystemReader implements Reader {
+    private readonly directory;
+    constructor(directory: string);
+    list(): string[];
+    read(name: string): string;
+    readAnyOf(filenames: string[]): string | undefined | ReaderFileLackPermissionsError;
+}

package/lib/readers/file-system.reader.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileSystemReader = void 0;
+const fs = require("fs");
+const path = require("path");
+const reader_1 = require("./reader");
+class FileSystemReader {
+    constructor(directory) {
+        this.directory = directory;
+    }
+    list() {
+        return fs.readdirSync(this.directory);
+    }
+    read(name) {
+        return fs.readFileSync(path.join(this.directory, name), 'utf8');
+    }
+    readAnyOf(filenames) {
+        let firstFilePathFoundButWithInsufficientPermissions;
+        for (let id = 0; id < filenames.length; id++) {
+            const file = filenames[id];
+            try {
+                return this.read(file);
+            }
+            catch (readErr) {
+                if (!firstFilePathFoundButWithInsufficientPermissions &&
+                    typeof readErr?.code === 'string') {
+                    const isInsufficientPermissionsError = readErr.code === 'EACCES' || readErr.code === 'EPERM';
+                    if (isInsufficientPermissionsError) {
+                        firstFilePathFoundButWithInsufficientPermissions = readErr.path;
+                    }
+                }
+                const isLastFileToLookFor = id === filenames.length - 1;
+                if (!isLastFileToLookFor) {
+                    continue;
+                }
+                if (firstFilePathFoundButWithInsufficientPermissions) {
+                    return new reader_1.ReaderFileLackPermissionsError(firstFilePathFoundButWithInsufficientPermissions, readErr.code);
+                }
+                else {
+                    return undefined;
+                }
+            }
+        }
+    }
+}
+exports.FileSystemReader = FileSystemReader;

package/lib/readers/index.d.ts

@@ -0,0 +1,2 @@
+export * from './reader';
+export * from './file-system.reader';

package/lib/readers/index.js

@@ -0,0 +1,18 @@
+"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("./reader"), exports);
+__exportStar(require("./file-system.reader"), exports);

package/lib/readers/reader.d.ts

@@ -0,0 +1,10 @@
+export declare class ReaderFileLackPermissionsError extends Error {
+    readonly filePath: string;
+    readonly fsErrorCode: string;
+    constructor(filePath: string, fsErrorCode: string);
+}
+export interface Reader {
+    list(): string[];
+    read(name: string): string;
+    readAnyOf(filenames: string[]): string | undefined | ReaderFileLackPermissionsError;
+}

package/lib/readers/reader.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReaderFileLackPermissionsError = void 0;
+class ReaderFileLackPermissionsError extends Error {
+    constructor(filePath, fsErrorCode) {
+        super(`File ${filePath} lacks read permissions!`);
+        this.filePath = filePath;
+        this.fsErrorCode = fsErrorCode;
+    }
+}
+exports.ReaderFileLackPermissionsError = ReaderFileLackPermissionsError;

package/lib/runners/abstract.runner.d.ts

@@ -0,0 +1,11 @@
+export declare class AbstractRunner {
+    protected binary: string;
+    protected args: string[];
+    constructor(binary: string, args?: string[]);
+    run(command: string, collect?: boolean, cwd?: string): Promise<null | string>;
+    /**
+     * @param command
+     * @returns The entire command that will be ran when calling `run(command)`.
+     */
+    rawFullCommand(command: string): string;
+}

package/lib/runners/abstract.runner.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractRunner = void 0;
+const ansis_1 = require("ansis");
+const child_process_1 = require("child_process");
+const os_1 = require("os");
+const ui_1 = require("../ui");
+class AbstractRunner {
+    constructor(binary, args = []) {
+        this.binary = binary;
+        this.args = args;
+    }
+    async run(command, collect = false, cwd = process.cwd()) {
+        const args = [command];
+        const isWindows = (0, os_1.platform)() === 'win32';
+        const options = {
+            cwd,
+            stdio: collect ? 'pipe' : 'inherit',
+            shell: true,
+        };
+        return new Promise((resolve, reject) => {
+            const command = [this.binary, ...this.args, ...args].join(' ');
+            const child = (0, child_process_1.spawn)(command, options);
+            if (collect) {
+                child.stdout.on('data', (data) => resolve(data.toString().replace(/\r\n|\n/, '')));
+            }
+            child.on('close', (code) => {
+                if (code === 0) {
+                    resolve(null);
+                }
+                else {
+                    console.error((0, ansis_1.red)(ui_1.MESSAGES.RUNNER_EXECUTION_ERROR(`${this.binary} ${command}`)));
+                    reject();
+                }
+            });
+        });
+    }
+    /**
+     * @param command
+     * @returns The entire command that will be ran when calling `run(command)`.
+     */
+    rawFullCommand(command) {
+        const commandArgs = [...this.args, command];
+        return `${this.binary} ${commandArgs.join(' ')}`;
+    }
+}
+exports.AbstractRunner = AbstractRunner;

package/lib/runners/git.runner.d.ts

@@ -0,0 +1,4 @@
+import { AbstractRunner } from './abstract.runner';
+export declare class GitRunner extends AbstractRunner {
+    constructor();
+}

package/lib/runners/git.runner.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitRunner = void 0;
+const abstract_runner_1 = require("./abstract.runner");
+class GitRunner extends abstract_runner_1.AbstractRunner {
+    constructor() {
+        super('git');
+    }
+}
+exports.GitRunner = GitRunner;

package/lib/runners/index.d.ts

@@ -0,0 +1,3 @@
+export * from './runner';
+export * from './runner.factory';
+export * from './abstract.runner';

package/lib/runners/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("./runner"), exports);
+__exportStar(require("./runner.factory"), exports);
+__exportStar(require("./abstract.runner"), exports);

package/lib/runners/npm.runner.d.ts

@@ -0,0 +1,4 @@
+import { AbstractRunner } from './abstract.runner';
+export declare class NpmRunner extends AbstractRunner {
+    constructor();
+}

package/lib/runners/npm.runner.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NpmRunner = void 0;
+const abstract_runner_1 = require("./abstract.runner");
+class NpmRunner extends abstract_runner_1.AbstractRunner {
+    constructor() {
+        super('npm');
+    }
+}
+exports.NpmRunner = NpmRunner;

package/lib/runners/pnpm.runner.d.ts

@@ -0,0 +1,4 @@
+import { AbstractRunner } from './abstract.runner';
+export declare class PnpmRunner extends AbstractRunner {
+    constructor();
+}

package/lib/runners/pnpm.runner.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PnpmRunner = void 0;
+const abstract_runner_1 = require("./abstract.runner");
+class PnpmRunner extends abstract_runner_1.AbstractRunner {
+    constructor() {
+        super('pnpm');
+    }
+}
+exports.PnpmRunner = PnpmRunner;

package/lib/runners/runner.d.ts

@@ -0,0 +1,6 @@
+export declare enum Runner {
+    SCHEMATIC = 0,
+    NPM = 1,
+    YARN = 2,
+    PNPM = 3
+}

package/lib/runners/runner.factory.d.ts

@@ -0,0 +1,8 @@
+import { NpmRunner } from './npm.runner';
+import { Runner } from './runner';
+import { SchematicRunner } from './schematic.runner';
+import { YarnRunner } from './yarn.runner';
+import { PnpmRunner } from './pnpm.runner';
+export declare class RunnerFactory {
+    static create(runner: Runner): NpmRunner | SchematicRunner | YarnRunner | PnpmRunner | undefined;
+}

package/lib/runners/runner.factory.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunnerFactory = void 0;
+const ansis_1 = require("ansis");
+const npm_runner_1 = require("./npm.runner");
+const runner_1 = require("./runner");
+const schematic_runner_1 = require("./schematic.runner");
+const yarn_runner_1 = require("./yarn.runner");
+const pnpm_runner_1 = require("./pnpm.runner");
+class RunnerFactory {
+    static create(runner) {
+        switch (runner) {
+            case runner_1.Runner.SCHEMATIC:
+                return new schematic_runner_1.SchematicRunner();
+            case runner_1.Runner.NPM:
+                return new npm_runner_1.NpmRunner();
+            case runner_1.Runner.YARN:
+                return new yarn_runner_1.YarnRunner();
+            case runner_1.Runner.PNPM:
+                return new pnpm_runner_1.PnpmRunner();
+            default:
+                console.info((0, ansis_1.yellow) `[WARN] Unsupported runner: ${runner}`);
+        }
+    }
+}
+exports.RunnerFactory = RunnerFactory;

package/lib/runners/runner.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Runner = void 0;
+var Runner;
+(function (Runner) {
+    Runner[Runner["SCHEMATIC"] = 0] = "SCHEMATIC";
+    Runner[Runner["NPM"] = 1] = "NPM";
+    Runner[Runner["YARN"] = 2] = "YARN";
+    Runner[Runner["PNPM"] = 3] = "PNPM";
+})(Runner || (exports.Runner = Runner = {}));

package/lib/runners/schematic.runner.d.ts

@@ -0,0 +1,6 @@
+import { AbstractRunner } from './abstract.runner';
+export declare class SchematicRunner extends AbstractRunner {
+    constructor();
+    static getModulePaths(): string[];
+    static findClosestSchematicsBinary(): string;
+}

package/lib/runners/schematic.runner.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchematicRunner = void 0;
+const abstract_runner_1 = require("./abstract.runner");
+class SchematicRunner extends abstract_runner_1.AbstractRunner {
+    constructor() {
+        super(`node`, [`"${SchematicRunner.findClosestSchematicsBinary()}"`]);
+    }
+    static getModulePaths() {
+        return module.paths;
+    }
+    static findClosestSchematicsBinary() {
+        try {
+            return require.resolve('@angular-devkit/schematics-cli/bin/schematics.js', { paths: this.getModulePaths() });
+        }
+        catch {
+            throw new Error("'schematics' binary path could not be found!");
+        }
+    }
+}
+exports.SchematicRunner = SchematicRunner;

package/lib/runners/yarn.runner.d.ts

@@ -0,0 +1,4 @@
+import { AbstractRunner } from './abstract.runner';
+export declare class YarnRunner extends AbstractRunner {
+    constructor();
+}

package/lib/runners/yarn.runner.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.YarnRunner = void 0;
+const abstract_runner_1 = require("./abstract.runner");
+class YarnRunner extends abstract_runner_1.AbstractRunner {
+    constructor() {
+        super('yarn');
+    }
+}
+exports.YarnRunner = YarnRunner;

package/lib/schematics/abstract.collection.d.ts

@@ -0,0 +1,12 @@
+import { AbstractRunner } from '../runners';
+import { Schematic } from './nest.collection';
+import { SchematicOption } from './schematic.option';
+export declare abstract class AbstractCollection {
+    protected collection: string;
+    protected runner: AbstractRunner;
+    constructor(collection: string, runner: AbstractRunner);
+    execute(name: string, options: SchematicOption[], extraFlags?: string): Promise<void>;
+    abstract getSchematics(): Schematic[];
+    private buildCommandLine;
+    private buildOptions;
+}

package/lib/schematics/abstract.collection.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractCollection = void 0;
+class AbstractCollection {
+    constructor(collection, runner) {
+        this.collection = collection;
+        this.runner = runner;
+    }
+    async execute(name, options, extraFlags) {
+        let command = this.buildCommandLine(name, options);
+        command = extraFlags ? command.concat(` ${extraFlags}`) : command;
+        await this.runner.run(command);
+    }
+    buildCommandLine(name, options) {
+        return `${this.collection}:${name}${this.buildOptions(options)}`;
+    }
+    buildOptions(options) {
+        return options.reduce((line, option) => {
+            return line.concat(` ${option.toCommandString()}`);
+        }, '');
+    }
+}
+exports.AbstractCollection = AbstractCollection;

package/lib/schematics/collection.d.ts

@@ -0,0 +1,3 @@
+export declare enum Collection {
+    NESTJS = "@nestjs/schematics"
+}

package/lib/schematics/collection.factory.d.ts

@@ -0,0 +1,5 @@
+import { AbstractCollection } from './abstract.collection';
+import { Collection } from './collection';
+export declare class CollectionFactory {
+    static create(collection: Collection | string): AbstractCollection;
+}

package/lib/schematics/collection.factory.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CollectionFactory = void 0;
+const runners_1 = require("../runners");
+const collection_1 = require("./collection");
+const custom_collection_1 = require("./custom.collection");
+const nest_collection_1 = require("./nest.collection");
+class CollectionFactory {
+    static create(collection) {
+        const schematicRunner = runners_1.RunnerFactory.create(runners_1.Runner.SCHEMATIC);
+        if (collection === collection_1.Collection.NESTJS) {
+            return new nest_collection_1.NestCollection(schematicRunner);
+        }
+        else {
+            return new custom_collection_1.CustomCollection(collection, schematicRunner);
+        }
+    }
+}
+exports.CollectionFactory = CollectionFactory;

package/lib/schematics/collection.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Collection = void 0;
+var Collection;
+(function (Collection) {
+    Collection["NESTJS"] = "@nestjs/schematics";
+})(Collection || (exports.Collection = Collection = {}));

package/lib/schematics/custom.collection.d.ts

@@ -0,0 +1,10 @@
+import { AbstractCollection } from './abstract.collection';
+import { Schematic } from './nest.collection';
+export interface CollectionSchematic {
+    schema: string;
+    description: string;
+    aliases: string[];
+}
+export declare class CustomCollection extends AbstractCollection {
+    getSchematics(): Schematic[];
+}

package/lib/schematics/custom.collection.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomCollection = void 0;
+const tools_1 = require("@angular-devkit/schematics/tools");
+const abstract_collection_1 = require("./abstract.collection");
+class CustomCollection extends abstract_collection_1.AbstractCollection {
+    getSchematics() {
+        const workflow = new tools_1.NodeWorkflow(process.cwd(), {});
+        const collection = workflow.engine.createCollection(this.collection);
+        const collectionDescriptions = [
+            collection.description,
+            ...(collection.baseDescriptions ?? []),
+        ];
+        const usedNames = new Set();
+        const schematics = [];
+        for (const collectionDesc of collectionDescriptions) {
+            const schematicsDescs = Object.entries(collectionDesc.schematics);
+            for (const [name, { description, aliases = [] }] of schematicsDescs) {
+                if (usedNames.has(name)) {
+                    continue;
+                }
+                usedNames.add(name);
+                const alias = aliases.find((a) => !usedNames.has(a)) ?? name;
+                for (const alias of aliases) {
+                    usedNames.add(alias);
+                }
+                schematics.push({ name, alias, description });
+            }
+        }
+        return schematics.sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+    }
+}
+exports.CustomCollection = CustomCollection;

package/lib/schematics/index.d.ts

@@ -0,0 +1,4 @@
+export * from './collection';
+export * from './collection.factory';
+export * from './schematic.option';
+export * from './abstract.collection';

package/lib/schematics/index.js

@@ -0,0 +1,20 @@
+"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("./collection"), exports);
+__exportStar(require("./collection.factory"), exports);
+__exportStar(require("./schematic.option"), exports);
+__exportStar(require("./abstract.collection"), exports);

package/lib/schematics/nest.collection.d.ts

@@ -0,0 +1,15 @@
+import { AbstractRunner } from '../runners';
+import { AbstractCollection } from './abstract.collection';
+import { SchematicOption } from './schematic.option';
+export interface Schematic {
+    name: string;
+    alias: string;
+    description: string;
+}
+export declare class NestCollection extends AbstractCollection {
+    private static schematics;
+    constructor(runner: AbstractRunner);
+    execute(name: string, options: SchematicOption[]): Promise<void>;
+    getSchematics(): Schematic[];
+    private validate;
+}