vovk-cli 0.1.3 → 0.3.0-beta.0

package/dist/index.mjs

@@ -1,16 +1,16 @@
 #!/usr/bin/env -S node --experimental-vm-modules --disable-warning=ExperimentalWarning
-import path from 'node:path';
 import { readFileSync } from 'node:fs';
+import path from 'node:path';
 import 'dotenv/config';
 import { Command } from 'commander';
 import concurrently from 'concurrently';
-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 { getProjectFullSchema } from './generate/get-project-full-schema.mjs';
+import { VovkGenerate } from './generate/index.mjs';
+import { getProjectInfo } from './get-project-info/index.mjs';
 import { newComponents } from './new/index.mjs';
-import { getProjectFullSchema } from './generate/getProjectFullSchema.mjs';
+import { getAvailablePort } from './utils/get-available-port.mjs';
 import { Init } from './init/index.mjs';
 const program = new Command();
 const vovkCliPackage = JSON.parse(readFileSync(path.join(import.meta.dirname, '../package.json'), 'utf-8'));
@@ -31,13 +31,11 @@ program
     const PORT = !nextDev
         ? process.env.PORT
         : process.env.PORT ||
-            (await getAvailablePort(3000, portAttempts, 0, (failedPort, tryingPort) => 
-            // eslint-disable-next-line no-console
-            console.warn(`🐺 Port ${failedPort} is in use, trying ${tryingPort} instead.`)).catch(() => {
-                throw new Error(`🐺 ❌ Failed to find an available port after ${portAttempts} attempts`);
+            (await getAvailablePort(3000, portAttempts, 0, (failedPort, tryingPort) => 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');
+        throw new Error('PORT env variable is required');
     }
     if (nextDev) {
         const { result } = concurrently([
@@ -54,7 +52,7 @@ program
                     __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_DEV_HTTPS_FLAG__: devHttps ? 'true' : '',
                     __VOVK_EXIT__: exit ? 'true' : 'false',
                     __VOVK_LOG_LEVEL__: logLevel ?? undefined,
                 },
@@ -67,12 +65,16 @@ program
         try {
             await result;
         }
-        finally {
-            // do nothing, all processes are killed
+        catch (closeEvents) {
+            // concurrently rejects with child close events on shutdown; children already logged the reason
+            const hasFailure = Array.isArray(closeEvents) &&
+                closeEvents.some((event) => typeof event?.exitCode === 'number' && event.exitCode !== 0);
+            if (hasFailure)
+                process.exit(1);
         }
     }
     else {
-        void new VovkDev({ schemaOut, devHttps, logLevel }).start({ exit });
+        await new VovkDev({ schemaOut, devHttps, logLevel }).start({ exit });
     }
 });
 program
@@ -120,7 +122,8 @@ program
     .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')
+    // the last long flag names the option, it has to stay prebundleOutDir
+    .option('--prebundle-out, --prebundle-out-dir <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')
@@ -189,7 +192,13 @@ program
     .command('help')
     .description('Show help message')
     .action(() => program.help());
-program.parse(process.argv);
+program.parseAsync(process.argv).catch((error) => {
+    const logLevelFlagIndex = process.argv.indexOf('--log-level');
+    const isDebug = ['debug', 'trace'].includes(process.argv[logLevelFlagIndex + 1] ?? '');
+    const err = error instanceof Error ? error : new Error(String(error));
+    console.error(`🐺 ❌ ${isDebug ? (err.stack ?? err.message) : err.message}`);
+    process.exit(1);
+});
 if (!process.argv.slice(2).length) {
     program.outputHelp();
 }

package/dist/init/{createConfig.d.mts → create-config.d.mts}

@@ -1,6 +1,6 @@
 import type { VovkStrictConfig } from 'vovk/internal';
-import type { getLogger } from '../utils/getLogger.mjs';
 import type { InitOptions } from '../types.mjs';
+import type { getLogger } from '../utils/get-logger.mjs';
 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;

package/dist/init/{createConfig.mjs → create-config.mjs}

@@ -1,8 +1,8 @@
-import path from 'node:path';
 import fs from 'node:fs/promises';
+import path from 'node:path';
+import { FileSystemEntryType, getFileSystemEntryType } from '../utils/get-file-system-entry-type.mjs';
 import { prettify } from '../utils/prettify.mjs';
-import { getFileSystemEntryType, FileSystemEntryType } from '../utils/getFileSystemEntryType.mjs';
-import { updateConfigProperty } from '../utils/updateConfigProperty.mjs';
+import { updateConfigProperty } from '../utils/update-config-property.mjs';
 export const BUNDLE_BUILD_TSDOWN = async ({ entry, outDir }) => {
     const { build } = await import('tsdown');
     await build({
@@ -16,14 +16,14 @@ export const BUNDLE_BUILD_TSDOWN = async ({ entry, outDir }) => {
         platform: 'neutral',
         outExtensions: () => ({ js: '.js', dts: '.d.ts' }),
         outputOptions: {
-            inlineDynamicImports: true,
+            codeSplitting: false,
         },
         inputOptions: {
             resolve: {
                 mainFields: ['module', 'main'],
             },
         },
-        noExternal: ['!next/**'],
+        deps: { alwaysBundle: ['!next/**'] },
     });
 };
 export async function createConfig({ root, options: { validationLibrary, bundle, lang, dryRun }, }) {
@@ -55,7 +55,7 @@ export async function createConfig({ root, options: { validationLibrary, bundle,
     config.outputConfig.imports.validateOnClient = 'vovk-ajv';
     if (lang?.length) {
         config.composedClient ??= {};
-        config.composedClient.fromTemplates = ['js', ...lang];
+        config.composedClient.fromTemplates = ['ts', ...lang];
     }
     config.moduleTemplates = moduleTemplates;
     if (bundle) {

package/dist/init/index.d.mts

@@ -1,5 +1,5 @@
-import { getLogger } from '../utils/getLogger.mjs';
 import type { InitOptions } from '../types.mjs';
+import { getLogger } from '../utils/get-logger.mjs';
 export declare class Init {
     #private;
     root: string;

package/dist/init/index.mjs

@@ -1,25 +1,30 @@
-import { confirm, select, checkbox } from '@inquirer/prompts';
-import path from 'node:path';
 import fs from 'node:fs/promises';
-import chalk from 'chalk';
+import path from 'node:path';
+import { checkbox, confirm, select } from '@inquirer/prompts';
 import NPMCliPackageJson from '@npmcli/package-json';
-import { getConfigAbsolutePaths } from '../getProjectInfo/getConfig/getConfigAbsolutePaths.mjs';
-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, 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 chalk from 'chalk';
+import { getConfigAbsolutePaths } from '../get-project-info/get-config/get-config-absolute-paths.mjs';
+import { chalkHighlightThing } from '../utils/chalk-highlight-thing.mjs';
+import { getFileSystemEntryType } from '../utils/get-file-system-entry-type.mjs';
+import { getLogger } from '../utils/get-logger.mjs';
+import { checkTSConfigForExperimentalDecorators } from './check-tsconfig-for-experimental-decorators.mjs';
+import { createConfig } from './create-config.mjs';
+import { getPackageManager, installDependencies } from './install-dependencies.mjs';
+import { logUpdateDependenciesError } from './log-update-dependencies-error.mjs';
+import { updateDependenciesWithoutInstalling } from './update-dependencies-without-installing.mjs';
+import { updateGitignore } from './update-gitignore.mjs';
+import { getDevScript, updateNPMScripts } from './update-npm-scripts.mjs';
+import { updateTypeScriptConfig } from './update-typescript-config.mjs';
+const VALIDATION_LIBRARIES = ['zod', 'valibot', 'arktype', 'none'];
+const LANGS = ['py', 'rs'];
+const UPDATE_SCRIPTS_MODES = ['implicit', 'explicit'];
+const CHANNELS = ['latest', 'beta', 'draft'];
 export class Init {
     root;
     log;
     async #init({ configPaths, pkgJson, }, { useNpm, useYarn, usePnpm, useBun, skipInstall, updateTsConfig, updateScripts, validationLibrary, bundle, lang, dryRun, channel, }) {
         const { log, root } = this;
-        const dependencies = ['vovk', 'vovk-client', 'vovk-ajv'];
+        const dependencies = ['vovk', 'vovk-ajv'];
         const devDependencies = ['vovk-cli'];
         if (lang?.includes('py')) {
             devDependencies.push('vovk-python');
@@ -29,8 +34,9 @@ export class Init {
         }
         // delete older config files
         if (configPaths.length) {
-            await Promise.all(configPaths.map((configPath) => fs.rm(configPath)));
-            log.debug(`Deleted existing config file${configPaths.length > 1 ? 's' : ''} at ${configPaths.join(', ')}`);
+            if (!dryRun)
+                await Promise.all(configPaths.map((configPath) => fs.rm(configPath)));
+            log.debug(`${dryRun ? 'Dry run: would delete' : 'Deleted'} existing config file${configPaths.length > 1 ? 's' : ''} at ${configPaths.join(', ')}`);
         }
         if (validationLibrary) {
             dependencies.push(...({
@@ -40,14 +46,14 @@ export class Init {
             }[validationLibrary] ?? []));
         }
         if (bundle) {
-            const TSDOWN_VERSION = '0.19.0';
+            const TSDOWN_VERSION = '0.22.14';
             devDependencies.push(`tsdown@${TSDOWN_VERSION}`);
         }
         if (updateScripts) {
             try {
                 if (!dryRun && pkgJson)
                     await updateNPMScripts({ pkgJson, root, bundle, updateScriptsMode: updateScripts });
-                log.info('Updated scripts at package.json');
+                log.info(`${dryRun ? 'Dry run: would update' : 'Updated'} scripts at package.json`);
             }
             catch (error) {
                 log.error(`Failed to update scripts at package.json: ${error.message}`);
@@ -63,7 +69,7 @@ export class Init {
                 };
                 if (!dryRun)
                     await updateTypeScriptConfig(root, compilerOptions);
-                log.info(`Added ${Object.keys(compilerOptions)
+                log.info(`${dryRun ? 'Dry run: would add' : 'Added'} ${Object.keys(compilerOptions)
                     .map((k) => `"${k}"`)
                     .join(' and ')} to tsconfig.json`);
             }
@@ -73,7 +79,7 @@ export class Init {
         }
         if (!dryRun && pkgJson) {
             let depsUpdated = false;
-            const packageManager = getPackageManager({ useNpm, useYarn, usePnpm, useBun, pkgJson });
+            const packageManager = getPackageManager({ useNpm, useYarn, usePnpm, useBun, pkgJson, log });
             try {
                 await updateDependenciesWithoutInstalling({
                     log,
@@ -114,13 +120,23 @@ export class Init {
                 }
             }
         }
+        try {
+            if (!dryRun) {
+                const gitignoreEntry = await updateGitignore(root);
+                if (gitignoreEntry)
+                    log.info(`Added ${chalkHighlightThing(gitignoreEntry)} to .gitignore`);
+            }
+        }
+        catch (error) {
+            log.error(`Failed to update .gitignore: ${error.message}`);
+        }
         try {
             const { configAbsolutePath } = await createConfig({
                 root,
                 log,
                 options: { validationLibrary, channel, bundle, lang, dryRun },
             });
-            log.info(`Config created successfully at ${chalkHighlightThing(configAbsolutePath)}`);
+            log.info(`Config ${dryRun ? 'would be created (dry run)' : 'created successfully'} at ${chalkHighlightThing(configAbsolutePath)}`);
             log.info(`You can now create a root segment with ${chalkHighlightThing('npx vovk new segment')} command`);
         }
         catch (error) {
@@ -131,6 +147,22 @@ export class Init {
         const cwd = process.cwd();
         const root = path.resolve(cwd, prefix ?? '.');
         const log = getLogger(logLevel ?? 'info');
+        validationLibrary = validationLibrary?.toLowerCase();
+        lang = lang?.map((l) => l.toLowerCase());
+        if (validationLibrary && !VALIDATION_LIBRARIES.includes(validationLibrary)) {
+            throw new Error(`Unknown --validation-library value "${validationLibrary}". Supported values: ${VALIDATION_LIBRARIES.join(', ')}`);
+        }
+        for (const l of lang ?? []) {
+            if (!LANGS.includes(l)) {
+                throw new Error(`Unknown --lang value "${l}". Supported values: ${LANGS.join(', ')}`);
+            }
+        }
+        if (updateScripts && !UPDATE_SCRIPTS_MODES.includes(updateScripts)) {
+            throw new Error(`Unknown --update-scripts value "${updateScripts}". Supported values: ${UPDATE_SCRIPTS_MODES.join(', ')}`);
+        }
+        if (channel && !CHANNELS.includes(channel)) {
+            throw new Error(`Unknown --channel value "${channel}". Supported values: ${CHANNELS.join(', ')}`);
+        }
         const pkgJson = await NPMCliPackageJson.load(root).catch(() => null);
         this.root = root;
         this.log = log;

package/dist/init/{installDependencies.d.mts → install-dependencies.d.mts}

@@ -1,9 +1,10 @@
 import type NPMCliPackageJson from '@npmcli/package-json';
-import type { getLogger } from '../utils/getLogger.mjs';
 import type { InitOptions } from '../types.mjs';
+import type { getLogger } from '../utils/get-logger.mjs';
 export type PackageManager = 'npm' | 'yarn' | 'pnpm' | 'bun';
 export declare function getPackageManager(options: Pick<InitOptions, 'useNpm' | 'useYarn' | 'usePnpm' | 'useBun'> & {
     pkgJson: NPMCliPackageJson;
+    log?: ReturnType<typeof getLogger>;
 }): PackageManager;
 export declare function installDependencies({ log, cwd, packageManager, }: {
     log: ReturnType<typeof getLogger>;

package/dist/init/{installDependencies.mjs → install-dependencies.mjs}

@@ -1,5 +1,6 @@
 import { spawn } from 'node:child_process';
-import { chalkHighlightThing } from '../utils/chalkHighlightThing.mjs';
+import { chalkHighlightThing } from '../utils/chalk-highlight-thing.mjs';
+const KNOWN_PACKAGE_MANAGERS = ['npm', 'yarn', 'pnpm', 'bun'];
 export function getPackageManager(options) {
     if (options.useNpm)
         return 'npm';
@@ -9,8 +10,15 @@ export function getPackageManager(options) {
         return 'pnpm';
     if (options.useBun)
         return 'bun';
-    const packageManager = options.pkgJson.content?.packageManager;
-    return packageManager ? packageManager.split('@')[0] : 'npm'; // Default to npm if no options are true
+    const packageManager = options.pkgJson.content?.packageManager?.split('@')[0];
+    if (!packageManager)
+        return 'npm'; // Default to npm if no options are true
+    // this name gets spawned, so an unknown one from package.json is not executed
+    if (!KNOWN_PACKAGE_MANAGERS.includes(packageManager)) {
+        options.log?.warn(`Unknown "packageManager" ${JSON.stringify(packageManager)} in package.json, using ${chalkHighlightThing('npm')} instead`);
+        return 'npm';
+    }
+    return packageManager;
 }
 export async function installDependencies({ log, cwd, packageManager, }) {
     log.info(`Installing dependencies at ${chalkHighlightThing(cwd)} using ${chalkHighlightThing(packageManager)}...`);

package/dist/init/{logUpdateDependenciesError.d.mts → log-update-dependencies-error.d.mts}

@@ -1,6 +1,6 @@
 import type { InitOptions } from '../types.mjs';
-import type { getLogger } from '../utils/getLogger.mjs';
-import type { PackageManager } from './installDependencies.mjs';
+import type { getLogger } from '../utils/get-logger.mjs';
+import type { PackageManager } from './install-dependencies.mjs';
 export declare function logUpdateDependenciesError({ packageManager, log, dependencies, devDependencies, error, channel, }: {
     packageManager: PackageManager;
     log: ReturnType<typeof getLogger>;

package/dist/init/{logUpdateDependenciesError.mjs → log-update-dependencies-error.mjs}

@@ -1,4 +1,4 @@
-import { chalkHighlightThing } from '../utils/chalkHighlightThing.mjs';
+import { chalkHighlightThing } from '../utils/chalk-highlight-thing.mjs';
 export function logUpdateDependenciesError({ packageManager, log, dependencies, devDependencies, error, channel, }) {
     const installCommands = [];
     const addChannel = (packageName) => {

package/dist/init/{updateDependenciesWithoutInstalling.d.mts → update-dependencies-without-installing.d.mts}

@@ -1,5 +1,5 @@
-import type { getLogger } from '../utils/getLogger.mjs';
 import type { InitOptions } from '../types.mjs';
+import type { getLogger } from '../utils/get-logger.mjs';
 export declare function updateDependenciesWithoutInstalling({ log, dir, dependencyNames, devDependencyNames, channel, }: {
     log: ReturnType<typeof getLogger>;
     dir: string;

package/dist/init/{updateDependenciesWithoutInstalling.mjs → update-dependencies-without-installing.mjs}

@@ -1,14 +1,13 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import chalk from 'chalk';
-import { getNPMPackageMetadata } from '../utils/getNPMPackageMetadata.mjs';
+import { getNPMPackageMetadata } from '../utils/get-npm-package-metadata.mjs';
 /** Root of the monorepo packages directory (…/packages) resolved from the compiled CLI location (dist/init/). */
 const packagesRoot = path.resolve(import.meta.dirname, '../../..');
 /** Vovk package names that have a matching local directory under packages/. */
 const localPackageDirs = {
     vovk: 'vovk',
     'vovk-cli': 'vovk-cli',
-    'vovk-client': 'vovk-client',
     'vovk-ajv': 'vovk-ajv',
     'vovk-python': 'vovk-python',
     'vovk-rust': 'vovk-rust',

package/dist/init/update-gitignore.d.mts

@@ -0,0 +1,2 @@
+/** Adds the default composed client outDir to .gitignore. Returns the added entry or null if already present. */
+export declare function updateGitignore(root: string): Promise<string | null>;

package/dist/init/update-gitignore.mjs

@@ -0,0 +1,20 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { getRelativeSrcRoot } from '../get-project-info/get-config/get-relative-src-root.mjs';
+/** Adds the default composed client outDir to .gitignore. Returns the added entry or null if already present. */
+export async function updateGitignore(root) {
+    const srcRoot = await getRelativeSrcRoot({ cwd: root });
+    const outDir = path.join(srcRoot ?? '.', 'client');
+    const entry = `/${outDir}`;
+    const gitignorePath = path.join(root, '.gitignore');
+    const content = await fs.readFile(gitignorePath, 'utf-8').catch(() => '');
+    const hasEntry = content.split('\n').some((line) => {
+        const trimmed = line.trim().replace(/\/$/, '');
+        return trimmed === entry || trimmed === outDir;
+    });
+    if (hasEntry)
+        return null;
+    const updated = `${content.length && !content.endsWith('\n') ? `${content}\n` : content}\n# vovk generated client\n${entry}\n`;
+    await fs.writeFile(gitignorePath, updated, 'utf-8');
+    return entry;
+}

package/dist/new/index.d.mts

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

package/dist/new/index.mjs

@@ -1,5 +1,5 @@
-import { newModule } from './newModule.mjs';
-import { newSegment } from './newSegment.mjs';
+import { newModule } from './new-module.mjs';
+import { newSegment } from './new-segment.mjs';
 export async function newComponents(components, projectInfo, { dryRun, outDir, templates, overwrite, noSegmentUpdate, empty, static: isStaticSegment }) {
     if (components[0] === 'segment' || components[0] === 'segments') {
         // vovk new segment [segmentName]

package/dist/new/{newModule.d.mts → new-module.d.mts}

@@ -1,4 +1,4 @@
-import type { ProjectInfo } from '../getProjectInfo/index.mjs';
+import type { ProjectInfo } from '../get-project-info/index.mjs';
 export declare function newModule({ projectInfo, what, moduleNameWithOptionalSegment, dryRun, outDir: outDirFlag, templates: templatesFlag, noSegmentUpdate, overwrite, empty, }: {
     projectInfo: ProjectInfo;
     what: string[];

package/dist/new/{newModule.mjs → new-module.mjs}

@@ -1,15 +1,15 @@
-import path from 'node:path';
 import fs from 'node:fs/promises';
+import path from 'node:path';
 import chalk from 'chalk';
 import { getTsconfig } from 'get-tsconfig';
-import { render } from './render.mjs';
-import { addClassToSegmentCode } from './addClassToSegmentCode.mjs';
-import { chalkHighlightThing } from '../utils/chalkHighlightThing.mjs';
-import { formatLoggedSegmentName } from '../utils/formatLoggedSegmentName.mjs';
-import { getFileSystemEntryType } from '../utils/getFileSystemEntryType.mjs';
+import { chalkHighlightThing } from '../utils/chalk-highlight-thing.mjs';
+import { formatLoggedSegmentName } from '../utils/format-logged-segment-name.mjs';
+import { getFileSystemEntryType } from '../utils/get-file-system-entry-type.mjs';
+import { locateSegments } from '../utils/locate-segments.mjs';
 import { prettify } from '../utils/prettify.mjs';
-import { resolveAbsoluteModulePath } from '../utils/resolveAbsoluteModulePath.mjs';
-import { locateSegments } from '../utils/locateSegments.mjs';
+import { resolveAbsoluteModulePath } from '../utils/resolve-absolute-module-path.mjs';
+import { addClassToSegmentCode } from './add-class-to-segment-code.mjs';
+import { render } from './render.mjs';
 function splitByLast(str, delimiter = '/') {
     const index = str.lastIndexOf(delimiter);
     if (index === -1) {
@@ -93,6 +93,9 @@ export async function newModule({ projectInfo, what, moduleNameWithOptionalSegme
                 log.info(`${chalk.green('Created')}${empty ? ' empty' : ''} ${chalkHighlightThing(absoluteModulePath)} using ${chalkHighlightThing(`"${type}"`)} template for ${formatLoggedSegmentName(segmentName)}`);
             }
         }
+        else {
+            log.info(`Dry run: would create${empty ? ' empty' : ''} ${chalkHighlightThing(absoluteModulePath)} using ${chalkHighlightThing(`"${type}"`)} template for ${formatLoggedSegmentName(segmentName)}`);
+        }
         if (type === 'controller') {
             if (!sourceName) {
                 throw new Error(`The template for "${type}" does not provide a sourceName`);
@@ -112,9 +115,12 @@ export async function newModule({ projectInfo, what, moduleNameWithOptionalSegme
                 }), routeFilePath);
                 if (!dryRun) {
                     await fs.writeFile(routeFilePath, newSegmentCode);
+                    log.info(`${chalk.green('Added')} ${chalkHighlightThing(sourceName)} ${type} as ${chalkHighlightThing(compiledName)} to ${formatLoggedSegmentName(segmentName)}`);
+                }
+                else {
+                    log.info(`Dry run: would add ${chalkHighlightThing(sourceName)} ${type} as ${chalkHighlightThing(compiledName)} to ${formatLoggedSegmentName(segmentName)}`);
                 }
             }
-            log.info(`${chalk.green('Added')} ${chalkHighlightThing(sourceName)} ${type} as ${chalkHighlightThing(compiledName)} to ${formatLoggedSegmentName(segmentName)}`);
         }
     }
 }

package/dist/new/{newSegment.d.mts → new-segment.d.mts}

@@ -1,4 +1,4 @@
-import type { ProjectInfo } from '../getProjectInfo/index.mjs';
+import type { ProjectInfo } from '../get-project-info/index.mjs';
 export declare function newSegment({ projectInfo, segmentName, isStaticSegment, overwrite, dryRun, }: {
     projectInfo: ProjectInfo;
     segmentName: string;

package/dist/new/{newSegment.mjs → new-segment.mjs}

@@ -1,10 +1,10 @@
-import path from 'node:path';
 import fs from 'node:fs/promises';
-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 path from 'node:path';
 import chalk from 'chalk';
+import { chalkHighlightThing } from '../utils/chalk-highlight-thing.mjs';
+import { formatLoggedSegmentName } from '../utils/format-logged-segment-name.mjs';
+import { getFileSystemEntryType } from '../utils/get-file-system-entry-type.mjs';
+import { prettify } from '../utils/prettify.mjs';
 export async function newSegment({ projectInfo, segmentName, isStaticSegment, overwrite, dryRun, }) {
     const { apiDirAbsolutePath, log, config } = projectInfo;
     if (!apiDirAbsolutePath) {
@@ -22,6 +22,8 @@ const controllers = {};
 export type Controllers = typeof controllers;
 ${isStaticSegment
         ? `
+export const dynamic = 'force-static';
+
 export function generateStaticParams() {
   return controllersToStaticParams(controllers);
 }
@@ -35,8 +37,11 @@ ${segmentName ? `  segmentName: '${segmentName}',\n` : ''}  emitSchema: true,
     if (!dryRun) {
         await fs.mkdir(path.dirname(absoluteSegmentRoutePath), { recursive: true });
         await fs.writeFile(absoluteSegmentRoutePath, code);
+        log.info(`${chalk.green('Created')} ${formatLoggedSegmentName(segmentName, { isStatic: isStaticSegment })} at ${absoluteSegmentRoutePath}.`);
+    }
+    else {
+        log.info(`Dry run: would create ${formatLoggedSegmentName(segmentName, { isStatic: isStaticSegment })} at ${absoluteSegmentRoutePath}.`);
     }
-    log.info(`${chalk.green('Created')} ${formatLoggedSegmentName(segmentName, { isStatic: isStaticSegment })} at ${absoluteSegmentRoutePath}.`);
     const dir = chalk.cyanBright([segmentName, 'thing'].filter(Boolean).join('/'));
     log.info(`Run ${chalkHighlightThing(`npx vovk new service controller ${dir}`)} to create a new controller with a service at ./${path.join(config.modulesDir, dir)}/ directory for this segment`);
 }

package/dist/new/render.mjs

@@ -1,12 +1,12 @@
+import path from 'node:path';
 import ejs from 'ejs';
 import matter from 'gray-matter';
 import _ from 'lodash';
 import pluralize from 'pluralize';
-import { addCommonTerms } from './addCommonTerms.mjs';
-import path from 'node:path';
+import { addCommonTerms } from './add-common-terms.mjs';
 addCommonTerms();
 export async function render(codeTemplate, { cwd, config, withService, segmentName, moduleName, empty, templateFileName, isNodeNextResolution, srcRoot, }) {
-    const defaultOutDir = [config.modulesDir, segmentName || config.rootSegmentModulesDirName, _.camelCase(moduleName)]
+    const defaultOutDir = [config.modulesDir, segmentName || config.rootSegmentModulesDirName, _.kebabCase(moduleName)]
         .filter(Boolean)
         .join('/');
     const relativePathToSourceRoot = path.relative(path.resolve(cwd, defaultOutDir), path.join(cwd, srcRoot ?? '.')) || '.';

package/dist/types.d.mts

@@ -88,7 +88,7 @@ export type VovkEnv = {
     VOVK_API_ENTRY_POINT?: string;
     __VOVK_START_WATCHER_IN_STANDALONE_MODE__?: 'true';
     __VOVK_SCHEMA_OUT_FLAG__?: string;
-    __VOVK_DEV_HTTPS_FLAG__?: 'true' | 'false';
+    __VOVK_DEV_HTTPS_FLAG__?: 'true' | '';
     __VOVK_EXIT__?: 'true' | 'false';
     __VOVK_LOG_LEVEL__?: LogLevelNames;
 };

package/dist/utils/{compileJSONSchemaToTypeScriptType.mjs → compile-json-schema-to-typescript-type.mjs}

@@ -1,4 +1,4 @@
-import { compileTs } from './compileTs.mjs';
+import { compileTs } from './compile-ts.mjs';
 export function compileJSONSchemaToTypeScriptType(schema, typeName, components = {}, options = {}) {
     if (!schema)
         return '';

package/dist/utils/{formatLoggedSegmentName.mjs → format-logged-segment-name.mjs}

@@ -1,5 +1,5 @@
 import upperFirstLodash from 'lodash/upperFirst.js';
-import { chalkHighlightThing } from './chalkHighlightThing.mjs';
+import { chalkHighlightThing } from './chalk-highlight-thing.mjs';
 export function formatLoggedSegmentName(segmentName, { withChalk = true, upperFirst = false, isStatic = false, segmentType = 'segment', // TODO: Apply to all formatLoggedSegmentName invocations
  } = {}) {
     let text = segmentName ? `${isStatic ? 'static ' : ''}${segmentType} "${segmentName}"` : 'the root segment';

package/dist/utils/{generateFnName.d.mts → generate-fn-name.d.mts}

@@ -10,14 +10,5 @@ interface GenerateFnNameOptions {
     /** Segments to strip out (e.g. ['api','v1']) */
     ignoreSegments?: string[];
 }
-/**
- * Turn an HTTP method + OpenAPI path into a camelCased function name.
- *
- * Examples:
- *   generateFnName('GET', '/users')                     // "listUsers"
- *   generateFnName('GET', '/users/{id}')                // "getUsersById"
- *   generateFnName('POST', '/v1/api/orders')            // "createOrders"
- *   generateFnName('PATCH', '/users/{userId}/profile')  // "patchUsersProfileByUserId"
- */
 export declare function generateFnName(method: HttpMethod, rawPath: string, opts?: GenerateFnNameOptions): string;
 export {};

package/dist/utils/{generateFnName.mjs → generate-fn-name.mjs}

@@ -15,15 +15,8 @@ export function capitalize(str) {
 const DEFAULT_OPTIONS = {
     ignoreSegments: ['api'],
 };
-/**
- * Turn an HTTP method + OpenAPI path into a camelCased function name.
- *
- * Examples:
- *   generateFnName('GET', '/users')                     // "listUsers"
- *   generateFnName('GET', '/users/{id}')                // "getUsersById"
- *   generateFnName('POST', '/v1/api/orders')            // "createOrders"
- *   generateFnName('PATCH', '/users/{userId}/profile')  // "patchUsersProfileByUserId"
- */
+// HTTP method + OpenAPI path to a camelCased fn name,
+// e.g. GET /users -> "listUsers", GET /users/{id} -> "getUsersById", POST /v1/api/orders -> "createOrders"
 export function generateFnName(method, rawPath, opts = {}) {
     const { ignoreSegments } = {
         ...DEFAULT_OPTIONS,

package/dist/utils/generated-banner.d.mts

@@ -0,0 +1 @@
+export declare const GENERATED_BANNER_PREFIX = "Generated by vovk-cli";

package/dist/utils/generated-banner.mjs

@@ -0,0 +1,3 @@
+// stamped as the first line of every generated file that can hold a comment,
+// the pruner relies on it to tell generated files from user files
+export const GENERATED_BANNER_PREFIX = 'Generated by vovk-cli';

package/dist/utils/get-available-port.d.mts

@@ -0,0 +1 @@
+export declare function getAvailablePort(startPort: number, maxAttempts: number, attempt: number, onWarning: (failedPort: number, tryingPort: number) => void): Promise<string>;