vovk-cli 0.0.1-beta.10 → 0.0.1-beta.12

package/dist/getProjectInfo/getConfig.mjs

@@ -9,7 +9,7 @@ export default async function getConfig({ clientOutDir }) {
         validateOnClient: env.VOVK_VALIDATE_ON_CLIENT ?? userConfig.validateOnClient ?? null,
         validationLibrary: env.VOVK_VALIDATION_LIBRARY ?? userConfig.validationLibrary ?? null,
         fetcher: env.VOVK_FETCHER ?? userConfig.fetcher ?? 'vovk/client/defaultFetcher',
-        metadataOutDir: env.VOVK_METADATA_OUT_DIR ?? userConfig.metadataOutDir ?? './.vovk-schema',
+        schemaOutDir: env.VOVK_SCHEMA_OUT_DIR ?? userConfig.schemaOutDir ?? './.vovk-schema',
         clientOutDir: clientOutDir ?? env.VOVK_CLIENT_OUT_DIR ?? userConfig.clientOutDir ?? './node_modules/.vovk',
         origin: (env.VOVK_ORIGIN ?? userConfig.origin ?? '').replace(/\/$/, ''), // Remove trailing slash
         rootEntry: env.VOVK_ROOT_ENTRY ?? userConfig.rootEntry ?? 'api',

package/dist/getProjectInfo/index.d.mts

@@ -6,11 +6,10 @@ export default function getProjectInfo({ port: givenPort, clientOutDir, }?: {
 }): Promise<{
     cwd: string;
     port: string;
-    vovkPort: string;
     apiEntryPoint: string;
     apiDir: string;
     srcRoot: string;
-    metadataOutImportPath: string;
+    schemaOutImportPath: string;
     fetcherClientImportPath: string;
     config: Required<import("../types.mjs").VovkConfig>;
     log: {

package/dist/getProjectInfo/index.mjs

@@ -3,16 +3,14 @@ import loglevel from 'loglevel';
 import chalk from 'chalk';
 import getConfig from './getConfig.mjs';
 export default async function getProjectInfo({ port: givenPort, clientOutDir, } = {}) {
-    const env = process.env;
     const port = givenPort?.toString() ?? process.env.PORT ?? '3000';
     // Make PORT available to the config file at getConfig
     process.env.PORT = port;
     const cwd = process.cwd();
     const { config, srcRoot } = await getConfig({ clientOutDir });
-    const vovkPort = env.VOVK_PORT || (parseInt(port) + 6969).toString();
     const apiEntryPoint = `${config.origin ?? ''}/${config.rootEntry}`;
     const apiDir = path.join(srcRoot, 'app', config.rootEntry);
-    const metadataOutImportPath = path.relative(config.clientOutDir, config.metadataOutDir);
+    const schemaOutImportPath = path.relative(config.clientOutDir, config.schemaOutDir);
     const fetcherClientImportPath = config.fetcher.startsWith('.')
         ? path.relative(config.clientOutDir, config.fetcher)
         : config.fetcher;
@@ -27,11 +25,10 @@ export default async function getProjectInfo({ port: givenPort, clientOutDir, }
     return {
         cwd,
         port,
-        vovkPort,
         apiEntryPoint,
         apiDir,
         srcRoot,
-        metadataOutImportPath,
+        schemaOutImportPath,
         fetcherClientImportPath,
         config,
         log,

package/dist/index.mjs

@@ -35,7 +35,7 @@ program
         const { result } = concurrently([
             {
                 command: `node ${import.meta.dirname}/server/index.mjs`,
-                name: 'Vovk.ts Metadata Server',
+                name: 'Vovk.ts Schema Server',
                 env: Object.assign({ PORT, __VOVK_START_SERVER_IN_STANDALONE_MODE__: 'true' }, options.clientOut ? { VOVK_CLIENT_OUT_DIR: options.clientOut } : {}),
             },
             {
@@ -67,9 +67,9 @@ program
     const projectInfo = await getProjectInfo({ clientOutDir: options.clientOut });
     const { cwd, config, apiDir } = projectInfo;
     const segments = await locateSegments(apiDir);
-    const metadataOutFullPath = path.join(cwd, config.metadataOutDir);
-    const metadata = (await import(path.join(metadataOutFullPath, 'index.js')));
-    await generateClient(projectInfo, segments, metadata.default);
+    const schemaOutFullPath = path.join(cwd, config.schemaOutDir);
+    const schema = (await import(path.join(schemaOutFullPath, 'index.js')));
+    await generateClient(projectInfo, segments, schema.default);
 });
 program
     .command('help')

package/dist/server/{diffMetadata.d.mts → diffSchema.d.mts}

@@ -1,5 +1,5 @@
-import { VovkMetadata } from 'vovk';
-import { _VovkControllerMetadata, _VovkWorkerMetadata } from 'vovk/types';
+import type { VovkSchema } from 'vovk';
+import { _VovkControllerSchema, _VovkWorkerSchema } from 'vovk/types';
 interface HandlersDiff {
     nameOfClass: string;
     added: string[];
@@ -15,8 +15,8 @@ export interface DiffResult {
     workers: WorkersOrControllersDiff;
     controllers: WorkersOrControllersDiff;
 }
-export declare function diffHandlers<T extends _VovkWorkerMetadata['_handlers'] | _VovkControllerMetadata['_handlers']>(oldHandlers: T, newHandlers: T, nameOfClass: string): HandlersDiff;
-export declare function diffWorkersOrControllers<T extends VovkMetadata['controllers'] | VovkMetadata['workers']>(oldItems: T, newItems: T): WorkersOrControllersDiff;
+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:
 {
@@ -39,5 +39,5 @@ example output:
   }
 }
 */
-export default function diffMetadata(oldJson: VovkMetadata, newJson: VovkMetadata): DiffResult;
+export default function diffSchema(oldJson: VovkSchema, newJson: VovkSchema): DiffResult;
 export {};

package/dist/server/{diffMetadata.mjs → diffSchema.mjs}

@@ -62,7 +62,7 @@ example output:
   }
 }
 */
-export default function diffMetadata(oldJson, newJson) {
+export default function diffSchema(oldJson, newJson) {
     const workersDiff = diffWorkersOrControllers(oldJson.workers ?? {}, newJson.workers ?? {});
     const controllersDiff = diffWorkersOrControllers(oldJson.controllers ?? {}, newJson.controllers ?? {});
     return {

package/dist/server/ensureSchemaFiles.d.mts

@@ -0,0 +1,3 @@
+import { ProjectInfo } from '../getProjectInfo/index.mjs';
+export default function ensureSchemaFiles(schemaOutFullPath: string, segmentNames: string[], projectInfo: ProjectInfo | null): Promise<void>;
+export declare const debouncedEnsureSchemaFiles: import("lodash").DebouncedFunc<typeof ensureSchemaFiles>;

package/dist/server/{ensureMetadataFiles.mjs → ensureSchemaFiles.mjs}

@@ -1,8 +1,8 @@
 import fs from 'fs/promises';
 import path from 'path';
 import debounce from 'lodash/debounce.js';
-import writeOneMetadataFile, { ROOT_SEGMENT_SCHEMA_NAME } from './writeOneMetadataFile.mjs';
-export default async function ensureMetadataFiles(metadataOutFullPath, segmentNames, projectInfo) {
+import writeOneSchemaFile, { ROOT_SEGMENT_SCHEMA_NAME } from './writeOneSchemaFile.mjs';
+export default async function ensureSchemaFiles(schemaOutFullPath, segmentNames, projectInfo) {
     const now = Date.now();
     let hasChanged = false;
     // Create index.js file
@@ -11,18 +11,18 @@ export default async function ensureMetadataFiles(metadataOutFullPath, segmentNa
         return `module.exports['${segmentName}'] = require('./${segmentName || ROOT_SEGMENT_SCHEMA_NAME}.json');`;
     })
         .join('\n');
-    const dTsContent = `import type { VovkMetadata } from 'vovk';
-declare const segmentMetadata: Record<string, VovkMetadata>;
-export default segmentMetadata;`;
-    await fs.mkdir(metadataOutFullPath, { recursive: true });
-    await fs.writeFile(path.join(metadataOutFullPath, 'index.js'), indexContent);
-    await fs.writeFile(path.join(metadataOutFullPath, 'index.d.ts'), dTsContent);
+    const dTsContent = `import type { VovkSchema } from 'vovk';
+declare const segmentSchema: Record<string, VovkSchema>;
+export default segmentSchema;`;
+    await fs.mkdir(schemaOutFullPath, { recursive: true });
+    await fs.writeFile(path.join(schemaOutFullPath, 'index.js'), indexContent);
+    await fs.writeFile(path.join(schemaOutFullPath, 'index.d.ts'), dTsContent);
     // Create JSON files (if not exist) with name [segmentName].json (where segmentName can include /, which means the folder structure can be nested) : {} (empty object)
     await Promise.all(segmentNames.map(async (segmentName) => {
-        const { isCreated } = await writeOneMetadataFile({
-            metadataOutFullPath,
-            metadata: {
-                emitMetadata: false,
+        const { isCreated } = await writeOneSchemaFile({
+            schemaOutFullPath,
+            schema: {
+                emitSchema: false,
                 segmentName,
                 controllers: {},
                 workers: {},
@@ -30,7 +30,7 @@ export default segmentMetadata;`;
             skipIfExists: true,
         });
         if (isCreated) {
-            projectInfo?.log.debug(`Created empty metadata file for segment "${segmentName}"`);
+            projectInfo?.log.debug(`Created empty schema file for segment "${segmentName}"`);
             hasChanged = true;
         }
     }));
@@ -46,25 +46,25 @@ export default segmentMetadata;`;
                 const remainingEntries = await fs.readdir(fullPath);
                 if (remainingEntries.length === 0) {
                     await fs.rmdir(fullPath);
-                    projectInfo?.log.debug(`Deleted unnecessary metadata directory "${fullPath}"`);
+                    projectInfo?.log.debug(`Deleted unnecessary schema directory "${fullPath}"`);
                     hasChanged = true;
                 }
             }
             else if (entry.isFile() && entry.name.endsWith('.json')) {
-                const relativePath = path.relative(metadataOutFullPath, fullPath);
+                const relativePath = path.relative(schemaOutFullPath, fullPath);
                 const segmentName = relativePath.replace(/\\/g, '/').slice(0, -5); // Remove '.json' extension
                 if (!segmentNames.includes(segmentName) &&
                     !segmentNames.includes(segmentName.replace(ROOT_SEGMENT_SCHEMA_NAME, ''))) {
                     await fs.unlink(fullPath);
-                    projectInfo?.log.debug(`Deleted unnecessary metadata file for segment "${segmentName}"`);
+                    projectInfo?.log.debug(`Deleted unnecessary schema file for segment "${segmentName}"`);
                     hasChanged = true;
                 }
             }
         }));
     }
     // Start the recursive deletion from the root directory
-    await deleteUnnecessaryJsonFiles(metadataOutFullPath);
+    await deleteUnnecessaryJsonFiles(schemaOutFullPath);
     if (hasChanged)
-        projectInfo?.log.info(`Metadata files updated in ${Date.now() - now}ms`);
+        projectInfo?.log.info(`Schema files updated in ${Date.now() - now}ms`);
 }
-export const debouncedEnsureMetadataFiles = debounce(ensureMetadataFiles, 1000);
+export const debouncedEnsureSchemaFiles = debounce(ensureSchemaFiles, 1000);

package/dist/server/generateClient.d.mts

@@ -1,7 +1,7 @@
 import type { ProjectInfo } from '../getProjectInfo/index.mjs';
 import type { Segment } from '../locateSegments.mjs';
-import { VovkMetadata } from 'vovk';
-export default function generateClient(projectInfo: ProjectInfo, segments: Segment[], segmentsMetadata: Record<string, VovkMetadata>): Promise<{
+import type { VovkSchema } from 'vovk';
+export default function generateClient(projectInfo: ProjectInfo, segments: Segment[], segmentsSchema: Record<string, VovkSchema>): Promise<{
     written: boolean;
     path: string;
 }>;

package/dist/server/generateClient.mjs

@@ -1,6 +1,6 @@
 import path from 'path';
 import fs from 'fs/promises';
-export default async function generateClient(projectInfo, segments, segmentsMetadata) {
+export default async function generateClient(projectInfo, segments, segmentsSchema) {
     const now = Date.now();
     const clientoOutDirFullPath = path.join(projectInfo.cwd, projectInfo.config.clientOutDir);
     const validateFullPath = projectInfo.config.validateOnClient?.startsWith('.')
@@ -19,7 +19,7 @@ import type fetcher from '${projectInfo.fetcherClientImportPath}';
 const { clientizeController } = require('vovk/client');
 const { promisifyWorker } = require('vovk/worker');
 const { default: fetcher } = require('${projectInfo.fetcherClientImportPath}');
-const metadata = require('${projectInfo.metadataOutImportPath}');
+const schema = require('${projectInfo.schemaOutImportPath}');
 `;
     let ts = `// auto-generated
 /* eslint-disable */
@@ -27,16 +27,16 @@ import { clientizeController } from 'vovk/client';
 import { promisifyWorker } from 'vovk/worker';
 import type { VovkClientFetcher } from 'vovk/client';
 import fetcher from '${projectInfo.fetcherClientImportPath}';
-import metadata from '${projectInfo.metadataOutImportPath}';
+import schema from '${projectInfo.schemaOutImportPath}';
 
 `;
     for (let i = 0; i < segments.length; i++) {
         const { routeFilePath, segmentName } = segments[i];
-        const metadata = segmentsMetadata[segmentName];
-        if (!metadata) {
-            throw new Error(`Unable to generate client. No metadata found for segment ${segmentName}`);
+        const schema = segmentsSchema[segmentName];
+        if (!schema) {
+            throw new Error(`Unable to generate client. No schema found for segment ${segmentName}`);
         }
-        if (!metadata.emitMetadata)
+        if (!schema.emitSchema)
             continue;
         const importRouteFilePath = path.relative(projectInfo.config.clientOutDir, routeFilePath);
         dts += `import type { Controllers as Controllers${i}, Workers as Workers${i} } from "${importRouteFilePath}";\n`;
@@ -56,21 +56,21 @@ const prefix = '${projectInfo.apiEntryPoint}';
 `;
     for (let i = 0; i < segments.length; i++) {
         const { segmentName } = segments[i];
-        const metadata = segmentsMetadata[segmentName];
-        if (!metadata) {
-            throw new Error(`Unable to generate client. No metadata found for segment ${segmentName}`);
+        const schema = segmentsSchema[segmentName];
+        if (!schema) {
+            throw new Error(`Unable to generate client. No schema found for segment ${segmentName}`);
         }
-        if (!metadata.emitMetadata)
+        if (!schema.emitSchema)
             continue;
-        for (const key of Object.keys(metadata.controllers)) {
+        for (const key of Object.keys(schema.controllers)) {
             dts += `export const ${key}: ReturnType<typeof clientizeController<Controllers${i}["${key}"], Options>>;\n`;
-            js += `exports.${key} = clientizeController(metadata['${segmentName}'].controllers.${key}, '${segmentName}', { fetcher, validateOnClient, defaultOptions: { prefix } });\n`;
-            ts += `export const ${key} = clientizeController<Controllers${i}["${key}"], Options>(metadata['${segmentName}'].controllers.${key}, '${segmentName}', { fetcher, validateOnClient, defaultOptions: { prefix } });\n`;
+            js += `exports.${key} = clientizeController(schema['${segmentName}'].controllers.${key}, '${segmentName}', { fetcher, validateOnClient, defaultOptions: { prefix } });\n`;
+            ts += `export const ${key} = clientizeController<Controllers${i}["${key}"], Options>(schema['${segmentName}'].controllers.${key}, '${segmentName}', { fetcher, validateOnClient, defaultOptions: { prefix } });\n`;
         }
-        for (const key of Object.keys(metadata.workers)) {
+        for (const key of Object.keys(schema.workers)) {
             dts += `export const ${key}: ReturnType<typeof promisifyWorker<Workers${i}["${key}"]>>;\n`;
-            js += `exports.${key} = promisifyWorker(null, metadata['${segmentName}'].workers.${key});\n`;
-            ts += `export const ${key} = promisifyWorker<Workers${i}["${key}"]>(null, metadata['${segmentName}'].workers.${key});\n`;
+            js += `exports.${key} = promisifyWorker(null, schema['${segmentName}'].workers.${key});\n`;
+            ts += `export const ${key} = promisifyWorker<Workers${i}["${key}"]>(null, schema['${segmentName}'].workers.${key});\n`;
         }
     }
     const localJsPath = path.join(clientoOutDirFullPath, 'client.js');

package/dist/server/index.mjs

@@ -2,8 +2,8 @@ import * as chokidar from 'chokidar';
 import fs from 'fs/promises';
 import getProjectInfo from '../getProjectInfo/index.mjs';
 import path from 'path';
-import { debouncedEnsureMetadataFiles } from './ensureMetadataFiles.mjs';
-import writeOneMetadataFile from './writeOneMetadataFile.mjs';
+import { debouncedEnsureSchemaFiles } from './ensureSchemaFiles.mjs';
+import writeOneSchemaFile from './writeOneSchemaFile.mjs';
 import logDiffResult from './logDiffResult.mjs';
 import generateClient from './generateClient.mjs';
 import locateSegments from '../locateSegments.mjs';
@@ -13,14 +13,14 @@ import isEmpty from 'lodash/isEmpty.js';
 export class VovkCLIServer {
     #projectInfo;
     #segments = [];
-    #metadata = {};
+    #schemas = {};
     #isWatching = false;
     #modulesWatcher = null;
     #segmentWatcher = null;
     #watchSegments = () => {
         const segmentReg = /\/?\[\[\.\.\.[a-zA-Z-_]+\]\]\/route.ts$/;
         const { cwd, log, config, apiDir } = this.#projectInfo;
-        const metadataOutFullPath = path.join(cwd, config.metadataOutDir);
+        const schemaOutFullPath = path.join(cwd, config.schemaOutDir);
         const apiDirFullPath = path.join(cwd, apiDir);
         const getSegmentName = (filePath) => path.relative(apiDirFullPath, filePath).replace(segmentReg, '');
         log.debug(`Watching segments in ${apiDirFullPath}`);
@@ -38,7 +38,7 @@ export class VovkCLIServer {
                     : [...this.#segments, { routeFilePath: filePath, segmentName }];
                 log.info(`Segment "${segmentName}" has been added`);
                 log.debug(`Full list of segments: ${this.#segments.map((s) => s.segmentName).join(', ')}`);
-                void debouncedEnsureMetadataFiles(metadataOutFullPath, this.#segments.map((s) => s.segmentName), this.#projectInfo // TODO refactor
+                void debouncedEnsureSchemaFiles(schemaOutFullPath, this.#segments.map((s) => s.segmentName), this.#projectInfo // TODO refactor
                 );
             }
         })
@@ -71,7 +71,7 @@ export class VovkCLIServer {
                 this.#segments = this.#segments.filter((s) => s.segmentName !== segmentName);
                 log.info(`Segment "${segmentName}" has been removed`);
                 log.debug(`Full list of segments: ${this.#segments.map((s) => s.segmentName).join(', ')}`);
-                void debouncedEnsureMetadataFiles(metadataOutFullPath, this.#segments.map((s) => s.segmentName), this.#projectInfo // TODO refactor
+                void debouncedEnsureSchemaFiles(schemaOutFullPath, this.#segments.map((s) => s.segmentName), this.#projectInfo // TODO refactor
                 );
             }
         })
@@ -169,10 +169,10 @@ export class VovkCLIServer {
         const importRegex = /import\s*{[^}]*\b(initVovk|get|post|put|del|head|options|worker)\b[^}]*}\s*from\s*['"]vovk['"]/;
         if (importRegex.test(code) && namesOfClasses.length) {
             const affectedSegments = this.#segments.filter((s) => {
-                const metadata = this.#metadata[s.segmentName];
-                if (!metadata)
+                const schema = this.#schemas[s.segmentName];
+                if (!schema)
                     return false;
-                return namesOfClasses.some((name) => metadata.controllers[name] || metadata.workers[name]);
+                return namesOfClasses.some((name) => schema.controllers[name] || schema.workers[name]);
             });
             if (affectedSegments.length) {
                 log.debug(`A file with controller or worker ${namesOfClasses.join(', ')} have been modified at path "${filePath}". Segment(s) affected: ${affectedSegments.map((s) => s.segmentName).join(', ')}`);
@@ -191,53 +191,53 @@ export class VovkCLIServer {
             log.warn(`Ping to segment "${segmentName}" failed with status code ${resp.status}. Expected 200.`);
             return;
         }
-        let metadata = null;
+        let schema = null;
         try {
-            ({ metadata } = (await resp.json()));
+            ({ schema } = (await resp.json()));
         }
         catch (error) {
-            log.error(`Error parsing metadata for segment "${segmentName}": ${error.message}`);
+            log.error(`Error parsing schema for segment "${segmentName}": ${error.message}`);
         }
-        await this.#handleMetadata(metadata);
+        await this.#handleSchema(schema);
     }, 500);
-    async #handleMetadata(metadata) {
+    async #handleSchema(schema) {
         const { log, config, cwd } = this.#projectInfo;
-        log.debug(`Handling received metadata`);
-        if (!metadata) {
-            log.warn('Segment metadata is null');
+        log.debug(`Handling received schema`);
+        if (!schema) {
+            log.warn('Segment schema is null');
             return;
         }
-        const metadataOutFullPath = path.join(cwd, config.metadataOutDir);
-        const segment = this.#segments.find((s) => s.segmentName === metadata.segmentName);
+        const schemaOutFullPath = path.join(cwd, config.schemaOutDir);
+        const segment = this.#segments.find((s) => s.segmentName === schema.segmentName);
         if (!segment) {
-            log.warn(`Segment "${metadata.segmentName}" not found`);
+            log.warn(`Segment "${schema.segmentName}" not found`);
             return;
         }
-        this.#metadata[metadata.segmentName] = metadata;
-        if (metadata.emitMetadata) {
+        this.#schemas[schema.segmentName] = schema;
+        if (schema.emitSchema) {
             const now = Date.now();
-            const { diffResult } = await writeOneMetadataFile({
-                metadataOutFullPath,
-                metadata,
+            const { diffResult } = await writeOneSchemaFile({
+                schemaOutFullPath,
+                schema,
                 skipIfExists: false,
             });
             const timeTook = Date.now() - now;
             if (diffResult) {
                 logDiffResult(segment.segmentName, diffResult, this.#projectInfo);
-                log.info(`Metadata for segment "${metadata.segmentName}" has been updated in ${timeTook}ms`);
+                log.info(`Schema for segment "${schema.segmentName}" has been updated in ${timeTook}ms`);
             }
         }
-        else if (metadata && (!isEmpty(metadata.controllers) || !isEmpty(metadata.workers))) {
-            log.error(`Non-empty metadata provided for segment "${metadata.segmentName}" but emitMetadata is false`);
+        else if (schema && (!isEmpty(schema.controllers) || !isEmpty(schema.workers))) {
+            log.error(`Non-empty schema provided for segment "${schema.segmentName}" but emitSchema is false`);
         }
-        if (this.#segments.every((s) => this.#metadata[s.segmentName])) {
-            log.debug(`All segments with emitMetadata=true have metadata.`);
-            await generateClient(this.#projectInfo, this.#segments, this.#metadata);
+        if (this.#segments.every((s) => this.#schemas[s.segmentName])) {
+            log.debug(`All segments with emitSchema=true have schema.`);
+            await generateClient(this.#projectInfo, this.#segments, this.#schemas);
         }
     }
     async startServer({ clientOutDir } = {}) {
         this.#projectInfo = await getProjectInfo({ clientOutDir });
-        const { vovkPort, log, config, cwd, apiDir } = this.#projectInfo;
+        const { log, config, cwd, apiDir } = this.#projectInfo;
         process.on('uncaughtException', (err) => {
             log.error(`Uncaught Exception: ${err.message}`);
         });
@@ -245,14 +245,10 @@ export class VovkCLIServer {
             log.error(`Unhandled Rejection: ${String(reason)}`);
         });
         const apiDirFullPath = path.join(cwd, apiDir);
-        const metadataOutFullPath = path.join(cwd, config.metadataOutDir);
+        const schemaOutFullPath = path.join(cwd, config.schemaOutDir);
         this.#segments = await locateSegments(apiDirFullPath);
-        if (!vovkPort) {
-            log.error('No port provided for Vovk Server. Exiting...');
-            return;
-        }
-        await debouncedEnsureMetadataFiles(metadataOutFullPath, this.#segments.map((s) => s.segmentName), this.#projectInfo);
-        // Ping every segment in 3 seconds in order to update metadata and start watching
+        await debouncedEnsureSchemaFiles(schemaOutFullPath, this.#segments.map((s) => s.segmentName), this.#projectInfo);
+        // Ping every segment in 3 seconds in order to update schema and start watching
         setTimeout(() => {
             for (const { segmentName } of this.#segments) {
                 void this.#ping(segmentName);

package/dist/server/isMetadataEmpty.d.mts

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

package/dist/server/isMetadataEmpty.mjs

@@ -1,4 +1,4 @@
 import isEmpty from 'lodash/isEmpty.js';
-export default function isMetadataEmpty(metadata) {
-    return isEmpty(metadata.controllers) && isEmpty(metadata.workers);
+export default function isSchemaEmpty(schema) {
+    return isEmpty(schema.controllers) && isEmpty(schema.workers);
 }

package/dist/server/logDiffResult.d.mts

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

package/dist/server/writeOneSchemaFile.d.mts

@@ -0,0 +1,11 @@
+import type { VovkSchema } from 'vovk';
+import { DiffResult } from './diffSchema.mjs';
+export declare const ROOT_SEGMENT_SCHEMA_NAME = "_root";
+export default function writeOneSchemaFile({ schemaOutFullPath, schema, skipIfExists, }: {
+    schemaOutFullPath: string;
+    schema: VovkSchema;
+    skipIfExists?: boolean;
+}): Promise<{
+    isCreated: boolean;
+    diffResult: DiffResult | null;
+}>;

package/dist/server/{writeOneMetadataFile.mjs → writeOneSchemaFile.mjs}

@@ -1,9 +1,9 @@
 import path from 'path';
 import fs from 'fs/promises';
-import diffMetadata from './diffMetadata.mjs';
+import diffSchema from './diffSchema.mjs';
 export const ROOT_SEGMENT_SCHEMA_NAME = '_root';
-export default async function writeOneMetadataFile({ metadataOutFullPath, metadata, skipIfExists = false, }) {
-    const segmentPath = path.join(metadataOutFullPath, `${metadata.segmentName || ROOT_SEGMENT_SCHEMA_NAME}.json`);
+export default async function writeOneSchemaFile({ schemaOutFullPath, schema, skipIfExists = false, }) {
+    const segmentPath = path.join(schemaOutFullPath, `${schema.segmentName || ROOT_SEGMENT_SCHEMA_NAME}.json`);
     if (skipIfExists) {
         try {
             await fs.stat(segmentPath);
@@ -14,14 +14,14 @@ export default async function writeOneMetadataFile({ metadataOutFullPath, metada
         }
     }
     await fs.mkdir(path.dirname(segmentPath), { recursive: true });
-    const metadataStr = JSON.stringify(metadata, null, 2);
+    const schemaStr = JSON.stringify(schema, null, 2);
     const existing = await fs.readFile(segmentPath, 'utf-8').catch(() => null);
-    if (existing === metadataStr) {
+    if (existing === schemaStr) {
         return { isCreated: false, diffResult: null };
     }
-    await fs.writeFile(segmentPath, metadataStr);
+    await fs.writeFile(segmentPath, schemaStr);
     if (existing) {
-        return { isCreated: false, diffResult: diffMetadata(JSON.parse(existing), metadata) };
+        return { isCreated: false, diffResult: diffSchema(JSON.parse(existing), schema) };
     }
     return { isCreated: true, diffResult: null };
 }

package/dist/types.d.mts

@@ -3,10 +3,9 @@ export type KnownAny = any;
 export type VovkEnv = {
     PORT?: string;
     VOVK_CLIENT_OUT_DIR?: string;
-    VOVK_METADATA_OUT_DIR?: string;
+    VOVK_SCHEMA_OUT_DIR?: string;
     VOVK_FETCHER?: string;
     VOVK_VALIDATE_ON_CLIENT?: string;
-    VOVK_PORT?: string;
     VOVK_MODULES_DIR?: string;
     VOVK_VALIDATION_LIBRARY?: string;
     VOVK_ORIGIN?: string;
@@ -18,7 +17,7 @@ export type VovkEnv = {
 };
 export type VovkConfig = {
     clientOutDir?: string;
-    metadataOutDir?: string;
+    schemaOutDir?: string;
     fetcher?: string;
     validateOnClient?: string | null;
     modulesDir?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vovk-cli",
-  "version": "0.0.1-beta.10",
+  "version": "0.0.1-beta.12",
   "bin": {
     "vovk": "./dist/index.mjs"
   },
@@ -30,7 +30,7 @@
   },
   "homepage": "https://vovk.dev",
   "peerDependencies": {
-    "vovk": "^3.0.0-beta.18"
+    "vovk": "^3.0.0-beta.22"
   },
   "dependencies": {
     "@inquirer/prompts": "^5.3.8",

package/dist/server/ensureMetadataFiles.d.mts

@@ -1,3 +0,0 @@
-import { ProjectInfo } from '../getProjectInfo/index.mjs';
-export default function ensureMetadataFiles(metadataOutFullPath: string, segmentNames: string[], projectInfo: ProjectInfo | null): Promise<void>;
-export declare const debouncedEnsureMetadataFiles: import("lodash").DebouncedFunc<typeof ensureMetadataFiles>;

package/dist/server/writeOneMetadataFile.d.mts

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