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

package/client-templates/compiled/{client.d.ts.ejs → compiled.d.ts.ejs}

@@ -1,9 +1,11 @@
+
 <%- '// 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) => { %>
-import type { Controllers as Controllers<%= i %>, Workers as Workers<%= i %> } from "<%= segment.segmentImportPath %>";
+<% segments.forEach((segment, i) => { 
+  const hasWorkers = !!Object.keys(segmentsSchema[segment.segmentName].workers).length;
+%>
+import type { Controllers as Controllers<%= i %><% if(hasWorkers) { %>, Workers as Workers<%= i %> <% } %> } from "<%= segment.segmentImportPath %>";
 <% }) %>
 type Options = typeof fetcher extends VovkClientFetcher<infer U> ? U : never;
 
@@ -14,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/{client.js.ejs → compiled.js.ejs}

@@ -1,11 +1,10 @@
 <%- '// 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 %>');
 
 const { default: validateOnClient = null } = <%- validateOnClientImportPath ? `require('${validateOnClientImportPath}')` : '{}'%>;
-const apiRoot = '<%= apiEntryPoint %>';
+const apiRoot = '<%= apiRoot %>';
 
 <% segments.forEach((segment) => {
     const segSchema = segmentsSchema[segment.segmentName];
@@ -14,13 +13,13 @@ const apiRoot = '<%= apiEntryPoint %>';
     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';
-import { promisifyWorker } from 'vovk/worker';
+import { createRPC, createWPC, type VovkClientFetcher } from 'vovk';
 import fetcher from '<%= fetcherClientImportPath %>';
 import schema from '<%= schemaOutImportPath %>';
 <% if (validateOnClientImportPath) { %>
@@ -9,16 +8,17 @@ import validateOnClient from '<%= validateOnClientImportPath %>';
 const validateOnClient = undefined;
 <% } %>
 type Options = typeof fetcher extends VovkClientFetcher<infer U> ? U : never;
-const apiRoot = '<%= apiEntryPoint %>';
+const apiRoot = '<%= apiRoot %>';
 
 <% segments.forEach((segment, i) => {
     const segSchema = segmentsSchema[segment.segmentName];
     if (!segSchema || !segSchema.emitSchema) return;
+    const hasWorkers = !!Object.keys(segmentsSchema[segment.segmentName].workers).length;
 %>
-import type { Controllers as Controllers<%= i %>, Workers as Workers<%= i %> } from "<%= segment.segmentImportPath %>";
+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 } }
@@ -26,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[];
@@ -15,7 +14,7 @@ export interface DiffResult {
     workers: WorkersOrControllersDiff;
     controllers: WorkersOrControllersDiff;
 }
-export declare function diffHandlers<T extends _VovkWorkerSchema['handlers'] | _VovkControllerSchema['handlers']>(oldHandlers: T, newHandlers: T, nameOfClass: string): HandlersDiff;
+export declare function diffHandlers<T extends VovkWorkerSchema['handlers'] | VovkControllerSchema['handlers']>(oldHandlers: T, newHandlers: T, nameOfClass: string): HandlersDiff;
 export declare function diffWorkersOrControllers<T extends VovkSchema['controllers'] | VovkSchema['workers']>(oldItems: T, newItems: T): WorkersOrControllersDiff;
 /**
 example output:

package/dist/dev/ensureClient.d.mts

@@ -1,5 +1,5 @@
 import type { ProjectInfo } from '../getProjectInfo/index.mjs';
-export default function ensureClient(projectInfo: ProjectInfo): Promise<{
+export default function ensureClient({ config, cwd, log }: ProjectInfo): Promise<{
     written: boolean;
     path: string;
 }>;

package/dist/dev/ensureClient.mjs

@@ -1,7 +1,6 @@
 import path from 'node:path';
 import fs from 'node:fs/promises';
-export default async function ensureClient(projectInfo) {
-    const { config, cwd, log } = projectInfo;
+export default async function ensureClient({ config, cwd, log }) {
     const now = Date.now();
     const clientoOutDirAbsolutePath = path.join(cwd, config.clientOutDir);
     const dts = `// auto-generated
@@ -10,8 +9,8 @@ export default async function ensureClient(projectInfo) {
 // Feel free to report an issue at https://github.com/finom/vovk/issues`;
     const js = dts;
     const ts = dts;
-    const localJsAbsolutePath = path.join(clientoOutDirAbsolutePath, 'client.js');
-    const localDtsAbsolutePath = path.join(clientoOutDirAbsolutePath, 'client.d.ts');
+    const localJsAbsolutePath = path.join(clientoOutDirAbsolutePath, 'compiled.js');
+    const localDtsAbsolutePath = path.join(clientoOutDirAbsolutePath, 'compiled.d.ts');
     const localTsAbsolutePath = path.join(clientoOutDirAbsolutePath, 'index.ts');
     const existingJs = await fs.readFile(localJsAbsolutePath, 'utf-8').catch(() => null);
     const existingDts = await fs.readFile(localDtsAbsolutePath, 'utf-8').catch(() => null);

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,12 +6,13 @@ 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';
 import ensureClient from './ensureClient.mjs';
 import getProjectInfo from '../getProjectInfo/index.mjs';
-import generateClient from '../generateClient.mjs';
+import generate from '../generate/index.mjs';
 import locateSegments from '../locateSegments.mjs';
 import debounceWithArgs from '../utils/debounceWithArgs.mjs';
 import formatLoggedSegmentName from '../utils/formatLoggedSegmentName.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,
@@ -215,9 +227,9 @@ export class VovkDev {
         }
     };
     #requestSchema = debounceWithArgs(async (segmentName) => {
-        const { apiEntryPoint, log, port, config } = this.#projectInfo;
+        const { apiRoot, log, port, config } = this.#projectInfo;
         const { devHttps } = config;
-        const endpoint = `${apiEntryPoint.startsWith(`http${devHttps ? 's' : ''}://`) ? apiEntryPoint : `http${devHttps ? 's' : ''}://localhost:${port}${apiEntryPoint}`}/${segmentName ? `${segmentName}/` : ''}_schema_`;
+        const endpoint = `${apiRoot.startsWith(`http${devHttps ? 's' : ''}://`) ? apiRoot : `http${devHttps ? 's' : ''}://localhost:${port}${apiRoot}`}/${segmentName ? `${segmentName}/` : ''}_schema_`;
         log.debug(`Requesting schema for ${formatLoggedSegmentName(segmentName)} at ${endpoint}`);
         try {
             const resp = await fetch(endpoint);
@@ -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 generateClient({ 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

@@ -0,0 +1,11 @@
+import { VovkConfig } from '../types.mjs';
+interface ClientTemplate {
+    templatePath: string;
+    outPath: string;
+}
+export default function getClientTemplates({ config, cwd, templateNames, }: {
+    config: Required<VovkConfig>;
+    cwd: string;
+    templateNames?: string[];
+}): ClientTemplate[];
+export {};

package/dist/generate/getClientTemplates.mjs

@@ -0,0 +1,28 @@
+import path from 'node:path';
+export default function getClientTemplates({ config, cwd, templateNames = [], }) {
+    const __dirname = path.dirname(new URL(import.meta.url).pathname);
+    const templatesDir = path.join(__dirname, '../..', 'client-templates');
+    const clientOutDirAbsolutePath = path.resolve(cwd, config.clientOutDir);
+    const mapper = (dir) => (name) => ({
+        templatePath: path.resolve(templatesDir, dir, name),
+        outPath: path.join(clientOutDirAbsolutePath, name.replace('.ejs', '')),
+    });
+    const builtInTemplatesMap = {
+        ts: ['index.ts.ejs'].map(mapper('ts')),
+        compiled: ['compiled.js.ejs', 'compiled.d.ts.ejs'].map(mapper('compiled')),
+        python: ['__init__.py'].map(mapper('python')),
+    };
+    const templateFiles = (templateNames ?? config.experimental_clientGenerateTemplateNames).reduce((acc, template) => {
+        if (template in builtInTemplatesMap) {
+            return [...acc, ...builtInTemplatesMap[template]];
+        }
+        return [
+            ...acc,
+            {
+                templatePath: path.resolve(cwd, template),
+                outPath: path.join(clientOutDirAbsolutePath, path.basename(template).replace('.ejs', '')),
+            },
+        ];
+    }, []);
+    return templateFiles;
+}

package/dist/generate/index.d.mts

@@ -0,0 +1,12 @@
+import type { VovkSchema } from 'vovk';
+import type { ProjectInfo } from '../getProjectInfo/index.mjs';
+import type { Segment } from '../locateSegments.mjs';
+import { GenerateOptions } from '../types.mjs';
+export default function generate({ projectInfo, segments, segmentsSchema, templates, prettify: prettifyClient, fullSchema, }: {
+    projectInfo: ProjectInfo;
+    segments: Segment[];
+    segmentsSchema: Record<string, VovkSchema>;
+} & Pick<GenerateOptions, 'templates' | 'prettify' | 'fullSchema'>): Promise<{
+    written: boolean;
+    path: string;
+}>;

package/dist/generate/index.mjs

@@ -0,0 +1,78 @@
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import ejs from 'ejs';
+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.experimental_clientGenerateTemplateNames;
+    const noClient = templates?.[0] === 'none';
+    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:
+    for (let i = 0; i < segments.length; i++) {
+        const { segmentName } = segments[i];
+        const schema = segmentsSchema[segmentName];
+        if (!schema) {
+            throw new Error(`Unable to generate client. No schema found for ${formatLoggedSegmentName(segmentName)}`);
+        }
+        if (!schema.emitSchema)
+            continue;
+    }
+    const now = Date.now();
+    // Data for the EJS templates:
+    const ejsData = {
+        apiRoot,
+        fetcherClientImportPath,
+        schemaOutImportPath,
+        validateOnClientImportPath,
+        segments,
+        segmentsSchema,
+    };
+    // 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}`);
+    }
+    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 };
+    }
+    // Write updated files where needed
+    await Promise.all(processedTemplates.map(({ outPath, rendered, needsWriting }) => {
+        if (needsWriting) {
+            return fs.writeFile(outPath, rendered);
+        }
+        return null;
+    }));
+    log.info(`Client generated in ${Date.now() - now}ms`);
+    return { written: true, path: clientOutDirAbsolutePath };
+}

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,6 +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,
+        experimental_clientGenerateTemplateNames: conf.experimental_clientGenerateTemplateNames ?? ['ts', 'compiled'],
         templates: {
             service: 'vovk-cli/templates/service.ejs',
             controller: 'vovk-cli/templates/controller.ejs',

package/dist/getProjectInfo/index.d.mts

@@ -6,7 +6,7 @@ export default function getProjectInfo({ port: givenPort, clientOutDir, cwd, }?:
 }): Promise<{
     cwd: string;
     port: string;
-    apiEntryPoint: string;
+    apiRoot: string;
     apiDir: string;
     srcRoot: string;
     schemaOutImportPath: string;

package/dist/getProjectInfo/index.mjs

@@ -6,7 +6,7 @@ export default async function getProjectInfo({ port: givenPort, clientOutDir, cw
     // Make PORT available to the config file at getConfig
     process.env.PORT = port;
     const { config, srcRoot, configAbsolutePaths, userConfig, error } = await getConfig({ clientOutDir, cwd });
-    const apiEntryPoint = `${config.origin ?? ''}/${config.rootEntry}`;
+    const apiRoot = `${config.origin ?? ''}/${config.rootEntry}`;
     const apiDir = path.join(srcRoot, 'app', config.rootEntry);
     const schemaOutImportPath = path.relative(config.clientOutDir, config.schemaOutDir).replace(/\\/g, '/'); // windows fix
     const fetcherClientImportPath = config.fetcher.startsWith('.')
@@ -25,7 +25,7 @@ export default async function getProjectInfo({ port: givenPort, clientOutDir, cw
     return {
         cwd,
         port,
-        apiEntryPoint,
+        apiRoot,
         apiDir,
         srcRoot,
         schemaOutImportPath,

package/dist/index.mjs

@@ -7,7 +7,7 @@ import { Command } from 'commander';
 import concurrently from 'concurrently';
 import getAvailablePort from './utils/getAvailablePort.mjs';
 import getProjectInfo from './getProjectInfo/index.mjs';
-import generateClient from './generateClient.mjs';
+import generate from './generate/index.mjs';
 import locateSegments from './locateSegments.mjs';
 import { VovkDev } from './dev/index.mjs';
 import newComponents from './new/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
@@ -66,19 +73,18 @@ program
     .alias('g')
     .description('Generate client')
     .option('--out, --client-out-dir <path>', 'Path to output directory')
-    .option('--template, --templates <templates...>', 'Client code templates')
-    .option('--no-client', 'Do not generate client')
+    .option('--template, --templates <templates...>', 'Client code templates ("ts", "compiled", "python", "none", a custom path)')
     .option('--full-schema [fileName]', 'Generate client with full schema')
     .option('--prettify', 'Prettify output files')
     .action(async (options) => {
-    const { clientOutDir, templates, prettify, noClient, fullSchema } = options;
+    const { clientOutDir, templates, prettify, fullSchema } = options;
     const projectInfo = await getProjectInfo({ clientOutDir });
     const { cwd, config, apiDir } = projectInfo;
     const segments = await locateSegments({ dir: apiDir, config });
     const schemaOutAbsolutePath = path.join(cwd, config.schemaOutDir);
     const schemaImportUrl = pathToFileURL(path.join(schemaOutAbsolutePath, 'index.js')).href;
-    const { default: segmentsSchema } = await import(schemaImportUrl);
-    await generateClient({ projectInfo, segments, segmentsSchema, templates, prettify, noClient, fullSchema });
+    const { default: segmentsSchema } = (await import(schemaImportUrl));
+    await generate({ projectInfo, segments, segmentsSchema, templates, prettify, fullSchema });
 });
 program
     .command('new [components...]')

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() {
-    const vovk = path.join(import.meta.dirname, '../../.vovk');
-    const js = path.join(vovk, 'client.js');
-    const ts = path.join(vovk, 'client.d.ts');
+    // 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,6 +31,7 @@ export type VovkConfig = {
     logLevel?: LogLevelNames;
     prettifyClient?: boolean;
     devHttps?: boolean;
+    experimental_clientGenerateTemplateNames?: string[];
     templates?: {
         service?: string;
         controller?: string;
@@ -46,13 +48,13 @@ export type VovkModuleRenderResult = {
 };
 export interface DevOptions {
     nextDev?: boolean;
+    exit?: boolean;
 }
 export interface GenerateOptions {
     clientOutDir?: string;
     templates?: string[];
     prettify?: boolean;
     fullSchema?: string | boolean;
-    noClient?: boolean;
 }
 export interface InitOptions {
     yes?: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vovk-cli",
-  "version": "0.0.1-draft.42",
+  "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.34"
+    "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"
   }
 }

package/dist/generateClient.d.mts

@@ -1,12 +0,0 @@
-import type { VovkSchema } from 'vovk';
-import type { ProjectInfo } from './getProjectInfo/index.mjs';
-import type { Segment } from './locateSegments.mjs';
-import { GenerateOptions } from './types.mjs';
-export default function generateClient({ projectInfo, segments, segmentsSchema, templates, prettify: prettifyClient, fullSchema, noClient, }: {
-    projectInfo: ProjectInfo;
-    segments: Segment[];
-    segmentsSchema: Record<string, VovkSchema>;
-} & Pick<GenerateOptions, 'templates' | 'prettify' | 'fullSchema' | 'noClient'>): Promise<{
-    written: boolean;
-    path: string;
-}>;

package/dist/generateClient.mjs

@@ -1,91 +0,0 @@
-import path from 'node:path';
-import fs from 'node:fs/promises';
-import ejs from 'ejs';
-import formatLoggedSegmentName from './utils/formatLoggedSegmentName.mjs';
-import prettify from './utils/prettify.mjs';
-export default async function generateClient({ projectInfo, segments, segmentsSchema, templates = ['ts', 'compiled'], prettify: prettifyClient, fullSchema, noClient, }) {
-    const { config, cwd, log, validateOnClientImportPath, apiEntryPoint, fetcherClientImportPath, schemaOutImportPath, } = projectInfo;
-    const __dirname = path.dirname(new URL(import.meta.url).pathname);
-    const templatesDir = path.join(__dirname, '..', 'client-templates');
-    const clientOutDirAbsolutePath = path.resolve(cwd, config.clientOutDir);
-    const mapper = (dir) => (name) => ({
-        templatePath: path.resolve(templatesDir, dir, name),
-        outPath: path.join(clientOutDirAbsolutePath, name.replace('.ejs', '')),
-    });
-    const builtInTemplatesMap = {
-        ts: ['index.ts.ejs'].map(mapper('ts')),
-        compiled: ['client.js.ejs', 'client.d.ts.ejs'].map(mapper('compiled')),
-        python: ['__init__.py'].map(mapper('python')),
-    };
-    const templateFiles = templates.reduce((acc, template) => {
-        if (template in builtInTemplatesMap) {
-            return [...acc, ...builtInTemplatesMap[template]];
-        }
-        return [...acc, {
-                templatePath: path.resolve(cwd, template),
-                outPath: path.join(clientOutDirAbsolutePath, path.basename(template).replace('.ejs', ''))
-            }];
-    }, []);
-    // Ensure that each segment has a matching schema if it needs to be emitted:
-    for (let i = 0; i < segments.length; i++) {
-        const { segmentName } = segments[i];
-        const schema = segmentsSchema[segmentName];
-        if (!schema) {
-            throw new Error(`Unable to generate client. No schema found for ${formatLoggedSegmentName(segmentName)}`);
-        }
-        if (!schema.emitSchema)
-            continue;
-    }
-    const now = Date.now();
-    // Data for the EJS templates:
-    const ejsData = {
-        apiEntryPoint,
-        fetcherClientImportPath,
-        schemaOutImportPath,
-        validateOnClientImportPath,
-        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,
-        };
-    }));
-    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 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
-    await Promise.all(processedTemplates.map(({ outPath, rendered, needsWriting }) => {
-        if (needsWriting) {
-            return fs.writeFile(outPath, rendered);
-        }
-        return null;
-    }));
-    log.info(`Client generated in ${Date.now() - now}ms`);
-    return { written: true, path: clientOutDirAbsolutePath };
-}