vovk-cli 0.0.1-draft.1 → 0.0.1-draft.10

package/README.md

@@ -1 +1 @@
-Description is coming soon.
+Description is coming soon.

package/dist/getProjectInfo/getRelativeSrcRoot.mjs

@@ -1,11 +1,11 @@
 import path from 'path';
-import directoryExists from './directoryExists.mjs';
+import getFileSystemEntryType, { FileSystemEntryType } from '../utils/getFileSystemEntryType.mjs';
 export default async function getRelativeSrcRoot({ cwd }) {
     // Next.js Docs: src/app or src/pages will be ignored if app or pages are present in the root directory.
-    if (await directoryExists(path.join(cwd, 'app'))) {
+    if ((await getFileSystemEntryType(path.join(cwd, 'app'))) === FileSystemEntryType.DIRECTORY) {
         return '.';
     }
-    else if (await directoryExists(path.join(cwd, 'src/app'))) {
+    else if ((await getFileSystemEntryType(path.join(cwd, 'src/app'))) === FileSystemEntryType.DIRECTORY) {
         return './src';
     }
     throw new Error(`${cwd} Could not find app router directory. Check Next.js docs for more info.`);

package/dist/getProjectInfo/getUserConfig.mjs

@@ -11,7 +11,7 @@ async function getUserConfig({ cwd, }) {
     try {
         userConfig = await importUncachedModule(configPath);
     }
-    catch (e) {
+    catch {
         try {
             const cacheBuster = Date.now();
             ({ default: userConfig } = (await import(`${configPath}?cache=${cacheBuster}`)));

package/dist/index.d.mts

@@ -20,7 +20,11 @@ export interface InitOptions {
     channel?: 'latest' | 'beta' | 'dev';
 }
 export interface NewOptions {
-    dryRun: boolean;
+    dryRun?: boolean;
+    template?: string;
+    dir?: string;
+    overwrite?: boolean;
+    noSegmentUpdate?: boolean;
 }
 declare const program: Command;
 export declare function initProgram(p: typeof program, command: string): Command;

package/dist/index.mjs

@@ -25,9 +25,7 @@ program
     const PORT = !options.nextDev
         ? process.env.PORT
         : process.env.PORT ||
-            (await getAvailablePort(3000, portAttempts, 0, (failedPort, tryingPort) => 
-            // eslint-disable-next-line no-console
-            console.warn(`🐺 Next.js Port ${failedPort} is in use, trying ${tryingPort} instead.`)).catch(() => {
+            (await getAvailablePort(3000, portAttempts, 0, (failedPort, tryingPort) => console.warn(`🐺 Next.js Port ${failedPort} is in use, trying ${tryingPort} instead.`)).catch(() => {
                 throw new Error(`🐺 ❌ Failed to find available Next port after ${portAttempts} attempts`);
             }));
     if (!PORT) {
@@ -88,8 +86,8 @@ export function initProgram(p, command) {
         .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('--dry-run', 'Do not write files to disk')
         .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));
 }
 initProgram(program, 'init ');
@@ -97,6 +95,10 @@ program
     .command('new [components...]')
     .alias('n')
     .description('Create new components. "vovk new [...components] [segmentName/]moduleName" to create a new module or "vovk new segment [segmentName]" to create a new segment')
+    .option('-O, --overwrite', 'Overwrite existing files')
+    .option('--template <template>', 'Override config template')
+    .option('--dir <dirname>', 'Override dirName in template file. Relative to the root of the project')
+    .option('--no-segment-update', 'Do not update segment files when creating a new module')
     .option('--dry-run', 'Do not write files to disk')
     .action((components, options) => newComponents(components, options));
 program

package/dist/init/index.mjs

@@ -62,13 +62,15 @@ import fs from '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 +115,7 @@ export class Init {
             }
         }
         if (!dryRun) {
+            let depsUpdated = false;
             try {
                 await updateDependenciesWithoutInstalling({
                     log,
@@ -121,27 +124,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')}`);
+                    }
                 }
             }
         }

package/dist/init/installDependencies.d.mts

@@ -1,7 +1,10 @@
 import { InitOptions } from '../index.mjs';
 import getLogger from '../utils/getLogger.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) {
+export function getPackageManager(options) {
     if (options.useNpm)
         return 'npm';
     if (options.useYarn)

package/dist/init/logUpdateDependenciesError.d.mts

@@ -0,0 +1,11 @@
+import 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.mjs

@@ -1,6 +1,7 @@
 import fs from 'fs/promises';
 import getNPMPackageMetadata from '../utils/getNPMPackageMetadata.mjs';
 import path from 'path';
+import chalk from 'chalk';
 async function updateDeps({ packageJson, packageNames, channel, key, }) {
     return Promise.all(packageNames.map(async (packageName) => {
         if (packageJson[key]?.[packageName])
@@ -18,8 +19,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.log(` - ${chalk.cyan(dependency)}`);
+    }
+    log.info('Added devDependencies to package.json:');
+    for (const dependency of devDependencyNames) {
+        log.raw.log(` - ${chalk.cyan(dependency)}`);
+    }
 }

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>;
+export default function newComponents(components: string[], { dryRun, dir, template, 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, template, 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,
+            template,
+            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: dirNameFlag, template: templateFlag, noSegmentUpdate, overwrite, }: {
     what: string[];
     moduleNameWithOptionalSegment: string;
-    dryRun: boolean;
+    dryRun?: boolean;
+    dir?: string;
+    template?: string;
+    noSegmentUpdate?: boolean;
+    overwrite?: boolean;
 }): Promise<void>;

package/dist/new/newModule.mjs

@@ -18,7 +18,7 @@ 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: dirNameFlag, template: templateFlag, noSegmentUpdate, overwrite, }) {
     const { config, log, apiDir, cwd } = await getProjectInfo();
     const templates = config.templates;
     const [segmentName, moduleName] = splitByLast(moduleNameWithOptionalSegment);
@@ -35,10 +35,19 @@ export default async function newModule({ what, moduleNameWithOptionalSegment, d
                 return s;
         }
     });
-    // check if template exists
-    for (const type of what) {
-        if (!templates[type]) {
-            throw new Error(`Template for ${type} not found in config`);
+    console.log('moduleNameWithOptionalSegment', moduleNameWithOptionalSegment);
+    console.log('what', what);
+    if (templateFlag) {
+        if (what.length > 1) {
+            throw new Error('Cannot use --template flag with multiple types');
+        }
+    }
+    else {
+        // check if template exists
+        for (const type of what) {
+            if (!templates[type]) {
+                throw new Error(`Template for ${type} not found in config`);
+            }
         }
     }
     const segments = await locateSegments(apiDir);
@@ -47,44 +56,53 @@ export default async function newModule({ what, moduleNameWithOptionalSegment, d
         throw new Error(`Segment ${segmentName} not found`);
     }
     for (const type of what) {
-        const templatePath = templates[type];
+        const templatePath = templateFlag ?? templates[type];
         const templateAbsolutePath = templatePath.startsWith('/') || templatePath.startsWith('.')
             ? 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 { dirName: renderedDirName, 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 absoluteModuleDir = path.join(cwd, dirNameFlag || renderedDirName);
+        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);
             }
         }
         if (type === 'controller' || type === 'worker') {
+            if (!sourceName) {
+                throw new Error('sourceName is required');
+            }
+            if (!compiledName) {
+                throw new Error('compiledName is required');
+            }
             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 = addClassToSegmentCode(segmentSourceCode, {
+                    sourceName,
+                    compiledName,
+                    type,
+                    importPath,
+                });
+                if (!dryRun) {
+                    await fs.writeFile(routeFilePath, newSegmentCode);
+                }
             }
             log.info(`Added ${chalkHighlightThing(sourceName)} ${type} to ${formatLoggedSegmentName(segmentName)} as ${chalkHighlightThing(compiledName)}`);
         }
-        log.info(`Created ${chalkHighlightThing(sourceName)} with ${chalkHighlightThing(type)} template for ${formatLoggedSegmentName(segmentName)}`);
+        log.info(`Created ${chalkHighlightThing(fileName)} using "${chalkHighlightThing(type)}" template for ${formatLoggedSegmentName(segmentName)}`);
     }
 }

package/dist/new/newSegment.d.mts

@@ -1,4 +1,5 @@
-export default function newSegment({ segmentName, dryRun }: {
+export default function newSegment({ segmentName, overwrite, dryRun, }: {
     segmentName: string;
-    dryRun: boolean;
+    overwrite?: boolean;
+    dryRun?: boolean;
 }): Promise<void>;

package/dist/new/newSegment.mjs

@@ -5,10 +5,10 @@ import getFileSystemEntryType from '../utils/getFileSystemEntryType.mjs';
 import chalkHighlightThing from '../utils/chalkHighlightThing.mjs';
 import formatLoggedSegmentName from '../utils/formatLoggedSegmentName.mjs';
 import prettify from '../utils/prettify.mjs';
-export default async function newSegment({ segmentName, dryRun }) {
+export default async function newSegment({ segmentName, overwrite, dryRun, }) {
     const { apiDir, cwd, log } = await getProjectInfo();
     const absoluteSegmentRoutePath = path.join(cwd, apiDir, segmentName, '[[...vovk]]/route.ts');
-    if (await getFileSystemEntryType(absoluteSegmentRoutePath)) {
+    if (!overwrite && (await getFileSystemEntryType(absoluteSegmentRoutePath))) {
         throw new Error(`Unable to create new segment. ${formatLoggedSegmentName(segmentName, { upperFirst: true })} already exists.`);
     }
     const code = await prettify(`import { initVovk } from 'vovk';
@@ -29,5 +29,5 @@ ${segmentName ? `  segmentName: '${segmentName}',\n` : ''}  emitSchema: true,
         await fs.mkdir(path.dirname(absoluteSegmentRoutePath), { recursive: true });
         await fs.writeFile(absoluteSegmentRoutePath, code);
     }
-    log.info(`${formatLoggedSegmentName(segmentName, { upperFirst: true })} created at ${absoluteSegmentRoutePath}. Run ${chalkHighlightThing(`vovk new controller ${segmentName}/someName`)} to create a controller or modify the segment file manually`);
+    log.info(`${formatLoggedSegmentName(segmentName, { upperFirst: true })} created at ${absoluteSegmentRoutePath}. Run ${chalkHighlightThing(`vovk new controller ${[segmentName, 'someName'].filter(Boolean).join('/')}`)} to create a controller.`);
 }

package/dist/new/render.d.mts

@@ -1,12 +1,8 @@
-import type { VovkConfig } from '../types.mjs';
+import type { VovkConfig, VovkModuleRenderResult } from '../types.mjs';
 export default function render(codeTemplate: string, { config, withService, segmentName, moduleName, }: {
+    cwd: string;
     config: VovkConfig;
     withService: boolean;
     segmentName: string;
     moduleName: string;
-}): Promise<{
-    filePath: string;
-    sourceName: string;
-    compiledName: string;
-    code: string;
-}>;
+}): Promise<VovkModuleRenderResult>;

package/dist/new/render.mjs

@@ -5,7 +5,7 @@ import pluralize from 'pluralize';
 import addCommonTerms from './addCommonTerms.mjs';
 addCommonTerms();
 export default async function render(codeTemplate, { config, withService, segmentName, moduleName, }) {
-    const getModulePath = (givenSegmentName, givenModuleName, fileName) => [givenSegmentName || config.rootSegmentModulesDirName, _.camelCase(givenModuleName), fileName]
+    const getModuleDirName = (givenSegmentName, givenModuleName) => [config.modulesDir, givenSegmentName || config.rootSegmentModulesDirName, _.camelCase(givenModuleName)]
         .filter(Boolean)
         .join('/');
     const templateVars = {
@@ -15,15 +15,22 @@ export default async function render(codeTemplate, { config, withService, segmen
         segmentName,
         moduleName,
         // utils
-        getModulePath,
+        getModuleDirName,
         // libraries
         _, // lodash
         pluralize,
     };
     // first, render the front matter because it can use ejs variables
     const parsed = matter((await ejs.render(codeTemplate, templateVars, { async: true })).trim());
-    const { filePath, sourceName, compiledName } = parsed.data;
-    const templateContent = parsed.content;
-    const code = await ejs.render(templateContent, templateVars, { async: true });
-    return { filePath, sourceName, compiledName, code };
+    const { dirName, fileName, sourceName, compiledName } = parsed.data;
+    const code = parsed.content;
+    // const templateContent = parsed.content; TODO
+    // const code = await ejs.render(templateContent, templateVars, { async: true });
+    return {
+        dirName,
+        fileName,
+        sourceName,
+        compiledName,
+        code,
+    };
 }

package/dist/postinstall.mjs

@@ -11,7 +11,9 @@ async function postinstall() {
     const js = path.join(vovk, 'client.js');
     const ts = path.join(vovk, 'client.d.ts');
     const index = path.join(vovk, 'index.ts');
-    if ((await getFileSystemEntryType(js)) || (await getFileSystemEntryType(ts)) || (await getFileSystemEntryType(index))) {
+    if ((await getFileSystemEntryType(js)) ||
+        (await getFileSystemEntryType(ts)) ||
+        (await getFileSystemEntryType(index))) {
         return;
     }
     await fs.mkdir(vovk, { recursive: true });

package/dist/types.d.mts

@@ -37,3 +37,10 @@ export type VovkConfig = {
         [key: string]: string | undefined;
     };
 };
+export type VovkModuleRenderResult = {
+    fileName: string;
+    dirName: string;
+    sourceName?: string;
+    compiledName?: string;
+    code: string;
+};

package/dist/utils/getAvailablePort.mjs

@@ -34,7 +34,7 @@ function getAvailablePort(startPort, maxAttempts, attempt, onWarning) {
                 getAvailablePort(startPort + 1, maxAttempts, attempt + 1, onWarning).then(resolve, reject);
             }
             else {
-                reject('No available ports found');
+                reject(new Error('No available ports found'));
             }
         });
     });

package/dist/watcher/ensureSchemaFiles.mjs

@@ -7,17 +7,29 @@ export default async function ensureSchemaFiles(projectInfo, schemaOutAbsolutePa
     const now = Date.now();
     let hasChanged = false;
     // Create index.js file
-    const indexContent = segmentNames
+    const indexContent = `// auto-generated
+${segmentNames
         .map((segmentName) => {
         return `module.exports['${segmentName}'] = require('./${segmentName || ROOT_SEGMENT_SCHEMA_NAME}.json');`;
     })
-        .join('\n');
-    const dTsContent = `import type { VovkSchema } from 'vovk';
-declare const segmentSchema: Record<string, VovkSchema>;
+        .join('\n')}`;
+    const dTsContent = `// auto-generated
+import type { VovkSchema } from 'vovk';
+declare const segmentSchema: {
+${segmentNames.map((segmentName) => `  '${segmentName}': VovkSchema;`).join('\n')}
+};
 export default segmentSchema;`;
+    const jsAbsolutePath = path.join(schemaOutAbsolutePath, 'index.js');
+    const dTsAbsolutePath = path.join(schemaOutAbsolutePath, 'index.d.ts');
+    const existingJs = await fs.readFile(jsAbsolutePath, 'utf-8').catch(() => null);
+    const existingDTs = await fs.readFile(dTsAbsolutePath, 'utf-8').catch(() => null);
     await fs.mkdir(schemaOutAbsolutePath, { recursive: true });
-    await fs.writeFile(path.join(schemaOutAbsolutePath, 'index.js'), indexContent);
-    await fs.writeFile(path.join(schemaOutAbsolutePath, 'index.d.ts'), dTsContent);
+    if (existingJs !== indexContent) {
+        await fs.writeFile(jsAbsolutePath, indexContent);
+    }
+    if (existingDTs !== dTsContent) {
+        await fs.writeFile(dTsAbsolutePath, dTsContent);
+    }
     // Create JSON files (if not exist) with name [segmentName].json (where segmentName can include /, which means the folder structure can be nested)
     await Promise.all(segmentNames.map(async (segmentName) => {
         const { isCreated } = await writeOneSchemaFile({

package/dist/watcher/index.mjs

@@ -51,7 +51,6 @@ export class VovkCLIWatcher {
                 void this.#requestSchema(getSegmentName(filePath));
             }
         })
-            // eslint-disable-next-line @typescript-eslint/no-misused-promises
             .on('addDir', async (dirPath) => {
             log.debug(`Directory ${dirPath} has been added to segments folder`);
             this.#segments = await locateSegments(apiDirAbsolutePath);
@@ -59,7 +58,6 @@ export class VovkCLIWatcher {
                 void this.#requestSchema(segmentName);
             }
         })
-            // eslint-disable-next-line @typescript-eslint/no-misused-promises
             .on('unlinkDir', async (dirPath) => {
             log.debug(`Directory ${dirPath} has been removed from segments folder`);
             this.#segments = await locateSegments(apiDirAbsolutePath);
@@ -81,7 +79,7 @@ export class VovkCLIWatcher {
             log.debug('Segments watcher is ready');
         })
             .on('error', (error) => {
-            log.error(`Error watching segments folder: ${error.message}`);
+            log.error(`Error watching segments folder: ${error?.message ?? 'Unknown error'}`);
         });
     };
     #watchModules = () => {
@@ -119,13 +117,14 @@ export class VovkCLIWatcher {
             log.debug('Modules watcher is ready');
         })
             .on('error', (error) => {
-            log.error(`Error watching modules folder: ${error.message}`);
+            log.error(`Error watching modules folder: ${error?.message ?? 'Unknown error'}`);
         });
     };
     #watchConfig = () => {
         const { log, cwd } = this.#projectInfo;
         log.debug(`Watching config files`);
         let isInitial = true;
+        let isReady = false;
         const handle = debounce(async () => {
             this.#projectInfo = await getProjectInfo();
             if (!isInitial) {
@@ -148,11 +147,14 @@ export class VovkCLIWatcher {
             .on('change', () => void handle())
             .on('unlink', () => void handle())
             .on('ready', () => {
+            if (isReady)
+                return;
+            // for some reason this watcher triggers ready event twice
             log.debug('Config files watcher is ready');
+            isReady = true;
         })
-            .on('error', (error) => {
-            log.error(`Error watching config files: ${error.message}`);
-        });
+            .on('error', (error) => log.error(`Error watching config files: ${error?.message ?? 'Unknown error'}`));
+        void handle();
     };
     #watch() {
         if (this.#isWatching)
@@ -274,13 +276,13 @@ export class VovkCLIWatcher {
         const schemaOutAbsolutePath = path.join(cwd, config.schemaOutDir);
         this.#segments = await locateSegments(apiDirAbsolutePath);
         await debouncedEnsureSchemaFiles(this.#projectInfo, schemaOutAbsolutePath, this.#segments.map((s) => s.segmentName));
-        // Request schema every segment in 3 seconds in order to update schema and start watching
+        // Request schema every segment in 5 seconds in order to update schema and start watching
         setTimeout(() => {
             for (const { segmentName } of this.#segments) {
                 void this.#requestSchema(segmentName);
             }
             this.#watch();
-        }, 3000);
+        }, 5000);
     }
 }
 const env = process.env;

package/dist/watcher/writeOneSchemaFile.mjs

@@ -1,10 +1,11 @@
 import path from 'path';
 import fs from 'fs/promises';
 import diffSchema from './diffSchema.mjs';
+import getFileSystemEntryType from '../utils/getFileSystemEntryType.mjs';
 export const ROOT_SEGMENT_SCHEMA_NAME = '_root';
 export default async function writeOneSchemaFile({ schemaOutAbsolutePath, schema, skipIfExists = false, }) {
     const segmentPath = path.join(schemaOutAbsolutePath, `${schema.segmentName || ROOT_SEGMENT_SCHEMA_NAME}.json`);
-    if (skipIfExists) {
+    if (skipIfExists && (await getFileSystemEntryType(segmentPath))) {
         try {
             await fs.stat(segmentPath);
             return { isCreated: false, diffResult: null };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vovk-cli",
-  "version": "0.0.1-draft.1",
+  "version": "0.0.1-draft.10",
   "bin": {
     "vovk": "./dist/index.mjs"
   },
@@ -11,8 +11,9 @@
   "scripts": {
     "build": "rm -rf dist tsconfig.build.tsbuildinfo && tsc -P tsconfig.build.json",
     "build-test": "rm -rf test_dist && tsc -P tsconfig.test.json",
-    "test": "npm run build && chmod +x ./dist/index.mjs && npm run build-test && node --test --test-only test_dist/test/**/*.mjs",
-    "test_": "npm run build && chmod +x ./dist/index.mjs && NODE_OPTIONS=\"--loader ts-node/esm\" TS_NODE_PROJECT=./tsconfig.test.json node --test --test-only test/**.mts",
+    "pre-test": "npm run build && chmod +x ./dist/index.mjs && npm run build-test",
+    "test-only": "npm run pre-test && node --test --test-only test_dist/test/**/*.mjs",
+    "test": "npm run pre-test && node --test --test-concurrency=1 test_dist/test/**/*.mjs",
     "ncu": "npm-check-updates -u",
     "npm-publish": "npm publish"
   },
@@ -33,10 +34,10 @@
   },
   "homepage": "https://vovk.dev",
   "peerDependencies": {
-    "vovk": "^3.0.0-draft.1"
+    "vovk": "^3.0.0-draft.12"
   },
   "dependencies": {
-    "@inquirer/prompts": "^7.0.0",
+    "@inquirer/prompts": "^7.0.1",
     "@npmcli/package-json": "^6.0.1",
     "chalk": "^5.3.0",
     "chokidar": "^4.0.1",

package/templates/controller.ejs

@@ -1,50 +1,51 @@
 <% var modulePascalName = _.upperFirst(_.camelCase(moduleName)); %>
 <% var modulePascalNamePlural = pluralize(modulePascalName); %>
-<% var ControllerName = modulePascalName + 'Controller'; %>
-<% var RPCName = modulePascalName + 'RPC'; %>
-<% var ServiceName = modulePascalName + 'Service'; %>
+<% var controllerName = modulePascalName + 'Controller'; %>
+<% var compiledName = modulePascalName + 'RPC'; %>
+<% var serviceName = modulePascalName + 'Service'; %>
 ---
-filePath: <%= getModulePath(segmentName, moduleName, ControllerName + '.ts') %> # Relative to "modules" dir
-sourceName: <%= ControllerName %> # Used to define import declaration in a segment route file for the given class
-compiledName: <%= RPCName %> # Used to define a compiled object name
+dirName: <%= getModuleDirName(segmentName, moduleName) %>
+fileName: <%= controllerName + '.ts' %>
+sourceName: <%= controllerName %>
+compiledName: <%= compiledName %>
 ---
 
-import { prefix, get, put, post, del<%= !config.validationLibrary ? ', type VovkRequest' : '' %> } from 'vovk';
+import { prefix, get, put, post, del, type VovkRequest } from 'vovk';
 <% if(withService) { %>
-import <%= ServiceName %> from './<%= ServiceName %>';
+import <%= serviceName %> from './<%= serviceName %>';
 <% } %>
 
 @prefix('<%= _.kebabCase(moduleName).toLowerCase() %>')
-export default class <%= ControllerName %> {
+export default class <%= controllerName %> {
     @get()
     static get<%= modulePascalNamePlural %> = async (req: VovkRequest<null, { q: string }>) => {
         const q = req.nextUrl.searchParams.get('q');
         <% if(withService) { %>
-        return <%= ServiceName %>.getMyThingsExample(q);
+        return <%= serviceName %>.get<%= modulePascalNamePlural %>(q);
         <% } else { %>
         return { q };
         <% } %>
     }
 
     @put(':id')
-    static update<%= modulePascalNamePlural %> = async (req: VovkRequest<{ foo: 'bar' | 'baz' }, { q: string }>, params: { id: string }) => {
+    static update<%= modulePascalName %> = async (req: VovkRequest<{ foo: 'bar' | 'baz' }, { q: string }>, params: { id: string }) => {
         const { id } = params;
         const body = await req.json();
         const q = req.nextUrl.searchParams.get('q');
         <% if(withService) { %>
-        return MyThingService.updateMyThingExample(id, q, body);
+        return MyThingService.update<%= modulePascalName %>(id, q, body);
         <% } else { %>
         return { id, body, q };
         <% } %>
     };
 
     @post()
-    static create<%= modulePascalNamePlural %> = () => {
+    static create<%= modulePascalName %> = () => {
         // ...
     };
 
     @del(':id')
-    static delete<%= modulePascalNamePlural %> = () => {
+    static delete<%= modulePascalName %> = () => {
         // ...
     };
 }

package/templates/service.ejs

@@ -1,7 +1,27 @@
-<% var ServiceName = _.upperFirst(_.camelCase(moduleName) + 'Service'; %>
-
+<% var modulePascalName = _.upperFirst(_.camelCase(moduleName)); %>
+<% var modulePascalNamePlural = pluralize(modulePascalName); %>
+<% var serviceName = modulePascalName + 'Service'; %>
+<% var controllerName = modulePascalName + 'Controller'; %>
 ---
-filePath: <%= getModulePath(segmentName, moduleName, ServiceName + '.ts') %> # Relative to "modules" dir
+dirName: <%= getModuleDirName(segmentName, moduleName) %>
+fileName: <%= serviceName + '.ts' %>
 ---
 
-// TO DO: Implement <%= ServiceName %>
+import type { VovkControllerBody, VovkControllerQuery } from 'vovk';
+import type <%= controllerName %> from './<%= controllerName %>';
+
+export default class <%= serviceName %> {
+  static get<%= modulePascalNamePlural %> = (q: VovkControllerQuery<typeof <%= controllerName %>.get<%= modulePascalNamePlural %>>['q']) => {
+    return [];
+  };
+
+  static update<%= modulePascalName %> = (
+    id: string,
+    q: VovkControllerQuery<typeof <%= controllerName %>.get<%= modulePascalName %>>['q'],
+    body: VovkControllerBody<typeof <%= controllerName %>.get<%= modulePascalName %>>
+  ) => {
+    return { id, q, body };
+  };
+
+  // ...
+}

package/templates/worker.ejs

@@ -1 +1,24 @@
-// TODO
+<% var modulePascalName = _.upperFirst(_.camelCase(moduleName)); %>
+<% var modulePascalNamePlural = pluralize(modulePascalName); %>
+<% var workerName = modulePascalName + 'Worker'; %>
+<% var compiledName = modulePascalName + 'WPC'; %>
+---
+dirName: <%= getModuleDirName(segmentName, moduleName) %>
+fileName: <%= controllerName + '.ts' %>
+sourceName: <%= workerName %>
+compiledName: <%= compiledName %>
+---
+import { worker } from 'vovk';
+
+@worker()
+export default class <%= workerName %> {
+    static heavyComputation = () => {
+       return 'Hello, World';
+    };
+
+    static heavyComputationYield = function* () {
+        for(const str of ['Hello', 'World'] as const) {
+            yield str;
+        }
+    };
+}

package/dist/getProjectInfo/directoryExists.d.mts

@@ -1 +0,0 @@
-export default function directoryExists(dir: string): Promise<boolean>;

package/dist/getProjectInfo/directoryExists.mjs

@@ -1,10 +0,0 @@
-import fs from 'fs/promises';
-export default async function directoryExists(dir) {
-    try {
-        const stats = await fs.stat(dir);
-        return stats.isDirectory();
-    }
-    catch (error) {
-        return false;
-    }
-}

package/templates_old/MyThingController.c.only.template.ts

@@ -1,32 +0,0 @@
-import { prefix, get, put, post, del, type VovkRequest } from 'vovk';
-
-@prefix('my-things')
-export default class MyThingController {
-  @get()
-  static getMyThingsExample = (req: VovkRequest<null, { q: string }>) => {
-    const q = req.nextUrl.searchParams.get('q');
-    return { q };
-  };
-
-  @put(':id')
-  static updateMyThingExample = async (
-    req: VovkRequest<{ foo: 'bar' | 'baz' }, { q: string }>,
-    params: { id: string }
-  ) => {
-    const { id } = params;
-    const body = await req.json();
-    const q = req.nextUrl.searchParams.get('q');
-
-    return { id, q, body };
-  };
-
-  @post()
-  static createMyThingExample = () => {
-    // ...
-  };
-
-  @del(':id')
-  static deleteMyThingExample = () => {
-    // ...
-  };
-}

package/templates_old/MyThingController.c.template.ts

@@ -1,34 +0,0 @@
-import { prefix, get, put, post, del, type VovkRequest } from 'vovk';
-import MyThingService from './MyThingService.s.template';
-
-@prefix('my-things')
-export default class MyThingController {
-  @get()
-  static getMyThingsExample(req: VovkRequest<null, { q: string }>) {
-    const q = req.nextUrl.searchParams.get('q');
-
-    return MyThingService.getMyThingsExample(q);
-  }
-
-  @put(':id')
-  static updateMyThingExample = async (
-    req: VovkRequest<{ foo: 'bar' | 'baz' }, { q: string }>,
-    params: { id: string }
-  ) => {
-    const { id } = params;
-    const body = await req.json();
-    const q = req.nextUrl.searchParams.get('q');
-
-    return MyThingService.updateMyThingExample(id, q, body);
-  };
-
-  @post()
-  static createMyThingExample = () => {
-    // ...
-  };
-
-  @del(':id')
-  static deleteMyThingExample = () => {
-    // ...
-  };
-}

package/templates_old/MyThingService.s.template.ts

@@ -1,18 +0,0 @@
-import type { VovkControllerBody, VovkControllerQuery } from 'vovk';
-import type MyThingController from './MyThingController.c.template';
-
-export default class MyThingService {
-  static getMyThingsExample = (q: VovkControllerQuery<typeof MyThingController.getMyThingsExample>['q']) => {
-    return { q };
-  };
-
-  static updateMyThingExample = (
-    id: string,
-    q: VovkControllerQuery<typeof MyThingController.updateMyThingExample>['q'],
-    body: VovkControllerBody<typeof MyThingController.updateMyThingExample>
-  ) => {
-    return { id, q, body };
-  };
-
-  // ...
-}

package/templates_old/controller.ejs

@@ -1,85 +0,0 @@
-<% var modulePascalName = _.upperFirst(_.camelCase(moduleName)); %>
-<% var modulePascalNamePlural = pluralize(modulePascalName); %>
-<% var ControllerName = modulePascalName + 'Controller'; %>
-<% var RPCName = modulePascalName + 'RPC'; %>
-<% var ServiceName = modulePascalName + 'Service'; %>
----
-# Relative to modules dir
-fileName: <%= getFileDir(segmentName, moduleName) + ControllerName + '.ts' %>
-className: <%= ControllerName %> # Used to define a controller in a segment
-rpcName: <%= RPCName %> # Used to define an exported RPC class in a segment
----
-
-import { prefix, get, put, post, del<%= !config.validationLibrary ? ', type VovkRequest' : '' %> } from 'vovk';
-<% if(withService) { %>
-import <%= ServiceName %> from './<%= ServiceName %>';
-<% } %>
-<% if(config.validationLibrary === 'vovk-zod') { %>
-import { withZod } from 'vovk-zod';
-import { z } from 'zod';
-<% } %>
-
-@prefix('<%= _.kebabCase(moduleName).toLowerCase() %>')
-export default class <%= ControllerName %> {
-    @get()
-    <% if(config.validationLibrary === 'vovk-zod') { %>
-    async get<%= modulePascalNamePlural %> = withZod(null, z.object({ q: z.string() }), (req) => {
-        const q = req.nextUrl.searchParams.get('q');
-        <% if(withService) { %>
-        return <%= ServiceName %>.getMyThingsExample(q);
-        <% } else { %>
-        return { q };
-        <% } %>
-    });
-    <% } else { %>
-    static get<%= modulePascalNamePlural %> = async (req: VovkRequest<null, { q: string }>) => {
-        const q = req.nextUrl.searchParams.get('q');
-        <% if(withService) { %>
-        return <%= ServiceName %>.getMyThingsExample(q);
-        <% } else { %>
-        return { q };
-        <% } %>
-    }
-    <% } %>
-
-    @put(':id')
-    <% if(config.validationLibrary === 'vovk-zod') { %>
-    static update<%= modulePascalNamePlural %> = withZod(
-        z.object({
-        foo: z.union([z.literal('bar'), z.literal('baz')]),
-        }),
-        z.object({ q: z.string() }),
-        async (req, params: { id: string }) => {
-        const { id } = params;
-        const body = await req.json();
-        const q = req.nextUrl.searchParams.get('q');
-        <% if(withService) { %>
-        return MyThingService.updateMyThingExample(id, q, body);
-        <% } else { %>
-        return { id, body, q };
-        <% } %>
-        }
-    );
-    <% } else { %>
-    static update<%= modulePascalNamePlural %> = async (req: VovkRequest<{ foo: 'bar' | 'baz' }, { q: string }>, params: { id: string }) => {
-        const { id } = params;
-        const body = await req.json();
-        const q = req.nextUrl.searchParams.get('q');
-        <% if(withService) { %>
-        return MyThingService.updateMyThingExample(id, q, body);
-        <% } else { %>
-        return { id, body, q };
-        <% } %>
-    };
-    <% } %>
-
-    @post()
-    static create<%= modulePascalNamePlural %> = () => {
-        // ...
-    };
-
-    @del(':id')
-    static delete<%= modulePascalNamePlural %> = () => {
-        // ...
-    };
-}

package/templates_old/service.ejs

@@ -1,9 +0,0 @@
-<% var modulePascalName = _.upperFirst(_.camelCase(moduleName); %>
-<% var ServiceName = modulePascalName + 'Service'; %>
-
----
-# Relative to modules dir
-fileName: <%= getFileDir(segmentName, moduleName) + ServiceName + '.ts' %>
----
-
-// TO DO: Implement <%= ServiceName %>

package/templates_old/worker.ejs

@@ -1,9 +0,0 @@
-<% var modulePascalName = _.upperFirst(_.camelCase(moduleName); %>
-<% var WorkerName = modulePascalName + 'Worker'; %>
-
----
-# Relative to modules dir
-fileName: <%= getFileDir(segmentName, moduleName) + WorkerName + '.ts' %>
----
-
-// TO DO: Implement <%= WorkerName %>

package/templates_old/zod/MyThingController.c.only.template.ts

@@ -1,32 +0,0 @@
-import { prefix, get, put, post, del, type VovkRequest } from 'vovk';
-
-@prefix('my-thing')
-export default class MyThingController {
-  @get()
-  static getMyThingsExample = (req: VovkRequest<null, { q: string }>) => {
-    const q = req.nextUrl.searchParams.get('q');
-    return { q };
-  };
-
-  @put(':id')
-  static updateMyThingExample = async (
-    req: VovkRequest<{ foo: 'bar' | 'baz' }, { q: string }>,
-    params: { id: string }
-  ) => {
-    const { id } = params;
-    const body = await req.json();
-    const q = req.nextUrl.searchParams.get('q');
-
-    return { id, q, body };
-  };
-
-  @post()
-  static createMyThingExample = () => {
-    // ...
-  };
-
-  @del(':id')
-  static deleteMyThingExample = () => {
-    // ...
-  };
-}

package/templates_old/zod/MyThingController.c.template.ts

@@ -1,39 +0,0 @@
-import { prefix, get, put, post, del } from 'vovk';
-import { z } from 'zod';
-import { withZod } from 'vovk-zod';
-import MyThingService from './MyThingService.s.template';
-
-@prefix('my-thing')
-export default class MyThingController {
-  @get()
-  static getMyThingsExample = withZod(null, z.object({ q: z.string() }), (req) => {
-    const q = req.nextUrl.searchParams.get('q');
-
-    return MyThingService.getMyThingsExample(q);
-  });
-
-  @put(':id')
-  static updateMyThingExample = withZod(
-    z.object({
-      foo: z.union([z.literal('bar'), z.literal('baz')]),
-    }),
-    z.object({ q: z.string() }),
-    async (req, params: { id: string }) => {
-      const { id } = params;
-      const body = await req.json();
-      const q = req.nextUrl.searchParams.get('q');
-
-      return MyThingService.updateMyThingExample(id, q, body);
-    }
-  );
-
-  @post()
-  static async createMyThingExample() {
-    // ...
-  }
-
-  @del(':id')
-  static deleteMyThingExample() {
-    // ...
-  }
-}

package/templates_old/zod/MyThingService.s.template.ts

@@ -1,18 +0,0 @@
-import type { VovkControllerBody, VovkControllerQuery } from 'vovk';
-import type MyThingController from './MyThingController.c.template';
-
-export default class MyThingService {
-  static getMyThingsExample = (q: VovkControllerQuery<typeof MyThingController.getMyThingsExample>['q']) => {
-    return { q };
-  };
-
-  static updateMyThingExample = (
-    id: string,
-    q: VovkControllerQuery<typeof MyThingController.updateMyThingExample>['q'],
-    body: VovkControllerBody<typeof MyThingController.updateMyThingExample>
-  ) => {
-    return { id, q, body };
-  };
-
-  // ...
-}