vovk-cli 0.0.1-draft.43 → 0.0.1-draft.44

package/client-templates/compiled/compiled.d.ts.ejs

@@ -1,7 +1,6 @@
 
 <%- '// auto-generated\n/* eslint-disable */' %>
-import type { clientizeController, VovkClientFetcher } from 'vovk/client';
-import type { promisifyWorker } from 'vovk/worker';
+import type { createRPC, createWPC, VovkClientFetcher } from 'vovk';
 import type fetcher from '<%= fetcherClientImportPath %>';
 <% segments.forEach((segment, i) => { 
   const hasWorkers = !!Object.keys(segmentsSchema[segment.segmentName].workers).length;
@@ -17,9 +16,9 @@ type Options = typeof fetcher extends VovkClientFetcher<infer U> ? U : never;
     const workers     = Object.keys(segSchema.workers);
 %>
   <% controllers.forEach((key) => { %>
-export const <%= key %>: ReturnType<typeof clientizeController<Controllers<%= i %>["<%= key %>"], Options>>;
+export const <%= key %>: ReturnType<typeof createRPC<Controllers<%= i %>["<%= key %>"], Options>>;
   <% }) %>
   <% workers.forEach((key) => { %>
-export const <%= key %>: ReturnType<typeof promisifyWorker<Workers<%= i %>["<%= key %>"]>>;
+export const <%= key %>: ReturnType<typeof createWPC<Workers<%= i %>["<%= key %>"]>>;
   <% }) %>
 <% }) %>

package/client-templates/compiled/compiled.js.ejs

@@ -1,6 +1,5 @@
 <%- '// auto-generated\n/* eslint-disable */' %>
-const { clientizeController } = require('vovk/client');
-const { promisifyWorker } = require('vovk/worker');
+const { createRPC, createWPC } = require('vovk');
 const { default: fetcher } = require('<%= fetcherClientImportPath %>');
 const schema = require('<%= schemaOutImportPath %>');
 
@@ -14,13 +13,13 @@ const apiRoot = '<%= apiRoot %>';
     const workers     = Object.keys(segSchema.workers);
 %>
   <% controllers.forEach((key) => { %>
-exports.<%= key %> = clientizeController(
+exports.<%= key %> = createRPC(
   schema['<%= segment.segmentName %>'].controllers.<%= key %>, 
   '<%= segment.segmentName %>', 
   { fetcher, validateOnClient, defaultOptions: { apiRoot } }
 );
   <% }) %>
   <% workers.forEach((key) => { %>
-exports.<%= key %> = promisifyWorker(null, schema['<%= segment.segmentName %>'].workers.<%= key %>);
+exports.<%= key %> = createWPC(null, schema['<%= segment.segmentName %>'].workers.<%= key %>);
   <% }) %>
 <% }) %>

package/client-templates/ts/index.ts.ejs

@@ -1,6 +1,5 @@
 <%- '// auto-generated\n/* eslint-disable */' %>
-import { clientizeController, type VovkClientFetcher } from 'vovk/client';
-<% if(hasWorkers) { %>import { promisifyWorker } from 'vovk/worker';<% } %>
+import { createRPC, createWPC, type VovkClientFetcher } from 'vovk';
 import fetcher from '<%= fetcherClientImportPath %>';
 import schema from '<%= schemaOutImportPath %>';
 <% if (validateOnClientImportPath) { %>
@@ -19,7 +18,7 @@ const apiRoot = '<%= apiRoot %>';
 import type { Controllers as Controllers<%= i %><% if(hasWorkers) { %>, Workers as Workers<%= i %> <% } %>} from "<%= segment.segmentImportPath %>";
 
   <% Object.keys(segSchema.controllers).forEach((key) => { %>
-export const <%= key %> = clientizeController<Controllers<%= i %>["<%= key %>"], Options>(
+export const <%= key %> = createRPC<Controllers<%= i %>["<%= key %>"], Options>(
   schema['<%= segment.segmentName %>'].controllers.<%= key %>, 
   '<%= segment.segmentName %>', 
   { fetcher, validateOnClient, defaultOptions: { apiRoot } }
@@ -27,7 +26,7 @@ export const <%= key %> = clientizeController<Controllers<%= i %>["<%= key %>"],
   <% }) %>
 
   <% Object.keys(segSchema.workers).forEach((key) => { %>
-export const <%= key %> = promisifyWorker<Workers<%= i %>["<%= key %>"]>(
+export const <%= key %> = createWPC<Workers<%= i %>["<%= key %>"]>(
   null, 
   schema['<%= segment.segmentName %>'].workers.<%= key %>
 );

package/dist/dev/diffSchema.d.mts

@@ -1,5 +1,4 @@
-import type { VovkSchema } from 'vovk';
-import type { VovkControllerSchema, VovkWorkerSchema } from 'vovk/types';
+import type { VovkControllerSchema, VovkWorkerSchema, VovkSchema } from 'vovk';
 interface HandlersDiff {
     nameOfClass: string;
     added: string[];

package/dist/dev/ensureSchemaFiles.d.mts

@@ -1,3 +1,6 @@
 import { ProjectInfo } from '../getProjectInfo/index.mjs';
+/**
+ * Ensure that the schema files are created to avoid any import errors.
+ */
 export default function ensureSchemaFiles(projectInfo: ProjectInfo | null, schemaOutAbsolutePath: string, segmentNames: string[]): Promise<void>;
 export declare const debouncedEnsureSchemaFiles: import("lodash").DebouncedFunc<typeof ensureSchemaFiles>;

package/dist/dev/ensureSchemaFiles.mjs

@@ -3,6 +3,9 @@ import path from 'node:path';
 import debounce from 'lodash/debounce.js';
 import writeOneSchemaFile, { ROOT_SEGMENT_SCHEMA_NAME } from './writeOneSchemaFile.mjs';
 import formatLoggedSegmentName from '../utils/formatLoggedSegmentName.mjs';
+/**
+ * Ensure that the schema files are created to avoid any import errors.
+ */
 export default async function ensureSchemaFiles(projectInfo, schemaOutAbsolutePath, segmentNames) {
     const now = Date.now();
     let hasChanged = false;
@@ -78,6 +81,6 @@ export default segmentSchema;`;
     // Start the recursive deletion from the root directory
     await deleteUnnecessaryJsonFiles(schemaOutAbsolutePath);
     if (hasChanged)
-        projectInfo?.log.info(`Schema files updated in ${Date.now() - now}ms`);
+        projectInfo?.log.info(`Created empty schema files in ${Date.now() - now}ms`);
 }
 export const debouncedEnsureSchemaFiles = debounce(ensureSchemaFiles, 1000);

package/dist/dev/index.d.mts

@@ -1,4 +1,6 @@
 export declare class VovkDev {
     #private;
-    start(): Promise<void>;
+    start({ exit }: {
+        exit: boolean;
+    }): Promise<void>;
 }

package/dist/dev/index.mjs

@@ -6,6 +6,7 @@ import keyBy from 'lodash/keyBy.js';
 import capitalize from 'lodash/capitalize.js';
 import debounce from 'lodash/debounce.js';
 import isEmpty from 'lodash/isEmpty.js';
+import once from 'lodash/once.js';
 import { debouncedEnsureSchemaFiles } from './ensureSchemaFiles.mjs';
 import writeOneSchemaFile from './writeOneSchemaFile.mjs';
 import logDiffResult from './logDiffResult.mjs';
@@ -22,6 +23,7 @@ export class VovkDev {
     #isWatching = false;
     #modulesWatcher = null;
     #segmentWatcher = null;
+    #onFirstTimeGenerate = null;
     #watchSegments = (callback) => {
         const segmentReg = /\/?\[\[\.\.\.[a-zA-Z-_]+\]\]\/route.ts$/;
         const { cwd, log, config, apiDir } = this.#projectInfo;
@@ -40,11 +42,14 @@ export class VovkDev {
                 const segmentName = getSegmentName(filePath);
                 this.#segments = this.#segments.find((s) => s.segmentName === segmentName)
                     ? this.#segments
-                    : [...this.#segments, {
+                    : [
+                        ...this.#segments,
+                        {
                             routeFilePath: filePath,
                             segmentName,
-                            segmentImportPath: path.relative(config.clientOutDir, filePath) // TODO DRY locateSegments 
-                        }];
+                            segmentImportPath: path.relative(config.clientOutDir, filePath), // TODO DRY locateSegments
+                        },
+                    ];
                 log.info(`${capitalize(formatLoggedSegmentName(segmentName))} has been added`);
                 log.debug(`Full list of segments: ${this.#segments.map((s) => s.segmentName).join(', ')}`);
                 void debouncedEnsureSchemaFiles(this.#projectInfo, schemaOutAbsolutePath, this.#segments.map((s) => s.segmentName));
@@ -138,7 +143,7 @@ export class VovkDev {
             await this.#segmentWatcher?.close();
             await Promise.all([
                 new Promise((resolve) => this.#watchModules(() => resolve(0))),
-                new Promise((resolve) => this.#watchSegments(() => resolve(0)))
+                new Promise((resolve) => this.#watchSegments(() => resolve(0))),
             ]);
             if (isInitial) {
                 callback();
@@ -150,7 +155,14 @@ export class VovkDev {
         }, 1000);
         chokidar
             // .watch(['vovk.config.{js,mjs,cjs}', '.config/vovk.config.{js,mjs,cjs}'], {
-            .watch(['vovk.config.js', 'vovk.config.mjs', 'vovk.config.cjs', '.config/vovk.config.js', '.config/vovk.config.mjs', '.config/vovk.config.cjs'], {
+            .watch([
+            'vovk.config.js',
+            'vovk.config.mjs',
+            'vovk.config.cjs',
+            '.config/vovk.config.js',
+            '.config/vovk.config.mjs',
+            '.config/vovk.config.cjs',
+        ], {
             persistent: true,
             cwd,
             ignoreInitial: false,
@@ -238,11 +250,12 @@ export class VovkDev {
             await this.#handleSchema(schema);
         }
         catch (error) {
-            log.error(`Error requesting schema for ${formatLoggedSegmentName(segmentName)}: ${error.message}`);
+            log.error(`Error requesting schema for ${formatLoggedSegmentName(segmentName)} at ${endpoint}: ${error.message}`);
             return { isError: true };
         }
         return { isError: false };
     }, 500);
+    #generate = debounce(() => generate({ projectInfo: this.#projectInfo, segments: this.#segments, segmentsSchema: this.#schemas }).then(this.#onFirstTimeGenerate), 1000);
     async #handleSchema(schema) {
         const { log, config, cwd } = this.#projectInfo;
         if (!schema) {
@@ -275,14 +288,19 @@ export class VovkDev {
         }
         if (this.#segments.every((s) => this.#schemas[s.segmentName])) {
             log.debug(`All segments with "emitSchema" have schema.`);
-            await generate({ projectInfo: this.#projectInfo, segments: this.#segments, segmentsSchema: this.#schemas });
+            this.#generate();
         }
     }
-    async start() {
+    async start({ exit }) {
         const now = Date.now();
         this.#projectInfo = await getProjectInfo();
         const { log, config, cwd, apiDir } = this.#projectInfo;
         log.info('Starting...');
+        if (exit) {
+            this.#onFirstTimeGenerate = once(() => {
+                log.info('The schemas and the RPC client have been generated. Exiting...');
+            });
+        }
         if (config.devHttps) {
             const agent = new Agent({
                 connect: {
@@ -301,10 +319,11 @@ export class VovkDev {
         const schemaOutAbsolutePath = path.join(cwd, config.schemaOutDir);
         this.#segments = await locateSegments({ dir: apiDirAbsolutePath, config });
         await debouncedEnsureSchemaFiles(this.#projectInfo, schemaOutAbsolutePath, this.#segments.map((s) => s.segmentName));
+        const MAX_ATTEMPTS = 5;
+        const DELAY = 5000;
         // Request schema every segment in 5 seconds in order to update schema on start
         setTimeout(() => {
             for (const { segmentName } of this.#segments) {
-                const MAX_ATTEMPTS = 3;
                 let attempts = 0;
                 void this.#requestSchema(segmentName).then(({ isError }) => {
                     if (isError) {
@@ -318,19 +337,25 @@ export class VovkDev {
                             void this.#requestSchema(segmentName).then(({ isError: isError2 }) => {
                                 if (!isError2) {
                                     clearInterval(interval);
+                                    log.info(`Requested schema for ${formatLoggedSegmentName(segmentName)} after ${attempts} attempts`);
                                 }
                             });
-                        }, 5000);
+                        }, DELAY);
                     }
                 });
             }
-        }, 5000);
-        this.#watch(() => {
-            log.info(`Ready in ${Date.now() - now}ms`);
-        });
+        }, DELAY);
+        if (!exit) {
+            this.#watch(() => {
+                log.info(`Ready in ${Date.now() - now}ms. Making initial requests for schemas in a moment...`);
+            });
+        }
+        else {
+            log.info(`Ready in ${Date.now() - now}ms. Making initial requests for schemas in a moment...`);
+        }
     }
 }
 const env = process.env;
 if (env.__VOVK_START_WATCHER_IN_STANDALONE_MODE__ === 'true') {
-    void new VovkDev().start();
+    void new VovkDev().start({ exit: env.__VOVK_EXIT__ === 'true' });
 }

package/dist/dev/logDiffResult.mjs

@@ -46,43 +46,43 @@ export default function logDiffResult(segmentName, diffResult, projectInfo) {
             case 'worker':
                 switch (diffNormalizedItem.type) {
                     case 'added':
-                        projectInfo.log.info(`Schema for worker ${chalkHighlightThing(diffNormalizedItem.name)} has been ${addedText} at ${formatLoggedSegmentName(segmentName)}`);
+                        projectInfo.log.info(`Schema for WPC ${chalkHighlightThing(diffNormalizedItem.name)} has been ${addedText} at ${formatLoggedSegmentName(segmentName)}`);
                         break;
                     case 'removed':
-                        projectInfo.log.info(`Schema for worker ${chalkHighlightThing(diffNormalizedItem.name)} has been ${removedText} from ${formatLoggedSegmentName(segmentName)}`);
+                        projectInfo.log.info(`Schema for WPC ${chalkHighlightThing(diffNormalizedItem.name)} has been ${removedText} from ${formatLoggedSegmentName(segmentName)}`);
                         break;
                 }
                 break;
             case 'controller':
                 switch (diffNormalizedItem.type) {
                     case 'added':
-                        projectInfo.log.info(`Schema for controller ${chalkHighlightThing(diffNormalizedItem.name)} has been ${addedText} at ${formatLoggedSegmentName(segmentName)}`);
+                        projectInfo.log.info(`Schema forn RPC ${chalkHighlightThing(diffNormalizedItem.name)} has been ${addedText} at ${formatLoggedSegmentName(segmentName)}`);
                         break;
                     case 'removed':
-                        projectInfo.log.info(`Schema for controller ${chalkHighlightThing(diffNormalizedItem.name)} has been ${removedText} from ${formatLoggedSegmentName(segmentName)}`);
+                        projectInfo.log.info(`Schema forn RPC ${chalkHighlightThing(diffNormalizedItem.name)} has been ${removedText} from ${formatLoggedSegmentName(segmentName)}`);
                         break;
                 }
                 break;
             case 'workerHandler':
                 switch (diffNormalizedItem.type) {
                     case 'added':
-                        projectInfo.log.info(`Schema for worker method ${chalkHighlightThing(diffNormalizedItem.name)} has been ${addedText} at ${formatLoggedSegmentName(segmentName)}`);
+                        projectInfo.log.info(`Schema for WPC method ${chalkHighlightThing(diffNormalizedItem.name)} has been ${addedText} at ${formatLoggedSegmentName(segmentName)}`);
                         break;
                     case 'removed':
-                        projectInfo.log.info(`Schema for worker method ${chalkHighlightThing(diffNormalizedItem.name)} has been ${removedText} from ${formatLoggedSegmentName(segmentName)}`);
+                        projectInfo.log.info(`Schema for WPC method ${chalkHighlightThing(diffNormalizedItem.name)} has been ${removedText} from ${formatLoggedSegmentName(segmentName)}`);
                         break;
                 }
                 break;
             case 'controllerHandler':
                 switch (diffNormalizedItem.type) {
                     case 'added':
-                        projectInfo.log.info(`Schema for controller method ${chalkHighlightThing(diffNormalizedItem.name)} has been ${addedText} at ${formatLoggedSegmentName(segmentName)}`);
+                        projectInfo.log.info(`Schema forn RPC method ${chalkHighlightThing(diffNormalizedItem.name)} has been ${addedText} at ${formatLoggedSegmentName(segmentName)}`);
                         break;
                     case 'removed':
-                        projectInfo.log.info(`Schema for controller method ${chalkHighlightThing(diffNormalizedItem.name)} has been ${removedText} from ${formatLoggedSegmentName(segmentName)}`);
+                        projectInfo.log.info(`Schema forn RPC method ${chalkHighlightThing(diffNormalizedItem.name)} has been ${removedText} from ${formatLoggedSegmentName(segmentName)}`);
                         break;
                     case 'changed':
-                        projectInfo.log.info(`Schema for controller method ${chalkHighlightThing(diffNormalizedItem.name)} has been ${changedText} at ${formatLoggedSegmentName(segmentName)}`);
+                        projectInfo.log.info(`Schema forn RPC method ${chalkHighlightThing(diffNormalizedItem.name)} has been ${changedText} at ${formatLoggedSegmentName(segmentName)}`);
                         break;
                 }
                 break;

package/dist/generate/getClientTemplates.d.mts

@@ -1,4 +1,4 @@
-import { VovkConfig } from "../types.mjs";
+import { VovkConfig } from '../types.mjs';
 interface ClientTemplate {
     templatePath: string;
     outPath: string;

package/dist/generate/getClientTemplates.mjs

@@ -12,14 +12,17 @@ export default function getClientTemplates({ config, cwd, templateNames = [], })
         compiled: ['compiled.js.ejs', 'compiled.d.ts.ejs'].map(mapper('compiled')),
         python: ['__init__.py'].map(mapper('python')),
     };
-    const templateFiles = (templateNames ?? config.clientGenerateTemplateNames).reduce((acc, template) => {
+    const templateFiles = (templateNames ?? config.experimental_clientGenerateTemplateNames).reduce((acc, template) => {
         if (template in builtInTemplatesMap) {
             return [...acc, ...builtInTemplatesMap[template]];
         }
-        return [...acc, {
+        return [
+            ...acc,
+            {
                 templatePath: path.resolve(cwd, template),
-                outPath: path.join(clientOutDirAbsolutePath, path.basename(template).replace('.ejs', ''))
-            }];
+                outPath: path.join(clientOutDirAbsolutePath, path.basename(template).replace('.ejs', '')),
+            },
+        ];
     }, []);
     return templateFiles;
 }

package/dist/generate/index.mjs

@@ -5,9 +5,9 @@ import formatLoggedSegmentName from '../utils/formatLoggedSegmentName.mjs';
 import prettify from '../utils/prettify.mjs';
 import getClientTemplates from './getClientTemplates.mjs';
 export default async function generate({ projectInfo, segments, segmentsSchema, templates, prettify: prettifyClient, fullSchema, }) {
-    templates = templates ?? projectInfo.config.clientGenerateTemplateNames;
+    templates = templates ?? projectInfo.config.experimental_clientGenerateTemplateNames;
     const noClient = templates?.[0] === 'none';
-    const { config, cwd, log, validateOnClientImportPath, apiRoot, fetcherClientImportPath, schemaOutImportPath, } = projectInfo;
+    const { config, cwd, log, validateOnClientImportPath, apiRoot, fetcherClientImportPath, schemaOutImportPath } = projectInfo;
     const clientOutDirAbsolutePath = path.resolve(cwd, config.clientOutDir);
     const templateFiles = getClientTemplates({ config, cwd, templateNames: templates });
     // Ensure that each segment has a matching schema if it needs to be emitted:
@@ -30,40 +30,43 @@ export default async function generate({ projectInfo, segments, segmentsSchema,
         segments,
         segmentsSchema,
     };
-    // 1. Process each template in parallel
-    const processedTemplates = noClient ? [] : await Promise.all(templateFiles.map(async ({ templatePath, outPath }) => {
-        // Read the EJS template
-        const templateContent = await fs.readFile(templatePath, 'utf-8');
-        // Render the template
-        let rendered = templatePath.endsWith('.ejs') ? ejs.render(templateContent, ejsData) : templateContent;
-        // Optionally prettify
-        if (prettifyClient || config.prettifyClient) {
-            rendered = await prettify(rendered, outPath);
-        }
-        // Read existing file content to compare
-        const existingContent = await fs.readFile(outPath, 'utf-8').catch(() => '');
-        // Determine if we need to rewrite the file
-        const needsWriting = existingContent !== rendered;
-        return {
-            outPath,
-            rendered,
-            needsWriting,
-        };
-    }));
+    // Process each template in parallel
+    const processedTemplates = noClient
+        ? []
+        : await Promise.all(templateFiles.map(async ({ templatePath, outPath }) => {
+            // Read the EJS template
+            const templateContent = await fs.readFile(templatePath, 'utf-8');
+            // Render the template
+            let rendered = templatePath.endsWith('.ejs') ? ejs.render(templateContent, ejsData) : templateContent;
+            // Optionally prettify
+            if (prettifyClient || config.prettifyClient) {
+                rendered = await prettify(rendered, outPath);
+            }
+            // Read existing file content to compare
+            const existingContent = await fs.readFile(outPath, 'utf-8').catch(() => '');
+            // Determine if we need to rewrite the file
+            const needsWriting = existingContent !== rendered;
+            return {
+                outPath,
+                rendered,
+                needsWriting,
+            };
+        }));
+    const anyNeedsWriting = processedTemplates.some(({ needsWriting }) => needsWriting);
+    if (fullSchema || anyNeedsWriting) {
+        // Make sure the output directory exists
+        await fs.mkdir(clientOutDirAbsolutePath, { recursive: true });
+    }
     if (fullSchema) {
         const fullSchemaOutAbsolutePath = path.resolve(clientOutDirAbsolutePath, typeof fullSchema === 'string' ? fullSchema : 'full-schema.json');
         await fs.writeFile(fullSchemaOutAbsolutePath, JSON.stringify(segmentsSchema, null, 2));
         log.info(`Full schema has ben written to ${fullSchemaOutAbsolutePath}`);
     }
-    // 2. Check if any file needs rewriting
-    const anyNeedsWriting = processedTemplates.some(({ needsWriting }) => needsWriting);
     if (!anyNeedsWriting) {
         log.debug(`Client is up to date and doesn't need to be regenerated (${Date.now() - now}ms)`);
         return { written: false, path: clientOutDirAbsolutePath };
     }
-    // 3. Make sure the output directory exists
-    await fs.mkdir(clientOutDirAbsolutePath, { recursive: true });
-    // 4. Write updated files where needed
+    // Write updated files where needed
     await Promise.all(processedTemplates.map(({ outPath, rendered, needsWriting }) => {
         if (needsWriting) {
             return fs.writeFile(outPath, rendered);

package/dist/getProjectInfo/getConfig.mjs

@@ -9,7 +9,7 @@ export default async function getConfig({ clientOutDir, cwd }) {
         modulesDir: env.VOVK_MODULES_DIR ?? conf.modulesDir ?? './' + [srcRoot, 'modules'].filter(Boolean).join('/'),
         validateOnClient: env.VOVK_VALIDATE_ON_CLIENT ?? conf.validateOnClient ?? null,
         validationLibrary: env.VOVK_VALIDATION_LIBRARY ?? conf.validationLibrary ?? null,
-        fetcher: env.VOVK_FETCHER ?? conf.fetcher ?? 'vovk/client/defaultFetcher',
+        fetcher: env.VOVK_FETCHER ?? conf.fetcher ?? 'vovk/dist/client/defaultFetcher',
         schemaOutDir: env.VOVK_SCHEMA_OUT_DIR ?? conf.schemaOutDir ?? './.vovk-schema',
         clientOutDir: clientOutDir ?? env.VOVK_CLIENT_OUT_DIR ?? conf.clientOutDir ?? './node_modules/.vovk-client',
         origin: (env.VOVK_ORIGIN ?? conf.origin ?? '').replace(/\/$/, ''), // Remove trailing slash
@@ -18,7 +18,7 @@ export default async function getConfig({ clientOutDir, cwd }) {
         logLevel: env.VOVK_LOG_LEVEL ?? conf.logLevel ?? 'info',
         prettifyClient: (env.VOVK_PRETTIFY_CLIENT ? !!env.VOVK_PRETTIFY_CLIENT : null) ?? conf.prettifyClient ?? false,
         devHttps: (env.VOVK_DEV_HTTPS ? !!env.VOVK_DEV_HTTPS : null) ?? conf.devHttps ?? false,
-        clientGenerateTemplateNames: conf.clientGenerateTemplateNames ?? ['compiled'],
+        experimental_clientGenerateTemplateNames: conf.experimental_clientGenerateTemplateNames ?? ['ts', 'compiled'],
         templates: {
             service: 'vovk-cli/templates/service.ejs',
             controller: 'vovk-cli/templates/controller.ejs',

package/dist/index.mjs

@@ -19,11 +19,13 @@ initProgram(program.command('init'));
 program
     .command('dev')
     .description('Start schema watcher (optional flag --next-dev to start it with Next.js)')
-    .option('--next-dev', 'Start schema watcher and Next.js with automatic port allocation', false)
+    .option('--next-dev', 'Start schema watcher and Next.js with automatic port allocation')
+    .option('--exit', 'Kill the processe when schema and client is generated')
     .allowUnknownOption(true)
     .action(async (options, command) => {
+    const { nextDev, exit = false } = options;
     const portAttempts = 30;
-    const PORT = !options.nextDev
+    const PORT = !nextDev
         ? process.env.PORT
         : process.env.PORT ||
             (await getAvailablePort(3000, portAttempts, 0, (failedPort, tryingPort) => 
@@ -34,7 +36,7 @@ program
     if (!PORT) {
         throw new Error('🐺 ❌ PORT env variable is required');
     }
-    if (options.nextDev) {
+    if (nextDev) {
         const { result } = concurrently([
             {
                 command: `npx next dev ${command.args.join(' ')}`,
@@ -43,12 +45,17 @@ program
             },
             {
                 command: `node ${import.meta.dirname}/dev/index.mjs`,
-                name: 'Vovk Dev Command',
-                env: { PORT, __VOVK_START_WATCHER_IN_STANDALONE_MODE__: 'true' },
+                name: 'Vovk Dev Watcher',
+                env: {
+                    PORT,
+                    __VOVK_START_WATCHER_IN_STANDALONE_MODE__: 'true',
+                    __VOVK_EXIT__: exit ? 'true' : 'false',
+                },
             },
         ], {
             killOthers: ['failure', 'success'],
             prefix: 'none',
+            successCondition: 'first',
         });
         try {
             await result;
@@ -58,7 +65,7 @@ program
         }
     }
     else {
-        void new VovkDev().start();
+        void new VovkDev().start({ exit });
     }
 });
 program
@@ -76,7 +83,7 @@ program
     const segments = await locateSegments({ dir: apiDir, config });
     const schemaOutAbsolutePath = path.join(cwd, config.schemaOutDir);
     const schemaImportUrl = pathToFileURL(path.join(schemaOutAbsolutePath, 'index.js')).href;
-    const { default: segmentsSchema } = await import(schemaImportUrl);
+    const { default: segmentsSchema } = (await import(schemaImportUrl));
     await generate({ projectInfo, segments, segmentsSchema, templates, prettify, fullSchema });
 });
 program

package/dist/init/updateDependenciesWithoutInstalling.mjs

@@ -5,7 +5,7 @@ import getNPMPackageMetadata from '../utils/getNPMPackageMetadata.mjs';
 async function updateDeps({ packageJson, packageNames, channel, key, }) {
     return Promise.all(packageNames.map(async (packageName) => {
         const metadata = await getNPMPackageMetadata(packageName);
-        const isVovk = packageName.startsWith('vovk');
+        const isVovk = packageName.startsWith('vovk') && packageName !== 'vovk-mapped-types';
         const latestVersion = metadata['dist-tags'][isVovk ? (channel ?? 'latest') : 'latest'];
         if (!packageJson[key]) {
             packageJson[key] = {};

package/dist/locateSegments.d.mts

@@ -4,7 +4,7 @@ export type Segment = {
     segmentName: string;
     segmentImportPath: string;
 };
-export default function locateSegments({ dir, rootDir, config }: {
+export default function locateSegments({ dir, rootDir, config, }: {
     dir: string;
     rootDir?: string;
     config: Required<VovkConfig> | null;

package/dist/locateSegments.mjs

@@ -2,7 +2,7 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import getFileSystemEntryType from './utils/getFileSystemEntryType.mjs';
 // config: null is used for testing
-export default async function locateSegments({ dir, rootDir, config }) {
+export default async function locateSegments({ dir, rootDir, config, }) {
     let results = [];
     rootDir = rootDir ?? dir;
     // Read the contents of the directory

package/dist/postinstall.mjs

@@ -1,24 +1,21 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
-/**
- * Checks if a file exists at the given path.
- * @param {string} filePath - The path to the file.
- * @returns {Promise<boolean>} - A promise that resolves to true if the file exists, false otherwise.
- */
-const getFileSystemEntryType = async (filePath) => !!(await fs.stat(filePath).catch(() => false));
+import getFileSystemEntryType from './utils/getFileSystemEntryType.mjs';
 async function postinstall() {
+    // TODO: The function doesn't consider client templates, how to do that?
     const vovk = path.join(import.meta.dirname, '../../.vovk-client');
     const js = path.join(vovk, 'compiled.js');
     const ts = path.join(vovk, 'compiled.d.ts');
     const index = path.join(vovk, 'index.ts');
-    if ((await getFileSystemEntryType(js)) ||
-        (await getFileSystemEntryType(ts)) ||
-        (await getFileSystemEntryType(index))) {
-        return;
-    }
     await fs.mkdir(vovk, { recursive: true });
-    await fs.writeFile(js, '/* postinstall */');
-    await fs.writeFile(ts, '/* postinstall */');
-    await fs.writeFile(index, '/* postinstall */');
+    if (!(await getFileSystemEntryType(js))) {
+        await fs.writeFile(js, '/* postinstall */');
+    }
+    if (!(await getFileSystemEntryType(ts))) {
+        await fs.writeFile(ts, '/* postinstall */');
+    }
+    if (!(await getFileSystemEntryType(index))) {
+        await fs.writeFile(index, '/* postinstall */');
+    }
 }
 void postinstall();

package/dist/types.d.mts

@@ -16,6 +16,7 @@ export type VovkEnv = {
     VOVK_PRETTIFY_CLIENT?: string;
     VOVK_DEV_HTTPS?: string;
     __VOVK_START_WATCHER_IN_STANDALONE_MODE__?: 'true';
+    __VOVK_EXIT__?: 'true' | 'false';
 };
 export type VovkConfig = {
     clientOutDir?: string;
@@ -30,7 +31,7 @@ export type VovkConfig = {
     logLevel?: LogLevelNames;
     prettifyClient?: boolean;
     devHttps?: boolean;
-    clientGenerateTemplateNames?: string[];
+    experimental_clientGenerateTemplateNames?: string[];
     templates?: {
         service?: string;
         controller?: string;
@@ -47,6 +48,7 @@ export type VovkModuleRenderResult = {
 };
 export interface DevOptions {
     nextDev?: boolean;
+    exit?: boolean;
 }
 export interface GenerateOptions {
     clientOutDir?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vovk-cli",
-  "version": "0.0.1-draft.43",
+  "version": "0.0.1-draft.44",
   "bin": {
     "vovk": "./dist/index.mjs"
   },
@@ -36,27 +36,27 @@
   },
   "homepage": "https://vovk.dev",
   "peerDependencies": {
-    "vovk": "^3.0.0-draft.35"
+    "vovk": "^3.0.0-draft.50"
   },
   "dependencies": {
-    "@inquirer/prompts": "^7.1.0",
-    "@npmcli/package-json": "^6.1.0",
-    "chalk": "^5.3.0",
-    "chokidar": "^4.0.1",
-    "commander": "^12.1.0",
-    "concurrently": "^9.1.0",
-    "dotenv": "^16.4.5",
+    "@inquirer/prompts": "^7.2.3",
+    "@npmcli/package-json": "^6.1.1",
+    "chalk": "^5.4.1",
+    "chokidar": "^4.0.3",
+    "commander": "^13.1.0",
+    "concurrently": "^9.1.2",
+    "dotenv": "^16.4.7",
     "ejs": "^3.1.10",
     "gray-matter": "^4.0.3",
-    "inflection": "^3.0.0",
+    "inflection": "^3.0.2",
     "jsonc-parser": "^3.3.1",
     "lodash": "^4.17.21",
     "loglevel": "^1.9.2",
     "pluralize": "^8.0.0",
-    "prettier": "^3.4.1",
+    "prettier": "^3.4.2",
     "tar-stream": "^3.1.7",
-    "ts-morph": "^24.0.0",
-    "undici": "^7.0.0"
+    "ts-morph": "^25.0.0",
+    "undici": "^7.3.0"
   },
   "devDependencies": {
     "@types/concat-stream": "^2.0.3",
@@ -65,8 +65,8 @@
     "@types/pluralize": "^0.0.33",
     "@types/tar-stream": "^3.1.3",
     "concat-stream": "^2.0.0",
-    "create-next-app": "^15.0.3",
+    "create-next-app": "^15.1.6",
     "node-pty": "^1.0.0",
-    "type-fest": "^4.29.0"
+    "type-fest": "^4.33.0"
   }
 }