vovk-cli 0.0.1-draft.334 → 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/dist/bundle/index.mjs

@@ -29,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,
@@ -73,10 +71,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,
                 composedFrom: group.map(([templateName]) => templateName),
                 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.mjs

@@ -19,19 +19,11 @@ 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;
@@ -235,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');
@@ -287,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) {
@@ -301,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({
@@ -318,7 +324,7 @@ 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();
         }

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

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

@@ -14,14 +14,13 @@ export default function getConfig({ configPath, cwd, logLevel, }: {
         schemaOutDir?: string;
         modulesDir?: string;
         rootEntry?: string;
-        origin?: string;
         logLevel?: "error" | "trace" | "debug" | "info" | "warn" | (string & {});
         libs?: {
             ajv: import("vovk").KnownAny;
             [key: string]: import("vovk").KnownAny;
         };
         devHttps?: boolean;
-        composedClient?: ({
+        composedClient?: {
             enabled?: boolean;
             outDir?: string;
             fromTemplates?: string[];
@@ -32,13 +31,8 @@ export default function getConfig({ configPath, cwd, logLevel, }: {
         } | {
             excludeSegments?: string[];
             includeSegments?: never;
-        })) & {
-            package?: import("type-fest").PackageJson;
-            readme?: {
-                banner?: string;
-            };
-        };
-        segmentedClient?: ({
+        });
+        segmentedClient?: {
             enabled?: boolean;
             outDir?: string;
             fromTemplates?: string[];
@@ -49,22 +43,11 @@ export default function getConfig({ configPath, cwd, logLevel, }: {
         } | {
             excludeSegments?: string[];
             includeSegments?: never;
-        })) & {
-            packages?: Record<string, import("type-fest").PackageJson>;
-            readmes?: Record<string, {
-                banner?: string;
-            }>;
-        };
+        });
         bundle?: {
             requires?: Record<string, string>;
             prebundleOutDir?: string;
             keepPrebundleDir?: boolean;
-            origin?: string;
-            package?: import("type-fest").PackageJson;
-            readme?: {
-                banner?: string;
-            };
-            reExports?: Record<string, string>;
             tsdownBuildOptions?: Parameters<typeof import("tsdown/config-9hj-APNF.mjs").build>[0];
         } & ({
             excludeSegments?: never;
@@ -85,34 +68,7 @@ export default function getConfig({ configPath, cwd, logLevel, }: {
             controller?: string;
             [key: string]: string | undefined;
         };
-        segmentConfig?: false | {
-            [x: string]: {
-                origin?: string;
-                rootEntry?: string;
-                segmentNameOverride?: string;
-                reExports?: Record<string, string>;
-            };
-        };
-        openApiMixins?: {
-            [mixinName: string]: {
-                source: {
-                    file: string;
-                } | {
-                    url: string;
-                    fallback?: string;
-                } | {
-                    object: import("openapi3-ts/oas31").OpenAPIObject;
-                };
-                package?: import("type-fest").PackageJson;
-                readme?: {
-                    banner?: string;
-                };
-                apiRoot?: string;
-                getModuleName?: "nestjs-operation-id" | (string & {}) | "api" | import("vovk/types").GetOpenAPINameFn;
-                getMethodName?: "nestjs-operation-id" | "camel-case-operation-id" | "auto" | import("vovk/types").GetOpenAPINameFn;
-                errorMessageKey?: string;
-            };
-        };
+        projectConfig?: import("vovk").VovkProjectConfig;
     } | null;
     log: {
         info: (msg: string) => void;

package/dist/getProjectInfo/getConfig/index.mjs

@@ -4,7 +4,7 @@ import getLogger from '../../utils/getLogger.mjs';
 import getUserConfig from './getUserConfig.mjs';
 import getRelativeSrcRoot from './getRelativeSrcRoot.mjs';
 import getTemplateDefs, { BuiltInTemplateName } from './getTemplateDefs.mjs';
-import { normalizeOpenAPIMixins } from '../../utils/normalizeOpenAPIMixins.mjs';
+import { normalizeOpenAPIMixin } from '../../utils/normalizeOpenAPIMixin.mjs';
 import chalkHighlightThing from '../../utils/chalkHighlightThing.mjs';
 export default async function getConfig({ configPath, cwd, logLevel, }) {
     const { configAbsolutePaths, error, userConfig } = await getUserConfig({
@@ -12,6 +12,7 @@ export default async function getConfig({ configPath, cwd, logLevel, }) {
         cwd,
     });
     const conf = userConfig ?? {};
+    const log = getLogger(logLevel ?? conf.logLevel);
     const env = process.env;
     const clientTemplateDefs = getTemplateDefs(conf.clientTemplateDefs);
     const srcRoot = await getRelativeSrcRoot({ cwd });
@@ -51,9 +52,6 @@ export default async function getConfig({ configPath, cwd, logLevel, }) {
                 [BuiltInTemplateName.readme]: '.',
                 [BuiltInTemplateName.packageJson]: '.',
             },
-            package: {},
-            readme: {},
-            reExports: {},
             ...conf.bundle,
             tsdownBuildOptions: {
                 outDir: conf.bundle?.tsdownBuildOptions?.outDir ?? 'dist',
@@ -62,7 +60,6 @@ export default async function getConfig({ configPath, cwd, logLevel, }) {
         },
         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: conf.rootSegmentModulesDirName ?? '',
         logLevel: conf.logLevel ?? 'info',
@@ -73,11 +70,22 @@ export default async function getConfig({ configPath, cwd, logLevel, }) {
             ...conf.moduleTemplates,
         },
         libs: conf.libs ?? {},
-        segmentConfig: conf.segmentConfig ?? {},
-        openApiMixins: {},
+        projectConfig: {
+            ...conf.projectConfig,
+            origin: (env.VOVK_ORIGIN ?? conf?.projectConfig?.origin ?? '').replace(/\/$/, ''), // Remove trailing slash
+            segments: Object.fromEntries(await Promise.all(Object.entries(conf.projectConfig?.segments ?? {}).map(async ([key, value]) => [
+                key,
+                {
+                    ...value,
+                    openAPIMixin: value.openAPIMixin
+                        ? await normalizeOpenAPIMixin({ mixinModule: value.openAPIMixin, log, cwd })
+                        : undefined,
+                },
+            ]))),
+        },
     };
     if (typeof conf.emitConfig === 'undefined') {
-        config.emitConfig = ['libs'];
+        config.emitConfig = ['libs', 'projectConfig'];
     }
     else if (conf.emitConfig === true) {
         config.emitConfig = Object.keys(config);
@@ -85,12 +93,6 @@ export default async function getConfig({ configPath, cwd, logLevel, }) {
     else if (Array.isArray(conf.emitConfig)) {
         config.emitConfig = conf.emitConfig;
     } // else it's false and emitConfig already is []
-    const log = getLogger(logLevel ?? config.logLevel);
-    config.openApiMixins = await normalizeOpenAPIMixins({
-        mixinModules: conf.openApiMixins ?? {},
-        cwd,
-        log,
-    });
     if (!userConfig) {
         log.warn(`Unable to load config at ${chalkHighlightThing(cwd)}. Using default values. ${error ?? ''}`);
     }

package/dist/getProjectInfo/getMetaSchema.d.mts

@@ -0,0 +1,10 @@
+import { VovkSchemaIdEnum, VovkStrictConfig } from 'vovk';
+import { PackageJson } from 'type-fest';
+export default function getMetaSchema({ config, package: packageJson, }: {
+    config: VovkStrictConfig;
+    package: PackageJson;
+}): {
+    config: VovkStrictConfig;
+    $schema: VovkSchemaIdEnum;
+    package: Pick<PackageJson, "name" | "version" | "description" | "author" | "license">;
+};

package/dist/getProjectInfo/getMetaSchema.mjs

@@ -0,0 +1,13 @@
+import { VovkSchemaIdEnum } from 'vovk';
+import pick from 'lodash/pick.js';
+export default function getMetaSchema({ config, package: packageJson, }) {
+    return {
+        $schema: VovkSchemaIdEnum.META,
+        package: pick(packageJson, ['name', 'version', 'description', 'author', 'license']),
+        ...{
+            config: (config
+                ? pick(config, [...config.emitConfig, '$schema'])
+                : {}),
+        },
+    };
+}

package/dist/getProjectInfo/index.mjs

@@ -18,7 +18,7 @@ export default async function getProjectInfo({ port: givenPort, cwd = process.cw
     if (srcRootRequired && !srcRoot) {
         throw new Error(`Could not find app router directory at ${cwd}. Check Next.js docs for more info.`);
     }
-    const apiRoot = `${config.origin ?? ''}/${config.rootEntry}`;
+    const apiRoot = `${config.projectConfig.origin ?? ''}/${config.rootEntry}`;
     const apiDirAbsolutePath = srcRoot ? path.resolve(cwd, srcRoot, 'app', config.rootEntry) : null;
     if (configAbsolutePaths.length > 1) {
         log.warn(`Multiple config files found. Using the first one: ${configAbsolutePaths[0]}`);

package/dist/index.mjs

@@ -138,11 +138,13 @@ program
         srcRootRequired: false,
         logLevel: cliBundleOptions.logLevel,
     });
-    const { cwd, config, log, isNextInstalled } = projectInfo;
+    const { cwd, config, log, isNextInstalled, packageJson } = projectInfo;
     const fullSchema = await getProjectFullSchema({
         schemaOutAbsolutePath: path.resolve(cwd, cliBundleOptions?.schema ?? config.schemaOutDir),
         log,
         isNextInstalled,
+        package: packageJson,
+        config,
     });
     await bundle({
         projectInfo,

package/dist/init/index.mjs

@@ -20,16 +20,7 @@ export class Init {
     log;
     async #init({ configPaths, pkgJson, cwd = process.cwd(), }, { useNpm, useYarn, usePnpm, useBun, skipInstall, updateTsConfig, updateScripts, validationLibrary, lang, dryRun, channel, }) {
         const { log, root } = this;
-        const dependencies = [
-            'vovk',
-            'vovk-client',
-            'openapi3-ts',
-            'vovk-ajv',
-            'ajv',
-            'ajv-errors',
-            'ajv-formats',
-            'ajv-i18n',
-        ];
+        const dependencies = ['vovk', 'vovk-client', 'openapi3-ts', 'vovk-ajv', 'ajv'];
         const devDependencies = ['vovk-cli'];
         if (lang?.includes('py')) {
             devDependencies.push('vovk-python');

package/dist/utils/generateFnName.d.mts

@@ -0,0 +1,23 @@
+import { HttpMethod } from 'vovk';
+export interface VerbMapEntry {
+    noParams?: string;
+    withParams?: string;
+    default?: string;
+}
+export declare const VERB_MAP: Record<HttpMethod, VerbMapEntry>;
+export declare function capitalize(str: string): string;
+interface GenerateFnNameOptions {
+    /** Segments to strip out (e.g. ['api','v1']) */
+    ignoreSegments?: string[];
+}
+/**
+ * Turn an HTTP method + OpenAPI path into a camelCased function name.
+ *
+ * Examples:
+ *   generateFnName('GET', '/users')                     // "listUsers"
+ *   generateFnName('GET', '/users/{id}')                // "getUsersById"
+ *   generateFnName('POST', '/v1/api/orders')            // "createOrders"
+ *   generateFnName('PATCH', '/users/{userId}/profile')  // "patchUsersProfileByUserId"
+ */
+export declare function generateFnName(method: HttpMethod, rawPath: string, opts?: GenerateFnNameOptions): string;
+export {};

package/dist/utils/generateFnName.mjs

@@ -0,0 +1,76 @@
+export const VERB_MAP = {
+    GET: { noParams: 'list', withParams: 'get' },
+    POST: { default: 'create' },
+    PUT: { default: 'update' },
+    PATCH: { default: 'patch' },
+    DELETE: { default: 'delete' },
+    HEAD: { default: 'head' },
+    OPTIONS: { default: 'options' },
+};
+export function capitalize(str) {
+    if (str.length === 0)
+        return '';
+    return str[0].toUpperCase() + str.slice(1);
+}
+const DEFAULT_OPTIONS = {
+    ignoreSegments: ['api'],
+};
+/**
+ * Turn an HTTP method + OpenAPI path into a camelCased function name.
+ *
+ * Examples:
+ *   generateFnName('GET', '/users')                     // "listUsers"
+ *   generateFnName('GET', '/users/{id}')                // "getUsersById"
+ *   generateFnName('POST', '/v1/api/orders')            // "createOrders"
+ *   generateFnName('PATCH', '/users/{userId}/profile')  // "patchUsersProfileByUserId"
+ */
+export function generateFnName(method, rawPath, opts = {}) {
+    const { ignoreSegments } = {
+        ...DEFAULT_OPTIONS,
+        ...opts,
+    };
+    // 1. Clean & split path
+    const parts = rawPath
+        .replace(/^\/|\/$/g, '') // strip leading/trailing slash
+        .split('/')
+        .filter((seg) => !ignoreSegments?.includes(seg.toLowerCase()))
+        .filter(Boolean);
+    // 2. Separate resource tokens from path-params
+    const resources = [];
+    const params = [];
+    parts.forEach((seg) => {
+        const match = seg.match(/^{?([^}]+)}?$/);
+        if (match) {
+            params.push(match[1]);
+        }
+        else {
+            resources.push(seg);
+        }
+    });
+    // 3. Pick base verb from VERB_MAP
+    let baseVerb;
+    if (method === 'GET') {
+        baseVerb = params.length ? VERB_MAP.GET.withParams : VERB_MAP.GET.noParams;
+    }
+    else {
+        baseVerb = VERB_MAP[method].default;
+    }
+    // 4. Build the “resource” part
+    const resourcePart = resources.map(capitalize).join('');
+    // 5. Build the “ByParam” suffix
+    const byParams = params.length ? 'By' + params.map(capitalize).join('') : '';
+    // 6. Combine and ensure camelCase
+    const rawName = `${baseVerb}${resourcePart}${byParams}`;
+    return rawName[0].toLowerCase() + rawName.slice(1);
+}
+/*
+// --- Example usage ---
+console.log(generateFnName('GET', '/users')); // listUsers
+console.log(generateFnName('GET', '/users/{id}')); // getUsersById
+console.log(generateFnName('POST', '/users')); // createUsers
+console.log(generateFnName('PATCH', '/users/{userId}/profile')); // patchUsersProfileByUserId
+console.log(generateFnName('DELETE', '/v1/api/orders/{orderId}')); // deleteOrdersByOrderId
+
+// You can also enable singularization:
+console.log(generateFnName('GET', '/users/{userId}/orders', { singularizeResources: true })); // getUserOrderByUserId
+*/

package/dist/utils/normalizeOpenAPIMixin.d.mts

@@ -0,0 +1,14 @@
+import { HttpMethod, VovkOperationObject, VovkStrictConfig, type VovkConfig } from 'vovk';
+import { OpenAPIObject } from 'openapi3-ts/oas31';
+import type { ProjectInfo } from '../getProjectInfo/index.mjs';
+export type GetOpenAPINameFn = (config: {
+    operationObject: VovkOperationObject;
+    method: HttpMethod;
+    path: string;
+    openAPIObject: OpenAPIObject;
+}) => string;
+export declare function normalizeOpenAPIMixin({ mixinModule, log, cwd, }: {
+    mixinModule: NonNullable<NonNullable<NonNullable<NonNullable<VovkConfig['projectConfig']>['segments']>[string]>['openAPIMixin']>;
+    log: ProjectInfo['log'];
+    cwd?: string;
+}): Promise<NonNullable<NonNullable<NonNullable<VovkStrictConfig['projectConfig']>['segments']>[string]>['openAPIMixin']>;

package/dist/utils/normalizeOpenAPIMixin.mjs

@@ -0,0 +1,114 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import * as YAML from 'yaml';
+import chalkHighlightThing from './chalkHighlightThing.mjs';
+import camelCase from 'lodash/camelCase.js';
+import { generateFnName } from './generateFnName.mjs';
+const getNamesNestJS = (operationObject) => {
+    const operationId = operationObject.operationId;
+    if (!operationId) {
+        throw new Error('Operation ID is required for NestJS module name generation');
+    }
+    const controllerHandlerMatch = operationId?.match(/^([A-Z][a-zA-Z0-9]*)_([a-zA-Z0-9_]+)/);
+    if (!controllerHandlerMatch) {
+        throw new Error(`Invalid operationId format for NestJS: ${operationId}`);
+    }
+    const [controllerName, handlerName] = controllerHandlerMatch.slice(1, 3);
+    return [controllerName.replace(/Controller$/, 'RPC'), handlerName];
+};
+const normalizeGetModuleName = (getModuleName) => {
+    if (getModuleName === 'nestjs-operation-id') {
+        getModuleName = ({ operationObject }) => getNamesNestJS(operationObject)[0];
+    }
+    else if (typeof getModuleName === 'string') {
+        const moduleName = getModuleName;
+        getModuleName = () => moduleName;
+    }
+    else if (typeof getModuleName !== 'function') {
+        throw new Error('getModuleName must be a function or one of the predefined strings');
+    }
+    return getModuleName;
+};
+const normalizeGetMethodName = (getMethodName) => {
+    if (getMethodName === 'nestjs-operation-id') {
+        getMethodName = ({ operationObject }) => getNamesNestJS(operationObject)[1];
+    }
+    else if (getMethodName === 'camel-case-operation-id') {
+        getMethodName = ({ operationObject }) => {
+            const operationId = operationObject.operationId;
+            if (!operationId) {
+                throw new Error('Operation ID is required for camel-case method name generation');
+            }
+            return camelCase(operationId);
+        };
+    }
+    else if (getMethodName === 'auto') {
+        getMethodName = ({ operationObject, method, path }) => {
+            const operationId = operationObject.operationId;
+            const isCamelCase = operationId && /^[a-z][a-zA-Z0-9]*$/.test(operationId);
+            const isSnakeCase = operationId && /^[a-z][a-z0-9_]+$/.test(operationId);
+            return isCamelCase ? operationId : isSnakeCase ? camelCase(operationId) : generateFnName(method, path);
+        };
+    }
+    else if (typeof getMethodName !== 'function') {
+        throw new Error('getMethodName must be a function or one of the predefined strings');
+    }
+    return getMethodName;
+};
+async function getOpenApiSpecLocal(openApiSpecFilePath, cwd) {
+    const openApiSpecAbsolutePath = path.resolve(cwd, openApiSpecFilePath);
+    const fileName = path.basename(openApiSpecAbsolutePath);
+    if (!fileName.endsWith('.json') && !fileName.endsWith('.yaml') && !fileName.endsWith('.yml')) {
+        throw new Error(`Invalid OpenAPI spec file format: ${fileName}. Please provide a JSON or YAML file.`);
+    }
+    const openApiSpecContent = await fs.readFile(openApiSpecAbsolutePath, 'utf8');
+    return (fileName.endsWith('.json') ? JSON.parse(openApiSpecContent) : YAML.parse(openApiSpecContent));
+}
+async function getOpenApiSpecRemote({ cwd, url, fallback, log, }) {
+    const resp = await fetch(url);
+    const text = await resp.text();
+    if (!resp.ok) {
+        if (fallback) {
+            log.warn(`Failed to fetch OpenAPI spec from ${chalkHighlightThing(url)}: ${resp.status} ${resp.statusText}. Falling back to ${chalkHighlightThing(fallback)}`);
+            return getOpenApiSpecLocal(fallback, cwd);
+        }
+        throw new Error(`Failed to fetch OpenAPI spec from ${chalkHighlightThing(url)}: ${resp.status} ${resp.statusText}`);
+    }
+    if (fallback) {
+        const fallbackAbsolutePath = path.resolve(cwd, fallback);
+        const existingFallback = await fs.readFile(fallbackAbsolutePath, 'utf8').catch(() => null);
+        if (existingFallback !== text) {
+            await fs.mkdir(path.dirname(fallbackAbsolutePath), { recursive: true });
+            await fs.writeFile(fallbackAbsolutePath, text);
+            log.info(`Saved OpenAPI spec to fallback file ${chalkHighlightThing(fallbackAbsolutePath)}`);
+        }
+        else {
+            log.debug(`OpenAPI spec at ${chalkHighlightThing(url)} is unchanged. Skipping write to fallback file ${chalkHighlightThing(fallbackAbsolutePath)}`);
+        }
+    }
+    return (text.trim().startsWith('{') || text.trim().startsWith('[') ? JSON.parse(text) : YAML.parse(text));
+}
+export async function normalizeOpenAPIMixin({ 
+// mixinName,
+mixinModule, log, cwd = process.cwd(), }) {
+    const { source, getModuleName, getMethodName } = mixinModule;
+    let openAPIObject;
+    if ('url' in source) {
+        openAPIObject = await getOpenApiSpecRemote({ url: source.url, fallback: source.fallback, log, cwd });
+    }
+    else if ('file' in source) {
+        openAPIObject = await getOpenApiSpecLocal(source.file, cwd);
+    }
+    else if ('object' in source) {
+        openAPIObject = source.object;
+    }
+    else {
+        throw new Error('Invalid source type for OpenAPI configuration');
+    }
+    return {
+        ...mixinModule,
+        source: { object: openAPIObject },
+        getModuleName: normalizeGetModuleName(getModuleName),
+        getMethodName: normalizeGetMethodName(getMethodName),
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vovk-cli",
-  "version": "0.0.1-draft.334",
+  "version": "0.0.1-draft.335",
   "bin": {
     "vovk": "./dist/index.mjs"
   },
@@ -35,7 +35,7 @@
   },
   "homepage": "https://vovk.dev",
   "peerDependencies": {
-    "vovk": "^3.0.0-draft.396"
+    "vovk": "^3.0.0-draft.397"
   },
   "optionalDependencies": {
     "@rolldown/binding-linux-x64-gnu": "1.0.0-beta.31"

package/dist/generate/mergePackages.d.mts

@@ -1,7 +0,0 @@
-import type { PackageJson } from 'type-fest';
-import type { ProjectInfo } from '../getProjectInfo/index.mjs';
-export default function mergePackages({ rootPackageJson, packages, }: {
-    rootPackageJson: PackageJson;
-    packages: (PackageJson | undefined)[];
-    log: ProjectInfo['log'];
-}): Promise<PackageJson>;

package/dist/generate/mergePackages.mjs

@@ -1,55 +0,0 @@
-import pick from 'lodash/pick.js';
-function mergeTwoPackageJsons(base, additional) {
-    const merged = { ...base, ...additional };
-    // TODO: Add deep merge for all properties
-    if (base.scripts || additional.scripts) {
-        merged.scripts = { ...base.scripts, ...additional.scripts };
-    }
-    if (base.dependencies || additional.dependencies) {
-        merged.dependencies = { ...base.dependencies, ...additional.dependencies };
-    }
-    if (base.devDependencies || additional.devDependencies) {
-        merged.devDependencies = { ...base.devDependencies, ...additional.devDependencies };
-    }
-    if (base.peerDependencies || additional.peerDependencies) {
-        merged.peerDependencies = { ...base.peerDependencies, ...additional.peerDependencies };
-    }
-    return merged;
-}
-export default async function mergePackages({ rootPackageJson, packages, }) {
-    const defaultPackageJson = {
-        main: './index.cjs',
-        module: './index.mjs',
-        types: './index.d.mts',
-        exports: {
-            '.': {
-                import: './index.mjs',
-                require: './index.cjs',
-            },
-            './schema': {
-                import: './schema.cjs',
-                require: './schema.cjs',
-                types: './schema.d.cts',
-            },
-        },
-    };
-    const pickedPackageJson = pick(rootPackageJson, [
-        'name',
-        'version',
-        'description',
-        'author',
-        'contributors',
-        'license',
-        'repository',
-        'homepage',
-        'bugs',
-        'keywords',
-    ]);
-    let result = { ...pickedPackageJson, ...defaultPackageJson };
-    for (const pkg of packages) {
-        if (pkg) {
-            result = mergeTwoPackageJsons(result, pkg);
-        }
-    }
-    return result;
-}

package/dist/utils/normalizeOpenAPIMixins.d.mts

@@ -1,7 +0,0 @@
-import { VovkStrictConfig, type VovkConfig } from 'vovk';
-import type { ProjectInfo } from '../getProjectInfo/index.mjs';
-export declare function normalizeOpenAPIMixins({ mixinModules, log, cwd, }: {
-    mixinModules: NonNullable<VovkConfig['openApiMixins']>;
-    log: ProjectInfo['log'];
-    cwd?: string;
-}): Promise<VovkStrictConfig['openApiMixins']>;

package/dist/utils/normalizeOpenAPIMixins.mjs

@@ -1,67 +0,0 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import * as YAML from 'yaml';
-import chalkHighlightThing from './chalkHighlightThing.mjs';
-async function getOpenApiSpecLocal(openApiSpecFilePath, cwd) {
-    const openApiSpecAbsolutePath = path.resolve(cwd, openApiSpecFilePath);
-    const fileName = path.basename(openApiSpecAbsolutePath);
-    if (!fileName.endsWith('.json') && !fileName.endsWith('.yaml') && !fileName.endsWith('.yml')) {
-        throw new Error(`Invalid OpenAPI spec file format: ${fileName}. Please provide a JSON or YAML file.`);
-    }
-    const openApiSpecContent = await fs.readFile(openApiSpecAbsolutePath, 'utf8');
-    return (fileName.endsWith('.json') ? JSON.parse(openApiSpecContent) : YAML.parse(openApiSpecContent));
-}
-async function getOpenApiSpecRemote({ cwd, url, fallback, log, }) {
-    const resp = await fetch(url);
-    const text = await resp.text();
-    if (!resp.ok) {
-        if (fallback) {
-            log.warn(`Failed to fetch OpenAPI spec from ${chalkHighlightThing(url)}: ${resp.status} ${resp.statusText}. Falling back to ${chalkHighlightThing(fallback)}`);
-            return getOpenApiSpecLocal(fallback, cwd);
-        }
-        throw new Error(`Failed to fetch OpenAPI spec from ${chalkHighlightThing(url)}: ${resp.status} ${resp.statusText}`);
-    }
-    if (fallback) {
-        const fallbackAbsolutePath = path.resolve(cwd, fallback);
-        const existingFallback = await fs.readFile(fallbackAbsolutePath, 'utf8').catch(() => null);
-        if (existingFallback !== text) {
-            await fs.mkdir(path.dirname(fallbackAbsolutePath), { recursive: true });
-            await fs.writeFile(fallbackAbsolutePath, text);
-            log.info(`Saved OpenAPI spec to fallback file ${chalkHighlightThing(fallbackAbsolutePath)}`);
-        }
-        else {
-            log.debug(`OpenAPI spec at ${chalkHighlightThing(url)} is unchanged. Skipping write to fallback file ${chalkHighlightThing(fallbackAbsolutePath)}`);
-        }
-    }
-    return (text.trim().startsWith('{') || text.trim().startsWith('[') ? JSON.parse(text) : YAML.parse(text));
-}
-export async function normalizeOpenAPIMixins({ mixinModules, log, cwd = process.cwd(), }) {
-    if (mixinModules) {
-        const modules = await Promise.all(Object.entries(mixinModules).map(async ([mixinName, { source, apiRoot, getModuleName, getMethodName, errorMessageKey, package: packageJson },]) => {
-            let openAPIObject;
-            if ('url' in source) {
-                openAPIObject = await getOpenApiSpecRemote({ url: source.url, fallback: source.fallback, log, cwd });
-            }
-            else if ('file' in source) {
-                openAPIObject = await getOpenApiSpecLocal(source.file, cwd);
-            }
-            else if ('object' in source) {
-                openAPIObject = source.object;
-            }
-            else {
-                throw new Error('Invalid source type for OpenAPI configuration');
-            }
-            return {
-                source: { object: openAPIObject },
-                apiRoot,
-                getModuleName,
-                getMethodName,
-                errorMessageKey,
-                package: packageJson,
-                mixinName,
-            };
-        }));
-        return Object.fromEntries(modules.map((module) => [module.mixinName, module]));
-    }
-    return {};
-}