vovk-cli 0.0.1-draft.5 → 0.0.1-draft.53

package/dist/init/logUpdateDependenciesError.mjs

@@ -0,0 +1,45 @@
+import chalkHighlightThing from '../utils/chalkHighlightThing.mjs';
+import { getPackageManager } from './installDependencies.mjs';
+export default function logUpdateDependenciesError({ useNpm, useYarn, usePnpm, useBun, log, dependencies, devDependencies, error, }) {
+    const packageManager = getPackageManager({ useNpm, useYarn, usePnpm, useBun });
+    const installCommands = [];
+    if (dependencies.length > 0) {
+        let depInstallCmd = '';
+        switch (packageManager) {
+            case 'npm':
+                depInstallCmd = `npm install ${dependencies.join(' ')}`;
+                break;
+            case 'yarn':
+                depInstallCmd = `yarn add ${dependencies.join(' ')}`;
+                break;
+            case 'pnpm':
+                depInstallCmd = `pnpm add ${dependencies.join(' ')}`;
+                break;
+            case 'bun':
+                depInstallCmd = `bun add ${dependencies.join(' ')}`;
+                break;
+        }
+        installCommands.push(depInstallCmd);
+    }
+    if (devDependencies.length > 0) {
+        let devDepInstallCmd = '';
+        switch (packageManager) {
+            case 'npm':
+                devDepInstallCmd = `npm install -D ${devDependencies.join(' ')}`;
+                break;
+            case 'yarn':
+                devDepInstallCmd = `yarn add --dev ${devDependencies.join(' ')}`;
+                break;
+            case 'pnpm':
+                devDepInstallCmd = `pnpm add -D ${devDependencies.join(' ')}`;
+                break;
+            case 'bun':
+                devDepInstallCmd = `bun add -d ${devDependencies.join(' ')}`;
+                break;
+        }
+        installCommands.push(devDepInstallCmd);
+    }
+    const installCmd = installCommands.join(' && ');
+    // Log the error with the appropriate manual installation instructions
+    log.warn(`Failed to update dependencies: ${error.message}. Please, install them manually with ${chalkHighlightThing(installCmd)}`);
+}

package/dist/init/updateDependenciesWithoutInstalling.d.mts

@@ -1,8 +1,9 @@
-import getLogger from '../utils/getLogger.mjs';
+import type getLogger from '../utils/getLogger.mjs';
+import { InitOptions } from '../types.mjs';
 export default function updateDependenciesWithoutInstalling({ log, dir, dependencyNames, devDependencyNames, channel, }: {
     log: ReturnType<typeof getLogger>;
     dir: string;
     dependencyNames: string[];
     devDependencyNames: string[];
-    channel: 'latest' | 'beta' | 'dev';
+    channel: InitOptions['channel'];
 }): Promise<void>;

package/dist/init/updateDependenciesWithoutInstalling.mjs

@@ -1,13 +1,12 @@
-import fs from 'fs/promises';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import chalk from 'chalk';
 import getNPMPackageMetadata from '../utils/getNPMPackageMetadata.mjs';
-import path from 'path';
 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 latestVersion = metadata['dist-tags'][isVovk ? channel : 'latest'];
+        const isVovk = packageName.startsWith('vovk') && packageName !== 'vovk-mapped-types';
+        const latestVersion = metadata['dist-tags'][isVovk ? (channel ?? 'latest') : 'latest'];
         if (!packageJson[key]) {
             packageJson[key] = {};
         }
@@ -18,8 +17,14 @@ export default async function updateDependenciesWithoutInstalling({ log, dir, de
     const packageJsonPath = path.join(dir, 'package.json');
     const packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf-8'));
     await updateDeps({ packageJson, packageNames: dependencyNames, channel, key: 'dependencies' });
-    log.debug('Updated dependencies in package.json');
     await updateDeps({ packageJson, packageNames: devDependencyNames, channel, key: 'devDependencies' });
-    log.debug('Updated devDependencies in package.json');
     await fs.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2));
+    log.info('Added dependencies to package.json:');
+    for (const dependency of dependencyNames) {
+        log.raw.info(` - ${chalk.cyan(dependency)}`);
+    }
+    log.info('Added devDependencies to package.json:');
+    for (const dependency of devDependencyNames) {
+        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,16 @@
-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: {
+            ...pkgJson.content.scripts,
             generate: 'vovk generate',
-            dev: updateScriptsMode === 'explicit'
-                ? "PORT=3000 concurrently 'vovk dev' 'next dev' --kill-others"
-                : 'vovk dev --next-dev',
+            dev: getDevScript(pkgJson, updateScriptsMode),
         },
     });
     await pkgJson.save();

package/dist/init/updateTypeScriptConfig.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';
 import prettify from '../utils/prettify.mjs';
 export default async function updateTypeScriptConfig(root) {

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 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', 'Path to validateOnClient file')
+        .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 { VovkConfig } from './types.mjs';
 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: Required<VovkConfig> | null;
+}): Promise<Segment[]>;

package/dist/locateSegments.mjs

@@ -1,8 +1,10 @@
-import { promises as fs } from 'fs';
-import * as path from 'path';
+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) {
+// config: null is used for testing
+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 +18,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 ?? '.__', 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,6 +1,10 @@
-import { Project, SyntaxKind } from 'ts-morph';
-export default function addClassToSegmentCode(segmentSourceCode, { sourceName, compiledName, type, importPath, }) {
-    const project = new Project();
+import { Project, QuoteKind, SyntaxKind } from 'ts-morph';
+export default function addClassToSegmentCode(segmentSourceCode, { sourceName, compiledName, importPath, }) {
+    const project = new Project({
+        manipulationSettings: {
+            quoteKind: QuoteKind.Single,
+        },
+    });
     const sourceFile = project.createSourceFile('route.ts', segmentSourceCode, { overwrite: true });
     // Add the import if it doesn't exist
     let importDeclaration = sourceFile.getImportDeclaration((imp) => {
@@ -12,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 '../index.mjs';
-export default function newComponents(components: string[], { dryRun, fileName, dirName, template, overwrite }: NewOptions): Promise<void>;
+import type { NewOptions } from '../types.mjs';
+export default function newComponents(components: string[], { dryRun, dir, templates, overwrite, noSegmentUpdate }: 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, fileName, dirName, template, overwrite }) {
+export default async function newComponents(components, { dryRun, dir, templates, overwrite, noSegmentUpdate }) {
     if (components[0] === 'segment' || components[0] === 'segments') {
         // vovk new segment [segmentName]
         let segmentNames = components
@@ -26,10 +26,10 @@ export default async function newComponents(components, { dryRun, fileName, dirN
         await newModule({
             what,
             moduleNameWithOptionalSegment,
-            fileName,
-            dirName,
-            template,
+            dir,
+            templates,
             overwrite,
+            noSegmentUpdate,
             dryRun,
         });
     }

package/dist/new/newModule.d.mts

@@ -1,9 +1,9 @@
-export default function newModule({ what, moduleNameWithOptionalSegment, dryRun, fileName: fileNameFlag, dirName: dirNameFlag, template: templateFlag, overwrite, }: {
+export default function newModule({ what, moduleNameWithOptionalSegment, dryRun, dir: dirFlag, templates: templatesFlag, noSegmentUpdate, overwrite, }: {
     what: string[];
     moduleNameWithOptionalSegment: string;
     dryRun?: boolean;
-    fileName?: string;
-    dirName?: string;
-    template?: string;
+    dir?: string;
+    templates?: string[];
+    noSegmentUpdate?: boolean;
     overwrite?: boolean;
 }): Promise<void>;

package/dist/new/newModule.mjs

@@ -1,11 +1,11 @@
-import path from 'path';
-import fs from 'fs/promises';
-import getProjectInfo from '../getProjectInfo/index.mjs';
+import path from 'node:path';
+import fs from 'node:fs/promises';
 import render from './render.mjs';
+import addClassToSegmentCode from './addClassToSegmentCode.mjs';
+import getProjectInfo from '../getProjectInfo/index.mjs';
+import locateSegments from '../locateSegments.mjs';
 import chalkHighlightThing from '../utils/chalkHighlightThing.mjs';
 import formatLoggedSegmentName from '../utils/formatLoggedSegmentName.mjs';
-import locateSegments from '../locateSegments.mjs';
-import addClassToSegmentCode from './addClassToSegmentCode.mjs';
 import getFileSystemEntryType from '../utils/getFileSystemEntryType.mjs';
 import prettify from '../utils/prettify.mjs';
 function splitByLast(str, delimiter = '/') {
@@ -18,50 +18,61 @@ function splitByLast(str, delimiter = '/') {
     const after = str.substring(index + delimiter.length);
     return [before, after];
 }
-export default async function newModule({ what, moduleNameWithOptionalSegment, dryRun, fileName: fileNameFlag, dirName: dirNameFlag, template: templateFlag, overwrite, }) {
+export default async function newModule({ what, moduleNameWithOptionalSegment, dryRun, dir: dirFlag, templates: templatesFlag, noSegmentUpdate, overwrite, }) {
     const { config, log, apiDir, cwd } = await getProjectInfo();
-    const templates = config.templates;
+    let templates = config.templates;
     const [segmentName, moduleName] = splitByLast(moduleNameWithOptionalSegment);
-    // replace c by controller, s by service, w by worker, everything else keeps the same
+    // replace c by controller, s by service, everything else keeps the same
     what = what.map((s) => {
         switch (s) {
             case 'c':
                 return 'controller';
             case 's':
                 return 'service';
-            case 'w':
-                return 'worker';
             default:
                 return s;
         }
     });
-    // check if template exists
+    if (templatesFlag) {
+        if (templatesFlag.length > what.length) {
+            throw new Error('Too many templates provided');
+        }
+        templates = templatesFlag.reduce((acc, templatePath, index) => ({
+            ...acc,
+            [what[index]]: templatePath,
+        }), templates);
+    }
     for (const type of what) {
         if (!templates[type]) {
-            throw new Error(`Template for ${type} not found in config`);
+            throw new Error(`Template for "${type}" not found`);
         }
     }
-    const segments = await locateSegments(apiDir);
+    const segments = await locateSegments({ dir: apiDir, config });
     const segment = segments.find((s) => s.segmentName === segmentName);
     if (!segment) {
-        throw new Error(`Segment ${segmentName} not found`);
+        throw new Error(`Unable to create module. Segment "${segmentName}" not found. Run "vovk new segment ${segmentName}" to create it`);
     }
     for (const type of what) {
-        const templatePath = templateFlag ?? templates[type];
+        const templatePath = templates[type];
         const templateAbsolutePath = templatePath.startsWith('/') || templatePath.startsWith('.')
             ? path.resolve(cwd, templatePath)
             : path.resolve(cwd, './node_modules', templatePath);
         const templateCode = await fs.readFile(templateAbsolutePath, 'utf-8');
-        const { dirName: renderedDirName, fileName: renderedFileName, sourceName, compiledName, code, } = await render(templateCode, {
+        const { dir: renderedDir, fileName, sourceName, compiledName, code, } = await render(templateCode, {
             cwd,
             config,
             withService: what.includes('service'),
             segmentName,
             moduleName,
         });
-        const fileName = fileNameFlag || renderedFileName;
-        const dirName = dirNameFlag || renderedDirName;
-        const absoluteModuleDir = path.join(cwd, config.modulesDir, dirName);
+        const dir = dirFlag || renderedDir;
+        if (!dir) {
+            throw new Error(`The template for "${type}" does not provide a dir`);
+        }
+        if (!fileName) {
+            throw new Error(`The template for "${type}" does not provide a fileName`);
+        }
+        const absoluteModuleDir = path.join(cwd, dir);
         const absoluteModulePath = path.join(absoluteModuleDir, fileName);
         const prettiedCode = await prettify(code, absoluteModulePath);
         if (!dryRun) {
@@ -71,29 +82,30 @@ export default async function newModule({ what, moduleNameWithOptionalSegment, d
             else {
                 await fs.mkdir(absoluteModuleDir, { recursive: true });
                 await fs.writeFile(absoluteModulePath, prettiedCode);
+                log.info(`Created ${chalkHighlightThing(fileName)} using ${chalkHighlightThing(`"${type}"`)} template for ${formatLoggedSegmentName(segmentName)}`);
             }
         }
-        if (type === 'controller' || type === 'worker') {
+        if (type === 'controller') {
             if (!sourceName) {
-                throw new Error('sourceName is required');
+                throw new Error(`The template for "${type}" does not provide a sourceName`);
             }
             if (!compiledName) {
-                throw new Error('compiledName is required');
+                throw new Error(`The template for "${type}" does not provide a compiledName`);
             }
             const { routeFilePath } = segment;
             const segmentSourceCode = await fs.readFile(routeFilePath, 'utf-8');
-            const importPath = path.relative(absoluteModuleDir, absoluteModulePath).replace(/\.(ts|tsx)$/, '');
-            const newSegmentCode = addClassToSegmentCode(segmentSourceCode, {
-                sourceName,
-                compiledName,
-                type,
-                importPath,
-            });
-            if (!dryRun) {
-                await fs.writeFile(routeFilePath, newSegmentCode);
+            const importPath = path.relative(path.dirname(routeFilePath), absoluteModulePath).replace(/\.(ts|tsx)$/, '');
+            if (!noSegmentUpdate) {
+                const newSegmentCode = await prettify(addClassToSegmentCode(segmentSourceCode, {
+                    sourceName,
+                    compiledName,
+                    importPath,
+                }), routeFilePath);
+                if (!dryRun) {
+                    await fs.writeFile(routeFilePath, newSegmentCode);
+                }
             }
-            log.info(`Added ${chalkHighlightThing(sourceName)} ${type} to ${formatLoggedSegmentName(segmentName)} as ${chalkHighlightThing(compiledName)}`);
+            log.info(`Added ${chalkHighlightThing(sourceName)} ${type} as ${chalkHighlightThing(compiledName)} to ${formatLoggedSegmentName(segmentName)}`);
         }
-        log.info(`Created ${chalkHighlightThing(fileName)} using "${chalkHighlightThing(type)}" template for ${formatLoggedSegmentName(segmentName)}`);
     }
 }

package/dist/new/newSegment.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 getProjectInfo from '../getProjectInfo/index.mjs';
 import getFileSystemEntryType from '../utils/getFileSystemEntryType.mjs';
 import chalkHighlightThing from '../utils/chalkHighlightThing.mjs';
@@ -13,15 +13,14 @@ export default async function newSegment({ segmentName, overwrite, dryRun, }) {
     }
     const code = await prettify(`import { initVovk } from 'vovk';
 
+export const runtime = 'edge';
+
 const controllers = {};
-const workers = {};
 
 export type Controllers = typeof controllers;
-export type Workers = typeof workers;
 
 export const { GET, POST, PATCH, PUT, HEAD, OPTIONS, DELETE } = initVovk({
 ${segmentName ? `  segmentName: '${segmentName}',\n` : ''}  emitSchema: true,
-  workers,
   controllers,
 });
 `, absoluteSegmentRoutePath);
@@ -29,5 +28,6 @@ ${segmentName ? `  segmentName: '${segmentName}',\n` : ''}  emitSchema: true,
         await fs.mkdir(path.dirname(absoluteSegmentRoutePath), { recursive: true });
         await fs.writeFile(absoluteSegmentRoutePath, code);
     }
-    log.info(`${formatLoggedSegmentName(segmentName, { upperFirst: true })} created at ${absoluteSegmentRoutePath}. Run ${chalkHighlightThing(`vovk new controller ${segmentName}/someName`)} to create a controller or modify the segment file manually`);
+    log.info(`${formatLoggedSegmentName(segmentName, { upperFirst: true })} created at ${absoluteSegmentRoutePath}.`);
+    log.info(`Run ${chalkHighlightThing(`npx vovk new service controller ${[segmentName, 'thing'].filter(Boolean).join('/')}`)} to create a new controller with a service at /modules/thing/ folder.`);
 }

package/dist/new/render.mjs

@@ -20,14 +20,11 @@ export default async function render(codeTemplate, { config, withService, segmen
         _, // lodash
         pluralize,
     };
-    // first, render the front matter because it can use ejs variables
     const parsed = matter((await ejs.render(codeTemplate, templateVars, { async: true })).trim());
-    const { dirName, fileName, sourceName, compiledName } = parsed.data;
+    const { dir, fileName, sourceName, compiledName } = parsed.data;
     const code = parsed.content;
-    // const templateContent = parsed.content; TODO
-    // const code = await ejs.render(templateContent, templateVars, { async: true });
     return {
-        dirName,
+        dir,
         fileName,
         sourceName,
         compiledName,

package/dist/postinstall.mjs

@@ -1,22 +1,21 @@
-import { promises as fs } from 'fs';
-import path from 'path';
-/**
- * Checks if a file exists at the given path.
- * @param {string} filePath - The path to the file.
- * @returns {Promise<boolean>} - A promise that resolves to true if the file exists, false otherwise.
- */
-const getFileSystemEntryType = async (filePath) => !!(await fs.stat(filePath).catch(() => false));
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import getFileSystemEntryType from './utils/getFileSystemEntryType.mjs';
 async function postinstall() {
-    const vovk = path.join(import.meta.dirname, '../../.vovk');
-    const js = path.join(vovk, 'client.js');
-    const ts = path.join(vovk, 'client.d.ts');
+    // TODO: The function doesn't consider client templates, how to do that?
+    const vovk = path.join(import.meta.dirname, '../../.vovk-client');
+    const js = path.join(vovk, 'compiled.js');
+    const ts = path.join(vovk, 'compiled.d.ts');
     const index = path.join(vovk, 'index.ts');
-    if ((await getFileSystemEntryType(js)) || (await getFileSystemEntryType(ts)) || (await getFileSystemEntryType(index))) {
-        return;
-    }
     await fs.mkdir(vovk, { recursive: true });
-    await fs.writeFile(js, '/* postinstall */');
-    await fs.writeFile(ts, '/* postinstall */');
-    await fs.writeFile(index, '/* postinstall */');
+    if (!(await getFileSystemEntryType(js))) {
+        await fs.writeFile(js, '/* postinstall */');
+    }
+    if (!(await getFileSystemEntryType(ts))) {
+        await fs.writeFile(ts, '/* postinstall */');
+    }
+    if (!(await getFileSystemEntryType(index))) {
+        await fs.writeFile(index, '/* postinstall */');
+    }
 }
 void postinstall();

package/dist/types.d.mts

@@ -1,13 +1,13 @@
-import { LogLevelNames } from 'loglevel';
+import type { LogLevelNames } from 'loglevel';
 export type KnownAny = any;
 export type VovkEnv = {
     PORT?: string;
     VOVK_CLIENT_OUT_DIR?: string;
     VOVK_SCHEMA_OUT_DIR?: string;
-    VOVK_FETCHER?: string;
-    VOVK_VALIDATE_ON_CLIENT?: string;
+    VOVK_FETCHER_PATH?: string;
+    VOVK_VALIDATE_ON_CLIENT_PATH?: string;
+    VOVK_CREATE_RPC_PATH?: string;
     VOVK_MODULES_DIR?: string;
-    VOVK_VALIDATION_LIBRARY?: string;
     VOVK_ORIGIN?: string;
     VOVK_ROOT_ENTRY?: string;
     VOVK_API_ENTRY_POINT?: string;
@@ -16,31 +16,64 @@ export type VovkEnv = {
     VOVK_PRETTIFY_CLIENT?: string;
     VOVK_DEV_HTTPS?: string;
     __VOVK_START_WATCHER_IN_STANDALONE_MODE__?: 'true';
+    __VOVK_EXIT__?: 'true' | 'false';
 };
 export type VovkConfig = {
     clientOutDir?: string;
     schemaOutDir?: string;
-    fetcher?: string;
-    validateOnClient?: string | null;
+    fetcherPath?: string;
+    validateOnClientPath?: string | null;
+    createRPCPath?: string;
     modulesDir?: string;
-    validationLibrary?: string | null;
     rootEntry?: string;
     origin?: string;
     rootSegmentModulesDirName?: string;
     logLevel?: LogLevelNames;
     prettifyClient?: boolean;
     devHttps?: boolean;
+    experimental_clientGenerateTemplateNames?: string[];
     templates?: {
         service?: string;
         controller?: string;
-        worker?: string;
         [key: string]: string | undefined;
     };
 };
 export type VovkModuleRenderResult = {
     fileName: string;
-    dirName: string;
+    dir: string;
     sourceName?: string;
     compiledName?: string;
     code: string;
 };
+export interface DevOptions {
+    nextDev?: boolean;
+    exit?: boolean;
+}
+export interface GenerateOptions {
+    clientOutDir?: string;
+    templates?: string[];
+    prettify?: boolean;
+    fullSchema?: string | boolean;
+}
+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' | 'draft';
+}
+export interface NewOptions {
+    dryRun?: boolean;
+    templates?: string[];
+    dir?: string;
+    overwrite?: boolean;
+    noSegmentUpdate?: boolean;
+}

package/dist/utils/debounceWithArgs.d.mts

@@ -1,2 +1,2 @@
 import { KnownAny } from '../types.mjs';
-export default function debounceWithArgs<T extends (...args: KnownAny[]) => KnownAny>(fn: T, wait: number): (...args: Parameters<T>) => void | Promise<void>;
+export default function debounceWithArgs<Callback extends (...args: KnownAny[]) => KnownAny>(callback: Callback, wait: number): (...args: Parameters<Callback>) => Promise<Awaited<ReturnType<Callback>>>;