vovk-cli 0.0.1-draft.32 → 0.0.1-draft.322

package/dist/getProjectInfo/{importUncachedModule.mjs → getConfig/importUncachedModule.mjs}

@@ -1,14 +1,11 @@
 // importUncachedModule.js
 import { Worker } from 'node:worker_threads';
 import path from 'node:path';
-import { fileURLToPath } from 'node:url';
 import './importUncachedModuleWorker.mjs'; // required for TS compilation
 function importUncachedModule(modulePath) {
     return new Promise((resolve, reject) => {
-        const __filename = fileURLToPath(import.meta.url);
-        const __dirname = path.dirname(__filename);
         // Resolve the path to the worker script
-        const workerPath = path.resolve(__dirname, 'importUncachedModuleWorker.mjs');
+        const workerPath = path.resolve(import.meta.dirname, 'importUncachedModuleWorker.mjs');
         // Initialize the worker thread
         const worker = new Worker(workerPath, {
             workerData: { modulePath },

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;
+        modulesDir?: string;
+        rootEntry?: string;
+        origin?: string;
+        logLevel?: "error" | "trace" | "debug" | "info" | "warn" | (string & {});
+        prettifyClient?: boolean;
+        libs?: {
+            ajv: import("vovk").KnownAny;
+            [key: string]: import("vovk").KnownAny;
+        };
+        devHttps?: boolean;
+        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?: {
+            requires?: Record<string, string>;
+            tsClientOutDir?: string;
+            dontDeleteTsClientOutDirAfter?: boolean;
+            package?: import("type-fest").PackageJson;
+            readme?: {
+                banner?: string;
+            };
+            reExports?: Record<string, string>;
+            tsdownBuildOptions?: Parameters<typeof import("tsdown/config-9hj-APNF.mjs").build>[0];
+        } & ({
+            excludeSegments?: never;
+            includeSegments?: string[];
+        } | {
+            excludeSegments?: string[];
+            includeSegments?: never;
+        });
+        clientTemplateDefs?: Record<string, import("vovk/mjs/types").ClientTemplateDef>;
+        imports?: {
+            fetcher?: string | [string, string] | [string];
+            validateOnClient?: string | [string, string] | [string];
+            createRPC?: string | [string, string] | [string];
+        };
+        rootSegmentModulesDirName?: string;
+        moduleTemplates?: {
+            service?: string;
+            controller?: string;
+            [key: string]: string | undefined;
+        };
+        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,97 @@
+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: {
+            tsClientOutDir: conf.bundle?.tsClientOutDir ?? 'tmp_prebundle',
+            dontDeleteTsClientOutDirAfter: conf.bundle?.dontDeleteTsClientOutDirAfter ?? false,
+            requires: {
+                [BuiltInTemplateName.readme]: '.',
+                [BuiltInTemplateName.packageJson]: '.',
+            },
+            package: {},
+            readme: {},
+            reExports: {},
+            ...conf.bundle,
+            tsdownBuildOptions: {
+                outDir: conf.bundle?.tsdownBuildOptions?.outDir ?? 'dist',
+                ...conf.bundle?.tsdownBuildOptions,
+            },
+        },
+        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 = ['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 'node:path';
-import getConfig from './getConfig.mjs';
-import getLogger from '../utils/getLogger.mjs';
-export default async function getProjectInfo({ port: givenPort, clientOutDir, cwd = process.cwd(), } = {}) {
+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,4 +1,4 @@
 #!/usr/bin/env node
-import type { VovkConfig, VovkDevEnv } from './types.mjs';
 import 'dotenv/config';
-export type { VovkConfig, VovkDevEnv };
+import type { VovkEnv } from './types.mjs';
+export type { VovkEnv };

package/dist/index.mjs

@@ -1,53 +1,66 @@
 #!/usr/bin/env node
 import path from 'node:path';
 import { readFileSync } from 'node:fs';
+import 'dotenv/config';
 import { Command } from 'commander';
 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 { VovkGenerate } from './generate/index.mjs';
+import { bundle } from './bundle/index.mjs';
 import { VovkDev } from './dev/index.mjs';
-import newComponents from './new/index.mjs';
-import 'dotenv/config';
-import initProgram from './initProgram.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('--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)')
+    .option('--https, --dev-https', 'use HTTPS for the dev server (default: false)')
+    .action(async (nextArgs, options) => {
+    const { nextDev, exit = false, schemaOut, devHttps } = 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: `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 Command',
-                env: { PORT, __VOVK_START_WATCHER_IN_STANDALONE_MODE__: 'true' },
+                name: 'Vovk Dev Watcher',
+                env: {
+                    PORT,
+                    __VOVK_START_WATCHER_IN_STANDALONE_MODE__: 'true',
+                    __VOVK_SCHEMA_OUT_FLAG__: schemaOut ?? '',
+                    __VOVK_DEV_HTTPS_FLAG__: devHttps ? 'true' : 'false',
+                    __VOVK_EXIT__: exit ? 'true' : 'false',
+                },
             },
         ], {
-            killOthers: ['failure', 'success'],
+            killOthersOn: ['failure', 'success'],
             prefix: 'none',
+            successCondition: 'first',
         });
         try {
             await result;
@@ -57,31 +70,83 @@ program
         }
     }
     else {
-        void new VovkDev().start();
+        void new VovkDev({ schemaOut, devHttps }).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('--composed-only', 'generate only composed client even if segmented client is enabled')
+    .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('--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 for client generation')
+    .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')
+    .option('--openapi-mixin-name <names...>', 'mixin names corresponding to the index of --openapi option')
+    .option('--openapi-fallback <paths...>', 'save OpenAPI spec and use it as a fallback if URL is not available')
+    .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('--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,
+    });
 });
 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, --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('--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));
+    .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')

package/dist/init/createConfig.d.mts

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

package/dist/init/createConfig.mjs

@@ -3,7 +3,7 @@ import fs from 'node:fs/promises';
 import getTemplateFilesFromPackage from './getTemplateFilesFromPackage.mjs';
 import prettify from '../utils/prettify.mjs';
 import getFileSystemEntryType, { FileSystemEntryType } from '../utils/getFileSystemEntryType.mjs';
-export default async function createConfig({ root, log, options: { validationLibrary, validateOnClient, channel, dryRun }, }) {
+export default async function createConfig({ root, log, options: { validationLibrary, lang, channel, dryRun }, }) {
     const config = {};
     const dotConfigPath = path.join(root, '.config');
     const dir = (await getFileSystemEntryType(dotConfigPath)) === FileSystemEntryType.DIRECTORY ? dotConfigPath : root;
@@ -11,26 +11,28 @@ export default async function createConfig({ root, log, options: { validationLib
         .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, channel);
-            Object.assign(templates, validationTemplates);
+            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];
+    }
+    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)

package/dist/init/getTemplateFilesFromPackage.mjs

@@ -2,7 +2,6 @@ import { Readable } from 'node:stream';
 import { createGunzip } from 'node:zlib';
 import tar from 'tar-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.
@@ -22,8 +21,14 @@ export default async function getTemplateFilesFromPackage(packageName, channel =
     // Extract the tarball in memory and collect template files
     const templateFiles = await extractTemplatesFromTarball(tarballBuffer);
     const entries = templateFiles
-        .filter((fileName) => fileName.startsWith('templates/') && !fileName.endsWith('/') && fileName.endsWith('.ejs'))
-        .map((fileName) => [fileName.substring('templates/'.length).replace(/\.ejs$/, ''), `${packageName}/${fileName}`]);
+        .filter((fileName) => fileName.startsWith('module-templates/') && !fileName.endsWith('/') && fileName.endsWith('.ts.ejs'))
+        .map((fileName) => [
+        fileName
+            .substring('module-templates/'.length)
+            .replace(/\.ts\.ejs$/, '')
+            .toLowerCase(),
+        `${packageName}/${fileName}`,
+    ]);
     return Object.fromEntries(entries);
 }
 /**
@@ -37,8 +42,8 @@ function extractTemplatesFromTarball(tarballBuffer) {
         const files = [];
         extract.on('entry', (header, stream, next) => {
             const filePath = header.name;
-            // Check if the file is in the 'templates' folder
-            if (filePath.startsWith('package/templates/')) {
+            // Check if the file is in the 'module-templates' folder
+            if (filePath.startsWith('package/module-templates/')) {
                 files.push(filePath.replace('package/', ''));
             }
             stream.on('end', () => next());

package/dist/init/index.d.mts

@@ -1,8 +1,8 @@
-import type { InitOptions } from '../types.mjs';
 import getLogger from '../utils/getLogger.mjs';
+import type { InitOptions } from '../types.mjs';
 export declare class Init {
     #private;
     root: string;
     log: ReturnType<typeof getLogger>;
-    main(prefix: string, { yes, logLevel, useNpm, useYarn, usePnpm, useBun, skipInstall, updateTsConfig, updateScripts, validationLibrary, validateOnClient, dryRun, channel, }: InitOptions): Promise<void>;
+    main(prefix: string, { yes, logLevel, useNpm, useYarn, usePnpm, useBun, skipInstall, updateTsConfig, updateScripts, validationLibrary, lang, dryRun, channel, }: InitOptions): Promise<void>;
 }