vovk-cli 0.0.1-beta.0

package/dist/server/index.js

@@ -0,0 +1,285 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VovkCLIServer = void 0;
+const chokidar = __importStar(require("chokidar"));
+const http = __importStar(require("http"));
+const promises_1 = __importDefault(require("fs/promises"));
+const getProjectInfo_1 = __importDefault(require("../getProjectInfo"));
+const path_1 = __importDefault(require("path"));
+const ensureMetadataFiles_1 = require("./ensureMetadataFiles");
+const createMetadataServer_1 = __importDefault(require("./createMetadataServer"));
+const writeOneMetadataFile_1 = __importDefault(require("./writeOneMetadataFile"));
+const logDiffResult_1 = __importDefault(require("./logDiffResult"));
+const generateClient_1 = __importDefault(require("./generateClient"));
+const locateSegments_1 = __importDefault(require("../locateSegments"));
+const debounceWithArgs_1 = __importDefault(require("../utils/debounceWithArgs"));
+const lodash_1 = require("lodash");
+class VovkCLIServer {
+    #projectInfo;
+    #segments = [];
+    #metadata = {};
+    #isWatching = false;
+    #modulesWatcher = null;
+    #segmentWatcher = null;
+    #watchSegments = () => {
+        const segmentReg = /\/?\[\[\.\.\.[a-zA-Z-_]+\]\]\/route.ts$/;
+        const { apiDir, log, metadataOutFullPath } = this.#projectInfo;
+        const getSegmentName = (filePath) => path_1.default.relative(apiDir, filePath).replace(segmentReg, '');
+        log.debug(`Watching segments in ${apiDir}`);
+        this.#segmentWatcher = chokidar
+            .watch(apiDir, {
+            persistent: true,
+            ignoreInitial: true,
+        })
+            .on('add', (filePath) => {
+            log.debug(`File ${filePath} has been added to segments folder`);
+            if (segmentReg.test(filePath)) {
+                const segmentName = getSegmentName(filePath);
+                this.#segments = this.#segments.find((s) => s.segmentName === segmentName)
+                    ? this.#segments
+                    : [...this.#segments, { routeFilePath: filePath, segmentName }];
+                log.info(`Segment "${segmentName}" has been added`);
+                log.debug(`Full list of segments: ${this.#segments.map((s) => s.segmentName).join(', ')}`);
+                void (0, ensureMetadataFiles_1.debouncedEnsureMetadataFiles)(metadataOutFullPath, this.#segments.map((s) => s.segmentName), this.#projectInfo // TODO refactor
+                );
+            }
+        })
+            .on('change', (filePath) => {
+            log.debug(`File ${filePath} has been changed at segments folder`);
+            if (segmentReg.test(filePath)) {
+                void this.#ping(getSegmentName(filePath));
+            }
+        })
+            // eslint-disable-next-line @typescript-eslint/no-misused-promises
+            .on('addDir', async (dirPath) => {
+            log.debug(`Directory ${dirPath} has been added to segments folder`);
+            this.#segments = await (0, locateSegments_1.default)(this.#projectInfo.apiDir);
+            for (const { segmentName } of this.#segments) {
+                void this.#ping(segmentName);
+            }
+        })
+            // eslint-disable-next-line @typescript-eslint/no-misused-promises
+            .on('unlinkDir', async (dirPath) => {
+            log.debug(`Directory ${dirPath} has been removed from segments folder`);
+            this.#segments = await (0, locateSegments_1.default)(this.#projectInfo.apiDir);
+            for (const { segmentName } of this.#segments) {
+                void this.#ping(segmentName);
+            }
+        })
+            .on('unlink', (filePath) => {
+            log.debug(`File ${filePath} has been removed from segments folder`);
+            if (segmentReg.test(filePath)) {
+                const segmentName = getSegmentName(filePath);
+                this.#segments = this.#segments.filter((s) => s.segmentName !== segmentName);
+                log.info(`Segment "${segmentName}" has been removed`);
+                log.debug(`Full list of segments: ${this.#segments.map((s) => s.segmentName).join(', ')}`);
+                void (0, ensureMetadataFiles_1.debouncedEnsureMetadataFiles)(metadataOutFullPath, this.#segments.map((s) => s.segmentName), this.#projectInfo // TODO refactor
+                );
+            }
+        })
+            .on('ready', () => {
+            log.debug('Segments watcher is ready');
+        })
+            .on('error', (error) => {
+            log.error(`Error watching segments folder: ${error.message}`);
+        });
+    };
+    #watchModules = () => {
+        const { config, log } = this.#projectInfo;
+        log.debug(`Watching modules in ${config.modulesDir}`);
+        this.#modulesWatcher = chokidar
+            .watch(config.modulesDir, {
+            persistent: true,
+            ignoreInitial: true,
+        })
+            .on('add', (filePath) => {
+            log.debug(`File ${filePath} has been added to modules folder`);
+            void this.#processControllerChange(filePath);
+        })
+            .on('change', (filePath) => {
+            log.debug(`File ${filePath} has been changed at modules folder`);
+            void this.#processControllerChange(filePath);
+        })
+            .on('unlink', (filePath) => {
+            log.debug(`File ${filePath} has been removed from modules folder`);
+        })
+            .on('addDir', () => {
+            for (const { segmentName } of this.#segments) {
+                void this.#ping(segmentName);
+            }
+        })
+            .on('unlinkDir', () => {
+            for (const { segmentName } of this.#segments) {
+                void this.#ping(segmentName);
+            }
+        })
+            .on('ready', () => {
+            log.debug('Modules watcher is ready');
+        })
+            .on('error', (error) => {
+            log.error(`Error watching modules folder: ${error.message}`);
+        });
+    };
+    #watchConfig = () => {
+        const { log } = this.#projectInfo;
+        log.debug(`Watching config files`);
+        let isInitial = true;
+        const handle = (0, lodash_1.debounce)(async () => {
+            this.#projectInfo = await (0, getProjectInfo_1.default)();
+            if (!isInitial) {
+                log.info('Config file has been updated');
+                isInitial = false;
+            }
+            await this.#modulesWatcher?.close();
+            await this.#segmentWatcher?.close();
+            this.#watchModules();
+            this.#watchSegments();
+        }, 1000);
+        chokidar
+            .watch('vovk.config.{js,mjs,cjs}', {
+            persistent: true,
+            cwd: process.cwd(),
+            ignoreInitial: false,
+            depth: 0,
+        })
+            .on('add', () => void handle())
+            .on('change', () => void handle())
+            .on('unlink', () => void handle())
+            .on('ready', () => {
+            log.debug('Config files watcher is ready');
+        })
+            .on('error', (error) => {
+            log.error(`Error watching config files: ${error.message}`);
+        });
+    };
+    #watch() {
+        if (this.#isWatching)
+            throw new Error('Already watching');
+        const { apiDir, log, config } = this.#projectInfo;
+        log.info(`Watching segments in ${apiDir} and modules in ${config.modulesDir}. Detected initial segments: ${JSON.stringify(this.#segments.map((s) => s.segmentName))}.`);
+        this.#watchSegments();
+        this.#watchModules();
+        this.#watchConfig();
+    }
+    #processControllerChange = async (filePath) => {
+        const { log } = this.#projectInfo;
+        const code = await promises_1.default.readFile(filePath, 'utf-8').catch(() => null);
+        if (typeof code !== 'string')
+            return;
+        const nameOfClasReg = /\bclass\s+([A-Za-z_]\w*)(?:\s*<[^>]*>)?\s*\{/g;
+        const namesOfClasses = [...code.matchAll(nameOfClasReg)].map((match) => match[1]);
+        const importRegex = /import\s*{[^}]*\b(initVovk|get|post|put|del|head|options|worker)\b[^}]*}\s*from\s*['"]vovk['"]/;
+        if (importRegex.test(code) && namesOfClasses.length) {
+            const affectedSegments = this.#segments.filter((s) => {
+                const metadata = this.#metadata[s.segmentName];
+                if (!metadata)
+                    return false;
+                return namesOfClasses.some((name) => metadata.controllers[name] || metadata.workers[name]);
+            });
+            if (affectedSegments.length) {
+                log.debug(`A file with controller or worker ${namesOfClasses.join(', ')} have been modified at path "${filePath}". Segment(s) affected: ${affectedSegments.map((s) => s.segmentName).join(', ')}`);
+                for (const segment of affectedSegments) {
+                    await this.#ping(segment.segmentName);
+                }
+            }
+        }
+    };
+    #ping = (0, debounceWithArgs_1.default)((segmentName) => {
+        const { apiEntryPoint, log } = this.#projectInfo;
+        const endpoint = `${apiEntryPoint}/${segmentName ? `${segmentName}/` : ''}_vovk-ping_`;
+        log.debug(`Pinging segment "${segmentName}" at ${endpoint}`);
+        const req = http.get(endpoint, (resp) => {
+            if (resp.statusCode !== 200) {
+                log.warn(`Ping to segment "${segmentName}" failed with status code ${resp.statusCode}. Expected 200.`);
+            }
+        });
+        req.on('error', (err) => {
+            log.error(`Error during HTTP request made to ${endpoint}: ${err.message}`);
+        });
+    }, 500);
+    #createMetadataServer() {
+        const { metadataOutFullPath, log } = this.#projectInfo;
+        return (0, createMetadataServer_1.default)(async ({ metadata }) => {
+            const segment = this.#segments.find((s) => s.segmentName === metadata.segmentName);
+            if (!segment) {
+                log.debug(`Segment "${metadata.segmentName}" not found`);
+                return;
+            }
+            this.#metadata[metadata.segmentName] = metadata;
+            if (metadata.emitMetadata) {
+                const now = Date.now();
+                const { diffResult } = await (0, writeOneMetadataFile_1.default)({
+                    metadataOutFullPath,
+                    metadata,
+                    skipIfExists: false,
+                });
+                const timeTook = Date.now() - now;
+                if (diffResult) {
+                    (0, logDiffResult_1.default)(segment.segmentName, diffResult, this.#projectInfo);
+                    log.info(`Metadata for segment "${metadata.segmentName}" has been updated in ${timeTook}ms`);
+                }
+            }
+            else if (metadata && (!(0, lodash_1.isEmpty)(metadata.controllers) || !(0, lodash_1.isEmpty)(metadata.workers))) {
+                log.error(`Non-empty metadata provided for segment "${metadata.segmentName}" but emitMetadata is false`);
+            }
+            if (this.#segments.every((s) => this.#metadata[s.segmentName])) {
+                log.debug(`All segments with emitMetadata=true have metadata.`);
+                await (0, generateClient_1.default)(this.#projectInfo, this.#segments, this.#metadata);
+            }
+        }, (error) => {
+            log.error(String(error));
+        });
+    }
+    async startServer({ clientOutDir } = {}) {
+        this.#projectInfo = await (0, getProjectInfo_1.default)({ clientOutDir });
+        this.#segments = await (0, locateSegments_1.default)(this.#projectInfo.apiDir);
+        const { vovkPort, log, metadataOutFullPath } = this.#projectInfo;
+        const server = this.#createMetadataServer();
+        if (!vovkPort) {
+            log.error('No port provided for Vovk Server. Exiting...');
+            return;
+        }
+        await (0, ensureMetadataFiles_1.debouncedEnsureMetadataFiles)(metadataOutFullPath, this.#segments.map((s) => s.segmentName), this.#projectInfo);
+        server.listen(vovkPort, () => {
+            log.info(`Vovk Metadata Server is running on port ${vovkPort}. Happy coding!`);
+        });
+        // Ping every segment in 3 seconds in order to update metadata and start watching
+        setTimeout(() => {
+            for (const { segmentName } of this.#segments) {
+                void this.#ping(segmentName);
+            }
+            this.#watch();
+        }, 3000);
+    }
+}
+exports.VovkCLIServer = VovkCLIServer;
+const env = process.env;
+if (env.__VOVK_START_SERVER_IN_STANDALONE_MODE__ === 'true') {
+    void new VovkCLIServer().startServer();
+}

package/dist/server/isMetadataEmpty.d.ts

@@ -0,0 +1,2 @@
+import type { VovkMetadata } from 'vovk';
+export default function isMetadataEmpty(metadata: VovkMetadata): boolean;

package/dist/server/isMetadataEmpty.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = isMetadataEmpty;
+const lodash_1 = require("lodash");
+function isMetadataEmpty(metadata) {
+    return (0, lodash_1.isEmpty)(metadata.controllers) && (0, lodash_1.isEmpty)(metadata.workers);
+}

package/dist/server/logDiffResult.d.ts

@@ -0,0 +1,3 @@
+import { ProjectInfo } from '../getProjectInfo';
+import { DiffResult } from './diffMetadata';
+export default function logDiffResult(segmentName: string, diffResult: DiffResult, projectInfo: ProjectInfo): void;

package/dist/server/logDiffResult.js

@@ -0,0 +1,84 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = logDiffResult;
+const chalk_1 = __importDefault(require("chalk"));
+function logDiffResult(segmentName, diffResult, projectInfo) {
+    const diffNormalized = [];
+    diffResult.workers.added.forEach((name) => {
+        diffNormalized.push({ what: 'worker', type: 'added', name });
+    });
+    diffResult.workers.removed.forEach((name) => {
+        diffNormalized.push({ what: 'worker', type: 'removed', name });
+    });
+    diffResult.controllers.added.forEach((name) => {
+        diffNormalized.push({ what: 'controller', type: 'added', name });
+    });
+    diffResult.controllers.removed.forEach((name) => {
+        diffNormalized.push({ what: 'controller', type: 'removed', name });
+    });
+    diffResult.controllers.handlers.forEach((handler) => {
+        handler.added.forEach((name) => {
+            diffNormalized.push({ what: 'controllerHandler', type: 'added', name: `${handler.nameOfClass}.${name}` });
+        });
+        handler.removed.forEach((name) => {
+            diffNormalized.push({ what: 'controllerHandler', type: 'removed', name: `${handler.nameOfClass}.${name}` });
+        });
+        handler.changed.forEach((name) => {
+            diffNormalized.push({ what: 'controllerHandler', type: 'changed', name: `${handler.nameOfClass}.${name}` });
+        });
+    });
+    const LIMIT = 5;
+    for (const diffNormalizedItem of diffNormalized.slice(0, LIMIT)) {
+        switch (diffNormalizedItem.what) {
+            case 'worker':
+                switch (diffNormalizedItem.type) {
+                    case 'added':
+                        projectInfo.log.info(`New worker ${chalk_1.default.white.bold(diffNormalizedItem.name)} has been added to segment "${chalk_1.default.white.bold(segmentName)}"`);
+                        break;
+                    case 'removed':
+                        projectInfo.log.info(`Worker ${chalk_1.default.white.bold(diffNormalizedItem.name)} has been removed from segment "${chalk_1.default.white.bold(segmentName)}"`);
+                        break;
+                }
+                break;
+            case 'controller':
+                switch (diffNormalizedItem.type) {
+                    case 'added':
+                        projectInfo.log.info(`New controller ${chalk_1.default.white.bold(diffNormalizedItem.name)} has been added to segment "${chalk_1.default.white.bold(segmentName)}"`);
+                        break;
+                    case 'removed':
+                        projectInfo.log.info(`Controller ${chalk_1.default.white.bold(diffNormalizedItem.name)} has been removed from segment "${chalk_1.default.white.bold(segmentName)}"`);
+                        break;
+                }
+                break;
+            case 'workerHandler':
+                switch (diffNormalizedItem.type) {
+                    case 'added':
+                        projectInfo.log.info(`New worker method ${chalk_1.default.white.bold(diffNormalizedItem.name)} has been added in segment "${chalk_1.default.white.bold(segmentName)}"`);
+                        break;
+                    case 'removed':
+                        projectInfo.log.info(`Worker method ${chalk_1.default.white.bold(diffNormalizedItem.name)} has been removed in segment "${chalk_1.default.white.bold(segmentName)}"`);
+                        break;
+                }
+                break;
+            case 'controllerHandler':
+                switch (diffNormalizedItem.type) {
+                    case 'added':
+                        projectInfo.log.info(`New controller method ${chalk_1.default.white.bold(diffNormalizedItem.name)} has been added in segment "${chalk_1.default.white.bold(segmentName)}"`);
+                        break;
+                    case 'removed':
+                        projectInfo.log.info(`Controller method ${chalk_1.default.white.bold(diffNormalizedItem.name)} has been removed in segment "${chalk_1.default.white.bold(segmentName)}"`);
+                        break;
+                    case 'changed':
+                        projectInfo.log.info(`Controller method ${chalk_1.default.white.bold(diffNormalizedItem.name)} has been changed in segment "${chalk_1.default.white.bold(segmentName)}"`);
+                        break;
+                }
+                break;
+        }
+    }
+    if (diffNormalized.length > LIMIT) {
+        projectInfo.log.info(`...and ${diffNormalized.length - LIMIT} more changes`);
+    }
+}

package/dist/server/writeOneMetadataFile.d.ts

@@ -0,0 +1,11 @@
+import { VovkMetadata } from 'vovk';
+import { DiffResult } from './diffMetadata';
+export declare const ROOT_SEGMENT_SCHEMA_NAME = "_root";
+export default function writeOneMetadataFile({ metadataOutFullPath, metadata, skipIfExists, }: {
+    metadataOutFullPath: string;
+    metadata: VovkMetadata;
+    skipIfExists?: boolean;
+}): Promise<{
+    isCreated: boolean;
+    diffResult: DiffResult | null;
+}>;

package/dist/server/writeOneMetadataFile.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ROOT_SEGMENT_SCHEMA_NAME = void 0;
+exports.default = writeOneMetadataFile;
+const path_1 = __importDefault(require("path"));
+const promises_1 = __importDefault(require("fs/promises"));
+const diffMetadata_1 = __importDefault(require("./diffMetadata"));
+exports.ROOT_SEGMENT_SCHEMA_NAME = '_root';
+async function writeOneMetadataFile({ metadataOutFullPath, metadata, skipIfExists = false, }) {
+    const segmentPath = path_1.default.join(metadataOutFullPath, `${metadata.segmentName || exports.ROOT_SEGMENT_SCHEMA_NAME}.json`);
+    if (skipIfExists) {
+        try {
+            await promises_1.default.stat(segmentPath);
+            return { isCreated: false, diffResult: null };
+        }
+        catch {
+            // File doesn't exist
+        }
+    }
+    await promises_1.default.mkdir(path_1.default.dirname(segmentPath), { recursive: true });
+    const metadataStr = JSON.stringify(metadata, null, 2);
+    const existing = await promises_1.default.readFile(segmentPath, 'utf-8').catch(() => null);
+    if (existing === metadataStr) {
+        return { isCreated: false, diffResult: null };
+    }
+    await promises_1.default.writeFile(segmentPath, metadataStr);
+    if (existing) {
+        return { isCreated: false, diffResult: (0, diffMetadata_1.default)(JSON.parse(existing), metadata) };
+    }
+    return { isCreated: true, diffResult: null };
+}

package/dist/types.d.ts

@@ -0,0 +1,30 @@
+import { LogLevelNames } from 'loglevel';
+export type KnownAny = any;
+export type VovkEnv = {
+    PORT?: string;
+    VOVK_CLIENT_OUT_DIR?: string;
+    VOVK_METADATA_OUT_DIR?: string;
+    VOVK_FETCHER?: string;
+    VOVK_VALIDATE_ON_CLIENT?: string;
+    VOVK_PORT?: string;
+    VOVK_MODULES_DIR?: string;
+    VOVK_VALIDATION_LIBRARY?: string;
+    VOVK_ORIGIN?: string;
+    VOVK_ROOT_ENTRY?: string;
+    VOVK_API_ENTRY_POINT?: string;
+    VOVK_ROOT_SEGMENT_MODULES_DIR_NAME?: string;
+    VOVK_LOG_LEVEL?: LogLevelNames;
+    __VOVK_START_SERVER_IN_STANDALONE_MODE__?: 'true';
+};
+export type VovkConfig = {
+    clientOutDir?: string;
+    metadataOutDir?: string;
+    fetcher?: string;
+    validateOnClient?: string | null;
+    modulesDir?: string;
+    validationLibrary?: string | null;
+    rootEntry?: string;
+    origin?: string;
+    rootSegmentModulesDirName?: string;
+    logLevel?: LogLevelNames;
+};

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/debounceWithArgs.d.ts

@@ -0,0 +1,2 @@
+import { KnownAny } from '../types';
+export default function debounceWithArgs<T extends (...args: KnownAny[]) => KnownAny>(fn: T, wait: number): (...args: Parameters<T>) => void | Promise<void>;

package/dist/utils/debounceWithArgs.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = debounceWithArgs;
+const debounce_1 = __importDefault(require("lodash/debounce"));
+function debounceWithArgs(fn, wait) {
+    const debouncedFunctions = new Map();
+    return (...args) => {
+        const key = JSON.stringify(args);
+        if (!debouncedFunctions.has(key)) {
+            debouncedFunctions.set(key, (0, debounce_1.default)(fn, wait));
+        }
+        const debouncedFn = debouncedFunctions.get(key);
+        if (debouncedFn) {
+            debouncedFn(...args);
+        }
+    };
+}

package/dist/utils/fileExists.d.ts

@@ -0,0 +1 @@
+export default function fileExists(filePath: string): Promise<boolean>;

package/dist/utils/fileExists.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = fileExists;
+const promises_1 = __importDefault(require("fs/promises"));
+async function fileExists(filePath) {
+    try {
+        await promises_1.default.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/utils/getAvailablePort.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 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>}
+ */
+declare function getAvailablePort(startPort: number, maxAttempts: number, attempt: number, onWarning: (failedPort: number, tryingPort: number) => void): Promise<string>;
+export default getAvailablePort;

package/dist/utils/getAvailablePort.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const net_1 = __importDefault(require("net"));
+/**
+ * Checks if a port is available.
+ * @param {number} port - The port to check.
+ * @param {(isAvailable: boolean) => void} callback - The callback function.
+ */
+function checkPort(port, callback) {
+    const server = net_1.default.createServer();
+    server.listen(port, () => {
+        server.close(() => {
+            callback(true); // Port is available
+        });
+    });
+    server.on('error', () => {
+        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>}
+ */
+function getAvailablePort(startPort, maxAttempts, attempt, onWarning) {
+    return new Promise((resolve, reject) => {
+        checkPort(startPort, (isAvailable) => {
+            if (isAvailable) {
+                resolve(startPort.toString()); // Found an available port
+            }
+            else if (attempt < maxAttempts) {
+                onWarning(startPort, startPort + 1);
+                getAvailablePort(startPort + 1, maxAttempts, attempt + 1, onWarning).then(resolve, reject);
+            }
+            else {
+                reject('No available ports found');
+            }
+        });
+    });
+}
+exports.default = getAvailablePort;

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "vovk-cli",
+  "version": "0.0.1-beta.0",
+  "bin": {
+    "vovk": "./dist/index.js"
+  },
+  "types": "./dist/index.d.ts",
+  "scripts": {
+    "postinstall_": "node ./dist/postinstall.js",
+    "build": "tsc",
+    "test": "ts-node test/index.ts",
+    "ncu": "npm-check-updates -u -x chalk",
+    "npm-publish": "npm publish"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/finom/vovk.git"
+  },
+  "keywords": [
+    "nextjs",
+    "router",
+    "cli",
+    "vovk"
+  ],
+  "author": "Andrii Gubanov",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/finom/vovk/issues"
+  },
+  "homepage": "https://vovk.dev",
+  "peerDependencies": {
+    "vovk": "^3.0.0-beta.0"
+  },
+  "dependencies": {
+    "@inquirer/prompts": "^5.3.8",
+    "chalk": "^4.1.2",
+    "chokidar": "^3.6.0",
+    "commander": "^12.1.0",
+    "concurrently": "^8.2.2",
+    "lodash": "^4.17.21",
+    "loglevel": "^1.9.1"
+  }
+}

package/src/getProjectInfo/directoryExists.ts

@@ -0,0 +1,10 @@
+import fs from 'fs/promises';
+
+export default async function directoryExists(dir: string) {
+  try {
+    const stats = await fs.stat(dir);
+    return stats.isDirectory();
+  } catch (error) {
+    return false;
+  }
+}

package/src/getProjectInfo/getConfig.ts

@@ -0,0 +1,29 @@
+import readConfig from './readConfig';
+import type { VovkConfig, VovkEnv } from '../types';
+import getCwdPath from './getCwdPath';
+import getSrcRoot from './getSrcRoot';
+import path from 'path';
+
+export default async function getConfig({ clientOutDir }: { clientOutDir?: string }) {
+  const env = process.env as VovkEnv;
+  const userConfig = await readConfig();
+  const srcRoot = await getSrcRoot();
+  const cwd = process.cwd();
+  const config: Required<VovkConfig> = {
+    modulesDir: path.join(
+      cwd,
+      env.VOVK_MODULES_DIR ?? userConfig.modulesDir ?? './' + [srcRoot, 'modules'].filter(Boolean).join('/')
+    ),
+    validateOnClient: getCwdPath(env.VOVK_VALIDATE_ON_CLIENT ?? userConfig.validateOnClient ?? null),
+    validationLibrary: getCwdPath(env.VOVK_VALIDATION_LIBRARY ?? userConfig.validationLibrary ?? null),
+    fetcher: getCwdPath(env.VOVK_FETCHER ?? userConfig.fetcher ?? 'vovk/client/defaultFetcher'),
+    metadataOutDir: env.VOVK_METADATA_OUT_DIR ?? userConfig.metadataOutDir ?? './.vovk-schema',
+    clientOutDir: clientOutDir ?? env.VOVK_CLIENT_OUT_DIR ?? userConfig.clientOutDir ?? './node_modules/.vovk',
+    origin: (env.VOVK_ORIGIN ?? userConfig.origin ?? '').replace(/\/$/, ''), // Remove trailing slash
+    rootEntry: env.VOVK_ROOT_ENTRY ?? userConfig.rootEntry ?? 'api',
+    rootSegmentModulesDirName: env.VOVK_ROOT_SEGMENT_MODULES_DIR_NAME ?? userConfig.rootSegmentModulesDirName ?? '',
+    logLevel: env.VOVK_LOG_LEVEL ?? userConfig.logLevel ?? 'debug', // TODO: change to 'warn' when v3 is ready
+  };
+
+  return { config, srcRoot };
+}