@mbc-cqrs-serverless/cli 0.1.50-beta.0 → 0.1.51-beta.0

package/dist/actions/generate.action.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = generateAction;
+const schematic_runner_1 = require("../runners/schematic.runner");
+const schematics_1 = require("../schematics");
+const ui_1 = require("../ui");
+/* eslint-disable no-console */
+async function generateAction(schematic, name, options, command) {
+    ui_1.logger.info(`Executing command '${command.name()}' for application with options '${JSON.stringify(options)}'`);
+    const commandOptions = command.opts();
+    const formatOptions = [];
+    formatOptions.push({ name: 'dry-run', value: !!commandOptions.dryRun });
+    formatOptions.push({ name: 'mode', value: commandOptions.mode });
+    formatOptions.push({
+        name: 'schema',
+        value: !!commandOptions.schema || !!commandOptions.noSchema, // noSchema > schema
+    });
+    const inputs = [];
+    inputs.push({ name: 'schematic', value: schematic });
+    inputs.push({ name: 'name', value: name });
+    const fullInputs = formatOptions.concat(inputs);
+    const schematicOptions = mapSchematicOptions(fullInputs);
+    const runner = new schematic_runner_1.SchematicRunner();
+    const fullCommand = buildCommandLine(schematic, schematicOptions);
+    runner.run(fullCommand);
+}
+function buildCommandLine(name, options) {
+    return `@mbc-cqrs-serverless/cli:${name}${buildOptions(options)}`;
+}
+function buildOptions(options) {
+    return options.reduce((line, option) => {
+        return line.concat(` ${option.toCommandString()}`);
+    }, '');
+}
+const mapSchematicOptions = (inputs) => {
+    const excludedInputNames = ['schematic', 'spec', 'flat', 'specFileSuffix'];
+    const options = [];
+    inputs.forEach((input) => {
+        if (!excludedInputNames.includes(input.name) && input.value !== undefined) {
+            options.push(new schematics_1.SchematicOption(input.name, input.value));
+        }
+    });
+    return options;
+};

package/dist/actions/new.action.get-package-version.spec.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const child_process_1 = require("child_process");
+const new_action_1 = require("./new.action");
+const { getPackageVersion } = new_action_1.exportsForTesting;
+jest.mock('child_process', () => ({
+    execSync: jest.fn(),
+}));
+describe('getPackageVersion', () => {
+    const mockExecSync = child_process_1.execSync;
+    const packageName = '@mbc-cqrs-serverless/core';
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+    it('should return the latest version when isLatest is true', () => {
+        const mockLatestVersion = '1.2.3';
+        mockExecSync.mockReturnValue(Buffer.from(`${mockLatestVersion}\n`));
+        const result = getPackageVersion(packageName, true);
+        expect(mockExecSync).toHaveBeenCalledWith(`npm view ${packageName} dist-tags.latest`);
+        expect(result).toEqual([mockLatestVersion]);
+    });
+    it('should return all versions when isLatest is false', () => {
+        const mockVersions = ['1.0.0', '1.1.0', '1.2.0'];
+        mockExecSync.mockReturnValue(Buffer.from(JSON.stringify(mockVersions)));
+        const result = getPackageVersion(packageName, false);
+        expect(mockExecSync).toHaveBeenCalledWith(`npm view ${packageName} versions --json`);
+        expect(result).toEqual(mockVersions);
+    });
+});

package/dist/actions/new.action.is-latest-version.spec.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const child_process_1 = require("child_process");
+const new_action_1 = require("./new.action");
+const { isLatestCli } = new_action_1.exportsForTesting;
+jest.mock('child_process', () => ({
+    execSync: jest.fn(),
+}));
+jest.mock('fs', () => ({
+    readFileSync: jest.fn(() => JSON.stringify({ version: '1.0.0' })),
+}));
+jest.mock('path', () => ({
+    join: jest.fn(() => '/mocked/path/to/package.json'),
+}));
+describe('isLatestCli', () => {
+    const mockExecSync = child_process_1.execSync;
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+    it('should return true if the current version matches the latest version', () => {
+        const mockLatestVersion = ['1.0.0'];
+        mockExecSync.mockReturnValue(Buffer.from(`${mockLatestVersion}\n`));
+        // Run the function
+        const result = isLatestCli();
+        // Assert that the result is true
+        expect(result).toBe(true);
+    });
+    it('should return false if the current version does not match the latest version', () => {
+        const mockLatestVersion = ['1.2.3'];
+        mockExecSync.mockReturnValue(Buffer.from(`${mockLatestVersion}\n`));
+        // Run the function
+        const result = isLatestCli();
+        // Assert that the result is true
+        expect(result).toBe(false);
+    });
+});

package/dist/actions/new.action.js

@@ -5,13 +5,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.exportsForTesting = void 0;
 exports.default = newAction;
+const chalk_1 = __importDefault(require("chalk"));
 const child_process_1 = require("child_process");
 const fs_1 = require("fs");
 const path_1 = __importDefault(require("path"));
+const ui_1 = require("../ui");
 /* eslint-disable no-console */
 async function newAction(name = '', options, command) {
     const [projectName, version = 'latest'] = name.split('@');
-    console.log(`Executing command '${command.name()}' for application '${projectName}' with options '${JSON.stringify(options)}'`);
+    ui_1.logger.info(`Executing command '${command.name()}' for application '${projectName}' with options '${JSON.stringify(options)}'`);
     let packageVersion;
     if (version === 'latest') {
         packageVersion = `^${getPackageVersion('@mbc-cqrs-serverless/core', true)[0]}`; //  use the latest patch and minor versions
@@ -27,12 +29,12 @@ async function newAction(name = '', options, command) {
             packageVersion = `^${matchVersions.at(-1)}`; // use the patch and minor versions
         }
         else {
-            console.log('The specified package version does not exist. Please chose a valid version!\n', versions);
+            ui_1.logger.error(`The specified package version does not exist. Please chose a valid version! ${versions}`);
             return;
         }
     }
     const destDir = path_1.default.join(process.cwd(), projectName);
-    console.log('Generating MBC cqrs serverless application in', destDir);
+    ui_1.logger.title('MBC', `Generating MBC cqrs serverless application in ${chalk_1.default.green(destDir)}`);
     (0, fs_1.mkdirSync)(destDir, { recursive: true });
     useTemplate(destDir);
     usePackageVersion(destDir, packageVersion, projectName);
@@ -49,12 +51,16 @@ async function newAction(name = '', options, command) {
     // cp .env.local .env
     (0, fs_1.copyFileSync)(path_1.default.join(destDir, '.env.local'), path_1.default.join(destDir, '.env'));
     // git init
+    ui_1.logger.title('git', 'Initializing git repository.');
     let logs = (0, child_process_1.execSync)('git init', { cwd: destDir });
-    console.log(logs.toString());
+    ui_1.logger.success('Initialized a git repository.');
     // npm install
-    console.log('Installing packages in', destDir);
-    logs = (0, child_process_1.execSync)('npm i', { cwd: destDir });
+    ui_1.logger.title('deps', `Installing dependencies`);
+    logs = (0, child_process_1.execSync)('npm i --ignore-scripts', { cwd: destDir });
+    (0, child_process_1.execSync)('npx prisma generate', { cwd: destDir });
     console.log(logs.toString());
+    ui_1.logger.success(`Dependencies installed`);
+    ui_1.logger.title('MBC', `Your application was created!`);
 }
 function useTemplate(destDir) {
     if (isLatestCli()) {

package/dist/actions/new.action.spec.js

@@ -0,0 +1,84 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const child_process_1 = require("child_process");
+const commander_1 = require("commander");
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const new_action_1 = __importDefault(require("./new.action"));
+jest.mock('child_process', () => ({
+    execSync: jest.fn(),
+}));
+jest.mock('fs', () => ({
+    copyFileSync: jest.fn(),
+    cpSync: jest.fn(),
+    mkdirSync: jest.fn(),
+    unlinkSync: jest.fn(),
+    writeFileSync: jest.fn(),
+    readFileSync: jest.fn(() => JSON.stringify({ version: '1.2.3', dependencies: {}, devDependencies: {} })),
+}));
+describe('newAction', () => {
+    const mockExecSync = child_process_1.execSync;
+    const mockCommand = new commander_1.Command().name('new'); // Mock command with name 'new'
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    it('should generate a project with the latest version when version is not specified', async () => {
+        const projectName = 'test-project';
+        const latestVersion = '1.2.3';
+        mockExecSync
+            .mockReturnValueOnce(Buffer.from(latestVersion)) // latest core
+            .mockReturnValueOnce(Buffer.from(latestVersion)) // latest cli
+            .mockReturnValue(Buffer.from(''));
+        await (0, new_action_1.default)(`${projectName}`, {}, mockCommand);
+        expect(child_process_1.execSync).toHaveBeenCalledWith('npm view @mbc-cqrs-serverless/core dist-tags.latest');
+        expect(fs_1.mkdirSync).toHaveBeenCalledWith(path_1.default.join(process.cwd(), projectName), { recursive: true });
+        expect(fs_1.cpSync).toHaveBeenCalledWith(path_1.default.join(__dirname, '../../templates'), path_1.default.join(process.cwd(), projectName), { recursive: true });
+        expect(fs_1.copyFileSync).toHaveBeenCalledTimes(3); // For .gitignore, infra/.gitignore and .env.local
+        expect(mockExecSync).toHaveBeenCalledWith('git init', {
+            cwd: path_1.default.join(process.cwd(), projectName),
+        });
+        expect(mockExecSync).toHaveBeenCalledWith('npm i --ignore-scripts', {
+            cwd: path_1.default.join(process.cwd(), projectName),
+        });
+        expect(mockExecSync).toHaveBeenCalledWith('npx prisma generate', {
+            cwd: path_1.default.join(process.cwd(), projectName),
+        });
+    });
+    it('should use a specific version if specified', async () => {
+        const projectName = 'test-project';
+        const version = '1.0.0';
+        const mockVersions = ['1.0.0', '1.1.0', '1.2.0'];
+        mockExecSync
+            .mockReturnValueOnce(Buffer.from(JSON.stringify(mockVersions))) // list version core
+            .mockReturnValueOnce(Buffer.from('1.2.3')) // latest cli
+            .mockReturnValue(Buffer.from(''));
+        await (0, new_action_1.default)(`${projectName}@${version}`, {}, mockCommand);
+        expect(child_process_1.execSync).toHaveBeenCalledWith('npm view @mbc-cqrs-serverless/core versions --json');
+        expect(fs_1.mkdirSync).toHaveBeenCalledWith(path_1.default.join(process.cwd(), projectName), { recursive: true });
+        expect(fs_1.cpSync).toHaveBeenCalledWith(path_1.default.join(__dirname, '../../templates'), path_1.default.join(process.cwd(), projectName), { recursive: true });
+        expect(fs_1.copyFileSync).toHaveBeenCalledTimes(3); // For .gitignore, infra/.gitignore and .env.local
+        expect(mockExecSync).toHaveBeenCalledWith('git init', {
+            cwd: path_1.default.join(process.cwd(), projectName),
+        });
+        expect(mockExecSync).toHaveBeenCalledWith('npm i --ignore-scripts', {
+            cwd: path_1.default.join(process.cwd(), projectName),
+        });
+        expect(mockExecSync).toHaveBeenCalledWith('npx prisma generate', {
+            cwd: path_1.default.join(process.cwd(), projectName),
+        });
+    });
+    it('should throw an error for an invalid version', async () => {
+        const projectName = 'test-project';
+        const invalidVersion = '2.0.0';
+        const mockVersions = ['1.0.0', '1.1.0', '1.2.0'];
+        mockExecSync.mockReturnValueOnce(Buffer.from(JSON.stringify(mockVersions)));
+        const consoleSpy = jest.spyOn(console, 'error').mockImplementation();
+        await (0, new_action_1.default)(`${projectName}@${invalidVersion}`, {}, mockCommand);
+        expect(child_process_1.execSync).toHaveBeenCalledWith('npm view @mbc-cqrs-serverless/core versions --json');
+        expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('The specified package version does not exist'));
+        consoleSpy.mockRestore();
+    });
+});

package/dist/actions/new.action.update-env-local.spec.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = require("fs");
+const new_action_1 = require("./new.action");
+const { updateEnvLocal } = new_action_1.exportsForTesting;
+jest.mock('fs');
+describe('updateEnvLocal', () => {
+    const mockEnvContent = `
+      # name of application
+      APP_NAME=%%projectName%%
+      # name of docker compose
+      COMPOSE_PROJECT_NAME=%%projectName%%
+      `;
+    const envPath = './.env.local';
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    it('should update the specified value in the .env.local file', () => {
+        const searchValue = '%%projectName%%';
+        const replaceValue = 'new-project-name';
+        fs_1.readFileSync.mockReturnValue(mockEnvContent);
+        updateEnvLocal(envPath, searchValue, replaceValue);
+        expect(fs_1.readFileSync).toHaveBeenCalledWith(envPath, 'utf8');
+        const expectedContent = mockEnvContent.replaceAll(searchValue, replaceValue);
+        expect(fs_1.writeFileSync).toHaveBeenCalledWith(envPath, expectedContent);
+    });
+    it('should not change the file content if searchValue is not found', () => {
+        const searchValue = 'non-existent-value';
+        const replaceValue = 'new-project-name';
+        fs_1.readFileSync.mockReturnValue(mockEnvContent);
+        updateEnvLocal(envPath, searchValue, replaceValue);
+        expect(fs_1.readFileSync).toHaveBeenCalledWith(envPath, 'utf8');
+        expect(fs_1.writeFileSync).toHaveBeenCalledWith(envPath, mockEnvContent);
+    });
+});

package/dist/actions/new.action.use-package-version.spec.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const faker_1 = require("@faker-js/faker");
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const new_action_1 = require("./new.action");
+const { usePackageVersion } = new_action_1.exportsForTesting;
+// create testcase for usePackageVersion function in new.action.ts file
+describe('usePackageVersion', () => {
+    const fname = path_1.default.join(__dirname, 'package.json');
+    const packageVersion = '1.0.0';
+    const packageJson = JSON.parse((0, fs_1.readFileSync)(path_1.default.join(__dirname, '../../package.json')).toString());
+    beforeEach(() => {
+        (0, fs_1.copyFileSync)(path_1.default.join(__dirname, '../../templates/package.json'), fname);
+    });
+    afterEach(() => {
+        (0, fs_1.unlinkSync)(fname);
+    });
+    it('it should update deps', () => {
+        usePackageVersion(__dirname, packageVersion);
+        const tplPackageJson = JSON.parse((0, fs_1.readFileSync)(fname).toString());
+        expect(tplPackageJson.dependencies['@mbc-cqrs-serverless/core']).toBe(packageVersion);
+        expect(packageJson.version).toBe(tplPackageJson.devDependencies['@mbc-cqrs-serverless/cli']);
+    });
+    it('it should not update name', () => {
+        const { name } = JSON.parse((0, fs_1.readFileSync)(fname).toString());
+        usePackageVersion(__dirname, packageVersion);
+        const tplPackageJson = JSON.parse((0, fs_1.readFileSync)(fname).toString());
+        expect(name).toBe(tplPackageJson.name);
+    });
+    it('it should not update name with empty name', () => {
+        const { name } = JSON.parse((0, fs_1.readFileSync)(fname).toString());
+        usePackageVersion(__dirname, packageVersion, '');
+        const tplPackageJson = JSON.parse((0, fs_1.readFileSync)(fname).toString());
+        expect(name).toBe(tplPackageJson.name);
+    });
+    it('it should update name', () => {
+        const name = faker_1.faker.word.sample();
+        usePackageVersion(__dirname, packageVersion, name);
+        const tplPackageJson = JSON.parse((0, fs_1.readFileSync)(fname).toString());
+        expect(name).toBe(tplPackageJson.name);
+    });
+});

package/dist/actions/ui.action.js

@@ -8,18 +8,19 @@ const child_process_1 = require("child_process");
 const fs_1 = require("fs");
 const path_1 = __importDefault(require("path"));
 const rimraf_1 = require("rimraf");
+const ui_1 = require("../ui");
 const repoUrl = 'https://gitlab.com/mbc-net/common/mbc-cqrs-ui-common.git';
 const componentOptions = ['all', 'appsync', 'component'];
 /* eslint-disable no-console */
 async function uiAction(options, command) {
-    console.log(`Executing command '${command.name()}' for application with options '${JSON.stringify(options)}'`);
+    ui_1.logger.info(`Executing command '${command.name()}' for application with options '${JSON.stringify(options)}'`);
     const { branch, auth, component, pathDir, token = '' } = options;
     if (componentOptions.findIndex((optionName) => optionName === component) === -1) {
-        console.error(`Please choose correct component options: ${componentOptions.join(', ')}`);
+        ui_1.logger.error(`Please choose correct component options: ${componentOptions.join(', ')}`);
     }
     // Check command run in base src
     if (!(0, fs_1.existsSync)(path_1.default.join(process.cwd(), 'tsconfig.json'))) {
-        console.log('Please run command in base folder');
+        ui_1.logger.error('Please run command in base folder');
         return;
     }
     // Check tsconfig.json contain path @ms
@@ -27,7 +28,7 @@ async function uiAction(options, command) {
     if (tsconfig?.compilerOptions &&
         tsconfig?.compilerOptions?.paths &&
         tsconfig?.compilerOptions?.paths.hasOwnProperty('@ms/*')) {
-        console.log('The project already contain mbc-cqrs-ui-common');
+        ui_1.logger.error('The project already contain mbc-cqrs-ui-common');
         return;
     }
     // Copy source
@@ -52,9 +53,10 @@ async function uiAction(options, command) {
     // Modify package.json
     modifyDependencies({ pathDir, component });
     // npm install
-    console.log('Installing packages');
+    ui_1.logger.title('deps', `Installing dependencies`);
     const logs = (0, child_process_1.execSync)('npm i');
     console.log(logs.toString());
+    ui_1.logger.success(`Dependencies installed`);
 }
 const installTemplate = ({ auth, token, pathDir, branch, component, }) => {
     let gitUrl = repoUrl;

package/dist/commands/command.input.js

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

package/dist/commands/generate.command.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCommand = generateCommand;
+const generate_action_1 = __importDefault(require("../actions/generate.action"));
+const schematic_colection_1 = require("../schematics/schematic.colection");
+async function generateCommand(program) {
+    program
+        .command('generate <schematic> [name]')
+        .alias('g')
+        .description(buildDescription())
+        .option('-d, --dry-run', 'Report actions that would be taken without writing out results.')
+        .option('--mode <mode>', 'Specify the mode of operation: sync or async (default: async)', 'async')
+        .option('--schema', 'Enable schema generation (default: true)', true)
+        .option('--no-schema', 'Disable schema generation (default: false)', false)
+        .action(generate_action_1.default);
+}
+function buildDescription() {
+    return ('Generate a MBC-cqrs-serverless element.\n' +
+        `  Schematics available on the collection:\n` +
+        (0, schematic_colection_1.buildSchematicsListAsTable)());
+}

package/dist/commands/index.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = loadCommands;
+const generate_command_1 = require("./generate.command");
 const new_command_1 = require("./new.command");
 const start_command_1 = require("./start.command");
 const ui_command_1 = require("./ui.command");
@@ -8,6 +9,7 @@ function loadCommands(program) {
     (0, new_command_1.newCommand)(program);
     (0, start_command_1.startCommand)(program);
     (0, ui_command_1.uiCommand)(program);
+    (0, generate_command_1.generateCommand)(program);
     // error handling
     program.on('command:*', () => {
         console.error(`\nInvalid command: '${program.args.join(' ')}'`);

package/dist/index.js

@@ -6,11 +6,22 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const commander_1 = require("commander");
 const commands_1 = __importDefault(require("./commands"));
+const utils_1 = require("./utils");
 async function bootstrap() {
     const program = new commander_1.Command();
+    program
+        .version(
     // eslint-disable-next-line @typescript-eslint/no-var-requires
-    program.version(require('../package.json').version);
-    (0, commands_1.default)(program);
+    require('../package.json').version, '-v, --version', 'Output the current version.')
+        .usage('<command> [options]')
+        .helpOption('-h, --help', 'Output usage information.');
+    if ((0, utils_1.localBinExists)()) {
+        const localCommandLoader = (0, utils_1.loadLocalBinCommandLoader)();
+        localCommandLoader.default(program);
+    }
+    else {
+        (0, commands_1.default)(program);
+    }
     await program.parseAsync(process.argv);
     if (!process.argv.slice(2).length) {
         program.outputHelp();

package/dist/runners/abstract.runner.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractRunner = void 0;
+const child_process_1 = require("child_process");
+const ui_1 = require("../ui");
+/* eslint-disable no-console */
+class AbstractRunner {
+    constructor(binary, args = []) {
+        this.binary = binary;
+        this.args = args;
+    }
+    async run(command, collect = false, cwd = process.cwd()) {
+        const args = [command];
+        const options = {
+            cwd,
+            stdio: collect ? 'pipe' : 'inherit',
+            shell: true,
+        };
+        return new Promise((resolve, reject) => {
+            const child = (0, child_process_1.spawn)(`${this.binary}`, [...this.args, ...args], 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(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/dist/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/dist/schematics/collection.json

@@ -0,0 +1,34 @@
+{
+  "$schema": "../../../node_modules/@angular-devkit/schematics/collection-schema.json",
+  "schematics": {
+    "module": {
+      "factory": "./lib/module/module.factory#main",
+      "description": "Create a mbc-cqrs-serverless module.",
+      "schema": "./lib/module/schema.json",
+      "aliases": ["mo"]
+    },
+    "controller": {
+      "factory": "./lib/controller/controller.factory#main",
+      "description": "Create a mbc-cqrs-serverless controller.",
+      "schema": "./lib/controller/schema.json",
+      "aliases": ["co"]
+    },
+    "service": {
+      "factory": "./lib/service/service.factory#main",
+      "description": "Create a mbc-cqrs-serverless service.",
+      "schema": "./lib/service/schema.json",
+      "aliases": ["se"]
+    },
+    "entity": {
+      "factory": "./lib/entity/entity.factory#main",
+      "description": "Create a mbc-cqrs-serverless entity.",
+      "schema": "./lib/entity/schema.json",
+      "aliases": ["en"]
+    },
+    "dto": {
+      "factory": "./lib/dto/dto.factory#main",
+      "description": "Create a mbc-cqrs-serverless dto.",
+      "schema": "./lib/dto/schema.json"
+    }
+  }
+}

package/dist/schematics/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("./schematic.option"), exports);

package/dist/schematics/lib/controller/controller.factory.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = main;
+const core_1 = require("@angular-devkit/core");
+const schematics_1 = require("@angular-devkit/schematics");
+function createController(options) {
+    return (0, schematics_1.mergeWith)((0, schematics_1.apply)((0, schematics_1.url)('./files'), [
+        (0, schematics_1.template)({
+            ...core_1.strings,
+            ...options,
+        }),
+        (0, schematics_1.move)((0, core_1.normalize)(`/src/${core_1.strings.dasherize(options.name)}`)),
+    ]));
+}
+function createUnitTest(options) {
+    return (0, schematics_1.mergeWith)((0, schematics_1.apply)((0, schematics_1.url)('./units'), [
+        (0, schematics_1.template)({
+            ...core_1.strings,
+            ...options,
+            specFileSuffix: 'spec',
+        }),
+        (0, schematics_1.move)((0, core_1.normalize)(`/test/unit/${core_1.strings.dasherize(options.name)}`)),
+    ]));
+}
+function main(options) {
+    return (tree, _context) => {
+        const filePath = (0, core_1.normalize)(`/src/${core_1.strings.dasherize(options.name)}/${core_1.strings.dasherize(options.name)}.controller.ts`);
+        const unitPath = (0, core_1.normalize)(`/test/unit/${core_1.strings.dasherize(options.name)}/${core_1.strings.dasherize(options.name)}.controller.spec.ts`);
+        const isFileExists = tree.exists(filePath);
+        const isUnitExists = tree.exists(unitPath);
+        if (isFileExists || isUnitExists) {
+            if (isFileExists)
+                _context.logger.info(`Controller file already exists at: ${filePath}`);
+            if (isUnitExists)
+                _context.logger.info(`Unit test file already exists at: ${unitPath}`);
+            return;
+        }
+        return (0, schematics_1.chain)([createController(options), createUnitTest(options)]);
+    };
+}