vovk-cli 0.0.1-draft.103 → 0.0.1-draft.105

package/client-templates/main/main.cjs.ejs

@@ -1,14 +1,13 @@
 <%- `// auto-generated ${new Date().toISOString()}\n/* eslint-disable */` %>
 const { default: fetcher } = require('<%= t.imports.fetcher %>');
 const { default: createRPC } = require('<%= t.imports.createRPC %>');
-const schema = require('<%= t.imports.schema %>');
+const fullSchema = require('<%= t.imports.fullSchema %>');
 const { default: validateOnClient = null } = <%- t.imports.validateOnClient ? `require('${t.imports.validateOnClient}')` : '{}'%>;
 const apiRoot = '<%= t.apiRoot %>';
-<% t.segments.forEach((segment) => { 
-  Object.keys(t.fullSchema[segment.segmentName].controllers).forEach((key) => { %>
-exports.<%= key %> = createRPC(
-  schema['<%= segment.segmentName %>'].controllers.<%= key %>, 
-  '<%= segment.segmentName %>', 
+<% Object.values(t.fullSchema.segments).forEach((segment) => { 
+  Object.keys(segment.controllers).forEach((controllerName) => { %>
+exports.<%= controllerName %> = createRPC(
+  fullSchema, '<%= segment.segmentName %>', '<%= controllerName %>',
   { fetcher, validateOnClient, defaultOptions: { apiRoot } }
 );
   <% })

package/client-templates/main/main.d.cts.ejs

@@ -3,12 +3,12 @@
 import type { VovkClientFetcher } from 'vovk';
 import type fetcher from '<%= t.imports.fetcher %>';
 import type createRPC from '<%= t.imports.createRPC %>';
-<% t.segments.forEach((segment, i) => { if(Object.keys(t.fullSchema[segment.segmentName].controllers).length) { %>
+<% Object.values(t.fullSchema.segments).forEach((segment, i) => { if(Object.keys(segment.controllers).length) { %>
 import type { Controllers as Controllers<%= i %> } from "<%= segment.segmentImportPath %>";
 <% }}) %>
 type Options = typeof fetcher extends VovkClientFetcher<infer U> ? U : never;
-<% t.segments.forEach((segment, i) => {
-  Object.keys(t.fullSchema[segment.segmentName].controllers).forEach((key) => { %>
-export const <%= key %>: ReturnType<typeof createRPC<Controllers<%= i %>["<%= key %>"], Options>>;
+<% Object.values(t.fullSchema.segments).forEach((segment, i) => {
+  Object.keys(segment.controllers).forEach((controllerName) => { %>
+export const <%= controllerName %>: ReturnType<typeof createRPC<Controllers<%= i %>["<%= controllerName %>"], Options>>;
   <% }) 
 }) %>

package/client-templates/module/module.d.mts.ejs

@@ -3,12 +3,12 @@
 import type { VovkClientFetcher } from 'vovk';
 import type fetcher from '<%= t.imports.module.fetcher %>';
 import type createRPC from '<%= t.imports.module.createRPC %>';
-<% t.segments.forEach((segment, i) => { if(Object.keys(t.fullSchema[segment.segmentName].controllers).length) { %>
+<% Object.values(t.fullSchema.segments).forEach((segment, i) => { if(Object.keys(segment.controllers).length) { %>
 import type { Controllers as Controllers<%= i %> } from "<%= segment.segmentImportPath %>";
 <% }}) %>
 type Options = typeof fetcher extends VovkClientFetcher<infer U> ? U : never;
-<% t.segments.forEach((segment, i) => { 
-  Object.keys(t.fullSchema[segment.segmentName].controllers).forEach((key) => { %>
-export const <%= key %>: ReturnType<typeof createRPC<Controllers<%= i %>["<%= key %>"], Options>>;
+<% Object.values(t.fullSchema.segments).forEach((segment, i) => { 
+  Object.keys(segment.controllers).forEach((controllerName) => { %>
+export const <%= controllerName %>: ReturnType<typeof createRPC<Controllers<%= i %>["<%= controllerName %>"], Options>>;
   <% }) 
 }) %>

package/client-templates/module/module.mjs.ejs

@@ -1,7 +1,7 @@
 <%- `// auto-generated ${new Date().toISOString()}\n/* eslint-disable */` %>
 import fetcherImport from '<%= t.imports.module.fetcher %>';
 import createRPCImport from '<%= t.imports.module.createRPC %>';
-import schema from '<%= t.imports.module.schema %>';
+import fullSchema from '<%= t.imports.module.fullSchema %>';
 <% if (t.imports.module.validateOnClient) { %>
 import validateOnClientImport from '<%= t.imports.module.validateOnClient %>';
 const validateOnClient = validateOnClientImport.default || validateOnClientImport;
@@ -11,11 +11,10 @@ const validateOnClient = undefined;
 const apiRoot = '<%= t.apiRoot %>';
 const fetcher = fetcherImport.default || fetcherImport;
 const createRPC = createRPCImport.default || createRPCImport;
-<% t.segments.forEach((segment, i) => {
-  Object.keys(t.fullSchema[segment.segmentName].controllers).forEach((key) => { %>
-export const <%= key %> = createRPC(
-  schema['<%= segment.segmentName %>'].controllers.<%= key %>, 
-  '<%= segment.segmentName %>', 
+<% Object.values(t.fullSchema.segments).forEach((segment, i) => {
+  Object.keys(segment.controllers).forEach((controllerName) => { %>
+export const <%= controllerName %> = createRPC(
+  fullSchema, '<%= segment.segmentName %>', '<%= controllerName %>',
   { fetcher, validateOnClient, defaultOptions: { apiRoot } }
 );
 <% 

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

@@ -2,8 +2,8 @@
 import type { VovkClientFetcher } from 'vovk';
 import fetcher from '<%= t.imports.fetcher %>';
 import createRPC from '<%= t.imports.createRPC %>';
-import schema from '<%= t.imports.schema %>';
-<% t.segments.forEach((segment, i) => { if(Object.keys(t.fullSchema[segment.segmentName].controllers).length) { %>
+import fullSchema from '<%= t.imports.fullSchema %>';
+<% Object.values(t.fullSchema.segments).forEach((segment, i) => { if(Object.keys(segment.controllers).length) { %>
 import type { Controllers as Controllers<%= i %> } from "<%= segment.segmentImportPath %>";
 <% }}) %>
 <% if (t.imports.validateOnClient) { %>
@@ -13,12 +13,10 @@ const validateOnClient = undefined;
 <% } %>
 type Options = typeof fetcher extends VovkClientFetcher<infer U> ? U : never;
 const apiRoot = '<%= t.apiRoot %>';
-
-<% t.segments.forEach((segment, i) => { %>
-  <% Object.keys(t.fullSchema[segment.segmentName].controllers).forEach((key) => { %>
-export const <%= key %> = createRPC<Controllers<%= i %>["<%= key %>"], Options>(
-  schema['<%= segment.segmentName %>'].controllers.<%= key %>, 
-  '<%= segment.segmentName %>', 
+<% Object.values(t.fullSchema.segments).forEach((segment, i) => { %>
+  <% Object.keys(segment.controllers).forEach((controllerName) => { %>
+export const <%= controllerName %> = createRPC<Controllers<%= i %>["<%= controllerName %>"], Options>(
+  fullSchema, '<%= segment.segmentName %>', '<%= controllerName %>',
   { fetcher, validateOnClient, defaultOptions: { apiRoot } }
 );
   <% }) %>

package/dist/dev/{diffSchema.d.mts → diffSegmentSchema.d.mts}

@@ -1,4 +1,4 @@
-import type { VovkControllerSchema, VovkSchema } from 'vovk';
+import type { VovkControllerSchema, VovkSegmentSchema } from 'vovk';
 interface HandlersDiff {
     nameOfClass: string;
     added: string[];
@@ -14,7 +14,7 @@ export interface DiffResult {
     controllers: ControllersDiff;
 }
 export declare function diffHandlers<T extends VovkControllerSchema['handlers']>(oldHandlers: T, newHandlers: T, nameOfClass: string): HandlersDiff;
-export declare function diffControllers<T extends VovkSchema['controllers']>(oldItems: T, newItems: T): ControllersDiff;
+export declare function diffControllers<T extends VovkSegmentSchema['controllers']>(oldItems: T, newItems: T): ControllersDiff;
 /**
 example output:
 {
@@ -32,5 +32,5 @@ example output:
   }
 }
 */
-export default function diffSchema(oldJson: VovkSchema, newJson: VovkSchema): DiffResult;
+export default function diffSegmentSchema(oldJson: VovkSegmentSchema, newJson: VovkSegmentSchema): DiffResult;
 export {};

package/dist/dev/{diffSchema.mjs → diffSegmentSchema.mjs}

@@ -57,7 +57,7 @@ example output:
   }
 }
 */
-export default function diffSchema(oldJson, newJson) {
+export default function diffSegmentSchema(oldJson, newJson) {
     return {
         controllers: diffControllers(oldJson.controllers ?? {}, newJson.controllers ?? {}),
     };

package/dist/dev/ensureSchemaFiles.mjs

@@ -1,32 +1,43 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import debounce from 'lodash/debounce.js';
-import writeOneSchemaFile, { JSON_DIR_NAME, ROOT_SEGMENT_SCHEMA_NAME } from './writeOneSchemaFile.mjs';
+import writeOneSchemaFile, { SEGMENTS_SCHEMA_DIR_NAME, ROOT_SEGMENT_SCHEMA_NAME, } from './writeOneSegmentSchemaFile.mjs';
 import formatLoggedSegmentName from '../utils/formatLoggedSegmentName.mjs';
+import writeConfigJson from './writeConfigJson.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;
-    const schemaJsonOutAbsolutePath = path.join(schemaOutAbsolutePath, JSON_DIR_NAME);
+    const schemaJsonOutAbsolutePath = path.join(schemaOutAbsolutePath, SEGMENTS_SCHEMA_DIR_NAME);
     const jsContent = `// auto-generated ${new Date().toISOString()}
+module.exports.config = require('./config.json');
+module.exports.segments = {
 ${segmentNames
         .map((segmentName) => {
-        return `module.exports['${segmentName}'] = require('./${JSON_DIR_NAME}/${segmentName || ROOT_SEGMENT_SCHEMA_NAME}.json');`;
+        return `  '${segmentName}': require('./${SEGMENTS_SCHEMA_DIR_NAME}/${segmentName || ROOT_SEGMENT_SCHEMA_NAME}.json'),`;
     })
-        .join('\n')}`;
+        .join('\n')}
+}`;
     const dTsContent = `// auto-generated ${new Date().toISOString()}
-import type { VovkSchema } from 'vovk';
+import type { VovkSegmentSchema, VovkStrictConfig } from 'vovk';
 declare const fullSchema: {
-${segmentNames.map((segmentName) => `  '${segmentName}': VovkSchema;`).join('\n')}
+  config: Partial<VovkStrictConfig>;
+  segments: {
+${segmentNames.map((segmentName) => `  '${segmentName}': VovkSegmentSchema;`).join('\n')}
+  };
 };
 export default fullSchema;`;
     const tsContent = `// auto-generated ${new Date().toISOString()}
-import type { VovkSchema } from 'vovk';
-${segmentNames.map((segmentName, i) => `import segment${i} from './${JSON_DIR_NAME}/${segmentName || ROOT_SEGMENT_SCHEMA_NAME}.json';`).join('\n')}
+import type { VovkSegmentSchema, VovkStrictConfig } from 'vovk';
+import config from './config.json';
+${segmentNames.map((segmentName, i) => `import segment${i} from './${SEGMENTS_SCHEMA_DIR_NAME}/${segmentName || ROOT_SEGMENT_SCHEMA_NAME}.json';`).join('\n')}
 const fullSchema = {
-${segmentNames.map((segmentName, i) => `  '${segmentName}': segment${i} as unknown as VovkSchema,`).join('\n')}
+  config: config as unknown as Partial<VovkStrictConfig>,
+  segments: {
+${segmentNames.map((segmentName, i) => `  '${segmentName}': segment${i} as unknown as VovkSegmentSchema,`).join('\n')}
+  }
 };
 export default fullSchema;`;
     const jsAbsolutePath = path.join(schemaOutAbsolutePath, 'main.cjs');
@@ -36,11 +47,12 @@ export default fullSchema;`;
     const existingDTs = await fs.readFile(dTsAbsolutePath, 'utf-8').catch(() => null);
     const existingTs = await fs.readFile(tsAbsolutePath, 'utf-8').catch(() => null);
     await fs.mkdir(schemaJsonOutAbsolutePath, { recursive: true });
+    await writeConfigJson(schemaOutAbsolutePath, projectInfo);
     // Create JSON files (if not exist) with name [segmentName].json (where segmentName can include /, which means the folder structure can be nested)
     await Promise.all(segmentNames.map(async (segmentName) => {
         const { isCreated } = await writeOneSchemaFile({
             schemaOutAbsolutePath,
-            schema: {
+            segmentSchema: {
                 emitSchema: false,
                 segmentName,
                 controllers: {},

package/dist/dev/index.mjs

@@ -7,7 +7,7 @@ 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 ensureClient from '../generate/ensureClient.mjs';
 import getProjectInfo from '../getProjectInfo/index.mjs';
@@ -15,11 +15,15 @@ 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 isSegmentSchemaEmpty from './isSegmentSchemaEmpty.mjs';
+import writeConfigJson from './writeConfigJson.mjs';
 export class VovkDev {
     #projectInfo;
     #segments = [];
-    #schemas = {};
+    #fullSchema = {
+        segments: {},
+        config: {},
+    };
     #isWatching = false;
     #modulesWatcher = null;
     #segmentWatcher = null;
@@ -145,6 +149,7 @@ export class VovkDev {
                 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();
             }
@@ -152,6 +157,7 @@ export class VovkDev {
                 log.info('Config file has been updated');
                 this.#generate();
             }
+            await writeConfigJson(schemaOutAbsolutePath, this.#projectInfo);
             isInitial = false;
         }, 1000);
         chokidar
@@ -203,11 +209,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.#fullSchema.segments[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))}`);
@@ -237,14 +243,14 @@ export class VovkDev {
                 log.warn(`Schema request to ${formatLoggedSegmentName(segmentName)} failed with status code ${resp.status} but expected 200.${probableCause ? ` Probable cause: ${probableCause}` : ''}`);
                 return { isError: true };
             }
-            let schema = null;
+            let segmentSchema = null;
             try {
-                ({ schema } = (await resp.json()));
+                ({ schema: segmentSchema } = (await resp.json()));
             }
             catch (error) {
                 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}`);
@@ -252,26 +258,26 @@ export class VovkDev {
         }
         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(() => 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;
@@ -280,10 +286,10 @@ export class VovkDev {
                 log.info(`Schema for ${formatLoggedSegmentName(segment.segmentName)} has been updated in ${timeTook}ms`);
             }
         }
-        else if (schema && !isSchemaEmpty(schema)) {
+        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.`);
             this.#generate();
         }

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

@@ -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;

package/dist/dev/logDiffResult.mjs

@@ -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');

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/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 diffSegmentSchema from './diffSegmentSchema.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({ schemaOutAbsolutePath, schema, skipIfExists = false, }) {
-    const segmentPath = path.join(schemaOutAbsolutePath, JSON_DIR_NAME, `${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);
@@ -16,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/getClientTemplates.d.mts

@@ -1,9 +1,9 @@
-import type { VovkStrictConfig } from '../types.mjs';
+import type { VovkStrictConfig } from 'vovk';
 interface ClientTemplate {
     templateName: string;
     templatePath: string;
     outPath: string;
-    fullSchema?: string | boolean;
+    emitFullSchema?: string | boolean;
 }
 export default function getClientTemplates({ config, cwd, generateFrom, }: {
     config: VovkStrictConfig;

package/dist/generate/index.d.mts

@@ -1,13 +1,13 @@
-import type { VovkSchema } from 'vovk';
+import type { VovkFullSchema } 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, forceNothingWrittenLog, templates, prettify: prettifyClient, fullSchema, }: {
+export default function generate({ projectInfo, segments, forceNothingWrittenLog, templates, prettify: prettifyClient, fullSchema, emitFullSchema, }: {
     projectInfo: ProjectInfo;
     segments: Segment[];
-    segmentsSchema: Record<string, VovkSchema>;
     forceNothingWrittenLog?: boolean;
-} & Pick<GenerateOptions, 'templates' | 'prettify' | 'fullSchema'>): Promise<{
+    fullSchema: VovkFullSchema;
+} & Pick<GenerateOptions, 'templates' | 'prettify' | 'emitFullSchema'>): Promise<{
     written: boolean;
     path: string;
 }>;

package/dist/generate/index.mjs

@@ -6,7 +6,8 @@ import prettify from '../utils/prettify.mjs';
 import getClientTemplates from './getClientTemplates.mjs';
 import chalkHighlightThing from '../utils/chalkHighlightThing.mjs';
 import uniq from 'lodash/uniq.js';
-export default async function generate({ projectInfo, segments, segmentsSchema, forceNothingWrittenLog, templates, prettify: prettifyClient, fullSchema, }) {
+export default async function generate({ projectInfo, segments, forceNothingWrittenLog, templates, prettify: prettifyClient, fullSchema, emitFullSchema, }) {
+    const segmentsSchema = fullSchema.segments;
     const generateFrom = templates ?? projectInfo.config.generateFrom;
     const noClient = templates?.[0] === 'none';
     const { config, cwd, log, clientImports, apiRoot } = projectInfo;
@@ -26,8 +27,7 @@ export default async function generate({ projectInfo, segments, segmentsSchema,
     const t = {
         apiRoot,
         imports: clientImports,
-        segments,
-        fullSchema: segmentsSchema,
+        fullSchema,
     };
     // Process each template in parallel
     const processedTemplates = noClient
@@ -59,11 +59,11 @@ export default async function generate({ projectInfo, segments, segmentsSchema,
     const usedTemplateNames = uniq(processedTemplates.filter(({ needsWriting }) => needsWriting).map(({ templateName }) => templateName));
     let fullSchemaNames = [];
     const DEFAULT_NAME = 'full-schema.json';
-    if (fullSchema) {
+    if (emitFullSchema) {
         fullSchemaNames.push(typeof fullSchema === 'string' ? fullSchema : DEFAULT_NAME);
         fullSchemaNames.push(...templateFiles
-            .filter(({ fullSchema }) => fullSchema)
-            .map(({ fullSchema }) => (typeof fullSchema === 'string' ? fullSchema : DEFAULT_NAME)));
+            .filter(({ emitFullSchema }) => emitFullSchema)
+            .map(({ emitFullSchema }) => (typeof emitFullSchema === 'string' ? emitFullSchema : DEFAULT_NAME)));
     }
     fullSchemaNames = uniq(fullSchemaNames);
     if (fullSchemaNames.length || usedTemplateNames.length > 0) {

package/dist/getProjectInfo/getConfig.d.mts

@@ -1,4 +1,4 @@
-import type { VovkStrictConfig } from '../types.mjs';
+import type { VovkStrictConfig } from 'vovk';
 export default function getConfig({ clientOutDir, cwd }: {
     clientOutDir?: string;
     cwd: string;
@@ -6,6 +6,6 @@ export default function getConfig({ clientOutDir, cwd }: {
     config: VovkStrictConfig;
     srcRoot: string;
     configAbsolutePaths: string[];
-    userConfig: import("../types.mjs").VovkConfig | null;
+    userConfig: import("vovk").VovkConfig | null;
     error: Error | undefined;
 }>;

package/dist/getProjectInfo/getConfig.mjs

@@ -10,6 +10,7 @@ export default async function getConfig({ clientOutDir, cwd }) {
     const createRPCImport = env.VOVK_CREATE_RPC_PATH ?? conf.createRPCImport ?? 'vovk/dist/client/createRPC.js';
     const defaultClientTemplates = ['ts', 'module', 'main'];
     const config = {
+        emitConfig: [],
         modulesDir: env.VOVK_MODULES_DIR ?? conf.modulesDir ?? './' + [srcRoot, 'modules'].filter(Boolean).join('/'),
         validateOnClientImport: typeof validateOnClientImport === 'string' ? [validateOnClientImport] : validateOnClientImport,
         fetcherImport: typeof fetcherImport === 'string' ? [fetcherImport] : fetcherImport,
@@ -31,5 +32,11 @@ export default async function getConfig({ clientOutDir, cwd }) {
             ...conf.templates,
         },
     };
+    if (typeof conf.emitConfig === 'undefined' || conf.emitConfig === true) {
+        config.emitConfig = Object.keys(config);
+    }
+    else if (Array.isArray(conf.emitConfig)) {
+        config.emitConfig = conf.emitConfig;
+    }
     return { config, srcRoot, configAbsolutePaths, userConfig, error };
 }

package/dist/getProjectInfo/getUserConfig.d.mts

@@ -1,4 +1,4 @@
-import type { VovkConfig } from '../types.mjs';
+import type { VovkConfig } from 'vovk';
 declare function getUserConfig({ cwd, }: {
     cwd: string;
 }): Promise<{

package/dist/getProjectInfo/index.d.mts

@@ -9,14 +9,14 @@ export default function getProjectInfo({ port: givenPort, clientOutDir, cwd, }?:
     apiRoot: string;
     apiDir: string;
     srcRoot: string;
-    config: import("../types.mjs").VovkStrictConfig;
+    config: import("vovk").VovkStrictConfig;
     clientImports: {
-        schema: string;
+        fullSchema: string;
         fetcher: string;
         createRPC: string;
         validateOnClient: string | null;
         module: {
-            schema: string;
+            fullSchema: string;
             fetcher: string;
             createRPC: string;
             validateOnClient: string | null;

package/dist/getProjectInfo/index.mjs

@@ -19,12 +19,12 @@ export default async function getProjectInfo({ port: givenPort, clientOutDir, cw
     }
     const getImportPath = (p) => (p.startsWith('.') ? path.relative(config.clientOutDir, p) : p);
     const clientImports = {
-        schema: schemaOutImportPath,
+        fullSchema: schemaOutImportPath,
         fetcher: getImportPath(config.fetcherImport[0]),
         createRPC: getImportPath(config.createRPCImport[0]),
         validateOnClient: config.validateOnClientImport ? getImportPath(config.validateOnClientImport[0]) : null,
         module: {
-            schema: schemaOutImportPath,
+            fullSchema: schemaOutImportPath,
             fetcher: getImportPath(config.fetcherImport[1] ?? config.fetcherImport[0]),
             createRPC: getImportPath(config.createRPCImport[1] ?? config.createRPCImport[0]),
             validateOnClient: config.validateOnClientImport

package/dist/index.d.mts

@@ -1,4 +1,2 @@
 #!/usr/bin/env node
 import 'dotenv/config';
-import type { VovkConfig, VovkEnv } from './types.mjs';
-export type { VovkConfig, VovkEnv };

package/dist/index.mjs

@@ -75,24 +75,24 @@ program
     .description('Generate RPC client from schema')
     .option('--out, --client-out-dir <path>', 'path to output directory')
     .option('--template, --templates <templates...>', 'client code templates ("ts", "compiled", "python", "none", a custom path)')
-    .option('--full-schema [fileName]', 'generate client with full schema')
+    .option('--emit-full-schema, --full-schema [fileName]', 'generate client with full schema')
     .option('--prettify', 'prettify output files')
     .action(async (options) => {
-    const { clientOutDir, templates, prettify, fullSchema } = options;
+    const { clientOutDir, templates, prettify, emitFullSchema } = 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, 'main.cjs')).href;
-    const { default: segmentsSchema } = (await import(schemaImportUrl));
+    const { default: fullSchema } = (await import(schemaImportUrl));
     await generate({
         projectInfo,
         segments,
-        segmentsSchema,
+        fullSchema,
         templates,
         prettify,
-        fullSchema,
         forceNothingWrittenLog: true,
+        emitFullSchema,
     });
 });
 program

package/dist/locateSegments.d.mts

@@ -1,4 +1,4 @@
-import type { VovkConfig } from './types.mjs';
+import type { VovkConfig } from 'vovk';
 export type Segment = {
     routeFilePath: string;
     segmentName: string;

package/dist/new/render.d.mts

@@ -1,4 +1,5 @@
-import type { VovkConfig, VovkModuleRenderResult } from '../types.mjs';
+import type { VovkConfig } from 'vovk';
+import type { VovkModuleRenderResult } from '../types.mjs';
 export default function render(codeTemplate: string, { config, withService, segmentName, moduleName, empty, templateFileName, }: {
     cwd: string;
     config: VovkConfig;

package/dist/new/render.mjs

@@ -8,14 +8,6 @@ export default async function render(codeTemplate, { config, withService, segmen
     const getModuleDirName = (givenSegmentName, givenModuleName) => [config.modulesDir, givenSegmentName || config.rootSegmentModulesDirName, _.camelCase(givenModuleName)]
         .filter(Boolean)
         .join('/');
-    /*
-      <% var modulePascalName = _.upperFirst(_.camelCase(moduleName)); %>
-  <% var modulePascalNamePlural = pluralize(modulePascalName); %>
-  <% var controllerName = modulePascalName + 'Controller'; %>
-  <% var compiledName = modulePascalName + 'RPC'; %>
-  <% var serviceName = modulePascalName + 'Service'; %>
-  <% var prefix = pluralize(_.kebabCase(moduleName).toLowerCase()); %>
-      */
     const theThing = _.camelCase(moduleName);
     const TheThing = _.upperFirst(theThing);
     const the_thing = _.snakeCase(moduleName);

package/dist/types.d.mts

@@ -1,55 +1,4 @@
 import type { LogLevelNames } from 'loglevel';
-export type KnownAny = any;
-export type VovkEnv = {
-    PORT?: string;
-    VOVK_CLIENT_OUT_DIR?: string;
-    VOVK_SCHEMA_OUT_DIR?: string;
-    VOVK_FETCHER_PATH?: string;
-    VOVK_VALIDATE_ON_CLIENT_PATH?: string;
-    VOVK_CREATE_RPC_PATH?: string;
-    VOVK_MODULES_DIR?: string;
-    VOVK_ORIGIN?: string;
-    VOVK_ROOT_ENTRY?: string;
-    VOVK_API_ENTRY_POINT?: string;
-    VOVK_ROOT_SEGMENT_MODULES_DIR_NAME?: string;
-    VOVK_LOG_LEVEL?: LogLevelNames;
-    VOVK_PRETTIFY_CLIENT?: string;
-    VOVK_DEV_HTTPS?: string;
-    __VOVK_START_WATCHER_IN_STANDALONE_MODE__?: 'true';
-    __VOVK_EXIT__?: 'true' | 'false';
-};
-type GenerateFrom = (string | {
-    templatePath: string;
-    outDir?: string;
-    templateName?: string;
-    fullSchema?: string | boolean;
-})[];
-export type VovkConfig = {
-    clientOutDir?: string;
-    schemaOutDir?: string;
-    fetcherImport?: string | string[];
-    validateOnClientImport?: string | string[] | null;
-    createRPCImport?: string | string[];
-    modulesDir?: string;
-    rootEntry?: string;
-    origin?: string;
-    rootSegmentModulesDirName?: string;
-    logLevel?: LogLevelNames;
-    prettifyClient?: boolean;
-    devHttps?: boolean;
-    generateFrom?: GenerateFrom | ((value: GenerateFrom) => GenerateFrom);
-    templates?: {
-        service?: string;
-        controller?: string;
-        [key: string]: string | undefined;
-    };
-};
-export type VovkStrictConfig = Required<Omit<VovkConfig, 'validateOnClientImport' | 'fetcherImport' | 'createRPCImport' | 'generateFrom'>> & {
-    validateOnClientImport: string[] | null;
-    fetcherImport: string[];
-    createRPCImport: string[];
-    generateFrom: GenerateFrom;
-};
 export type VovkModuleRenderResult = {
     fileName: string;
     dir: string;
@@ -65,7 +14,7 @@ export interface GenerateOptions {
     clientOutDir?: string;
     templates?: string[];
     prettify?: boolean;
-    fullSchema?: string | boolean;
+    emitFullSchema?: string | boolean;
 }
 export interface InitOptions {
     yes?: boolean;
@@ -91,4 +40,3 @@ export interface NewOptions {
     noSegmentUpdate?: boolean;
     empty?: boolean;
 }
-export {};

package/dist/utils/debounceWithArgs.d.mts

@@ -1,2 +1,2 @@
-import { KnownAny } from '../types.mjs';
+import type { KnownAny } from 'vovk';
 export default function debounceWithArgs<Callback extends (...args: KnownAny[]) => KnownAny>(callback: Callback, wait: number): (...args: Parameters<Callback>) => Promise<Awaited<ReturnType<Callback>>>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vovk-cli",
-  "version": "0.0.1-draft.103",
+  "version": "0.0.1-draft.105",
   "bin": {
     "vovk": "./dist/index.mjs"
   },
@@ -36,7 +36,7 @@
   },
   "homepage": "https://vovk.dev",
   "peerDependencies": {
-    "vovk": "^3.0.0-draft.87"
+    "vovk": "^3.0.0-draft.90"
   },
   "dependencies": {
     "@inquirer/prompts": "^7.3.1",

package/dist/dev/isSchemaEmpty.d.mts

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

package/dist/dev/isSchemaEmpty.mjs

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

package/dist/dev/writeOneSchemaFile.d.mts

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