vovk-cli 0.0.1-draft.11 → 0.0.1-draft.112

package/dist/generate/index.mjs

@@ -0,0 +1,105 @@
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import ejs from 'ejs';
+import matter from 'gray-matter';
+import uniq from 'lodash/uniq.js';
+import formatLoggedSegmentName from '../utils/formatLoggedSegmentName.mjs';
+import prettify from '../utils/prettify.mjs';
+import getClientTemplates from './getClientTemplates.mjs';
+import chalkHighlightThing from '../utils/chalkHighlightThing.mjs';
+export default async function generate({ projectInfo, segments, forceNothingWrittenLog, templates, prettify: prettifyClient, fullSchema, emitFullSchema, }) {
+    const segmentsSchema = fullSchema.segments;
+    const generateFrom = templates ?? projectInfo.config.generateFrom;
+    const noClient = templates?.[0] === 'none';
+    const { config, cwd, log, clientImports, apiRoot } = projectInfo;
+    const { clientOutDirAbsolutePath, templateFiles } = getClientTemplates({ config, cwd, generateFrom });
+    // Ensure that each segment has a matching schema if it needs to be emitted:
+    for (let i = 0; i < segments.length; i++) {
+        const { segmentName } = segments[i];
+        const schema = segmentsSchema[segmentName];
+        if (!schema) {
+            throw new Error(`Unable to generate client. No schema found for ${formatLoggedSegmentName(segmentName)}`);
+        }
+        if (!schema.emitSchema)
+            continue;
+    }
+    const now = Date.now();
+    // Data for the EJS templates:
+    const t = {
+        apiRoot,
+        imports: clientImports,
+        fullSchema,
+        segmentMeta: Object.fromEntries(segments.map(({ segmentName, ...s }) => [segmentName, s])),
+    };
+    // Process each template in parallel
+    const processedTemplates = noClient
+        ? []
+        : await Promise.all(templateFiles.map(async ({ templatePath, outPath, templateName }) => {
+            /*const parsed = matter((await ejs.render(codeTemplate, { t }, { async: true, filename: templateFileName })).trim());
+              const { dir, fileName, sourceName, compiledName } = parsed.data as VovkModuleRenderResult;
+              const code = empty ? (sourceName ? `export default class ${sourceName} {}` : '') : parsed.content;*/
+            // Read the EJS template
+            const templateContent = await fs.readFile(templatePath, 'utf-8');
+            const { data, content } = matter(templateContent);
+            if (data.imports instanceof Array) {
+                for (const imp of data.imports) {
+                    t.imports = {
+                        ...t.imports,
+                        [imp]: await import(imp),
+                    };
+                }
+            }
+            // Render the template
+            let rendered = templatePath.endsWith('.ejs')
+                ? ejs.render(content, { t }, {
+                    filename: templatePath,
+                })
+                : templateContent;
+            // Optionally prettify
+            if (prettifyClient || config.prettifyClient) {
+                rendered = await prettify(rendered, outPath);
+            }
+            // Read existing file content to compare
+            const existingContent = await fs.readFile(outPath, 'utf-8').catch(() => '');
+            // Determine if we need to rewrite the file, ignore 1st line
+            const needsWriting = existingContent.trim().split('\n').slice(1).join('\n') !== rendered.trim().split('\n').slice(1).join('\n');
+            return {
+                outPath,
+                rendered,
+                needsWriting,
+                templateName,
+            };
+        }));
+    const usedTemplateNames = uniq(processedTemplates.filter(({ needsWriting }) => needsWriting).map(({ templateName }) => templateName));
+    let fullSchemaNames = [];
+    const DEFAULT_NAME = 'full-schema.json';
+    if (emitFullSchema) {
+        fullSchemaNames.push(typeof fullSchema === 'string' ? fullSchema : DEFAULT_NAME);
+        fullSchemaNames.push(...templateFiles
+            .filter(({ emitFullSchema }) => emitFullSchema)
+            .map(({ emitFullSchema }) => (typeof emitFullSchema === 'string' ? emitFullSchema : DEFAULT_NAME)));
+    }
+    fullSchemaNames = uniq(fullSchemaNames);
+    if (fullSchemaNames.length) {
+        await Promise.all(fullSchemaNames.map(async (name) => {
+            const fullSchemaOutAbsolutePath = path.resolve(clientOutDirAbsolutePath, name);
+            await fs.writeFile(fullSchemaOutAbsolutePath, JSON.stringify(segmentsSchema, null, 2));
+            log.info(`Full schema has ben written to ${fullSchemaOutAbsolutePath}`);
+        }));
+    }
+    if (usedTemplateNames.length === 0) {
+        const logOrDebug = forceNothingWrittenLog ? log.info : log.debug;
+        logOrDebug(`Client is up to date and doesn't need to be regenerated (${Date.now() - now}ms)`);
+        return { written: false, path: clientOutDirAbsolutePath };
+    }
+    // Write updated files where needed
+    await Promise.all(processedTemplates.map(async ({ outPath, rendered, needsWriting }) => {
+        if (needsWriting) {
+            await fs.mkdir(clientOutDirAbsolutePath, { recursive: true });
+            return fs.writeFile(outPath, rendered);
+        }
+        return null;
+    }));
+    log.info(`Client generated from template${usedTemplateNames.length !== 1 ? 's' : ''} ${chalkHighlightThing(usedTemplateNames.map((s) => `"${s}"`).join(', '))} at ${clientOutDirAbsolutePath} in ${Date.now() - now}ms`);
+    return { written: true, path: clientOutDirAbsolutePath };
+}

package/dist/getProjectInfo/getConfig.d.mts

@@ -1,11 +1,11 @@
-import type { VovkConfig } from '../types.mjs';
+import type { VovkStrictConfig } from 'vovk';
 export default function getConfig({ clientOutDir, cwd }: {
     clientOutDir?: string;
     cwd: string;
 }): Promise<{
-    config: Required<VovkConfig>;
+    config: VovkStrictConfig;
     srcRoot: string;
     configAbsolutePaths: string[];
-    userConfig: VovkConfig | null;
+    userConfig: import("vovk").VovkConfig | null;
     error: Error | undefined;
 }>;

package/dist/getProjectInfo/getConfig.mjs

@@ -5,25 +5,42 @@ export default async function getConfig({ clientOutDir, cwd }) {
     const { configAbsolutePaths, error, userConfig } = await getUserConfig({ cwd });
     const conf = userConfig ?? {};
     const srcRoot = await getRelativeSrcRoot({ cwd });
+    const validateOnClientImport = env.VOVK_VALIDATE_ON_CLIENT_PATH ?? conf.validateOnClientImport ?? null;
+    const fetcherImport = env.VOVK_FETCHER_PATH ?? conf.fetcherImport ?? 'vovk';
+    const createRPCImport = env.VOVK_CREATE_RPC_PATH ?? conf.createRPCImport ?? 'vovk';
+    const defaultClientTemplates = ['ts', 'module', 'main'];
     const config = {
+        emitConfig: [],
         modulesDir: env.VOVK_MODULES_DIR ?? conf.modulesDir ?? './' + [srcRoot, 'modules'].filter(Boolean).join('/'),
-        validateOnClient: env.VOVK_VALIDATE_ON_CLIENT ?? conf.validateOnClient ?? null,
-        validationLibrary: env.VOVK_VALIDATION_LIBRARY ?? conf.validationLibrary ?? null,
-        fetcher: env.VOVK_FETCHER ?? conf.fetcher ?? 'vovk/client/defaultFetcher',
+        validateOnClientImport: typeof validateOnClientImport === 'string' ? [validateOnClientImport] : validateOnClientImport,
+        fetcherImport: typeof fetcherImport === 'string' ? [fetcherImport] : fetcherImport,
+        createRPCImport: typeof createRPCImport === 'string' ? [createRPCImport] : createRPCImport,
         schemaOutDir: env.VOVK_SCHEMA_OUT_DIR ?? conf.schemaOutDir ?? './.vovk-schema',
         clientOutDir: clientOutDir ?? env.VOVK_CLIENT_OUT_DIR ?? conf.clientOutDir ?? './node_modules/.vovk-client',
         origin: (env.VOVK_ORIGIN ?? conf.origin ?? '').replace(/\/$/, ''), // Remove trailing slash
         rootEntry: env.VOVK_ROOT_ENTRY ?? conf.rootEntry ?? 'api',
         rootSegmentModulesDirName: env.VOVK_ROOT_SEGMENT_MODULES_DIR_NAME ?? conf.rootSegmentModulesDirName ?? '',
-        logLevel: env.VOVK_LOG_LEVEL ?? conf.logLevel ?? 'debug', // TODO: change to 'warn' when v3 is ready
+        logLevel: env.VOVK_LOG_LEVEL ?? conf.logLevel ?? 'info',
         prettifyClient: (env.VOVK_PRETTIFY_CLIENT ? !!env.VOVK_PRETTIFY_CLIENT : null) ?? conf.prettifyClient ?? false,
         devHttps: (env.VOVK_DEV_HTTPS ? !!env.VOVK_DEV_HTTPS : null) ?? conf.devHttps ?? false,
+        generateFrom: typeof conf.generateFrom === 'function'
+            ? conf.generateFrom(defaultClientTemplates)
+            : (conf.generateFrom ?? ['ts', 'module', 'main']),
         templates: {
             service: 'vovk-cli/templates/service.ejs',
             controller: 'vovk-cli/templates/controller.ejs',
-            worker: 'vovk-cli/templates/worker.ejs',
             ...conf.templates,
         },
+        custom: conf.custom ?? {},
     };
+    if (typeof conf.emitConfig === 'undefined') {
+        config.emitConfig = ['custom'];
+    }
+    else if (conf.emitConfig === true) {
+        config.emitConfig = Object.keys(config);
+    }
+    else if (Array.isArray(conf.emitConfig)) {
+        config.emitConfig = conf.emitConfig;
+    } // else it's false and emitConfig already is []
     return { config, srcRoot, configAbsolutePaths, userConfig, error };
 }

package/dist/getProjectInfo/getConfigAbsolutePaths.mjs

@@ -1,5 +1,5 @@
-import fs from 'fs/promises';
-import path from 'path';
+import fs from 'node:fs/promises';
+import path from 'node:path';
 export default async function getConfigAbsolutePaths({ cwd, relativePath, }) {
     const rootDir = path.resolve(cwd, relativePath || '');
     const baseName = 'vovk.config';

package/dist/getProjectInfo/getRelativeSrcRoot.mjs

@@ -1,4 +1,4 @@
-import path from 'path';
+import path from 'node:path';
 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.

package/dist/getProjectInfo/getUserConfig.d.mts

@@ -1,4 +1,4 @@
-import type { VovkConfig } from '../types.mjs';
+import type { VovkConfig } from 'vovk';
 declare function getUserConfig({ cwd, }: {
     cwd: string;
 }): Promise<{

package/dist/getProjectInfo/getUserConfig.mjs

@@ -1,3 +1,4 @@
+import { pathToFileURL } from 'node:url';
 import getConfigAbsolutePaths from './getConfigAbsolutePaths.mjs';
 import importUncachedModule from './importUncachedModule.mjs';
 async function getUserConfig({ cwd, }) {
@@ -14,7 +15,8 @@ async function getUserConfig({ cwd, }) {
     catch {
         try {
             const cacheBuster = Date.now();
-            ({ default: userConfig } = (await import(`${configPath}?cache=${cacheBuster}`)));
+            const configPathUrl = pathToFileURL(configPath).href;
+            ({ default: userConfig } = (await import(`${configPathUrl}?cache=${cacheBuster}`)));
         }
         catch (e) {
             return { userConfig: null, configAbsolutePaths, error: e };

package/dist/getProjectInfo/importUncachedModule.mjs

@@ -3,7 +3,6 @@ import { Worker } from 'node:worker_threads';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import './importUncachedModuleWorker.mjs'; // required for TS compilation
-// TODO comments
 function importUncachedModule(modulePath) {
     return new Promise((resolve, reject) => {
         const __filename = fileURLToPath(import.meta.url);

package/dist/getProjectInfo/importUncachedModuleWorker.mjs

@@ -1,7 +1,6 @@
 import { parentPort, workerData as wData } from 'node:worker_threads';
 import { pathToFileURL } from 'node:url';
 void (async () => {
-    // TODO Comments
     if (!parentPort)
         return;
     const workerData = wData;

package/dist/getProjectInfo/index.d.mts

@@ -6,13 +6,22 @@ export default function getProjectInfo({ port: givenPort, clientOutDir, cwd, }?:
 }): Promise<{
     cwd: string;
     port: string;
-    apiEntryPoint: string;
+    apiRoot: string;
     apiDir: string;
     srcRoot: string;
-    schemaOutImportPath: string;
-    fetcherClientImportPath: string;
-    validateOnClientImportPath: string | null;
-    config: Required<import("../types.mjs").VovkConfig>;
+    config: import("vovk").VovkStrictConfig;
+    clientImports: {
+        fullSchema: string;
+        fetcher: string;
+        createRPC: string;
+        validateOnClient: string | null;
+        module: {
+            fullSchema: string;
+            fetcher: string;
+            createRPC: string;
+            validateOnClient: string | null;
+        };
+    };
     log: {
         info: (msg: string) => void;
         warn: (msg: string) => void;

package/dist/getProjectInfo/index.mjs

@@ -1,4 +1,4 @@
-import path from 'path';
+import path from 'node:path';
 import getConfig from './getConfig.mjs';
 import getLogger from '../utils/getLogger.mjs';
 export default async function getProjectInfo({ port: givenPort, clientOutDir, cwd = process.cwd(), } = {}) {
@@ -6,15 +6,10 @@ export default async function getProjectInfo({ port: givenPort, clientOutDir, cw
     // Make PORT available to the config file at getConfig
     process.env.PORT = port;
     const { config, srcRoot, configAbsolutePaths, userConfig, error } = await getConfig({ clientOutDir, cwd });
-    const apiEntryPoint = `${config.origin ?? ''}/${config.rootEntry}`;
+    const apiRoot = `${config.origin ?? ''}/${config.rootEntry}`;
     const apiDir = path.join(srcRoot, 'app', config.rootEntry);
-    const schemaOutImportPath = path.relative(config.clientOutDir, config.schemaOutDir);
-    const fetcherClientImportPath = config.fetcher.startsWith('.')
-        ? path.relative(config.clientOutDir, config.fetcher)
-        : config.fetcher;
-    const validateOnClientImportPath = config.validateOnClient?.startsWith('.')
-        ? path.relative(config.clientOutDir, config.validateOnClient)
-        : config.validateOnClient;
+    const schemaOutImportPath = path.relative(config.clientOutDir, config.schemaOutDir).replace(/\\/g, '/') + // windows fix
+        '/main.cjs';
     const log = getLogger(config.logLevel);
     if (configAbsolutePaths.length > 1) {
         log.warn(`Multiple config files found. Using the first one: ${configAbsolutePaths[0]}`);
@@ -22,16 +17,29 @@ export default async function getProjectInfo({ port: givenPort, clientOutDir, cw
     if (!userConfig && configAbsolutePaths.length > 0) {
         log.error(`Error reading config file at ${configAbsolutePaths[0]}: ${error?.message ?? 'Unknown Error'}`);
     }
+    const getImportPath = (p) => (p.startsWith('.') ? path.relative(config.clientOutDir, p) : p);
+    const clientImports = {
+        fullSchema: schemaOutImportPath,
+        fetcher: getImportPath(config.fetcherImport[0]),
+        createRPC: getImportPath(config.createRPCImport[0]),
+        validateOnClient: config.validateOnClientImport ? getImportPath(config.validateOnClientImport[0]) : null,
+        module: {
+            fullSchema: schemaOutImportPath,
+            fetcher: getImportPath(config.fetcherImport[1] ?? config.fetcherImport[0]),
+            createRPC: getImportPath(config.createRPCImport[1] ?? config.createRPCImport[0]),
+            validateOnClient: config.validateOnClientImport
+                ? getImportPath(config.validateOnClientImport[1] ?? config.validateOnClientImport[0])
+                : null,
+        },
+    };
     return {
         cwd,
         port,
-        apiEntryPoint,
+        apiRoot,
         apiDir,
         srcRoot,
-        schemaOutImportPath,
-        fetcherClientImportPath,
-        validateOnClientImportPath,
         config,
+        clientImports,
         log,
     };
 }

package/dist/index.d.mts

@@ -1,30 +1,2 @@
 #!/usr/bin/env node
-import { Command } from 'commander';
-import type { LogLevelNames } from 'loglevel';
-import type { VovkConfig, VovkEnv } from './types.mjs';
 import 'dotenv/config';
-export type { VovkConfig, VovkEnv };
-export interface InitOptions {
-    yes?: boolean;
-    logLevel: LogLevelNames;
-    useNpm?: boolean;
-    useYarn?: boolean;
-    usePnpm?: boolean;
-    useBun?: boolean;
-    skipInstall?: boolean;
-    updateTsConfig?: boolean;
-    updateScripts?: 'implicit' | 'explicit';
-    validationLibrary?: string | null;
-    validateOnClient?: boolean;
-    dryRun?: boolean;
-    channel?: 'latest' | 'beta' | 'dev';
-}
-export interface NewOptions {
-    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

@@ -1,51 +1,62 @@
 #!/usr/bin/env node
-import path from 'path';
+import path from 'node:path';
+import { readFileSync } from 'node:fs';
+import { pathToFileURL } from 'node:url';
+import 'dotenv/config';
 import { Command } from 'commander';
-import { readFileSync } from 'fs';
 import concurrently from 'concurrently';
 import getAvailablePort from './utils/getAvailablePort.mjs';
 import getProjectInfo from './getProjectInfo/index.mjs';
-import generateClient from './generateClient.mjs';
+import generate from './generate/index.mjs';
 import locateSegments from './locateSegments.mjs';
-import { VovkCLIWatcher } from './watcher/index.mjs';
-import { Init } from './init/index.mjs';
+import { VovkDev } from './dev/index.mjs';
 import newComponents from './new/index.mjs';
-import 'dotenv/config';
+import initProgram from './initProgram.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);
+initProgram(program.command('init'));
 program
     .command('dev')
-    .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 schema watcher and Next.js with automatic port allocation', false)
-    .allowUnknownOption(true)
-    .action(async (options, command) => {
+    .alias('d')
+    .description('start schema watcher (optional flag --next-dev to start it with Next.js)')
+    .argument('[nextArgs...]', 'extra arguments for the dev command')
+    .option('--next-dev', 'start schema watcher and Next.js with automatic port allocation')
+    .option('--exit', 'kill the processe when schema and client is generated')
+    .action(async (nextArgs, options) => {
+    const { nextDev, exit = false } = options;
     const portAttempts = 30;
-    const PORT = !options.nextDev
+    const PORT = !nextDev
         ? process.env.PORT
         : process.env.PORT ||
-            (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`);
+            (await getAvailablePort(3000, portAttempts, 0, (failedPort, tryingPort) => 
+            // eslint-disable-next-line no-console
+            console.warn(`🐺 Port ${failedPort} is in use, trying ${tryingPort} instead.`)).catch(() => {
+                throw new Error(`🐺 ❌ Failed to find an available port after ${portAttempts} attempts`);
             }));
     if (!PORT) {
         throw new Error('🐺 ❌ PORT env variable is required');
     }
-    if (options.nextDev) {
+    if (nextDev) {
         const { result } = concurrently([
             {
-                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: `npx next dev ${command.args.join(' ')}`,
+                command: `npx next dev ${nextArgs.join(' ')}`,
                 name: 'Next.js Development Server',
                 env: { PORT },
             },
+            {
+                command: `node ${import.meta.dirname}/dev/index.mjs`,
+                name: 'Vovk Dev Watcher',
+                env: {
+                    PORT,
+                    __VOVK_START_WATCHER_IN_STANDALONE_MODE__: 'true',
+                    __VOVK_EXIT__: exit ? 'true' : 'false',
+                },
+            },
         ], {
             killOthers: ['failure', 'success'],
             prefix: 'none',
+            successCondition: 'first',
         });
         try {
             await result;
@@ -55,65 +66,50 @@ program
         }
     }
     else {
-        void new VovkCLIWatcher().start({ clientOutDir: options.clientOut });
+        void new VovkDev().start({ exit });
     }
 });
 program
     .command('generate')
-    .description('Generate client')
-    .option('--client-out <path>', 'Path to output directory')
+    .alias('g')
+    .description('Generate RPC client from schema')
+    .option('--out, --client-out-dir <path>', 'path to output directory')
+    .option('--template, --templates <templates...>', 'client code templates ("ts", "compiled", "python", "none", a custom path)')
+    .option('--emit-full-schema, --full-schema [fileName]', 'generate client with full schema')
+    .option('--prettify', 'prettify output files')
     .action(async (options) => {
-    const projectInfo = await getProjectInfo({ clientOutDir: options.clientOut });
+    const { clientOutDir, templates, prettify, emitFullSchema } = options;
+    const projectInfo = await getProjectInfo({ clientOutDir });
     const { cwd, config, apiDir } = projectInfo;
-    const segments = await locateSegments(apiDir);
+    const segments = await locateSegments({ dir: apiDir, config });
     const schemaOutAbsolutePath = path.join(cwd, config.schemaOutDir);
-    const schema = (await import(path.join(schemaOutAbsolutePath, 'index.js')));
-    await generateClient(projectInfo, segments, schema.default);
+    const schemaImportUrl = pathToFileURL(path.join(schemaOutAbsolutePath, 'main.cjs')).href;
+    const { default: fullSchema } = (await import(schemaImportUrl));
+    await generate({
+        projectInfo,
+        segments,
+        fullSchema,
+        templates,
+        prettify,
+        forceNothingWrittenLog: true,
+        emitFullSchema,
+    });
 });
-// reused at vovk-init
-export function initProgram(p, command) {
-    return p
-        .command(command + '[prefix]')
-        .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));
-}
-initProgram(program, 'init ');
 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')
+    .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, --templates <templates...>', 'override config template; accepts an array of strings that correspond the order of the components')
+    .option('--dir <dirname>', 'override dirName in template file; relative to the root of the project')
+    .option('--empty', 'create an empty module')
+    .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
     .command('help')
     .description('Show help message')
     .action(() => program.help());
-/*
-TODO
-vovk new segment [segmentName]
-vovk new controller service [segmentName/]moduleName
-vovk new c s w [segmentName/]moduleName
-
-vovk c s w userApi/user
-vovk new c s w user
-*/
 program.parse(process.argv);
 if (!process.argv.slice(2).length) {
     program.outputHelp();

package/dist/init/checkTSConfigForExperimentalDecorators.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';
 export default async function checkTSConfigForExperimentalDecorators(root) {
     const tsconfigPath = path.resolve(root, 'tsconfig.json');

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, reactQuery, channel, dryRun }, }: {
     root: string;
     log: ReturnType<typeof getLogger>;
-    dryRun?: boolean;
-    options: Pick<InitOptions, 'validationLibrary' | 'validateOnClient'>;
+    options: Pick<InitOptions, 'validationLibrary' | 'reactQuery' | '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, reactQuery, channel, dryRun }, }) {
     const config = {};
     const dotConfigPath = path.join(root, '.config');
     const dir = (await getFileSystemEntryType(dotConfigPath)) === FileSystemEntryType.DIRECTORY ? dotConfigPath : root;
@@ -14,21 +14,23 @@ export default async function createConfig({ root, log, dryRun, options: { valid
     const templates = {
         controller: 'vovk-cli/templates/controller.ejs',
         service: 'vovk-cli/templates/service.ejs',
-        worker: 'vovk-cli/templates/worker.ejs',
     };
     if (validationLibrary) {
-        config.validationLibrary = validationLibrary;
-        if (validateOnClient) {
-            config.validateOnClient = `${validationLibrary}/validateOnClient`;
-        }
+        config.validateOnClientImport =
+            {
+                'vovk-dto': `vovk-dto/validateOnClient.js`,
+            }[validationLibrary] ?? 'vovk-ajv';
         try {
-            const validationTemplates = await getTemplateFilesFromPackage(validationLibrary);
+            const validationTemplates = await getTemplateFilesFromPackage(validationLibrary, channel);
             Object.assign(templates, validationTemplates);
         }
         catch (error) {
             log.warn(`Failed to fetch validation library templates: ${error.message}`);
         }
     }
+    if (reactQuery) {
+        config.createRPCImport = 'vovk-react-query';
+    }
     config.templates = templates;
     const configStr = await prettify(`/** @type {import('vovk-cli').VovkConfig} */
 const config = ${JSON.stringify(config, null, 2)};

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,14 @@
-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';
+// Crereated with AI
 /**
  * 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;
@@ -37,7 +37,6 @@ function extractTemplatesFromTarball(tarballBuffer) {
         const files = [];
         extract.on('entry', (header, stream, next) => {
             const filePath = header.name;
-            // TODO revisit comments
             // Check if the file is in the 'templates' folder
             if (filePath.startsWith('package/templates/')) {
                 files.push(filePath.replace('package/', ''));