vovk-cli 0.0.1-draft.98 → 0.0.1

package/dist/dev/index.mjs

@@ -1,34 +1,48 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
+import { VovkSchemaIdEnum } from 'vovk/internal';
 import * as chokidar from 'chokidar';
 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, { JSON_DIR_NAME } from './writeOneSchemaFile.mjs';
-import logDiffResult from './logDiffResult.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 formatLoggedSegmentName from '../utils/formatLoggedSegmentName.mjs';
-import isSchemaEmpty from './isSchemaEmpty.mjs';
+import isEmpty from 'lodash/isEmpty.js';
+import { ensureSchemaFiles, debouncedEnsureSchemaFiles } from './ensureSchemaFiles.mjs';
+import { writeOneSegmentSchemaFile } from './writeOneSegmentSchemaFile.mjs';
+import { logDiffResult } from './logDiffResult.mjs';
+import { ensureClient } from '../generate/ensureClient.mjs';
+import { getProjectInfo } from '../getProjectInfo/index.mjs';
+import { generate } from '../generate/generate.mjs';
+import { locateSegments } from '../utils/locateSegments.mjs';
+import { debounceWithArgs } from '../utils/debounceWithArgs.mjs';
+import { formatLoggedSegmentName } from '../utils/formatLoggedSegmentName.mjs';
+import { writeMetaJson } from './writeMetaJson.mjs';
+import { chalkHighlightThing } from '../utils/chalkHighlightThing.mjs';
+import { getMetaSchema } from '../getProjectInfo/getMetaSchema.mjs';
 export class VovkDev {
     #projectInfo;
     #segments = [];
-    #schemas = {};
+    #schemaSegments = {};
     #isWatching = false;
     #modulesWatcher = null;
     #segmentWatcher = null;
     #onFirstTimeGenerate = null;
+    #schemaOut = null;
+    #devHttps;
+    #logLevel;
+    constructor({ schemaOut, devHttps, logLevel }) {
+        this.#schemaOut = schemaOut || null;
+        this.#devHttps = devHttps || false;
+        this.#logLevel = logLevel || 'info';
+    }
     #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 { cwd, log, config, apiDirAbsolutePath } = this.#projectInfo;
+        if (!apiDirAbsolutePath) {
+            throw new Error('Unable to watch segments. It looks like CWD is not a Next.js app.');
+        }
+        const schemaOutAbsolutePath = path.resolve(cwd, this.#schemaOut ?? config.schemaOutDir);
         const getSegmentName = (filePath) => path.relative(apiDirAbsolutePath, filePath).replace(segmentReg, '');
         log.debug(`Watching segments at ${apiDirAbsolutePath}`);
         this.#segmentWatcher = chokidar
@@ -47,7 +61,6 @@ export class VovkDev {
                         {
                             routeFilePath: filePath,
                             segmentName,
-                            segmentImportPath: path.relative(config.clientOutDir, filePath), // TODO DRY locateSegments
                         },
                     ];
                 log.info(`${capitalize(formatLoggedSegmentName(segmentName))} has been added`);
@@ -63,14 +76,22 @@ export class VovkDev {
         })
             .on('addDir', async (dirPath) => {
             log.debug(`Directory ${dirPath} has been added to segments folder`);
-            this.#segments = await locateSegments({ dir: apiDirAbsolutePath, config });
+            this.#segments = await locateSegments({
+                dir: apiDirAbsolutePath,
+                config,
+                log: this.#projectInfo.log,
+            });
             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({ dir: apiDirAbsolutePath, config });
+            this.#segments = await locateSegments({
+                dir: apiDirAbsolutePath,
+                config,
+                log: this.#projectInfo.log,
+            });
             for (const { segmentName } of this.#segments) {
                 void this.#requestSchema(segmentName);
             }
@@ -138,13 +159,16 @@ export class VovkDev {
         let isInitial = true;
         let isReady = false;
         const handle = debounce(async () => {
-            this.#projectInfo = await getProjectInfo();
+            this.#projectInfo = await getProjectInfo({ logLevel: this.#logLevel });
+            const { config, apiDirAbsolutePath } = this.#projectInfo;
+            this.#segments = await locateSegments({ dir: apiDirAbsolutePath, config, log });
             await this.#modulesWatcher?.close();
             await this.#segmentWatcher?.close();
             await Promise.all([
                 new Promise((resolve) => this.#watchModules(() => resolve(0))),
                 new Promise((resolve) => this.#watchSegments(() => resolve(0))),
             ]);
+            const schemaOutAbsolutePath = path.join(cwd, this.#schemaOut ?? this.#projectInfo.config.schemaOutDir);
             if (isInitial) {
                 callback();
             }
@@ -152,18 +176,12 @@ export class VovkDev {
                 log.info('Config file has been updated');
                 this.#generate();
             }
+            await writeMetaJson(schemaOutAbsolutePath, this.#projectInfo);
             isInitial = false;
         }, 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,mjs}', '.config/vovk.config.{js,mjs}'], {
+            .watch(['vovk.config.js', 'vovk.config.mjs', '.config/vovk.config.js', '.config/vovk.config.mjs'], {
             persistent: true,
             cwd,
             ignoreInitial: false,
@@ -187,7 +205,6 @@ export class VovkDev {
             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(callback);
     }
@@ -203,11 +220,11 @@ export class VovkDev {
         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.#schemaSegments[s.segmentName];
+                if (!segmentSchema)
                     return false;
-                const controllersByOriginalName = keyBy(schema.controllers, 'originalControllerName');
-                return namesOfClasses.some((name) => schema.controllers[name] || controllersByOriginalName[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 ${namesOfClasses.join(', ')} have been modified at path "${filePath}". Segment(s) affected: ${JSON.stringify(affectedSegments.map((s) => s.segmentName))}`);
@@ -220,58 +237,82 @@ export class VovkDev {
             }
         }
         else {
-            log.debug(`The file does not contain any controller`);
+            log.debug(`The file ${filePath} does not contain any controller`);
         }
     };
     #requestSchema = debounceWithArgs(async (segmentName) => {
         const { apiRoot, log, port, config } = this.#projectInfo;
-        const { devHttps } = config;
+        const devHttps = this.#devHttps ?? config.devHttps;
         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);
+            const text = await resp.text();
+            let json;
+            try {
+                json = JSON.parse(text);
+            }
+            catch (error) {
+                log.error(`Error parsing JSON from ${chalkHighlightThing(endpoint)} for ${formatLoggedSegmentName(segmentName)}: ${error?.message}`);
+                log.error(`Response text: ${text.length > 2000 ? text.slice(0, 2000) + '...' : text}`);
+                return { isError: true };
+            }
             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}` : ''}`);
+                log.warn(`Schema request to ${chalkHighlightThing(endpoint)} for ${formatLoggedSegmentName(segmentName)} failed with status code ${resp.status} but expected 200.${probableCause ? ` Probable cause: ${probableCause}.` : ''}.`);
+                log.warn(`Response from ${formatLoggedSegmentName(segmentName)}: ${text}`);
                 return { isError: true };
             }
-            let schema = null;
+            let segmentSchema = null;
             try {
-                ({ schema } = (await resp.json()));
+                ({ schema: segmentSchema } = json);
             }
             catch (error) {
-                log.error(`Error parsing schema for ${formatLoggedSegmentName(segmentName)}: ${error.message}`);
+                log.error(`Error parsing schema for ${formatLoggedSegmentName(segmentName)}: ${error?.message}`);
             }
-            await this.#handleSchema(schema);
+            await this.#handleSegmentSchema(segmentName, segmentSchema);
         }
         catch (error) {
-            log.error(`Error requesting schema for ${formatLoggedSegmentName(segmentName)} at ${endpoint}: ${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) {
+    #generate = debounce(() => {
+        const fullSchema = {
+            $schema: VovkSchemaIdEnum.SCHEMA,
+            segments: this.#schemaSegments,
+            meta: getMetaSchema({
+                config: this.#projectInfo.config,
+            }),
+        };
+        return generate({
+            projectInfo: this.#projectInfo,
+            fullSchema,
+            locatedSegments: this.#segments,
+        }).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, { upperFirst: true })} schema is null`);
             return;
         }
-        log.debug(`Handling received schema from ${formatLoggedSegmentName(schema.segmentName)}`);
-        const schemaJsonOutAbsolutePath = path.join(cwd, config.schemaOutDir, JSON_DIR_NAME);
-        const segment = this.#segments.find((s) => s.segmentName === schema.segmentName);
+        log.debug(`Handling received schema from ${formatLoggedSegmentName(segmentName)}`);
+        const schemaOutAbsolutePath = path.resolve(cwd, this.#schemaOut ?? config.schemaOutDir);
+        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.#schemaSegments[segmentName] = segmentSchema;
+        if (segmentSchema.emitSchema) {
             const now = Date.now();
-            const { diffResult } = await writeOneSchemaFile({
-                schemaJsonOutAbsolutePath,
-                schema,
+            const { diffResult } = await writeOneSegmentSchemaFile({
+                schemaOutAbsolutePath,
+                segmentSchema,
                 skipIfExists: false,
             });
             const timeTook = Date.now() - now;
@@ -280,25 +321,27 @@ export class VovkDev {
                 log.info(`Schema for ${formatLoggedSegmentName(segment.segmentName)} has been updated in ${timeTook}ms`);
             }
         }
-        else if (schema && !isSchemaEmpty(schema)) {
+        else if (segmentSchema && !isEmpty(segmentSchema.controllers)) {
             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.#schemaSegments[s.segmentName])) {
             log.debug(`All segments with "emitSchema" have schema.`);
             this.#generate();
         }
     }
     async start({ exit }) {
         const now = Date.now();
-        this.#projectInfo = await getProjectInfo();
-        const { log, config, cwd, apiDir } = this.#projectInfo;
+        this.#projectInfo = await getProjectInfo({ logLevel: this.#logLevel });
+        const { log, config, cwd, apiDirAbsolutePath } = this.#projectInfo;
+        this.#segments = await locateSegments({ dir: apiDirAbsolutePath, config, log });
         log.info('Starting...');
         if (exit) {
             this.#onFirstTimeGenerate = once(() => {
                 log.info('The schemas and the RPC client have been generated. Exiting...');
             });
         }
-        if (config.devHttps) {
+        const devHttps = this.#devHttps ?? config.devHttps;
+        if (devHttps) {
             const agent = new Agent({
                 connect: {
                     rejectUnauthorized: false,
@@ -312,10 +355,10 @@ export class VovkDev {
         process.on('unhandledRejection', (reason) => {
             log.error(`Unhandled Rejection: ${String(reason)}`);
         });
-        const apiDirAbsolutePath = path.join(cwd, apiDir);
-        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 schemaOutAbsolutePath = path.resolve(cwd, this.#schemaOut ?? config.schemaOutDir);
+        const segmentNames = this.#segments.map((s) => s.segmentName);
+        await ensureSchemaFiles(this.#projectInfo, schemaOutAbsolutePath, segmentNames);
+        await ensureClient(this.#projectInfo, this.#segments);
         const MAX_ATTEMPTS = 5;
         const DELAY = 5000;
         // Request schema every segment in 5 seconds in order to update schema on start
@@ -334,7 +377,7 @@ export class VovkDev {
                             void this.#requestSchema(segmentName).then(({ isError: isError2 }) => {
                                 if (!isError2) {
                                     clearInterval(interval);
-                                    log.info(`Requested schema for ${formatLoggedSegmentName(segmentName)} after ${attempts} attempts`);
+                                    log.info(`Requested schema for ${formatLoggedSegmentName(segmentName)} after ${attempts} attempt${attempts === 1 ? '' : 's'}`);
                                 }
                             });
                         }, DELAY);
@@ -354,5 +397,11 @@ export class VovkDev {
 }
 const env = process.env;
 if (env.__VOVK_START_WATCHER_IN_STANDALONE_MODE__ === 'true') {
-    void new VovkDev().start({ exit: env.__VOVK_EXIT__ === 'true' });
+    void new VovkDev({
+        schemaOut: env.__VOVK_SCHEMA_OUT_FLAG__ || undefined,
+        devHttps: env.__VOVK_DEV_HTTPS_FLAG__ === 'true',
+        logLevel: env.__VOVK_LOG_LEVEL__,
+    }).start({
+        exit: env.__VOVK_EXIT__ === 'true',
+    });
 }

package/dist/dev/logDiffResult.d.mts

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

package/dist/dev/logDiffResult.mjs

@@ -1,7 +1,7 @@
 import chalk from 'chalk';
-import formatLoggedSegmentName from '../utils/formatLoggedSegmentName.mjs';
-import chalkHighlightThing from '../utils/chalkHighlightThing.mjs';
-export default function logDiffResult(segmentName, diffResult, projectInfo) {
+import { formatLoggedSegmentName } from '../utils/formatLoggedSegmentName.mjs';
+import { chalkHighlightThing } from '../utils/chalkHighlightThing.mjs';
+export function logDiffResult(segmentName, diffResult, projectInfo) {
     const diffNormalized = [];
     diffResult.controllers.added.forEach((name) => {
         diffNormalized.push({ what: 'controller', type: 'added', name });
@@ -20,7 +20,7 @@ export default function logDiffResult(segmentName, diffResult, projectInfo) {
             diffNormalized.push({ what: 'controllerHandler', type: 'changed', name: `${handler.nameOfClass}.${name}` });
         });
     });
-    const LIMIT = diffNormalized.length < 12 ? diffNormalized.length : 10;
+    const LIMIT = diffNormalized.length < 17 ? diffNormalized.length : 15;
     const addedText = chalk.green('added');
     const removedText = chalk.red('removed');
     const changedText = chalk.cyan('changed');
@@ -29,10 +29,10 @@ export default function logDiffResult(segmentName, diffResult, projectInfo) {
             case 'controller':
                 switch (diffNormalizedItem.type) {
                     case 'added':
-                        projectInfo.log.info(`Schema for RPC ${chalkHighlightThing(diffNormalizedItem.name)} has been ${addedText} at ${formatLoggedSegmentName(segmentName)}`);
+                        projectInfo.log.info(`Schema for RPC module ${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)}`);
+                        projectInfo.log.info(`Schema for RPC module ${chalkHighlightThing(diffNormalizedItem.name)} has been ${removedText} from ${formatLoggedSegmentName(segmentName)}`);
                         break;
                 }
                 break;

package/dist/dev/writeMetaJson.d.mts

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

package/dist/dev/writeMetaJson.mjs

@@ -0,0 +1,19 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { META_FILE_NAME } from './writeOneSegmentSchemaFile.mjs';
+import { chalkHighlightThing } from '../utils/chalkHighlightThing.mjs';
+import { getMetaSchema } from '../getProjectInfo/getMetaSchema.mjs';
+export async function writeMetaJson(schemaOutAbsolutePath, projectInfo) {
+    const metaJsonPath = path.join(schemaOutAbsolutePath, META_FILE_NAME + '.json');
+    const metaStr = JSON.stringify(getMetaSchema({
+        config: projectInfo.config,
+    }), null, 2);
+    const existingStr = await fs.readFile(metaJsonPath, 'utf-8').catch(() => null);
+    if (existingStr !== metaStr) {
+        await fs.writeFile(metaJsonPath, metaStr);
+        projectInfo?.log.info(`Meta JSON is written to ${chalkHighlightThing(metaJsonPath)}`);
+    }
+    else {
+        projectInfo?.log.debug(`Meta JSON is up to date at ${chalkHighlightThing(metaJsonPath)}`);
+    }
+}

package/dist/dev/writeOneSegmentSchemaFile.d.mts

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

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

@@ -1,11 +1,11 @@
 import path from 'node:path';
 import fs from 'node:fs/promises';
-import diffSchema from './diffSchema.mjs';
-import getFileSystemEntryType from '../utils/getFileSystemEntryType.mjs';
-export const ROOT_SEGMENT_SCHEMA_NAME = '_root';
-export const JSON_DIR_NAME = 'json';
-export default async function writeOneSchemaFile({ schemaJsonOutAbsolutePath, schema, skipIfExists = false, }) {
-    const segmentPath = path.join(schemaJsonOutAbsolutePath, `${schema.segmentName || ROOT_SEGMENT_SCHEMA_NAME}.json`);
+import { diffSegmentSchema } from './diffSegmentSchema.mjs';
+import { getFileSystemEntryType } from '../utils/getFileSystemEntryType.mjs';
+export const ROOT_SEGMENT_FILE_NAME = 'root';
+export const META_FILE_NAME = '_meta';
+export async function writeOneSegmentSchemaFile({ schemaOutAbsolutePath, segmentSchema, skipIfExists = false, }) {
+    const segmentPath = path.join(schemaOutAbsolutePath, `${segmentSchema.segmentName || ROOT_SEGMENT_FILE_NAME}.json`);
     if (skipIfExists && (await getFileSystemEntryType(segmentPath))) {
         try {
             await fs.stat(segmentPath);
@@ -16,14 +16,17 @@ export default async function writeOneSchemaFile({ schemaJsonOutAbsolutePath, sc
         }
     }
     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

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

package/dist/generate/ensureClient.mjs

@@ -1,30 +1,28 @@
-import fs from 'node:fs/promises';
-import getClientTemplates from './getClientTemplates.mjs';
-import uniq from 'lodash/uniq.js';
-import chalkHighlightThing from '../utils/chalkHighlightThing.mjs';
-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(clientOutDirAbsolutePath, { 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`);
+import { VovkSchemaIdEnum } from 'vovk/internal';
+import { generate } from './generate.mjs';
+import { getMetaSchema } from '../getProjectInfo/getMetaSchema.mjs';
+const getEmptySegmentRecordSchema = (segmentNames) => {
+    const result = {};
+    for (const segmentName of segmentNames) {
+        result[segmentName] = {
+            $schema: VovkSchemaIdEnum.SEGMENT,
+            segmentName,
+            segmentType: 'segment',
+            emitSchema: false,
+            controllers: {},
+        };
     }
-    return { written: !!usedTemplateNames.length, path: clientOutDirAbsolutePath };
+    return result;
+};
+export async function ensureClient(projectInfo, locatedSegments) {
+    return generate({
+        isEnsuringClient: true,
+        projectInfo,
+        fullSchema: {
+            $schema: VovkSchemaIdEnum.SCHEMA,
+            segments: getEmptySegmentRecordSchema(locatedSegments.map(({ segmentName }) => segmentName)),
+            meta: getMetaSchema({ config: projectInfo.config }),
+        },
+        locatedSegments,
+    });
 }

package/dist/generate/generate.d.mts

@@ -0,0 +1,13 @@
+import type { VovkSchema } from 'vovk';
+import type { ProjectInfo } from '../getProjectInfo/index.mjs';
+import type { GenerateOptions } from '../types.mjs';
+import type { Segment } from '../utils/locateSegments.mjs';
+export declare function generate({ isEnsuringClient, isBundle, projectInfo, forceNothingWrittenLog, fullSchema, locatedSegments, cliGenerateOptions, }: {
+    isEnsuringClient?: boolean;
+    isBundle?: boolean;
+    projectInfo: ProjectInfo;
+    forceNothingWrittenLog?: boolean;
+    fullSchema: VovkSchema;
+    locatedSegments: Segment[];
+    cliGenerateOptions?: GenerateOptions;
+}): Promise<void>;