vovk-cli 0.2.0 → 0.3.0-beta.0

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 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 { installDependencies, getPackageManager } from './install-dependencies.mjs';
 import { getLogger } from '../utils/get-logger.mjs';
-import { createConfig } from './create-config.mjs';
-import { updateNPMScripts, getDevScript } from './update-npm-scripts.mjs';
 import { checkTSConfigForExperimentalDecorators } from './check-tsconfig-for-experimental-decorators.mjs';
-import { updateTypeScriptConfig } from './update-typescript-config.mjs';
-import { updateDependenciesWithoutInstalling } from './update-dependencies-without-installing.mjs';
+import { createConfig } from './create-config.mjs';
+import { getPackageManager, installDependencies } from './install-dependencies.mjs';
 import { logUpdateDependenciesError } from './log-update-dependencies-error.mjs';
-import { chalkHighlightThing } from '../utils/chalk-highlight-thing.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/install-dependencies.d.mts

@@ -1,9 +1,10 @@
 import type NPMCliPackageJson from '@npmcli/package-json';
-import type { getLogger } from '../utils/get-logger.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/install-dependencies.mjs

@@ -1,5 +1,6 @@
 import { spawn } from 'node:child_process';
 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/update-dependencies-without-installing.d.mts

@@ -1,5 +1,5 @@
-import type { getLogger } from '../utils/get-logger.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/update-dependencies-without-installing.mjs

@@ -8,7 +8,6 @@ const packagesRoot = path.resolve(import.meta.dirname, '../../..');
 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/init/update-typescript-config.mjs

@@ -1,5 +1,5 @@
-import path from 'node:path';
 import fs from 'node:fs/promises';
+import path from 'node:path';
 import * as jsonc from 'jsonc-parser';
 import { prettify } from '../utils/prettify.mjs';
 export async function updateTypeScriptConfig(root, compilerOptions) {

package/dist/new/index.d.mts

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

package/dist/new/new-module.mjs

@@ -1,16 +1,15 @@
-import path from 'node:path';
 import fs from 'node:fs/promises';
+import path from 'node:path';
 import chalk from 'chalk';
-import _ from 'lodash';
 import { getTsconfig } from 'get-tsconfig';
-import { render } from './render.mjs';
-import { addClassToSegmentCode } from './add-class-to-segment-code.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/resolve-absolute-module-path.mjs';
-import { locateSegments } from '../utils/locate-segments.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) {
@@ -82,16 +81,6 @@ export async function newModule({ projectInfo, what, moduleNameWithOptionalSegme
         }
         const absoluteModuleDir = path.join(cwd, outDir);
         const absoluteModulePath = path.join(absoluteModuleDir, fileName);
-        // Pre-kebab-case projects keep modules at e.g. userProfile/UserProfileController.ts; scaffolding
-        // user-profile/user-profile-controller.ts next to it would register a duplicate class in the segment.
-        const legacySuffix = type === 'controller' ? 'Controller' : type === 'service' ? 'Service' : null;
-        if (!outDirFlag && legacySuffix && path.basename(absoluteModuleDir) === _.kebabCase(moduleName)) {
-            const legacyModulePath = path.join(path.dirname(absoluteModuleDir), _.camelCase(moduleName), `${_.upperFirst(_.camelCase(moduleName))}${legacySuffix}.ts`);
-            if (await getFileSystemEntryType(legacyModulePath)) {
-                log.error(`Found ${chalkHighlightThing(legacyModulePath)} created with the pre-kebab-case naming convention. Rename it to ${chalkHighlightThing(absoluteModulePath)} manually or pass --out-dir to scaffold elsewhere.`);
-                return process.exit(1);
-            }
-        }
         const prettiedCode = await prettify(code, absoluteModulePath);
         if (!dryRun) {
             if (!overwrite && (await getFileSystemEntryType(absoluteModulePath))) {
@@ -104,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`);
@@ -123,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/new-segment.mjs

@@ -1,10 +1,10 @@
-import path from 'node:path';
 import fs from 'node:fs/promises';
-import { getFileSystemEntryType } from '../utils/get-file-system-entry-type.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';
-import chalk from 'chalk';
 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,9 +1,9 @@
+import path from 'node:path';
 import ejs from 'ejs';
 import matter from 'gray-matter';
 import _ from 'lodash';
 import pluralize from 'pluralize';
 import { addCommonTerms } from './add-common-terms.mjs';
-import path from 'node:path';
 addCommonTerms();
 export async function render(codeTemplate, { cwd, config, withService, segmentName, moduleName, empty, templateFileName, isNodeNextResolution, srcRoot, }) {
     const defaultOutDir = [config.modulesDir, segmentName || config.rootSegmentModulesDirName, _.kebabCase(moduleName)]

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/compile-json-schema-to-typescript-type.d.mts

@@ -1,5 +1,5 @@
-import type { OpenAPIObject } from 'openapi3-ts/oas31';
 import type { JSONSchema7 } from 'json-schema';
+import type { OpenAPIObject } from 'openapi3-ts/oas31';
 export declare function compileJSONSchemaToTypeScriptType(schema: JSONSchema7, typeName: string, components?: NonNullable<OpenAPIObject['components']>, options?: {
     dontCreateRefTypes?: boolean;
 }): string;

package/dist/utils/compile-ts.mjs

@@ -1,5 +1,5 @@
-import upperFirst from 'lodash/upperFirst.js';
 import camelCase from 'lodash/camelCase.js';
+import upperFirst from 'lodash/upperFirst.js';
 export function compileTs(options) {
     const context = {
         refs: options.refs || new Map(),

package/dist/utils/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/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

@@ -1,9 +1 @@
-/**
- * Finds an available port starting from a given port.
- * @param {number} startPort - The port to start checking from.
- * @param {number} maxAttempts - The maximum number of attempts to find an available port.
- * @param {number} attempt - The current attempt number.
- * @param {(failedPort: number, tryingPort: number) => void} onWarning - The callback function for warnings.
- * @returns {Promise<string>}
- */
 export declare function getAvailablePort(startPort: number, maxAttempts: number, attempt: number, onWarning: (failedPort: number, tryingPort: number) => void): Promise<string>;

package/dist/utils/get-available-port.mjs

@@ -1,10 +1,5 @@
 import net from 'node:net';
-// Created with AI
-/**
- * Checks if a port is available.
- * @param {number} port - The port to check.
- * @param {(isAvailable: boolean) => void} callback - The callback function.
- */
+// checks if a port is free
 function checkPort(port, callback) {
     const server = net.createServer();
     server.listen(port, () => {
@@ -16,14 +11,7 @@ function checkPort(port, callback) {
         callback(false);
     });
 }
-/**
- * Finds an available port starting from a given port.
- * @param {number} startPort - The port to start checking from.
- * @param {number} maxAttempts - The maximum number of attempts to find an available port.
- * @param {number} attempt - The current attempt number.
- * @param {(failedPort: number, tryingPort: number) => void} onWarning - The callback function for warnings.
- * @returns {Promise<string>}
- */
+// finds a free port starting from startPort, up to maxAttempts
 export function getAvailablePort(startPort, maxAttempts, attempt, onWarning) {
     return new Promise((resolve, reject) => {
         checkPort(startPort, (isAvailable) => {

package/dist/utils/get-file-system-entry-type.d.mts

@@ -1,5 +1,6 @@
-export declare enum FileSystemEntryType {
-    FILE = "FILE",
-    DIRECTORY = "DIRECTORY"
-}
+export declare const FileSystemEntryType: {
+    readonly FILE: "FILE";
+    readonly DIRECTORY: "DIRECTORY";
+};
+export type FileSystemEntryType = (typeof FileSystemEntryType)[keyof typeof FileSystemEntryType];
 export declare function getFileSystemEntryType(filePath: string): Promise<FileSystemEntryType | null>;

package/dist/utils/get-file-system-entry-type.mjs

@@ -1,9 +1,9 @@
 import fs from 'node:fs/promises';
-export var FileSystemEntryType;
-(function (FileSystemEntryType) {
-    FileSystemEntryType["FILE"] = "FILE";
-    FileSystemEntryType["DIRECTORY"] = "DIRECTORY";
-})(FileSystemEntryType || (FileSystemEntryType = {}));
+// const object instead of enum, node 26 runs ts with erasable syntax only
+export const FileSystemEntryType = {
+    FILE: 'FILE',
+    DIRECTORY: 'DIRECTORY',
+};
 export async function getFileSystemEntryType(filePath) {
     try {
         const stats = await fs.stat(filePath);

package/dist/utils/normalize-openapi-mixin.d.mts

@@ -1,6 +1,6 @@
+import type { OpenAPIObject } from 'openapi3-ts/oas31';
 import type { HttpMethod, VovkConfig } from 'vovk';
 import type { VovkOperationObject, VovkStrictConfig } from 'vovk/internal';
-import type { OpenAPIObject } from 'openapi3-ts/oas31';
 import type { ProjectInfo } from '../get-project-info/index.mjs';
 export type GetOpenAPINameFn = (config: {
     operationObject: VovkOperationObject;

package/dist/utils/normalize-openapi-mixin.mjs

@@ -1,10 +1,11 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
+import camelCase from 'lodash/camelCase.js';
 import * as YAML from 'yaml';
 import { chalkHighlightThing } from './chalk-highlight-thing.mjs';
-import camelCase from 'lodash/camelCase.js';
 import { generateFnName } from './generate-fn-name.mjs';
 const normalizeGetModuleName = (getModuleName) => {
+    getModuleName = getModuleName ?? 'api';
     if (typeof getModuleName === 'string') {
         const moduleName = getModuleName;
         getModuleName = () => moduleName;
@@ -15,6 +16,7 @@ const normalizeGetModuleName = (getModuleName) => {
     return getModuleName;
 };
 const normalizeGetMethodName = (getMethodName) => {
+    getMethodName = getMethodName ?? 'auto';
     if (getMethodName === 'camel-case-operation-id') {
         getMethodName = ({ operationObject }) => {
             const operationId = operationObject.operationId;
@@ -47,8 +49,21 @@ async function getOpenApiSpecLocal(openApiSpecFilePath, cwd) {
     return (fileName.endsWith('.json') ? JSON.parse(openApiSpecContent) : YAML.parse(openApiSpecContent));
 }
 async function getOpenApiSpecRemote({ cwd, url, fallback, log, }) {
-    const resp = await fetch(url);
-    const text = await resp.text();
+    let resp;
+    let text;
+    try {
+        resp = await fetch(url);
+        text = await resp.text();
+    }
+    catch (error) {
+        // network failures (DNS, offline, timeouts) should use the fallback too
+        const message = `Failed to fetch OpenAPI spec from ${chalkHighlightThing(url)}: ${error.message}`;
+        if (fallback) {
+            log.warn(`${message}. Falling back to ${chalkHighlightThing(fallback)}`);
+            return getOpenApiSpecLocal(fallback, cwd);
+        }
+        throw new Error(message);
+    }
     if (!resp.ok) {
         if (fallback) {
             log.warn(`Failed to fetch OpenAPI spec from ${chalkHighlightThing(url)}: ${resp.status} ${resp.statusText}. Falling back to ${chalkHighlightThing(fallback)}`);

package/dist/utils/prettify.d.mts

@@ -1 +1,5 @@
+import type { getLogger } from './get-logger.mjs';
+/** Formats with the project-installed prettier; returns the code unchanged when it's not installed. */
 export declare function prettify(code: string, absoluteFilePath: string): Promise<string>;
+/** Warns once per run when prettifyClient is enabled but prettier is not installed. */
+export declare function warnIfPrettierMissing(log: ReturnType<typeof getLogger>): Promise<void>;

package/dist/utils/prettify.mjs

@@ -1,10 +1,46 @@
-import prettier from 'prettier';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+let prettierPromise;
+let warned = false;
+/** Prettier is not a CLI dependency; it's resolved from the user's project if installed. */
+function getPrettier() {
+    prettierPromise ??= (async () => {
+        try {
+            const require = createRequire(path.join(process.cwd(), 'noop.js'));
+            const mod = (await import(pathToFileURL(require.resolve('prettier')).href));
+            return mod.default ?? mod;
+        }
+        catch {
+            return null;
+        }
+    })();
+    return prettierPromise;
+}
+/** Formats with the project-installed prettier; returns the code unchanged when it's not installed. */
 export async function prettify(code, absoluteFilePath) {
+    const prettier = await getPrettier();
+    if (!prettier)
+        return code;
     const options = await prettier.resolveConfig(absoluteFilePath);
     const finalOptions = {
         ...options,
         filepath: absoluteFilePath, // for selecting the correct parser
     };
-    const formattedCode = await prettier.format(code, finalOptions);
-    return formattedCode;
+    try {
+        return await prettier.format(code, finalOptions);
+    }
+    catch (error) {
+        // no parser for this file type (.rs, .toml, .py etc)
+        if (error.name === 'UndefinedParserError')
+            return code;
+        throw error;
+    }
+}
+/** Warns once per run when prettifyClient is enabled but prettier is not installed. */
+export async function warnIfPrettierMissing(log) {
+    if (warned || (await getPrettier()))
+        return;
+    warned = true;
+    log.warn('prettifyClient is enabled but prettier is not installed. Either install it or set prettifyClient to false to suppress this warning.');
 }

package/dist/utils/remove-unlisted-directories.d.mts

@@ -1,9 +1 @@
-/**
- * Removes all directories in a folder that aren't in the provided allowlist
- * Supports nested directory paths like 'foo/bar/baz'
- *
- * @param folderPath - The path to the folder to process
- * @param allowedDirs - Array of relative directory paths to keep
- * @returns Promise that resolves when all operations are complete
- */
-export declare function removeUnlistedDirectories(folderPath: string, allowedDirs: string[]): Promise<void>;
+export declare function removeUnlistedDirectories(folderPath: string, allowedDirs: string[], generatedRelPaths?: string[]): Promise<string[]>;