vovk-cli 0.0.1-draft.39 → 0.0.1-draft.392

package/dist/generate/generate.mjs

@@ -0,0 +1,300 @@
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import matter from 'gray-matter';
+import _ from 'lodash';
+import { openAPIToVovkSchema, vovkSchemaToOpenAPI, } 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 writeOneClientFile, { normalizeOutTemplatePath } from './writeOneClientFile.mjs';
+import { ROOT_SEGMENT_FILE_NAME } from '../dev/writeOneSegmentSchemaFile.mjs';
+import { getTsconfig } from 'get-tsconfig';
+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);
+    const includeSegments = cliGenerateOptions?.[configKey === 'segmentedClient' ? 'segmentedIncludeSegments' : 'composedIncludeSegments'] ??
+        config[configKey].includeSegments;
+    const excludeSegments = cliGenerateOptions?.[configKey === 'segmentedClient' ? 'segmentedExcludeSegments' : 'composedExcludeSegments'] ??
+        config[configKey].excludeSegments;
+    if (includeSegments?.length && excludeSegments?.length) {
+        throw new Error(`Both includeSegments and excludeSegments are set in "${configKey}" config. Please use only one of them.`);
+    }
+    const includedSegmentNames = Array.isArray(includeSegments) && includeSegments.length
+        ? includeSegments.map((segmentName) => {
+            const segment = segments.find(({ segmentName: sName }) => sName === segmentName);
+            if (!segment) {
+                throw new Error(`Segment "${segmentName}" not found in the config for "${configKey}"`);
+            }
+            return segment.segmentName;
+        })
+        : Array.isArray(excludeSegments) && excludeSegments.length // TODO: Warn if excludeSegments includes a segment name that is not listed at segments
+            ? segments
+                .filter(({ segmentName }) => !excludeSegments?.includes(segmentName))
+                .map(({ segmentName }) => segmentName)
+            : segments.map(({ segmentName }) => segmentName);
+    return includedSegmentNames;
+};
+function logClientGenerationResults({ results, log, isEnsuringClient = false, forceNothingWrittenLog = false, clientType = 'Composed', startTime, fromTemplates, }) {
+    const writtenResults = results.filter(({ written }) => written);
+    const duration = Date.now() - startTime;
+    const groupedByDir = _.groupBy(writtenResults, ({ outAbsoluteDir }) => outAbsoluteDir);
+    const logOrDebug = forceNothingWrittenLog ? log.info : log.debug;
+    if (writtenResults.length) {
+        for (const [outAbsoluteDir, dirResults] of Object.entries(groupedByDir)) {
+            const templateNames = _.uniq(dirResults.map(({ templateName }) => templateName));
+            log.info(`${clientType} client${isEnsuringClient ? ' placeholder' : ''} is generated to ${chalkHighlightThing(normalizeOutTemplatePath(outAbsoluteDir, dirResults[0].package))} from template${templateNames.length !== 1 ? 's' : ''} ${chalkHighlightThing(templateNames.map((s) => `"${s}"`).join(', '))} in ${duration}ms`);
+        }
+    }
+    else if (fromTemplates.length) {
+        if (!writtenResults.length) {
+            logOrDebug(`${clientType} client${isEnsuringClient ? ' placeholder' : ''} is up to date (${duration}ms)`);
+        }
+        else if (!isEnsuringClient) {
+            for (const [outAbsoluteDir, dirResults] of Object.entries(groupedByDir)) {
+                const templateNames = _.uniq(dirResults.map(({ templateName }) => templateName));
+                logOrDebug(`${clientType} client that was generated to ${chalkHighlightThing(normalizeOutTemplatePath(outAbsoluteDir, dirResults[0].package))} from template${templateNames.length !== 1 ? 's' : ''} ${chalkHighlightThing(templateNames.map((s) => `"${s}"`).join(', '))} is up to date and doesn't need to be regenerated (${duration}ms)`);
+            }
+        }
+    }
+    else {
+        logOrDebug(`${clientType} client${isEnsuringClient ? ' placeholder' : ''} is not generated because no files were written (${duration}ms)`);
+    }
+}
+const cliOptionsToOpenAPIMixins = ({ openapiGetMethodName, openapiGetModuleName, openapiRootUrl, openapiSpec, openapiFallback, openapiMixinName, }) => {
+    return Object.fromEntries((openapiSpec?.map((spec, i) => {
+        return {
+            source: spec.startsWith('http://') || spec.startsWith('https://')
+                ? { url: spec, fallback: openapiFallback?.[i] }
+                : { file: spec },
+            apiRoot: openapiRootUrl?.[i] ?? '',
+            getModuleName: openapiGetModuleName?.[i] ?? 'api',
+            getMethodName: openapiGetMethodName?.[i] ?? 'auto',
+            mixinName: openapiMixinName?.[i] ?? 'mixin' + (i > 0 ? i + 1 : ''),
+        };
+    }) || []).map(({ source, apiRoot, getModuleName, getMethodName, mixinName }) => [
+        mixinName,
+        {
+            source,
+            apiRoot,
+            getModuleName,
+            getMethodName,
+            mixinName,
+        },
+    ]));
+};
+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))
+            // preserve original object, so segments can be extended
+            .map((segment) => ({ ...segment }))),
+    };
+    const { config, cwd, log, srcRoot, vovkCliPackage, packageJson: projectPackageJson } = projectInfo;
+    Object.entries(config.outputConfig.segments ?? {})
+        .filter(([, segmentConfig]) => segmentConfig.openAPIMixin)
+        .forEach(([segmentName, segmentConfig]) => {
+        fullSchema.segments = {
+            ...fullSchema.segments,
+            [segmentName]: openAPIToVovkSchema({ ...segmentConfig.openAPIMixin, segmentName }).segments[segmentName],
+        };
+    });
+    const cliMixins = cliOptionsToOpenAPIMixins(cliGenerateOptions ?? {});
+    fullSchema.segments = {
+        ...fullSchema.segments,
+        ...Object.fromEntries(await Promise.all(Object.entries(cliMixins).map(async ([mixinName, mixinModule]) => {
+            return [
+                mixinName,
+                openAPIToVovkSchema({
+                    segmentName: mixinName,
+                    ...(await normalizeOpenAPIMixin({ mixinModule, log })),
+                }).segments[mixinName],
+            ];
+        }))),
+    };
+    const moduleResolution = await getTsconfig(cwd)?.config?.compilerOptions?.moduleResolution?.toLowerCase();
+    const isNodeNextResolution = !moduleResolution || ['node16', 'nodenext'].includes(moduleResolution ?? '');
+    const isVovkProject = !!srcRoot;
+    const isComposedEnabled = cliGenerateOptions?.composedOnly ||
+        !!cliGenerateOptions?.composedFrom ||
+        !!cliGenerateOptions?.composedOut ||
+        (config.composedClient?.enabled && !cliGenerateOptions?.segmentedOnly);
+    const isSegmentedEnabled = cliGenerateOptions?.segmentedOnly ||
+        !!cliGenerateOptions?.segmentedFrom ||
+        !!cliGenerateOptions?.segmentedOut ||
+        (config.segmentedClient?.enabled && !cliGenerateOptions?.composedOnly);
+    if (isComposedEnabled) {
+        const now = Date.now();
+        const segmentNames = getIncludedSegmentNames(config, fullSchema, 'composedClient', cliGenerateOptions);
+        const { templateFiles: composedClientTemplateFiles, fromTemplates } = await getClientTemplateFiles({
+            config,
+            cwd,
+            log,
+            cliGenerateOptions,
+            configKey: 'composedClient',
+        });
+        const composedClientResults = await Promise.all(composedClientTemplateFiles.map(async (clientTemplateFile) => {
+            const { templateFilePath, templateName, templateDef, outCwdRelativeDir } = clientTemplateFile;
+            const templateContent = await fs.readFile(templateFilePath, 'utf-8');
+            const matterResult = templateFilePath.endsWith('.ejs')
+                ? matter(templateContent)
+                : { data: { imports: [] }, content: templateContent };
+            const { package: packageJson, readme, origin, samples, reExports, openAPIObject, } = vovkSchemaToOpenAPI({
+                config: projectInfo.config,
+                rootEntry: config.rootEntry,
+                schema: fullSchema,
+                outputConfigs: [templateDef.outputConfig ?? {}, { origin: cliGenerateOptions?.origin }],
+                projectPackageJson,
+                isBundle,
+                segmentName: null,
+            });
+            const composedFullSchema = pickSegmentFullSchema(fullSchema, segmentNames);
+            const hasMixins = Object.values(composedFullSchema.segments).some((segment) => segment.segmentType === 'mixin');
+            if (templateName === BuiltInTemplateName.mixins && !hasMixins) {
+                return null;
+            }
+            const { written } = await writeOneClientFile({
+                cwd,
+                projectInfo,
+                clientTemplateFile,
+                fullSchema: composedFullSchema,
+                prettifyClient: cliGenerateOptions?.prettify ?? config.composedClient.prettifyClient,
+                segmentName: null,
+                templateContent,
+                matterResult,
+                openAPIObject,
+                package: packageJson,
+                readme,
+                samples,
+                reExports,
+                isEnsuringClient,
+                outCwdRelativeDir,
+                templateDef,
+                locatedSegments,
+                isNodeNextResolution,
+                hasMixins,
+                isVovkProject,
+                vovkCliPackage,
+                isBundle,
+                origin,
+                configKey: 'composedClient',
+                cliSchemaPath: cliGenerateOptions?.schemaPath ?? null,
+                projectConfig: config,
+            });
+            const outAbsoluteDir = path.resolve(cwd, outCwdRelativeDir);
+            return {
+                written,
+                templateName,
+                outAbsoluteDir,
+                package: packageJson,
+            };
+        }));
+        if (composedClientTemplateFiles.length) {
+            logClientGenerationResults({
+                results: composedClientResults.filter((result) => !!result),
+                log,
+                isEnsuringClient,
+                forceNothingWrittenLog,
+                clientType: 'Composed',
+                startTime: now,
+                fromTemplates,
+            });
+        }
+        else {
+            log.warn('No composed client template files found. Skipping composed client generation.');
+        }
+    }
+    if (isSegmentedEnabled) {
+        const now = Date.now();
+        const segmentNames = getIncludedSegmentNames(config, fullSchema, 'segmentedClient', cliGenerateOptions);
+        const { templateFiles: segmentedClientTemplateFiles, fromTemplates } = await getClientTemplateFiles({
+            config,
+            cwd,
+            log,
+            cliGenerateOptions,
+            configKey: 'segmentedClient',
+        });
+        const segmentedClientResults = await Promise.all(segmentedClientTemplateFiles.map(async (clientTemplateFile) => {
+            const { templateFilePath, templateName, templateDef, outCwdRelativeDir } = clientTemplateFile;
+            const templateContent = await fs.readFile(templateFilePath, 'utf-8');
+            const matterResult = templateFilePath.endsWith('.ejs')
+                ? matter(templateContent)
+                : { data: { imports: [] }, content: templateContent };
+            const results = await Promise.all(segmentNames.map(async (segmentName) => {
+                const segmentedFullSchema = pickSegmentFullSchema(fullSchema, [segmentName]);
+                const hasMixins = Object.values(segmentedFullSchema.segments).some((segment) => segment.segmentType === 'mixin');
+                if (templateName === BuiltInTemplateName.mixins && !hasMixins) {
+                    return null;
+                }
+                const { package: packageJson, readme, origin, samples, reExports, openAPIObject, } = vovkSchemaToOpenAPI({
+                    config: projectInfo.config,
+                    schema: fullSchema,
+                    rootEntry: config.rootEntry,
+                    segmentName,
+                    outputConfigs: [templateDef.outputConfig ?? {}, { origin: cliGenerateOptions?.origin }],
+                    isBundle,
+                    projectPackageJson,
+                });
+                const { written } = await writeOneClientFile({
+                    cwd,
+                    projectInfo,
+                    clientTemplateFile,
+                    fullSchema: segmentedFullSchema,
+                    prettifyClient: cliGenerateOptions?.prettify ?? config.segmentedClient.prettifyClient,
+                    segmentName,
+                    templateContent,
+                    matterResult,
+                    openAPIObject,
+                    package: packageJson,
+                    readme,
+                    samples,
+                    reExports,
+                    isEnsuringClient,
+                    outCwdRelativeDir,
+                    templateDef,
+                    locatedSegments,
+                    isNodeNextResolution,
+                    hasMixins,
+                    isVovkProject,
+                    vovkCliPackage,
+                    isBundle,
+                    origin,
+                    configKey: 'segmentedClient',
+                    cliSchemaPath: cliGenerateOptions?.schemaPath ?? null,
+                    projectConfig: config,
+                });
+                return {
+                    written,
+                    templateName,
+                    package: packageJson,
+                };
+            }));
+            const outAbsoluteDir = path.resolve(cwd, outCwdRelativeDir);
+            // Remove unlisted directories in the output directory
+            await removeUnlistedDirectories(outAbsoluteDir, segmentNames.map((s) => s || ROOT_SEGMENT_FILE_NAME));
+            return {
+                written: results.filter((result) => !!result).some(({ written }) => written),
+                templateName,
+                outAbsoluteDir,
+                package: results[0]?.package || {}, // TODO: Might be wrong in Python segmented client (unknown use case)
+            };
+        }));
+        if (segmentedClientTemplateFiles.length) {
+            logClientGenerationResults({
+                results: segmentedClientResults,
+                log,
+                isEnsuringClient,
+                forceNothingWrittenLog,
+                clientType: 'Segmented',
+                startTime: now,
+                fromTemplates,
+            });
+        }
+        else {
+            log.warn('No segmented client template files found. Skipping segmented client generation.');
+        }
+    }
+}

package/dist/generate/getClientTemplateFiles.d.mts

@@ -0,0 +1,20 @@
+import type { VovkStrictConfig } from 'vovk';
+import type { ProjectInfo } from '../getProjectInfo/index.mjs';
+import type { GenerateOptions } from '../types.mjs';
+export interface ClientTemplateFile {
+    templateName: string;
+    templateFilePath: string;
+    relativeDir: string;
+    outCwdRelativeDir: string;
+    templateDef: VovkStrictConfig['clientTemplateDefs'][string];
+}
+export default function getClientTemplateFiles({ config, cwd, log, configKey, cliGenerateOptions, }: {
+    config: VovkStrictConfig;
+    cwd: string;
+    log: ProjectInfo['log'];
+    configKey: 'composedClient' | 'segmentedClient';
+    cliGenerateOptions?: GenerateOptions;
+}): Promise<{
+    fromTemplates: string[];
+    templateFiles: ClientTemplateFile[];
+}>;

package/dist/generate/getClientTemplateFiles.mjs

@@ -0,0 +1,85 @@
+import path from 'node:path';
+import { glob } from 'glob';
+import resolveAbsoluteModulePath from '../utils/resolveAbsoluteModulePath.mjs';
+import getFileSystemEntryType, { FileSystemEntryType } from '../utils/getFileSystemEntryType.mjs';
+import getPublicModuleNameFromPath from '../utils/getPublicModuleNameFromPath.mjs';
+import omit from 'lodash/omit.js';
+import merge from 'lodash/merge.js';
+export default async function getClientTemplateFiles({ config, cwd, log, configKey, cliGenerateOptions, }) {
+    const usedTemplateDefs = {};
+    const fromTemplates = configKey === 'composedClient'
+        ? cliGenerateOptions?.composedFrom || cliGenerateOptions?.segmentedFrom
+            ? (cliGenerateOptions?.composedFrom ?? [])
+            : config.composedClient.fromTemplates
+        : cliGenerateOptions?.composedFrom || cliGenerateOptions?.segmentedFrom
+            ? (cliGenerateOptions?.segmentedFrom ?? [])
+            : config.segmentedClient.fromTemplates;
+    const cliOutDir = configKey === 'composedClient' ? cliGenerateOptions?.composedOut : cliGenerateOptions?.segmentedOut;
+    const configOutDir = config[configKey].outDir;
+    for (const templateName of fromTemplates) {
+        if (!(templateName in config.clientTemplateDefs)) {
+            throw new Error(`Unknown template name: ${templateName}`);
+        }
+        usedTemplateDefs[templateName] = config.clientTemplateDefs[templateName];
+    }
+    const templateFiles = [];
+    const entries = Object.entries(usedTemplateDefs);
+    for (let i = 0; i < entries.length; i++) {
+        const [templateName, templateDef, forceOutCwdRelativeDir] = entries[i];
+        const templateAbsolutePath = templateDef.templatePath
+            ? resolveAbsoluteModulePath(templateDef.templatePath, cwd)
+            : null;
+        const entryType = templateAbsolutePath ? await getFileSystemEntryType(templateAbsolutePath) : null;
+        if (templateAbsolutePath && !entryType) {
+            const { moduleName } = templateDef.templatePath ? getPublicModuleNameFromPath(templateDef.templatePath) : {};
+            if (moduleName) {
+                throw new Error(`Unable to locate template path "${templateDef.templatePath}" resolved as "${templateAbsolutePath}". You may need to install the package "${moduleName}" first.`);
+            }
+            throw new Error(`Unable to locate template path "${templateDef.templatePath}" resolved as "${templateAbsolutePath}"`);
+        }
+        const defOutDir = configKey === 'composedClient' ? templateDef.composedClient?.outDir : templateDef.segmentedClient?.outDir;
+        let files = [];
+        const outCwdRelativeDir = forceOutCwdRelativeDir ?? cliOutDir ?? defOutDir ?? configOutDir;
+        if (templateAbsolutePath) {
+            if (entryType === FileSystemEntryType.FILE) {
+                files = [{ filePath: templateAbsolutePath, isSingleFileTemplate: true }];
+            }
+            else {
+                const globPath = path.join(templateAbsolutePath, '**/*.*');
+                files = (await glob(globPath)).map((filePath) => ({
+                    filePath,
+                    isSingleFileTemplate: false,
+                }));
+            }
+            if (files.length === 0) {
+                log.error(`Template "${templateAbsolutePath}" not found`);
+                continue;
+            }
+            for (const { filePath, isSingleFileTemplate } of files) {
+                templateFiles.push({
+                    templateName,
+                    templateFilePath: filePath,
+                    relativeDir: path.relative(isSingleFileTemplate ? path.dirname(templateAbsolutePath) : templateAbsolutePath, path.dirname(filePath) + '/'),
+                    outCwdRelativeDir,
+                    templateDef,
+                });
+            }
+        }
+        if (templateDef.requires) {
+            for (const [tName, reqRelativeDir] of Object.entries(templateDef.requires)) {
+                let def = config.clientTemplateDefs[tName];
+                if (!def) {
+                    throw new Error(`Template "${tName}" required by "${templateName}" not found`);
+                }
+                def = {
+                    ...def,
+                    outputConfig: merge({}, templateDef?.outputConfig, def.outputConfig),
+                    composedClient: merge(omit(templateDef?.composedClient ?? {}, ['outDir']), def.composedClient),
+                    segmentedClient: merge(omit(templateDef?.segmentedClient ?? {}, ['outDir']), def.segmentedClient),
+                };
+                entries.push([tName, def, path.join(outCwdRelativeDir, reqRelativeDir)]);
+            }
+        }
+    }
+    return { fromTemplates, templateFiles };
+}

package/dist/generate/getProjectFullSchema.d.mts

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

package/dist/generate/getProjectFullSchema.mjs

@@ -0,0 +1,66 @@
+import { readFile, access } from 'node:fs/promises';
+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';
+import getMetaSchema from '../getProjectInfo/getMetaSchema.mjs';
+import deepExtend from '../utils/deepExtend.mjs';
+export async function getProjectFullSchema({ schemaOutAbsolutePath, isNextInstalled, log, config, }) {
+    const result = {
+        $schema: VovkSchemaIdEnum.SCHEMA,
+        segments: {},
+        meta: getMetaSchema({
+            config,
+            useEmitConfig: false,
+        }),
+    };
+    const isEmptyLogOrWarn = isNextInstalled ? log.warn : log.debug;
+    // Handle config.json
+    const metaPath = path.join(schemaOutAbsolutePath, `${META_FILE_NAME}.json`);
+    try {
+        const metaContent = await readFile(metaPath, 'utf-8');
+        const fromFileMeta = JSON.parse(metaContent);
+        result.meta = deepExtend({}, result.meta, fromFileMeta);
+    }
+    catch {
+        isEmptyLogOrWarn(`${META_FILE_NAME}.json not found at ${metaPath}. Using empty meta as fallback.`);
+    }
+    // Handle segments directory
+    const segmentsDir = path.join(schemaOutAbsolutePath);
+    try {
+        await access(segmentsDir); // Check if directory exists
+        // Use glob to get all JSON files recursively
+        const files = await glob(`${segmentsDir}/**/*.json`);
+        const filePaths = [];
+        for await (const filePath of files) {
+            if (path.basename(filePath) === `${META_FILE_NAME}.json`)
+                continue; // Skip _meta.json
+            filePaths.push(filePath);
+        }
+        // Process each JSON file
+        for (const filePath of filePaths.toSorted()) {
+            try {
+                const content = await readFile(filePath, 'utf-8');
+                const jsonData = JSON.parse(content);
+                // Get relative path from segments directory and convert to key
+                let relativePath = path
+                    .relative(segmentsDir, filePath)
+                    .replace(/\.json$/, '') // Remove .json extension
+                    .replace(/\\/g, '/'); // Normalize to forward slashes
+                // Special case for _root.json
+                if (path.basename(filePath) === `${ROOT_SEGMENT_FILE_NAME}.json` && path.dirname(filePath) === segmentsDir) {
+                    relativePath = '';
+                }
+                result.segments[relativePath] = jsonData;
+            }
+            catch (error) {
+                log.warn(`Failed to process file ${filePath}: ${error}`);
+            }
+        }
+    }
+    catch {
+        isEmptyLogOrWarn(`Segments directory not found at ${segmentsDir}. Using empty segments as fallback.`);
+        result.segments = {};
+    }
+    return result;
+}

package/dist/generate/getTemplateClientImports.d.mts

@@ -0,0 +1,21 @@
+import { VovkStrictConfig, type VovkSchema } from 'vovk';
+export type ClientImports = {
+    fetcher: string;
+    validateOnClient: string | null;
+    createRPC: string;
+};
+export default function getTemplateClientImports({ config, fullSchema, outCwdRelativeDir, segmentName, isBundle, outputConfigs, }: {
+    config: VovkStrictConfig;
+    fullSchema: VovkSchema;
+    outCwdRelativeDir: string;
+    segmentName: string | null;
+    isBundle: boolean;
+    outputConfigs: VovkStrictConfig['outputConfig'][];
+}): {
+    composedClient: ClientImports & {
+        module: ClientImports;
+    };
+    segmentedClient: Record<string, ClientImports & {
+        module: ClientImports;
+    }>;
+};

package/dist/generate/getTemplateClientImports.mjs

@@ -0,0 +1,56 @@
+import path from 'node:path';
+import { resolveGeneratorConfigValues } from 'vovk';
+import { ROOT_SEGMENT_FILE_NAME } from '../dev/writeOneSegmentSchemaFile.mjs';
+export default function getTemplateClientImports({ config, fullSchema, outCwdRelativeDir, segmentName, isBundle, outputConfigs, }) {
+    const { imports: configImports } = resolveGeneratorConfigValues({
+        config,
+        schema: fullSchema,
+        segmentName,
+        isBundle,
+        projectPackageJson: undefined,
+        outputConfigs,
+    });
+    const validateOnClientImport = configImports?.validateOnClient ?? null;
+    const fetcherImport = configImports?.fetcher ?? 'vovk';
+    const createRPCImport = configImports?.createRPC ?? 'vovk';
+    const imports = {
+        fetcher: typeof fetcherImport === 'string' ? [fetcherImport] : fetcherImport,
+        validateOnClient: typeof validateOnClientImport === 'string'
+            ? [validateOnClientImport]
+            : (validateOnClientImport ?? null),
+        createRPC: typeof createRPCImport === 'string' ? [createRPCImport] : createRPCImport,
+    };
+    const getImportPath = (p, s = '') => p.startsWith('.') ? path.relative(path.join(outCwdRelativeDir, s), p) : p;
+    const clientImports = {
+        composedClient: {
+            fetcher: getImportPath(imports.fetcher[0]),
+            createRPC: getImportPath(imports.createRPC[0]),
+            validateOnClient: imports.validateOnClient ? getImportPath(imports.validateOnClient[0]) : null,
+            module: {
+                fetcher: getImportPath(imports.fetcher[1] ?? imports.fetcher[0]),
+                createRPC: getImportPath(imports.createRPC[1] ?? imports.createRPC[0]),
+                validateOnClient: imports.validateOnClient
+                    ? getImportPath(imports.validateOnClient[1] ?? imports.validateOnClient[0])
+                    : null,
+            },
+        },
+        segmentedClient: Object.fromEntries(Object.values(fullSchema.segments).map((segment) => [
+            segment.segmentName,
+            {
+                fetcher: getImportPath(imports.fetcher[0], segment.segmentName || ROOT_SEGMENT_FILE_NAME),
+                createRPC: getImportPath(imports.createRPC[0], segment.segmentName || ROOT_SEGMENT_FILE_NAME),
+                validateOnClient: imports.validateOnClient
+                    ? getImportPath(imports.validateOnClient[0], segment.segmentName || ROOT_SEGMENT_FILE_NAME)
+                    : null,
+                module: {
+                    fetcher: getImportPath(imports.fetcher[1] ?? imports.fetcher[0], segment.segmentName || ROOT_SEGMENT_FILE_NAME),
+                    createRPC: getImportPath(imports.createRPC[1] ?? imports.createRPC[0], segment.segmentName || ROOT_SEGMENT_FILE_NAME),
+                    validateOnClient: imports.validateOnClient
+                        ? getImportPath(imports.validateOnClient[1] ?? imports.validateOnClient[0], segment.segmentName || ROOT_SEGMENT_FILE_NAME)
+                        : null,
+                },
+            },
+        ])),
+    };
+    return clientImports;
+}

package/dist/generate/index.d.mts

@@ -0,0 +1,33 @@
+import { type VovkSchema } from 'vovk';
+import type { GenerateOptions } from '../types.mjs';
+import type { ProjectInfo } from '../getProjectInfo/index.mjs';
+export declare class VovkGenerate {
+    #private;
+    constructor({ cliGenerateOptions, projectInfo, forceNothingWrittenLog, }: {
+        cliGenerateOptions: GenerateOptions;
+        projectInfo: ProjectInfo;
+        forceNothingWrittenLog?: boolean;
+    });
+    start(): void;
+    generate(): Promise<void>;
+    getFullSchema(): Promise<VovkSchema>;
+    watch({ throttleDelay }: {
+        throttleDelay: number;
+    }): void;
+    watchSchema({ schemaPath, throttleDelay }: {
+        schemaPath: string;
+        throttleDelay: number;
+    }): void;
+    watchOpenApiSpec({ openApiSpec, throttleDelay }: {
+        openApiSpec: string[];
+        throttleDelay: number;
+    }): void;
+    watchOpenApiSpecLocal({ openApiSpecPaths, throttleDelay }: {
+        openApiSpecPaths: string[];
+        throttleDelay: number;
+    }): void;
+    watchOpenApiSpecRemote({ openApiSpecUrl, throttleDelay }: {
+        openApiSpecUrl: string;
+        throttleDelay: number;
+    }): void;
+}