vovk-cli 0.0.1-draft.11 → 0.0.1-draft.112

package/dist/{watcher → dev}/index.mjs

@@ -1,33 +1,40 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
 import * as chokidar from 'chokidar';
-import fs from 'fs/promises';
-import getProjectInfo from '../getProjectInfo/index.mjs';
-import path from 'path';
+import { Agent, setGlobalDispatcher } from 'undici';
+import keyBy from 'lodash/keyBy.js';
+import capitalize from 'lodash/capitalize.js';
+import debounce from 'lodash/debounce.js';
+import once from 'lodash/once.js';
 import { debouncedEnsureSchemaFiles } from './ensureSchemaFiles.mjs';
-import writeOneSchemaFile from './writeOneSchemaFile.mjs';
+import writeOneSegmentSchemaFile from './writeOneSegmentSchemaFile.mjs';
 import logDiffResult from './logDiffResult.mjs';
-import generateClient from '../generateClient.mjs';
+import ensureClient from '../generate/ensureClient.mjs';
+import getProjectInfo from '../getProjectInfo/index.mjs';
+import generate from '../generate/index.mjs';
 import locateSegments from '../locateSegments.mjs';
 import debounceWithArgs from '../utils/debounceWithArgs.mjs';
-import debounce from 'lodash/debounce.js';
-import isEmpty from 'lodash/isEmpty.js';
 import formatLoggedSegmentName from '../utils/formatLoggedSegmentName.mjs';
-import keyBy from 'lodash/keyBy.js';
-import capitalize from 'lodash/capitalize.js';
-import { Agent, setGlobalDispatcher } from 'undici';
-export class VovkCLIWatcher {
+import isSegmentSchemaEmpty from './isSegmentSchemaEmpty.mjs';
+import writeConfigJson from './writeConfigJson.mjs';
+export class VovkDev {
     #projectInfo;
     #segments = [];
-    #schemas = {};
+    #fullSchema = {
+        segments: {},
+        config: {},
+    };
     #isWatching = false;
     #modulesWatcher = null;
     #segmentWatcher = null;
-    #watchSegments = () => {
+    #onFirstTimeGenerate = null;
+    #watchSegments = (callback) => {
         const segmentReg = /\/?\[\[\.\.\.[a-zA-Z-_]+\]\]\/route.ts$/;
         const { cwd, log, config, apiDir } = this.#projectInfo;
         const schemaOutAbsolutePath = path.join(cwd, config.schemaOutDir);
         const apiDirAbsolutePath = path.join(cwd, apiDir);
         const getSegmentName = (filePath) => path.relative(apiDirAbsolutePath, filePath).replace(segmentReg, '');
-        log.debug(`Watching segments in ${apiDirAbsolutePath}`);
+        log.debug(`Watching segments at ${apiDirAbsolutePath}`);
         this.#segmentWatcher = chokidar
             .watch(apiDirAbsolutePath, {
             persistent: true,
@@ -39,7 +46,14 @@ export class VovkCLIWatcher {
                 const segmentName = getSegmentName(filePath);
                 this.#segments = this.#segments.find((s) => s.segmentName === segmentName)
                     ? this.#segments
-                    : [...this.#segments, { routeFilePath: filePath, segmentName }];
+                    : [
+                        ...this.#segments,
+                        {
+                            routeFilePath: filePath,
+                            segmentName,
+                            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));
@@ -53,14 +67,14 @@ export class VovkCLIWatcher {
         })
             .on('addDir', async (dirPath) => {
             log.debug(`Directory ${dirPath} has been added to segments folder`);
-            this.#segments = await locateSegments(apiDirAbsolutePath);
+            this.#segments = await locateSegments({ dir: apiDirAbsolutePath, config });
             for (const { segmentName } of this.#segments) {
                 void this.#requestSchema(segmentName);
             }
         })
             .on('unlinkDir', async (dirPath) => {
             log.debug(`Directory ${dirPath} has been removed from segments folder`);
-            this.#segments = await locateSegments(apiDirAbsolutePath);
+            this.#segments = await locateSegments({ dir: apiDirAbsolutePath, config });
             for (const { segmentName } of this.#segments) {
                 void this.#requestSchema(segmentName);
             }
@@ -76,16 +90,17 @@ export class VovkCLIWatcher {
             }
         })
             .on('ready', () => {
+            callback();
             log.debug('Segments watcher is ready');
         })
             .on('error', (error) => {
             log.error(`Error watching segments folder: ${error?.message ?? 'Unknown error'}`);
         });
     };
-    #watchModules = () => {
+    #watchModules = (callback) => {
         const { config, cwd, log } = this.#projectInfo;
         const modulesDirAbsolutePath = path.join(cwd, config.modulesDir);
-        log.debug(`Watching modules in ${modulesDirAbsolutePath}`);
+        log.debug(`Watching modules at ${modulesDirAbsolutePath}`);
         const processControllerChange = debounceWithArgs(this.#processControllerChange, 500);
         this.#modulesWatcher = chokidar
             .watch(modulesDirAbsolutePath, {
@@ -114,30 +129,47 @@ export class VovkCLIWatcher {
             }
         })
             .on('ready', () => {
+            callback();
             log.debug('Modules watcher is ready');
         })
             .on('error', (error) => {
             log.error(`Error watching modules folder: ${error?.message ?? 'Unknown error'}`);
         });
     };
-    #watchConfig = () => {
+    #watchConfig = (callback) => {
         const { log, cwd } = this.#projectInfo;
         log.debug(`Watching config files`);
         let isInitial = true;
         let isReady = false;
         const handle = debounce(async () => {
             this.#projectInfo = await getProjectInfo();
-            if (!isInitial) {
-                log.info('Config file has been updated');
-                isInitial = false;
-            }
             await this.#modulesWatcher?.close();
             await this.#segmentWatcher?.close();
-            this.#watchModules();
-            this.#watchSegments();
+            await Promise.all([
+                new Promise((resolve) => this.#watchModules(() => resolve(0))),
+                new Promise((resolve) => this.#watchSegments(() => resolve(0))),
+            ]);
+            const schemaOutAbsolutePath = path.join(cwd, this.#projectInfo.config.schemaOutDir);
+            if (isInitial) {
+                callback();
+            }
+            else {
+                log.info('Config file has been updated');
+                this.#generate();
+            }
+            await writeConfigJson(schemaOutAbsolutePath, this.#projectInfo);
+            isInitial = false;
         }, 1000);
         chokidar
-            .watch(['vovk.config.{js,mjs,cjs}', '.config/vovk.config.{js,mjs,cjs}'], {
+            // .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',
+        ], {
             persistent: true,
             cwd,
             ignoreInitial: false,
@@ -156,13 +188,14 @@ export class VovkCLIWatcher {
             .on('error', (error) => log.error(`Error watching config files: ${error?.message ?? 'Unknown error'}`));
         void handle();
     };
-    #watch() {
+    async #watch(callback) {
         if (this.#isWatching)
             throw new Error('Already watching');
         const { log } = this.#projectInfo;
         log.debug(`Starting segments and modules watcher. Detected initial segments: ${JSON.stringify(this.#segments.map((s) => s.segmentName))}.`);
+        await ensureClient(this.#projectInfo);
         // automatically watches segments and modules
-        this.#watchConfig();
+        this.#watchConfig(callback);
     }
     #processControllerChange = async (filePath) => {
         const { log } = this.#projectInfo;
@@ -173,72 +206,78 @@ export class VovkCLIWatcher {
         }
         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(get|post|put|del|head|options|worker)\b[^}]*}\s*from\s*['"]vovk['"]/;
+        const importRegex = /import\s*{[^}]*\b(get|post|put|del|head|options)\b[^}]*}\s*from\s*['"]vovk['"]/;
         if (importRegex.test(code) && namesOfClasses.length) {
             const affectedSegments = this.#segments.filter((s) => {
-                const schema = this.#schemas[s.segmentName];
-                if (!schema)
+                const segmentSchema = this.#fullSchema.segments[s.segmentName];
+                if (!segmentSchema)
                     return false;
-                const controllersByOriginalName = keyBy(schema.controllers, '_originalControllerName');
-                const workersByOriginalName = keyBy(schema.workers, '_originalWorkerName');
-                return namesOfClasses.some((name) => schema.controllers[name] ||
-                    schema.workers[name] ||
-                    controllersByOriginalName[name] ||
-                    workersByOriginalName[name]);
+                const controllersByOriginalName = keyBy(segmentSchema.controllers, 'originalControllerName');
+                return namesOfClasses.some((name) => segmentSchema.controllers[name] || controllersByOriginalName[name]);
             });
             if (affectedSegments.length) {
-                log.debug(`A file with controller or worker ${namesOfClasses.join(', ')} have been modified at path "${filePath}". Segment(s) affected: ${JSON.stringify(affectedSegments.map((s) => s.segmentName))}`);
+                log.debug(`A file with controller ${namesOfClasses.join(', ')} have been modified at path "${filePath}". Segment(s) affected: ${JSON.stringify(affectedSegments.map((s) => s.segmentName))}`);
                 for (const segment of affectedSegments) {
                     await this.#requestSchema(segment.segmentName);
                 }
             }
+            else {
+                log.debug(`The class ${namesOfClasses.join(', ')} does not belong to any segment`);
+            }
         }
         else {
-            log.debug(`The file does not contain any controller or worker`);
+            log.debug(`The file does not contain any controller`);
         }
     };
     #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}`);
-        const resp = await fetch(endpoint);
-        if (resp.status !== 200) {
-            const probableCause = {
-                404: 'The segment is not compiled.',
-                500: 'Syntax error in one of controllers.',
-            }[resp.status];
-            log.warn(`Schema request to ${formatLoggedSegmentName(segmentName)} failed with status code ${resp.status} but expected 200.${probableCause ? ` Probable cause: ${probableCause}` : ''}`);
-            return;
-        }
-        let schema = null;
         try {
-            ({ schema } = (await resp.json()));
+            const resp = await fetch(endpoint);
+            if (resp.status !== 200) {
+                const probableCause = {
+                    404: 'The segment did not compile or config.origin is wrong.',
+                }[resp.status];
+                log.warn(`Schema request to ${formatLoggedSegmentName(segmentName)} failed with status code ${resp.status} but expected 200.${probableCause ? ` Probable cause: ${probableCause}` : ''}`);
+                return { isError: true };
+            }
+            let segmentSchema = null;
+            try {
+                ({ schema: segmentSchema } = (await resp.json()));
+            }
+            catch (error) {
+                log.error(`Error parsing schema for ${formatLoggedSegmentName(segmentName)}: ${error.message}`);
+            }
+            await this.#handleSegmentSchema(segmentName, segmentSchema);
         }
         catch (error) {
-            log.error(`Error parsing schema for ${formatLoggedSegmentName(segmentName)}: ${error.message}`);
+            log.error(`Error requesting schema for ${formatLoggedSegmentName(segmentName)} at ${endpoint}: ${error.message}`);
+            return { isError: true };
         }
-        await this.#handleSchema(schema);
+        return { isError: false };
     }, 500);
-    async #handleSchema(schema) {
+    #generate = debounce(() => generate({ projectInfo: this.#projectInfo, segments: this.#segments, fullSchema: this.#fullSchema }).then(this.#onFirstTimeGenerate), 1000);
+    async #handleSegmentSchema(segmentName, segmentSchema) {
         const { log, config, cwd } = this.#projectInfo;
-        if (!schema) {
-            log.warn('Segment schema is null');
+        if (!segmentSchema) {
+            log.warn(`${formatLoggedSegmentName(segmentName)} schema is null`);
             return;
         }
-        log.debug(`Handling received schema from ${formatLoggedSegmentName(schema.segmentName)}`);
+        log.debug(`Handling received schema from ${formatLoggedSegmentName(segmentName)}`);
         const schemaOutAbsolutePath = path.join(cwd, config.schemaOutDir);
-        const segment = this.#segments.find((s) => s.segmentName === schema.segmentName);
+        const segment = this.#segments.find((s) => s.segmentName === segmentName);
         if (!segment) {
-            log.warn(`Segment "${schema.segmentName}" not found`);
+            log.warn(`${formatLoggedSegmentName(segmentName)} not found`);
             return;
         }
-        this.#schemas[schema.segmentName] = schema;
-        if (schema.emitSchema) {
+        this.#fullSchema.segments[segmentName] = segmentSchema;
+        if (segmentSchema.emitSchema) {
             const now = Date.now();
-            const { diffResult } = await writeOneSchemaFile({
+            const { diffResult } = await writeOneSegmentSchemaFile({
                 schemaOutAbsolutePath,
-                schema,
+                segmentSchema,
                 skipIfExists: false,
             });
             const timeTook = Date.now() - now;
@@ -247,17 +286,24 @@ export class VovkCLIWatcher {
                 log.info(`Schema for ${formatLoggedSegmentName(segment.segmentName)} has been updated in ${timeTook}ms`);
             }
         }
-        else if (schema && (!isEmpty(schema.controllers) || !isEmpty(schema.workers))) {
-            log.error(`Non-empty schema provided for ${formatLoggedSegmentName(segment.segmentName)} but emitSchema is false`);
+        else if (segmentSchema && !isSegmentSchemaEmpty(segmentSchema)) {
+            log.error(`Non-empty schema provided for ${formatLoggedSegmentName(segment.segmentName)} but "emitSchema" is false`);
         }
-        if (this.#segments.every((s) => this.#schemas[s.segmentName])) {
+        if (this.#segments.every((s) => this.#fullSchema.segments[s.segmentName])) {
             log.debug(`All segments with "emitSchema" have schema.`);
-            await generateClient(this.#projectInfo, this.#segments, this.#schemas);
+            this.#generate();
         }
     }
-    async start({ clientOutDir } = {}) {
-        this.#projectInfo = await getProjectInfo({ clientOutDir });
+    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: {
@@ -274,18 +320,45 @@ export class VovkCLIWatcher {
         });
         const apiDirAbsolutePath = path.join(cwd, apiDir);
         const schemaOutAbsolutePath = path.join(cwd, config.schemaOutDir);
-        this.#segments = await locateSegments(apiDirAbsolutePath);
+        this.#segments = await locateSegments({ dir: apiDirAbsolutePath, config });
         await debouncedEnsureSchemaFiles(this.#projectInfo, schemaOutAbsolutePath, this.#segments.map((s) => s.segmentName));
-        // Request schema every segment in 5 seconds in order to update schema and start watching
+        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) {
-                void this.#requestSchema(segmentName);
+                let attempts = 0;
+                void this.#requestSchema(segmentName).then(({ isError }) => {
+                    if (isError) {
+                        const interval = setInterval(() => {
+                            attempts++;
+                            if (attempts >= MAX_ATTEMPTS) {
+                                clearInterval(interval);
+                                log.error(`Failed to request schema for ${formatLoggedSegmentName(segmentName)} after ${MAX_ATTEMPTS} attempts`);
+                                return;
+                            }
+                            void this.#requestSchema(segmentName).then(({ isError: isError2 }) => {
+                                if (!isError2) {
+                                    clearInterval(interval);
+                                    log.info(`Requested schema for ${formatLoggedSegmentName(segmentName)} after ${attempts} attempts`);
+                                }
+                            });
+                        }, DELAY);
+                    }
+                });
             }
-            this.#watch();
-        }, 5000);
+        }, 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 requests for schemas in a moment...`);
+        }
     }
 }
 const env = process.env;
 if (env.__VOVK_START_WATCHER_IN_STANDALONE_MODE__ === 'true') {
-    void new VovkCLIWatcher().start();
+    void new VovkDev().start({ exit: env.__VOVK_EXIT__ === 'true' });
 }

package/dist/dev/isSegmentSchemaEmpty.d.mts

@@ -0,0 +1,2 @@
+import type { VovkSegmentSchema } from 'vovk';
+export default function isSegmentSchemaEmpty(segmentSchema: VovkSegmentSchema): boolean;

package/dist/dev/isSegmentSchemaEmpty.mjs

@@ -0,0 +1,4 @@
+import isEmpty from 'lodash/isEmpty.js';
+export default function isSegmentSchemaEmpty(segmentSchema) {
+    return isEmpty(segmentSchema.controllers);
+}

package/dist/dev/logDiffResult.d.mts

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

package/dist/dev/logDiffResult.mjs

@@ -0,0 +1,57 @@
+import chalk from 'chalk';
+import formatLoggedSegmentName from '../utils/formatLoggedSegmentName.mjs';
+import chalkHighlightThing from '../utils/chalkHighlightThing.mjs';
+export default function logDiffResult(segmentName, diffResult, projectInfo) {
+    const diffNormalized = [];
+    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 = diffNormalized.length < 17 ? diffNormalized.length : 15;
+    const addedText = chalk.green('added');
+    const removedText = chalk.red('removed');
+    const changedText = chalk.cyan('changed');
+    for (const diffNormalizedItem of diffNormalized.slice(0, LIMIT)) {
+        switch (diffNormalizedItem.what) {
+            case 'controller':
+                switch (diffNormalizedItem.type) {
+                    case 'added':
+                        projectInfo.log.info(`Schema for RPC ${chalkHighlightThing(diffNormalizedItem.name)} has been ${addedText} at ${formatLoggedSegmentName(segmentName)}`);
+                        break;
+                    case 'removed':
+                        projectInfo.log.info(`Schema for RPC ${chalkHighlightThing(diffNormalizedItem.name)} has been ${removedText} from ${formatLoggedSegmentName(segmentName)}`);
+                        break;
+                }
+                break;
+            case 'controllerHandler':
+                switch (diffNormalizedItem.type) {
+                    case 'added':
+                        projectInfo.log.info(`Schema for RPC method ${chalkHighlightThing(diffNormalizedItem.name)} has been ${addedText} at ${formatLoggedSegmentName(segmentName)}`);
+                        break;
+                    case 'removed':
+                        projectInfo.log.info(`Schema for RPC method ${chalkHighlightThing(diffNormalizedItem.name)} has been ${removedText} from ${formatLoggedSegmentName(segmentName)}`);
+                        break;
+                    case 'changed':
+                        projectInfo.log.info(`Schema for RPC method ${chalkHighlightThing(diffNormalizedItem.name)} has been ${changedText} at ${formatLoggedSegmentName(segmentName)}`);
+                        break;
+                }
+                break;
+        }
+    }
+    if (diffNormalized.length > LIMIT) {
+        projectInfo.log.info(`... and ${diffNormalized.length - LIMIT} more changes`);
+    }
+}

package/dist/dev/writeConfigJson.d.mts

@@ -0,0 +1,2 @@
+import type { ProjectInfo } from '../getProjectInfo/index.mjs';
+export default function writeConfigJson(schemaOutAbsolutePath: string, projectInfo: ProjectInfo | null): Promise<void>;

package/dist/dev/writeConfigJson.mjs

@@ -0,0 +1,15 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import pick from 'lodash/pick.js';
+export default async function writeConfigJson(schemaOutAbsolutePath, projectInfo) {
+    const configJsonPath = path.join(schemaOutAbsolutePath, 'config.json');
+    const configStr = JSON.stringify(projectInfo ? pick(projectInfo.config, projectInfo.config.emitConfig) : {}, null, 2);
+    const existingStr = await fs.readFile(configJsonPath, 'utf-8').catch(() => null);
+    if (existingStr !== configStr) {
+        await fs.writeFile(configJsonPath, configStr);
+        projectInfo?.log.info(`Config JSON written to ${configJsonPath}`);
+    }
+    else {
+        projectInfo?.log.debug(`Config JSON is up to date at ${configJsonPath}`);
+    }
+}

package/dist/dev/writeOneSegmentSchemaFile.d.mts

@@ -0,0 +1,12 @@
+import type { VovkSegmentSchema } from 'vovk';
+import { type DiffResult } from './diffSegmentSchema.mjs';
+export declare const ROOT_SEGMENT_SCHEMA_NAME = "_root";
+export declare const SEGMENTS_SCHEMA_DIR_NAME = "segments";
+export default function writeOneSegmentSchemaFile({ schemaOutAbsolutePath, segmentSchema, skipIfExists, }: {
+    schemaOutAbsolutePath: string;
+    segmentSchema: VovkSegmentSchema;
+    skipIfExists?: boolean;
+}): Promise<{
+    isCreated: boolean;
+    diffResult: DiffResult | null;
+}>;

package/dist/{watcher/writeOneSchemaFile.mjs → dev/writeOneSegmentSchemaFile.mjs}

@@ -1,10 +1,11 @@
-import path from 'path';
-import fs from 'fs/promises';
-import diffSchema from './diffSchema.mjs';
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import diffSegmentSchema from './diffSegmentSchema.mjs';
 import getFileSystemEntryType from '../utils/getFileSystemEntryType.mjs';
 export const ROOT_SEGMENT_SCHEMA_NAME = '_root';
-export default async function writeOneSchemaFile({ schemaOutAbsolutePath, schema, skipIfExists = false, }) {
-    const segmentPath = path.join(schemaOutAbsolutePath, `${schema.segmentName || ROOT_SEGMENT_SCHEMA_NAME}.json`);
+export const SEGMENTS_SCHEMA_DIR_NAME = 'segments';
+export default async function writeOneSegmentSchemaFile({ schemaOutAbsolutePath, segmentSchema, skipIfExists = false, }) {
+    const segmentPath = path.join(schemaOutAbsolutePath, SEGMENTS_SCHEMA_DIR_NAME, `${segmentSchema.segmentName || ROOT_SEGMENT_SCHEMA_NAME}.json`);
     if (skipIfExists && (await getFileSystemEntryType(segmentPath))) {
         try {
             await fs.stat(segmentPath);
@@ -15,14 +16,17 @@ export default async function writeOneSchemaFile({ schemaOutAbsolutePath, schema
         }
     }
     await fs.mkdir(path.dirname(segmentPath), { recursive: true });
-    const schemaStr = JSON.stringify(schema, null, 2);
+    const schemaStr = JSON.stringify(segmentSchema, null, 2);
     const existing = await fs.readFile(segmentPath, 'utf-8').catch(() => null);
     if (existing === schemaStr) {
         return { isCreated: false, diffResult: null };
     }
     await fs.writeFile(segmentPath, schemaStr);
     if (existing) {
-        return { isCreated: false, diffResult: diffSchema(JSON.parse(existing), schema) };
+        return {
+            isCreated: false,
+            diffResult: diffSegmentSchema(JSON.parse(existing), segmentSchema),
+        };
     }
     return { isCreated: true, diffResult: null };
 }

package/dist/generate/ensureClient.d.mts

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

package/dist/generate/ensureClient.mjs

@@ -0,0 +1,31 @@
+import fs from 'node:fs/promises';
+import getClientTemplates from './getClientTemplates.mjs';
+import uniq from 'lodash/uniq.js';
+import chalkHighlightThing from '../utils/chalkHighlightThing.mjs';
+import path from 'node:path';
+export default async function ensureClient({ config, cwd, log }) {
+    const now = Date.now();
+    const { clientOutDirAbsolutePath, templateFiles } = getClientTemplates({
+        config,
+        cwd,
+        generateFrom: config.generateFrom,
+    });
+    let usedTemplateNames = [];
+    const text = `// auto-generated ${new Date().toISOString()}
+// This is a temporary placeholder to avoid compilation errors if client is imported before it's generated.
+// If you still see this text, the client is not generated yet because of an unknown problem.
+// Feel free to report an issue at https://github.com/finom/vovk/issues`;
+    for (const { outPath, templateName } of templateFiles) {
+        const existing = await fs.readFile(outPath, 'utf-8').catch(() => null);
+        if (!existing) {
+            await fs.mkdir(path.dirname(outPath), { recursive: true });
+            await fs.writeFile(outPath, outPath.endsWith('.py') ? text.replace(/\/\//g, '#') : text);
+            usedTemplateNames.push(templateName);
+        }
+    }
+    usedTemplateNames = uniq(usedTemplateNames);
+    if (usedTemplateNames.length) {
+        log.info(`Placeholder client files from template${usedTemplateNames.length !== 1 ? 's' : ''} ${chalkHighlightThing(usedTemplateNames.map((s) => `"${s}"`).join(', '))} are generated at ${clientOutDirAbsolutePath} in ${Date.now() - now}ms`);
+    }
+    return { written: !!usedTemplateNames.length };
+}

package/dist/generate/getClientTemplates.d.mts

@@ -0,0 +1,16 @@
+import type { VovkStrictConfig } from 'vovk';
+interface ClientTemplate {
+    templateName: string;
+    templatePath: string;
+    outPath: string;
+    emitFullSchema?: string | boolean;
+}
+export default function getClientTemplates({ config, cwd, generateFrom, }: {
+    config: VovkStrictConfig;
+    cwd: string;
+    generateFrom?: VovkStrictConfig['generateFrom'];
+}): {
+    clientOutDirAbsolutePath: string;
+    templateFiles: ClientTemplate[];
+};
+export {};

package/dist/generate/getClientTemplates.mjs

@@ -0,0 +1,42 @@
+import path from 'node:path';
+export default function getClientTemplates({ config, cwd, generateFrom = [], }) {
+    const templatesDir = path.join(import.meta.dirname, '../..', 'client-templates');
+    const clientOutDirAbsolutePath = path.resolve(cwd, config.clientOutDir);
+    const mapper = (dir) => (name) => ({
+        templateName: dir,
+        templatePath: path.resolve(templatesDir, dir, name),
+        outPath: path.join(clientOutDirAbsolutePath, name.replace('.ejs', '')),
+    });
+    const builtInTemplatesMap = {
+        ts: ['index.ts.ejs'].map(mapper('ts')),
+        main: ['main.cjs.ejs', 'main.d.cts.ejs'].map(mapper('main')),
+        module: ['module.mjs.ejs', 'module.d.mts.ejs'].map(mapper('module')),
+        python: ['__init__.py'].map(mapper('python')),
+    };
+    const templateFiles = (generateFrom ?? config.generateFrom).reduce((acc, template) => {
+        if (typeof template === 'string') {
+            if (template in builtInTemplatesMap) {
+                return [...acc, ...builtInTemplatesMap[template]];
+            }
+            return [
+                ...acc,
+                {
+                    templateName: template,
+                    templatePath: path.resolve(cwd, template),
+                    outPath: path.join(clientOutDirAbsolutePath, path.basename(template).replace('.ejs', '')),
+                },
+            ];
+        }
+        const outDirAbsolutePath = template.outDir ? path.resolve(cwd, template.outDir) : clientOutDirAbsolutePath;
+        return [
+            ...acc,
+            {
+                templateName: template.templateName ?? template.templatePath,
+                templatePath: path.resolve(cwd, template.templatePath),
+                outPath: path.join(outDirAbsolutePath, path.basename(template.templatePath).replace('.ejs', '')),
+                fullSchema: template.fullSchema,
+            },
+        ];
+    }, []);
+    return { clientOutDirAbsolutePath, templateFiles };
+}

package/dist/generate/index.d.mts

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