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

package/dist/generate/getTemplateClientImports.d.mts

@@ -1,16 +1,15 @@
-import type { VovkStrictConfig } from 'vovk';
-import type { Segment } from '../locateSegments.mjs';
+import type { VovkSchema, VovkStrictConfig } from 'vovk';
 export type ClientImports = {
     fetcher: string;
     validateOnClient: string | null;
     createRPC: string;
 };
-export default function getTemplateClientImports({ config, segments, outCwdRelativeDir, }: {
+export default function getTemplateClientImports({ config, fullSchema, outCwdRelativeDir, }: {
     config: VovkStrictConfig;
-    segments: Segment[];
+    fullSchema: VovkSchema;
     outCwdRelativeDir: string;
 }): {
-    fullClient: ClientImports & {
+    composedClient: ClientImports & {
         module: ClientImports;
     };
     segmentedClient: Record<string, ClientImports & {

package/dist/generate/getTemplateClientImports.mjs

@@ -1,10 +1,10 @@
 import path from 'node:path';
 import { ROOT_SEGMENT_SCHEMA_NAME } from '../dev/writeOneSegmentSchemaFile.mjs';
-export default function getTemplateClientImports({ config, segments, outCwdRelativeDir, }) {
+export default function getTemplateClientImports({ config, fullSchema, outCwdRelativeDir, }) {
     const { imports } = config;
     const getImportPath = (p, s = '') => p.startsWith('.') ? path.relative(path.join(outCwdRelativeDir, s), p) : p;
     const clientImports = {
-        fullClient: {
+        composedClient: {
             fetcher: getImportPath(imports.fetcher[0]),
             createRPC: getImportPath(imports.createRPC[0]),
             validateOnClient: imports.validateOnClient ? getImportPath(imports.validateOnClient[0]) : null,
@@ -16,7 +16,7 @@ export default function getTemplateClientImports({ config, segments, outCwdRelat
                     : null,
             },
         },
-        segmentedClient: Object.fromEntries(segments.map((segment) => [
+        segmentedClient: Object.fromEntries(Object.values(fullSchema.segments).map((segment) => [
             segment.segmentName,
             {
                 fetcher: getImportPath(imports.fetcher[0], segment.segmentName || ROOT_SEGMENT_SCHEMA_NAME),

package/dist/generate/index.d.mts

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

package/dist/generate/index.mjs

@@ -2,7 +2,6 @@ import path from 'node:path';
 import fs from 'node:fs/promises';
 import matter from 'gray-matter';
 import _ from 'lodash';
-import formatLoggedSegmentName from '../utils/formatLoggedSegmentName.mjs';
 import getClientTemplateFiles from './getClientTemplateFiles.mjs';
 import chalkHighlightThing from '../utils/chalkHighlightThing.mjs';
 import pickSegmentFullSchema from '../utils/pickSegmentFullSchema.mjs';
@@ -11,29 +10,31 @@ import getTemplateClientImports from './getTemplateClientImports.mjs';
 import mergePackages from './mergePackages.mjs';
 import writeOneClientFile from './writeOneClientFile.mjs';
 import { ROOT_SEGMENT_SCHEMA_NAME } from '../dev/writeOneSegmentSchemaFile.mjs';
-const getIncludedSegmentNames = (config, segments, configKey) => {
-    if ('includeSegments' in config[configKey] &&
-        'excludeSegments' in config[configKey]) {
-        throw new Error(`Both includeSegments and excludeSegments are set in ${configKey} config. Please use only one of them.`);
+const getIncludedSegmentNames = (config, fullSchema, configKey, cliGenerateOptions) => {
+    const segments = Object.values(fullSchema.segments);
+    const includeSegments = cliGenerateOptions?.[configKey === 'segmentedClient' ? 'segmentedIncludeSegments' : 'composedIncludeSegments'] ??
+        config[configKey].includeSegments;
+    const excludeSegments = cliGenerateOptions?.[configKey === 'segmentedClient' ? 'segmentedExcludeSegments' : 'composedExcludeSegments'] ??
+        config[configKey].excludeSegments;
+    if (includeSegments?.length && excludeSegments?.length) {
+        throw new Error(`Both includeSegments and excludeSegments are set in "${configKey}" config. Please use only one of them.`);
     }
-    const includedSegmentNames = 'includeSegments' in config[configKey] &&
-        Array.isArray(config[configKey].includeSegments)
-        ? config[configKey].includeSegments.map((segmentName) => {
+    const includedSegmentNames = Array.isArray(includeSegments) && includeSegments.length
+        ? includeSegments.map((segmentName) => {
             const segment = segments.find(({ segmentName: sName }) => sName === segmentName);
             if (!segment) {
-                throw new Error(`Segment "${segmentName}" not found in the config for ${configKey}`);
+                throw new Error(`Segment "${segmentName}" not found in the config for "${configKey}"`);
             }
             return segment.segmentName;
         })
-        : 'excludeSegments' in config[configKey] &&
-            Array.isArray(config[configKey].excludeSegments)
+        : Array.isArray(excludeSegments) && excludeSegments.length // TODO: Warn if excludeSegments includes a segment name that is not listed at segments
             ? segments
-                .filter(({ segmentName }) => !config[configKey].excludeSegments?.includes(segmentName))
+                .filter(({ segmentName }) => !excludeSegments?.includes(segmentName))
                 .map(({ segmentName }) => segmentName)
             : segments.map(({ segmentName }) => segmentName);
     return includedSegmentNames;
 };
-function logClientGenerationResults({ results, log, isEnsuringClient = false, forceNothingWrittenLog = false, clientType = 'Full', startTime, fromTemplates, }) {
+function logClientGenerationResults({ results, log, isEnsuringClient = false, forceNothingWrittenLog = false, clientType = 'Composed', startTime, fromTemplates, }) {
     const writtenResults = results.filter(({ written }) => written);
     const duration = Date.now() - startTime;
     if (writtenResults.length) {
@@ -48,29 +49,27 @@ function logClientGenerationResults({ results, log, isEnsuringClient = false, fo
         logOrDebug(`${clientType} client is up to date and doesn't need to be regenerated (${duration}ms)`);
     }
 }
-export default async function generate({ isEnsuringClient = false, projectInfo, forceNothingWrittenLog, fullSchema, cliGenerateOptions, }) {
-    const { config, cwd, log, segments } = projectInfo;
-    // Ensure that each segment has a matching schema if it needs to be emitted:
-    for (let i = 0; i < segments.length; i++) {
-        const { segmentName } = segments[i];
-        const schema = fullSchema.segments[segmentName];
-        if (!schema) {
-            throw new Error(`Unable to generate client. No schema found for ${formatLoggedSegmentName(segmentName)}`);
-        }
-        if (!schema.emitSchema)
-            continue;
-    }
-    if (config.fullClient.enabled) {
+export default async function generate({ isEnsuringClient = false, projectInfo, forceNothingWrittenLog, fullSchema, locatedSegments, cliGenerateOptions, }) {
+    const { config, cwd, log } = projectInfo;
+    const isComposedEnabled = cliGenerateOptions?.composedOnly ||
+        !!cliGenerateOptions?.composedFrom ||
+        !!cliGenerateOptions?.composedOut ||
+        (config.composedClient?.enabled && !cliGenerateOptions?.segmentedOnly);
+    const isSegmentedEnabled = cliGenerateOptions?.segmentedOnly ||
+        !!cliGenerateOptions?.segmentedFrom ||
+        !!cliGenerateOptions?.segmentedOut ||
+        (config.segmentedClient?.enabled && !cliGenerateOptions?.composedOnly);
+    if (isComposedEnabled) {
         const now = Date.now();
-        const segmentNames = getIncludedSegmentNames(config, segments, 'fullClient');
-        const { templateFiles: fullClientTemplateFiles, fromTemplates } = await getClientTemplateFiles({
+        const segmentNames = getIncludedSegmentNames(config, fullSchema, 'composedClient', cliGenerateOptions);
+        const { templateFiles: composedClientTemplateFiles, fromTemplates } = await getClientTemplateFiles({
             config,
             cwd,
             log,
             cliGenerateOptions,
-            configKey: 'fullClient',
+            configKey: 'composedClient',
         });
-        const fullClientResults = await Promise.all(fullClientTemplateFiles.map(async (clientTemplateFile) => {
+        const composedClientResults = await Promise.all(composedClientTemplateFiles.map(async (clientTemplateFile) => {
             const { templateFilePath, templateName, templateDef, outCwdRelativeDir } = clientTemplateFile;
             const templateContent = await fs.readFile(templateFilePath, 'utf-8');
             const matterResult = templateFilePath.endsWith('.ejs')
@@ -78,13 +77,13 @@ export default async function generate({ isEnsuringClient = false, projectInfo,
                 : { data: { imports: [] }, content: templateContent };
             const clientImports = await getTemplateClientImports({
                 config,
-                segments,
+                fullSchema,
                 outCwdRelativeDir,
             });
             const packageJson = await mergePackages({
                 cwd,
                 config,
-                packages: [config.fullClient.package, templateDef.fullClient?.package],
+                packages: [config.composedClient.package, templateDef.composedClient?.package],
             });
             const { written } = await writeOneClientFile({
                 cwd,
@@ -93,7 +92,7 @@ export default async function generate({ isEnsuringClient = false, projectInfo,
                 fullSchema: pickSegmentFullSchema(fullSchema, segmentNames),
                 prettifyClient: config.prettifyClient,
                 segmentName: null,
-                imports: clientImports.fullClient,
+                imports: clientImports.composedClient,
                 templateContent,
                 matterResult,
                 package: packageJson,
@@ -101,6 +100,7 @@ export default async function generate({ isEnsuringClient = false, projectInfo,
                 outCwdRelativeDir,
                 origin: config.origin ?? templateDef?.origin ?? null,
                 templateDef,
+                locatedSegments,
             });
             const outAbsoluteDir = path.join(cwd, outCwdRelativeDir);
             return {
@@ -109,24 +109,24 @@ export default async function generate({ isEnsuringClient = false, projectInfo,
                 outAbsoluteDir,
             };
         }));
-        if (fullClientTemplateFiles.length) {
+        if (composedClientTemplateFiles.length) {
             logClientGenerationResults({
-                results: fullClientResults,
+                results: composedClientResults,
                 log,
                 isEnsuringClient,
                 forceNothingWrittenLog,
-                clientType: 'Full',
+                clientType: 'Composed',
                 startTime: now,
                 fromTemplates,
             });
         }
         else {
-            log.warn('No full client template files found. Skipping full client generation.');
+            log.warn('No composed client template files found. Skipping composed client generation.');
         }
     }
-    if (config.segmentedClient.enabled) {
+    if (isSegmentedEnabled) {
         const now = Date.now();
-        const segmentNames = getIncludedSegmentNames(config, segments, 'segmentedClient');
+        const segmentNames = getIncludedSegmentNames(config, fullSchema, 'segmentedClient', cliGenerateOptions);
         const { templateFiles: segmentedClientTemplateFiles, fromTemplates } = await getClientTemplateFiles({
             config,
             cwd,
@@ -143,7 +143,7 @@ export default async function generate({ isEnsuringClient = false, projectInfo,
             const results = await Promise.all(segmentNames.map(async (segmentName) => {
                 const clientImports = await getTemplateClientImports({
                     config,
-                    segments,
+                    fullSchema,
                     outCwdRelativeDir,
                 });
                 const packageJson = await mergePackages({
@@ -169,6 +169,7 @@ export default async function generate({ isEnsuringClient = false, projectInfo,
                     outCwdRelativeDir,
                     origin: config.origin ?? templateDef?.origin ?? null,
                     templateDef,
+                    locatedSegments,
                 });
                 return {
                     written,

package/dist/generate/mergePackages.mjs

@@ -36,10 +36,10 @@ export default async function mergePackages({ cwd, packages, }) {
                 import: './index.mjs',
                 require: './index.cjs',
             },
-            './fullSchema': {
-                import: './fullSchema.cjs',
-                require: './fullSchema.cjs',
-                types: './fullSchema.d.cts',
+            './schema': {
+                import: './schema.cjs',
+                require: './schema.cjs',
+                types: './schema.d.cts',
             },
         },
     };

package/dist/generate/writeOneClientFile.d.mts

@@ -1,13 +1,14 @@
-import type { VovkFullSchema, VovkStrictConfig } from 'vovk';
+import { type VovkSchema, type VovkStrictConfig } from 'vovk';
 import type { ProjectInfo } from '../getProjectInfo/index.mjs';
 import type { ClientTemplateFile } from './getClientTemplateFiles.mjs';
 import type { ClientImports } from './getTemplateClientImports.mjs';
 import type { PackageJson } from 'type-fest';
-export default function writeOneClientFile({ cwd, projectInfo, clientTemplateFile, fullSchema, prettifyClient, segmentName, imports, templateContent, matterResult: { data, content }, package: packageJson, isEnsuringClient, outCwdRelativeDir, origin, templateDef, }: {
+import type { Segment } from '../locateSegments.mjs';
+export default function writeOneClientFile({ cwd, projectInfo, clientTemplateFile, fullSchema, prettifyClient, segmentName, imports, templateContent, matterResult: { data, content }, package: packageJson, isEnsuringClient, outCwdRelativeDir, origin, templateDef, locatedSegments, }: {
     cwd: string;
     projectInfo: ProjectInfo;
     clientTemplateFile: ClientTemplateFile;
-    fullSchema: VovkFullSchema;
+    fullSchema: VovkSchema;
     prettifyClient: boolean;
     segmentName: string | null;
     imports: ClientImports;
@@ -23,6 +24,7 @@ export default function writeOneClientFile({ cwd, projectInfo, clientTemplateFil
     outCwdRelativeDir: string;
     origin: string | null;
     templateDef: VovkStrictConfig['clientTemplateDefs'][string];
+    locatedSegments: Segment[];
 }): Promise<{
     written: boolean;
 }>;

package/dist/generate/writeOneClientFile.mjs

@@ -1,13 +1,14 @@
 import fs from 'fs/promises';
 import path from 'node:path';
 import ejs from 'ejs';
-import _ from 'lodash';
+import _, { keyBy } from 'lodash';
+import { VovkSchemaIdEnum } from 'vovk';
 import prettify from '../utils/prettify.mjs';
 import { ROOT_SEGMENT_SCHEMA_NAME, SEGMENTS_SCHEMA_DIR_NAME } from '../dev/writeOneSegmentSchemaFile.mjs';
-import { SchemaIdEnum } from '../enums.mjs';
-export default async function writeOneClientFile({ cwd, projectInfo, clientTemplateFile, fullSchema, prettifyClient, segmentName, imports, templateContent, matterResult: { data, content }, package: packageJson, isEnsuringClient, outCwdRelativeDir, origin, templateDef, }) {
-    const { config, apiRoot, segments } = projectInfo;
+export default async function writeOneClientFile({ cwd, projectInfo, clientTemplateFile, fullSchema, prettifyClient, segmentName, imports, templateContent, matterResult: { data, content }, package: packageJson, isEnsuringClient, outCwdRelativeDir, origin, templateDef, locatedSegments, }) {
+    const { config, apiRoot } = projectInfo;
     const { templateFilePath, relativeDir } = clientTemplateFile;
+    const locatedSegmentsByName = keyBy(locatedSegments, 'segmentName');
     const outPath = path.resolve(cwd, outCwdRelativeDir, typeof segmentName === 'string' ? segmentName || ROOT_SEGMENT_SCHEMA_NAME : '', relativeDir.replace('[package_name]', packageJson.name ?? 'my-package-name'), path.basename(templateFilePath).replace('.ejs', ''));
     let placeholder = `// This is a temporary placeholder to avoid compilation errors if client is imported before it's generated.
 // If you still see this text, the client is not generated yet because of an unknown problem.
@@ -21,13 +22,16 @@ export default async function writeOneClientFile({ cwd, projectInfo, clientTempl
         SEGMENTS_SCHEMA_DIR_NAME,
         apiRoot: origin ? `${origin}/${config.rootEntry}` : apiRoot,
         imports,
-        fullSchema,
-        SchemaIdEnum,
+        schema: fullSchema,
+        VovkSchemaIdEnum,
         schemaOutDir: typeof segmentName === 'string'
             ? path.relative(path.join(outCwdRelativeDir, segmentName || ROOT_SEGMENT_SCHEMA_NAME), config.schemaOutDir)
             : path.relative(outCwdRelativeDir, config.schemaOutDir),
-        segmentMeta: Object.fromEntries(segments.map(({ segmentName: sName, routeFilePath }) => {
-            const segmentImportPath = path.relative(path.resolve(cwd, outCwdRelativeDir, typeof segmentName === 'string' ? segmentName || ROOT_SEGMENT_SCHEMA_NAME : '.'), path.resolve(cwd, routeFilePath));
+        segmentMeta: Object.fromEntries(Object.values(fullSchema.segments).map(({ segmentName: sName }) => {
+            const { routeFilePath = null } = locatedSegmentsByName[sName] ?? {};
+            const segmentImportPath = routeFilePath
+                ? path.relative(path.resolve(cwd, outCwdRelativeDir, typeof segmentName === 'string' ? segmentName || ROOT_SEGMENT_SCHEMA_NAME : '.'), path.resolve(cwd, routeFilePath))
+                : null;
             const { origin: configOrigin, rootEntry: configRootEntry } = {
                 ...(config.segmentConfig ? config.segmentConfig[sName] : {}),
                 ...(templateDef.segmentConfig ? templateDef.segmentConfig[sName] : {}),

package/dist/getProjectInfo/{getRelativeSrcRoot.d.mts → getConfig/getRelativeSrcRoot.d.mts}

@@ -1,3 +1,3 @@
 export default function getRelativeSrcRoot({ cwd }: {
     cwd: string;
-}): Promise<"." | "./src">;
+}): Promise<"." | "./src" | null>;

package/dist/getProjectInfo/{getRelativeSrcRoot.mjs → getConfig/getRelativeSrcRoot.mjs}

@@ -1,5 +1,5 @@
 import path from 'node:path';
-import getFileSystemEntryType, { FileSystemEntryType } from '../utils/getFileSystemEntryType.mjs';
+import getFileSystemEntryType, { FileSystemEntryType } from '../../utils/getFileSystemEntryType.mjs';
 export default async function getRelativeSrcRoot({ cwd }) {
     // Next.js Docs: src/app or src/pages will be ignored if app or pages are present in the root directory.
     if ((await getFileSystemEntryType(path.join(cwd, 'app'))) === FileSystemEntryType.DIRECTORY) {
@@ -8,5 +8,5 @@ export default async function getRelativeSrcRoot({ cwd }) {
     else if ((await getFileSystemEntryType(path.join(cwd, 'src/app'))) === FileSystemEntryType.DIRECTORY) {
         return './src';
     }
-    throw new Error(`${cwd} Could not find app router directory. Check Next.js docs for more info.`);
+    return null;
 }

package/dist/getProjectInfo/getConfig/getTemplateDefs.d.mts

@@ -3,9 +3,9 @@ export declare enum BuiltInTemplateName {
     ts = "ts",
     cjs = "cjs",
     mjs = "mjs",
-    fullSchemaTs = "fullSchemaTs",
-    fullSchemaCjs = "fullSchemaCjs",
-    fullSchemaJson = "fullSchemaJson",
+    schemaTs = "schemaTs",
+    schemaCjs = "schemaCjs",
+    schemaJson = "schemaJson",
     readme = "readme",
     packageJson = "packageJson",
     rs = "rs",

package/dist/getProjectInfo/getConfig/getTemplateDefs.mjs

@@ -1,4 +1,3 @@
-import path from 'node:path';
 export var BuiltInTemplateName;
 (function (BuiltInTemplateName) {
     // ts/js
@@ -6,31 +5,30 @@ export var BuiltInTemplateName;
     BuiltInTemplateName["cjs"] = "cjs";
     BuiltInTemplateName["mjs"] = "mjs";
     // schema
-    BuiltInTemplateName["fullSchemaTs"] = "fullSchemaTs";
-    BuiltInTemplateName["fullSchemaCjs"] = "fullSchemaCjs";
-    BuiltInTemplateName["fullSchemaJson"] = "fullSchemaJson";
+    BuiltInTemplateName["schemaTs"] = "schemaTs";
+    BuiltInTemplateName["schemaCjs"] = "schemaCjs";
+    BuiltInTemplateName["schemaJson"] = "schemaJson";
     // misc
     BuiltInTemplateName["readme"] = "readme";
     BuiltInTemplateName["packageJson"] = "packageJson";
-    // other languages
+    // other languages (packages installed separately)
     BuiltInTemplateName["rs"] = "rs";
     BuiltInTemplateName["py"] = "py";
 })(BuiltInTemplateName || (BuiltInTemplateName = {}));
-const templatesDir = path.join(import.meta.dirname, '../../..', 'client-templates');
 export default function getTemplateDefs(userTemplateDefs = {}) {
     const defs = {};
     const builtInDefs = {
         [BuiltInTemplateName.ts]: {
             templatePath: `vovk-cli/client-templates/${BuiltInTemplateName.ts}/`,
-            requires: { [BuiltInTemplateName.fullSchemaTs]: '.' },
+            requires: { [BuiltInTemplateName.schemaTs]: '.' },
         },
         [BuiltInTemplateName.cjs]: {
             templatePath: `vovk-cli/client-templates/${BuiltInTemplateName.cjs}/`,
-            requires: { [BuiltInTemplateName.fullSchemaCjs]: '.' },
+            requires: { [BuiltInTemplateName.schemaCjs]: '.' },
         },
         [BuiltInTemplateName.mjs]: {
             templatePath: `vovk-cli/client-templates/${BuiltInTemplateName.mjs}/`,
-            requires: { [BuiltInTemplateName.fullSchemaCjs]: '.' },
+            requires: { [BuiltInTemplateName.schemaCjs]: '.' },
         },
         [BuiltInTemplateName.readme]: {
             templatePath: `vovk-cli/client-templates/${BuiltInTemplateName.readme}/`,
@@ -38,31 +36,31 @@ export default function getTemplateDefs(userTemplateDefs = {}) {
         [BuiltInTemplateName.packageJson]: {
             templatePath: `vovk-cli/client-templates/${BuiltInTemplateName.packageJson}/`,
         },
-        [BuiltInTemplateName.fullSchemaTs]: {
-            templatePath: `vovk-cli/client-templates/${BuiltInTemplateName.fullSchemaTs}/`,
+        [BuiltInTemplateName.schemaTs]: {
+            templatePath: `vovk-cli/client-templates/${BuiltInTemplateName.schemaTs}/`,
         },
-        [BuiltInTemplateName.fullSchemaCjs]: {
-            templatePath: `vovk-cli/client-templates/${BuiltInTemplateName.fullSchemaCjs}/`,
+        [BuiltInTemplateName.schemaCjs]: {
+            templatePath: `vovk-cli/client-templates/${BuiltInTemplateName.schemaCjs}/`,
         },
-        [BuiltInTemplateName.fullSchemaJson]: {
-            templatePath: `vovk-cli/client-templates/${BuiltInTemplateName.fullSchemaJson}/`,
+        [BuiltInTemplateName.schemaJson]: {
+            templatePath: `vovk-cli/client-templates/${BuiltInTemplateName.schemaJson}/`,
         },
         [BuiltInTemplateName.rs]: {
             templatePath: 'vovk-rust-client/template/',
-            fullClient: {
+            composedClient: {
                 outDir: 'dist_rust',
             },
             requires: {
-                fullSchemaJson: './data',
+                schemaJson: './data',
             },
         },
         [BuiltInTemplateName.py]: {
             templatePath: 'vovk-python-client/template/',
-            fullClient: {
+            composedClient: {
                 outDir: 'dist_python',
             },
             requires: {
-                fullSchemaJson: './data',
+                schemaJson: './data',
             },
         },
     };

package/dist/getProjectInfo/{getUserConfig.mjs → getConfig/getUserConfig.mjs}

@@ -5,7 +5,7 @@ async function getUserConfig({ configPath: givenConfigPath, cwd, }) {
     const configAbsolutePaths = await getConfigAbsolutePaths({ configPath: givenConfigPath, cwd });
     let userConfig;
     if (!configAbsolutePaths.length) {
-        return { userConfig: null, configAbsolutePaths, error: new Error('No config file found') };
+        return { userConfig: null, configAbsolutePaths };
     }
     const configPath = configAbsolutePaths[0];
     // TODO explain

package/dist/getProjectInfo/getConfig/index.d.mts

@@ -1,15 +1,12 @@
-import type { VovkStrictConfig } from 'vovk';
-import type { BundleOptions, GenerateOptions } from '../../types.mjs';
-export default function getConfig({ cliGenerateOptions, cliBundleOptions, cwd, }: {
-    cliGenerateOptions?: GenerateOptions;
-    cliBundleOptions?: BundleOptions;
+import { type VovkStrictConfig } from 'vovk';
+export default function getConfig({ configPath, cwd }: {
+    configPath?: string;
     cwd: string;
 }): Promise<{
     config: VovkStrictConfig;
-    srcRoot: string;
+    srcRoot: string | null;
     configAbsolutePaths: string[];
     userConfig: import("vovk").VovkConfig | null;
-    error: Error | undefined;
     log: {
         info: (msg: string) => void;
         warn: (msg: string) => void;

package/dist/getProjectInfo/getConfig/index.mjs

@@ -1,22 +1,21 @@
 import path from 'node:path';
-import camelCase from 'lodash/camelCase.js';
+import { VovkSchemaIdEnum } from 'vovk';
 import getLogger from '../../utils/getLogger.mjs';
-import getUserConfig from '../getUserConfig.mjs';
-import getRelativeSrcRoot from '../getRelativeSrcRoot.mjs';
+import getUserConfig from './getUserConfig.mjs';
+import getRelativeSrcRoot from './getRelativeSrcRoot.mjs';
 import getTemplateDefs, { BuiltInTemplateName } from './getTemplateDefs.mjs';
-import { SchemaIdEnum } from '../../enums.mjs';
-export default async function getConfig({ cliGenerateOptions, cliBundleOptions, cwd, }) {
+export default async function getConfig({ configPath, cwd }) {
     const { configAbsolutePaths, error, userConfig } = await getUserConfig({
-        configPath: cliGenerateOptions?.config,
+        configPath,
         cwd,
     });
     const conf = userConfig ?? {};
     const env = process.env;
     const clientTemplateDefs = getTemplateDefs(conf.clientTemplateDefs);
     const srcRoot = await getRelativeSrcRoot({ cwd });
-    const validateOnClientImport = env.VOVK_IMPORTS_VALIDATE_ON_CLIENT ?? conf.imports?.validateOnClient ?? null;
-    const fetcherImport = env.VOVK_IMPORTS_FETCHER ?? conf.imports?.fetcher ?? 'vovk';
-    const createRPCImport = env.VOVK_IMPORTS_CREATE_RPC ?? conf.imports?.createRPC ?? 'vovk';
+    const validateOnClientImport = conf.imports?.validateOnClient ?? null;
+    const fetcherImport = conf.imports?.fetcher ?? 'vovk';
+    const createRPCImport = conf.imports?.createRPC ?? 'vovk';
     const imports = {
         fetcher: typeof fetcherImport === 'string' ? [fetcherImport] : fetcherImport,
         validateOnClient: typeof validateOnClientImport === 'string'
@@ -25,39 +24,38 @@ export default async function getConfig({ cliGenerateOptions, cliBundleOptions,
         createRPC: typeof createRPCImport === 'string' ? [createRPCImport] : createRPCImport,
     };
     const config = {
-        $schema: SchemaIdEnum.CONFIG,
+        $schema: VovkSchemaIdEnum.CONFIG,
         clientTemplateDefs,
         imports,
         emitConfig: [],
-        fullClient: {
-            enabled: !cliGenerateOptions?.segmentedOnly || !!cliGenerateOptions?.fullFrom || !!cliGenerateOptions?.fullOut,
-            ...conf.fullClient,
-            fromTemplates: cliGenerateOptions?.fullFrom ?? conf.fullClient?.fromTemplates ?? ['mjs', 'cjs'],
-            outDir: cliGenerateOptions?.fullOut ?? conf.fullClient?.outDir ?? './node_modules/.vovk-client',
+        composedClient: {
+            ...conf.composedClient,
+            enabled: conf.composedClient?.enabled ?? true,
+            fromTemplates: conf.composedClient?.fromTemplates ?? ['mjs', 'cjs'],
+            outDir: conf.composedClient?.outDir ?? './node_modules/.vovk-client',
         },
         segmentedClient: {
-            enabled: !!cliGenerateOptions?.segmentedOnly ||
-                !!cliGenerateOptions?.segmentedFrom ||
-                !!cliGenerateOptions?.segmentedOut,
             ...conf.segmentedClient,
-            fromTemplates: cliGenerateOptions?.segmentedFrom ?? conf.segmentedClient?.fromTemplates ?? ['ts'],
-            outDir: cliGenerateOptions?.segmentedOut ?? conf.segmentedClient?.outDir ?? path.join(srcRoot, 'client'),
+            enabled: conf.segmentedClient?.enabled ?? false,
+            fromTemplates: conf.segmentedClient?.fromTemplates ?? ['ts'],
+            outDir: conf.segmentedClient?.outDir ?? path.join(srcRoot ?? '.', 'client'),
         },
         bundle: {
-            outDir: cliBundleOptions?.outDir ?? conf.bundle?.outDir ?? 'dist',
-            tsClientOutDir: cliBundleOptions?.tsClientOutDir ?? conf.bundle?.tsClientOutDir ?? '.tmp-ts-rpc',
-            dontDeleteTsClientOutDirAfter: cliBundleOptions?.dontDeleteTsClientOutDirAfter ?? conf.bundle?.dontDeleteTsClientOutDirAfter ?? false,
-            sourcemap: cliBundleOptions?.sourcemap ?? conf.bundle?.sourcemap ?? false,
+            ...conf.bundle,
+            outDir: conf.bundle?.outDir ?? 'dist',
+            tsClientOutDir: conf.bundle?.tsClientOutDir ?? 'tmp_ts_rpc',
+            dontDeleteTsClientOutDirAfter: conf.bundle?.dontDeleteTsClientOutDirAfter ?? false,
+            sourcemap: conf.bundle?.sourcemap ?? false,
             requires: {
                 [BuiltInTemplateName.readme]: '.',
                 [BuiltInTemplateName.packageJson]: '.',
             },
         },
-        modulesDir: env.VOVK_MODULES_DIR ?? conf.modulesDir ?? './' + [srcRoot, 'modules'].filter(Boolean).join('/'),
+        modulesDir: conf.modulesDir ?? path.join(srcRoot ?? '.', 'modules'),
         schemaOutDir: env.VOVK_SCHEMA_OUT_DIR ?? conf.schemaOutDir ?? './.vovk-schema',
         origin: (env.VOVK_ORIGIN ?? conf.origin ?? '').replace(/\/$/, ''), // Remove trailing slash
         rootEntry: env.VOVK_ROOT_ENTRY ?? conf.rootEntry ?? 'api',
-        rootSegmentModulesDirName: env.VOVK_ROOT_SEGMENT_MODULES_DIR_NAME ?? conf.rootSegmentModulesDirName ?? '',
+        rootSegmentModulesDirName: conf.rootSegmentModulesDirName ?? '',
         logLevel: env.VOVK_LOG_LEVEL ?? conf.logLevel ?? 'info',
         prettifyClient: (env.VOVK_PRETTIFY_CLIENT ? !!env.VOVK_PRETTIFY_CLIENT : null) ?? conf.prettifyClient ?? false,
         devHttps: (env.VOVK_DEV_HTTPS ? !!env.VOVK_DEV_HTTPS : null) ?? conf.devHttps ?? false,
@@ -70,7 +68,7 @@ export default async function getConfig({ cliGenerateOptions, cliBundleOptions,
         segmentConfig: {},
     };
     if (typeof conf.emitConfig === 'undefined') {
-        config.emitConfig = ['libs', '$schema'];
+        config.emitConfig = ['$schema', 'libs'];
     }
     else if (conf.emitConfig === true) {
         config.emitConfig = Object.keys(config);
@@ -79,42 +77,7 @@ export default async function getConfig({ cliGenerateOptions, cliBundleOptions,
         config.emitConfig = conf.emitConfig;
     } // else it's false and emitConfig already is []
     const log = getLogger(config.logLevel);
-    for (const [envKey, envValue] of Object.entries(env)) {
-        if (envKey.startsWith('VOVK_')) {
-            const pathArr = envKey
-                .replace(/^VOVK_/, '')
-                .split('__')
-                .map(camelCase);
-            // Parse value
-            let value = envValue;
-            if (envValue === 'null') {
-                value = null;
-            }
-            else if (envValue === 'true') {
-                value = true;
-            }
-            else if (envValue === 'false') {
-                value = false;
-            }
-            else if (typeof envValue === 'string' && envValue.startsWith('[') && envValue.endsWith(']')) {
-                value = envValue
-                    .slice(1, -1)
-                    .split(',')
-                    .map((s) => s.trim())
-                    .filter(Boolean);
-            }
-            // Set value in config at the given path
-            let target = config;
-            for (let i = 0; i < pathArr.length - 1; i++) {
-                const key = pathArr[i];
-                if (typeof target[key] !== 'object' || target[key] === null) {
-                    target[key] = {};
-                }
-                target = target[key];
-            }
-            target[pathArr[pathArr.length - 1]] = value;
-            log.debug(`Set config.${pathArr.join('.')} from env ${envKey}=${envValue}`);
-        }
-    }
-    return { config, srcRoot, configAbsolutePaths, userConfig, error, log };
+    if (error)
+        log.error(`Error reading config: ${String(error)}`);
+    return { config, srcRoot, configAbsolutePaths, userConfig, log };
 }