vovk-cli 0.0.1-draft.36 → 0.0.1-draft.360

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

@@ -0,0 +1,78 @@
+import { VovkSchemaIdEnum, type VovkStrictConfig } from 'vovk';
+import type { LogLevelNames } from 'loglevel';
+export default function getConfig({ configPath, cwd, logLevel, }: {
+    configPath?: string;
+    cwd: string;
+    logLevel?: LogLevelNames;
+}): Promise<{
+    config: VovkStrictConfig;
+    srcRoot: string | null;
+    configAbsolutePaths: string[];
+    userConfig: {
+        $schema?: typeof VovkSchemaIdEnum.CONFIG | (string & {});
+        emitConfig?: boolean | (keyof VovkStrictConfig | (string & {}))[];
+        schemaOutDir?: string;
+        modulesDir?: string;
+        rootEntry?: string;
+        logLevel?: "error" | "trace" | "debug" | "info" | "warn" | (string & {});
+        libs?: {
+            ajv: import("vovk").KnownAny;
+            [key: string]: import("vovk").KnownAny;
+        };
+        devHttps?: boolean;
+        composedClient?: {
+            enabled?: boolean;
+            outDir?: string;
+            fromTemplates?: string[];
+            prettifyClient?: boolean;
+        } & ({
+            excludeSegments?: never;
+            includeSegments?: string[];
+        } | {
+            excludeSegments?: string[];
+            includeSegments?: never;
+        });
+        segmentedClient?: {
+            enabled?: boolean;
+            outDir?: string;
+            fromTemplates?: string[];
+            prettifyClient?: boolean;
+        } & ({
+            excludeSegments?: never;
+            includeSegments?: string[];
+        } | {
+            excludeSegments?: string[];
+            includeSegments?: never;
+        });
+        bundle?: {
+            requires?: Record<string, string>;
+            prebundleOutDir?: string;
+            keepPrebundleDir?: boolean;
+            tsdownBuildOptions?: Parameters<typeof import("tsdown/index.mjs").build>[0];
+            generatorConfig?: import("vovk").VovkGeneratorConfig;
+        } & ({
+            excludeSegments?: never;
+            includeSegments?: string[];
+        } | {
+            excludeSegments?: string[];
+            includeSegments?: never;
+        });
+        clientTemplateDefs?: Record<string, import("vovk/types").ClientTemplateDef>;
+        rootSegmentModulesDirName?: string;
+        moduleTemplates?: {
+            service?: string;
+            controller?: string;
+            [key: string]: string | undefined;
+        };
+        generatorConfig?: import("vovk").VovkGeneratorConfig & {
+            segments?: Record<string, import("vovk/types").VovkSegmentConfig>;
+        };
+    } | null;
+    log: {
+        info: (msg: string) => void;
+        warn: (msg: string) => void;
+        error: (msg: string) => void;
+        debug: (msg: string) => void;
+        raw: import("loglevel").RootLogger;
+    };
+}>;

package/dist/getProjectInfo/getConfig/index.mjs

@@ -0,0 +1,91 @@
+import path from 'node:path';
+import { VovkSchemaIdEnum } from 'vovk';
+import getLogger from '../../utils/getLogger.mjs';
+import getUserConfig from './getUserConfig.mjs';
+import getRelativeSrcRoot from './getRelativeSrcRoot.mjs';
+import getTemplateDefs, { BuiltInTemplateName } from './getTemplateDefs.mjs';
+import { normalizeOpenAPIMixin } from '../../utils/normalizeOpenAPIMixin.mjs';
+import chalkHighlightThing from '../../utils/chalkHighlightThing.mjs';
+export default async function getConfig({ configPath, cwd, logLevel, }) {
+    const { configAbsolutePaths, error, userConfig } = await getUserConfig({
+        configPath,
+        cwd,
+    });
+    const conf = userConfig ?? {};
+    logLevel = logLevel ?? conf.logLevel ?? 'info';
+    const log = getLogger(logLevel);
+    const env = process.env;
+    const clientTemplateDefs = getTemplateDefs(conf.clientTemplateDefs);
+    const srcRoot = await getRelativeSrcRoot({ cwd });
+    const config = {
+        $schema: VovkSchemaIdEnum.CONFIG,
+        clientTemplateDefs,
+        emitConfig: [],
+        composedClient: {
+            ...conf.composedClient,
+            enabled: conf.composedClient?.enabled ?? true,
+            fromTemplates: conf.composedClient?.fromTemplates ?? ['mjs', 'cjs'],
+            outDir: conf.composedClient?.outDir ?? './node_modules/.vovk-client',
+            prettifyClient: conf.composedClient?.prettifyClient ?? false,
+        },
+        segmentedClient: {
+            ...conf.segmentedClient,
+            enabled: conf.segmentedClient?.enabled ?? false,
+            fromTemplates: conf.segmentedClient?.fromTemplates ?? ['ts'],
+            outDir: conf.segmentedClient?.outDir ?? path.join(srcRoot ?? '.', 'client'),
+            prettifyClient: conf.segmentedClient?.prettifyClient ?? true,
+        },
+        bundle: {
+            prebundleOutDir: conf.bundle?.prebundleOutDir ?? 'tmp_prebundle',
+            keepPrebundleDir: conf.bundle?.keepPrebundleDir ?? false,
+            requires: {
+                [BuiltInTemplateName.readme]: '.',
+                [BuiltInTemplateName.packageJson]: '.',
+            },
+            generatorConfig: {},
+            ...conf.bundle,
+            tsdownBuildOptions: {
+                outDir: conf.bundle?.tsdownBuildOptions?.outDir ?? 'dist',
+                ...conf.bundle?.tsdownBuildOptions,
+            },
+        },
+        modulesDir: conf.modulesDir ?? path.join(srcRoot ?? '.', 'modules'),
+        schemaOutDir: env.VOVK_SCHEMA_OUT_DIR ?? conf.schemaOutDir ?? './.vovk-schema',
+        rootEntry: env.VOVK_ROOT_ENTRY ?? conf.rootEntry ?? 'api',
+        rootSegmentModulesDirName: conf.rootSegmentModulesDirName ?? '',
+        logLevel,
+        devHttps: conf.devHttps ?? false,
+        moduleTemplates: {
+            service: 'vovk-cli/module-templates/service.ts.ejs',
+            controller: 'vovk-cli/module-templates/controller.ts.ejs',
+            ...conf.moduleTemplates,
+        },
+        libs: conf.libs ?? {},
+        generatorConfig: {
+            ...conf.generatorConfig,
+            origin: (env.VOVK_ORIGIN ?? conf?.generatorConfig?.origin ?? '').replace(/\/$/, ''), // Remove trailing slash
+            segments: Object.fromEntries(await Promise.all(Object.entries(conf.generatorConfig?.segments ?? {}).map(async ([key, value]) => [
+                key,
+                {
+                    ...value,
+                    openAPIMixin: value.openAPIMixin
+                        ? await normalizeOpenAPIMixin({ mixinModule: value.openAPIMixin, log, cwd })
+                        : undefined,
+                },
+            ]))),
+        },
+    };
+    if (typeof conf.emitConfig === 'undefined') {
+        config.emitConfig = ['libs', 'generatorConfig'];
+    }
+    else if (conf.emitConfig === true) {
+        config.emitConfig = Object.keys(config);
+    }
+    else if (Array.isArray(conf.emitConfig)) {
+        config.emitConfig = conf.emitConfig;
+    } // else it's false and emitConfig already is []
+    if (!userConfig) {
+        log.warn(`Unable to load config at ${chalkHighlightThing(cwd)}. Using default values. ${error ?? ''}`);
+    }
+    return { config, srcRoot, configAbsolutePaths, userConfig, log };
+}

package/dist/getProjectInfo/getMetaSchema.d.mts

@@ -0,0 +1,8 @@
+import { VovkSchemaIdEnum, type VovkStrictConfig } from 'vovk';
+export default function getMetaSchema({ config, useEmitConfig }: {
+    config: VovkStrictConfig;
+    useEmitConfig: boolean;
+}): {
+    config: VovkStrictConfig;
+    $schema: VovkSchemaIdEnum;
+};

package/dist/getProjectInfo/getMetaSchema.mjs

@@ -0,0 +1,14 @@
+import { VovkSchemaIdEnum } from 'vovk';
+import pick from 'lodash/pick.js';
+export default function getMetaSchema({ config, useEmitConfig }) {
+    return {
+        $schema: VovkSchemaIdEnum.META,
+        ...{
+            config: useEmitConfig
+                ? (config
+                    ? pick(config, [...config.emitConfig, '$schema'])
+                    : {})
+                : config,
+        },
+    };
+}

package/dist/getProjectInfo/index.d.mts

@@ -1,18 +1,23 @@
+import { LogLevelNames } from 'loglevel';
 export type ProjectInfo = Awaited<ReturnType<typeof getProjectInfo>>;
-export default function getProjectInfo({ port: givenPort, clientOutDir, cwd, }?: {
+export default function getProjectInfo({ port: givenPort, cwd, configPath, srcRootRequired, logLevel, }?: {
     port?: number;
-    clientOutDir?: string;
     cwd?: string;
+    configPath?: string;
+    srcRootRequired?: boolean;
+    logLevel?: LogLevelNames;
 }): Promise<{
     cwd: string;
     port: string;
-    apiEntryPoint: string;
-    apiDir: string;
-    srcRoot: string;
-    schemaOutImportPath: string;
-    fetcherClientImportPath: string;
-    validateOnClientImportPath: string | null;
-    config: Required<import("../types.mjs").VovkConfig>;
+    apiRoot: string;
+    apiDirAbsolutePath: string | null;
+    srcRoot: string | null;
+    vovkCliPackage: {
+        version: string;
+    };
+    config: import("vovk/types").VovkStrictConfig;
+    packageJson: import("type-fest").PackageJson;
+    isNextInstalled: boolean;
     log: {
         info: (msg: string) => void;
         warn: (msg: string) => void;

package/dist/getProjectInfo/index.mjs

@@ -1,37 +1,39 @@
 import path from 'node:path';
-import getConfig from './getConfig.mjs';
-import getLogger from '../utils/getLogger.mjs';
-export default async function getProjectInfo({ port: givenPort, clientOutDir, cwd = process.cwd(), } = {}) {
+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, 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, userConfig, error } = await getConfig({ clientOutDir, cwd });
-    const apiEntryPoint = `${config.origin ?? ''}/${config.rootEntry}`;
-    const apiDir = path.join(srcRoot, 'app', config.rootEntry);
-    const schemaOutImportPath = path.relative(config.clientOutDir, config.schemaOutDir).replace(/\\/g, '/'); // windows fix
-    const fetcherClientImportPath = config.fetcher.startsWith('.')
-        ? path.relative(config.clientOutDir, config.fetcher)
-        : config.fetcher;
-    const validateOnClientImportPath = config.validateOnClient?.startsWith('.')
-        ? path.relative(config.clientOutDir, config.validateOnClient)
-        : config.validateOnClient;
-    const log = getLogger(config.logLevel);
+    const { config, srcRoot, configAbsolutePaths, log } = await getConfig({
+        configPath,
+        cwd,
+        logLevel,
+    });
+    const packageJson = await getPackageJson(cwd, log);
+    const isNextInstalled = !!packageJson?.dependencies?.next || !!packageJson?.devDependencies?.next;
+    if (srcRootRequired && !srcRoot) {
+        throw new Error(`Could not find app router directory at ${cwd}. Check Next.js docs for more info.`);
+    }
+    const apiRoot = `${config.generatorConfig.origin ?? ''}/${config.rootEntry}`;
+    const apiDirAbsolutePath = srcRoot ? path.resolve(cwd, srcRoot, 'app', config.rootEntry) : null;
     if (configAbsolutePaths.length > 1) {
         log.warn(`Multiple config files found. Using the first one: ${configAbsolutePaths[0]}`);
     }
-    if (!userConfig && configAbsolutePaths.length > 0) {
-        log.error(`Error reading config file at ${configAbsolutePaths[0]}: ${error?.message ?? 'Unknown Error'}`);
-    }
+    const vovkCliPackage = JSON.parse(await readFile(path.join(import.meta.dirname, '../../package.json'), 'utf-8'));
     return {
         cwd,
         port,
-        apiEntryPoint,
-        apiDir,
+        apiRoot,
+        apiDirAbsolutePath,
         srcRoot,
-        schemaOutImportPath,
-        fetcherClientImportPath,
-        validateOnClientImportPath,
+        vovkCliPackage,
         config,
+        packageJson,
+        isNextInstalled,
         log,
     };
 }

package/dist/index.d.mts

@@ -1,4 +1,4 @@
 #!/usr/bin/env node
-import type { VovkConfig, VovkDevEnv } from './types.mjs';
 import 'dotenv/config';
-export type { VovkConfig, VovkDevEnv };
+import type { VovkEnv } from './types.mjs';
+export type { VovkEnv };

package/dist/index.mjs

@@ -1,54 +1,69 @@
 #!/usr/bin/env node
 import path from 'node:path';
 import { readFileSync } from 'node:fs';
+import 'dotenv/config';
 import { Command } from 'commander';
 import concurrently from 'concurrently';
 import getAvailablePort from './utils/getAvailablePort.mjs';
 import getProjectInfo from './getProjectInfo/index.mjs';
-import generateClient from './generateClient.mjs';
-import locateSegments from './locateSegments.mjs';
+import { VovkGenerate } from './generate/index.mjs';
+import { bundle } from './bundle/index.mjs';
 import { VovkDev } from './dev/index.mjs';
-import newComponents from './new/index.mjs';
-import 'dotenv/config';
-import initProgram from './initProgram.mjs';
-import { pathToFileURL } from 'node:url';
+import { newComponents } from './new/index.mjs';
+import { initProgram } from './initProgram.mjs';
+import { getProjectFullSchema } from './generate/getProjectFullSchema.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);
+const vovkCliPackage = JSON.parse(readFileSync(path.join(import.meta.dirname, '../package.json'), 'utf-8'));
+program.name('vovk').description('Vovk CLI').version(vovkCliPackage.version);
 initProgram(program.command('init'));
 program
     .command('dev')
+    .alias('d')
     .description('Start schema watcher (optional flag --next-dev to start it with Next.js)')
-    .option('--next-dev', 'Start schema watcher and Next.js with automatic port allocation', false)
-    .allowUnknownOption(true)
-    .action(async (options, command) => {
+    .argument('[nextArgs...]', 'extra arguments for the dev command')
+    .option('--next-dev', 'start schema watcher and Next.js with automatic port allocation')
+    .option('--exit', 'kill the 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, logLevel } = options;
     const portAttempts = 30;
-    const PORT = !options.nextDev
+    const PORT = !nextDev
         ? process.env.PORT
         : process.env.PORT ||
             (await getAvailablePort(3000, portAttempts, 0, (failedPort, tryingPort) => 
             // eslint-disable-next-line no-console
-            console.warn(`🐺 Next.js Port ${failedPort} is in use, trying ${tryingPort} instead.`)).catch(() => {
-                throw new Error(`🐺 ❌ Failed to find available Next port after ${portAttempts} attempts`);
+            console.warn(`🐺 Port ${failedPort} is in use, trying ${tryingPort} instead.`)).catch(() => {
+                throw new Error(`🐺 ❌ Failed to find an available port after ${portAttempts} attempts`);
             }));
     if (!PORT) {
         throw new Error('🐺 ❌ PORT env variable is required');
     }
-    if (options.nextDev) {
+    if (nextDev) {
         const { result } = concurrently([
             {
-                command: `npx next dev ${command.args.join(' ')}`,
+                command: `npx next dev ${nextArgs.join(' ')}`,
                 name: 'Next.js Development Server',
                 env: { PORT },
             },
             {
                 command: `node ${import.meta.dirname}/dev/index.mjs`,
-                name: 'Vovk Dev Command',
-                env: { PORT, __VOVK_START_WATCHER_IN_STANDALONE_MODE__: 'true' },
+                name: 'Vovk Dev Watcher',
+                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,
+                },
             },
         ], {
-            killOthers: ['failure', 'success'],
+            killOthersOn: ['failure', 'success'],
             prefix: 'none',
+            successCondition: 'first',
         });
         try {
             await result;
@@ -58,32 +73,99 @@ program
         }
     }
     else {
-        void new VovkDev().start();
+        void new VovkDev({ schemaOut, devHttps, logLevel }).start({ exit });
     }
 });
 program
     .command('generate')
-    .description('Generate client')
-    .option('--client-out <path>', 'Path to output directory')
-    .action(async (options) => {
-    const projectInfo = await getProjectInfo({ clientOutDir: options.clientOut });
-    const { cwd, config, apiDir } = projectInfo;
-    const segments = await locateSegments(apiDir);
-    const schemaOutAbsolutePath = path.join(cwd, config.schemaOutDir);
-    const schemaImportUrl = pathToFileURL(path.join(schemaOutAbsolutePath, 'index.js')).href;
-    const schema = await import(schemaImportUrl);
-    await generateClient(projectInfo, segments, schema.default);
+    .alias('g')
+    .description('Generate RPC client from schema')
+    .option('--composed-only', 'generate only composed client even if segmented client is enabled')
+    .option('--out, --composed-out <path>', 'path to output directory for composed client')
+    .option('--from, --composed-from <templates...>', 'client template names for composed client')
+    .option('--include, --composed-include-segments <segments...>', 'include segments in composed client')
+    .option('--exclude, --composed-exclude-segments <segments...>', 'exclude segments in composed client')
+    .option('--segmented-only', 'generate only segmented client even if composed client is enabled')
+    .option('--segmented-out <path>', 'path to output directory for segmented client')
+    .option('--segmented-from <templates...>', 'client template names for segmented client')
+    .option('--segmented-include-segments <segments...>', 'include segments in segmented client')
+    .option('--segmented-exclude-segments <segments...>', 'exclude segments in segmented client')
+    .option('--prettify', 'prettify output files')
+    .option('--schema, --schema-path <path>', 'path to schema folder (default: ./.vovk-schema)')
+    .option('--config, --config-path <config>', 'path to config file')
+    .option('--origin <url>', 'set the origin URL for the generated client')
+    .option('--watch [s]', 'watch for changes in schema or openapi spec and regenerate client; accepts a number in seconds to throttle the watcher or make an HTTP request to the OpenAPI spec URL')
+    .option('--openapi, --openapi-spec <openapi_path_or_urls...>', 'use OpenAPI schema for client generation')
+    .option('--openapi-module-name, --openapi-get-module-name <names...>', 'module names corresponding to the index of --openapi option')
+    .option('--openapi-method-name, --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('--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,
+        logLevel: cliGenerateOptions.logLevel,
+    });
+    await new VovkGenerate({
+        projectInfo,
+        forceNothingWrittenLog: true,
+        cliGenerateOptions,
+    }).start();
+});
+program
+    .command('bundle')
+    .alias('b')
+    .description('Generate TypeScript RPC and bundle it')
+    .option('--out, --out-dir <path>', 'path to output directory for bundle')
+    .option('--include, --include-segments <segments...>', 'include segments')
+    .option('--exclude, --exclude-segments <segments...>', 'exclude segments')
+    .option('--prebundle-out-dir, --prebundle-out <path>', 'path to output directory for prebundle')
+    .option('--keep-prebundle-dir', 'do not delete prebundle directory after bundling')
+    .option('--schema, --schema-path <path>', 'path to schema folder (default: .vovk-schema)')
+    .option('--config, --config-path <config>', 'path to config file')
+    .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.configPath,
+        srcRootRequired: false,
+        logLevel: cliBundleOptions.logLevel,
+    });
+    const { cwd, config, log, isNextInstalled } = projectInfo;
+    const fullSchema = await getProjectFullSchema({
+        schemaOutAbsolutePath: path.resolve(cwd, cliBundleOptions?.schema ?? config.schemaOutDir),
+        log,
+        isNextInstalled,
+        config,
+    });
+    await bundle({
+        projectInfo,
+        fullSchema,
+        cliBundleOptions,
+    });
 });
 program
     .command('new [components...]')
     .alias('n')
     .description('Create new components. "vovk new [...components] [segmentName/]moduleName" to create a new module or "vovk new segment [segmentName]" to create a new segment')
-    .option('-o, --overwrite', 'Overwrite existing files')
-    .option('--template, --templates <templates...>', 'Override config template. Accepts an array of strings that correspond the order of the components')
-    .option('--dir <dirname>', 'Override dirName in template file. Relative to the root of the project')
-    .option('--no-segment-update', 'Do not update segment files when creating a new module')
-    .option('--dry-run', 'Do not write files to disk')
-    .action((components, options) => newComponents(components, options));
+    .option('-o, --overwrite', 'overwrite existing files')
+    .option('--template, --templates <templates...>', 'override config template; accepts an array of strings that correspond the order of the components')
+    .option('--dir <dirname>', 'override dirName in template file; relative to the root of the project')
+    .option('--empty', 'create an empty module')
+    .option('--no-segment-update', 'do not update segment files when creating a new module')
+    .option('--dry-run', 'do not write files to disk')
+    .option('--static', 'if the segment is static')
+    .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.d.mts

@@ -1,9 +1,9 @@
 import type getLogger from '../utils/getLogger.mjs';
 import type { InitOptions } from '../types.mjs';
-export default function createConfig({ root, log, options: { validationLibrary, validateOnClient, channel, dryRun }, }: {
+export default function createConfig({ root, log, options: { validationLibrary, lang, channel, dryRun }, }: {
     root: string;
     log: ReturnType<typeof getLogger>;
-    options: Pick<InitOptions, 'validationLibrary' | 'validateOnClient' | 'channel' | 'dryRun'>;
+    options: Pick<InitOptions, 'validationLibrary' | 'lang' | 'channel' | 'dryRun'>;
 }): Promise<{
     configAbsolutePath: string;
 }>;

package/dist/init/createConfig.mjs

@@ -3,7 +3,7 @@ import fs from 'node:fs/promises';
 import getTemplateFilesFromPackage from './getTemplateFilesFromPackage.mjs';
 import prettify from '../utils/prettify.mjs';
 import getFileSystemEntryType, { FileSystemEntryType } from '../utils/getFileSystemEntryType.mjs';
-export default async function createConfig({ root, log, options: { validationLibrary, validateOnClient, channel, dryRun }, }) {
+export default async function createConfig({ root, log, options: { validationLibrary, lang, channel, dryRun }, }) {
     const config = {};
     const dotConfigPath = path.join(root, '.config');
     const dir = (await getFileSystemEntryType(dotConfigPath)) === FileSystemEntryType.DIRECTORY ? dotConfigPath : root;
@@ -11,26 +11,52 @@ 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 templates = {
-        controller: 'vovk-cli/templates/controller.ejs',
-        service: 'vovk-cli/templates/service.ejs',
-        worker: 'vovk-cli/templates/worker.ejs',
+    const typeTemplates = {
+        controller: 'vovk-cli/module-templates/type/controller.ts.ejs',
+        service: 'vovk-cli/module-templates/type/service.ts.ejs',
     };
-    if (validationLibrary) {
-        config.validationLibrary = validationLibrary;
-        if (validateOnClient) {
-            config.validateOnClient = `${validationLibrary}/validateOnClient`;
-        }
+    const moduleTemplates = {
+        ...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.generatorConfig ??= {};
+    config.generatorConfig.imports ??= {};
+    config.generatorConfig.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(templates, validationTemplates);
+            Object.assign(moduleTemplates, validationTemplates);
         }
         catch (error) {
             log.warn(`Failed to fetch validation library templates: ${error.message}`);
         }
     }
-    config.templates = templates;
-    const configStr = await prettify(`/** @type {import('vovk-cli').VovkConfig} */
+    if (lang?.length) {
+        config.composedClient ??= {};
+        config.composedClient.fromTemplates = ['mjs', 'cjs', ...lang];
+    }
+    config.moduleTemplates = moduleTemplates;
+    const configStr = await prettify(`// @ts-check
+/** @type {import('vovk').VovkConfig} */
 const config = ${JSON.stringify(config, null, 2)};
 ${isModule ? '\nexport default config;' : 'module.exports = config;'}`, configAbsolutePath);
     if (!dryRun)

package/dist/init/createStandardSchemaValidatorFile.d.mts

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

package/dist/init/createStandardSchemaValidatorFile.mjs

@@ -0,0 +1,39 @@
+import fs from 'fs/promises';
+import path from 'path';
+import getRelativeSrcRoot from '../getProjectInfo/getConfig/getRelativeSrcRoot.mjs';
+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({ root, validationLibrary, }) {
+    const code = getCode(validationLibrary);
+    const srcRoot = (await getRelativeSrcRoot({ cwd: root })) ?? '.';
+    const libDir = path.resolve(root, srcRoot, 'lib');
+    const filePath = path.join(libDir, `${validationLibrary === 'arktype' ? 'withArk' : 'withValibot'}.ts`);
+    await fs.mkdir(libDir, { recursive: true });
+    await fs.writeFile(filePath, code);
+}