vovk-cli 0.0.1-beta.3 → 0.0.1-beta.31

package/LICENSE

@@ -0,0 +1,23 @@
+MIT License
+
+Copyright (c) 2023-present Andrii Gubanov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+

package/dist/generateClient.d.mts

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,97 @@
+import path from 'path';
+import fs from 'fs/promises';
+import formatLoggedSegmentName from './utils/formatLoggedSegmentName.mjs';
+import prettify from './utils/prettify.mjs';
+export default async function generateClient(projectInfo, segments, segmentsSchema) {
+    const { config, cwd, log, validateOnClientImportPath, apiEntryPoint, fetcherClientImportPath, schemaOutImportPath } = projectInfo;
+    const now = Date.now();
+    const clientoOutDirAbsolutePath = path.join(cwd, config.clientOutDir);
+    let dts = `// auto-generated
+/* eslint-disable */
+import type { clientizeController } from 'vovk/client';
+import type { promisifyWorker } from 'vovk/worker';
+import type { VovkClientFetcher } from 'vovk/client';
+import type fetcher from '${fetcherClientImportPath}';
+
+`;
+    let js = `// auto-generated
+/* eslint-disable */
+const { clientizeController } = require('vovk/client');
+const { promisifyWorker } = require('vovk/worker');
+const { default: fetcher } = require('${fetcherClientImportPath}');
+const schema = require('${schemaOutImportPath}');
+`;
+    let ts = `// auto-generated
+/* eslint-disable */
+import { clientizeController } from 'vovk/client';
+import { promisifyWorker } from 'vovk/worker';
+import type { VovkClientFetcher } from 'vovk/client';
+import fetcher from '${fetcherClientImportPath}';
+import schema from '${schemaOutImportPath}';
+
+`;
+    for (let i = 0; i < segments.length; i++) {
+        const { routeFilePath, segmentName } = segments[i];
+        const schema = segmentsSchema[segmentName];
+        if (!schema) {
+            throw new Error(`Unable to generate client. No schema found for ${formatLoggedSegmentName(segmentName)}`);
+        }
+        if (!schema.emitSchema)
+            continue;
+        const importRouteFilePath = path.relative(config.clientOutDir, routeFilePath);
+        dts += `import type { Controllers as Controllers${i}, Workers as Workers${i} } from "${importRouteFilePath}";\n`;
+        ts += `import type { Controllers as Controllers${i}, Workers as Workers${i} } from "${importRouteFilePath}";\n`;
+    }
+    dts += `
+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}';
+`;
+    js += `
+const { default: validateOnClient = null } = ${validateOnClientImportPath ? `require('${validateOnClientImportPath}')` : '{}'};
+const prefix = '${apiEntryPoint}';
+`;
+    for (let i = 0; i < segments.length; i++) {
+        const { segmentName } = segments[i];
+        const schema = segmentsSchema[segmentName];
+        if (!schema) {
+            throw new Error(`Unable to generate client. No schema found for ${formatLoggedSegmentName(segmentName)}`);
+        }
+        if (!schema.emitSchema)
+            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`;
+        }
+        for (const key of Object.keys(schema.workers)) {
+            dts += `export const ${key}: ReturnType<typeof promisifyWorker<Workers${i}["${key}"]>>;\n`;
+            js += `exports.${key} = promisifyWorker(null, schema['${segmentName}'].workers.${key});\n`;
+            ts += `export const ${key} = promisifyWorker<Workers${i}["${key}"]>(null, schema['${segmentName}'].workers.${key});\n`;
+        }
+    }
+    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(() => '');
+    const existingDts = await fs.readFile(localDtsAbsolutePath, 'utf-8').catch(() => '');
+    const existingTs = await fs.readFile(localTsAbsolutePath, 'utf-8').catch(() => '');
+    if (config.prettifyClient) {
+        js = await prettify(js, localJsAbsolutePath);
+        dts = await prettify(dts, localDtsAbsolutePath);
+        ts = await prettify(ts, localTsAbsolutePath);
+    }
+    if (existingJs === js && existingDts === dts && existingTs === ts) {
+        log.debug(`Client is up to date and doesn't need to be regenerated (${Date.now() - now}ms)`);
+        return { written: false, path: clientoOutDirAbsolutePath };
+    }
+    await fs.mkdir(clientoOutDirAbsolutePath, { recursive: true });
+    await fs.writeFile(localJsAbsolutePath, js);
+    await fs.writeFile(localDtsAbsolutePath, dts);
+    await fs.writeFile(localTsAbsolutePath, ts);
+    log.info(`Client generated in ${Date.now() - now}ms`);
+    return { written: true, path: clientoOutDirAbsolutePath };
+}

package/dist/getProjectInfo/getConfig.d.mts

@@ -1,7 +1,9 @@
 import type { VovkConfig } from '../types.mjs';
-export default function getConfig({ clientOutDir }: {
+export default function getConfig({ clientOutDir, cwd }: {
     clientOutDir?: string;
+    cwd: string;
 }): Promise<{
     config: Required<VovkConfig>;
     srcRoot: string;
+    configAbsolutePaths: string[];
 }>;

package/dist/getProjectInfo/getConfig.mjs

@@ -1,23 +1,27 @@
-import readConfig from './readConfig.mjs';
-import getCwdPath from './getCwdPath.mjs';
-import getSrcRoot from './getSrcRoot.mjs';
-import path from 'path';
-export default async function getConfig({ clientOutDir }) {
+import getUserConfig from './getUserConfig.mjs';
+import getRelativeSrcRoot from './getRelativeSrcRoot.mjs';
+export default async function getConfig({ clientOutDir, cwd }) {
     const env = process.env;
-    const userConfig = await readConfig();
-    const srcRoot = await getSrcRoot();
-    const cwd = process.cwd();
+    const { userConfig, configAbsolutePaths } = await getUserConfig({ cwd });
+    const srcRoot = await getRelativeSrcRoot({ cwd });
     const config = {
-        modulesDir: path.join(cwd, env.VOVK_MODULES_DIR ?? userConfig.modulesDir ?? './' + [srcRoot, 'modules'].filter(Boolean).join('/')),
-        validateOnClient: getCwdPath(env.VOVK_VALIDATE_ON_CLIENT ?? userConfig.validateOnClient ?? null),
-        validationLibrary: getCwdPath(env.VOVK_VALIDATION_LIBRARY ?? userConfig.validationLibrary ?? null),
-        fetcher: getCwdPath(env.VOVK_FETCHER ?? userConfig.fetcher ?? 'vovk/client/defaultFetcher'),
-        metadataOutDir: env.VOVK_METADATA_OUT_DIR ?? userConfig.metadataOutDir ?? './.vovk-schema',
-        clientOutDir: clientOutDir ?? env.VOVK_CLIENT_OUT_DIR ?? userConfig.clientOutDir ?? './node_modules/.vovk',
+        modulesDir: env.VOVK_MODULES_DIR ?? userConfig.modulesDir ?? './' + [srcRoot, 'modules'].filter(Boolean).join('/'),
+        validateOnClient: env.VOVK_VALIDATE_ON_CLIENT ?? userConfig.validateOnClient ?? null,
+        validationLibrary: env.VOVK_VALIDATION_LIBRARY ?? userConfig.validationLibrary ?? null,
+        fetcher: env.VOVK_FETCHER ?? userConfig.fetcher ?? 'vovk/client/defaultFetcher',
+        schemaOutDir: env.VOVK_SCHEMA_OUT_DIR ?? userConfig.schemaOutDir ?? './.vovk-schema',
+        clientOutDir: clientOutDir ?? env.VOVK_CLIENT_OUT_DIR ?? userConfig.clientOutDir ?? './node_modules/.vovk-client',
         origin: (env.VOVK_ORIGIN ?? userConfig.origin ?? '').replace(/\/$/, ''), // Remove trailing slash
         rootEntry: env.VOVK_ROOT_ENTRY ?? userConfig.rootEntry ?? 'api',
         rootSegmentModulesDirName: env.VOVK_ROOT_SEGMENT_MODULES_DIR_NAME ?? userConfig.rootSegmentModulesDirName ?? '',
         logLevel: env.VOVK_LOG_LEVEL ?? userConfig.logLevel ?? 'debug', // TODO: change to 'warn' when v3 is ready
+        prettifyClient: userConfig.prettifyClient ?? false,
+        templates: {
+            service: 'vovk-cli/templates/service.ejs',
+            controller: 'vovk-cli/templates/controller.ejs',
+            worker: 'vovk-cli/templates/worker.ejs',
+            ...userConfig.templates,
+        },
     };
-    return { config, srcRoot };
+    return { config, srcRoot, configAbsolutePaths };
 }

package/dist/getProjectInfo/getConfigAbsolutePaths.d.mts

@@ -0,0 +1,4 @@
+export default function getConfigAbsolutePaths({ cwd, relativePath, }: {
+    cwd: string;
+    relativePath?: string;
+}): Promise<string[]>;

package/dist/getProjectInfo/getConfigAbsolutePaths.mjs

@@ -0,0 +1,22 @@
+import fs from 'fs/promises';
+import path from 'path';
+export default async function getConfigAbsolutePaths({ cwd, relativePath, }) {
+    const rootDir = path.resolve(cwd, relativePath || '');
+    const baseName = 'vovk.config';
+    const extensions = ['cjs', 'mjs', 'js'];
+    const dirs = [path.join(rootDir, '.config'), rootDir];
+    const configs = [];
+    for (const ext of extensions) {
+        for (const dir of dirs) {
+            const filePath = path.join(dir, `${baseName}.${ext}`);
+            try {
+                await fs.stat(filePath);
+                configs.push(filePath); // Return the path if the file exists
+            }
+            catch {
+                // Empty
+            }
+        }
+    }
+    return configs;
+}

package/dist/getProjectInfo/getRelativeSrcRoot.d.mts

@@ -0,0 +1,3 @@
+export default function getRelativeSrcRoot({ cwd }: {
+    cwd: string;
+}): Promise<"." | "./src">;

package/dist/getProjectInfo/{getSrcRoot.mjs → getRelativeSrcRoot.mjs}

@@ -1,13 +1,12 @@
 import path from 'path';
 import directoryExists from './directoryExists.mjs';
-export default async function getSrcRoot() {
-    const cwd = process.cwd();
+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'))) {
-        return cwd;
+        return '.';
     }
     else if (await directoryExists(path.join(cwd, 'src/app'))) {
-        return path.join(cwd, 'src');
+        return './src';
     }
     throw new Error(`Could not find app router directory. Check Next.js docs for more info.`);
 }

package/dist/getProjectInfo/getUserConfig.d.mts

@@ -0,0 +1,8 @@
+import type { VovkConfig } from '../types.mjs';
+declare function getUserConfig({ cwd, }: {
+    cwd: string;
+}): Promise<{
+    userConfig: VovkConfig;
+    configAbsolutePaths: string[];
+}>;
+export default getUserConfig;

package/dist/getProjectInfo/getUserConfig.mjs

@@ -0,0 +1,19 @@
+import getConfigAbsolutePaths from './getConfigAbsolutePaths.mjs';
+async function getUserConfig({ cwd, }) {
+    const configAbsolutePaths = await getConfigAbsolutePaths({ cwd });
+    let userConfig = {};
+    if (!configAbsolutePaths.length) {
+        return { userConfig, configAbsolutePaths };
+    }
+    const configPath = configAbsolutePaths[0];
+    try {
+        const cacheBuster = Date.now();
+        ({ default: userConfig } = (await import(`${configPath}?cache=${cacheBuster}`)));
+    }
+    catch (e) {
+        // eslint-disable-next-line no-console
+        console.error('🐺 ❌ Error reading config file:', e.message);
+    }
+    return { userConfig, configAbsolutePaths };
+}
+export default getUserConfig;

package/dist/getProjectInfo/index.d.mts

@@ -1,25 +1,23 @@
-import loglevel from 'loglevel';
 export type ProjectInfo = Awaited<ReturnType<typeof getProjectInfo>>;
-export default function getProjectInfo({ port: givenPort, clientOutDir, }?: {
+export default function getProjectInfo({ port: givenPort, clientOutDir, cwd, }?: {
     port?: number;
     clientOutDir?: string;
+    cwd?: string;
 }): Promise<{
     cwd: string;
     port: string;
-    vovkPort: string;
     apiEntryPoint: string;
     apiDir: string;
     srcRoot: string;
-    metadataOutFullPath: string;
-    metadataOutImportPath: string;
-    clientOutFullPath: string;
+    schemaOutImportPath: string;
     fetcherClientImportPath: string;
+    validateOnClientImportPath: string | null;
     config: Required<import("../types.mjs").VovkConfig>;
     log: {
         info: (msg: string) => void;
         warn: (msg: string) => void;
         error: (msg: string) => void;
         debug: (msg: string) => void;
-        raw: loglevel.RootLogger;
+        raw: import("loglevel").RootLogger;
     };
 }>;

package/dist/getProjectInfo/index.mjs

@@ -1,42 +1,33 @@
 import path from 'path';
-import loglevel from 'loglevel';
-import chalk from 'chalk';
 import getConfig from './getConfig.mjs';
-export default async function getProjectInfo({ port: givenPort, clientOutDir, } = {}) {
-    const env = process.env;
+import getLogger from '../utils/getLogger.mjs';
+export default async function getProjectInfo({ port: givenPort, clientOutDir, cwd = process.cwd(), } = {}) {
     const port = givenPort?.toString() ?? process.env.PORT ?? '3000';
     // Make PORT available to the config file at getConfig
     process.env.PORT = port;
-    const cwd = process.cwd();
-    const { config, srcRoot } = await getConfig({ clientOutDir });
-    const vovkPort = env.VOVK_PORT || (parseInt(port) + 6969).toString();
+    const { config, srcRoot, configAbsolutePaths } = await getConfig({ clientOutDir, cwd });
     const apiEntryPoint = `${config.origin ?? ''}/${config.rootEntry}`;
     const apiDir = path.join(srcRoot, 'app', config.rootEntry);
-    const metadataOutFullPath = path.join(cwd, config.metadataOutDir);
-    const metadataOutImportPath = path.relative(config.clientOutDir, metadataOutFullPath);
+    const schemaOutImportPath = path.relative(config.clientOutDir, config.schemaOutDir);
     const fetcherClientImportPath = config.fetcher.startsWith('.')
         ? path.relative(config.clientOutDir, config.fetcher)
         : config.fetcher;
-    const clientOutFullPath = path.join(cwd, config.clientOutDir);
-    const log = {
-        info: (msg) => loglevel.info(chalk.blueBright(`🐺 ${msg}`)),
-        warn: (msg) => loglevel.warn(chalk.yellowBright(`🐺 ${msg}`)),
-        error: (msg) => loglevel.error(chalk.redBright(`🐺 ${msg}`)),
-        debug: (msg) => loglevel.debug(chalk.gray(`🐺 ${msg}`)),
-        raw: loglevel,
-    };
-    loglevel.setLevel(config.logLevel);
+    const validateOnClientImportPath = config.validateOnClient?.startsWith('.')
+        ? path.relative(config.clientOutDir, config.validateOnClient)
+        : config.validateOnClient;
+    const log = getLogger(config.logLevel);
+    if (configAbsolutePaths.length > 1) {
+        log.warn(`Multiple config files found. Using the first one: ${configAbsolutePaths[0]}`);
+    }
     return {
         cwd,
         port,
-        vovkPort,
         apiEntryPoint,
         apiDir,
         srcRoot,
-        metadataOutFullPath,
-        metadataOutImportPath,
-        clientOutFullPath,
+        schemaOutImportPath,
         fetcherClientImportPath,
+        validateOnClientImportPath,
         config,
         log,
     };

package/dist/index.d.mts

@@ -1,3 +1,23 @@
 #!/usr/bin/env node
-import { VovkConfig, VovkEnv } from './types.mjs';
+import { Command } from 'commander';
+import type { LogLevelNames } from 'loglevel';
+import type { VovkConfig, VovkEnv } from './types.mjs';
 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;
+    validateOnClient?: boolean;
+}
+export interface NewOptions {
+    dryRun: boolean;
+}
+declare const program: Command;
+export declare function initProgram(p: typeof program, command: string): Command;

package/dist/index.mjs

@@ -1,22 +1,23 @@
 #!/usr/bin/env node
+import path from 'path';
 import { Command } from 'commander';
+import { readFileSync } from 'fs';
 import concurrently from 'concurrently';
 import getAvailablePort from './utils/getAvailablePort.mjs';
-import { VovkCLIServer } from './server/index.mjs';
 import getProjectInfo from './getProjectInfo/index.mjs';
-import generateClient from './server/generateClient.mjs';
+import generateClient from './generateClient.mjs';
 import locateSegments from './locateSegments.mjs';
-import path from 'path';
-import { readFileSync } from 'fs';
+import { VovkCLIWatcher } from './watcher/index.mjs';
+import { Init } from './init/index.mjs';
+import newComponents from './new/index.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);
 program
     .command('dev')
-    .description('Start development server (optional flag --next-dev to start Vovk Server with Next.js)')
-    .option('--project <path>', 'Path to Next.js project', process.cwd())
+    .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 Vovk Server and Next.js with automatic port allocation', false)
+    .option('--next-dev', 'Start schema watcher and Next.js with automatic port allocation', false)
     .allowUnknownOption(true)
     .action(async (options, command) => {
     const portAttempts = 30;
@@ -34,12 +35,12 @@ program
     if (options.nextDev) {
         const { result } = concurrently([
             {
-                command: `node ${import.meta.dirname}/server/index.mjs`,
-                name: 'Vovk.ts Metadata Server',
-                env: Object.assign({ PORT, __VOVK_START_SERVER_IN_STANDALONE_MODE__: 'true' }, options.clientOut ? { VOVK_CLIENT_OUT_DIR: options.clientOut } : {}),
+                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: `cd ${options.project} && npx next dev ${command.args.join(' ')}`,
+                command: `npx next dev ${command.args.join(' ')}`,
                 name: 'Next.js Development Server',
                 env: { PORT },
             },
@@ -51,12 +52,11 @@ program
             await result;
         }
         finally {
-            // eslint-disable-next-line no-console
-            console.log('🐺 Exiting...');
+            // do nothing, all processes are killed
         }
     }
     else {
-        void new VovkCLIServer().startServer({ clientOutDir: options.clientOut });
+        void new VovkCLIWatcher().start({ clientOutDir: options.clientOut });
     }
 });
 program
@@ -65,14 +65,49 @@ program
     .option('--client-out <path>', 'Path to output directory')
     .action(async (options) => {
     const projectInfo = await getProjectInfo({ clientOutDir: options.clientOut });
-    const segments = await locateSegments(projectInfo.apiDir);
-    const metadata = (await import(path.join(projectInfo.metadataOutFullPath, 'index.js')));
-    await generateClient(projectInfo, segments, metadata.default);
+    const { cwd, config, apiDir } = projectInfo;
+    const segments = await locateSegments(apiDir);
+    const schemaOutAbsolutePath = path.join(cwd, config.schemaOutDir);
+    const schema = (await import(path.join(schemaOutAbsolutePath, 'index.js')));
+    await generateClient(projectInfo, segments, schema.default);
 });
+// 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', 'debug') // TODO change to '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')
+        .option('--validate-on-client', 'Validate on client')
+        .action((prefix = '.', options) => new Init().main(prefix, options));
+}
+initProgram(program, 'init ');
+program
+    .command('new [components...]')
+    .alias('n')
+    .description('Create new components. "vovk new [...components] [segmentName/]moduleName" to create a new module or "vovk new segment [segmentName]" to create a new segment')
+    .option('--dry-run', 'Do not write files to disk')
+    .action((components, options) => newComponents(components, options));
 program
     .command('help')
     .description('Show help message')
     .action(() => program.help());
+/*
+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.d.mts

@@ -0,0 +1 @@
+export default function checkTSConfigForExperimentalDecorators(root: string): Promise<boolean>;

package/dist/init/checkTSConfigForExperimentalDecorators.mjs

@@ -0,0 +1,15 @@
+import path from 'path';
+import fs from 'fs/promises';
+import * as jsonc from 'jsonc-parser';
+export default async function checkTSConfigForExperimentalDecorators(root) {
+    const tsconfigPath = path.resolve(root, 'tsconfig.json');
+    let tsconfigContent;
+    try {
+        tsconfigContent = await fs.readFile(tsconfigPath, 'utf8');
+    }
+    catch (error) {
+        throw new Error(`Failed to read tsconfig.json at ${tsconfigPath}. You can run "npx tsc --init" to create it. ${String(error)}`);
+    }
+    const tsconfig = jsonc.parse(tsconfigContent);
+    return !!tsconfig?.compilerOptions?.experimentalDecorators;
+}

package/dist/init/createConfig.d.mts

@@ -0,0 +1,7 @@
+import type getLogger from '../utils/getLogger.mjs';
+import type { InitOptions } from '../index.mjs';
+export default function createConfig({ root, log, options: { validationLibrary, validateOnClient }, }: {
+    root: string;
+    log: ReturnType<typeof getLogger>;
+    options: Pick<InitOptions, 'validationLibrary' | 'validateOnClient'>;
+}): Promise<void>;

package/dist/init/createConfig.mjs

@@ -0,0 +1,38 @@
+import path from 'path';
+import fs from 'fs/promises';
+import getFileSystemEntryType, { FileSystemEntryType } from '../utils/getFileSystemEntryType.mjs';
+import getTemplateFilesFromPackage from './getTemplateFilesFromPackage.mjs';
+import prettify from '../utils/prettify.mjs';
+export default async function createConfig({ root, log, options: { validationLibrary, validateOnClient }, }) {
+    const config = {};
+    const dotConfigPath = path.join(root, '.config');
+    const dir = (await getFileSystemEntryType(dotConfigPath)) === FileSystemEntryType.DIRECTORY ? dotConfigPath : root;
+    const isModule = await fs
+        .readFile(path.join(root, 'package.json'), 'utf-8')
+        .then((content) => JSON.parse(content).type === 'module');
+    const configAbsolutePath = path.join(dir, isModule ? 'vovk.config.mjs' : 'vovk.config.js');
+    config.validationLibrary = validationLibrary;
+    if (validateOnClient) {
+        config.validateOnClient = `${validationLibrary}/validateOnClient`;
+    }
+    const templates = {
+        controller: 'vovk-cli/templates/controller.ejs',
+        service: 'vovk-cli/templates/service.ejs',
+        worker: 'vovk-cli/templates/worker.ejs',
+    };
+    if (validationLibrary) {
+        try {
+            const validationTemplates = await getTemplateFilesFromPackage(validationLibrary);
+            Object.assign(templates, validationTemplates);
+        }
+        catch (error) {
+            log.error(`Failed to fetch validation library templates: ${error.message}`);
+        }
+    }
+    config.templates = templates;
+    const configStr = await prettify(`/** @type {import('vovk-cli').VovkConfig} */
+const config = ${JSON.stringify(config, null, 2)};
+${isModule ? '\nexport default config;' : 'module.exports = config;'}`, configAbsolutePath);
+    await fs.writeFile(configAbsolutePath, configStr, 'utf-8');
+    log.info(`Config created at ${configAbsolutePath}`);
+}

package/dist/init/getTemplateFilesFromPackage.d.mts

@@ -0,0 +1,6 @@
+/**
+ * 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): Promise<Record<string, string>>;