vovk-cli 0.0.1-draft.165 → 0.0.1-draft.166

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

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

package/client-templates/cjs/index.d.cts.ejs

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

package/client-templates/mjs/index.d.mts.ejs

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

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

@@ -1,20 +1,20 @@
 <%- `// auto-generated ${new Date().toISOString()}\n/* eslint-disable */` %>
 import { fetcher } from '<%= t.imports.module.fetcher %>';
 import { createRPC } from '<%= t.imports.module.createRPC %>';
-import { fullSchema } from './fullSchema.cjs';
+import { schema } from './schema.cjs';
 <% if (t.imports.module.validateOnClient) { %>
 import { validateOnClient } from '<%= t.imports.module.validateOnClient %>';
 <% } else { %>
 const validateOnClient = undefined;
 <% } %>
-<% Object.values(t.fullSchema.segments).filter((segment) => segment.emitSchema).forEach((segment, i) => {
+<% Object.values(t.schema.segments).filter((segment) => segment.emitSchema).forEach((segment, i) => {
   Object.keys(segment.controllers).forEach((rpcModuleName) => { %>
 export const <%= rpcModuleName %> = createRPC(
-  fullSchema, '<%= segment.segmentName %>', '<%= rpcModuleName %>',
+  schema, '<%= segment.segmentName %>', '<%= rpcModuleName %>',
   { fetcher, validateOnClient, defaultOptions: { apiRoot: '<%= segment.segmentApiRoot ?? t.apiRoot %>' } }
 );
 <% 
   }); 
 });
 %>
-export { fullSchema };
+export { schema };

package/client-templates/readme/README.md.ejs

@@ -16,7 +16,7 @@ imports: ['vovk-openapi']
 npm install <%= t.package.name.replace(/-/g, '_') %>
 ```
 
-<% Object.entries(t.fullSchema.segments).forEach(([segmentName, segment]) => {
+<% Object.entries(t.schema.segments).forEach(([segmentName, segment]) => {
     Object.values(segment.controllers).forEach((controllerSchema) => { %>
 
 ## <%= controllerSchema.rpcModuleName %>

package/client-templates/{fullSchemaCjs/fullSchema.cjs.ejs → schemaCjs/schema.cjs.ejs}

@@ -1,12 +1,12 @@
 <%- `// auto-generated ${new Date().toISOString()}\n/* eslint-disable */` %>
 const config = require('./<%= t.schemaOutDir %>/config.json');
-const segments = {<% Object.values(t.fullSchema.segments).filter((segment) => segment.emitSchema).forEach((segment) => { %>
+const segments = {<% Object.values(t.schema.segments).filter((segment) => segment.emitSchema).forEach((segment) => { %>
     '<%= segment.segmentName %>': require('./<%= t.schemaOutDir %>/<%= t.SEGMENTS_SCHEMA_DIR_NAME %>/<%= segment.segmentName || t.ROOT_SEGMENT_SCHEMA_NAME %>.json'),<% }) %>
 };
-const fullSchema = {
-  $schema: '<%- t.SchemaIdEnum.FULL %>',
+const schema = {
+  $schema: '<%- t.VovkSchemaIdEnum.FULL %>',
   config,
   segments,
 };
 
-module.exports.fullSchema = fullSchema;
+module.exports.schema = schema;

package/client-templates/schemaCjs/schema.d.cts.ejs

@@ -0,0 +1,10 @@
+<%- `// auto-generated ${new Date().toISOString()}\n/* eslint-disable */` %>
+import type { VovkStrictConfig, VovkSegmentSchema, VovkSchemaIdEnum } from 'vovk';
+
+export const schema: {
+    $schema: '<%- t.VovkSchemaIdEnum.FULL %>';
+    config: Partial<VovkStrictConfig>;
+    segments: {<% Object.values(t.schema.segments).filter((segment) => segment.emitSchema).forEach((segment) => { %>
+      '<%= segment.segmentName %>': VovkSegmentSchema;<% }) %>
+    };
+};

package/client-templates/schemaJson/schema.json.ejs

@@ -0,0 +1 @@
+<%- JSON.stringify(t.schema, null, 2) %>

package/client-templates/{fullSchemaTs/fullSchema.ts.ejs → schemaTs/schema.ts.ejs}

@@ -1,14 +1,14 @@
 <%- `// auto-generated ${new Date().toISOString()}\n/* eslint-disable */` %>
 import config from './<%= t.schemaOutDir %>/config.json' with { type: "json" };
-<% Object.values(t.fullSchema.segments).filter((segment) => segment.emitSchema).forEach((segment, i) => { %>
+<% Object.values(t.schema.segments).filter((segment) => segment.emitSchema).forEach((segment, i) => { %>
 import segment<%= i %> from './<%= t.schemaOutDir %>/<%= t.SEGMENTS_SCHEMA_DIR_NAME %>/<%= segment.segmentName || t.ROOT_SEGMENT_SCHEMA_NAME %>.json' with { type: "json" };
 <% }) %>
-const segments = {<% Object.values(t.fullSchema.segments).filter((segment) => segment.emitSchema).forEach((segment, i) => { %>
+const segments = {<% Object.values(t.schema.segments).filter((segment) => segment.emitSchema).forEach((segment, i) => { %>
   '<%= segment.segmentName %>': segment<%= i %>,<% }) %>
 };
 
-export const fullSchema = {
-  $schema: '<%- t.SchemaIdEnum.FULL %>',
+export const schema = {
+  $schema: '<%- t.VovkSchemaIdEnum.FULL %>',
   config,
   segments,
 };

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 { fullSchema } from './fullSchema.ts';
-<% Object.values(t.fullSchema.segments).filter((segment) => segment.emitSchema).forEach((segment, i) => { %>
+import { schema } from './schema.ts';
+<% Object.values(t.schema.segments).filter((segment) => segment.emitSchema).forEach((segment, i) => { %>
 import type { Controllers as Controllers<%= i %> } from "<%= t.segmentMeta[segment.segmentName].segmentImportPath %>";
 <% }) %>
 <% if (t.imports.validateOnClient) { %>
@@ -12,12 +12,12 @@ import { validateOnClient } from '<%= t.imports.validateOnClient %>';
 const validateOnClient = undefined;
 <% } %>
 type Options = typeof fetcher extends VovkClientFetcher<infer U> ? U : never;
-<% Object.values(t.fullSchema.segments).filter((segment) => segment.emitSchema).forEach((segment, i) => { %>
+<% Object.values(t.schema.segments).filter((segment) => segment.emitSchema).forEach((segment, i) => { %>
   <% Object.keys(segment.controllers).forEach((rpcModuleName) => { %>
 export const <%= rpcModuleName %> = createRPC<Controllers<%= i %>["<%= rpcModuleName %>"], Options>(
-  fullSchema, '<%= segment.segmentName %>', '<%= rpcModuleName %>',
+  schema, '<%= segment.segmentName %>', '<%= rpcModuleName %>',
   { fetcher, validateOnClient, defaultOptions: { apiRoot: '<%= segment.segmentApiRoot ?? t.apiRoot %>' } }
 );
   <% }) %>
 <% }) %>
-export { fullSchema };
+export { schema };

package/dist/bundle/index.d.mts

@@ -1,6 +1,8 @@
-import type { VovkFullSchema } from 'vovk';
+import type { VovkSchema } from 'vovk';
 import type { ProjectInfo } from '../getProjectInfo/index.mjs';
-export default function bundle({ projectInfo, fullSchema, }: {
+import type { BundleOptions } from '../types.mjs';
+export default function bundle({ projectInfo, fullSchema, cliBundleOptions, }: {
     projectInfo: ProjectInfo;
-    fullSchema: VovkFullSchema;
+    fullSchema: VovkSchema;
+    cliBundleOptions: BundleOptions;
 }): Promise<void>;

package/dist/bundle/index.mjs

@@ -5,25 +5,36 @@ import groupBy from 'lodash/groupBy.js';
 import generate from '../generate/index.mjs';
 import { BuiltInTemplateName } from '../getProjectInfo/getConfig/getTemplateDefs.mjs';
 import chalkHighlightThing from '../utils/chalkHighlightThing.mjs';
-export default async function bundle({ projectInfo, fullSchema, }) {
-    const { config, log } = projectInfo;
+import locateSegments from '../locateSegments.mjs';
+export default async function bundle({ projectInfo, fullSchema, cliBundleOptions, }) {
+    const { config, log, cwd, apiDir } = projectInfo;
+    const locatedSegments = await locateSegments({ dir: path.join(cwd, apiDir), config, log });
     const { bundle: bundleConfig } = config;
-    const cwd = process.cwd();
     const tsFullClientOutAbsoluteDirInput = path.join(cwd, bundleConfig.tsClientOutDir);
+    const tsClientOutDir = cliBundleOptions?.tsClientOutDir ?? bundleConfig.tsClientOutDir;
+    const dontDeleteTsClientOutDirAfter = cliBundleOptions?.dontDeleteTsClientOutDirAfter ?? bundleConfig?.dontDeleteTsClientOutDirAfter ?? false;
+    const sourcemap = cliBundleOptions?.sourcemap ?? bundleConfig?.sourcemap;
+    if (!tsClientOutDir) {
+        throw new Error('No output directory specified for composed client');
+    }
+    const outDir = cliBundleOptions?.outDir ?? bundleConfig.outDir;
+    if (!outDir) {
+        throw new Error('No output directory specified for bundling');
+    }
     await generate({
         isEnsuringClient: false,
         projectInfo,
         forceNothingWrittenLog: true,
         fullSchema,
+        locatedSegments,
         cliGenerateOptions: {
-            fullFrom: [BuiltInTemplateName.ts],
-            fullOut: bundleConfig.tsClientOutDir,
+            composedFrom: [BuiltInTemplateName.ts],
+            composedOut: tsClientOutDir,
+            composedOnly: true,
+            composedIncludeSegments: cliBundleOptions.includeSegments ?? bundleConfig.includeSegments,
+            composedExcludeSegments: cliBundleOptions.excludeSegments ?? bundleConfig.excludeSegments,
         },
     });
-    const outDir = bundleConfig.outDir;
-    if (!outDir) {
-        throw new Error('No output directory specified for bundling');
-    }
     await build({
         entry: path.join(tsFullClientOutAbsoluteDirInput, './index.ts'),
         dts: true,
@@ -35,29 +46,30 @@ export default async function bundle({ projectInfo, fullSchema, }) {
     const outDirAbsolute = path.resolve(cwd, outDir);
     log.info(`Bundled index.ts to ${chalkHighlightThing(outDirAbsolute)}`);
     await build({
-        entry: path.join(tsFullClientOutAbsoluteDirInput, './fullSchema.ts'),
+        entry: path.join(tsFullClientOutAbsoluteDirInput, './schema.ts'),
         dts: true,
         format: ['cjs'],
         fixedExtension: true,
         outDir,
         clean: false,
-        sourcemap: bundleConfig.sourcemap,
+        sourcemap,
     });
-    log.info(`Bundled fullSchema.ts to ${chalkHighlightThing(outDirAbsolute)}`);
-    const requiresGroup = groupBy(Object.entries(bundleConfig.requires), ([, relativeOutDir]) => relativeOutDir);
+    log.info(`Bundled schema.ts to ${chalkHighlightThing(outDirAbsolute)}`);
+    const requiresGroup = groupBy(Object.entries(bundleConfig.requires), ([, relativePath]) => relativePath);
     for (const [relativePath, group] of Object.entries(requiresGroup)) {
         await generate({
             isEnsuringClient: false,
             projectInfo,
             forceNothingWrittenLog: true,
             fullSchema,
+            locatedSegments,
             cliGenerateOptions: {
-                fullFrom: group.map(([templateName]) => templateName),
-                fullOut: path.resolve(outDir, relativePath),
+                composedFrom: group.map(([templateName]) => templateName),
+                composedOut: path.resolve(outDir, relativePath),
             },
         });
     }
-    if (!bundleConfig.dontDeleteTsClientOutDirAfter) {
+    if (!dontDeleteTsClientOutDirAfter) {
         await fs.rm(tsFullClientOutAbsoluteDirInput, { recursive: true, force: true });
         log.debug(`Deleted temporary TypeScript client output directory: ${chalkHighlightThing(tsFullClientOutAbsoluteDirInput)}`);
     }

package/dist/dev/ensureSchemaFiles.mjs

@@ -1,10 +1,10 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import debounce from 'lodash/debounce.js';
+import { VovkSchemaIdEnum } from 'vovk';
 import writeOneSchemaFile, { SEGMENTS_SCHEMA_DIR_NAME, ROOT_SEGMENT_SCHEMA_NAME, } from './writeOneSegmentSchemaFile.mjs';
 import formatLoggedSegmentName from '../utils/formatLoggedSegmentName.mjs';
 import writeConfigJson from './writeConfigJson.mjs';
-import { SchemaIdEnum } from '../enums.mjs';
 /**
  * Ensure that the schema files are created to avoid any import errors.
  */
@@ -19,7 +19,7 @@ export default async function ensureSchemaFiles(projectInfo, schemaOutAbsolutePa
         const { isCreated } = await writeOneSchemaFile({
             schemaOutAbsolutePath,
             segmentSchema: {
-                $schema: SchemaIdEnum.SEGMENT,
+                $schema: VovkSchemaIdEnum.SEGMENT,
                 emitSchema: false,
                 segmentName,
                 controllers: {},

package/dist/dev/index.mjs

@@ -1,5 +1,6 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
+import { VovkSchemaIdEnum } from 'vovk';
 import * as chokidar from 'chokidar';
 import { Agent, setGlobalDispatcher } from 'undici';
 import keyBy from 'lodash/keyBy.js';
@@ -15,13 +16,13 @@ import generate from '../generate/index.mjs';
 import locateSegments from '../locateSegments.mjs';
 import debounceWithArgs from '../utils/debounceWithArgs.mjs';
 import formatLoggedSegmentName from '../utils/formatLoggedSegmentName.mjs';
-import isSegmentSchemaEmpty from './isSegmentSchemaEmpty.mjs';
 import writeConfigJson from './writeConfigJson.mjs';
-import { SchemaIdEnum } from '../enums.mjs';
+import { isEmpty } from 'lodash';
 export class VovkDev {
     #projectInfo;
+    #segments = [];
     #fullSchema = {
-        $schema: SchemaIdEnum.FULL,
+        $schema: VovkSchemaIdEnum.SCHEMA,
         segments: {},
         config: {},
     };
@@ -45,18 +46,18 @@ export class VovkDev {
             log.debug(`File ${filePath} has been added to segments folder`);
             if (segmentReg.test(filePath)) {
                 const segmentName = getSegmentName(filePath);
-                this.#projectInfo.segments = this.#projectInfo.segments.find((s) => s.segmentName === segmentName)
-                    ? this.#projectInfo.segments
+                this.#segments = this.#segments.find((s) => s.segmentName === segmentName)
+                    ? this.#segments
                     : [
-                        ...this.#projectInfo.segments,
+                        ...this.#segments,
                         {
                             routeFilePath: filePath,
                             segmentName,
                         },
                     ];
                 log.info(`${capitalize(formatLoggedSegmentName(segmentName))} has been added`);
-                log.debug(`Full list of segments: ${this.#projectInfo.segments.map((s) => s.segmentName).join(', ')}`);
-                void debouncedEnsureSchemaFiles(this.#projectInfo, schemaOutAbsolutePath, this.#projectInfo.segments.map((s) => s.segmentName));
+                log.debug(`Full list of segments: ${this.#segments.map((s) => s.segmentName).join(', ')}`);
+                void debouncedEnsureSchemaFiles(this.#projectInfo, schemaOutAbsolutePath, this.#segments.map((s) => s.segmentName));
             }
         })
             .on('change', (filePath) => {
@@ -67,23 +68,23 @@ export class VovkDev {
         })
             .on('addDir', async (dirPath) => {
             log.debug(`Directory ${dirPath} has been added to segments folder`);
-            this.#projectInfo.segments = await locateSegments({
+            this.#segments = await locateSegments({
                 dir: apiDirAbsolutePath,
                 config,
                 log: this.#projectInfo.log,
             });
-            for (const { segmentName } of this.#projectInfo.segments) {
+            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.#projectInfo.segments = await locateSegments({
+            this.#segments = await locateSegments({
                 dir: apiDirAbsolutePath,
                 config,
                 log: this.#projectInfo.log,
             });
-            for (const { segmentName } of this.#projectInfo.segments) {
+            for (const { segmentName } of this.#segments) {
                 void this.#requestSchema(segmentName);
             }
         })
@@ -91,10 +92,10 @@ export class VovkDev {
             log.debug(`File ${filePath} has been removed from segments folder`);
             if (segmentReg.test(filePath)) {
                 const segmentName = getSegmentName(filePath);
-                this.#projectInfo.segments = this.#projectInfo.segments.filter((s) => s.segmentName !== segmentName);
+                this.#segments = this.#segments.filter((s) => s.segmentName !== segmentName);
                 log.info(`${formatLoggedSegmentName(segmentName, { upperFirst: true })} has been removed`);
-                log.debug(`Full list of segments: ${this.#projectInfo.segments.map((s) => s.segmentName).join(', ')}`);
-                void debouncedEnsureSchemaFiles(this.#projectInfo, schemaOutAbsolutePath, this.#projectInfo.segments.map((s) => s.segmentName));
+                log.debug(`Full list of segments: ${this.#segments.map((s) => s.segmentName).join(', ')}`);
+                void debouncedEnsureSchemaFiles(this.#projectInfo, schemaOutAbsolutePath, this.#segments.map((s) => s.segmentName));
             }
         })
             .on('ready', () => {
@@ -127,12 +128,12 @@ export class VovkDev {
             log.debug(`File ${filePath} has been removed from modules folder`);
         })
             .on('addDir', () => {
-            for (const { segmentName } of this.#projectInfo.segments) {
+            for (const { segmentName } of this.#segments) {
                 void this.#requestSchema(segmentName);
             }
         })
             .on('unlinkDir', () => {
-            for (const { segmentName } of this.#projectInfo.segments) {
+            for (const { segmentName } of this.#segments) {
                 void this.#requestSchema(segmentName);
             }
         })
@@ -151,6 +152,8 @@ export class VovkDev {
         let isReady = false;
         const handle = debounce(async () => {
             this.#projectInfo = await getProjectInfo();
+            const { config, apiDir } = this.#projectInfo;
+            this.#segments = await locateSegments({ dir: path.join(cwd, apiDir), config, log });
             await this.#modulesWatcher?.close();
             await this.#segmentWatcher?.close();
             await Promise.all([
@@ -200,7 +203,7 @@ export class VovkDev {
         if (this.#isWatching)
             throw new Error('Already watching');
         const { log } = this.#projectInfo;
-        log.debug(`Starting segments and modules watcher. Detected initial segments: ${JSON.stringify(this.#projectInfo.segments.map((s) => s.segmentName))}.`);
+        log.debug(`Starting segments and modules watcher. Detected initial segments: ${JSON.stringify(this.#segments.map((s) => s.segmentName))}.`);
         // automatically watches segments and modules
         this.#watchConfig(callback);
     }
@@ -215,7 +218,7 @@ export class VovkDev {
         const namesOfClasses = [...code.matchAll(nameOfClasReg)].map((match) => match[1]);
         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.#projectInfo.segments.filter((s) => {
+            const affectedSegments = this.#segments.filter((s) => {
                 const segmentSchema = this.#fullSchema.segments[s.segmentName];
                 if (!segmentSchema)
                     return false;
@@ -265,7 +268,7 @@ export class VovkDev {
         }
         return { isError: false };
     }, 500);
-    #generate = debounce(() => generate({ projectInfo: this.#projectInfo, fullSchema: this.#fullSchema }).then(this.#onFirstTimeGenerate), 1000);
+    #generate = debounce(() => generate({ projectInfo: this.#projectInfo, fullSchema: this.#fullSchema, locatedSegments: this.#segments }).then(this.#onFirstTimeGenerate), 1000);
     async #handleSegmentSchema(segmentName, segmentSchema) {
         const { log, config, cwd } = this.#projectInfo;
         if (!segmentSchema) {
@@ -274,7 +277,7 @@ export class VovkDev {
         }
         log.debug(`Handling received schema from ${formatLoggedSegmentName(segmentName)}`);
         const schemaOutAbsolutePath = path.join(cwd, config.schemaOutDir);
-        const segment = this.#projectInfo.segments.find((s) => s.segmentName === segmentName);
+        const segment = this.#segments.find((s) => s.segmentName === segmentName);
         if (!segment) {
             log.warn(`${formatLoggedSegmentName(segmentName)} not found`);
             return;
@@ -293,10 +296,10 @@ export class VovkDev {
                 log.info(`Schema for ${formatLoggedSegmentName(segment.segmentName)} has been updated in ${timeTook}ms`);
             }
         }
-        else if (segmentSchema && !isSegmentSchemaEmpty(segmentSchema)) {
+        else if (segmentSchema && !isEmpty(segmentSchema.controllers)) {
             log.error(`Non-empty schema provided for ${formatLoggedSegmentName(segment.segmentName)} but "emitSchema" is false`);
         }
-        if (this.#projectInfo.segments.every((s) => this.#fullSchema.segments[s.segmentName])) {
+        if (this.#segments.every((s) => this.#fullSchema.segments[s.segmentName])) {
             log.debug(`All segments with "emitSchema" have schema.`);
             this.#generate();
         }
@@ -304,7 +307,8 @@ export class VovkDev {
     async start({ exit }) {
         const now = Date.now();
         this.#projectInfo = await getProjectInfo();
-        const { log, config, cwd } = this.#projectInfo;
+        const { log, config, cwd, apiDir } = this.#projectInfo;
+        this.#segments = await locateSegments({ dir: path.join(cwd, apiDir), config, log });
         log.info('Starting...');
         if (exit) {
             this.#onFirstTimeGenerate = once(() => {
@@ -326,13 +330,14 @@ export class VovkDev {
             log.error(`Unhandled Rejection: ${String(reason)}`);
         });
         const schemaOutAbsolutePath = path.join(cwd, config.schemaOutDir);
-        await ensureSchemaFiles(this.#projectInfo, schemaOutAbsolutePath, this.#projectInfo.segments.map((s) => s.segmentName));
-        await ensureClient(this.#projectInfo);
+        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
         setTimeout(() => {
-            for (const { segmentName } of this.#projectInfo.segments) {
+            for (const { segmentName } of this.#segments) {
                 let attempts = 0;
                 void this.#requestSchema(segmentName).then(({ isError }) => {
                     if (isError) {

package/dist/generate/ensureClient.d.mts

@@ -1,2 +1,3 @@
 import type { ProjectInfo } from '../getProjectInfo/index.mjs';
-export default function ensureClient(projectInfo: ProjectInfo): Promise<void>;
+import type { Segment } from '../locateSegments.mjs';
+export default function ensureClient(projectInfo: ProjectInfo, locatedSegments: Segment[]): Promise<void>;

package/dist/generate/ensureClient.mjs

@@ -1,10 +1,10 @@
-import { SchemaIdEnum } from '../enums.mjs';
+import { VovkSchemaIdEnum } from 'vovk';
 import generate from './index.mjs';
-const getEmptySegmentRecordSchema = (segments) => {
+const getEmptySegmentRecordSchema = (segmentNames) => {
     const result = {};
-    for (const { segmentName } of segments) {
+    for (const segmentName of segmentNames) {
         result[segmentName] = {
-            $schema: SchemaIdEnum.SEGMENT,
+            $schema: VovkSchemaIdEnum.SEGMENT,
             segmentName,
             emitSchema: false,
             controllers: {},
@@ -12,14 +12,15 @@ const getEmptySegmentRecordSchema = (segments) => {
     }
     return result;
 };
-export default async function ensureClient(projectInfo) {
+export default async function ensureClient(projectInfo, locatedSegments) {
     return generate({
         isEnsuringClient: true,
         projectInfo,
         fullSchema: {
-            $schema: SchemaIdEnum.FULL,
+            $schema: VovkSchemaIdEnum.SCHEMA,
             config: {},
-            segments: getEmptySegmentRecordSchema(projectInfo.segments),
+            segments: getEmptySegmentRecordSchema(locatedSegments.map(({ segmentName }) => segmentName)),
         },
+        locatedSegments,
     });
 }

package/dist/generate/getClientTemplateFiles.d.mts

@@ -12,7 +12,7 @@ export default function getClientTemplateFiles({ config, cwd, log, configKey, cl
     config: VovkStrictConfig;
     cwd: string;
     log: ProjectInfo['log'];
-    configKey: 'fullClient' | 'segmentedClient';
+    configKey: 'composedClient' | 'segmentedClient';
     cliGenerateOptions?: GenerateOptions;
 }): Promise<{
     fromTemplates: string[];

package/dist/generate/getClientTemplateFiles.mjs

@@ -2,18 +2,18 @@ import path from 'node:path';
 import { glob } from 'glob';
 import resolveAbsoluteModulePath from '../utils/resolveAbsoluteModulePath.mjs';
 import getFileSystemEntryType, { FileSystemEntryType } from '../utils/getFileSystemEntryType.mjs';
+import getPublicModuleNameFromPath from '../utils/getPublicModuleNameFromPath.mjs';
 export default async function getClientTemplateFiles({ config, cwd, log, configKey, cliGenerateOptions, }) {
     const usedTemplateDefs = {};
-    const fromTemplates = configKey === 'fullClient'
-        ? cliGenerateOptions?.fullFrom || cliGenerateOptions?.segmentedFrom
-            ? (cliGenerateOptions?.fullFrom ?? [])
-            : config.fullClient.fromTemplates
-        : cliGenerateOptions?.fullFrom || cliGenerateOptions?.segmentedFrom
+    const fromTemplates = configKey === 'composedClient'
+        ? cliGenerateOptions?.composedFrom || cliGenerateOptions?.segmentedFrom
+            ? (cliGenerateOptions?.composedFrom ?? [])
+            : config.composedClient.fromTemplates
+        : cliGenerateOptions?.composedFrom || cliGenerateOptions?.segmentedFrom
             ? (cliGenerateOptions?.segmentedFrom ?? [])
             : config.segmentedClient.fromTemplates;
-    const outDir = configKey === 'fullClient'
-        ? (cliGenerateOptions?.fullOut ?? config.fullClient.outDir)
-        : (cliGenerateOptions?.segmentedOut ?? config.segmentedClient.outDir);
+    const cliOutDir = configKey === 'composedClient' ? cliGenerateOptions?.composedOut : cliGenerateOptions?.segmentedOut;
+    const configOutDir = configKey === 'composedClient' ? config.composedClient.outDir : config.segmentedClient.outDir;
     for (const templateName of fromTemplates) {
         if (!(templateName in config.clientTemplateDefs)) {
             throw new Error(`Unknown template name: ${templateName}`);
@@ -29,16 +29,13 @@ export default async function getClientTemplateFiles({ config, cwd, log, configK
             : null;
         const entryType = templateAbsolutePath ? await getFileSystemEntryType(templateAbsolutePath) : null;
         if (templateAbsolutePath && !entryType) {
-            if (templateDef.templatePath &&
-                !templateDef.templatePath.startsWith('.') &&
-                !templateDef.templatePath.startsWith('/')) {
-                const pathParts = templateDef.templatePath.split('/');
-                const npmModuleName = pathParts[0].startsWith('@') ? `${pathParts[0]}/${pathParts[1]}` : pathParts[0];
-                throw new Error(`Unable to locate template path "${templateDef.templatePath}" resolved as "${templateAbsolutePath}". You may need to install the package "${npmModuleName}" first.`);
+            const { moduleName } = templateDef.templatePath ? getPublicModuleNameFromPath(templateDef.templatePath) : {};
+            if (moduleName) {
+                throw new Error(`Unable to locate template path "${templateDef.templatePath}" resolved as "${templateAbsolutePath}". You may need to install the package "${moduleName}" first.`);
             }
             throw new Error(`Unable to locate template path "${templateDef.templatePath}" resolved as "${templateAbsolutePath}"`);
         }
-        const defOutDir = configKey === 'fullClient' ? templateDef.fullClient?.outDir : templateDef.segmentedClient?.outDir;
+        const defOutDir = configKey === 'composedClient' ? templateDef.composedClient?.outDir : templateDef.segmentedClient?.outDir;
         let files = [];
         if (templateAbsolutePath) {
             if (entryType === FileSystemEntryType.FILE) {
@@ -55,7 +52,7 @@ export default async function getClientTemplateFiles({ config, cwd, log, configK
                 log.error(`Template "${templateAbsolutePath}" not found`);
                 continue;
             }
-            const outCwdRelativeDir = forceOutCwdRelativeDir ?? defOutDir ?? outDir;
+            const outCwdRelativeDir = forceOutCwdRelativeDir ?? cliOutDir ?? defOutDir ?? configOutDir;
             for (const { filePath, isSingleFileTemplate } of files) {
                 templateFiles.push({
                     templateName,

package/dist/generate/getFullSchemaFromJSON.d.mts

@@ -1,3 +1,3 @@
-import type { VovkFullSchema } from 'vovk';
+import { type VovkSchema } from 'vovk';
 import type { ProjectInfo } from '../getProjectInfo/index.mjs';
-export declare function getFullSchemaFromJSON(schemaOutAbsolutePath: string, projectInfo: ProjectInfo): Promise<VovkFullSchema>;
+export declare function getFullSchemaFromJSON(schemaOutAbsolutePath: string, log: ProjectInfo['log']): Promise<VovkSchema>;

package/dist/generate/getFullSchemaFromJSON.mjs

@@ -1,15 +1,14 @@
 import { readFile, access } from 'node:fs/promises';
 import path from 'node:path';
 import { glob } from 'glob';
+import { VovkSchemaIdEnum } from 'vovk';
 import { ROOT_SEGMENT_SCHEMA_NAME } from '../dev/writeOneSegmentSchemaFile.mjs';
-import { SchemaIdEnum } from '../enums.mjs';
-export async function getFullSchemaFromJSON(schemaOutAbsolutePath, projectInfo) {
+export async function getFullSchemaFromJSON(schemaOutAbsolutePath, log) {
     const result = {
-        $schema: SchemaIdEnum.FULL,
+        $schema: VovkSchemaIdEnum.SCHEMA,
         config: {},
         segments: {},
     };
-    const { log } = projectInfo;
     // Handle config.json
     const configPath = path.join(schemaOutAbsolutePath, 'config.json');
     try {