vovk-cli 0.0.1-beta.12 → 0.0.1-beta.14

package/dist/{server/generateClient.d.mts → generateClient.d.mts}

@@ -1,5 +1,5 @@
-import type { ProjectInfo } from '../getProjectInfo/index.mjs';
-import type { Segment } from '../locateSegments.mjs';
+import type { ProjectInfo } from './getProjectInfo/index.mjs';
+import type { Segment } from './locateSegments.mjs';
 import type { VovkSchema } from 'vovk';
 export default function generateClient(projectInfo: ProjectInfo, segments: Segment[], segmentsSchema: Record<string, VovkSchema>): Promise<{
     written: boolean;

package/dist/{server/generateClient.mjs → generateClient.mjs}

@@ -1,5 +1,6 @@
 import path from 'path';
 import fs from 'fs/promises';
+import formatLoggedSegmentName from './utils/formatLoggedSegmentName.mjs';
 export default async function generateClient(projectInfo, segments, segmentsSchema) {
     const now = Date.now();
     const clientoOutDirFullPath = path.join(projectInfo.cwd, projectInfo.config.clientOutDir);
@@ -34,7 +35,7 @@ import schema from '${projectInfo.schemaOutImportPath}';
         const { routeFilePath, segmentName } = segments[i];
         const schema = segmentsSchema[segmentName];
         if (!schema) {
-            throw new Error(`Unable to generate client. No schema found for segment ${segmentName}`);
+            throw new Error(`Unable to generate client. No schema found for ${formatLoggedSegmentName(segmentName)}`);
         }
         if (!schema.emitSchema)
             continue;
@@ -44,12 +45,12 @@ import schema from '${projectInfo.schemaOutImportPath}';
     }
     dts += `
 type Options = typeof fetcher extends VovkClientFetcher<infer U> ? U : never;
-  `;
+`;
     ts += `
 ${validateFullPath ? `import validateOnClient from '${validateFullPath}';\n` : '\nconst validateOnClient = undefined;'}
 type Options = typeof fetcher extends VovkClientFetcher<infer U> ? U : never;
 const prefix = '${projectInfo.apiEntryPoint}';
-  `;
+`;
     js += `
 const { default: validateOnClient = null } = ${validateFullPath ? `require('${validateFullPath}')` : '{}'};
 const prefix = '${projectInfo.apiEntryPoint}';
@@ -58,7 +59,7 @@ const prefix = '${projectInfo.apiEntryPoint}';
         const { segmentName } = segments[i];
         const schema = segmentsSchema[segmentName];
         if (!schema) {
-            throw new Error(`Unable to generate client. No schema found for segment ${segmentName}`);
+            throw new Error(`Unable to generate client. No schema found for ${formatLoggedSegmentName(segmentName)}`);
         }
         if (!schema.emitSchema)
             continue;

package/dist/getProjectInfo/getConfigPath.d.mts

@@ -0,0 +1 @@
+export default function getConfigPath(relativePath?: string): Promise<string | null>;

package/dist/getProjectInfo/getConfigPath.mjs

@@ -0,0 +1,18 @@
+import fs from 'fs/promises';
+import path from 'path';
+export default async function getConfigPath(relativePath = '') {
+    const rootDir = path.resolve(process.cwd(), relativePath || '');
+    const baseName = 'vovk.config';
+    const extensions = ['cjs', 'mjs', 'js'];
+    for (const ext of extensions) {
+        const filePath = path.join(rootDir, `${baseName}.${ext}`);
+        try {
+            await fs.stat(filePath);
+            return filePath; // Return the path if the file exists
+        }
+        catch {
+            // Empty
+        }
+    }
+    return null; // Return null if no config file was found
+}

package/dist/getProjectInfo/index.d.mts

@@ -1,4 +1,3 @@
-import loglevel from 'loglevel';
 export type ProjectInfo = Awaited<ReturnType<typeof getProjectInfo>>;
 export default function getProjectInfo({ port: givenPort, clientOutDir, }?: {
     port?: number;
@@ -17,6 +16,6 @@ export default function getProjectInfo({ port: givenPort, clientOutDir, }?: {
         warn: (msg: string) => void;
         error: (msg: string) => void;
         debug: (msg: string) => void;
-        raw: loglevel.RootLogger;
+        raw: import("loglevel").RootLogger;
     };
 }>;

package/dist/getProjectInfo/index.mjs

@@ -1,7 +1,6 @@
 import path from 'path';
-import loglevel from 'loglevel';
-import chalk from 'chalk';
 import getConfig from './getConfig.mjs';
+import getLogger from '../utils/getLogger.mjs';
 export default async function getProjectInfo({ port: givenPort, clientOutDir, } = {}) {
     const port = givenPort?.toString() ?? process.env.PORT ?? '3000';
     // Make PORT available to the config file at getConfig
@@ -14,14 +13,7 @@ export default async function getProjectInfo({ port: givenPort, clientOutDir, }
     const fetcherClientImportPath = config.fetcher.startsWith('.')
         ? path.relative(config.clientOutDir, config.fetcher)
         : config.fetcher;
-    const log = {
-        info: (msg) => loglevel.info(chalk.blueBright(`🐺 ${msg}`)),
-        warn: (msg) => loglevel.warn(chalk.yellowBright(`🐺 ${msg}`)),
-        error: (msg) => loglevel.error(chalk.redBright(`🐺 ${msg}`)),
-        debug: (msg) => loglevel.debug(chalk.gray(`🐺 ${msg}`)),
-        raw: loglevel,
-    };
-    loglevel.setLevel(config.logLevel);
+    const log = getLogger(config.logLevel);
     return {
         cwd,
         port,

package/dist/getProjectInfo/readConfig.mjs

@@ -1,23 +1,6 @@
-import { promises as fs } from 'fs';
-import path from 'path';
-async function findConfigPath() {
-    const rootDir = process.cwd();
-    const baseName = 'vovk.config';
-    const extensions = ['cjs', 'mjs', 'js'];
-    for (const ext of extensions) {
-        const filePath = path.join(rootDir, `${baseName}.${ext}`);
-        try {
-            await fs.stat(filePath);
-            return filePath; // Return the path if the file exists
-        }
-        catch {
-            // If the file doesn't exist, an error is thrown. Catch it and continue checking.
-        }
-    }
-    return null; // Return null if no config file was found
-}
+import getConfigPath from './getConfigPath.mjs';
 async function readConfig() {
-    const configPath = await findConfigPath();
+    const configPath = await getConfigPath();
     let config = {};
     if (!configPath) {
         return config;

package/dist/index.d.mts

@@ -1,3 +1,8 @@
 #!/usr/bin/env node
 import { VovkConfig, VovkEnv } from './types.mjs';
+import type { LogLevelNames } from 'loglevel';
 export type { VovkConfig, VovkEnv };
+export interface InitOptions {
+    yes: boolean;
+    logLevel: LogLevelNames;
+}

package/dist/index.mjs

@@ -2,21 +2,21 @@
 import { Command } from 'commander';
 import concurrently from 'concurrently';
 import getAvailablePort from './utils/getAvailablePort.mjs';
-import { VovkCLIServer } from './server/index.mjs';
+import { VovkCLIWatcher } from './watcher/index.mjs';
 import getProjectInfo from './getProjectInfo/index.mjs';
-import generateClient from './server/generateClient.mjs';
+import generateClient from './generateClient.mjs';
 import locateSegments from './locateSegments.mjs';
 import path from 'path';
 import { readFileSync } from 'fs';
+import { Init } from './init/index.mjs';
 const program = new Command();
 const packageJSON = JSON.parse(readFileSync(path.join(import.meta.dirname, '../package.json'), 'utf-8'));
 program.name('vovk').description('Vovk CLI').version(packageJSON.version);
 program
     .command('dev')
-    .description('Start development server (optional flag --next-dev to start Vovk Server with Next.js)')
-    .option('--project <path>', 'Path to Next.js project', process.cwd())
+    .description('Start schema watcher (optional flag --next-dev to start it with Next.js)')
     .option('--client-out <path>', 'Path to client output directory')
-    .option('--next-dev', 'Start Vovk Server and Next.js with automatic port allocation', false)
+    .option('--next-dev', 'Start schema watcher and Next.js with automatic port allocation', false)
     .allowUnknownOption(true)
     .action(async (options, command) => {
     const portAttempts = 30;
@@ -34,9 +34,9 @@ program
     if (options.nextDev) {
         const { result } = concurrently([
             {
-                command: `node ${import.meta.dirname}/server/index.mjs`,
-                name: 'Vovk.ts Schema Server',
-                env: Object.assign({ PORT, __VOVK_START_SERVER_IN_STANDALONE_MODE__: 'true' }, options.clientOut ? { VOVK_CLIENT_OUT_DIR: options.clientOut } : {}),
+                command: `node ${import.meta.dirname}/watcher/index.mjs`,
+                name: 'Vovk.ts Schema Watcher',
+                env: Object.assign({ PORT, __VOVK_START_WATCHER_IN_STANDALONE_MODE__: 'true' }, options.clientOut ? { VOVK_CLIENT_OUT_DIR: options.clientOut } : {}),
             },
             {
                 command: `cd ${options.project} && npx next dev ${command.args.join(' ')}`,
@@ -56,7 +56,7 @@ program
         }
     }
     else {
-        void new VovkCLIServer().startServer({ clientOutDir: options.clientOut });
+        void new VovkCLIWatcher().start({ clientOutDir: options.clientOut });
     }
 });
 program
@@ -71,6 +71,14 @@ program
     const schema = (await import(path.join(schemaOutFullPath, 'index.js')));
     await generateClient(projectInfo, segments, schema.default);
 });
+program
+    .command('init [prefix]')
+    .description('Initialize Vovk project')
+    .option('-Y, --yes', 'Skip all prompts and use default values')
+    .option('--log-level <level>', 'Set log level', 'info')
+    .action(async (prefix = '.', options) => {
+    await Init.main(prefix, options);
+});
 program
     .command('help')
     .description('Show help message')

package/dist/init/index.d.mts

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+import type { VovkConfig } from '../types.mjs';
+import type { InitOptions } from '../index.mjs';
+import getLogger from '../utils/getLogger.mjs';
+declare abstract class Action<T> {
+    context: Context;
+    data: T;
+    action: () => void;
+    constructor(context: Context);
+    toJSON: () => T;
+}
+declare class Context {
+    actions: Action<unknown>[];
+    vovkConfig: VovkConfig;
+    root: string;
+    log: ReturnType<typeof getLogger>;
+    static main(prefix: string, { yes, logLevel }: InitOptions): Promise<void>;
+}
+export declare const Init: typeof Context;
+export {};

package/dist/init/index.mjs

@@ -0,0 +1,244 @@
+#!/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 NPMCliPackageJson from '@npmcli/package-json';
+import path from 'path';
+import fs from 'fs/promises';
+import * as jsonc from 'jsonc-parser';
+import getConfigPath from '../getProjectInfo/getConfigPath.mjs';
+import chalk from 'chalk';
+import fileExists from '../utils/fileExists.mjs';
+import installDependencies from './installDependencies.mjs';
+import getLogger from '../utils/getLogger.mjs';
+class Action {
+    context;
+    data;
+    // public prevAction: Action | null = null;
+    action;
+    constructor(context) {
+        this.context = context;
+    }
+    toJSON = () => this.data;
+}
+class InstallValidationLibraryAction extends Action {
+    constructor(context, data) {
+        super(context);
+        this.data = data;
+    }
+    action = () => {
+        this.context.vovkConfig.validationLibrary = this.data.validationLibrary;
+        if (this.data.validationLibrary && this.data.enableClientValidation) {
+            this.context.vovkConfig.validateOnClient = `${this.data.validationLibrary}/validateOnClient`;
+        }
+    };
+}
+class UpdateNpmScriptsAction extends Action {
+    constructor(context) {
+        super(context);
+        this.data = { shouldUpdateNpmScripts: true };
+    }
+    action = async () => {
+        if (this.data.shouldUpdateNpmScripts && typeof this.data.useConcurrently === 'undefined') {
+            throw new Error('useConcurrently must be defined');
+        }
+        const pkgJson = await NPMCliPackageJson.load(this.context.root);
+        pkgJson.update({
+            scripts: {
+                generate: 'vovk generate',
+                dev: this.data.useConcurrently
+                    ? 'PORT=3000 concurrently "vovk dev" "next dev" --kill-others'
+                    : 'vovk dev --next-dev',
+            },
+        });
+        await pkgJson.save();
+    };
+}
+class UpdateTsconfigAction extends Action {
+    constructor(context) {
+        super(context);
+    }
+    action = async () => {
+        const tsconfigPath = path.resolve(process.cwd(), 'tsconfig.json');
+        try {
+            // Read the content of tsconfig.json asynchronously
+            const tsconfigContent = await fs.readFile(tsconfigPath, 'utf8');
+            // Use jsonc-parser to generate edits and modify the experimentalDecorators property
+            const edits = jsonc.modify(tsconfigContent, ['compilerOptions', 'experimentalDecorators'], true, {
+                formattingOptions: {},
+            });
+            // Apply the edits to the original content
+            const updatedContent = jsonc.applyEdits(tsconfigContent, edits);
+            // Write the updated content back to the file asynchronously
+            await fs.writeFile(tsconfigPath, updatedContent, 'utf8');
+        }
+        catch (error) {
+            throw new Error(`Failed to update tsconfig.json at ${tsconfigPath}. ${String(error)}`);
+        }
+    };
+    static async checkTsconfigForExperimentalDecorators() {
+        const tsconfigPath = path.resolve(process.cwd(), 'tsconfig.json');
+        let tsconfigContent;
+        try {
+            tsconfigContent = await fs.readFile(tsconfigPath, 'utf8');
+        }
+        catch (error) {
+            throw new Error(`Failed to read tsconfig.json at ${tsconfigPath}. You can run "npx tsc --init" to create it. ${String(error)}`);
+        }
+        const tsconfig = jsonc.parse(tsconfigContent);
+        return !!tsconfig?.compilerOptions?.experimentalDecorators;
+    }
+}
+class Context {
+    actions = [];
+    vovkConfig = {};
+    root;
+    log;
+    static async main(prefix, { yes, logLevel }) {
+        // TODO handle yes option
+        console.log('yes', yes);
+        const context = new Context();
+        const cwd = process.cwd();
+        const configPath = await getConfigPath(prefix);
+        const toBeInstalled = ['vovk'];
+        const root = path.join(cwd, prefix);
+        const log = getLogger(logLevel);
+        context.root = root;
+        context.log = log;
+        if (!(await fileExists(path.join(root, 'package.json')))) {
+            throw new Error(`package.json not found at ${root}. Run "npx create-next-app" to create a new Next.js project.`);
+        }
+        if (!(await fileExists(path.join(root, 'tsconfig.json')))) {
+            throw new Error(`tsconfig.json not found at ${root}. Run "npx tsc --init" to create a new tsconfig.json file.`);
+        }
+        if (configPath) {
+            if (!(await confirm({
+                message: `Found existing config file at ${configPath}. Do you want to reinitialize the project?`,
+            })))
+                return;
+        }
+        const validationLibrary = await select({
+            message: 'Choose validation library',
+            default: 'vovk-zod',
+            choices: [
+                {
+                    name: 'vovk-zod',
+                    value: 'vovk-zod',
+                    description: 'Use Zod for data validation',
+                },
+                {
+                    name: 'vovk-yup',
+                    value: 'vovk-yup',
+                    description: 'Use Yup for data validation',
+                },
+                {
+                    name: 'vovk-dto',
+                    value: 'vovk-dto',
+                    description: 'Use class-validator and class-transformer for data validation',
+                },
+                { name: 'None', value: null, description: 'Install validation library later' },
+            ],
+        });
+        if (validationLibrary) {
+            toBeInstalled.push(validationLibrary);
+            toBeInstalled.push(...({
+                'vovk-zod': ['zod'],
+                'vovk-yup': ['yup'],
+                'vovk-dto': ['class-validator', 'class-transformer'],
+            }[validationLibrary] ?? []));
+            const installValidationLibraryAction = new InstallValidationLibraryAction(context, { validationLibrary });
+            context.actions.push(installValidationLibraryAction);
+            installValidationLibraryAction.data.enableClientValidation = await confirm({
+                message: 'Do you want to enable client validation?',
+            });
+        }
+        const devScriptType = await select({
+            message: 'Do you want to update package.json by adding "generate" and "dev" scripts?',
+            default: 'IMPLICIT',
+            choices: [
+                {
+                    name: 'Yes, with implicit concurrently',
+                    description: `The "dev" script will use concurrently API internally and automatically set a port ${chalk.whiteBright(`"vovk dev --next-dev"`)}`,
+                    value: 'IMPLICIT',
+                },
+                {
+                    name: 'Yes, with explicit concurrently',
+                    value: 'EXPLICIT',
+                    description: `The "dev" script will use pre-defined PORT variable ${chalk.whiteBright(`"PORT=3000 concurrently 'vovk dev' 'next dev' --kill-others"`)}`,
+                },
+                {
+                    name: 'No',
+                    value: null,
+                    description: 'Add the scripts manually',
+                },
+            ],
+        });
+        if (devScriptType) {
+            const updateNpmScriptsAction = new UpdateNpmScriptsAction(context);
+            context.actions.push(updateNpmScriptsAction);
+            updateNpmScriptsAction.data.useConcurrently = devScriptType === 'EXPLICIT';
+        }
+        if (!(await UpdateTsconfigAction.checkTsconfigForExperimentalDecorators()) &&
+            (await confirm({ message: 'Do you want to add experimentalDecorators to tsconfig.json?' }))) {
+            const updateTsconfigAction = new UpdateTsconfigAction(context);
+            context.actions.push(updateTsconfigAction);
+        }
+        await installDependencies(root, toBeInstalled, ['concurrently', 'vovk-cli']);
+    }
+}
+export const Init = Context;

package/dist/init/installDependencies.d.mts

@@ -0,0 +1 @@
+export default function installDependencies(installDir: string, dependencies: string[], devDependencies: string[]): Promise<void>;

package/dist/init/installDependencies.mjs

@@ -0,0 +1,28 @@
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import * as path from 'path';
+const execPromise = promisify(exec);
+export default async function installDependencies(installDir, dependencies, devDependencies) {
+    const fullPath = path.resolve(installDir);
+    try {
+        if (dependencies.length > 0) {
+            console.log(`Installing dependencies in ${fullPath}...`);
+            const { stdout, stderr } = await execPromise(`npm install ${dependencies.join(' ')} --prefix ${fullPath}`);
+            console.log(stdout);
+            if (stderr) {
+                console.error(stderr);
+            }
+        }
+        if (devDependencies.length > 0) {
+            console.log(`Installing dev dependencies in ${fullPath}...`);
+            const { stdout, stderr } = await execPromise(`npm install --save-dev ${devDependencies.join(' ')} --prefix ${fullPath}`);
+            console.log(stdout);
+            if (stderr) {
+                console.error(stderr);
+            }
+        }
+    }
+    catch (err) {
+        console.error(`Error installing dependencies: ${err.message}`);
+    }
+}

package/dist/types.d.mts

@@ -13,7 +13,7 @@ export type VovkEnv = {
     VOVK_API_ENTRY_POINT?: string;
     VOVK_ROOT_SEGMENT_MODULES_DIR_NAME?: string;
     VOVK_LOG_LEVEL?: LogLevelNames;
-    __VOVK_START_SERVER_IN_STANDALONE_MODE__?: 'true';
+    __VOVK_START_WATCHER_IN_STANDALONE_MODE__?: 'true';
 };
 export type VovkConfig = {
     clientOutDir?: string;

package/dist/utils/formatLoggedSegmentName.d.mts

@@ -0,0 +1 @@
+export default function formatLoggedSegmentName(segmentName: string, withChalk?: boolean): string;

package/dist/utils/formatLoggedSegmentName.mjs

@@ -0,0 +1,5 @@
+import chalk from 'chalk';
+export default function formatLoggedSegmentName(segmentName, withChalk = false) {
+    const text = segmentName ? `segment "${segmentName}"` : 'the root segment';
+    return withChalk ? chalk.white.bold(text) : text;
+}

package/dist/utils/getLogger.d.mts

@@ -0,0 +1,8 @@
+import loglevel, { type LogLevelNames } from 'loglevel';
+export default function getLogger(level: LogLevelNames): {
+    info: (msg: string) => void;
+    warn: (msg: string) => void;
+    error: (msg: string) => void;
+    debug: (msg: string) => void;
+    raw: loglevel.RootLogger;
+};

package/dist/utils/getLogger.mjs

@@ -0,0 +1,13 @@
+import chalk from 'chalk';
+import loglevel from 'loglevel';
+export default function getLogger(level) {
+    const log = {
+        info: (msg) => loglevel.info(chalk.cyanBright(`🐺 ${msg}`)),
+        warn: (msg) => loglevel.warn(chalk.yellowBright(`🐺 ${msg}`)),
+        error: (msg) => loglevel.error(chalk.redBright(`🐺 ${msg}`)),
+        debug: (msg) => loglevel.debug(chalk.gray(`🐺 ${msg}`)),
+        raw: loglevel,
+    };
+    loglevel.setLevel(level);
+    return log;
+}

package/dist/{server → watcher}/ensureSchemaFiles.mjs

@@ -2,6 +2,7 @@ import fs from 'fs/promises';
 import path from 'path';
 import debounce from 'lodash/debounce.js';
 import writeOneSchemaFile, { ROOT_SEGMENT_SCHEMA_NAME } from './writeOneSchemaFile.mjs';
+import formatLoggedSegmentName from '../utils/formatLoggedSegmentName.mjs';
 export default async function ensureSchemaFiles(schemaOutFullPath, segmentNames, projectInfo) {
     const now = Date.now();
     let hasChanged = false;
@@ -30,7 +31,7 @@ export default segmentSchema;`;
             skipIfExists: true,
         });
         if (isCreated) {
-            projectInfo?.log.debug(`Created empty schema file for segment "${segmentName}"`);
+            projectInfo?.log.debug(`Created empty schema file for ${formatLoggedSegmentName(segmentName, true)}`);
             hasChanged = true;
         }
     }));
@@ -56,7 +57,7 @@ export default segmentSchema;`;
                 if (!segmentNames.includes(segmentName) &&
                     !segmentNames.includes(segmentName.replace(ROOT_SEGMENT_SCHEMA_NAME, ''))) {
                     await fs.unlink(fullPath);
-                    projectInfo?.log.debug(`Deleted unnecessary schema file for segment "${segmentName}"`);
+                    projectInfo?.log.debug(`Deleted unnecessary schema file for ${formatLoggedSegmentName(segmentName, true)}`);
                     hasChanged = true;
                 }
             }

package/dist/watcher/index.d.mts

@@ -0,0 +1,6 @@
+export declare class VovkCLIWatcher {
+    #private;
+    start({ clientOutDir }?: {
+        clientOutDir?: string;
+    }): Promise<void>;
+}

package/dist/{server → watcher}/index.mjs

@@ -5,12 +5,13 @@ import path from 'path';
 import { debouncedEnsureSchemaFiles } from './ensureSchemaFiles.mjs';
 import writeOneSchemaFile from './writeOneSchemaFile.mjs';
 import logDiffResult from './logDiffResult.mjs';
-import generateClient from './generateClient.mjs';
+import generateClient from '../generateClient.mjs';
 import locateSegments from '../locateSegments.mjs';
 import debounceWithArgs from '../utils/debounceWithArgs.mjs';
 import debounce from 'lodash/debounce.js';
 import isEmpty from 'lodash/isEmpty.js';
-export class VovkCLIServer {
+import formatLoggedSegmentName from '../utils/formatLoggedSegmentName.mjs';
+export class VovkCLIWatcher {
     #projectInfo;
     #segments = [];
     #schemas = {};
@@ -45,7 +46,7 @@ export class VovkCLIServer {
             .on('change', (filePath) => {
             log.debug(`File ${filePath} has been changed at segments folder`);
             if (segmentReg.test(filePath)) {
-                void this.#ping(getSegmentName(filePath));
+                void this.#requestSchema(getSegmentName(filePath));
             }
         })
             // eslint-disable-next-line @typescript-eslint/no-misused-promises
@@ -53,7 +54,7 @@ export class VovkCLIServer {
             log.debug(`Directory ${dirPath} has been added to segments folder`);
             this.#segments = await locateSegments(apiDirFullPath);
             for (const { segmentName } of this.#segments) {
-                void this.#ping(segmentName);
+                void this.#requestSchema(segmentName);
             }
         })
             // eslint-disable-next-line @typescript-eslint/no-misused-promises
@@ -61,7 +62,7 @@ export class VovkCLIServer {
             log.debug(`Directory ${dirPath} has been removed from segments folder`);
             this.#segments = await locateSegments(apiDirFullPath);
             for (const { segmentName } of this.#segments) {
-                void this.#ping(segmentName);
+                void this.#requestSchema(segmentName);
             }
         })
             .on('unlink', (filePath) => {
@@ -104,12 +105,12 @@ export class VovkCLIServer {
         })
             .on('addDir', () => {
             for (const { segmentName } of this.#segments) {
-                void this.#ping(segmentName);
+                void this.#requestSchema(segmentName);
             }
         })
             .on('unlinkDir', () => {
             for (const { segmentName } of this.#segments) {
-                void this.#ping(segmentName);
+                void this.#requestSchema(segmentName);
             }
         })
             .on('ready', () => {
@@ -177,18 +178,18 @@ export class VovkCLIServer {
             if (affectedSegments.length) {
                 log.debug(`A file with controller or worker ${namesOfClasses.join(', ')} have been modified at path "${filePath}". Segment(s) affected: ${affectedSegments.map((s) => s.segmentName).join(', ')}`);
                 for (const segment of affectedSegments) {
-                    await this.#ping(segment.segmentName);
+                    await this.#requestSchema(segment.segmentName);
                 }
             }
         }
     };
-    #ping = debounceWithArgs(async (segmentName) => {
+    #requestSchema = debounceWithArgs(async (segmentName) => {
         const { apiEntryPoint, log, port } = this.#projectInfo;
         const endpoint = `${apiEntryPoint.startsWith('http') ? apiEntryPoint : `http://localhost:${port}${apiEntryPoint}`}/${segmentName ? `${segmentName}/` : ''}_schema_`;
-        log.debug(`Pinging segment "${segmentName}" at ${endpoint}`);
+        log.debug(`Requesting schema for ${formatLoggedSegmentName(segmentName, true)} at ${endpoint}`);
         const resp = await fetch(endpoint);
         if (resp.status !== 200) {
-            log.warn(`Ping to segment "${segmentName}" failed with status code ${resp.status}. Expected 200.`);
+            log.warn(`Schema request to ${formatLoggedSegmentName(segmentName, true)} failed with status code ${resp.status}. Expected 200.`);
             return;
         }
         let schema = null;
@@ -196,7 +197,7 @@ export class VovkCLIServer {
             ({ schema } = (await resp.json()));
         }
         catch (error) {
-            log.error(`Error parsing schema for segment "${segmentName}": ${error.message}`);
+            log.error(`Error parsing schema for ${formatLoggedSegmentName(segmentName, true)}: ${error.message}`);
         }
         await this.#handleSchema(schema);
     }, 500);
@@ -224,18 +225,18 @@ export class VovkCLIServer {
             const timeTook = Date.now() - now;
             if (diffResult) {
                 logDiffResult(segment.segmentName, diffResult, this.#projectInfo);
-                log.info(`Schema for segment "${schema.segmentName}" has been updated in ${timeTook}ms`);
+                log.info(`Schema for ${formatLoggedSegmentName(segment.segmentName, true)} has been updated in ${timeTook}ms`);
             }
         }
         else if (schema && (!isEmpty(schema.controllers) || !isEmpty(schema.workers))) {
-            log.error(`Non-empty schema provided for segment "${schema.segmentName}" but emitSchema is false`);
+            log.error(`Non-empty schema provided for ${formatLoggedSegmentName(segment.segmentName, true)} but emitSchema is false`);
         }
         if (this.#segments.every((s) => this.#schemas[s.segmentName])) {
             log.debug(`All segments with emitSchema=true have schema.`);
             await generateClient(this.#projectInfo, this.#segments, this.#schemas);
         }
     }
-    async startServer({ clientOutDir } = {}) {
+    async start({ clientOutDir } = {}) {
         this.#projectInfo = await getProjectInfo({ clientOutDir });
         const { log, config, cwd, apiDir } = this.#projectInfo;
         process.on('uncaughtException', (err) => {
@@ -248,16 +249,16 @@ export class VovkCLIServer {
         const schemaOutFullPath = path.join(cwd, config.schemaOutDir);
         this.#segments = await locateSegments(apiDirFullPath);
         await debouncedEnsureSchemaFiles(schemaOutFullPath, this.#segments.map((s) => s.segmentName), this.#projectInfo);
-        // Ping every segment in 3 seconds in order to update schema and start watching
+        // Request schema every segment in 3 seconds in order to update schema and start watching
         setTimeout(() => {
             for (const { segmentName } of this.#segments) {
-                void this.#ping(segmentName);
+                void this.#requestSchema(segmentName);
             }
             this.#watch();
         }, 3000);
     }
 }
 const env = process.env;
-if (env.__VOVK_START_SERVER_IN_STANDALONE_MODE__ === 'true') {
-    void new VovkCLIServer().startServer();
+if (env.__VOVK_START_WATCHER_IN_STANDALONE_MODE__ === 'true') {
+    void new VovkCLIWatcher().start();
 }

package/dist/{server → watcher}/logDiffResult.mjs

@@ -1,4 +1,5 @@
 import chalk from 'chalk';
+import formatLoggedSegmentName from '../utils/formatLoggedSegmentName.mjs';
 export default function logDiffResult(segmentName, diffResult, projectInfo) {
     const diffNormalized = [];
     diffResult.workers.added.forEach((name) => {
@@ -30,43 +31,43 @@ export default function logDiffResult(segmentName, diffResult, projectInfo) {
             case 'worker':
                 switch (diffNormalizedItem.type) {
                     case 'added':
-                        projectInfo.log.info(`New worker ${chalk.white.bold(diffNormalizedItem.name)} has been added to segment "${chalk.white.bold(segmentName)}"`);
+                        projectInfo.log.info(`Schema for worker ${chalk.white.bold(diffNormalizedItem.name)} has been added at ${formatLoggedSegmentName(segmentName, true)}`);
                         break;
                     case 'removed':
-                        projectInfo.log.info(`Worker ${chalk.white.bold(diffNormalizedItem.name)} has been removed from segment "${chalk.white.bold(segmentName)}"`);
+                        projectInfo.log.info(`Schema for worker ${chalk.white.bold(diffNormalizedItem.name)} has been removed from ${formatLoggedSegmentName(segmentName, true)}`);
                         break;
                 }
                 break;
             case 'controller':
                 switch (diffNormalizedItem.type) {
                     case 'added':
-                        projectInfo.log.info(`New controller ${chalk.white.bold(diffNormalizedItem.name)} has been added to segment "${chalk.white.bold(segmentName)}"`);
+                        projectInfo.log.info(`Schema for controller ${chalk.white.bold(diffNormalizedItem.name)} has been added at ${formatLoggedSegmentName(segmentName, true)}`);
                         break;
                     case 'removed':
-                        projectInfo.log.info(`Controller ${chalk.white.bold(diffNormalizedItem.name)} has been removed from segment "${chalk.white.bold(segmentName)}"`);
+                        projectInfo.log.info(`Schema for controller ${chalk.white.bold(diffNormalizedItem.name)} has been removed from ${formatLoggedSegmentName(segmentName, true)}`);
                         break;
                 }
                 break;
             case 'workerHandler':
                 switch (diffNormalizedItem.type) {
                     case 'added':
-                        projectInfo.log.info(`New worker method ${chalk.white.bold(diffNormalizedItem.name)} has been added in segment "${chalk.white.bold(segmentName)}"`);
+                        projectInfo.log.info(`Schema for worker method ${chalk.white.bold(diffNormalizedItem.name)} has been added at ${formatLoggedSegmentName(segmentName, true)}`);
                         break;
                     case 'removed':
-                        projectInfo.log.info(`Worker method ${chalk.white.bold(diffNormalizedItem.name)} has been removed in segment "${chalk.white.bold(segmentName)}"`);
+                        projectInfo.log.info(`Schema for worker method ${chalk.white.bold(diffNormalizedItem.name)} has been removed from ${formatLoggedSegmentName(segmentName, true)}`);
                         break;
                 }
                 break;
             case 'controllerHandler':
                 switch (diffNormalizedItem.type) {
                     case 'added':
-                        projectInfo.log.info(`New controller method ${chalk.white.bold(diffNormalizedItem.name)} has been added in segment "${chalk.white.bold(segmentName)}"`);
+                        projectInfo.log.info(`Schema for controller method ${chalk.white.bold(diffNormalizedItem.name)} has been added at ${formatLoggedSegmentName(segmentName, true)}`);
                         break;
                     case 'removed':
-                        projectInfo.log.info(`Controller method ${chalk.white.bold(diffNormalizedItem.name)} has been removed in segment "${chalk.white.bold(segmentName)}"`);
+                        projectInfo.log.info(`Schema for controller method ${chalk.white.bold(diffNormalizedItem.name)} has been removed from ${formatLoggedSegmentName(segmentName, true)}`);
                         break;
                     case 'changed':
-                        projectInfo.log.info(`Controller method ${chalk.white.bold(diffNormalizedItem.name)} has been changed in segment "${chalk.white.bold(segmentName)}"`);
+                        projectInfo.log.info(`Schema for controller method ${chalk.white.bold(diffNormalizedItem.name)} has been changed at ${formatLoggedSegmentName(segmentName, true)}`);
                         break;
                 }
                 break;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vovk-cli",
-  "version": "0.0.1-beta.12",
+  "version": "0.0.1-beta.14",
   "bin": {
     "vovk": "./dist/index.mjs"
   },
@@ -34,11 +34,17 @@
   },
   "dependencies": {
     "@inquirer/prompts": "^5.3.8",
+    "@npmcli/package-json": "^5.2.0",
     "chalk": "^5.3.0",
     "chokidar": "^3.6.0",
     "commander": "^12.1.0",
     "concurrently": "^8.2.2",
+    "jsonc-parser": "^3.3.1",
     "lodash": "^4.17.21",
     "loglevel": "^1.9.1"
+  },
+  "devDependencies": {
+    "@types/npmcli__package-json": "^4.0.4",
+    "type-fest": "^4.26.0"
   }
 }

package/dist/init.d.mts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};

package/dist/init.mjs

@@ -1,171 +0,0 @@
-#!/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 use concurrently? (NO NEED, USE CONCURRENTLY BY DEFAULT)
-    - Yes (recommended)
-        - Add concurrently to the installation list
-    - No
-- Do you want to update NPM scripts?
-    - Yes
-        - Update NPM scripts
-    - 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 } from '@inquirer/prompts';
-// Or
-// import confirm from '@inquirer/confirm';
-// eslint-disable-next-line no-console
-void confirm({ message: 'Continue?' }).then(console.info);
-/*
-const wizard = [
-  {
-    description: 'Check if the project is already initialized',
-    type: 'check',
-    choices: {
-      type: 'choice',
-      choices: [
-        {
-          label: 'Yes',
-          action: 'continue',
-        },
-        {
-          label: 'No',
-          action: 'exit',
-          exitMessage: 'Exiting...',
-        },
-      ],
-    },
-  },
-  {
-    description: 'Check for package.json',
-    type: 'check',
-    handleCheck: () => {
-      // Check if the project is already initialized
-    },
-    yes: {
-      action: 'continue',
-    },
-    no: {
-      action: 'exit',
-      exitMessage: 'Exiting...',
-    },
-  },
-  {
-    description: 'Check for tsconfig.json',
-    type: 'check',
-    handleCheck: () => {
-      // Check for package.json
-    },
-    yes: {
-      action: 'continue',
-    },
-    no: {
-      action: 'exit',
-      exitMessage: 'Exiting...',
-    },
-  },
-  {
-    description: 'Check Next.js installed with app router',
-    type: 'check',
-    handleCheck: () => {
-      // Check for tsconfig.json
-    },
-    yes: {
-      action: 'continue',
-    },
-    no: {
-      action: 'exit',
-      exitMessage: 'Exiting...',
-    },
-  },
-  {
-    description: 'Choose validation library',
-    type: 'install',
-    choices: {
-      type: 'choice',
-      choices: [
-        {
-          package: 'vovk-zod',
-          action: 'install',
-          notes: 'Further installation notes: install zod',
-        },
-        {
-          package: 'vovk-yup',
-          action: 'install',
-          notes: 'Further installation notes: install yup',
-        },
-        {
-          package: 'vovk-dto',
-          action: 'install',
-          notes: 'Further installation notes: install class-validator and class-transformer',
-        },
-        {
-          package: null,
-          action: 'continue',
-        },
-      ],
-    },
-  },
-  {
-    description: 'Do you want to enable client validation?',
-    type: 'choice',
-    choices: [
-      {
-        label: 'Yes',
-        action: 'updateConfig',
-      },
-      {
-        label: 'No',
-        action: 'updateConfig',
-      },
-    ],
-  },
-];
-
-// export default console.info(wizard);
-*/

package/dist/server/index.d.mts

@@ -1,6 +0,0 @@
-export declare class VovkCLIServer {
-    #private;
-    startServer({ clientOutDir }?: {
-        clientOutDir?: string;
-    }): Promise<void>;
-}