vovk-cli 0.0.1-draft.2 → 0.0.1-draft.20

package/README.md

@@ -1 +1 @@
-Description is coming soon.
+Description is coming soon.

package/dist/{watcher → dev}/diffSchema.d.mts

@@ -1,5 +1,5 @@
 import type { VovkSchema } from 'vovk';
-import { _VovkControllerSchema, _VovkWorkerSchema } from 'vovk/types';
+import type { _VovkControllerSchema, _VovkWorkerSchema } from 'vovk/types';
 interface HandlersDiff {
     nameOfClass: string;
     added: string[];

package/dist/dev/ensureClient.d.mts

@@ -0,0 +1,5 @@
+import type { ProjectInfo } from '../getProjectInfo/index.mjs';
+export default function ensureClient(projectInfo: ProjectInfo): Promise<{
+    written: boolean;
+    path: string;
+}>;

package/dist/dev/ensureClient.mjs

@@ -0,0 +1,31 @@
+import path from 'node:path';
+import fs from 'node:fs/promises';
+export default async function ensureClient(projectInfo) {
+    const { config, cwd, log } = projectInfo;
+    const now = Date.now();
+    const clientoOutDirAbsolutePath = path.join(cwd, config.clientOutDir);
+    const dts = `// auto-generated
+// This is a temporary placeholder to avoid errors if client is imported before it's generated.
+// If you still see this text, the client is not generated yet because of an unknown problem.
+// Feel free to report an issue at https://github.com/finom/vovk/issues`;
+    const js = dts;
+    const ts = dts;
+    const localJsAbsolutePath = path.join(clientoOutDirAbsolutePath, 'client.js');
+    const localDtsAbsolutePath = path.join(clientoOutDirAbsolutePath, 'client.d.ts');
+    const localTsAbsolutePath = path.join(clientoOutDirAbsolutePath, 'index.ts');
+    const existingJs = await fs.readFile(localJsAbsolutePath, 'utf-8').catch(() => null);
+    const existingDts = await fs.readFile(localDtsAbsolutePath, 'utf-8').catch(() => null);
+    const existingTs = await fs.readFile(localTsAbsolutePath, 'utf-8').catch(() => null);
+    if (existingJs && existingDts && existingTs) {
+        return { written: false, path: clientoOutDirAbsolutePath };
+    }
+    await fs.mkdir(clientoOutDirAbsolutePath, { recursive: true });
+    if (!existingJs)
+        await fs.writeFile(localJsAbsolutePath, js);
+    if (!existingDts)
+        await fs.writeFile(localDtsAbsolutePath, dts);
+    if (!existingTs)
+        await fs.writeFile(localTsAbsolutePath, ts);
+    log.info(`Empty client files are generated in ${Date.now() - now}ms`);
+    return { written: true, path: clientoOutDirAbsolutePath };
+}

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

@@ -1,5 +1,5 @@
-import fs from 'fs/promises';
-import path from 'path';
+import fs from 'node:fs/promises';
+import path from 'node:path';
 import debounce from 'lodash/debounce.js';
 import writeOneSchemaFile, { ROOT_SEGMENT_SCHEMA_NAME } from './writeOneSchemaFile.mjs';
 import formatLoggedSegmentName from '../utils/formatLoggedSegmentName.mjs';
@@ -7,17 +7,29 @@ export default async function ensureSchemaFiles(projectInfo, schemaOutAbsolutePa
     const now = Date.now();
     let hasChanged = false;
     // Create index.js file
-    const indexContent = segmentNames
+    const indexContent = `// auto-generated
+${segmentNames
         .map((segmentName) => {
         return `module.exports['${segmentName}'] = require('./${segmentName || ROOT_SEGMENT_SCHEMA_NAME}.json');`;
     })
-        .join('\n');
-    const dTsContent = `import type { VovkSchema } from 'vovk';
-declare const segmentSchema: Record<string, VovkSchema>;
+        .join('\n')}`;
+    const dTsContent = `// auto-generated
+import type { VovkSchema } from 'vovk';
+declare const segmentSchema: {
+${segmentNames.map((segmentName) => `  '${segmentName}': VovkSchema;`).join('\n')}
+};
 export default segmentSchema;`;
+    const jsAbsolutePath = path.join(schemaOutAbsolutePath, 'index.js');
+    const dTsAbsolutePath = path.join(schemaOutAbsolutePath, 'index.d.ts');
+    const existingJs = await fs.readFile(jsAbsolutePath, 'utf-8').catch(() => null);
+    const existingDTs = await fs.readFile(dTsAbsolutePath, 'utf-8').catch(() => null);
     await fs.mkdir(schemaOutAbsolutePath, { recursive: true });
-    await fs.writeFile(path.join(schemaOutAbsolutePath, 'index.js'), indexContent);
-    await fs.writeFile(path.join(schemaOutAbsolutePath, 'index.d.ts'), dTsContent);
+    if (existingJs !== indexContent) {
+        await fs.writeFile(jsAbsolutePath, indexContent);
+    }
+    if (existingDTs !== dTsContent) {
+        await fs.writeFile(dTsAbsolutePath, dTsContent);
+    }
     // Create JSON files (if not exist) with name [segmentName].json (where segmentName can include /, which means the folder structure can be nested)
     await Promise.all(segmentNames.map(async (segmentName) => {
         const { isCreated } = await writeOneSchemaFile({

package/dist/{watcher → dev}/index.d.mts

@@ -1,4 +1,4 @@
-export declare class VovkCLIWatcher {
+export declare class VovkDev {
     #private;
     start({ clientOutDir }?: {
         clientOutDir?: string;

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

@@ -1,20 +1,21 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
 import * as chokidar from 'chokidar';
-import fs from 'fs/promises';
-import getProjectInfo from '../getProjectInfo/index.mjs';
-import path from 'path';
+import { Agent, setGlobalDispatcher } from 'undici';
+import keyBy from 'lodash/keyBy.js';
+import capitalize from 'lodash/capitalize.js';
+import debounce from 'lodash/debounce.js';
+import isEmpty from 'lodash/isEmpty.js';
 import { debouncedEnsureSchemaFiles } from './ensureSchemaFiles.mjs';
 import writeOneSchemaFile from './writeOneSchemaFile.mjs';
 import logDiffResult from './logDiffResult.mjs';
+import ensureClient from './ensureClient.mjs';
+import getProjectInfo from '../getProjectInfo/index.mjs';
 import generateClient from '../generateClient.mjs';
 import locateSegments from '../locateSegments.mjs';
 import debounceWithArgs from '../utils/debounceWithArgs.mjs';
-import debounce from 'lodash/debounce.js';
-import isEmpty from 'lodash/isEmpty.js';
 import formatLoggedSegmentName from '../utils/formatLoggedSegmentName.mjs';
-import keyBy from 'lodash/keyBy.js';
-import capitalize from 'lodash/capitalize.js';
-import { Agent, setGlobalDispatcher } from 'undici';
-export class VovkCLIWatcher {
+export class VovkDev {
     #projectInfo;
     #segments = [];
     #schemas = {};
@@ -27,7 +28,7 @@ export class VovkCLIWatcher {
         const schemaOutAbsolutePath = path.join(cwd, config.schemaOutDir);
         const apiDirAbsolutePath = path.join(cwd, apiDir);
         const getSegmentName = (filePath) => path.relative(apiDirAbsolutePath, filePath).replace(segmentReg, '');
-        log.debug(`Watching segments in ${apiDirAbsolutePath}`);
+        log.debug(`Watching segments at ${apiDirAbsolutePath}`);
         this.#segmentWatcher = chokidar
             .watch(apiDirAbsolutePath, {
             persistent: true,
@@ -51,7 +52,6 @@ export class VovkCLIWatcher {
                 void this.#requestSchema(getSegmentName(filePath));
             }
         })
-            // eslint-disable-next-line @typescript-eslint/no-misused-promises
             .on('addDir', async (dirPath) => {
             log.debug(`Directory ${dirPath} has been added to segments folder`);
             this.#segments = await locateSegments(apiDirAbsolutePath);
@@ -59,7 +59,6 @@ export class VovkCLIWatcher {
                 void this.#requestSchema(segmentName);
             }
         })
-            // eslint-disable-next-line @typescript-eslint/no-misused-promises
             .on('unlinkDir', async (dirPath) => {
             log.debug(`Directory ${dirPath} has been removed from segments folder`);
             this.#segments = await locateSegments(apiDirAbsolutePath);
@@ -81,13 +80,13 @@ export class VovkCLIWatcher {
             log.debug('Segments watcher is ready');
         })
             .on('error', (error) => {
-            log.error(`Error watching segments folder: ${error.message}`);
+            log.error(`Error watching segments folder: ${error?.message ?? 'Unknown error'}`);
         });
     };
     #watchModules = () => {
         const { config, cwd, log } = this.#projectInfo;
         const modulesDirAbsolutePath = path.join(cwd, config.modulesDir);
-        log.debug(`Watching modules in ${modulesDirAbsolutePath}`);
+        log.debug(`Watching modules at ${modulesDirAbsolutePath}`);
         const processControllerChange = debounceWithArgs(this.#processControllerChange, 500);
         this.#modulesWatcher = chokidar
             .watch(modulesDirAbsolutePath, {
@@ -119,13 +118,14 @@ export class VovkCLIWatcher {
             log.debug('Modules watcher is ready');
         })
             .on('error', (error) => {
-            log.error(`Error watching modules folder: ${error.message}`);
+            log.error(`Error watching modules folder: ${error?.message ?? 'Unknown error'}`);
         });
     };
     #watchConfig = () => {
         const { log, cwd } = this.#projectInfo;
         log.debug(`Watching config files`);
         let isInitial = true;
+        let isReady = false;
         const handle = debounce(async () => {
             this.#projectInfo = await getProjectInfo();
             if (!isInitial) {
@@ -148,18 +148,21 @@ export class VovkCLIWatcher {
             .on('change', () => void handle())
             .on('unlink', () => void handle())
             .on('ready', () => {
+            if (isReady)
+                return;
+            // for some reason this watcher triggers ready event twice
             log.debug('Config files watcher is ready');
+            isReady = true;
         })
-            .on('error', (error) => {
-            log.error(`Error watching config files: ${error.message}`);
-        });
+            .on('error', (error) => log.error(`Error watching config files: ${error?.message ?? 'Unknown error'}`));
         void handle();
     };
-    #watch() {
+    async #watch() {
         if (this.#isWatching)
             throw new Error('Already watching');
         const { log } = this.#projectInfo;
         log.debug(`Starting segments and modules watcher. Detected initial segments: ${JSON.stringify(this.#segments.map((s) => s.segmentName))}.`);
+        await ensureClient(this.#projectInfo);
         // automatically watches segments and modules
         this.#watchConfig();
     }
@@ -275,16 +278,16 @@ export class VovkCLIWatcher {
         const schemaOutAbsolutePath = path.join(cwd, config.schemaOutDir);
         this.#segments = await locateSegments(apiDirAbsolutePath);
         await debouncedEnsureSchemaFiles(this.#projectInfo, schemaOutAbsolutePath, this.#segments.map((s) => s.segmentName));
-        // Request schema every segment in 3 seconds in order to update schema and start watching
+        // Request schema every segment in 5 seconds in order to update schema and start watching
         setTimeout(() => {
             for (const { segmentName } of this.#segments) {
                 void this.#requestSchema(segmentName);
             }
             this.#watch();
-        }, 3000);
+        }, 5000);
     }
 }
 const env = process.env;
 if (env.__VOVK_START_WATCHER_IN_STANDALONE_MODE__ === 'true') {
-    void new VovkCLIWatcher().start();
+    void new VovkDev().start();
 }

package/dist/{watcher → dev}/logDiffResult.d.mts

@@ -1,3 +1,3 @@
-import { ProjectInfo } from '../getProjectInfo/index.mjs';
-import { DiffResult } from './diffSchema.mjs';
+import type { DiffResult } from './diffSchema.mjs';
+import type { ProjectInfo } from '../getProjectInfo/index.mjs';
 export default function logDiffResult(segmentName: string, diffResult: DiffResult, projectInfo: ProjectInfo): void;

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

@@ -1,3 +1,4 @@
+import chalk from 'chalk';
 import formatLoggedSegmentName from '../utils/formatLoggedSegmentName.mjs';
 import chalkHighlightThing from '../utils/chalkHighlightThing.mjs';
 export default function logDiffResult(segmentName, diffResult, projectInfo) {
@@ -37,48 +38,51 @@ export default function logDiffResult(segmentName, diffResult, projectInfo) {
         });
     });
     const LIMIT = diffNormalized.length < 12 ? diffNormalized.length : 10;
+    const addedText = chalk.green('added');
+    const removedText = chalk.red('removed');
+    const changedText = chalk.cyan('changed');
     for (const diffNormalizedItem of diffNormalized.slice(0, LIMIT)) {
         switch (diffNormalizedItem.what) {
             case 'worker':
                 switch (diffNormalizedItem.type) {
                     case 'added':
-                        projectInfo.log.info(`Schema for worker ${chalkHighlightThing(diffNormalizedItem.name)} has been added at ${formatLoggedSegmentName(segmentName)}`);
+                        projectInfo.log.info(`Schema for worker ${chalkHighlightThing(diffNormalizedItem.name)} has been ${addedText} at ${formatLoggedSegmentName(segmentName)}`);
                         break;
                     case 'removed':
-                        projectInfo.log.info(`Schema for worker ${chalkHighlightThing(diffNormalizedItem.name)} has been removed from ${formatLoggedSegmentName(segmentName)}`);
+                        projectInfo.log.info(`Schema for worker ${chalkHighlightThing(diffNormalizedItem.name)} has been ${removedText} from ${formatLoggedSegmentName(segmentName)}`);
                         break;
                 }
                 break;
             case 'controller':
                 switch (diffNormalizedItem.type) {
                     case 'added':
-                        projectInfo.log.info(`Schema for controller ${chalkHighlightThing(diffNormalizedItem.name)} has been added at ${formatLoggedSegmentName(segmentName)}`);
+                        projectInfo.log.info(`Schema for controller ${chalkHighlightThing(diffNormalizedItem.name)} has been ${addedText} at ${formatLoggedSegmentName(segmentName)}`);
                         break;
                     case 'removed':
-                        projectInfo.log.info(`Schema for controller ${chalkHighlightThing(diffNormalizedItem.name)} has been removed from ${formatLoggedSegmentName(segmentName)}`);
+                        projectInfo.log.info(`Schema for controller ${chalkHighlightThing(diffNormalizedItem.name)} has been ${removedText} from ${formatLoggedSegmentName(segmentName)}`);
                         break;
                 }
                 break;
             case 'workerHandler':
                 switch (diffNormalizedItem.type) {
                     case 'added':
-                        projectInfo.log.info(`Schema for worker method ${chalkHighlightThing(diffNormalizedItem.name)} has been added at ${formatLoggedSegmentName(segmentName)}`);
+                        projectInfo.log.info(`Schema for worker method ${chalkHighlightThing(diffNormalizedItem.name)} has been ${addedText} at ${formatLoggedSegmentName(segmentName)}`);
                         break;
                     case 'removed':
-                        projectInfo.log.info(`Schema for worker method ${chalkHighlightThing(diffNormalizedItem.name)} has been removed from ${formatLoggedSegmentName(segmentName)}`);
+                        projectInfo.log.info(`Schema for worker method ${chalkHighlightThing(diffNormalizedItem.name)} has been ${removedText} from ${formatLoggedSegmentName(segmentName)}`);
                         break;
                 }
                 break;
             case 'controllerHandler':
                 switch (diffNormalizedItem.type) {
                     case 'added':
-                        projectInfo.log.info(`Schema for controller method ${chalkHighlightThing(diffNormalizedItem.name)} has been added at ${formatLoggedSegmentName(segmentName)}`);
+                        projectInfo.log.info(`Schema for controller method ${chalkHighlightThing(diffNormalizedItem.name)} has been ${addedText} at ${formatLoggedSegmentName(segmentName)}`);
                         break;
                     case 'removed':
-                        projectInfo.log.info(`Schema for controller method ${chalkHighlightThing(diffNormalizedItem.name)} has been removed from ${formatLoggedSegmentName(segmentName)}`);
+                        projectInfo.log.info(`Schema for controller method ${chalkHighlightThing(diffNormalizedItem.name)} has been ${removedText} from ${formatLoggedSegmentName(segmentName)}`);
                         break;
                     case 'changed':
-                        projectInfo.log.info(`Schema for controller method ${chalkHighlightThing(diffNormalizedItem.name)} has been changed at ${formatLoggedSegmentName(segmentName)}`);
+                        projectInfo.log.info(`Schema for controller method ${chalkHighlightThing(diffNormalizedItem.name)} has been ${changedText} at ${formatLoggedSegmentName(segmentName)}`);
                         break;
                 }
                 break;

package/dist/{watcher → dev}/writeOneSchemaFile.d.mts

@@ -1,5 +1,5 @@
 import type { VovkSchema } from 'vovk';
-import { DiffResult } from './diffSchema.mjs';
+import { type DiffResult } from './diffSchema.mjs';
 export declare const ROOT_SEGMENT_SCHEMA_NAME = "_root";
 export default function writeOneSchemaFile({ schemaOutAbsolutePath, schema, skipIfExists, }: {
     schemaOutAbsolutePath: string;

package/dist/{watcher → dev}/writeOneSchemaFile.mjs

@@ -1,10 +1,11 @@
-import path from 'path';
-import fs from 'fs/promises';
+import path from 'node:path';
+import fs from 'node:fs/promises';
 import diffSchema from './diffSchema.mjs';
+import getFileSystemEntryType from '../utils/getFileSystemEntryType.mjs';
 export const ROOT_SEGMENT_SCHEMA_NAME = '_root';
 export default async function writeOneSchemaFile({ schemaOutAbsolutePath, schema, skipIfExists = false, }) {
     const segmentPath = path.join(schemaOutAbsolutePath, `${schema.segmentName || ROOT_SEGMENT_SCHEMA_NAME}.json`);
-    if (skipIfExists) {
+    if (skipIfExists && (await getFileSystemEntryType(segmentPath))) {
         try {
             await fs.stat(segmentPath);
             return { isCreated: false, diffResult: null };

package/dist/generateClient.d.mts

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

package/dist/generateClient.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 formatLoggedSegmentName from './utils/formatLoggedSegmentName.mjs';
 import prettify from './utils/prettify.mjs';
 export default async function generateClient(projectInfo, segments, segmentsSchema) {
@@ -48,11 +48,11 @@ type Options = typeof fetcher extends VovkClientFetcher<infer U> ? U : never;
     ts += `
 ${validateOnClientImportPath ? `import validateOnClient from '${validateOnClientImportPath}';\n` : '\nconst validateOnClient = undefined;'}
 type Options = typeof fetcher extends VovkClientFetcher<infer U> ? U : never;
-const prefix = '${apiEntryPoint}';
+const apiRoot = '${apiEntryPoint}';
 `;
     js += `
 const { default: validateOnClient = null } = ${validateOnClientImportPath ? `require('${validateOnClientImportPath}')` : '{}'};
-const prefix = '${apiEntryPoint}';
+const apiRoot = '${apiEntryPoint}';
 `;
     for (let i = 0; i < segments.length; i++) {
         const { segmentName } = segments[i];
@@ -64,8 +64,8 @@ const prefix = '${apiEntryPoint}';
             continue;
         for (const key of Object.keys(schema.controllers)) {
             dts += `export const ${key}: ReturnType<typeof clientizeController<Controllers${i}["${key}"], Options>>;\n`;
-            js += `exports.${key} = clientizeController(schema['${segmentName}'].controllers.${key}, '${segmentName}', { fetcher, validateOnClient, defaultOptions: { prefix } });\n`;
-            ts += `export const ${key} = clientizeController<Controllers${i}["${key}"], Options>(schema['${segmentName}'].controllers.${key}, '${segmentName}', { fetcher, validateOnClient, defaultOptions: { prefix } });\n`;
+            js += `exports.${key} = clientizeController(schema['${segmentName}'].controllers.${key}, '${segmentName}', { fetcher, validateOnClient, defaultOptions: { apiRoot } });\n`;
+            ts += `export const ${key} = clientizeController<Controllers${i}["${key}"], Options>(schema['${segmentName}'].controllers.${key}, '${segmentName}', { fetcher, validateOnClient, defaultOptions: { apiRoot } });\n`;
         }
         for (const key of Object.keys(schema.workers)) {
             dts += `export const ${key}: ReturnType<typeof promisifyWorker<Workers${i}["${key}"]>>;\n`;

package/dist/getProjectInfo/getConfigAbsolutePaths.mjs

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

package/dist/getProjectInfo/getRelativeSrcRoot.mjs

@@ -1,11 +1,11 @@
-import path from 'path';
-import directoryExists from './directoryExists.mjs';
+import path from 'node:path';
+import getFileSystemEntryType, { FileSystemEntryType } from '../utils/getFileSystemEntryType.mjs';
 export default async function getRelativeSrcRoot({ cwd }) {
     // Next.js Docs: src/app or src/pages will be ignored if app or pages are present in the root directory.
-    if (await directoryExists(path.join(cwd, 'app'))) {
+    if ((await getFileSystemEntryType(path.join(cwd, 'app'))) === FileSystemEntryType.DIRECTORY) {
         return '.';
     }
-    else if (await directoryExists(path.join(cwd, 'src/app'))) {
+    else if ((await getFileSystemEntryType(path.join(cwd, 'src/app'))) === FileSystemEntryType.DIRECTORY) {
         return './src';
     }
     throw new Error(`${cwd} Could not find app router directory. Check Next.js docs for more info.`);

package/dist/getProjectInfo/getUserConfig.mjs

@@ -11,7 +11,7 @@ async function getUserConfig({ cwd, }) {
     try {
         userConfig = await importUncachedModule(configPath);
     }
-    catch (e) {
+    catch {
         try {
             const cacheBuster = Date.now();
             ({ default: userConfig } = (await import(`${configPath}?cache=${cacheBuster}`)));

package/dist/getProjectInfo/index.mjs

@@ -1,4 +1,4 @@
-import path from 'path';
+import path from 'node:path';
 import getConfig from './getConfig.mjs';
 import getLogger from '../utils/getLogger.mjs';
 export default async function getProjectInfo({ port: givenPort, clientOutDir, cwd = process.cwd(), } = {}) {

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 type { VovkConfig, VovkDevEnv } 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;
+export type { VovkConfig, VovkDevEnv };

package/dist/index.mjs

@@ -1,19 +1,20 @@
 #!/usr/bin/env node
-import path from 'path';
+import path from 'node:path';
+import { readFileSync } from 'node:fs';
 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 { VovkDev } from './dev/index.mjs';
 import newComponents from './new/index.mjs';
 import 'dotenv/config';
+import initProgram from './initProgram.mjs';
 const program = new Command();
 const packageJSON = JSON.parse(readFileSync(path.join(import.meta.dirname, '../package.json'), 'utf-8'));
 program.name('vovk').description('Vovk CLI').version(packageJSON.version);
+initProgram(program, 'init ');
 program
     .command('dev')
     .description('Start schema watcher (optional flag --next-dev to start it with Next.js)')
@@ -36,8 +37,8 @@ program
     if (options.nextDev) {
         const { result } = concurrently([
             {
-                command: `node ${import.meta.dirname}/watcher/index.mjs`,
-                name: 'Vovk.ts Schema Watcher',
+                command: `node ${import.meta.dirname}/dev/index.mjs`,
+                name: 'Vovk Dev Command',
                 env: Object.assign({ PORT, __VOVK_START_WATCHER_IN_STANDALONE_MODE__: 'true' }, options.clientOut ? { VOVK_CLIENT_OUT_DIR: options.clientOut } : {}),
             },
             {
@@ -57,7 +58,7 @@ program
         }
     }
     else {
-        void new VovkCLIWatcher().start({ clientOutDir: options.clientOut });
+        void new VovkDev().start({ clientOutDir: options.clientOut });
     }
 });
 program
@@ -72,46 +73,20 @@ program
     const schema = (await import(path.join(schemaOutAbsolutePath, 'index.js')));
     await generateClient(projectInfo, segments, schema.default);
 });
-// 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('-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));
 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, validateOnClient, channel, dryRun }, }: {
     root: string;
     log: ReturnType<typeof getLogger>;
-    dryRun?: boolean;
-    options: Pick<InitOptions, 'validationLibrary' | 'validateOnClient'>;
+    options: Pick<InitOptions, 'validationLibrary' | 'validateOnClient' | '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, validateOnClient, channel, dryRun }, }) {
     const config = {};
     const dotConfigPath = path.join(root, '.config');
     const dir = (await getFileSystemEntryType(dotConfigPath)) === FileSystemEntryType.DIRECTORY ? dotConfigPath : root;
@@ -22,7 +22,7 @@ export default async function createConfig({ root, log, dryRun, options: { valid
             config.validateOnClient = `${validationLibrary}/validateOnClient`;
         }
         try {
-            const validationTemplates = await getTemplateFilesFromPackage(validationLibrary);
+            const validationTemplates = await getTemplateFilesFromPackage(validationLibrary, channel);
             Object.assign(templates, validationTemplates);
         }
         catch (error) {

package/dist/init/getTemplateFilesFromPackage.d.mts

@@ -1,6 +1,7 @@
+import { InitOptions } from '../types.mjs';
 /**
  * Retrieves a list of files in the 'templates' folder of an NPM package.
  * @param packageName - The name of the NPM package.
  * @returns A promise that resolves to an array of file paths.
  */
-export default function getTemplatesFiles(packageName: string, channel?: string): Promise<Record<string, string>>;
+export default function getTemplateFilesFromPackage(packageName: string, channel?: InitOptions['channel']): Promise<Record<string, string>>;

package/dist/init/getTemplateFilesFromPackage.mjs

@@ -1,14 +1,13 @@
-import { createGunzip } from 'zlib';
+import { Readable } from 'node:stream';
+import { createGunzip } from 'node:zlib';
 import tar from 'tar-stream';
-import { Readable } from 'stream';
 import getNPMPackageMetadata from '../utils/getNPMPackageMetadata.mjs';
 /**
  * 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;

package/dist/init/index.d.mts

@@ -1,5 +1,4 @@
-#!/usr/bin/env node
-import type { InitOptions } from '../index.mjs';
+import type { InitOptions } from '../types.mjs';
 import getLogger from '../utils/getLogger.mjs';
 export declare class Init {
     #private;