vovk-cli 0.0.1-draft.13 → 0.0.1-draft.131

package/dist/index.mjs

@@ -1,54 +1,61 @@
 #!/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 { VovkCLIWatcher } from './watcher/index.mjs';
-import { Init } from './init/index.mjs';
+import generate from './generate/index.mjs';
+import { VovkDev } from './dev/index.mjs';
 import newComponents from './new/index.mjs';
-import 'dotenv/config';
+import initProgram from './initProgram.mjs';
+import { getFullSchemaFromJSON } from './generate/getFullSchemaFromJSON.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) => 
             // 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');
     }
-    console.log(`TODO:`, command.args);
-    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;
@@ -58,65 +65,48 @@ 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-json [fileName]', 'generate client with full schema')
+    .option('--prettify', 'prettify output files')
+    .option('--config <config>', 'path to config file')
     .action(async (options) => {
-    const projectInfo = await getProjectInfo({ clientOutDir: options.clientOut });
-    const { cwd, config, apiDir } = projectInfo;
-    const segments = await locateSegments(apiDir);
+    const { clientOutDir, templates, prettify, emitFullSchema, config: configPath } = options;
+    const projectInfo = await getProjectInfo({ clientOutDir, configPath });
+    const { cwd, config } = projectInfo;
     const schemaOutAbsolutePath = path.join(cwd, config.schemaOutDir);
-    const schema = (await import(path.join(schemaOutAbsolutePath, 'index.js')));
-    await generateClient(projectInfo, segments, schema.default);
+    const fullSchema = await getFullSchemaFromJSON(schemaOutAbsolutePath, projectInfo);
+    await generate({
+        projectInfo,
+        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, --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')
+    .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/createConfig.d.mts

@@ -1,10 +1,9 @@
 import type getLogger from '../utils/getLogger.mjs';
 import type { InitOptions } from '../types.mjs';
-export default function createConfig({ root, log, dryRun, options: { validationLibrary, validateOnClient }, }: {
+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

@@ -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, dryRun, options: { validationLibrary, validateOnClient }, }) {
+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,25 @@ 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.imports ??= {};
+        config.imports.validateOnClient =
+            {
+                '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.imports ??= {};
+        config.imports.createRPC = '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

@@ -2,13 +2,13 @@ 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.
  * @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/', ''));

package/dist/init/index.d.mts

@@ -4,5 +4,5 @@ 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, reactQuery, dryRun, channel, }: InitOptions): Promise<void>;
 }

package/dist/init/index.mjs

@@ -7,18 +7,19 @@ import getFileSystemEntryType from '../utils/getFileSystemEntryType.mjs';
 import installDependencies, { getPackageManager } from './installDependencies.mjs';
 import getLogger from '../utils/getLogger.mjs';
 import createConfig from './createConfig.mjs';
-import updateNPMScripts from './updateNPMScripts.mjs';
+import updateNPMScripts, { getDevScript } from './updateNPMScripts.mjs';
 import checkTSConfigForExperimentalDecorators from './checkTSConfigForExperimentalDecorators.mjs';
 import updateTypeScriptConfig from './updateTypeScriptConfig.mjs';
 import updateDependenciesWithoutInstalling from './updateDependenciesWithoutInstalling.mjs';
 import logUpdateDependenciesError from './logUpdateDependenciesError.mjs';
 import chalkHighlightThing from '../utils/chalkHighlightThing.mjs';
+import NPMCliPackageJson from '@npmcli/package-json';
 export class Init {
     root;
     log;
-    async #init({ configPaths, }, { useNpm, useYarn, usePnpm, useBun, skipInstall, updateTsConfig, updateScripts, validationLibrary, validateOnClient, dryRun, channel, }) {
+    async #init({ configPaths, pkgJson, }, { useNpm, useYarn, usePnpm, useBun, skipInstall, updateTsConfig, updateScripts, validationLibrary, reactQuery, dryRun, channel, }) {
         const { log, root } = this;
-        const dependencies = ['vovk'];
+        const dependencies = ['vovk', 'vovk-client', 'vovk-openapi'];
         const devDependencies = ['vovk-cli'];
         // delete older config files
         if (configPaths.length) {
@@ -26,17 +27,19 @@ export class Init {
             log.debug(`Deleted existing config file${configPaths.length > 1 ? 's' : ''} at ${configPaths.join(', ')}`);
         }
         if (validationLibrary) {
-            dependencies.push(validationLibrary);
-            dependencies.push(...({
+            dependencies.push(validationLibrary, 'vovk-ajv', ...({
                 'vovk-zod': ['zod'],
                 'vovk-yup': ['yup'],
-                'vovk-dto': ['class-validator', 'class-transformer'],
+                'vovk-dto': ['class-validator', 'class-transformer', 'vovk-mapped-types', 'reflect-metadata'],
             }[validationLibrary] ?? []));
         }
+        if (reactQuery) {
+            dependencies.push('vovk-react-query', '@tanstack/react-query');
+        }
         if (updateScripts) {
             try {
                 if (!dryRun)
-                    await updateNPMScripts(root, updateScripts);
+                    await updateNPMScripts(pkgJson, root, updateScripts);
                 log.info('Updated scripts at package.json');
             }
             catch (error) {
@@ -101,8 +104,7 @@ export class Init {
             const { configAbsolutePath } = await createConfig({
                 root,
                 log,
-                options: { validationLibrary, validateOnClient },
-                dryRun,
+                options: { validationLibrary, reactQuery, channel, dryRun },
             });
             log.info('Config created successfully at ' + configAbsolutePath);
         }
@@ -110,15 +112,16 @@ export class Init {
             log.error(`Failed to create config: ${error.message}`);
         }
     }
-    async main(prefix, { yes, logLevel, useNpm, useYarn, usePnpm, useBun, skipInstall, updateTsConfig, updateScripts, validationLibrary, validateOnClient, dryRun, channel, }) {
+    async main(prefix, { yes, logLevel, useNpm, useYarn, usePnpm, useBun, skipInstall, updateTsConfig, updateScripts, validationLibrary, reactQuery, dryRun, channel, }) {
         const cwd = process.cwd();
         const root = path.resolve(cwd, prefix);
         const log = getLogger(logLevel);
+        const pkgJson = await NPMCliPackageJson.load(root);
         this.root = root;
         this.log = log;
         const configPaths = await getConfigPaths({ cwd, relativePath: prefix });
         if (yes) {
-            return this.#init({ configPaths }, {
+            return this.#init({ configPaths, pkgJson }, {
                 useNpm: useNpm ?? (!useYarn && !usePnpm && !useBun),
                 useYarn: useYarn ?? false,
                 usePnpm: usePnpm ?? false,
@@ -127,7 +130,7 @@ export class Init {
                 updateTsConfig: updateTsConfig ?? true,
                 updateScripts: updateScripts ?? 'implicit',
                 validationLibrary: validationLibrary?.toLocaleLowerCase() === 'none' ? null : (validationLibrary ?? 'vovk-zod'),
-                validateOnClient: validateOnClient ?? true,
+                reactQuery: reactQuery ?? true,
                 dryRun: dryRun ?? false,
                 channel: channel ?? 'latest',
             });
@@ -165,56 +168,54 @@ export class Init {
                             {
                                 name: 'vovk-dto',
                                 value: 'vovk-dto',
-                                description: 'Use class-validator and class-transformer for data validation',
+                                description: 'Use class-validator for data validation. Also installs class-transformer, vovk-mapped-types and reflect-metadata',
                             },
                             { name: 'None', value: null, description: 'Install validation library later' },
                         ],
                     })));
-        if (validationLibrary) {
-            validateOnClient =
-                validateOnClient ??
-                    (await confirm({
-                        message: 'Do you want to enable client validation?',
-                    }));
-        }
         updateScripts =
             updateScripts ??
                 (await select({
-                    message: 'Do you want to update package.json by adding "generate" and "dev" scripts?',
+                    message: 'Do you want to update "dev" NPM script at package.json?',
                     default: 'implicit',
                     choices: [
                         {
                             name: 'Yes, use "concurrently" implicitly',
-                            description: `The "dev" script will use "concurrently" API internally in order to run "next dev" and "vovk dev" together and automatically look for an available port ${chalk.whiteBright.bold(`"vovk dev --next-dev"`)}`,
                             value: 'implicit',
+                            description: `The script will use "concurrently" API to run "next dev" and "vovk dev" commands together and automatically find an available port ${chalk.whiteBright.bold(`"${getDevScript(pkgJson, 'implicit')}"`)}`,
                         },
                         {
                             name: 'Yes, use "concurrently" explicitly',
                             value: 'explicit',
-                            description: `The "dev" script will use pre-defined PORT variable and run "next dev" and "vovk dev" as "concurrently" CLI arguments ${chalk.whiteBright.bold(`"PORT=3000 concurrently 'vovk dev' 'next dev' --kill-others"`)}`,
+                            description: `The script will use pre-defined PORT variable and run "next dev" and "vovk dev" as "concurrently" CLI arguments ${chalk.whiteBright.bold(`"${getDevScript(pkgJson, 'explicit')}"`)}`,
                         },
                         {
                             name: 'No',
                             value: undefined,
-                            description: 'Add the scripts manually',
+                            description: 'Add the NPM scripts manually',
                         },
                     ],
                 }));
+        reactQuery =
+            reactQuery ??
+                (await confirm({
+                    message: 'Do you want to use @tanstack/react-query for data fetching at React components?',
+                }));
         if (typeof updateTsConfig === 'undefined') {
             let shouldAsk = false;
             try {
                 shouldAsk = !(await checkTSConfigForExperimentalDecorators(root));
             }
             catch (error) {
-                log.error(`Failed to check tsconfig.json for experimentalDecorators: ${error.message}`);
+                log.error(`Failed to check tsconfig.json for "experimentalDecorators": ${error.message}`);
             }
             if (shouldAsk) {
                 updateTsConfig = await confirm({
-                    message: 'Do you want to add experimentalDecorators to tsconfig.json?',
+                    message: 'Do you want to add "experimentalDecorators" option to tsconfig.json?',
                 });
             }
         }
-        await this.#init({ configPaths }, {
+        await this.#init({ configPaths, pkgJson }, {
             useNpm: useNpm ?? (!useYarn && !usePnpm && !useBun),
             useYarn: useYarn ?? false,
             usePnpm: usePnpm ?? false,
@@ -223,7 +224,7 @@ export class Init {
             updateTsConfig,
             updateScripts,
             validationLibrary,
-            validateOnClient,
+            reactQuery,
             dryRun,
             channel,
         });

package/dist/init/updateDependenciesWithoutInstalling.mjs

@@ -4,10 +4,8 @@ import chalk from 'chalk';
 import getNPMPackageMetadata from '../utils/getNPMPackageMetadata.mjs';
 async function updateDeps({ packageJson, packageNames, channel, key, }) {
     return Promise.all(packageNames.map(async (packageName) => {
-        if (packageJson[key]?.[packageName])
-            return; // Skip if already present
         const metadata = await getNPMPackageMetadata(packageName);
-        const isVovk = packageName.startsWith('vovk');
+        const isVovk = packageName.startsWith('vovk') && packageName !== 'vovk-mapped-types';
         const latestVersion = metadata['dist-tags'][isVovk ? (channel ?? 'latest') : 'latest'];
         if (!packageJson[key]) {
             packageJson[key] = {};
@@ -23,10 +21,10 @@ export default async function updateDependenciesWithoutInstalling({ log, dir, de
     await fs.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2));
     log.info('Added dependencies to package.json:');
     for (const dependency of dependencyNames) {
-        log.raw.log(` - ${chalk.cyan(dependency)}`);
+        log.raw.info(` - ${chalk.cyan(dependency)}`);
     }
     log.info('Added devDependencies to package.json:');
     for (const dependency of devDependencyNames) {
-        log.raw.log(` - ${chalk.cyan(dependency)}`);
+        log.raw.info(` - ${chalk.cyan(dependency)}`);
     }
 }

package/dist/init/updateNPMScripts.d.mts

@@ -1 +1,3 @@
-export default function updateNPMScripts(root: string, updateScriptsMode: 'implicit' | 'explicit'): Promise<void>;
+import NPMCliPackageJson from '@npmcli/package-json';
+export declare function getDevScript(pkgJson: NPMCliPackageJson, updateScriptsMode: 'implicit' | 'explicit'): string;
+export default function updateNPMScripts(pkgJson: NPMCliPackageJson, root: string, updateScriptsMode: 'implicit' | 'explicit'): Promise<void>;

package/dist/init/updateNPMScripts.mjs

@@ -1,12 +1,15 @@
-import NPMCliPackageJson from '@npmcli/package-json';
-export default async function updateNPMScripts(root, updateScriptsMode) {
-    const pkgJson = await NPMCliPackageJson.load(root);
+export function getDevScript(pkgJson, updateScriptsMode) {
+    const nextDev = pkgJson.content.scripts?.dev ?? 'next dev';
+    const nextDevFlags = nextDev.replace('next dev', '').trim();
+    return updateScriptsMode === 'explicit'
+        ? `PORT=3000 concurrently '${nextDev}' 'vovk dev' --kill-others`
+        : `vovk dev --next-dev${nextDevFlags ? ` -- ${nextDevFlags}` : ''}`;
+}
+export default async function updateNPMScripts(pkgJson, root, updateScriptsMode) {
     pkgJson.update({
         scripts: {
-            generate: 'vovk generate',
-            dev: updateScriptsMode === 'explicit'
-                ? "PORT=3000 concurrently 'vovk dev' 'next dev' --kill-others"
-                : 'vovk dev --next-dev',
+            ...pkgJson.content.scripts,
+            dev: getDevScript(pkgJson, updateScriptsMode),
         },
     });
     await pkgJson.save();

package/dist/initProgram.d.mts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export default function initProgram(program: Command): Command;

package/dist/initProgram.mjs

@@ -0,0 +1,21 @@
+import { Init } from './init/index.mjs';
+// reused at vovk-init
+export default function initProgram(program) {
+    return program
+        .argument('[prefix]', 'directory to initialize project in', '.')
+        .description('Initialize Vovk.ts 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')
+        .option('--react-query', 'use @tanstack/react-query for data fetching inside components')
+        .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));
+}

package/dist/locateSegments.d.mts

@@ -1,5 +1,11 @@
+import type { VovkStrictConfig } from 'vovk';
 export type Segment = {
     routeFilePath: string;
     segmentName: string;
+    segmentImportPath: string;
 };
-export default function locateSegments(dir: string, rootDir?: string): Promise<Segment[]>;
+export default function locateSegments({ dir, rootDir, config, }: {
+    dir: string;
+    rootDir?: string;
+    config: VovkStrictConfig | null;
+}): Promise<Segment[]>;

package/dist/locateSegments.mjs

@@ -1,8 +1,9 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import getFileSystemEntryType from './utils/getFileSystemEntryType.mjs';
-export default async function locateSegments(dir, rootDir = dir) {
+export default async function locateSegments({ dir, rootDir, config, }) {
     let results = [];
+    rootDir = rootDir ?? dir;
     // Read the contents of the directory
     const list = await fs.readdir(dir);
     // Iterate through each item in the directory
@@ -16,12 +17,13 @@ export default async function locateSegments(dir, rootDir = dir) {
                 const routeFilePath = path.join(filePath, 'route.ts');
                 if (await getFileSystemEntryType(routeFilePath)) {
                     // Calculate the basePath relative to the root directory
-                    const segmentName = path.relative(rootDir, dir);
-                    results.push({ routeFilePath, segmentName });
+                    const segmentName = path.relative(rootDir, dir).replace(/\\/g, '/'); // windows fix
+                    const segmentImportPath = path.relative(config?.clientOutDir ?? '.__error', routeFilePath);
+                    results.push({ routeFilePath, segmentName, segmentImportPath });
                 }
             }
             // Recursively search inside subdirectories
-            const subDirResults = await locateSegments(filePath, rootDir);
+            const subDirResults = await locateSegments({ dir: filePath, rootDir, config });
             results = results.concat(subDirResults);
         }
     }

package/dist/new/addClassToSegmentCode.d.mts

@@ -1,6 +1,5 @@
-export default function addClassToSegmentCode(segmentSourceCode: string, { sourceName, compiledName, type, importPath, }: {
+export default function addClassToSegmentCode(segmentSourceCode: string, { sourceName, compiledName, importPath, }: {
     sourceName: string;
     compiledName: string;
-    type: 'worker' | 'controller';
     importPath: string;
 }): string;

package/dist/new/addClassToSegmentCode.mjs

@@ -1,5 +1,5 @@
 import { Project, QuoteKind, SyntaxKind } from 'ts-morph';
-export default function addClassToSegmentCode(segmentSourceCode, { sourceName, compiledName, type, importPath, }) {
+export default function addClassToSegmentCode(segmentSourceCode, { sourceName, compiledName, importPath, }) {
     const project = new Project({
         manipulationSettings: {
             quoteKind: QuoteKind.Single,
@@ -16,8 +16,8 @@ export default function addClassToSegmentCode(segmentSourceCode, { sourceName, c
             moduleSpecifier: importPath,
         });
     }
-    // Get the variable declaration for controllers or workers
-    const variableDeclaration = sourceFile.getVariableDeclaration(`${type}s`);
+    // Get the variable declaration for controllers
+    const variableDeclaration = sourceFile.getVariableDeclaration('controllers');
     if (variableDeclaration) {
         const initializer = variableDeclaration.getInitializer();
         if (initializer && initializer.getKind() === SyntaxKind.ObjectLiteralExpression) {

package/dist/new/addCommonTerms.mjs

@@ -2,6 +2,7 @@ import pluralize from 'pluralize';
 // feel free to open a direct PR if you have more common terms to add
 const terms = [
     ['entity', 'entities'],
+    ['entry', 'entries'],
     ['regex', 'regexes'],
     ['index', 'indices'],
     ['matrix', 'matrices'],

package/dist/new/index.d.mts

@@ -1,2 +1,2 @@
 import type { NewOptions } from '../types.mjs';
-export default function newComponents(components: string[], { dryRun, dir, templates, overwrite, noSegmentUpdate }: NewOptions): Promise<void>;
+export default function newComponents(components: string[], { dryRun, dir, templates, overwrite, noSegmentUpdate, empty }: NewOptions): Promise<void>;

package/dist/new/index.mjs

@@ -1,6 +1,6 @@
 import newModule from './newModule.mjs';
 import newSegment from './newSegment.mjs';
-export default async function newComponents(components, { dryRun, dir, templates, overwrite, noSegmentUpdate }) {
+export default async function newComponents(components, { dryRun, dir, templates, overwrite, noSegmentUpdate, empty }) {
     if (components[0] === 'segment' || components[0] === 'segments') {
         // vovk new segment [segmentName]
         let segmentNames = components
@@ -31,6 +31,7 @@ export default async function newComponents(components, { dryRun, dir, templates
             overwrite,
             noSegmentUpdate,
             dryRun,
+            empty,
         });
     }
 }