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

package/dist/getProjectInfo/getConfig/index.d.mts

@@ -0,0 +1,120 @@
+import { VovkSchemaIdEnum, type VovkStrictConfig } from 'vovk';
+export default function getConfig({ configPath, cwd }: {
+    configPath?: string;
+    cwd: string;
+}): Promise<{
+    config: VovkStrictConfig;
+    srcRoot: string | null;
+    configAbsolutePaths: string[];
+    userConfig: {
+        $schema?: typeof VovkSchemaIdEnum.CONFIG | string;
+        emitConfig?: boolean | (keyof VovkStrictConfig | string)[];
+        schemaOutDir?: string;
+        composedClient?: ({
+            enabled?: boolean;
+            outDir?: string;
+            fromTemplates?: string[];
+        } & ({
+            excludeSegments?: never;
+            includeSegments?: string[];
+        } | {
+            excludeSegments?: string[];
+            includeSegments?: never;
+        })) & {
+            package?: import("type-fest").PackageJson;
+            readme?: {
+                banner?: string;
+            };
+        };
+        segmentedClient?: ({
+            enabled?: boolean;
+            outDir?: string;
+            fromTemplates?: string[];
+        } & ({
+            excludeSegments?: never;
+            includeSegments?: string[];
+        } | {
+            excludeSegments?: string[];
+            includeSegments?: never;
+        })) & {
+            packages?: Record<string, import("type-fest").PackageJson>;
+            readmes?: Record<string, {
+                banner?: string;
+            }>;
+        };
+        bundle?: {
+            outDir?: string;
+            requires?: Record<string, string>;
+            tsClientOutDir?: string;
+            dontDeleteTsClientOutDirAfter?: boolean;
+            sourcemap?: boolean;
+            package?: import("type-fest").PackageJson;
+            readme?: {
+                banner?: string;
+            };
+        } & ({
+            excludeSegments?: never;
+            includeSegments?: string[];
+        } | {
+            excludeSegments?: string[];
+            includeSegments?: never;
+        });
+        imports?: {
+            fetcher?: string | [string, string] | [string];
+            validateOnClient?: string | [string, string] | [string];
+            createRPC?: string | [string, string] | [string];
+        };
+        modulesDir?: string;
+        rootEntry?: string;
+        origin?: string;
+        rootSegmentModulesDirName?: string;
+        logLevel?: "error" | "trace" | "debug" | "info" | "warn";
+        prettifyClient?: boolean;
+        devHttps?: boolean;
+        clientTemplateDefs?: Record<string, import("vovk/mjs/types").ClientTemplateDef>;
+        moduleTemplates?: {
+            service?: string;
+            controller?: string;
+            [key: string]: string | undefined;
+        };
+        libs?: {
+            ajv: import("vovk").KnownAny;
+            [key: string]: import("vovk").KnownAny;
+        };
+        segmentConfig?: false | {
+            [x: string]: {
+                origin?: string;
+                rootEntry?: string;
+                segmentNameOverride?: string;
+                reExports?: Record<string, string>;
+            };
+        };
+        openApiMixins?: {
+            [mixinName: string]: {
+                source: {
+                    file: string;
+                } | {
+                    url: string;
+                    fallback?: string;
+                } | {
+                    object: import("openapi3-ts/oas31").OpenAPIObject;
+                };
+                package?: import("type-fest").PackageJson;
+                readme?: {
+                    banner?: string;
+                };
+                apiRoot?: string;
+                getModuleName?: "nestjs-operation-id" | (string & {}) | "api" | import("vovk/mjs/types").GetOpenAPINameFn;
+                getMethodName?: "nestjs-operation-id" | "camel-case-operation-id" | "auto" | import("vovk/mjs/types").GetOpenAPINameFn;
+                errorMessageKey?: string;
+            };
+        };
+    } | null;
+    log: {
+        info: (msg: string) => void;
+        warn: (msg: string) => void;
+        error: (msg: string) => void;
+        debug: (msg: string) => void;
+        raw: import("loglevel").RootLogger;
+    };
+}>;

package/dist/getProjectInfo/getConfig/index.mjs

@@ -0,0 +1,94 @@
+import path from 'node:path';
+import { VovkSchemaIdEnum } from 'vovk';
+import getLogger from '../../utils/getLogger.mjs';
+import getUserConfig from './getUserConfig.mjs';
+import getRelativeSrcRoot from './getRelativeSrcRoot.mjs';
+import getTemplateDefs, { BuiltInTemplateName } from './getTemplateDefs.mjs';
+import { normalizeOpenAPIMixins } from '../../utils/normalizeOpenAPIMixins.mjs';
+import chalkHighlightThing from '../../utils/chalkHighlightThing.mjs';
+export default async function getConfig({ configPath, cwd }) {
+    const { configAbsolutePaths, error, userConfig } = await getUserConfig({
+        configPath,
+        cwd,
+    });
+    const conf = userConfig ?? {};
+    const env = process.env;
+    const clientTemplateDefs = getTemplateDefs(conf.clientTemplateDefs);
+    const srcRoot = await getRelativeSrcRoot({ cwd });
+    const validateOnClientImport = conf.imports?.validateOnClient ?? null;
+    const fetcherImport = conf.imports?.fetcher ?? 'vovk';
+    const createRPCImport = conf.imports?.createRPC ?? 'vovk';
+    const imports = {
+        fetcher: typeof fetcherImport === 'string' ? [fetcherImport] : fetcherImport,
+        validateOnClient: typeof validateOnClientImport === 'string'
+            ? [validateOnClientImport]
+            : (validateOnClientImport ?? null),
+        createRPC: typeof createRPCImport === 'string' ? [createRPCImport] : createRPCImport,
+    };
+    const config = {
+        $schema: VovkSchemaIdEnum.CONFIG,
+        clientTemplateDefs,
+        imports,
+        emitConfig: [],
+        composedClient: {
+            ...conf.composedClient,
+            enabled: conf.composedClient?.enabled ?? true,
+            fromTemplates: conf.composedClient?.fromTemplates ?? ['mjs', 'cjs'],
+            outDir: conf.composedClient?.outDir ?? './node_modules/.vovk-client',
+        },
+        segmentedClient: {
+            ...conf.segmentedClient,
+            enabled: conf.segmentedClient?.enabled ?? false,
+            fromTemplates: conf.segmentedClient?.fromTemplates ?? ['ts'],
+            outDir: conf.segmentedClient?.outDir ?? path.join(srcRoot ?? '.', 'client'),
+        },
+        bundle: {
+            outDir: conf.bundle?.outDir ?? 'dist',
+            tsClientOutDir: conf.bundle?.tsClientOutDir ?? 'tmp_ts_rpc',
+            dontDeleteTsClientOutDirAfter: conf.bundle?.dontDeleteTsClientOutDirAfter ?? false,
+            sourcemap: conf.bundle?.sourcemap ?? false,
+            requires: {
+                [BuiltInTemplateName.readme]: '.',
+                [BuiltInTemplateName.packageJson]: '.',
+            },
+            package: {},
+            readme: {},
+            ...conf.bundle,
+        },
+        modulesDir: conf.modulesDir ?? path.join(srcRoot ?? '.', 'modules'),
+        schemaOutDir: env.VOVK_SCHEMA_OUT_DIR ?? conf.schemaOutDir ?? './.vovk-schema',
+        origin: (env.VOVK_ORIGIN ?? conf.origin ?? '').replace(/\/$/, ''), // Remove trailing slash
+        rootEntry: env.VOVK_ROOT_ENTRY ?? conf.rootEntry ?? 'api',
+        rootSegmentModulesDirName: conf.rootSegmentModulesDirName ?? '',
+        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,
+        moduleTemplates: {
+            service: 'vovk-cli/module-templates/service.ts.ejs',
+            controller: 'vovk-cli/module-templates/controller.ts.ejs',
+            ...conf.moduleTemplates,
+        },
+        libs: conf.libs ?? {},
+        segmentConfig: conf.segmentConfig ?? {},
+        openApiMixins: {},
+    };
+    if (typeof conf.emitConfig === 'undefined') {
+        config.emitConfig = ['$schema', 'libs'];
+    }
+    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 []
+    const log = getLogger(config.logLevel);
+    config.openApiMixins = await normalizeOpenAPIMixins({
+        mixinModules: conf.openApiMixins ?? {},
+        cwd,
+        log,
+    });
+    if (!userConfig) {
+        log.warn(`Unable to load config at ${chalkHighlightThing(cwd)}. Using default values. ${error ?? ''}`);
+    }
+    return { config, srcRoot, configAbsolutePaths, userConfig, log };
+}

package/dist/getProjectInfo/index.d.mts

@@ -1,18 +1,21 @@
 export type ProjectInfo = Awaited<ReturnType<typeof getProjectInfo>>;
-export default function getProjectInfo({ port: givenPort, clientOutDir, cwd, }?: {
+export default function getProjectInfo({ port: givenPort, cwd, configPath, srcRootRequired, }?: {
     port?: number;
-    clientOutDir?: string;
     cwd?: string;
+    configPath?: string;
+    srcRootRequired?: boolean;
 }): Promise<{
     cwd: string;
     port: string;
-    apiEntryPoint: string;
-    apiDir: string;
-    srcRoot: string;
-    schemaOutImportPath: string;
-    fetcherClientImportPath: string;
-    validateOnClientImportPath: string | null;
-    config: Required<import("../types.mjs").VovkConfig>;
+    apiRoot: string;
+    apiDirAbsolutePath: string | null;
+    srcRoot: string | null;
+    vovkCliPackage: {
+        version: string;
+    };
+    config: import("vovk").VovkStrictConfig;
+    packageJson: import("type-fest").PackageJson;
+    isNextInstalled: boolean;
     log: {
         info: (msg: string) => void;
         warn: (msg: string) => void;

package/dist/getProjectInfo/index.mjs

@@ -1,37 +1,36 @@
-import path from 'path';
-import getConfig from './getConfig.mjs';
-import getLogger from '../utils/getLogger.mjs';
-export default async function getProjectInfo({ port: givenPort, clientOutDir, cwd = process.cwd(), } = {}) {
+import path from 'node:path';
+import getConfig from './getConfig/index.mjs';
+import { getPackageJson } from '../utils/getPackageJson.mjs';
+import { readFile } from 'node:fs/promises';
+export default async function getProjectInfo({ port: givenPort, cwd = process.cwd(), configPath, srcRootRequired = true, } = {}) {
     const port = givenPort?.toString() ?? process.env.PORT ?? '3000';
     // 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 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 log = getLogger(config.logLevel);
+    const { config, srcRoot, configAbsolutePaths, log } = await getConfig({
+        configPath,
+        cwd,
+    });
+    const packageJson = await getPackageJson(cwd, log);
+    const isNextInstalled = !!packageJson?.dependencies?.next || !!packageJson?.devDependencies?.next;
+    if (srcRootRequired && !srcRoot) {
+        throw new Error(`Could not find app router directory at ${cwd}. Check Next.js docs for more info.`);
+    }
+    const apiRoot = `${config.origin ?? ''}/${config.rootEntry}`;
+    const apiDirAbsolutePath = srcRoot ? path.resolve(cwd, srcRoot, 'app', config.rootEntry) : null;
     if (configAbsolutePaths.length > 1) {
         log.warn(`Multiple config files found. Using the first one: ${configAbsolutePaths[0]}`);
     }
-    if (!userConfig && configAbsolutePaths.length > 0) {
-        log.error(`Error reading config file at ${configAbsolutePaths[0]}: ${error?.message ?? 'Unknown Error'}`);
-    }
+    const vovkCliPackage = JSON.parse(await readFile(path.join(import.meta.dirname, '../../package.json'), 'utf-8'));
     return {
         cwd,
         port,
-        apiEntryPoint,
-        apiDir,
+        apiRoot,
+        apiDirAbsolutePath,
         srcRoot,
-        schemaOutImportPath,
-        fetcherClientImportPath,
-        validateOnClientImportPath,
+        vovkCliPackage,
         config,
+        packageJson,
+        isNextInstalled,
         log,
     };
 }

package/dist/index.d.mts

@@ -1,26 +1,4 @@
 #!/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;
-}
-declare const program: Command;
-export declare function initProgram(p: typeof program, command: string): Command;
+import type { VovkEnv } from './types.mjs';
+export type { VovkEnv };

package/dist/index.mjs

@@ -1,53 +1,64 @@
 #!/usr/bin/env node
-import path from 'path';
+import path from 'node:path';
+import { readFileSync } from 'node:fs';
+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 locateSegments from './locateSegments.mjs';
-import { VovkCLIWatcher } from './watcher/index.mjs';
-import { Init } from './init/index.mjs';
-import newComponents from './new/index.mjs';
-import 'dotenv/config';
+import { VovkGenerate } from './generate/index.mjs';
+import { bundle } from './bundle/index.mjs';
+import { VovkDev } from './dev/index.mjs';
+import { newComponents } from './new/index.mjs';
+import { initProgram } from './initProgram.mjs';
+import { getProjectFullSchema } from './generate/getProjectFullSchema.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);
+const vovkCliPackage = JSON.parse(readFileSync(path.join(import.meta.dirname, '../package.json'), 'utf-8'));
+program.name('vovk').description('Vovk CLI').version(vovkCliPackage.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')
+    .option('--schema-out <path>', 'path to schema output directory (default: .vovk-schema)')
+    .action(async (nextArgs, options) => {
+    const { nextDev, exit = false, schemaOut } = options;
     const portAttempts = 30;
-    const PORT = !options.nextDev
+    const PORT = !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(() => {
-                throw new Error(`🐺 ❌ Failed to find available Next port after ${portAttempts} attempts`);
+            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_SCHEMA_OUT_FLAG__: schemaOut ?? '',
+                    __VOVK_EXIT__: exit ? 'true' : 'false',
+                },
+            },
         ], {
-            killOthers: ['failure', 'success'],
+            killOthersOn: ['failure', 'success'],
             prefix: 'none',
+            successCondition: 'first',
         });
         try {
             await result;
@@ -57,61 +68,87 @@ program
         }
     }
     else {
-        void new VovkCLIWatcher().start({ clientOutDir: options.clientOut });
+        void new VovkDev({ schemaOut }).start({ exit });
     }
 });
 program
     .command('generate')
-    .description('Generate client')
-    .option('--client-out <path>', 'Path to output directory')
-    .action(async (options) => {
-    const projectInfo = await getProjectInfo({ clientOutDir: options.clientOut });
-    const { cwd, config, apiDir } = projectInfo;
-    const segments = await locateSegments(apiDir);
-    const schemaOutAbsolutePath = path.join(cwd, config.schemaOutDir);
-    const schema = (await import(path.join(schemaOutAbsolutePath, 'index.js')));
-    await generateClient(projectInfo, segments, schema.default);
+    .alias('g')
+    .description('generate RPC client from schema')
+    .option('--out, --composed-out <path>', 'path to output directory for composed client')
+    .option('--from, --composed-from <templates...>', 'client template names for composed client')
+    .option('--include, --composed-include-segments <segments...>', 'include segments in composed client')
+    .option('--exclude, --composed-exclude-segments <segments...>', 'exclude segments in composed client')
+    .option('--composed-only', 'generate only composed client even if segmented client is enabled')
+    .option('--segmented-only', 'generate only segmented client even if composed client is enabled')
+    .option('--segmented-out <path>', 'path to output directory for segmented client')
+    .option('--segmented-from <templates...>', 'client template names for segmented client')
+    .option('--segmented-include-segments <segments...>', 'include segments in segmented client')
+    .option('--segmented-exclude-segments <segments...>', 'exclude segments in segmented client')
+    .option('--prettify', 'prettify output files')
+    .option('--schema, --schema-path <path>', 'path to schema folder (default: ./.vovk-schema)')
+    .option('--config, --config-path <config>', 'path to config file')
+    .option('--force-ts-standalone', 'force TypeScript standalone mode (Next.js environment will be ignored, by default it\'s "true" for non-Next.js directories)')
+    .option('--watch <s>', 'watch for changes in schema or openapi spec and regenerate client; accepts a number in seconds to throttle the watcher or make an HTTP request to the OpenAPI spec URL')
+    .option('--openapi, --openapi-spec <openapi_path_or_urls...>', 'use OpenAPI schema instead of Vovk schema')
+    .option('--openapi-get-module-name <names...>', 'module names corresponding to the index of --openapi option')
+    .option('--openapi-get-method-name <names...>', 'method names corresponding to the index of --openapi option')
+    .option('--openapi-root-url <urls...>', 'root URLs corresponding to the index of --openapi option')
+    .action(async (cliGenerateOptions) => {
+    const projectInfo = await getProjectInfo({ configPath: cliGenerateOptions.configPath, srcRootRequired: false });
+    await new VovkGenerate({
+        projectInfo,
+        forceNothingWrittenLog: true,
+        cliGenerateOptions,
+    }).start();
+});
+program
+    .command('bundle')
+    .alias('b')
+    .description('generate TypeScrtipt RPC and bundle it')
+    .option('--out, --out-dir <path>', 'path to output directory for bundle')
+    .option('--include, --include-segments <segments...>', 'include segments')
+    .option('--exclude, --exclude-segments <segments...>', 'exclude segments')
+    .option('--ts-client-out-dir <path>', 'path to output directory for TypeScript client')
+    .option('--dont-delete-ts-client-out-dir-after', 'do not delete TypeScript client output directory after bundling')
+    .option('--config <config>', 'path to config file')
+    .option('--schema <path>', 'path to schema folder (default: .vovk-schema)')
+    .option('--sourcemap', 'generate sourcemaps')
+    .option('--force-ts-standalone', 'force TypeScript standalone mode (Next.js environment will be ignored, by default it\'s "true" for non-Next.js directories)')
+    .option('--openapi, --openapi-spec <openapi_path_or_urls...>', 'use OpenAPI schema instead of Vovk schema')
+    .option('--openapi-get-module-name <names...>', 'module names corresponding to the index of --openapi option')
+    .option('--openapi-get-method-name <names...>', 'method names corresponding to the index of --openapi option')
+    .option('--openapi-root-url <urls...>', 'root URLs corresponding to the index of --openapi option')
+    .action(async (cliBundleOptions) => {
+    const projectInfo = await getProjectInfo({ configPath: cliBundleOptions.config, srcRootRequired: false });
+    const { cwd, config, log, isNextInstalled } = projectInfo;
+    const fullSchema = await getProjectFullSchema({
+        schemaOutAbsolutePath: path.resolve(cwd, cliBundleOptions?.schema ?? config.schemaOutDir),
+        log,
+        isNextInstalled,
+    });
+    await bundle({
+        projectInfo,
+        fullSchema,
+        cliBundleOptions,
+    });
 });
-// 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('--dry-run', 'Do not write files to disk')
-        .option('--channel <channel>', 'Channel to use for fetching packages', 'latest')
-        .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('--dry-run', 'Do not write files to disk')
-    .action((components, options) => newComponents(components, options));
+    .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')
+    .option('--static', 'if the segment is static')
+    .action((components, newOptions) => newComponents(components, newOptions));
 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, lang, channel, dryRun }, }: {
     root: string;
     log: ReturnType<typeof getLogger>;
-    dryRun?: boolean;
-    options: Pick<InitOptions, 'validationLibrary' | 'validateOnClient'>;
+    options: Pick<InitOptions, 'validationLibrary' | 'reactQuery' | 'lang' | '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, lang, channel, dryRun }, }) {
     const config = {};
     const dotConfigPath = path.join(root, '.config');
     const dir = (await getFileSystemEntryType(dotConfigPath)) === FileSystemEntryType.DIRECTORY ? dotConfigPath : root;
@@ -11,26 +11,32 @@ export default async function createConfig({ root, log, dryRun, options: { valid
         .readFile(path.join(root, 'package.json'), 'utf-8')
         .then((content) => JSON.parse(content).type === 'module');
     const configAbsolutePath = path.join(dir, isModule ? 'vovk.config.mjs' : 'vovk.config.js');
-    const templates = {
-        controller: 'vovk-cli/templates/controller.ejs',
-        service: 'vovk-cli/templates/service.ejs',
-        worker: 'vovk-cli/templates/worker.ejs',
+    const moduleTemplates = {
+        controller: 'vovk-cli/module-templates/controller.ts.ejs',
+        service: 'vovk-cli/module-templates/service.ts.ejs',
     };
+    config.imports ??= {};
+    config.imports.validateOnClient = validationLibrary === 'vovk-dto' ? 'vovk-dto/validateOnClient' : 'vovk-ajv';
     if (validationLibrary) {
-        config.validationLibrary = validationLibrary;
-        if (validateOnClient) {
-            config.validateOnClient = `${validationLibrary}/validateOnClient`;
-        }
         try {
-            const validationTemplates = await getTemplateFilesFromPackage(validationLibrary);
-            Object.assign(templates, validationTemplates);
+            const validationTemplates = await getTemplateFilesFromPackage(validationLibrary, channel);
+            Object.assign(moduleTemplates, validationTemplates);
         }
         catch (error) {
             log.warn(`Failed to fetch validation library templates: ${error.message}`);
         }
     }
-    config.templates = templates;
-    const configStr = await prettify(`/** @type {import('vovk-cli').VovkConfig} */
+    if (lang?.length) {
+        config.composedClient ??= {};
+        config.composedClient.fromTemplates = ['mjs', 'cjs', ...lang];
+    }
+    if (reactQuery) {
+        config.imports ??= {};
+        config.imports.createRPC = 'vovk-react-query';
+    }
+    config.moduleTemplates = moduleTemplates;
+    const configStr = await prettify(`// @ts-check
+/** @type {import('vovk').VovkConfig} */
 const config = ${JSON.stringify(config, null, 2)};
 ${isModule ? '\nexport default config;' : 'module.exports = config;'}`, configAbsolutePath);
     if (!dryRun)