vovk-cli 0.0.1-draft.333 → 0.0.1-draft.335

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

@@ -3,13 +3,13 @@
 
 # <%= t.package.name %> v<%= t.package.version %> [![TypeScript](https://badgen.net/badge/-/TypeScript?icon=typescript&label&labelColor=blue&color=555555)](https://www.typescriptlang.org/) [![Vovk.ts](https://badgen.net/badge/Built%20with/Vovk.ts/333333?icon=https://vovk.dev/icon-white.svg)](https://vovk.dev)
 
-<%- t.package.description ? `> ${t.package.description}` : '' %>
+<%- t.readme.description ?? (`${t.package.description ? `> ${t.package.description}` : ''}`) %>
 
 <%- t.package.license ? `License: **${t.package.license}**` : '' %>
 
 ```bash
 # Install the package
-npm install <%= t.package.name %>
+<%= t.readme.installCommand ?? `npm install ${t.package.name}` %>
 ```
 
 <% Object.entries(t.schema.segments).forEach(([segmentName, segment]) => {
@@ -31,6 +31,7 @@ npm install <%= t.package.name %>
     handlerName,
     controllerSchema,
     package: t.package,
+    config: t.snippets,
 }).ts %>
 ```
         <% }) %>

package/client-templates/schemaCjs/schema.cjs.ejs

@@ -16,10 +16,7 @@ const schema = {
   $schema: '<%- t.VovkSchemaIdEnum.SCHEMA %>',
   segments,
   meta: {
-    apiRoot: '<%= t.apiRoot %>', // for debugging purposes
-    <% if(t.isVovkProject) { %>
-    ...meta
-    <% } %>
+    <% if(t.isVovkProject) { %>...meta<% } %>
   }
 };
 

package/client-templates/schemaTs/schema.ts.ejs

@@ -22,11 +22,7 @@ export const schema = {
   $schema: '<%- t.VovkSchemaIdEnum.SCHEMA %>',
   segments,
   meta: {
-    $schema: '<%- t.VovkSchemaIdEnum.META %>',
-    apiRoot: '<%= t.apiRoot %>', // for debugging purposes
-    <% if(t.isVovkProject) { %>
-    ...meta,
-    <% } %>
+    <% if(t.isVovkProject) { %>...meta,<% } %>
   }
 };
 

package/dist/bundle/index.mjs

@@ -17,9 +17,11 @@ export async function bundle({ projectInfo, fullSchema, cliBundleOptions, }) {
         throw new Error('No output directory specified for composed client');
     }
     const outDir = cliBundleOptions?.outDir ?? bundleConfig.tsdownBuildOptions.outDir;
+    const tsconfig = cliBundleOptions?.tsconfig ?? bundleConfig.tsdownBuildOptions.tsconfig;
     if (!outDir) {
         throw new Error('No output directory specified for bundling');
     }
+    const outDirAbsolute = path.resolve(cwd, outDir);
     await generate({
         isEnsuringClient: false,
         isBundle: true,
@@ -27,10 +29,8 @@ export async function bundle({ projectInfo, fullSchema, cliBundleOptions, }) {
         forceNothingWrittenLog: true,
         fullSchema,
         locatedSegments,
-        package: bundleConfig.package,
-        readme: bundleConfig.readme,
         cliGenerateOptions: {
-            origin: cliBundleOptions?.origin ?? bundleConfig.origin,
+            origin: cliBundleOptions?.origin,
             openapiSpec: cliBundleOptions?.openapiSpec,
             openapiGetModuleName: cliBundleOptions?.openapiGetModuleName,
             openapiGetMethodName: cliBundleOptions?.openapiGetMethodName,
@@ -47,18 +47,20 @@ export async function bundle({ projectInfo, fullSchema, cliBundleOptions, }) {
         dts: true,
         format: ['cjs', 'esm'],
         fixedExtension: true,
-        outDir,
+        clean: true,
         ...bundleConfig.tsdownBuildOptions,
+        outDir: outDirAbsolute,
+        tsconfig,
     });
-    const outDirAbsolute = path.resolve(cwd, outDir);
     log.debug(`Bundled index.ts to ${chalkHighlightThing(outDirAbsolute)}`);
     await build({
         entry: path.join(tsFullClientOutAbsoluteDirInput, './schema.ts'),
         dts: true,
         format: ['cjs'],
         fixedExtension: true,
-        outDir,
+        outDir: outDirAbsolute,
         clean: false,
+        tsconfig,
     });
     log.debug(`Bundled schema.ts to ${chalkHighlightThing(outDirAbsolute)}`);
     const requiresGroup = groupBy(Object.entries(bundleConfig.requires), ([, relativePath]) => relativePath);
@@ -69,12 +71,10 @@ export async function bundle({ projectInfo, fullSchema, cliBundleOptions, }) {
             forceNothingWrittenLog: true,
             fullSchema,
             locatedSegments,
-            package: bundleConfig.package,
-            readme: bundleConfig.readme,
             cliGenerateOptions: {
-                origin: cliBundleOptions?.origin ?? bundleConfig.origin,
+                origin: cliBundleOptions?.origin,
                 composedFrom: group.map(([templateName]) => templateName),
-                composedOut: path.resolve(outDir, relativePath),
+                composedOut: path.resolve(outDirAbsolute, relativePath),
                 composedOnly: true,
             },
         });

package/dist/dev/ensureSchemaFiles.d.mts

@@ -2,5 +2,5 @@ import { ProjectInfo } from '../getProjectInfo/index.mjs';
 /**
  * Ensure that the schema files are created to avoid any import errors.
  */
-export default function ensureSchemaFiles(projectInfo: ProjectInfo | null, schemaOutAbsolutePath: string, segmentNames: string[]): Promise<void>;
+export default function ensureSchemaFiles(projectInfo: ProjectInfo, schemaOutAbsolutePath: string, segmentNames: string[]): Promise<void>;
 export declare const debouncedEnsureSchemaFiles: import("lodash").DebouncedFunc<typeof ensureSchemaFiles>;

package/dist/dev/index.d.mts

@@ -1,7 +1,7 @@
 import type { DevOptions } from '../types.mjs';
 export declare class VovkDev {
     #private;
-    constructor({ schemaOut, devHttps }: Pick<DevOptions, 'schemaOut' | 'devHttps'>);
+    constructor({ schemaOut, devHttps, logLevel }: Pick<DevOptions, 'schemaOut' | 'devHttps' | 'logLevel'>);
     start({ exit }: {
         exit: boolean;
     }): Promise<void>;

package/dist/dev/index.mjs

@@ -19,28 +19,22 @@ import debounceWithArgs from '../utils/debounceWithArgs.mjs';
 import formatLoggedSegmentName from '../utils/formatLoggedSegmentName.mjs';
 import writeMetaJson from './writeMetaJson.mjs';
 import chalkHighlightThing from '../utils/chalkHighlightThing.mjs';
+import getMetaSchema from '../getProjectInfo/getMetaSchema.mjs';
 export class VovkDev {
     #projectInfo;
     #segments = [];
-    #fullSchema = {
-        $schema: VovkSchemaIdEnum.SCHEMA,
-        segments: {},
-        meta: {
-            $schema: VovkSchemaIdEnum.META,
-            config: {
-                $schema: VovkSchemaIdEnum.CONFIG,
-            },
-        },
-    };
+    #schemaSegments = {};
     #isWatching = false;
     #modulesWatcher = null;
     #segmentWatcher = null;
     #onFirstTimeGenerate = null;
     #schemaOut = null;
     #devHttps;
-    constructor({ schemaOut, devHttps }) {
-        this.#schemaOut = schemaOut ?? null;
-        this.#devHttps = devHttps ?? false;
+    #logLevel;
+    constructor({ schemaOut, devHttps, logLevel }) {
+        this.#schemaOut = schemaOut || null;
+        this.#devHttps = devHttps || false;
+        this.#logLevel = logLevel || 'info';
     }
     #watchSegments = (callback) => {
         const segmentReg = /\/?\[\[\.\.\.[a-zA-Z-_]+\]\]\/route.ts$/;
@@ -165,7 +159,7 @@ export class VovkDev {
         let isInitial = true;
         let isReady = false;
         const handle = debounce(async () => {
-            this.#projectInfo = await getProjectInfo();
+            this.#projectInfo = await getProjectInfo({ logLevel: this.#logLevel });
             const { config, apiDirAbsolutePath } = this.#projectInfo;
             this.#segments = await locateSegments({ dir: apiDirAbsolutePath, config, log });
             await this.#modulesWatcher?.close();
@@ -233,7 +227,7 @@ 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 segmentSchema = this.#fullSchema.segments[s.segmentName];
+                const segmentSchema = this.#schemaSegments[s.segmentName];
                 if (!segmentSchema)
                     return false;
                 const controllersByOriginalName = keyBy(segmentSchema.controllers, 'originalControllerName');
@@ -285,7 +279,21 @@ export class VovkDev {
         }
         return { isError: false };
     }, 500);
-    #generate = debounce(() => generate({ projectInfo: this.#projectInfo, fullSchema: this.#fullSchema, locatedSegments: this.#segments }).then(this.#onFirstTimeGenerate), 1000);
+    #generate = debounce(() => {
+        const fullSchema = {
+            $schema: VovkSchemaIdEnum.SCHEMA,
+            segments: this.#schemaSegments,
+            meta: getMetaSchema({
+                config: this.#projectInfo.config,
+                package: this.#projectInfo.packageJson,
+            }),
+        };
+        return generate({
+            projectInfo: this.#projectInfo,
+            fullSchema,
+            locatedSegments: this.#segments,
+        }).then(this.#onFirstTimeGenerate);
+    }, 1000);
     async #handleSegmentSchema(segmentName, segmentSchema) {
         const { log, config, cwd } = this.#projectInfo;
         if (!segmentSchema) {
@@ -299,7 +307,7 @@ export class VovkDev {
             log.warn(`${formatLoggedSegmentName(segmentName)} not found`);
             return;
         }
-        this.#fullSchema.segments[segmentName] = segmentSchema;
+        this.#schemaSegments[segmentName] = segmentSchema;
         if (segmentSchema.emitSchema) {
             const now = Date.now();
             const { diffResult } = await writeOneSegmentSchemaFile({
@@ -316,14 +324,14 @@ export class VovkDev {
         else if (segmentSchema && !isEmpty(segmentSchema.controllers)) {
             log.error(`Non-empty schema provided for ${formatLoggedSegmentName(segment.segmentName)} but "emitSchema" is false`);
         }
-        if (this.#segments.every((s) => this.#fullSchema.segments[s.segmentName])) {
+        if (this.#segments.every((s) => this.#schemaSegments[s.segmentName])) {
             log.debug(`All segments with "emitSchema" have schema.`);
             this.#generate();
         }
     }
     async start({ exit }) {
         const now = Date.now();
-        this.#projectInfo = await getProjectInfo();
+        this.#projectInfo = await getProjectInfo({ logLevel: this.#logLevel });
         const { log, config, cwd, apiDirAbsolutePath } = this.#projectInfo;
         this.#segments = await locateSegments({ dir: apiDirAbsolutePath, config, log });
         log.info('Starting...');
@@ -392,6 +400,7 @@ if (env.__VOVK_START_WATCHER_IN_STANDALONE_MODE__ === 'true') {
     void new VovkDev({
         schemaOut: env.__VOVK_SCHEMA_OUT_FLAG__ || undefined,
         devHttps: env.__VOVK_DEV_HTTPS_FLAG__ === 'true',
+        logLevel: env.__VOVK_LOG_LEVEL__,
     }).start({
         exit: env.__VOVK_EXIT__ === 'true',
     });

package/dist/dev/writeMetaJson.d.mts

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

package/dist/dev/writeMetaJson.mjs

@@ -1,11 +1,14 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
-import pick from 'lodash/pick.js';
 import { META_FILE_NAME } from './writeOneSegmentSchemaFile.mjs';
 import chalkHighlightThing from '../utils/chalkHighlightThing.mjs';
+import getMetaSchema from '../getProjectInfo/getMetaSchema.mjs';
 export default async function writeMetaJson(schemaOutAbsolutePath, projectInfo) {
     const metaJsonPath = path.join(schemaOutAbsolutePath, META_FILE_NAME + '.json');
-    const metaStr = JSON.stringify({ config: projectInfo ? pick(projectInfo.config, [...projectInfo.config.emitConfig, '$schema']) : {} }, null, 2);
+    const metaStr = JSON.stringify(getMetaSchema({
+        config: projectInfo.config,
+        package: projectInfo.packageJson,
+    }), null, 2);
     const existingStr = await fs.readFile(metaJsonPath, 'utf-8').catch(() => null);
     if (existingStr !== metaStr) {
         await fs.writeFile(metaJsonPath, metaStr);

package/dist/generate/generate.d.mts

@@ -1,9 +1,8 @@
-import { type VovkSchema, type VovkStrictConfig } from 'vovk';
-import type { PackageJson } from 'type-fest';
+import { type VovkSchema } from 'vovk';
 import type { ProjectInfo } from '../getProjectInfo/index.mjs';
 import type { GenerateOptions } from '../types.mjs';
 import type { Segment } from '../locateSegments.mjs';
-export declare function generate({ isEnsuringClient, isBundle, projectInfo, forceNothingWrittenLog, fullSchema, locatedSegments, cliGenerateOptions, package: argPackageJson, readme: argReadme, }: {
+export declare function generate({ isEnsuringClient, isBundle, projectInfo, forceNothingWrittenLog, fullSchema, locatedSegments, cliGenerateOptions, }: {
     isEnsuringClient?: boolean;
     isBundle?: boolean;
     projectInfo: ProjectInfo;
@@ -11,6 +10,4 @@ export declare function generate({ isEnsuringClient, isBundle, projectInfo, forc
     fullSchema: VovkSchema;
     locatedSegments: Segment[];
     cliGenerateOptions?: GenerateOptions;
-    package?: PackageJson;
-    readme?: VovkStrictConfig['bundle']['readme'];
 }): Promise<void>;

package/dist/generate/generate.mjs

@@ -2,17 +2,16 @@ import path from 'node:path';
 import fs from 'node:fs/promises';
 import matter from 'gray-matter';
 import _ from 'lodash';
-import { openAPIToVovkSchema } from 'vovk';
+import { getGeneratorConfig, openAPIToVovkSchema, } from 'vovk';
 import getClientTemplateFiles from './getClientTemplateFiles.mjs';
 import chalkHighlightThing from '../utils/chalkHighlightThing.mjs';
 import pickSegmentFullSchema from '../utils/pickSegmentFullSchema.mjs';
 import removeUnlistedDirectories from '../utils/removeUnlistedDirectories.mjs';
 import getTemplateClientImports from './getTemplateClientImports.mjs';
-import mergePackages from './mergePackages.mjs';
 import writeOneClientFile, { normalizeOutTemplatePath } from './writeOneClientFile.mjs';
 import { ROOT_SEGMENT_FILE_NAME } from '../dev/writeOneSegmentSchemaFile.mjs';
 import { getTsconfig } from 'get-tsconfig';
-import { normalizeOpenAPIMixins } from '../utils/normalizeOpenAPIMixins.mjs';
+import { normalizeOpenAPIMixin } from '../utils/normalizeOpenAPIMixin.mjs';
 import { BuiltInTemplateName } from '../getProjectInfo/getConfig/getTemplateDefs.mjs';
 const getIncludedSegmentNames = (config, fullSchema, configKey, cliGenerateOptions) => {
     const segments = Object.values(fullSchema.segments);
@@ -86,30 +85,35 @@ const cliOptionsToOpenAPIMixins = ({ openapiGetMethodName, openapiGetModuleName,
         },
     ]));
 };
-export async function generate({ isEnsuringClient = false, isBundle = false, projectInfo, forceNothingWrittenLog, fullSchema, locatedSegments, cliGenerateOptions, package: argPackageJson, readme: argReadme, }) {
+export async function generate({ isEnsuringClient = false, isBundle = false, projectInfo, forceNothingWrittenLog, fullSchema, locatedSegments, cliGenerateOptions, }) {
     fullSchema = {
         ...fullSchema,
         // sort segments by name to avoid unnecessary rendering
-        segments: Object.fromEntries(Object.entries(fullSchema.segments).sort(([a], [b]) => a.localeCompare(b))),
+        segments: Object.fromEntries(Object.entries(fullSchema.segments)
+            .sort(([a], [b]) => a.localeCompare(b))
+            // preserve original object, so segments can be extended
+            .map((segment) => ({ ...segment }))),
     };
-    const { config, cwd, log, srcRoot, packageJson: rootPackageJson, vovkCliPackage } = projectInfo;
-    const allOpenAPIMixins = {
-        ...config.openApiMixins,
-        ...cliOptionsToOpenAPIMixins(cliGenerateOptions ?? {}),
-    };
-    if (Object.keys(allOpenAPIMixins).length) {
-        const mixins = Object.fromEntries(Object.entries(await normalizeOpenAPIMixins({ mixinModules: allOpenAPIMixins, log })).map(([mixinName, conf]) => [
-            mixinName,
-            openAPIToVovkSchema({ ...conf, mixinName }).segments[mixinName],
-        ]));
-        fullSchema = {
-            ...fullSchema,
-            segments: {
-                ...fullSchema.segments,
-                ...mixins,
+    const { config, cwd, log, srcRoot, vovkCliPackage } = projectInfo;
+    Object.entries(config.projectConfig.segments ?? {}).forEach(([segmentName, segmentConfig]) => {
+        fullSchema.segments = {
+            ...fullSchema.segments,
+            [segmentName]: {
+                ...fullSchema.segments[segmentName],
+                ...openAPIToVovkSchema({ ...segmentConfig.openAPIMixin, segmentName }).segments[segmentName],
             },
         };
-    }
+    });
+    const cliMixins = cliOptionsToOpenAPIMixins(cliGenerateOptions ?? {});
+    await Promise.all(Object.entries(cliMixins).map(async ([mixinName, mixinModule]) => {
+        fullSchema.segments = {
+            ...fullSchema.segments,
+            [mixinName]: {
+                ...fullSchema.segments[mixinName],
+                ...openAPIToVovkSchema(await normalizeOpenAPIMixin({ mixinModule, log })).segments[mixinName],
+            },
+        };
+    }));
     const isNodeNextResolution = ['node16', 'nodenext'].includes((await getTsconfig(cwd)?.config?.compilerOptions?.moduleResolution?.toLowerCase()) ?? '');
     const isVovkProject = !!srcRoot;
     const isComposedEnabled = cliGenerateOptions?.composedOnly ||
@@ -141,12 +145,11 @@ export async function generate({ isEnsuringClient = false, isBundle = false, pro
                 fullSchema,
                 outCwdRelativeDir,
             });
-            const packageJson = await mergePackages({
-                log,
-                rootPackageJson,
-                packages: [config.composedClient.package, templateDef.composedClient?.package, argPackageJson],
+            const { package: packageJson, readme, origin, snippets, } = getGeneratorConfig({
+                schema: fullSchema,
+                config: templateDef.projectConfig,
+                isBundle,
             });
-            const readme = Object.assign({}, config.composedClient.readme, templateDef.composedClient?.readme, argReadme);
             const composedFullSchema = pickSegmentFullSchema(fullSchema, segmentNames);
             const hasMixins = Object.values(composedFullSchema.segments).some((segment) => segment.segmentType === 'mixin');
             if (templateName === BuiltInTemplateName.mixins && !hasMixins) {
@@ -164,6 +167,7 @@ export async function generate({ isEnsuringClient = false, isBundle = false, pro
                 matterResult,
                 package: packageJson,
                 readme,
+                snippets,
                 isEnsuringClient,
                 outCwdRelativeDir,
                 templateDef,
@@ -173,7 +177,7 @@ export async function generate({ isEnsuringClient = false, isBundle = false, pro
                 isVovkProject,
                 vovkCliPackage,
                 isBundle,
-                origin: cliGenerateOptions?.origin ?? templateDef.origin ?? config.origin,
+                origin: cliGenerateOptions?.origin ?? origin,
             });
             const outAbsoluteDir = path.resolve(cwd, outCwdRelativeDir);
             return {
@@ -220,19 +224,12 @@ export async function generate({ isEnsuringClient = false, isBundle = false, pro
                 outCwdRelativeDir,
             });
             const results = await Promise.all(segmentNames.map(async (segmentName) => {
-                const packageJson = await mergePackages({
-                    log,
-                    rootPackageJson,
-                    packages: [
-                        fullSchema.segments[segmentName]?.meta?.package,
-                        config.segmentedClient.packages?.[segmentName],
-                        templateDef.segmentedClient?.packages?.[segmentName],
-                        argPackageJson,
-                    ],
+                const { package: packageJson, readme, origin, snippets, } = getGeneratorConfig({
+                    schema: fullSchema,
+                    config: templateDef.projectConfig,
+                    segmentName,
+                    isBundle,
                 });
-                const readme = Object.assign({}, 
-                // TODO fullSchema.segments[segmentName]?.meta?.readme,
-                config.segmentedClient.readmes?.[segmentName], templateDef.segmentedClient?.readmes?.[segmentName], argReadme);
                 const segmentedFullSchema = pickSegmentFullSchema(fullSchema, [segmentName]);
                 const hasMixins = Object.values(segmentedFullSchema.segments).some((segment) => segment.segmentType === 'mixin');
                 if (templateName === BuiltInTemplateName.mixins && !hasMixins) {
@@ -250,6 +247,7 @@ export async function generate({ isEnsuringClient = false, isBundle = false, pro
                     matterResult,
                     package: packageJson,
                     readme,
+                    snippets,
                     isEnsuringClient,
                     outCwdRelativeDir,
                     templateDef,
@@ -259,7 +257,7 @@ export async function generate({ isEnsuringClient = false, isBundle = false, pro
                     isVovkProject,
                     vovkCliPackage,
                     isBundle,
-                    origin: cliGenerateOptions?.origin ?? templateDef.origin ?? config.origin,
+                    origin: cliGenerateOptions?.origin ?? origin,
                 });
                 return {
                     written,

package/dist/generate/getClientTemplateFiles.mjs

@@ -73,7 +73,7 @@ export default async function getClientTemplateFiles({ config, cwd, log, configK
                 }
                 def = {
                     ...def,
-                    origin: templateDef.origin ?? def.origin,
+                    projectConfig: merge({}, templateDef?.projectConfig, def.projectConfig),
                     composedClient: merge(omit(templateDef?.composedClient ?? {}, ['outDir']), def.composedClient),
                     segmentedClient: merge(omit(templateDef?.segmentedClient ?? {}, ['outDir']), def.segmentedClient),
                 };

package/dist/generate/getProjectFullSchema.d.mts

@@ -1,7 +1,10 @@
-import { type VovkSchema } from 'vovk';
+import { VovkStrictConfig, type VovkSchema } from 'vovk';
 import type { ProjectInfo } from '../getProjectInfo/index.mjs';
-export declare function getProjectFullSchema({ schemaOutAbsolutePath, isNextInstalled, log, }: {
+import { PackageJson } from 'type-fest';
+export declare function getProjectFullSchema({ schemaOutAbsolutePath, isNextInstalled, log, package: packageJson, config, }: {
     schemaOutAbsolutePath: string;
     isNextInstalled: boolean;
     log: ProjectInfo['log'];
+    package: PackageJson;
+    config: VovkStrictConfig;
 }): Promise<VovkSchema>;

package/dist/generate/getProjectFullSchema.mjs

@@ -3,17 +3,17 @@ import path from 'node:path';
 import { glob } from 'glob';
 import { VovkSchemaIdEnum } from 'vovk';
 import { META_FILE_NAME, ROOT_SEGMENT_FILE_NAME } from '../dev/writeOneSegmentSchemaFile.mjs';
-export async function getProjectFullSchema({ schemaOutAbsolutePath, isNextInstalled, log, }) {
+import getMetaSchema from '../getProjectInfo/getMetaSchema.mjs';
+export async function getProjectFullSchema({ schemaOutAbsolutePath, isNextInstalled, log, package: packageJson, config, }) {
     const result = {
         $schema: VovkSchemaIdEnum.SCHEMA,
         segments: {},
-        meta: {
-            $schema: VovkSchemaIdEnum.META,
-            config: {
-                $schema: VovkSchemaIdEnum.CONFIG,
-            },
-        },
+        meta: getMetaSchema({
+            config,
+            package: packageJson,
+        }),
     };
+    console.log('result', result);
     const isEmptyLogOrWarn = isNextInstalled ? log.warn : log.debug;
     // Handle config.json
     const metaPath = path.join(schemaOutAbsolutePath, `${META_FILE_NAME}.json`);

package/dist/generate/index.mjs

@@ -37,12 +37,14 @@ export class VovkGenerate {
         });
     }
     async getFullSchema() {
-        const { log, config, cwd, isNextInstalled } = this.#projectInfo;
+        const { log, config, cwd, isNextInstalled, packageJson } = this.#projectInfo;
         const { schemaPath } = this.#cliGenerateOptions;
         const fullSchema = await getProjectFullSchema({
             schemaOutAbsolutePath: path.resolve(cwd, schemaPath ?? config.schemaOutDir),
             isNextInstalled,
             log,
+            package: packageJson,
+            config,
         });
         return fullSchema;
     }

package/dist/generate/writeOneClientFile.d.mts

@@ -1,11 +1,11 @@
-import { type VovkSchema, type VovkStrictConfig } from 'vovk';
+import { VovkReadmeConfig, VovkSnippetsConfig, type VovkSchema, type VovkStrictConfig } from 'vovk';
 import type { PackageJson } from 'type-fest';
 import type { ProjectInfo } from '../getProjectInfo/index.mjs';
 import type { ClientTemplateFile } from './getClientTemplateFiles.mjs';
 import type { ClientImports } from './getTemplateClientImports.mjs';
 import type { Segment } from '../locateSegments.mjs';
 export declare function normalizeOutTemplatePath(out: string, packageJson: PackageJson): string;
-export default function writeOneClientFile({ cwd, projectInfo, clientTemplateFile, fullSchema, prettifyClient, segmentName, imports, templateContent, matterResult: { data, content }, package: packageJson, readme, isEnsuringClient, outCwdRelativeDir, templateDef, locatedSegments, isNodeNextResolution, hasMixins, isVovkProject, vovkCliPackage, isBundle, origin, }: {
+export default function writeOneClientFile({ cwd, projectInfo, clientTemplateFile, fullSchema, prettifyClient, segmentName, imports, templateContent, matterResult: { data, content }, package: packageJson, readme, snippets, isEnsuringClient, outCwdRelativeDir, locatedSegments, isNodeNextResolution, hasMixins, isVovkProject, vovkCliPackage, isBundle, origin, }: {
     cwd: string;
     projectInfo: ProjectInfo;
     clientTemplateFile: ClientTemplateFile;
@@ -21,7 +21,8 @@ export default function writeOneClientFile({ cwd, projectInfo, clientTemplateFil
         content: string;
     };
     package: PackageJson;
-    readme: VovkStrictConfig['bundle']['readme'];
+    readme: VovkReadmeConfig;
+    snippets: VovkSnippetsConfig;
     isEnsuringClient: boolean;
     outCwdRelativeDir: string;
     templateDef: VovkStrictConfig['clientTemplateDefs'][string];

package/dist/generate/writeOneClientFile.mjs

@@ -2,7 +2,7 @@ import fs from 'fs/promises';
 import path from 'node:path';
 import ejs from 'ejs';
 import _ from 'lodash';
-import { createCodeExamples, VovkSchemaIdEnum } from 'vovk';
+import { createCodeExamples, VovkSchemaIdEnum, } from 'vovk';
 import * as YAML from 'yaml';
 import TOML from '@iarna/toml';
 import prettify from '../utils/prettify.mjs';
@@ -11,7 +11,9 @@ import { compileJSONSchemaToTypeScriptType } from '../utils/compileJSONSchemaToT
 export function normalizeOutTemplatePath(out, packageJson) {
     return out.replace('[package_name]', packageJson.name?.replace(/-/g, '_') ?? 'my_package_name');
 }
-export default async function writeOneClientFile({ cwd, projectInfo, clientTemplateFile, fullSchema, prettifyClient, segmentName, imports, templateContent, matterResult: { data, content }, package: packageJson, readme, isEnsuringClient, outCwdRelativeDir, templateDef, locatedSegments, isNodeNextResolution, hasMixins, isVovkProject, vovkCliPackage, isBundle, origin, }) {
+export default async function writeOneClientFile({ cwd, projectInfo, clientTemplateFile, fullSchema, prettifyClient, segmentName, imports, templateContent, matterResult: { data, content }, package: packageJson, readme, snippets, isEnsuringClient, outCwdRelativeDir, 
+// templateDef,
+locatedSegments, isNodeNextResolution, hasMixins, isVovkProject, vovkCliPackage, isBundle, origin, }) {
     const { config, apiRoot } = projectInfo;
     const { templateFilePath, relativeDir } = clientTemplateFile;
     const locatedSegmentsByName = _.keyBy(locatedSegments, 'segmentName');
@@ -38,6 +40,7 @@ export default async function writeOneClientFile({ cwd, projectInfo, clientTempl
         isVovkProject,
         package: packageJson,
         readme,
+        snippets,
         ROOT_SEGMENT_FILE_NAME,
         apiRoot: origin ? `${origin}/${config.rootEntry}` : apiRoot,
         imports,
@@ -63,11 +66,14 @@ export default async function writeOneClientFile({ cwd, projectInfo, clientTempl
                 ? path.relative(path.resolve(cwd, outCwdRelativeDir, typeof segmentName === 'string' ? segmentName || ROOT_SEGMENT_FILE_NAME : '.'), path.resolve(cwd, routeFilePath))
                 : null;
             const segmentConfig = {
-                ...(config.segmentConfig ? config.segmentConfig[sName] : {}),
-                ...(templateDef.segmentConfig ? templateDef.segmentConfig[sName] : {}),
+                ...config.projectConfig.segments?.[sName],
+                // ...templateDef.projectConfig?.segments?.[sName],
             };
             const { origin: segmentConfigOrigin, rootEntry: segmentConfigRootEntry, segmentNameOverride } = segmentConfig;
-            const reExports = { ...segmentConfig.reExports, ...(isBundle ? projectInfo.config.bundle.reExports : {}) };
+            const reExports = {
+                ...segmentConfig.reExports,
+                ...(isBundle ? projectInfo.config.projectConfig?.bundle?.reExports : {}),
+            };
             return [
                 sName,
                 {

package/dist/getProjectInfo/getConfig/getTemplateDefs.mjs

@@ -129,9 +129,9 @@ export default function getTemplateDefs(userTemplateDefs = {}) {
                         ...builtIn.segmentedClient,
                         ...templateDef.segmentedClient,
                     },
-                    segmentConfig: {
-                        ...builtIn.segmentConfig,
-                        ...templateDef.segmentConfig,
+                    projectConfig: {
+                        ...builtIn.projectConfig,
+                        ...templateDef.projectConfig,
                     },
                     // 'requires' and other props will be overridden
                 };