vovk-cli 0.0.1-draft.99 → 0.0.3

package/dist/index.mjs

@@ -1,30 +1,32 @@
-#!/usr/bin/env node
+#!/usr/bin/env -S node --experimental-vm-modules --disable-warning=ExperimentalWarning
 import path from 'node:path';
 import { readFileSync } from 'node:fs';
-import { pathToFileURL } from 'node:url';
 import 'dotenv/config';
 import { Command } from 'commander';
 import concurrently from 'concurrently';
-import getAvailablePort from './utils/getAvailablePort.mjs';
-import getProjectInfo from './getProjectInfo/index.mjs';
-import generate from './generate/index.mjs';
-import locateSegments from './locateSegments.mjs';
+import { getAvailablePort } from './utils/getAvailablePort.mjs';
+import { getProjectInfo } from './getProjectInfo/index.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 initProgram from './initProgram.mjs';
+import { newComponents } from './new/index.mjs';
+import { getProjectFullSchema } from './generate/getProjectFullSchema.mjs';
+import { Init } from './init/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);
-initProgram(program.command('init'));
+const vovkCliPackage = JSON.parse(readFileSync(path.join(import.meta.dirname, '../package.json'), 'utf-8'));
+program.name('vovk').description('Vovk CLI').version(vovkCliPackage.version);
 program
     .command('dev')
     .alias('d')
-    .description('start schema watcher (optional flag --next-dev to start it with Next.js)')
-    .argument('[nextArgs...]', 'extra arguments for the dev command')
+    .description('Start schema watcher (optional flag --next-dev to start it with Next.js)')
+    .argument('[nextArgs...]', 'extra arguments for the implicit next dev command call')
     .option('--next-dev', 'start schema watcher and Next.js with automatic port allocation')
-    .option('--exit', 'kill the processe when schema and client is generated')
+    .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 } = options;
+    const { nextDev, exit = false, schemaOut, devHttps, logLevel } = options;
     const portAttempts = 30;
     const PORT = !nextDev
         ? process.env.PORT
@@ -50,11 +52,15 @@ 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,
                 },
             },
         ], {
-            killOthers: ['failure', 'success'],
+            killOthersOn: ['failure', 'success'],
             prefix: 'none',
             successCondition: 'first',
         });
@@ -66,46 +72,119 @@ program
         }
     }
     else {
-        void new VovkDev().start({ exit });
+        void new VovkDev({ schemaOut, devHttps, logLevel }).start({ exit });
     }
 });
 program
     .command('generate')
     .alias('g')
     .description('Generate RPC client from schema')
-    .option('--out, --client-out-dir <path>', 'path to output directory')
-    .option('--template, --templates <templates...>', 'client code templates ("ts", "compiled", "python", "none", a custom path)')
-    .option('--full-schema [fileName]', 'generate client with full 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')
-    .action(async (options) => {
-    const { clientOutDir, templates, prettify, fullSchema } = options;
-    const projectInfo = await getProjectInfo({ clientOutDir });
-    const { cwd, config, apiDir } = projectInfo;
-    const segments = await locateSegments({ dir: apiDir, config });
-    const schemaOutAbsolutePath = path.join(cwd, config.schemaOutDir);
-    const schemaImportUrl = pathToFileURL(path.join(schemaOutAbsolutePath, 'main.cjs')).href;
-    const { default: segmentsSchema } = (await import(schemaImportUrl));
-    await generate({
+    .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 URLs')
+    .option('--openapi, --openapi-spec <openapi_path_or_urls...>', 'use OpenAPI mixins for client generation')
+    .option('--openapi-module-name, --openapi-get-module-name <names...>', 'module name strategies corresponding to the index of --openapi option')
+    .option('--openapi-method-name, --openapi-get-method-name <names...>', 'method name strategies 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 corresponding to the index of --openapi option to a local file 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,
-        segments,
-        segmentsSchema,
-        templates,
-        prettify,
-        fullSchema,
         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('--openapi, --openapi-spec <openapi_path_or_urls...>', 'use OpenAPI mixins for client generation')
+    .option('--openapi-module-name, --openapi-get-module-name <names...>', 'module name strategies corresponding to the index of --openapi option')
+    .option('--openapi-method-name, --openapi-get-method-name <names...>', 'method name strategies 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 corresponding to the index of --openapi option to a local file and use it as a fallback if URL is not available')
+    .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?.schemaPath ?? 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')
+    .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('--empty', 'create an empty module')
-    .option('--no-segment-update', 'do not update segment files when creating a new module')
+    .option('--static', '(new segment only) if the segment is static')
+    .option('--template, --templates <templates...>', '(new module only) override config template; accepts an array of strings that correspond the order of the components')
+    .option('--out, --out-dir <dirname>', '(new module only) override outDir in template file; relative to the root of the project')
+    .option('--no-segment-update', '(new module only) do not update segment files when creating a new module')
+    .option('--empty', '(new module only) create an empty module')
+    .option('--dry-run', 'do not write files to disk')
+    .option('--log-level <level>', 'set the log level')
+    .action(async (components, newOptions) => newComponents(components, await getProjectInfo({
+    logLevel: newOptions.logLevel,
+}), newOptions));
+program
+    .command('init')
+    .description('Initialize Vovk.ts at existing Next.js project')
+    .option('--prefix <prefix>', 'directory to initialize project in')
+    .option('-y, --yes', 'skip all prompts and use default values')
+    .option('--log-level <level>', 'set log level', 'info')
+    .option('--use-npm', 'use npm as package manager')
+    .option('--use-yarn', 'use yarn as package manager')
+    .option('--use-pnpm', 'use pnpm as package manager')
+    .option('--use-bun', 'use bun as package manager')
+    .option('--skip-install', 'skip installing dependencies')
+    .option('--update-ts-config', 'update tsconfig.json')
+    .option('--update-scripts <mode>', 'update package.json scripts ("implicit" or "explicit")')
+    .option('--bundle', 'set up "tsdown" bundler')
+    .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 ("zod", "valibot" or "arktype"); 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((components, options) => newComponents(components, options));
+    .action((options) => new Init().main(options));
 program
     .command('help')
     .description('Show help message')

package/dist/init/checkTSConfigForExperimentalDecorators.d.mts

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

package/dist/init/checkTSConfigForExperimentalDecorators.mjs

@@ -1,14 +1,14 @@
 import path from 'node:path';
 import fs from 'node:fs/promises';
 import * as jsonc from 'jsonc-parser';
-export default async function checkTSConfigForExperimentalDecorators(root) {
+export 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)}`);
+        throw new Error(`Failed to read tsconfig.json at ${tsconfigPath}. You can run "npx tsc --init" to create it. ${String(error)}`, { cause: error });
     }
     const tsconfig = jsonc.parse(tsconfigContent);
     return !!tsconfig?.compilerOptions?.experimentalDecorators;

package/dist/init/createConfig.d.mts

@@ -1,9 +1,11 @@
-import type getLogger from '../utils/getLogger.mjs';
+import type { VovkStrictConfig } from 'vovk/internal';
+import type { getLogger } from '../utils/getLogger.mjs';
 import type { InitOptions } from '../types.mjs';
-export default function createConfig({ root, log, options: { validationLibrary, validateOnClient, reactQuery, channel, dryRun }, }: {
+export declare const BUNDLE_BUILD_TSDOWN: ({ entry, outDir }: Parameters<VovkStrictConfig["bundle"]["build"]>[0]) => Promise<void>;
+export declare function createConfig({ root, options: { validationLibrary, bundle, lang, dryRun }, }: {
     root: string;
     log: ReturnType<typeof getLogger>;
-    options: Pick<InitOptions, 'validationLibrary' | 'validateOnClient' | 'reactQuery' | 'channel' | 'dryRun'>;
+    options: Pick<InitOptions, 'validationLibrary' | 'bundle' | 'lang' | 'channel' | 'dryRun'>;
 }): Promise<{
     configAbsolutePath: string;
 }>;

package/dist/init/createConfig.mjs

@@ -1,39 +1,89 @@
 import path from 'node:path';
 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, reactQuery, channel, dryRun }, }) {
+import { prettify } from '../utils/prettify.mjs';
+import { getFileSystemEntryType, FileSystemEntryType } from '../utils/getFileSystemEntryType.mjs';
+import { updateConfigProperty } from '../utils/updateConfigProperty.mjs';
+export const BUNDLE_BUILD_TSDOWN = async ({ entry, outDir }) => {
+    const { build } = await import('tsdown');
+    await build({
+        entry,
+        dts: true,
+        format: 'esm',
+        hash: false,
+        fixedExtension: true,
+        clean: true,
+        outDir,
+        platform: 'neutral',
+        outExtensions: () => ({ js: '.js', dts: '.d.ts' }),
+        outputOptions: {
+            inlineDynamicImports: true,
+        },
+        inputOptions: {
+            resolve: {
+                mainFields: ['module', 'main'],
+            },
+        },
+        noExternal: ['!next/**'],
+    });
+};
+export async function createConfig({ root, options: { validationLibrary, bundle, lang, dryRun }, }) {
     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');
-    const templates = {
-        controller: 'vovk-cli/templates/controller.ejs',
-        service: 'vovk-cli/templates/service.ejs',
+    const configAbsolutePath = path.join(dir, 'vovk.config.mjs');
+    const typeTemplates = {
+        controller: 'vovk-cli/module-templates/type/controller.ts.ejs',
+        service: 'vovk-cli/module-templates/type/service.ts.ejs',
     };
-    if (validationLibrary) {
-        if (validateOnClient) {
-            config.validateOnClientImport = `${validationLibrary}/validateOnClient.js`;
-        }
-        try {
-            const validationTemplates = await getTemplateFilesFromPackage(validationLibrary, channel);
-            Object.assign(templates, validationTemplates);
-        }
-        catch (error) {
-            log.warn(`Failed to fetch validation library templates: ${error.message}`);
-        }
+    const moduleTemplates = {
+        ...typeTemplates,
+        ...{
+            type: typeTemplates,
+            zod: {
+                controller: 'vovk-cli/module-templates/zod/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.outputConfig ??= {};
+    config.outputConfig.imports ??= {};
+    config.outputConfig.imports.validateOnClient = 'vovk-ajv';
+    if (lang?.length) {
+        config.composedClient ??= {};
+        config.composedClient.fromTemplates = ['js', ...lang];
     }
-    if (reactQuery) {
-        config.createRPCImport = 'vovk-react-query';
+    config.moduleTemplates = moduleTemplates;
+    if (bundle) {
+        config.bundle ??= {};
+        config.bundle.outputConfig ??= {
+            imports: { validateOnClient: null },
+            package: {
+                type: 'module',
+                main: './index.js',
+                types: './index.d.ts',
+                exports: {
+                    '.': {
+                        default: './index.js',
+                        types: './index.d.ts',
+                    },
+                },
+            },
+        };
     }
-    config.templates = templates;
-    const configStr = await prettify(`/** @type {import('vovk-cli').VovkConfig} */
+    let configStr = `// @ts-check
+/** @type {import('vovk').VovkConfig} */
 const config = ${JSON.stringify(config, null, 2)};
-${isModule ? '\nexport default config;' : 'module.exports = config;'}`, configAbsolutePath);
+
+export default config;`;
+    if (bundle) {
+        configStr = await updateConfigProperty(configStr, ['bundle', 'build'], BUNDLE_BUILD_TSDOWN);
+    }
+    configStr = await prettify(configStr, configAbsolutePath);
     if (!dryRun)
         await fs.writeFile(configAbsolutePath, configStr, 'utf-8');
     return { configAbsolutePath };

package/dist/init/index.d.mts

@@ -1,8 +1,8 @@
+import { getLogger } from '../utils/getLogger.mjs';
 import type { InitOptions } from '../types.mjs';
-import getLogger from '../utils/getLogger.mjs';
 export declare class Init {
     #private;
     root: string;
     log: ReturnType<typeof getLogger>;
-    main(prefix: string, { yes, logLevel, useNpm, useYarn, usePnpm, useBun, skipInstall, updateTsConfig, updateScripts, validationLibrary, validateOnClient, reactQuery, dryRun, channel, }: InitOptions): Promise<void>;
+    main({ prefix, yes, logLevel, useNpm, useYarn, usePnpm, useBun, skipInstall, updateTsConfig, updateScripts, validationLibrary, bundle, lang, dryRun, channel, }: InitOptions): Promise<void>;
 }