vovk-cli 0.0.1-draft.332 → 0.0.1-draft.334

package/client-templates/schemaCjs/schema.cjs.ejs

@@ -16,10 +16,7 @@ const schema = {
   $schema: '<%- t.VovkSchemaIdEnum.SCHEMA %>',
   segments,
   meta: {
-    apiRoot: '<%= t.apiRoot %>', // for debugging purposes
-    <% if(t.isVovkProject) { %>
-    ...meta
-    <% } %>
+    <% if(t.isVovkProject) { %>...meta<% } %>
   }
 };
 

package/client-templates/schemaTs/schema.ts.ejs

@@ -22,11 +22,7 @@ export const schema = {
   $schema: '<%- t.VovkSchemaIdEnum.SCHEMA %>',
   segments,
   meta: {
-    $schema: '<%- t.VovkSchemaIdEnum.META %>',
-    apiRoot: '<%= t.apiRoot %>', // for debugging purposes
-    <% if(t.isVovkProject) { %>
-    ...meta,
-    <% } %>
+    <% if(t.isVovkProject) { %>...meta,<% } %>
   }
 };
 

package/dist/bundle/index.mjs

@@ -17,9 +17,11 @@ export async function bundle({ projectInfo, fullSchema, cliBundleOptions, }) {
         throw new Error('No output directory specified for composed client');
     }
     const outDir = cliBundleOptions?.outDir ?? bundleConfig.tsdownBuildOptions.outDir;
+    const tsconfig = cliBundleOptions?.tsconfig ?? bundleConfig.tsdownBuildOptions.tsconfig;
     if (!outDir) {
         throw new Error('No output directory specified for bundling');
     }
+    const outDirAbsolute = path.resolve(cwd, outDir);
     await generate({
         isEnsuringClient: false,
         isBundle: true,
@@ -47,18 +49,20 @@ export async function bundle({ projectInfo, fullSchema, cliBundleOptions, }) {
         dts: true,
         format: ['cjs', 'esm'],
         fixedExtension: true,
-        outDir,
+        clean: true,
         ...bundleConfig.tsdownBuildOptions,
+        outDir: outDirAbsolute,
+        tsconfig,
     });
-    const outDirAbsolute = path.resolve(cwd, outDir);
     log.debug(`Bundled index.ts to ${chalkHighlightThing(outDirAbsolute)}`);
     await build({
         entry: path.join(tsFullClientOutAbsoluteDirInput, './schema.ts'),
         dts: true,
         format: ['cjs'],
         fixedExtension: true,
-        outDir,
+        outDir: outDirAbsolute,
         clean: false,
+        tsconfig,
     });
     log.debug(`Bundled schema.ts to ${chalkHighlightThing(outDirAbsolute)}`);
     const requiresGroup = groupBy(Object.entries(bundleConfig.requires), ([, relativePath]) => relativePath);
@@ -74,7 +78,7 @@ export async function bundle({ projectInfo, fullSchema, cliBundleOptions, }) {
             cliGenerateOptions: {
                 origin: cliBundleOptions?.origin ?? bundleConfig.origin,
                 composedFrom: group.map(([templateName]) => templateName),
-                composedOut: path.resolve(outDir, relativePath),
+                composedOut: path.resolve(outDirAbsolute, relativePath),
                 composedOnly: true,
             },
         });

package/dist/dev/index.d.mts

@@ -1,7 +1,7 @@
 import type { DevOptions } from '../types.mjs';
 export declare class VovkDev {
     #private;
-    constructor({ schemaOut, devHttps }: Pick<DevOptions, 'schemaOut' | 'devHttps'>);
+    constructor({ schemaOut, devHttps, logLevel }: Pick<DevOptions, 'schemaOut' | 'devHttps' | 'logLevel'>);
     start({ exit }: {
         exit: boolean;
     }): Promise<void>;

package/dist/dev/index.mjs

@@ -38,9 +38,11 @@ export class VovkDev {
     #onFirstTimeGenerate = null;
     #schemaOut = null;
     #devHttps;
-    constructor({ schemaOut, devHttps }) {
-        this.#schemaOut = schemaOut ?? null;
-        this.#devHttps = devHttps ?? false;
+    #logLevel;
+    constructor({ schemaOut, devHttps, logLevel }) {
+        this.#schemaOut = schemaOut || null;
+        this.#devHttps = devHttps || false;
+        this.#logLevel = logLevel || 'info';
     }
     #watchSegments = (callback) => {
         const segmentReg = /\/?\[\[\.\.\.[a-zA-Z-_]+\]\]\/route.ts$/;
@@ -165,7 +167,7 @@ export class VovkDev {
         let isInitial = true;
         let isReady = false;
         const handle = debounce(async () => {
-            this.#projectInfo = await getProjectInfo();
+            this.#projectInfo = await getProjectInfo({ logLevel: this.#logLevel });
             const { config, apiDirAbsolutePath } = this.#projectInfo;
             this.#segments = await locateSegments({ dir: apiDirAbsolutePath, config, log });
             await this.#modulesWatcher?.close();
@@ -323,7 +325,7 @@ export class VovkDev {
     }
     async start({ exit }) {
         const now = Date.now();
-        this.#projectInfo = await getProjectInfo();
+        this.#projectInfo = await getProjectInfo({ logLevel: this.#logLevel });
         const { log, config, cwd, apiDirAbsolutePath } = this.#projectInfo;
         this.#segments = await locateSegments({ dir: apiDirAbsolutePath, config, log });
         log.info('Starting...');
@@ -392,6 +394,7 @@ if (env.__VOVK_START_WATCHER_IN_STANDALONE_MODE__ === 'true') {
     void new VovkDev({
         schemaOut: env.__VOVK_SCHEMA_OUT_FLAG__ || undefined,
         devHttps: env.__VOVK_DEV_HTTPS_FLAG__ === 'true',
+        logLevel: env.__VOVK_LOG_LEVEL__,
     }).start({
         exit: env.__VOVK_EXIT__ === 'true',
     });

package/dist/getProjectInfo/getConfig/index.d.mts

@@ -1,7 +1,9 @@
 import { VovkSchemaIdEnum, type VovkStrictConfig } from 'vovk';
-export default function getConfig({ configPath, cwd }: {
+import type { LogLevelNames } from 'loglevel';
+export default function getConfig({ configPath, cwd, logLevel, }: {
     configPath?: string;
     cwd: string;
+    logLevel?: LogLevelNames;
 }): Promise<{
     config: VovkStrictConfig;
     srcRoot: string | null;
@@ -71,7 +73,7 @@ export default function getConfig({ configPath, cwd }: {
             excludeSegments?: string[];
             includeSegments?: never;
         });
-        clientTemplateDefs?: Record<string, import("vovk/mjs/types").ClientTemplateDef>;
+        clientTemplateDefs?: Record<string, import("vovk/types").ClientTemplateDef>;
         imports?: {
             fetcher?: string | [string, string] | [string];
             validateOnClient?: string | [string, string] | [string];
@@ -106,8 +108,8 @@ export default function getConfig({ configPath, cwd }: {
                     banner?: string;
                 };
                 apiRoot?: string;
-                getModuleName?: "nestjs-operation-id" | (string & {}) | "api" | import("vovk/mjs/types").GetOpenAPINameFn;
-                getMethodName?: "nestjs-operation-id" | "camel-case-operation-id" | "auto" | import("vovk/mjs/types").GetOpenAPINameFn;
+                getModuleName?: "nestjs-operation-id" | (string & {}) | "api" | import("vovk/types").GetOpenAPINameFn;
+                getMethodName?: "nestjs-operation-id" | "camel-case-operation-id" | "auto" | import("vovk/types").GetOpenAPINameFn;
                 errorMessageKey?: string;
             };
         };

package/dist/getProjectInfo/getConfig/index.mjs

@@ -6,7 +6,7 @@ import getRelativeSrcRoot from './getRelativeSrcRoot.mjs';
 import getTemplateDefs, { BuiltInTemplateName } from './getTemplateDefs.mjs';
 import { normalizeOpenAPIMixins } from '../../utils/normalizeOpenAPIMixins.mjs';
 import chalkHighlightThing from '../../utils/chalkHighlightThing.mjs';
-export default async function getConfig({ configPath, cwd }) {
+export default async function getConfig({ configPath, cwd, logLevel, }) {
     const { configAbsolutePaths, error, userConfig } = await getUserConfig({
         configPath,
         cwd,
@@ -65,7 +65,7 @@ export default async function getConfig({ configPath, cwd }) {
         origin: (env.VOVK_ORIGIN ?? conf.origin ?? '').replace(/\/$/, ''), // Remove trailing slash
         rootEntry: env.VOVK_ROOT_ENTRY ?? conf.rootEntry ?? 'api',
         rootSegmentModulesDirName: conf.rootSegmentModulesDirName ?? '',
-        logLevel: env.VOVK_LOG_LEVEL ?? conf.logLevel ?? 'info',
+        logLevel: conf.logLevel ?? 'info',
         devHttps: conf.devHttps ?? false,
         moduleTemplates: {
             service: 'vovk-cli/module-templates/service.ts.ejs',
@@ -85,7 +85,7 @@ export default async function getConfig({ configPath, cwd }) {
     else if (Array.isArray(conf.emitConfig)) {
         config.emitConfig = conf.emitConfig;
     } // else it's false and emitConfig already is []
-    const log = getLogger(config.logLevel);
+    const log = getLogger(logLevel ?? config.logLevel);
     config.openApiMixins = await normalizeOpenAPIMixins({
         mixinModules: conf.openApiMixins ?? {},
         cwd,

package/dist/getProjectInfo/index.d.mts

@@ -1,9 +1,11 @@
+import { LogLevelNames } from 'loglevel';
 export type ProjectInfo = Awaited<ReturnType<typeof getProjectInfo>>;
-export default function getProjectInfo({ port: givenPort, cwd, configPath, srcRootRequired, }?: {
+export default function getProjectInfo({ port: givenPort, cwd, configPath, srcRootRequired, logLevel, }?: {
     port?: number;
     cwd?: string;
     configPath?: string;
     srcRootRequired?: boolean;
+    logLevel?: LogLevelNames;
 }): Promise<{
     cwd: string;
     port: string;
@@ -13,7 +15,7 @@ export default function getProjectInfo({ port: givenPort, cwd, configPath, srcRo
     vovkCliPackage: {
         version: string;
     };
-    config: import("vovk").VovkStrictConfig;
+    config: import("vovk/types").VovkStrictConfig;
     packageJson: import("type-fest").PackageJson;
     isNextInstalled: boolean;
     log: {

package/dist/getProjectInfo/index.mjs

@@ -2,13 +2,16 @@ import path from 'node:path';
 import getConfig from './getConfig/index.mjs';
 import { getPackageJson } from '../utils/getPackageJson.mjs';
 import { readFile } from 'node:fs/promises';
-export default async function getProjectInfo({ port: givenPort, cwd = process.cwd(), configPath, srcRootRequired = true, } = {}) {
+export default async function getProjectInfo({ port: givenPort, cwd = process.cwd(), configPath, srcRootRequired = true, logLevel, } = {
+    logLevel: 'info',
+}) {
     const port = givenPort?.toString() ?? process.env.PORT ?? '3000';
     // Make PORT available to the config file at getConfig
     process.env.PORT = port;
     const { config, srcRoot, configAbsolutePaths, log } = await getConfig({
         configPath,
         cwd,
+        logLevel,
     });
     const packageJson = await getPackageJson(cwd, log);
     const isNextInstalled = !!packageJson?.dependencies?.next || !!packageJson?.devDependencies?.next;

package/dist/index.mjs

@@ -25,8 +25,9 @@ program
     .option('--exit', 'kill the processes when schema and client is generated')
     .option('--schema-out <path>', 'path to schema output directory (default: .vovk-schema)')
     .option('--https, --dev-https', 'use HTTPS for the dev server (default: false)')
+    .option('--log-level <level>', 'set the log level')
     .action(async (nextArgs, options) => {
-    const { nextDev, exit = false, schemaOut, devHttps } = options;
+    const { nextDev, exit = false, schemaOut, devHttps, logLevel } = options;
     const portAttempts = 30;
     const PORT = !nextDev
         ? process.env.PORT
@@ -52,9 +53,11 @@ program
                 env: {
                     PORT,
                     __VOVK_START_WATCHER_IN_STANDALONE_MODE__: 'true',
+                    // TODO: Pass these as flags
                     __VOVK_SCHEMA_OUT_FLAG__: schemaOut ?? '',
                     __VOVK_DEV_HTTPS_FLAG__: devHttps ? 'true' : 'false',
                     __VOVK_EXIT__: exit ? 'true' : 'false',
+                    __VOVK_LOG_LEVEL__: logLevel ?? undefined,
                 },
             },
         ], {
@@ -70,7 +73,7 @@ program
         }
     }
     else {
-        void new VovkDev({ schemaOut, devHttps }).start({ exit });
+        void new VovkDev({ schemaOut, devHttps, logLevel }).start({ exit });
     }
 });
 program
@@ -98,8 +101,13 @@ program
     .option('--openapi-root-url <urls...>', 'root URLs corresponding to the index of --openapi option')
     .option('--openapi-mixin-name <names...>', 'mixin names corresponding to the index of --openapi option')
     .option('--openapi-fallback <paths...>', 'save OpenAPI spec and use it as a fallback if URL is not available')
+    .option('--log-level <level>', 'set the log level')
     .action(async (cliGenerateOptions) => {
-    const projectInfo = await getProjectInfo({ configPath: cliGenerateOptions.configPath, srcRootRequired: false });
+    const projectInfo = await getProjectInfo({
+        configPath: cliGenerateOptions.configPath,
+        srcRootRequired: false,
+        logLevel: cliGenerateOptions.logLevel,
+    });
     await new VovkGenerate({
         projectInfo,
         forceNothingWrittenLog: true,
@@ -118,12 +126,18 @@ program
     .option('--config <config>', 'path to config file')
     .option('--schema <path>', 'path to schema folder (default: .vovk-schema)')
     .option('--origin <url>', 'set the origin URL for the generated client')
+    .option('--tsconfig <path>', 'path to tsconfig.json for bundling by tsdown')
     .option('--openapi, --openapi-spec <openapi_path_or_urls...>', 'use OpenAPI schema instead of Vovk schema')
     .option('--openapi-get-module-name <names...>', 'module names corresponding to the index of --openapi option')
     .option('--openapi-get-method-name <names...>', 'method names corresponding to the index of --openapi option')
     .option('--openapi-root-url <urls...>', 'root URLs corresponding to the index of --openapi option')
+    .option('--log-level <level>', 'set the log level')
     .action(async (cliBundleOptions) => {
-    const projectInfo = await getProjectInfo({ configPath: cliBundleOptions.config, srcRootRequired: false });
+    const projectInfo = await getProjectInfo({
+        configPath: cliBundleOptions.config,
+        srcRootRequired: false,
+        logLevel: cliBundleOptions.logLevel,
+    });
     const { cwd, config, log, isNextInstalled } = projectInfo;
     const fullSchema = await getProjectFullSchema({
         schemaOutAbsolutePath: path.resolve(cwd, cliBundleOptions?.schema ?? config.schemaOutDir),
@@ -147,7 +161,10 @@ program
     .option('--no-segment-update', 'do not update segment files when creating a new module')
     .option('--dry-run', 'do not write files to disk')
     .option('--static', 'if the segment is static')
-    .action((components, newOptions) => newComponents(components, newOptions));
+    .option('--log-level <level>', 'set the log level')
+    .action(async (components, newOptions) => newComponents(components, await getProjectInfo({
+    logLevel: newOptions.logLevel,
+}), newOptions));
 program
     .command('help')
     .description('Show help message')

package/dist/init/createConfig.mjs

@@ -11,14 +11,36 @@ export default async function createConfig({ root, log, options: { validationLib
         .readFile(path.join(root, 'package.json'), 'utf-8')
         .then((content) => JSON.parse(content).type === 'module');
     const configAbsolutePath = path.join(dir, isModule ? 'vovk.config.mjs' : 'vovk.config.js');
+    const typeTemplates = {
+        controller: 'vovk-cli/module-templates/type/controller.ts.ejs',
+        service: 'vovk-cli/module-templates/type/service.ts.ejs',
+    };
     const moduleTemplates = {
-        controller: 'vovk-cli/module-templates/controller.ts.ejs',
-        service: 'vovk-cli/module-templates/service.ts.ejs',
+        ...typeTemplates,
+        ...{
+            type: typeTemplates,
+            zod: {
+                controller: 'vovk-zod/module-templates/controller.ts.ejs',
+            },
+            yup: {
+                controller: 'vovk-yup/module-templates/controller.ts.ejs',
+            },
+            'class-validator': {
+                controller: 'vovk-dto/module-templates/controller.ts.ejs',
+            },
+            valibot: {
+                controller: 'vovk-cli/module-templates/valibot/controller.ts.ejs',
+            },
+            arktype: {
+                controller: 'vovk-cli/module-templates/arktype/controller.ts.ejs',
+            },
+        }[validationLibrary ?? 'type'],
     };
     config.imports ??= {};
-    config.imports.validateOnClient = validationLibrary === 'vovk-dto' ? 'vovk-dto/validateOnClient' : 'vovk-ajv';
-    if (validationLibrary) {
+    config.imports.validateOnClient = validationLibrary === 'class-validator' ? 'vovk-dto/validateOnClient' : 'vovk-ajv';
+    if (validationLibrary && !moduleTemplates) {
         try {
+            // TODO: Legacy, is it useful to keep it?
             const validationTemplates = await getTemplateFilesFromPackage(validationLibrary, channel);
             Object.assign(moduleTemplates, validationTemplates);
         }

package/dist/init/createStandardSchemaValidatorFile.d.mts

@@ -0,0 +1,4 @@
+export declare function createStandardSchemaValidatorFile({ cwd, validationLibrary, }: {
+    cwd: string;
+    validationLibrary: 'arktype' | 'valibot';
+}): Promise<void>;

package/dist/init/createStandardSchemaValidatorFile.mjs

@@ -0,0 +1,38 @@
+import fs from 'fs/promises';
+import getRelativeSrcRoot from '../getProjectInfo/getConfig/getRelativeSrcRoot.mjs';
+import path from 'path';
+function getCode(validationLibrary) {
+    if (validationLibrary === 'valibot') {
+        return `
+import { createStandardValidation, KnownAny } from 'vovk';
+import { toJsonSchema } from '@valibot/to-json-schema';
+import * as v from 'valibot';
+
+const withValibot = createStandardValidation({
+  toJSONSchema: (model: v.BaseSchema<KnownAny, KnownAny, KnownAny>) => toJsonSchema(model),
+});
+
+export default withValibot;
+`.trimStart();
+    }
+    if (validationLibrary === 'arktype') {
+        return `
+import { createStandardValidation } from 'vovk';
+import { type } from 'arktype';
+
+const withArk = createStandardValidation({
+  toJSONSchema: (model: type) => model.toJsonSchema(),
+});
+
+export default withArk;
+`.trimStart();
+    }
+    throw new Error(`Unknown validation library: ${validationLibrary}`);
+}
+export async function createStandardSchemaValidatorFile({ cwd, validationLibrary, }) {
+    const code = getCode(validationLibrary);
+    const srcRoot = (await getRelativeSrcRoot({ cwd })) ?? '.';
+    const libDir = path.join(cwd, srcRoot, 'lib');
+    await fs.mkdir(libDir, { recursive: true });
+    await fs.writeFile(path.join(libDir, `${validationLibrary === 'arktype' ? 'withArk' : 'withValibot'}.ts`), code);
+}

package/dist/init/index.mjs

@@ -8,18 +8,28 @@ 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, { getBuildScript, getDevScript } 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 { createStandardSchemaValidatorFile } from './createStandardSchemaValidatorFile.mjs';
 export class Init {
     root;
     log;
-    async #init({ configPaths, pkgJson, }, { useNpm, useYarn, usePnpm, useBun, skipInstall, updateTsConfig, updateScripts, validationLibrary, lang, dryRun, channel, }) {
+    async #init({ configPaths, pkgJson, cwd = process.cwd(), }, { useNpm, useYarn, usePnpm, useBun, skipInstall, updateTsConfig, updateScripts, validationLibrary, lang, dryRun, channel, }) {
         const { log, root } = this;
-        const dependencies = ['vovk', 'vovk-client', 'vovk-ajv', 'openapi3-ts'];
+        const dependencies = [
+            'vovk',
+            'vovk-client',
+            'openapi3-ts',
+            'vovk-ajv',
+            'ajv',
+            'ajv-errors',
+            'ajv-formats',
+            'ajv-i18n',
+        ];
         const devDependencies = ['vovk-cli'];
         if (lang?.includes('py')) {
             devDependencies.push('vovk-python');
@@ -33,9 +43,18 @@ export class Init {
             log.debug(`Deleted existing config file${configPaths.length > 1 ? 's' : ''} at ${configPaths.join(', ')}`);
         }
         if (validationLibrary) {
-            dependencies.push(validationLibrary, ...({
-                'vovk-zod': ['zod'],
-                'vovk-dto': ['class-validator', 'class-transformer', 'dto-mapped-types', 'reflect-metadata'],
+            dependencies.push(...({
+                zod: ['zod', 'vovk-zod'],
+                'class-validator': [
+                    'class-validator',
+                    'class-transformer',
+                    'dto-mapped-types',
+                    'reflect-metadata',
+                    'vovk-dto',
+                ],
+                yup: ['yup', 'vovk-yup'],
+                valibot: ['valibot', '@valibot/to-json-schema'],
+                arktype: ['arktype'],
             }[validationLibrary] ?? []));
         }
         if (updateScripts) {
@@ -56,7 +75,7 @@ export class Init {
                 const compilerOptions = {
                     experimentalDecorators: true,
                 };
-                if (validationLibrary === 'vovk-dto') {
+                if (validationLibrary === 'class-validator') {
                     compilerOptions.emitDecoratorMetadata = true;
                 }
                 if (!dryRun)
@@ -120,6 +139,12 @@ export class Init {
                 }
             }
         }
+        if (validationLibrary === 'valibot' || validationLibrary === 'arktype') {
+            createStandardSchemaValidatorFile({
+                cwd,
+                validationLibrary,
+            });
+        }
         try {
             const { configAbsolutePath } = await createConfig({
                 root,
@@ -135,13 +160,13 @@ export class Init {
     async main({ prefix, yes, logLevel, useNpm, useYarn, usePnpm, useBun, skipInstall, updateTsConfig, updateScripts, validationLibrary, lang, dryRun, channel, }) {
         const cwd = process.cwd();
         const root = path.resolve(cwd, prefix ?? '.');
-        const log = getLogger(logLevel);
+        const log = getLogger(logLevel ?? 'info');
         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, pkgJson }, {
+            return this.#init({ configPaths, pkgJson, cwd }, {
                 prefix: prefix ?? '.',
                 useNpm: useNpm ?? (!useYarn && !usePnpm && !useBun),
                 useYarn: useYarn ?? false,
@@ -150,7 +175,7 @@ export class Init {
                 skipInstall: skipInstall ?? false,
                 updateTsConfig: updateTsConfig ?? true,
                 updateScripts: updateScripts ?? 'implicit',
-                validationLibrary: validationLibrary?.toLocaleLowerCase() === 'none' ? null : (validationLibrary ?? 'vovk-zod'),
+                validationLibrary: validationLibrary?.toLocaleLowerCase() === 'none' ? null : (validationLibrary ?? 'zod'),
                 dryRun: dryRun ?? false,
                 channel: channel ?? 'latest',
                 lang: lang ?? [],
@@ -174,17 +199,27 @@ export class Init {
                 : (validationLibrary ??
                     (await select({
                         message: 'Choose validation library',
-                        default: 'vovk-zod',
+                        default: 'zod',
                         choices: [
                             {
-                                name: 'vovk-zod',
-                                value: 'vovk-zod',
+                                name: 'Zod',
+                                value: 'zod',
                                 description: 'Use Zod for data validation',
                             },
                             {
-                                name: 'vovk-dto',
-                                value: 'vovk-dto',
-                                description: 'Use class-validator for data validation. Also installs class-transformer, dto-mapped-types and reflect-metadata',
+                                name: 'class-validator',
+                                value: 'class-validator',
+                                description: 'Use class-validator for data validation',
+                            },
+                            {
+                                name: 'Valibot',
+                                value: 'valibot',
+                                description: 'Use valibot for data validation.',
+                            },
+                            {
+                                name: 'ArkType',
+                                value: 'arktype',
+                                description: 'Use arktype for data validation.',
                             },
                             { name: 'None', value: null, description: 'Install validation library later' },
                         ],
@@ -196,12 +231,12 @@ export class Init {
                 {
                     name: 'Yes, use "concurrently" implicitly',
                     value: 'implicit',
-                    description: `The "dev" 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')}"`)} and the "build" scrilt will run "vovk generate" before "next build" ${chalk.whiteBright.bold(`"${getBuildScript(pkgJson)}"`)}`,
+                    description: `The "dev" 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')}"`)} and the "prebuild" script will run "vovk generate"`,
                 },
                 {
                     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(`"${getDevScript(pkgJson, 'explicit')}"`)} and the "build" scrilt will run "vovk generate" before "next build" ${chalk.whiteBright.bold(`"${getBuildScript(pkgJson)}"`)}`,
+                    description: `The "dev" script will use pre-defined PORT variable and run "next dev" and "vovk dev" as "concurrently" CLI arguments ${chalk.whiteBright.bold(`"${getDevScript(pkgJson, 'explicit')}"`)} and the "prebuild" script will run "vovk generate"`,
                 },
                 {
                     name: 'No',
@@ -220,7 +255,7 @@ export class Init {
             }
             if (shouldAsk) {
                 const keys = ['experimentalDecorators'];
-                if (validationLibrary === 'vovk-dto') {
+                if (validationLibrary === 'class-validator') {
                     keys.push('emitDecoratorMetadata');
                 }
                 updateTsConfig = await confirm({
@@ -229,13 +264,13 @@ export class Init {
             }
         }
         lang ??= await checkbox({
-            message: 'Do you want to generate RPC client for other languages besides TypeScript (beta)?',
+            message: 'Do you want to generate RPC client for other languages besides TypeScript (experimental)?',
             choices: [
                 { name: 'Python', value: 'py' },
                 { name: 'Rust', value: 'rs' },
             ],
         });
-        await this.#init({ configPaths, pkgJson }, {
+        await this.#init({ configPaths, pkgJson, cwd }, {
             useNpm: useNpm ?? (!useYarn && !usePnpm && !useBun),
             useYarn: useYarn ?? false,
             usePnpm: usePnpm ?? false,

package/dist/init/updateNPMScripts.d.mts

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

package/dist/init/updateNPMScripts.mjs

@@ -5,16 +5,12 @@ export function getDevScript(pkgJson, updateScriptsMode) {
         ? `PORT=3000 concurrently '${nextDev}' 'vovk dev' --kill-others`
         : `vovk dev --next-dev${nextDevFlags ? ` -- ${nextDevFlags}` : ''}`;
 }
-export function getBuildScript(pkgJson) {
-    const nextBuild = pkgJson.content.scripts?.build ?? 'next build';
-    return `vovk generate && ${nextBuild}`;
-}
 export default async function updateNPMScripts(pkgJson, root, updateScriptsMode) {
     pkgJson.update({
         scripts: {
             ...pkgJson.content.scripts,
             dev: getDevScript(pkgJson, updateScriptsMode),
-            build: getBuildScript(pkgJson),
+            prebuild: 'vovk generate',
         },
     });
     await pkgJson.save();

package/dist/initProgram.mjs

@@ -14,7 +14,7 @@ export function initProgram(program) {
         .option('--update-ts-config', 'update tsconfig.json')
         .option('--update-scripts <mode>', 'update package.json scripts ("implicit" or "explicit")')
         .option('--lang <languages...>', 'generate client for other programming languages by default ("py" for Python and "rs" for Rust are supported)')
-        .option('--validation-library <library>', 'validation library to use ("vovk-zod", "vovk-dto" or another); set to "none" to skip')
+        .option('--validation-library <library>', 'validation library to use ("zod", "class-validator", "valibot", "arktype" or another); set to "none" to skip')
         .option('--channel <channel>', 'channel to use for fetching packages', 'latest')
         .option('--dry-run', 'do not write files to disk')
         .action((options) => new Init().main(options));

package/dist/new/index.d.mts

@@ -1,2 +1,3 @@
 import type { NewOptions } from '../types.mjs';
-export declare function newComponents(components: string[], { dryRun, dir, templates, overwrite, noSegmentUpdate, empty, static: isStaticSegment }: NewOptions): Promise<void>;
+import type { ProjectInfo } from '../getProjectInfo/index.mts';
+export declare function newComponents(components: string[], projectInfo: ProjectInfo, { dryRun, dir, templates, overwrite, noSegmentUpdate, empty, static: isStaticSegment }: NewOptions): Promise<void>;

package/dist/new/index.mjs

@@ -1,6 +1,6 @@
 import newModule from './newModule.mjs';
 import newSegment from './newSegment.mjs';
-export async function newComponents(components, { dryRun, dir, templates, overwrite, noSegmentUpdate, empty, static: isStaticSegment }) {
+export async function newComponents(components, projectInfo, { dryRun, dir, templates, overwrite, noSegmentUpdate, empty, static: isStaticSegment }) {
     if (components[0] === 'segment' || components[0] === 'segments') {
         // vovk new segment [segmentName]
         let segmentNames = components
@@ -10,7 +10,7 @@ export async function newComponents(components, { dryRun, dir, templates, overwr
             segmentNames = [''];
         }
         for (const segmentName of segmentNames) {
-            await newSegment({ segmentName, isStaticSegment, overwrite, dryRun });
+            await newSegment({ projectInfo, segmentName, isStaticSegment, overwrite, dryRun });
         }
     }
     else {
@@ -24,6 +24,7 @@ export async function newComponents(components, { dryRun, dir, templates, overwr
             throw new Error('A module name with an optional segment cannot be empty');
         }
         await newModule({
+            projectInfo,
             what,
             moduleNameWithOptionalSegment,
             dir,

package/dist/new/newModule.d.mts

@@ -1,4 +1,6 @@
-export default function newModule({ what, moduleNameWithOptionalSegment, dryRun, dir: dirFlag, templates: templatesFlag, noSegmentUpdate, overwrite, empty, }: {
+import type { ProjectInfo } from '../getProjectInfo/index.mjs';
+export default function newModule({ projectInfo, what, moduleNameWithOptionalSegment, dryRun, dir: dirFlag, templates: templatesFlag, noSegmentUpdate, overwrite, empty, }: {
+    projectInfo: ProjectInfo;
     what: string[];
     moduleNameWithOptionalSegment: string;
     dryRun?: boolean;

package/dist/new/newModule.mjs

@@ -3,7 +3,6 @@ import fs from 'node:fs/promises';
 import { getTsconfig } from 'get-tsconfig';
 import render from './render.mjs';
 import addClassToSegmentCode from './addClassToSegmentCode.mjs';
-import getProjectInfo from '../getProjectInfo/index.mjs';
 import chalkHighlightThing from '../utils/chalkHighlightThing.mjs';
 import formatLoggedSegmentName from '../utils/formatLoggedSegmentName.mjs';
 import getFileSystemEntryType from '../utils/getFileSystemEntryType.mjs';
@@ -20,8 +19,8 @@ function splitByLast(str, delimiter = '/') {
     const after = str.substring(index + delimiter.length);
     return [before, after];
 }
-export default async function newModule({ what, moduleNameWithOptionalSegment, dryRun, dir: dirFlag, templates: templatesFlag, noSegmentUpdate, overwrite, empty, }) {
-    const { config, log, cwd, apiDirAbsolutePath } = await getProjectInfo();
+export default async function newModule({ projectInfo, what, moduleNameWithOptionalSegment, dryRun, dir: dirFlag, templates: templatesFlag, noSegmentUpdate, overwrite, empty, }) {
+    const { config, log, cwd, apiDirAbsolutePath } = projectInfo;
     const segments = await locateSegments({ dir: apiDirAbsolutePath, config, log });
     const isNodeNextResolution = ['node16', 'nodenext'].includes((await getTsconfig(cwd)?.config?.compilerOptions?.moduleResolution?.toLowerCase()) ?? '');
     let templates = config.moduleTemplates;

package/dist/new/newSegment.d.mts

@@ -1,4 +1,6 @@
-export default function newSegment({ segmentName, isStaticSegment, overwrite, dryRun, }: {
+import type { ProjectInfo } from '../getProjectInfo/index.mjs';
+export default function newSegment({ projectInfo, segmentName, isStaticSegment, overwrite, dryRun, }: {
+    projectInfo: ProjectInfo;
     segmentName: string;
     isStaticSegment?: boolean;
     overwrite?: boolean;

package/dist/new/newSegment.mjs

@@ -1,13 +1,12 @@
 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';
 import formatLoggedSegmentName from '../utils/formatLoggedSegmentName.mjs';
 import prettify from '../utils/prettify.mjs';
 import chalk from 'chalk';
-export default async function newSegment({ segmentName, isStaticSegment, overwrite, dryRun, }) {
-    const { apiDirAbsolutePath, log, config } = await getProjectInfo();
+export default async function newSegment({ projectInfo, segmentName, isStaticSegment, overwrite, dryRun, }) {
+    const { apiDirAbsolutePath, log, config } = projectInfo;
     if (!apiDirAbsolutePath) {
         throw new Error('No API directory found. Please ensure you are in a Nest.js project.');
     }

package/dist/types.d.mts

@@ -12,6 +12,7 @@ export interface DevOptions {
     nextDev?: boolean;
     exit?: boolean;
     devHttps?: boolean;
+    logLevel?: LogLevelNames;
 }
 export interface GenerateOptions {
     prettify?: boolean;
@@ -35,22 +36,24 @@ export interface GenerateOptions {
     segmentedOnly?: boolean;
     segmentedIncludeSegments?: string[];
     segmentedExcludeSegments?: string[];
+    logLevel?: LogLevelNames;
 }
 export interface BundleOptions extends Partial<Pick<VovkStrictConfig['bundle'], 'prebundleOutDir' | 'keepPrebundleDir' | 'includeSegments' | 'excludeSegments'>> {
     config?: string;
     schema?: string;
     outDir?: string;
     origin?: string;
+    tsconfig?: string;
     openapiSpec?: string[];
     openapiGetModuleName?: string[];
     openapiGetMethodName?: string[];
     openapiRootUrl?: string[];
     openapiMixinName?: string[];
+    logLevel?: LogLevelNames;
 }
 export interface InitOptions {
     prefix?: string;
     yes?: boolean;
-    logLevel: LogLevelNames;
     useNpm?: boolean;
     useYarn?: boolean;
     usePnpm?: boolean;
@@ -58,10 +61,11 @@ export interface InitOptions {
     skipInstall?: boolean;
     updateTsConfig?: boolean;
     updateScripts?: 'implicit' | 'explicit';
-    validationLibrary?: string | null;
+    validationLibrary?: 'zod' | 'yup' | 'class-validator' | 'valibot' | 'arktype' | null;
     dryRun?: boolean;
     lang?: string[];
     channel?: 'latest' | 'beta' | 'draft';
+    logLevel?: LogLevelNames;
 }
 export interface NewOptions {
     dryRun?: boolean;
@@ -71,6 +75,7 @@ export interface NewOptions {
     noSegmentUpdate?: boolean;
     empty?: boolean;
     static?: boolean;
+    logLevel?: LogLevelNames;
 }
 export type VovkEnv = {
     PORT?: string;
@@ -78,9 +83,9 @@ export type VovkEnv = {
     VOVK_ORIGIN?: string;
     VOVK_ROOT_ENTRY?: string;
     VOVK_API_ENTRY_POINT?: string;
-    VOVK_LOG_LEVEL?: LogLevelNames;
     __VOVK_START_WATCHER_IN_STANDALONE_MODE__?: 'true';
     __VOVK_SCHEMA_OUT_FLAG__?: string;
     __VOVK_DEV_HTTPS_FLAG__?: 'true' | 'false';
     __VOVK_EXIT__?: 'true' | 'false';
+    __VOVK_LOG_LEVEL__?: LogLevelNames;
 };

package/module-templates/arktype/controller.ts.ejs

@@ -0,0 +1,68 @@
+<% const vars = { 
+  ModuleName: t.TheThing + 'Controller',
+  ServiceName: t.TheThing + 'Service',
+}; %>
+---
+dir: <%= t.defaultDir %>
+fileName: <%= vars.ModuleName + '.ts' %>
+sourceName: <%= vars.ModuleName %>
+compiledName: <%= t.TheThing + 'RPC' %>
+---
+
+import { prefix, get, put, post, del, openapi } from 'vovk';
+import { type } from 'arktype';
+import withArk from '@/lib/withArk<%= t.nodeNextResolutionExt.ts %>';
+<% if(t.withService) { %>
+import <%= vars.ServiceName %> from './<%= vars.ServiceName %><%= t.nodeNextResolutionExt.ts %>';
+<% } %>
+
+@prefix('<%= t['the-things'] %>')
+export default class <%= vars.ModuleName %> {
+    @openapi({
+      summary: 'Get <%= t.TheThings %>',
+    })
+    @get()
+    static get<%= t.TheThings %> = withArk({
+        query: type({ search: type('string') }), 
+        handle(req) {
+            const search = req.nextUrl.searchParams.get('search');
+            <% if(t.withService) { %>
+            return <%= vars.ServiceName %>.get<%= t.TheThings %>(search);
+            <% } else { %>
+            return { results: [], search };
+            <% } %>
+        }
+    });
+
+    @openapi({
+        summary: 'Update <%= t.TheThing %>',
+    })
+    @put('{id}')
+    static update<%= t.TheThing %> = withArk({
+        body: type({
+          foo: type('"bar" | "baz"'),
+        }),
+        query: type({ q: type('string') }),
+        params: type({ id: type('string') }),
+        async handle(req, params) {
+            const { id } = params;
+            const body = await req.json();
+            const q = req.nextUrl.searchParams.get('q');
+            <% if(t.withService) { %>
+            return <%= vars.ServiceName %>.update<%= t.TheThing %>(id, q, body);
+            <% } else { %>
+            return { id, body, q };
+            <% } %>
+        }
+    });
+
+    @post()
+    static create<%= t.TheThing %> = () => {
+        // ...
+    };
+
+    @del(':id')
+    static delete<%= t.TheThing %> = () => {
+        // ...
+    };
+}

package/module-templates/valibot/controller.ts.ejs

@@ -0,0 +1,68 @@
+<% const vars = { 
+  ModuleName: t.TheThing + 'Controller',
+  ServiceName: t.TheThing + 'Service',
+}; %>
+---
+dir: <%= t.defaultDir %>
+fileName: <%= vars.ModuleName + '.ts' %>
+sourceName: <%= vars.ModuleName %>
+compiledName: <%= t.TheThing + 'RPC' %>
+---
+
+import { prefix, get, put, post, del, openapi } from 'vovk';
+import * as v from 'valibot';
+import withValibot from '@/lib/withValibot<%= t.nodeNextResolutionExt.ts %>';
+<% if(t.withService) { %>
+import <%= vars.ServiceName %> from './<%= vars.ServiceName %><%= t.nodeNextResolutionExt.ts %>';
+<% } %>
+
+@prefix('<%= t['the-things'] %>')
+export default class <%= vars.ModuleName %> {
+    @openapi({
+      summary: 'Get <%= t.TheThings %>',
+    })
+    @get()
+    static get<%= t.TheThings %> = withValibot({
+        query: v.object({ search: v.string() }), 
+        handle(req) {
+            const search = req.nextUrl.searchParams.get('search');
+            <% if(t.withService) { %>
+            return <%= vars.ServiceName %>.get<%= t.TheThings %>(search);
+            <% } else { %>
+            return { results: [], search };
+            <% } %>
+        }
+    });
+
+    @openapi({
+        summary: 'Update <%= t.TheThing %>',
+    })
+    @put('{id}')
+    static update<%= t.TheThing %> = withValibot({
+        body: v.object({
+          foo: v.union([v.literal('bar'), v.literal('baz')]),
+        }),
+        query: v.object({ q: v.string() }),
+        params: v.object({ id: v.string() }),
+        async handle(req, params) {
+            const { id } = params;
+            const body = await req.json();
+            const q = req.nextUrl.searchParams.get('q');
+            <% if(t.withService) { %>
+            return <%= vars.ServiceName %>.update<%= t.TheThing %>(id, q, body);
+            <% } else { %>
+            return { id, body, q };
+            <% } %>
+        }
+    });
+
+    @post()
+    static create<%= t.TheThing %> = () => {
+        // ...
+    };
+
+    @del(':id')
+    static delete<%= t.TheThing %> = () => {
+        // ...
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vovk-cli",
-  "version": "0.0.1-draft.332",
+  "version": "0.0.1-draft.334",
   "bin": {
     "vovk": "./dist/index.mjs"
   },
@@ -35,7 +35,7 @@
   },
   "homepage": "https://vovk.dev",
   "peerDependencies": {
-    "vovk": "^3.0.0-draft.366"
+    "vovk": "^3.0.0-draft.396"
   },
   "optionalDependencies": {
     "@rolldown/binding-linux-x64-gnu": "1.0.0-beta.31"