vovk-cli 0.0.1-draft.3 → 0.0.1-draft.30

package/dist/init/createConfig.d.mts

@@ -1,10 +1,9 @@
 import type getLogger from '../utils/getLogger.mjs';
-import type { InitOptions } from '../index.mjs';
-export default function createConfig({ root, log, dryRun, options: { validationLibrary, validateOnClient }, }: {
+import type { InitOptions } from '../types.mjs';
+export default function createConfig({ root, log, options: { validationLibrary, validateOnClient, channel, dryRun }, }: {
     root: string;
     log: ReturnType<typeof getLogger>;
-    dryRun?: boolean;
-    options: Pick<InitOptions, 'validationLibrary' | 'validateOnClient'>;
+    options: Pick<InitOptions, 'validationLibrary' | 'validateOnClient' | 'channel' | 'dryRun'>;
 }): Promise<{
     configAbsolutePath: string;
 }>;

package/dist/init/createConfig.mjs

@@ -1,9 +1,9 @@
-import path from 'path';
-import fs from 'fs/promises';
-import getFileSystemEntryType, { FileSystemEntryType } from '../utils/getFileSystemEntryType.mjs';
+import path from 'node:path';
+import fs from 'node:fs/promises';
 import getTemplateFilesFromPackage from './getTemplateFilesFromPackage.mjs';
 import prettify from '../utils/prettify.mjs';
-export default async function createConfig({ root, log, dryRun, options: { validationLibrary, validateOnClient }, }) {
+import getFileSystemEntryType, { FileSystemEntryType } from '../utils/getFileSystemEntryType.mjs';
+export default async function createConfig({ root, log, options: { validationLibrary, validateOnClient, channel, dryRun }, }) {
     const config = {};
     const dotConfigPath = path.join(root, '.config');
     const dir = (await getFileSystemEntryType(dotConfigPath)) === FileSystemEntryType.DIRECTORY ? dotConfigPath : root;
@@ -22,7 +22,7 @@ export default async function createConfig({ root, log, dryRun, options: { valid
             config.validateOnClient = `${validationLibrary}/validateOnClient`;
         }
         try {
-            const validationTemplates = await getTemplateFilesFromPackage(validationLibrary);
+            const validationTemplates = await getTemplateFilesFromPackage(validationLibrary, channel);
             Object.assign(templates, validationTemplates);
         }
         catch (error) {

package/dist/init/getTemplateFilesFromPackage.d.mts

@@ -1,6 +1,7 @@
+import { InitOptions } from '../types.mjs';
 /**
  * Retrieves a list of files in the 'templates' folder of an NPM package.
  * @param packageName - The name of the NPM package.
  * @returns A promise that resolves to an array of file paths.
  */
-export default function getTemplatesFiles(packageName: string, channel?: string): Promise<Record<string, string>>;
+export default function getTemplateFilesFromPackage(packageName: string, channel?: InitOptions['channel']): Promise<Record<string, string>>;

package/dist/init/getTemplateFilesFromPackage.mjs

@@ -1,14 +1,13 @@
-import { createGunzip } from 'zlib';
+import { Readable } from 'node:stream';
+import { createGunzip } from 'node:zlib';
 import tar from 'tar-stream';
-import { Readable } from 'stream';
 import getNPMPackageMetadata from '../utils/getNPMPackageMetadata.mjs';
 /**
  * Retrieves a list of files in the 'templates' folder of an NPM package.
  * @param packageName - The name of the NPM package.
  * @returns A promise that resolves to an array of file paths.
  */
-export default async function getTemplatesFiles(packageName, channel = 'beta' // TODO change to latest
-) {
+export default async function getTemplateFilesFromPackage(packageName, channel = 'latest') {
     const metadata = await getNPMPackageMetadata(packageName);
     const latestVersion = metadata['dist-tags'][channel];
     const tarballUrl = metadata.versions[latestVersion].dist.tarball;

package/dist/init/index.d.mts

@@ -1,5 +1,4 @@
-#!/usr/bin/env node
-import type { InitOptions } from '../index.mjs';
+import type { InitOptions } from '../types.mjs';
 import getLogger from '../utils/getLogger.mjs';
 export declare class Init {
     #private;

package/dist/init/index.mjs

@@ -1,74 +1,18 @@
-#!/usr/bin/env node
-/*
-npx vovk-cli init
-- Check if the project is already initialized
-  - Do you want to reinitialize the project?
-    - Yes
-    - No (exit)
-- Check for package.json, if not found, show error and exit
-- Check for tsconfig.json, if not found, show error and exit
-- Check Next.js installed
-- Choose validation library: add to the installation list
-    - vovk-zod
-        - Further installation notes: install zod
-    - vovk-yup
-        - Further installation notes: install yup
-    - vovk-dto
-        - Further installation notes: install class-validator and class-transformer
-    - None
-- If validation library is not None,
-    - Do you want to enable client validation?
-        - Yes
-            - Add client validation to the config
-        - No
-- Do you want to update NPM scripts?
-    - Yes
-        - Update NPM scripts
-    - No
-- Do you want to use explicit concurrently?
-    - Yes (recommended)
-        - Add concurrently to the installation list
-    - No
-- if experimentalDecorators is not found in tsconfig.json,
-    - Do you want to add experimentalDecorators to tsconfig.json?
-        - Yes
-            - Add experimentalDecorators to tsconfig.json
-        - No
-- Do you want to create route file with example service and controller? (NO NEED)
-    - Yes
-        - Create route file with example controller
-    - No, I will create it myself
-- End
-    - If there are any packages to install, install them
-    - Show installation notes
-    - If there are any files to create, create
-    - If there are any config files to update, update
-    - If example route file is NOT created, show example route file and controller
-    - Show how to run the project
-        - If npm scripts are updated
-            - npm run dev
-        - If npm scripts are NOT updated
-            - If concurrently is installed
-                - concurrently "vovk dev" "next dev"
-            - If concurrently is NOT installed
-                - vovk dev --next-dev
-        - Open http://localhost:3000/api/hello-world
-        - Show how to make a request to the example route
-    - Show success message
-*/
 import { confirm, select } from '@inquirer/prompts';
-import path from 'path';
-import fs from 'fs/promises';
+import path from 'node:path';
+import fs from 'node:fs/promises';
 import getConfigPaths from '../getProjectInfo/getConfigAbsolutePaths.mjs';
 import chalk from 'chalk';
 import getFileSystemEntryType from '../utils/getFileSystemEntryType.mjs';
-import installDependencies from './installDependencies.mjs';
+import installDependencies, { getPackageManager } from './installDependencies.mjs';
 import getLogger from '../utils/getLogger.mjs';
 import createConfig from './createConfig.mjs';
 import updateNPMScripts from './updateNPMScripts.mjs';
 import checkTSConfigForExperimentalDecorators from './checkTSConfigForExperimentalDecorators.mjs';
 import updateTypeScriptConfig from './updateTypeScriptConfig.mjs';
 import updateDependenciesWithoutInstalling from './updateDependenciesWithoutInstalling.mjs';
+import logUpdateDependenciesError from './logUpdateDependenciesError.mjs';
+import chalkHighlightThing from '../utils/chalkHighlightThing.mjs';
 export class Init {
     root;
     log;
@@ -113,6 +57,7 @@ export class Init {
             }
         }
         if (!dryRun) {
+            let depsUpdated = false;
             try {
                 await updateDependenciesWithoutInstalling({
                     log,
@@ -121,27 +66,34 @@ export class Init {
                     devDependencyNames: devDependencies,
                     channel: channel ?? 'latest',
                 });
-                log.info('Updated dependencies and devDependencies in package.json');
+                depsUpdated = true;
             }
-            catch (error) {
-                log.error(`Failed to update dependencies: ${error.message}. Please `);
+            catch (e) {
+                const error = e;
+                logUpdateDependenciesError({ log, error, useNpm, useYarn, usePnpm, useBun, dependencies, devDependencies });
             }
-            if (!skipInstall) {
-                try {
-                    await installDependencies({
-                        log,
-                        cwd: root,
-                        options: {
-                            useNpm,
-                            useYarn,
-                            usePnpm,
-                            useBun,
-                        },
-                    });
-                    log.info('Dependencies installed successfully');
+            if (depsUpdated) {
+                const packageManager = getPackageManager({ useNpm, useYarn, usePnpm, useBun });
+                if (skipInstall) {
+                    log.info(`Installation skipped. Please, install them manually with ${chalkHighlightThing(packageManager + ' install')}`);
                 }
-                catch (error) {
-                    log.error(`Failed to install dependencies: ${error.message}`);
+                else {
+                    try {
+                        await installDependencies({
+                            log,
+                            cwd: root,
+                            options: {
+                                useNpm,
+                                useYarn,
+                                usePnpm,
+                                useBun,
+                            },
+                        });
+                        log.info('Dependencies installed successfully');
+                    }
+                    catch (error) {
+                        log.warn(`Failed to install dependencies: ${error.message}. Please, install them manually with ${chalkHighlightThing(packageManager + ' install')}`);
+                    }
                 }
             }
         }
@@ -149,8 +101,7 @@ export class Init {
             const { configAbsolutePath } = await createConfig({
                 root,
                 log,
-                options: { validationLibrary, validateOnClient },
-                dryRun,
+                options: { validationLibrary, validateOnClient, channel, dryRun },
             });
             log.info('Config created successfully at ' + configAbsolutePath);
         }
@@ -228,23 +179,23 @@ export class Init {
         updateScripts =
             updateScripts ??
                 (await select({
-                    message: 'Do you want to update package.json by adding "generate" and "dev" scripts?',
+                    message: 'Do you want to update package.json by adding "generate" and "dev" NPM scripts?',
                     default: 'implicit',
                     choices: [
                         {
                             name: 'Yes, use "concurrently" implicitly',
-                            description: `The "dev" script will use "concurrently" API internally in order to run "next dev" and "vovk dev" together and automatically look for an available port ${chalk.whiteBright.bold(`"vovk dev --next-dev"`)}`,
                             value: 'implicit',
+                            description: `The "dev" script will use "concurrently" API to run "next dev" and "vovk dev" commands together and automatically find an available port ${chalk.whiteBright.bold(`"vovk dev --next-dev"`)}`,
                         },
                         {
                             name: 'Yes, use "concurrently" explicitly',
                             value: 'explicit',
-                            description: `The "dev" script will use pre-defined PORT variable and run "next dev" and "vovk dev" as "concurrently" CLI arguments ${chalk.whiteBright.bold(`"PORT=3000 concurrently 'vovk dev' 'next dev' --kill-others"`)}`,
+                            description: `The "dev" script will use pre-defined PORT variable and run "next dev" and "vovk dev" as "concurrently" CLI arguments ${chalk.whiteBright.bold(`"PORT=3000 concurrently 'next dev' 'vovk dev' --kill-others"`)}`,
                         },
                         {
                             name: 'No',
                             value: undefined,
-                            description: 'Add the scripts manually',
+                            description: 'Add the NPM scripts manually',
                         },
                     ],
                 }));

package/dist/init/installDependencies.d.mts

@@ -1,7 +1,10 @@
-import { InitOptions } from '../index.mjs';
 import getLogger from '../utils/getLogger.mjs';
+import type { InitOptions } from '../types.mjs';
+type PackageManager = 'npm' | 'yarn' | 'pnpm' | 'bun';
+export declare function getPackageManager(options: Pick<InitOptions, 'useNpm' | 'useYarn' | 'usePnpm' | 'useBun'>): PackageManager;
 export default function installDependencies({ log, cwd, options, }: {
     log: ReturnType<typeof getLogger>;
     cwd: string;
     options: Pick<InitOptions, 'useNpm' | 'useYarn' | 'usePnpm' | 'useBun'>;
 }): Promise<void>;
+export {};

package/dist/init/installDependencies.mjs

@@ -1,5 +1,5 @@
-import { spawn } from 'child_process';
-function getPackageManager(options) {
+import { spawn } from 'node:child_process';
+export function getPackageManager(options) {
     if (options.useNpm)
         return 'npm';
     if (options.useYarn)

package/dist/init/logUpdateDependenciesError.d.mts

@@ -0,0 +1,11 @@
+import type getLogger from '../utils/getLogger.mjs';
+export default function logUpdateDependenciesError({ useNpm, useYarn, usePnpm, useBun, log, dependencies, devDependencies, error, }: {
+    useNpm?: boolean;
+    useYarn?: boolean;
+    usePnpm?: boolean;
+    useBun?: boolean;
+    log: ReturnType<typeof getLogger>;
+    dependencies: string[];
+    devDependencies: string[];
+    error: Error;
+}): void;

package/dist/init/logUpdateDependenciesError.mjs

@@ -0,0 +1,45 @@
+import chalkHighlightThing from '../utils/chalkHighlightThing.mjs';
+import { getPackageManager } from './installDependencies.mjs';
+export default function logUpdateDependenciesError({ useNpm, useYarn, usePnpm, useBun, log, dependencies, devDependencies, error, }) {
+    const packageManager = getPackageManager({ useNpm, useYarn, usePnpm, useBun });
+    const installCommands = [];
+    if (dependencies.length > 0) {
+        let depInstallCmd = '';
+        switch (packageManager) {
+            case 'npm':
+                depInstallCmd = `npm install ${dependencies.join(' ')}`;
+                break;
+            case 'yarn':
+                depInstallCmd = `yarn add ${dependencies.join(' ')}`;
+                break;
+            case 'pnpm':
+                depInstallCmd = `pnpm add ${dependencies.join(' ')}`;
+                break;
+            case 'bun':
+                depInstallCmd = `bun add ${dependencies.join(' ')}`;
+                break;
+        }
+        installCommands.push(depInstallCmd);
+    }
+    if (devDependencies.length > 0) {
+        let devDepInstallCmd = '';
+        switch (packageManager) {
+            case 'npm':
+                devDepInstallCmd = `npm install -D ${devDependencies.join(' ')}`;
+                break;
+            case 'yarn':
+                devDepInstallCmd = `yarn add --dev ${devDependencies.join(' ')}`;
+                break;
+            case 'pnpm':
+                devDepInstallCmd = `pnpm add -D ${devDependencies.join(' ')}`;
+                break;
+            case 'bun':
+                devDepInstallCmd = `bun add -d ${devDependencies.join(' ')}`;
+                break;
+        }
+        installCommands.push(devDepInstallCmd);
+    }
+    const installCmd = installCommands.join(' && ');
+    // Log the error with the appropriate manual installation instructions
+    log.warn(`Failed to update dependencies: ${error.message}. Please, install them manually with ${chalkHighlightThing(installCmd)}`);
+}

package/dist/init/updateDependenciesWithoutInstalling.d.mts

@@ -1,8 +1,9 @@
-import getLogger from '../utils/getLogger.mjs';
+import type getLogger from '../utils/getLogger.mjs';
+import { InitOptions } from '../types.mjs';
 export default function updateDependenciesWithoutInstalling({ log, dir, dependencyNames, devDependencyNames, channel, }: {
     log: ReturnType<typeof getLogger>;
     dir: string;
     dependencyNames: string[];
     devDependencyNames: string[];
-    channel: 'latest' | 'beta' | 'dev';
+    channel: InitOptions['channel'];
 }): Promise<void>;

package/dist/init/updateDependenciesWithoutInstalling.mjs

@@ -1,13 +1,12 @@
-import fs from 'fs/promises';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import chalk from 'chalk';
 import getNPMPackageMetadata from '../utils/getNPMPackageMetadata.mjs';
-import path from 'path';
 async function updateDeps({ packageJson, packageNames, channel, key, }) {
     return Promise.all(packageNames.map(async (packageName) => {
-        if (packageJson[key]?.[packageName])
-            return; // Skip if already present
         const metadata = await getNPMPackageMetadata(packageName);
         const isVovk = packageName.startsWith('vovk');
-        const latestVersion = metadata['dist-tags'][isVovk ? channel : 'latest'];
+        const latestVersion = metadata['dist-tags'][isVovk ? (channel ?? 'latest') : 'latest'];
         if (!packageJson[key]) {
             packageJson[key] = {};
         }
@@ -18,8 +17,14 @@ export default async function updateDependenciesWithoutInstalling({ log, dir, de
     const packageJsonPath = path.join(dir, 'package.json');
     const packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf-8'));
     await updateDeps({ packageJson, packageNames: dependencyNames, channel, key: 'dependencies' });
-    log.debug('Updated dependencies in package.json');
     await updateDeps({ packageJson, packageNames: devDependencyNames, channel, key: 'devDependencies' });
-    log.debug('Updated devDependencies in package.json');
     await fs.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2));
+    log.info('Added dependencies to package.json:');
+    for (const dependency of dependencyNames) {
+        log.raw.info(` - ${chalk.cyan(dependency)}`);
+    }
+    log.info('Added devDependencies to package.json:');
+    for (const dependency of devDependencyNames) {
+        log.raw.info(` - ${chalk.cyan(dependency)}`);
+    }
 }

package/dist/init/updateNPMScripts.mjs

@@ -3,9 +3,10 @@ export default async function updateNPMScripts(root, updateScriptsMode) {
     const pkgJson = await NPMCliPackageJson.load(root);
     pkgJson.update({
         scripts: {
+            ...pkgJson.content.scripts,
             generate: 'vovk generate',
             dev: updateScriptsMode === 'explicit'
-                ? "PORT=3000 concurrently 'vovk dev' 'next dev' --kill-others"
+                ? "PORT=3000 concurrently 'next dev' 'vovk dev' --kill-others"
                 : 'vovk dev --next-dev',
         },
     });

package/dist/init/updateTypeScriptConfig.mjs

@@ -1,5 +1,5 @@
-import path from 'path';
-import fs from 'fs/promises';
+import path from 'node:path';
+import fs from 'node:fs/promises';
 import * as jsonc from 'jsonc-parser';
 import prettify from '../utils/prettify.mjs';
 export default async function updateTypeScriptConfig(root) {

package/dist/initProgram.d.mts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export default function initProgram(program: Command): Command;

package/dist/initProgram.mjs

@@ -0,0 +1,21 @@
+import { Init } from './init/index.mjs';
+// reused at vovk-init
+export default function initProgram(program) {
+    return program
+        .argument('[prefix]', 'Directory to initialize project in', '.')
+        .description('Initialize Vovk project')
+        .option('-y, --yes', 'Skip all prompts and use default values')
+        .option('--log-level <level>', 'Set log level', 'info')
+        .option('--use-npm', 'Use npm as package manager')
+        .option('--use-yarn', 'Use yarn as package manager')
+        .option('--use-pnpm', 'Use pnpm as package manager')
+        .option('--use-bun', 'Use bun as package manager')
+        .option('--skip-install', 'Skip installing dependencies')
+        .option('--update-ts-config', 'Update tsconfig.json')
+        .option('--update-scripts <mode>', 'Update package.json scripts (implicit or explicit)')
+        .option('--validation-library <library>', 'Validation library to use ("vovk-zod", "vovk-yup", "vovk-dto" or another). Set to "none" to skip validation')
+        .option('--validate-on-client', 'Validate on client')
+        .option('--channel <channel>', 'Channel to use for fetching packages', 'latest')
+        .option('--dry-run', 'Do not write files to disk')
+        .action((prefix = '.', options) => new Init().main(prefix, options));
+}

package/dist/locateSegments.mjs

@@ -1,5 +1,5 @@
-import { promises as fs } from 'fs';
-import * as path from 'path';
+import fs from 'node:fs/promises';
+import path from 'node:path';
 import getFileSystemEntryType from './utils/getFileSystemEntryType.mjs';
 export default async function locateSegments(dir, rootDir = dir) {
     let results = [];

package/dist/new/addClassToSegmentCode.mjs

@@ -1,6 +1,10 @@
-import { Project, SyntaxKind } from 'ts-morph';
+import { Project, QuoteKind, SyntaxKind } from 'ts-morph';
 export default function addClassToSegmentCode(segmentSourceCode, { sourceName, compiledName, type, importPath, }) {
-    const project = new Project();
+    const project = new Project({
+        manipulationSettings: {
+            quoteKind: QuoteKind.Single,
+        },
+    });
     const sourceFile = project.createSourceFile('route.ts', segmentSourceCode, { overwrite: true });
     // Add the import if it doesn't exist
     let importDeclaration = sourceFile.getImportDeclaration((imp) => {

package/dist/new/index.d.mts

@@ -1,2 +1,2 @@
-import type { NewOptions } from '../index.mjs';
-export default function newComponents(components: string[], options: NewOptions): Promise<void>;
+import type { NewOptions } from '../types.mjs';
+export default function newComponents(components: string[], { dryRun, dir, templates, overwrite, noSegmentUpdate }: NewOptions): Promise<void>;

package/dist/new/index.mjs

@@ -1,7 +1,8 @@
 import newModule from './newModule.mjs';
 import newSegment from './newSegment.mjs';
-export default async function newComponents(components, options) {
+export default async function newComponents(components, { dryRun, dir, templates, overwrite, noSegmentUpdate }) {
     if (components[0] === 'segment' || components[0] === 'segments') {
+        // vovk new segment [segmentName]
         let segmentNames = components
             .slice(1)
             .map((segmentName) => (segmentName === '""' || segmentName === "''" ? '' : segmentName));
@@ -9,10 +10,11 @@ export default async function newComponents(components, options) {
             segmentNames = [''];
         }
         for (const segmentName of segmentNames) {
-            await newSegment({ segmentName, dryRun: options.dryRun });
+            await newSegment({ segmentName, overwrite, dryRun });
         }
     }
     else {
+        // vovk new [what...] [moduleNameWithOptionalSegment]
         if (components.length < 2) {
             throw new Error('Invalid command invocation. Please provide at least two arguments.');
         }
@@ -21,6 +23,14 @@ export default async function newComponents(components, options) {
         if (!moduleNameWithOptionalSegment) {
             throw new Error('A module name with an optional segment cannot be empty');
         }
-        await newModule({ what, moduleNameWithOptionalSegment, dryRun: options.dryRun });
+        await newModule({
+            what,
+            moduleNameWithOptionalSegment,
+            dir,
+            templates,
+            overwrite,
+            noSegmentUpdate,
+            dryRun,
+        });
     }
 }

package/dist/new/newModule.d.mts

@@ -1,5 +1,9 @@
-export default function newModule({ what, moduleNameWithOptionalSegment, dryRun, }: {
+export default function newModule({ what, moduleNameWithOptionalSegment, dryRun, dir: dirFlag, templates: templatesFlag, noSegmentUpdate, overwrite, }: {
     what: string[];
     moduleNameWithOptionalSegment: string;
-    dryRun: boolean;
+    dryRun?: boolean;
+    dir?: string;
+    templates?: string[];
+    noSegmentUpdate?: boolean;
+    overwrite?: boolean;
 }): Promise<void>;

package/dist/new/newModule.mjs

@@ -1,11 +1,11 @@
-import path from 'path';
-import fs from 'fs/promises';
-import getProjectInfo from '../getProjectInfo/index.mjs';
+import path from 'node:path';
+import fs from 'node:fs/promises';
 import render from './render.mjs';
+import addClassToSegmentCode from './addClassToSegmentCode.mjs';
+import getProjectInfo from '../getProjectInfo/index.mjs';
+import locateSegments from '../locateSegments.mjs';
 import chalkHighlightThing from '../utils/chalkHighlightThing.mjs';
 import formatLoggedSegmentName from '../utils/formatLoggedSegmentName.mjs';
-import locateSegments from '../locateSegments.mjs';
-import addClassToSegmentCode from './addClassToSegmentCode.mjs';
 import getFileSystemEntryType from '../utils/getFileSystemEntryType.mjs';
 import prettify from '../utils/prettify.mjs';
 function splitByLast(str, delimiter = '/') {
@@ -18,9 +18,9 @@ function splitByLast(str, delimiter = '/') {
     const after = str.substring(index + delimiter.length);
     return [before, after];
 }
-export default async function newModule({ what, moduleNameWithOptionalSegment, dryRun, }) {
+export default async function newModule({ what, moduleNameWithOptionalSegment, dryRun, dir: dirFlag, templates: templatesFlag, noSegmentUpdate, overwrite, }) {
     const { config, log, apiDir, cwd } = await getProjectInfo();
-    const templates = config.templates;
+    let templates = config.templates;
     const [segmentName, moduleName] = splitByLast(moduleNameWithOptionalSegment);
     // replace c by controller, s by service, w by worker, everything else keeps the same
     what = what.map((s) => {
@@ -35,16 +35,24 @@ export default async function newModule({ what, moduleNameWithOptionalSegment, d
                 return s;
         }
     });
-    // check if template exists
+    if (templatesFlag) {
+        if (templatesFlag.length > what.length) {
+            throw new Error('Too many templates provided');
+        }
+        templates = templatesFlag.reduce((acc, templatePath, index) => ({
+            ...acc,
+            [what[index]]: templatePath,
+        }), templates);
+    }
     for (const type of what) {
         if (!templates[type]) {
-            throw new Error(`Template for ${type} not found in config`);
+            throw new Error(`Template for "${type}" not found`);
         }
     }
     const segments = await locateSegments(apiDir);
     const segment = segments.find((s) => s.segmentName === segmentName);
     if (!segment) {
-        throw new Error(`Segment ${segmentName} not found`);
+        throw new Error(`Unable to create module. Segment "${segmentName}" not found. Run "vovk new segment ${segmentName}" to create it`);
     }
     for (const type of what) {
         const templatePath = templates[type];
@@ -52,39 +60,55 @@ export default async function newModule({ what, moduleNameWithOptionalSegment, d
             ? path.resolve(cwd, templatePath)
             : path.resolve(cwd, './node_modules', templatePath);
         const templateCode = await fs.readFile(templateAbsolutePath, 'utf-8');
-        const { filePath, sourceName, compiledName, code } = await render(templateCode, {
+        const { dir: renderedDir, fileName, sourceName, compiledName, code, } = await render(templateCode, {
+            cwd,
             config,
             withService: what.includes('service'),
             segmentName,
             moduleName,
         });
-        const absoluteModulePath = path.join(cwd, config.modulesDir, filePath);
-        const dirName = path.dirname(absoluteModulePath);
+        const dir = dirFlag || renderedDir;
+        if (!dir) {
+            throw new Error(`The template for "${type}" does not provide a dir`);
+        }
+        if (!fileName) {
+            throw new Error(`The template for "${type}" does not provide a fileName`);
+        }
+        const absoluteModuleDir = path.join(cwd, dir);
+        const absoluteModulePath = path.join(absoluteModuleDir, fileName);
         const prettiedCode = await prettify(code, absoluteModulePath);
         if (!dryRun) {
-            if (await getFileSystemEntryType(absoluteModulePath)) {
+            if (!overwrite && (await getFileSystemEntryType(absoluteModulePath))) {
                 log.warn(`File ${chalkHighlightThing(absoluteModulePath)} already exists, skipping this "${type}"`);
             }
             else {
-                await fs.mkdir(dirName, { recursive: true });
+                await fs.mkdir(absoluteModuleDir, { recursive: true });
                 await fs.writeFile(absoluteModulePath, prettiedCode);
+                log.info(`Created ${chalkHighlightThing(fileName)} using ${chalkHighlightThing(`"${type}"`)} template for ${formatLoggedSegmentName(segmentName)}`);
             }
         }
         if (type === 'controller' || type === 'worker') {
+            if (!sourceName) {
+                throw new Error(`The template for "${type}" does not provide a sourceName`);
+            }
+            if (!compiledName) {
+                throw new Error('The template for "${type}" does not provide a compiledName');
+            }
             const { routeFilePath } = segment;
             const segmentSourceCode = await fs.readFile(routeFilePath, 'utf-8');
-            const importPath = path.relative(dirName, absoluteModulePath).replace(/\.(ts|tsx)$/, '');
-            const newSegmentCode = addClassToSegmentCode(segmentSourceCode, {
-                sourceName,
-                compiledName,
-                type,
-                importPath,
-            });
-            if (!dryRun) {
-                await fs.writeFile(routeFilePath, newSegmentCode);
+            const importPath = path.relative(path.dirname(routeFilePath), absoluteModulePath).replace(/\.(ts|tsx)$/, '');
+            if (!noSegmentUpdate) {
+                const newSegmentCode = await prettify(addClassToSegmentCode(segmentSourceCode, {
+                    sourceName,
+                    compiledName,
+                    type,
+                    importPath,
+                }), routeFilePath);
+                if (!dryRun) {
+                    await fs.writeFile(routeFilePath, newSegmentCode);
+                }
             }
-            log.info(`Added ${chalkHighlightThing(sourceName)} ${type} to ${formatLoggedSegmentName(segmentName)} as ${chalkHighlightThing(compiledName)}`);
+            log.info(`Added ${chalkHighlightThing(sourceName)} ${type} as ${chalkHighlightThing(compiledName)} to ${formatLoggedSegmentName(segmentName)}`);
         }
-        log.info(`Created ${chalkHighlightThing(sourceName)} with ${chalkHighlightThing(type)} template for ${formatLoggedSegmentName(segmentName)}`);
     }
 }