vovk-cli 0.0.1-draft.33 → 0.0.1-draft.330

package/dist/generate/index.mjs

@@ -0,0 +1,189 @@
+import path from 'node:path';
+import * as chokidar from 'chokidar';
+import { getProjectFullSchema } from './getProjectFullSchema.mjs';
+import { generate } from './generate.mjs';
+import { locateSegments } from '../locateSegments.mjs';
+import chalkHighlightThing from '../utils/chalkHighlightThing.mjs';
+const THROTTLE_DELAY = 5000;
+export class VovkGenerate {
+    #cliGenerateOptions;
+    #projectInfo;
+    #forceNothingWrittenLog;
+    constructor({ cliGenerateOptions, projectInfo, forceNothingWrittenLog, }) {
+        this.#cliGenerateOptions = cliGenerateOptions;
+        this.#projectInfo = projectInfo;
+        this.#forceNothingWrittenLog = forceNothingWrittenLog ?? true;
+    }
+    start() {
+        const { watch } = this.#cliGenerateOptions;
+        if (watch) {
+            const throttleDelay = typeof watch === 'boolean' ? THROTTLE_DELAY : parseFloat(watch) * 1e3 || THROTTLE_DELAY;
+            this.watch({ throttleDelay });
+        }
+        else {
+            this.generate();
+        }
+    }
+    async generate() {
+        const fullSchema = await this.getFullSchema();
+        const { log, config, apiDirAbsolutePath } = this.#projectInfo;
+        const locatedSegments = await locateSegments({ dir: apiDirAbsolutePath, config, log });
+        await generate({
+            projectInfo: this.#projectInfo,
+            fullSchema,
+            forceNothingWrittenLog: this.#forceNothingWrittenLog,
+            cliGenerateOptions: this.#cliGenerateOptions,
+            locatedSegments,
+        });
+    }
+    async getFullSchema() {
+        const { log, config, cwd, isNextInstalled } = this.#projectInfo;
+        const { schemaPath } = this.#cliGenerateOptions;
+        const fullSchema = await getProjectFullSchema({
+            schemaOutAbsolutePath: path.resolve(cwd, schemaPath ?? config.schemaOutDir),
+            isNextInstalled,
+            log,
+        });
+        return fullSchema;
+    }
+    watch({ throttleDelay }) {
+        const { openapiSpec, schemaPath } = this.#cliGenerateOptions;
+        const { log, cwd, config } = this.#projectInfo;
+        if (openapiSpec) {
+            log.debug(`Watching OpenAPI spec: ${openapiSpec}`);
+            this.watchOpenApiSpec({ openApiSpec: openapiSpec, throttleDelay });
+        }
+        else {
+            const resolvedSchemaPath = path.resolve(cwd, schemaPath ?? config.schemaOutDir);
+            log.debug(`Watching schema directory: ${resolvedSchemaPath}`);
+            this.watchSchema({ schemaPath: resolvedSchemaPath, throttleDelay });
+        }
+    }
+    watchSchema({ schemaPath, throttleDelay }) {
+        const { log } = this.#projectInfo;
+        let lastGenerationTime = 0;
+        chokidar
+            .watch(schemaPath, {
+            persistent: true,
+            ignoreInitial: true,
+        })
+            .on('all', (event, path) => {
+            if (event === 'change' || event === 'add' || event === 'ready' || event === 'unlink') {
+                log.debug(`Schema file ${event}: ${path}`);
+                const now = Date.now();
+                const shouldGenerateImmediately = now - lastGenerationTime > throttleDelay;
+                const generateCode = async () => {
+                    try {
+                        lastGenerationTime = Date.now();
+                        await this.generate();
+                        log.debug(`Regenerated from schema changes`);
+                    }
+                    catch (error) {
+                        log.error(`Failed to regenerate from schema: ${error instanceof Error ? error.message : String(error)}`);
+                    }
+                };
+                // Generate immediately if it's been a while since the last generation
+                if (shouldGenerateImmediately) {
+                    generateCode();
+                }
+            }
+        });
+    }
+    watchOpenApiSpec({ openApiSpec, throttleDelay }) {
+        const fileSpecs = openApiSpec.filter((spec) => !spec.startsWith('http://') && !spec.startsWith('https://'));
+        const remoteSpecs = openApiSpec.filter((spec) => spec.startsWith('http://') || spec.startsWith('https://'));
+        if (fileSpecs.length) {
+            this.watchOpenApiSpecLocal({
+                openApiSpecPaths: fileSpecs,
+                throttleDelay,
+            });
+        }
+        if (remoteSpecs.length) {
+            remoteSpecs.forEach((spec) => {
+                this.watchOpenApiSpecRemote({
+                    openApiSpecUrl: spec,
+                    throttleDelay,
+                });
+            });
+        }
+    }
+    watchOpenApiSpecLocal({ openApiSpecPaths, throttleDelay }) {
+        const { log, cwd } = this.#projectInfo;
+        let lastGenerationTime = 0;
+        chokidar
+            .watch(openApiSpecPaths, {
+            cwd,
+            persistent: true,
+            ignoreInitial: true,
+        })
+            .on('all', (event, path) => {
+            if (event === 'change' || event === 'add' || event === 'ready' || event === 'unlink') {
+                log.debug(`OpenAPI spec file changed: ${path}`);
+                const now = Date.now();
+                const shouldGenerateImmediately = now - lastGenerationTime > throttleDelay;
+                const generateCode = async () => {
+                    try {
+                        lastGenerationTime = Date.now();
+                        await this.generate();
+                        log.debug(`Regenerated from OpenAPI spec changes`);
+                    }
+                    catch (error) {
+                        log.error(`Failed to regenerate from OpenAPI spec: ${error instanceof Error ? error.message : String(error)}`);
+                    }
+                };
+                // Generate immediately if it's been a while since the last generation
+                if (shouldGenerateImmediately) {
+                    generateCode();
+                }
+            }
+        });
+    }
+    watchOpenApiSpecRemote({ openApiSpecUrl, throttleDelay }) {
+        const { log } = this.#projectInfo;
+        let lastContent = null;
+        let isPolling = false;
+        log.info(`Polling remote OpenAPI spec at ${chalkHighlightThing(openApiSpecUrl)} every ${throttleDelay}ms`);
+        const pollRemoteSpec = async () => {
+            if (isPolling)
+                return;
+            isPolling = true;
+            try {
+                const response = await fetch(openApiSpecUrl, {
+                    headers: {
+                        Accept: 'application/json, application/yaml',
+                    },
+                });
+                if (!response.ok) {
+                    log.error(`Failed to fetch OpenAPI spec: ${response.status} ${response.statusText}`);
+                    return;
+                }
+                const content = await response.text();
+                if (lastContent === null) {
+                    lastContent = content;
+                    return;
+                }
+                if (content !== lastContent) {
+                    log.info(`Remote OpenAPI spec changed at ${chalkHighlightThing(openApiSpecUrl)}`);
+                    lastContent = content;
+                    try {
+                        await this.generate();
+                        log.debug(`Regenerated from remote OpenAPI spec changes`);
+                    }
+                    catch (error) {
+                        log.error(`Failed to regenerate from OpenAPI spec: ${error instanceof Error ? error.message : String(error)}`);
+                    }
+                }
+            }
+            catch (error) {
+                log.error(`Error polling OpenAPI spec: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            finally {
+                isPolling = false;
+            }
+        };
+        // Initial fetch
+        pollRemoteSpec();
+        // Set up polling
+        setInterval(pollRemoteSpec, throttleDelay);
+    }
+}

package/dist/generate/mergePackages.d.mts

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,55 @@
+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/generate/writeOneClientFile.d.mts

@@ -0,0 +1,37 @@
+import { 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, }: {
+    cwd: string;
+    projectInfo: ProjectInfo;
+    clientTemplateFile: ClientTemplateFile;
+    fullSchema: VovkSchema;
+    prettifyClient: boolean;
+    segmentName: string | null;
+    imports: ClientImports;
+    templateContent: string;
+    matterResult: {
+        data: {
+            imports?: string[];
+        };
+        content: string;
+    };
+    package: PackageJson;
+    readme: VovkStrictConfig['bundle']['readme'];
+    isEnsuringClient: boolean;
+    outCwdRelativeDir: string;
+    templateDef: VovkStrictConfig['clientTemplateDefs'][string];
+    locatedSegments: Segment[];
+    isNodeNextResolution: boolean;
+    hasMixins: boolean;
+    isVovkProject: boolean;
+    vovkCliPackage: PackageJson;
+    isBundle: boolean;
+    origin: string | null;
+}): Promise<{
+    written: boolean;
+}>;

package/dist/generate/writeOneClientFile.mjs

@@ -0,0 +1,122 @@
+import fs from 'fs/promises';
+import path from 'node:path';
+import ejs from 'ejs';
+import _ from 'lodash';
+import { createCodeExamples, VovkSchemaIdEnum } from 'vovk';
+import * as YAML from 'yaml';
+import TOML from '@iarna/toml';
+import prettify from '../utils/prettify.mjs';
+import { ROOT_SEGMENT_FILE_NAME } from '../dev/writeOneSegmentSchemaFile.mjs';
+import { compileJSONSchemaToTypeScriptType } from '../utils/compileJSONSchemaToTypeScriptType.mjs';
+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, }) {
+    const { config, apiRoot } = projectInfo;
+    const { templateFilePath, relativeDir } = clientTemplateFile;
+    const locatedSegmentsByName = _.keyBy(locatedSegments, 'segmentName');
+    const outPath = normalizeOutTemplatePath(path.resolve(cwd, outCwdRelativeDir, typeof segmentName === 'string' ? segmentName || ROOT_SEGMENT_FILE_NAME : '', relativeDir, path.basename(templateFilePath).replace('.ejs', '')), packageJson);
+    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.
+// Feel free to report an issue at https://github.com/finom/vovk/issues`;
+    placeholder = outPath.endsWith('.py') ? placeholder.replace(/\/\//g, '#') : placeholder;
+    const getFirstLineBanner = (type = 'c') => {
+        const text = `auto-generated by vovk-cli v${vovkCliPackage.version} at ${new Date().toISOString()}`;
+        switch (type) {
+            case 'html':
+                return `<!-- ${text} -->`;
+            case 'sh':
+                return `# ${text}`;
+            case 'c':
+                return `// ${text}`;
+        }
+    };
+    // Data for the EJS templates:
+    const t = {
+        _, // lodash
+        hasMixins,
+        isVovkProject,
+        package: packageJson,
+        readme,
+        ROOT_SEGMENT_FILE_NAME,
+        apiRoot: origin ? `${origin}/${config.rootEntry}` : apiRoot,
+        imports,
+        schema: fullSchema,
+        VovkSchemaIdEnum,
+        createCodeExamples,
+        compileJSONSchemaToTypeScriptType,
+        YAML,
+        TOML,
+        getFirstLineBanner,
+        nodeNextResolutionExt: {
+            ts: isNodeNextResolution ? '.ts' : '',
+            js: isNodeNextResolution ? '.js' : '',
+            cjs: isNodeNextResolution ? '.cjs' : '',
+            mjs: isNodeNextResolution ? '.mjs' : '',
+        },
+        schemaOutDir: typeof segmentName === 'string'
+            ? path.relative(path.join(outCwdRelativeDir, segmentName || ROOT_SEGMENT_FILE_NAME), config.schemaOutDir)
+            : path.relative(outCwdRelativeDir, config.schemaOutDir),
+        segmentMeta: Object.fromEntries(Object.values(fullSchema.segments).map(({ segmentName: sName, forceApiRoot }) => {
+            const { routeFilePath = null } = locatedSegmentsByName[sName] ?? {};
+            const segmentImportPath = routeFilePath
+                ? 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] : {}),
+            };
+            const { origin: segmentConfigOrigin, rootEntry: segmentConfigRootEntry, segmentNameOverride } = segmentConfig;
+            const reExports = { ...segmentConfig.reExports, ...(isBundle ? projectInfo.config.bundle.reExports : {}) };
+            return [
+                sName,
+                {
+                    forceApiRoot: forceApiRoot ??
+                        (segmentConfigOrigin || segmentConfigRootEntry
+                            ? `${segmentConfigOrigin ?? origin}/${segmentConfigRootEntry ?? config.rootEntry}`
+                            : null),
+                    routeFilePath,
+                    segmentImportPath,
+                    segmentNameOverride,
+                    reExports: _.mapValues(reExports ?? {}, (p) => p.startsWith('.')
+                        ? path.relative(path.join(outCwdRelativeDir, typeof segmentName === 'string' ? segmentName || ROOT_SEGMENT_FILE_NAME : '.'), path.resolve(cwd, p))
+                        : p),
+                },
+            ];
+        })),
+    };
+    if (data.imports instanceof Array) {
+        for (const imp of data.imports) {
+            t.imports = {
+                ...t.imports,
+                [imp]: await import(imp),
+            };
+        }
+    }
+    // Render the template
+    let rendered = templateFilePath.endsWith('.ejs')
+        ? await ejs.render(content, { t }, {
+            filename: templateFilePath,
+            async: true,
+        })
+        : templateContent;
+    // Optionally prettify
+    if (prettifyClient) {
+        rendered = await prettify(rendered, outPath);
+    }
+    if (isEnsuringClient) {
+        rendered = rendered + `\n\n${placeholder}`;
+    }
+    // Read existing file content to compare
+    const existingContent = await fs.readFile(outPath, 'utf-8').catch(() => null);
+    // Determine if we need to rewrite the file, ignore 1st line
+    const needsWriting = isEnsuringClient
+        ? !existingContent
+        : !existingContent ||
+            existingContent.trim().split('\n').slice(1).join('\n') !== rendered.trim().split('\n').slice(1).join('\n');
+    if (needsWriting) {
+        await fs.mkdir(path.dirname(outPath), { recursive: true });
+        await fs.writeFile(outPath, rendered, 'utf-8');
+    }
+    return { written: needsWriting };
+}

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

@@ -0,0 +1,5 @@
+export default function getConfigAbsolutePaths({ cwd, configPath, relativePath, }: {
+    cwd: string;
+    configPath?: string;
+    relativePath?: string;
+}): Promise<string[]>;

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

@@ -1,6 +1,9 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
-export default async function getConfigAbsolutePaths({ cwd, relativePath, }) {
+export default async function getConfigAbsolutePaths({ cwd, configPath, relativePath, }) {
+    if (configPath) {
+        return [path.resolve(cwd, configPath)];
+    }
     const rootDir = path.resolve(cwd, relativePath || '');
     const baseName = 'vovk.config';
     const extensions = ['cjs', 'mjs', 'js'];

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

@@ -0,0 +1,22 @@
+import type { VovkStrictConfig } from 'vovk';
+export declare enum BuiltInTemplateName {
+    ts = "ts",
+    cjs = "cjs",
+    mjs = "mjs",
+    schemaTs = "schemaTs",
+    schemaCjs = "schemaCjs",
+    schemaJson = "schemaJson",
+    standaloneTypesTs = "standaloneTypesTs",
+    readme = "readme",
+    packageJson = "packageJson",
+    mixins = "mixins",
+    rsSrc = "rsSrc",
+    rsPkg = "rsPkg",
+    rsReadme = "rsReadme",
+    rs = "rs",
+    pySrc = "pySrc",
+    pyPkg = "pyPkg",
+    pyReadme = "pyReadme",
+    py = "py"
+}
+export default function getTemplateDefs(userTemplateDefs?: VovkStrictConfig['clientTemplateDefs']): VovkStrictConfig['clientTemplateDefs'];

package/dist/getProjectInfo/getConfig/getTemplateDefs.mjs

@@ -0,0 +1,145 @@
+export var BuiltInTemplateName;
+(function (BuiltInTemplateName) {
+    // ts/js
+    BuiltInTemplateName["ts"] = "ts";
+    BuiltInTemplateName["cjs"] = "cjs";
+    BuiltInTemplateName["mjs"] = "mjs";
+    // schema
+    BuiltInTemplateName["schemaTs"] = "schemaTs";
+    BuiltInTemplateName["schemaCjs"] = "schemaCjs";
+    BuiltInTemplateName["schemaJson"] = "schemaJson";
+    // types
+    BuiltInTemplateName["standaloneTypesTs"] = "standaloneTypesTs";
+    // misc
+    BuiltInTemplateName["readme"] = "readme";
+    BuiltInTemplateName["packageJson"] = "packageJson";
+    BuiltInTemplateName["mixins"] = "mixins";
+    // other languages (packages installed separately)
+    BuiltInTemplateName["rsSrc"] = "rsSrc";
+    BuiltInTemplateName["rsPkg"] = "rsPkg";
+    BuiltInTemplateName["rsReadme"] = "rsReadme";
+    BuiltInTemplateName["rs"] = "rs";
+    BuiltInTemplateName["pySrc"] = "pySrc";
+    BuiltInTemplateName["pyPkg"] = "pyPkg";
+    BuiltInTemplateName["pyReadme"] = "pyReadme";
+    BuiltInTemplateName["py"] = "py";
+})(BuiltInTemplateName || (BuiltInTemplateName = {}));
+export default function getTemplateDefs(userTemplateDefs = {}) {
+    const defs = {};
+    const builtInDefs = {
+        [BuiltInTemplateName.ts]: {
+            templatePath: `vovk-cli/client-templates/${BuiltInTemplateName.ts}/`,
+            requires: {
+                [BuiltInTemplateName.schemaTs]: '.',
+                [BuiltInTemplateName.mixins]: '.', // used conditionally if OpenAPI mixins are used
+            },
+        },
+        [BuiltInTemplateName.cjs]: {
+            templatePath: `vovk-cli/client-templates/${BuiltInTemplateName.cjs}/`,
+            requires: {
+                [BuiltInTemplateName.schemaCjs]: '.',
+                [BuiltInTemplateName.mixins]: '.', // used conditionally if OpenAPI mixins are used
+            },
+        },
+        [BuiltInTemplateName.mjs]: {
+            templatePath: `vovk-cli/client-templates/${BuiltInTemplateName.mjs}/`,
+            requires: {
+                [BuiltInTemplateName.schemaCjs]: '.',
+                [BuiltInTemplateName.mixins]: '.', // used conditionally if OpenAPI mixins are used
+            },
+        },
+        [BuiltInTemplateName.schemaTs]: {
+            templatePath: `vovk-cli/client-templates/${BuiltInTemplateName.schemaTs}/`,
+        },
+        [BuiltInTemplateName.schemaCjs]: {
+            templatePath: `vovk-cli/client-templates/${BuiltInTemplateName.schemaCjs}/`,
+        },
+        [BuiltInTemplateName.schemaJson]: {
+            templatePath: `vovk-cli/client-templates/${BuiltInTemplateName.schemaJson}/`,
+        },
+        [BuiltInTemplateName.readme]: {
+            templatePath: `vovk-cli/client-templates/${BuiltInTemplateName.readme}/`,
+        },
+        [BuiltInTemplateName.packageJson]: {
+            templatePath: `vovk-cli/client-templates/${BuiltInTemplateName.packageJson}/`,
+        },
+        [BuiltInTemplateName.mixins]: {
+            templatePath: `vovk-cli/client-templates/${BuiltInTemplateName.mixins}/`,
+        },
+        [BuiltInTemplateName.rsSrc]: {
+            templatePath: `vovk-rust/client-templates/${BuiltInTemplateName.rsSrc}/`,
+            requires: {
+                [BuiltInTemplateName.schemaJson]: './',
+            },
+        },
+        [BuiltInTemplateName.rsPkg]: {
+            templatePath: `vovk-rust/client-templates/${BuiltInTemplateName.rsPkg}/`,
+        },
+        [BuiltInTemplateName.rsReadme]: {
+            templatePath: `vovk-rust/client-templates/${BuiltInTemplateName.rsReadme}/`,
+        },
+        [BuiltInTemplateName.rs]: {
+            composedClient: {
+                outDir: 'dist_rust',
+            },
+            requires: {
+                [BuiltInTemplateName.rsSrc]: './src/',
+                [BuiltInTemplateName.rsPkg]: './',
+                [BuiltInTemplateName.rsReadme]: './',
+            },
+        },
+        [BuiltInTemplateName.pySrc]: {
+            templatePath: `vovk-python/client-templates/${BuiltInTemplateName.pySrc}/`,
+            requires: {
+                [BuiltInTemplateName.schemaJson]: '.',
+            },
+        },
+        [BuiltInTemplateName.pyPkg]: {
+            templatePath: `vovk-python/client-templates/${BuiltInTemplateName.pyPkg}/`,
+        },
+        [BuiltInTemplateName.pyReadme]: {
+            templatePath: `vovk-python/client-templates/${BuiltInTemplateName.pyReadme}/`,
+        },
+        [BuiltInTemplateName.py]: {
+            composedClient: {
+                outDir: 'dist_python',
+            },
+            requires: {
+                [BuiltInTemplateName.pySrc]: './src/[package_name]/',
+                [BuiltInTemplateName.pyPkg]: './',
+                [BuiltInTemplateName.pyReadme]: './',
+            },
+        },
+    };
+    for (const [name, templateDef] of Object.entries(userTemplateDefs)) {
+        if ('extends' in templateDef) {
+            if (templateDef.extends) {
+                const builtIn = builtInDefs[templateDef.extends];
+                if (!builtIn) {
+                    throw new Error(`Unknown template extends: ${templateDef.extends}`);
+                }
+                defs[name] = {
+                    ...builtIn,
+                    ...templateDef,
+                    composedClient: {
+                        ...builtIn.composedClient,
+                        ...templateDef.composedClient,
+                    },
+                    segmentedClient: {
+                        ...builtIn.segmentedClient,
+                        ...templateDef.segmentedClient,
+                    },
+                    segmentConfig: {
+                        ...builtIn.segmentConfig,
+                        ...templateDef.segmentConfig,
+                    },
+                    // 'requires' and other props will be overridden
+                };
+            }
+        }
+        else {
+            defs[name] = templateDef;
+        }
+    }
+    return { ...builtInDefs, ...defs };
+}

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

@@ -1,5 +1,6 @@
-import type { VovkConfig } from '../types.mjs';
-declare function getUserConfig({ cwd, }: {
+import type { VovkConfig } from 'vovk';
+declare function getUserConfig({ configPath: givenConfigPath, cwd, }: {
+    configPath?: string;
     cwd: string;
 }): Promise<{
     userConfig: VovkConfig | null;

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

@@ -1,10 +1,11 @@
+import { pathToFileURL } from 'node:url';
 import getConfigAbsolutePaths from './getConfigAbsolutePaths.mjs';
 import importUncachedModule from './importUncachedModule.mjs';
-async function getUserConfig({ cwd, }) {
-    const configAbsolutePaths = await getConfigAbsolutePaths({ cwd });
+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
@@ -14,7 +15,8 @@ async function getUserConfig({ cwd, }) {
     catch {
         try {
             const cacheBuster = Date.now();
-            ({ default: userConfig } = (await import(`${configPath}?cache=${cacheBuster}`)));
+            const configPathUrl = pathToFileURL(configPath).href;
+            ({ default: userConfig } = (await import(`${configPathUrl}?cache=${cacheBuster}`)));
         }
         catch (e) {
             return { userConfig: null, configAbsolutePaths, error: e };