vovk-cli 0.0.1-draft.12 → 0.0.1-draft.121

package/dist/generate/getClientTemplates.mjs

@@ -0,0 +1,86 @@
+import path from 'node:path';
+import { glob } from 'node:fs/promises';
+import resolveAbsoluteModulePath from '../utils/resolveAbsoluteModulePath.mjs';
+export const DEFAULT_FULL_SCHEMA_FILE_NAME = 'full-schema.json';
+export var BuiltInTemplateName;
+(function (BuiltInTemplateName) {
+    BuiltInTemplateName["ts"] = "ts";
+    BuiltInTemplateName["main"] = "main";
+    BuiltInTemplateName["module"] = "module";
+    BuiltInTemplateName["fullSchema"] = "fullSchema";
+})(BuiltInTemplateName || (BuiltInTemplateName = {}));
+export default async function getClientTemplates({ config, cwd, generateFrom = [], }) {
+    const templatesDir = path.join(import.meta.dirname, '../..', 'client-templates');
+    const clientOutDirAbsolutePath = path.resolve(cwd, config.clientOutDir);
+    const builtIn = {
+        ts: {
+            templateName: BuiltInTemplateName.ts,
+            templatePath: path.resolve(templatesDir, 'ts/*'),
+            outDir: clientOutDirAbsolutePath,
+            fullSchema: false,
+            origin: null,
+        },
+        main: {
+            templateName: BuiltInTemplateName.main,
+            templatePath: path.resolve(templatesDir, 'main/*'),
+            outDir: clientOutDirAbsolutePath,
+            fullSchema: false,
+            origin: null,
+        },
+        module: {
+            templateName: BuiltInTemplateName.module,
+            templatePath: path.resolve(templatesDir, 'module/*'),
+            outDir: clientOutDirAbsolutePath,
+            fullSchema: false,
+            origin: null,
+        },
+        fullSchema: {
+            templateName: BuiltInTemplateName.fullSchema,
+            templatePath: path.resolve(templatesDir, 'fullSchema/*'),
+            outDir: clientOutDirAbsolutePath,
+            fullSchema: false,
+            origin: null,
+        },
+    };
+    const generateFromStrict = generateFrom.map((template) => {
+        if (typeof template === 'string') {
+            if (template in builtIn) {
+                return builtIn[template];
+            }
+            return {
+                templateName: template,
+                templatePath: resolveAbsoluteModulePath(template, cwd),
+                outDir: clientOutDirAbsolutePath,
+                fullSchema: false,
+                origin: null,
+            };
+        }
+        return {
+            templateName: template.templateName ?? template.templatePath,
+            templatePath: resolveAbsoluteModulePath(template.templatePath, cwd),
+            outDir: template.outDir ? path.resolve(cwd, template.outDir) : clientOutDirAbsolutePath,
+            fullSchema: template.fullSchema ?? false,
+            origin: template.origin ?? null,
+        };
+    });
+    if (['ts', 'main', 'module'].some((template) => generateFromStrict.some((item) => item.templateName === template))) {
+        generateFromStrict.unshift(builtIn.fullSchema);
+    }
+    const templateFiles = [];
+    for (const generateFromItem of generateFromStrict) {
+        const files = await glob(generateFromItem.templatePath);
+        for await (const templatePath of files) {
+            const fullSchemaOutAbsolutePath = generateFromItem.fullSchema
+                ? path.resolve(generateFromItem.outDir, generateFromItem.fullSchema === 'string' ? generateFromItem.fullSchema : DEFAULT_FULL_SCHEMA_FILE_NAME)
+                : null;
+            templateFiles.push({
+                templateName: generateFromItem.templateName,
+                templatePath,
+                outPath: path.join(generateFromItem.outDir, path.basename(templatePath).replace('.ejs', '')),
+                fullSchemaOutAbsolutePath,
+                origin: generateFromItem.origin,
+            });
+        }
+    }
+    return { clientOutDirAbsolutePath, templateFiles };
+}

package/dist/generate/getFullSchemaFromJSON.d.mts

@@ -0,0 +1,3 @@
+import type { VovkFullSchema } from 'vovk';
+import { ProjectInfo } from '../getProjectInfo/index.mjs';
+export declare function getFullSchemaFromJSON(schemaOutAbsolutePath: string, projectInfo: ProjectInfo): Promise<VovkFullSchema>;

package/dist/generate/getFullSchemaFromJSON.mjs

@@ -0,0 +1,64 @@
+import { readFile, access } from 'node:fs/promises';
+import { glob } from 'glob';
+import * as path from 'node:path';
+export async function getFullSchemaFromJSON(schemaOutAbsolutePath, projectInfo) {
+    const result = {
+        config: {},
+        segments: {},
+    };
+    const { log } = projectInfo;
+    // Handle config.json
+    const configPath = path.join(schemaOutAbsolutePath, 'config.json');
+    try {
+        const configContent = await readFile(configPath, 'utf-8');
+        result.config = JSON.parse(configContent);
+    }
+    catch {
+        log.warn(`Warning: config.json not found at ${configPath}. Using empty config as fallback.`);
+        result.config = {};
+    }
+    // Handle segments directory
+    const segmentsDir = path.join(schemaOutAbsolutePath, 'segments');
+    try {
+        await access(segmentsDir); // Check if directory exists
+        // Use glob to get all JSON files recursively
+        const files = await glob(`${segmentsDir}/**/*.json`);
+        // Process each JSON file
+        for await (const filePath of files) {
+            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.json' && path.dirname(filePath) === segmentsDir) {
+                    relativePath = '';
+                }
+                result.segments[relativePath] = jsonData;
+            }
+            catch (error) {
+                log.warn(`Warning: Failed to process file ${filePath}: ${error}`);
+            }
+        }
+    }
+    catch {
+        log.warn(`Warning: Segments directory not found at ${segmentsDir}. Using empty segments as fallback.`);
+        result.segments = {};
+    }
+    return result;
+}
+// Example usage:
+/*
+async function main() {
+  try {
+    const schema = await getSchemaFromJSON('/path/to/directory');
+    console.log(schema);
+  } catch (error) {
+    console.error('Error:', error);
+  }
+}
+main();
+*/

package/dist/generate/index.d.mts

@@ -0,0 +1,13 @@
+import type { VovkFullSchema } from 'vovk';
+import type { ProjectInfo } from '../getProjectInfo/index.mjs';
+import type { Segment } from '../locateSegments.mjs';
+import type { GenerateOptions } from '../types.mjs';
+export default function generate({ projectInfo, segments, forceNothingWrittenLog, templates, prettify: prettifyClient, fullSchema, emitFullSchema, }: {
+    projectInfo: ProjectInfo;
+    segments: Segment[];
+    forceNothingWrittenLog?: boolean;
+    fullSchema: VovkFullSchema;
+} & Pick<GenerateOptions, 'templates' | 'prettify' | 'emitFullSchema'>): Promise<{
+    written: boolean;
+    path: string;
+}>;

package/dist/generate/index.mjs

@@ -0,0 +1,115 @@
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import ejs from 'ejs';
+import matter from 'gray-matter';
+import uniq from 'lodash/uniq.js';
+import formatLoggedSegmentName from '../utils/formatLoggedSegmentName.mjs';
+import prettify from '../utils/prettify.mjs';
+import getClientTemplates, { DEFAULT_FULL_SCHEMA_FILE_NAME } from './getClientTemplates.mjs';
+import chalkHighlightThing from '../utils/chalkHighlightThing.mjs';
+import _ from 'lodash';
+import { ROOT_SEGMENT_SCHEMA_NAME, SEGMENTS_SCHEMA_DIR_NAME } from '../dev/writeOneSegmentSchemaFile.mjs';
+export default async function generate({ projectInfo, segments, forceNothingWrittenLog, templates, prettify: prettifyClient, fullSchema, emitFullSchema, }) {
+    const segmentsSchema = fullSchema.segments;
+    const generateFrom = templates ?? projectInfo.config.generateFrom;
+    const noClient = templates?.[0] === 'none';
+    const { config, cwd, log, clientImports, apiRoot } = projectInfo;
+    const { clientOutDirAbsolutePath, templateFiles } = await getClientTemplates({ config, cwd, generateFrom });
+    // Ensure that each segment has a matching schema if it needs to be emitted:
+    for (let i = 0; i < segments.length; i++) {
+        const { segmentName } = segments[i];
+        const schema = segmentsSchema[segmentName];
+        if (!schema) {
+            throw new Error(`Unable to generate client. No schema found for ${formatLoggedSegmentName(segmentName)}`);
+        }
+        if (!schema.emitSchema)
+            continue;
+    }
+    const now = Date.now();
+    const schemaOutDir = path.relative(config.clientOutDir, config.schemaOutDir).replace(/\\/g, '/'); // windows fix
+    // Process each template in parallel
+    const processedTemplates = noClient
+        ? []
+        : await Promise.all(templateFiles.map(async ({ templatePath, outPath, templateName, origin }) => {
+            /*const parsed = matter((await ejs.render(codeTemplate, { t }, { async: true, filename: templateFileName })).trim());
+              const { dir, fileName, sourceName, compiledName } = parsed.data as VovkModuleRenderResult;
+              const code = empty ? (sourceName ? `export default class ${sourceName} {}` : '') : parsed.content;*/
+            // Read the EJS template
+            const templateContent = await fs.readFile(templatePath, 'utf-8');
+            const { data, content } = matter(templateContent);
+            // Data for the EJS templates:
+            const t = {
+                _, // lodash
+                ROOT_SEGMENT_SCHEMA_NAME,
+                SEGMENTS_SCHEMA_DIR_NAME,
+                apiRoot: origin ? `${origin}/${config.rootEntry}` : apiRoot,
+                imports: clientImports,
+                fullSchema,
+                schemaOutDir,
+                segmentMeta: Object.fromEntries(segments.map(({ segmentName, ...s }) => [segmentName, s])),
+            };
+            if (data.imports instanceof Array) {
+                for (const imp of data.imports) {
+                    t.imports = {
+                        ...t.imports,
+                        [imp]: await import(imp),
+                    };
+                }
+            }
+            // Render the template
+            let rendered = templatePath.endsWith('.ejs')
+                ? ejs.render(content, { t }, {
+                    filename: templatePath,
+                })
+                : templateContent;
+            // Optionally prettify
+            if (prettifyClient || config.prettifyClient) {
+                rendered = await prettify(rendered, outPath);
+            }
+            // Read existing file content to compare
+            const existingContent = await fs.readFile(outPath, 'utf-8').catch(() => '');
+            // Determine if we need to rewrite the file, ignore 1st line
+            const needsWriting = existingContent.trim().split('\n').slice(1).join('\n') !== rendered.trim().split('\n').slice(1).join('\n');
+            return {
+                outPath,
+                rendered,
+                needsWriting,
+                templateName,
+            };
+        }));
+    const usedTemplateNames = uniq(processedTemplates.filter(({ needsWriting }) => needsWriting).map(({ templateName }) => templateName));
+    let schemaPaths = templateFiles
+        .map(({ fullSchemaOutAbsolutePath }) => fullSchemaOutAbsolutePath)
+        .filter(Boolean);
+    if (emitFullSchema) {
+        const fullSchemaOutAbsolutePath = emitFullSchema
+            ? path.resolve(clientOutDirAbsolutePath, emitFullSchema === 'string' ? emitFullSchema : DEFAULT_FULL_SCHEMA_FILE_NAME)
+            : null;
+        if (fullSchemaOutAbsolutePath) {
+            schemaPaths.push(fullSchemaOutAbsolutePath);
+        }
+    }
+    schemaPaths = uniq(schemaPaths);
+    if (schemaPaths.length) {
+        await Promise.all(schemaPaths.map(async (fullSchemaOutAbsolutePath) => {
+            fs.mkdir(path.dirname(fullSchemaOutAbsolutePath), { recursive: true });
+            return fs.writeFile(fullSchemaOutAbsolutePath, JSON.stringify(fullSchema, null, 2));
+        }));
+        log.info(`Full schema has been written to ${schemaPaths.map((s) => `"${s}"`).join(', ')}`);
+    }
+    if (usedTemplateNames.length === 0) {
+        const logOrDebug = forceNothingWrittenLog ? log.info : log.debug;
+        logOrDebug(`Client is up to date and doesn't need to be regenerated (${Date.now() - now}ms)`);
+        return { written: false, path: clientOutDirAbsolutePath };
+    }
+    // Write updated files where needed
+    await Promise.all(processedTemplates.map(async ({ outPath, rendered, needsWriting }) => {
+        if (needsWriting) {
+            await fs.mkdir(path.dirname(outPath), { recursive: true });
+            return fs.writeFile(outPath, rendered);
+        }
+        return null;
+    }));
+    log.info(`Client generated from template${usedTemplateNames.length !== 1 ? 's' : ''} ${chalkHighlightThing(usedTemplateNames.map((s) => `"${s}"`).join(', '))} in ${Date.now() - now}ms`);
+    return { written: true, path: clientOutDirAbsolutePath };
+}

package/dist/getProjectInfo/getConfig.d.mts

@@ -1,11 +1,12 @@
-import type { VovkConfig } from '../types.mjs';
-export default function getConfig({ clientOutDir, cwd }: {
+import type { VovkStrictConfig } from 'vovk';
+export default function getConfig({ clientOutDir, configPath, cwd, }: {
     clientOutDir?: string;
+    configPath?: string;
     cwd: string;
 }): Promise<{
-    config: Required<VovkConfig>;
+    config: VovkStrictConfig;
     srcRoot: string;
     configAbsolutePaths: string[];
-    userConfig: VovkConfig | null;
+    userConfig: import("vovk").VovkConfig | null;
     error: Error | undefined;
 }>;

package/dist/getProjectInfo/getConfig.mjs

@@ -1,29 +1,48 @@
 import getUserConfig from './getUserConfig.mjs';
 import getRelativeSrcRoot from './getRelativeSrcRoot.mjs';
-export default async function getConfig({ clientOutDir, cwd }) {
+export default async function getConfig({ clientOutDir, configPath, cwd, }) {
     const env = process.env;
-    const { configAbsolutePaths, error, userConfig } = await getUserConfig({ cwd });
+    const { configAbsolutePaths, error, userConfig } = await getUserConfig({ configPath, cwd });
     const conf = userConfig ?? {};
     const srcRoot = await getRelativeSrcRoot({ cwd });
+    const validateOnClientImport = env.VOVK_VALIDATE_ON_CLIENT_PATH ?? conf.imports?.validateOnClient ?? null;
+    const fetcherImport = env.VOVK_FETCHER_PATH ?? conf.imports?.fetcher ?? 'vovk';
+    const createRPCImport = env.VOVK_CREATE_RPC_PATH ?? conf.imports?.createRPC ?? 'vovk';
+    const defaultClientTemplates = ['module', 'main'];
     const config = {
+        emitConfig: [],
         modulesDir: env.VOVK_MODULES_DIR ?? conf.modulesDir ?? './' + [srcRoot, 'modules'].filter(Boolean).join('/'),
-        validateOnClient: env.VOVK_VALIDATE_ON_CLIENT ?? conf.validateOnClient ?? null,
-        validationLibrary: env.VOVK_VALIDATION_LIBRARY ?? conf.validationLibrary ?? null,
-        fetcher: env.VOVK_FETCHER ?? conf.fetcher ?? 'vovk/client/defaultFetcher',
+        imports: {
+            fetcher: typeof fetcherImport === 'string' ? [fetcherImport] : fetcherImport,
+            validateOnClient: typeof validateOnClientImport === 'string' ? [validateOnClientImport] : (validateOnClientImport ?? null),
+            createRPC: typeof createRPCImport === 'string' ? [createRPCImport, 'vovk'] : createRPCImport,
+        },
         schemaOutDir: env.VOVK_SCHEMA_OUT_DIR ?? conf.schemaOutDir ?? './.vovk-schema',
         clientOutDir: clientOutDir ?? env.VOVK_CLIENT_OUT_DIR ?? conf.clientOutDir ?? './node_modules/.vovk-client',
         origin: (env.VOVK_ORIGIN ?? conf.origin ?? '').replace(/\/$/, ''), // Remove trailing slash
         rootEntry: env.VOVK_ROOT_ENTRY ?? conf.rootEntry ?? 'api',
         rootSegmentModulesDirName: env.VOVK_ROOT_SEGMENT_MODULES_DIR_NAME ?? conf.rootSegmentModulesDirName ?? '',
-        logLevel: env.VOVK_LOG_LEVEL ?? conf.logLevel ?? 'debug', // TODO: change to 'warn' when v3 is ready
+        logLevel: env.VOVK_LOG_LEVEL ?? conf.logLevel ?? 'info',
         prettifyClient: (env.VOVK_PRETTIFY_CLIENT ? !!env.VOVK_PRETTIFY_CLIENT : null) ?? conf.prettifyClient ?? false,
         devHttps: (env.VOVK_DEV_HTTPS ? !!env.VOVK_DEV_HTTPS : null) ?? conf.devHttps ?? false,
+        generateFrom: typeof conf.generateFrom === 'function'
+            ? conf.generateFrom(defaultClientTemplates)
+            : (conf.generateFrom ?? defaultClientTemplates),
         templates: {
             service: 'vovk-cli/templates/service.ejs',
             controller: 'vovk-cli/templates/controller.ejs',
-            worker: 'vovk-cli/templates/worker.ejs',
             ...conf.templates,
         },
+        libs: conf.libs ?? {},
     };
+    if (typeof conf.emitConfig === 'undefined') {
+        config.emitConfig = ['libs'];
+    }
+    else if (conf.emitConfig === true) {
+        config.emitConfig = Object.keys(config);
+    }
+    else if (Array.isArray(conf.emitConfig)) {
+        config.emitConfig = conf.emitConfig;
+    } // else it's false and emitConfig already is []
     return { config, srcRoot, configAbsolutePaths, userConfig, error };
 }

package/dist/getProjectInfo/getConfigAbsolutePaths.d.mts

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

package/dist/getProjectInfo/getConfigAbsolutePaths.mjs

@@ -1,6 +1,9 @@
-import fs from 'fs/promises';
-import path from 'path';
-export default async function getConfigAbsolutePaths({ cwd, relativePath, }) {
+import fs from 'node:fs/promises';
+import path from 'node:path';
+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.mjs

@@ -1,4 +1,4 @@
-import path from 'path';
+import path from 'node:path';
 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.

package/dist/getProjectInfo/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

@@ -1,7 +1,8 @@
+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') };
@@ -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 };

package/dist/getProjectInfo/importUncachedModule.mjs

@@ -3,7 +3,6 @@ import { Worker } from 'node:worker_threads';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import './importUncachedModuleWorker.mjs'; // required for TS compilation
-// TODO comments
 function importUncachedModule(modulePath) {
     return new Promise((resolve, reject) => {
         const __filename = fileURLToPath(import.meta.url);

package/dist/getProjectInfo/importUncachedModuleWorker.mjs

@@ -1,7 +1,6 @@
 import { parentPort, workerData as wData } from 'node:worker_threads';
 import { pathToFileURL } from 'node:url';
 void (async () => {
-    // TODO Comments
     if (!parentPort)
         return;
     const workerData = wData;

package/dist/getProjectInfo/index.d.mts

@@ -1,18 +1,26 @@
 export type ProjectInfo = Awaited<ReturnType<typeof getProjectInfo>>;
-export default function getProjectInfo({ port: givenPort, clientOutDir, cwd, }?: {
+export default function getProjectInfo({ port: givenPort, clientOutDir, configPath, cwd, }?: {
     port?: number;
     clientOutDir?: string;
+    configPath?: string;
     cwd?: string;
 }): Promise<{
     cwd: string;
     port: string;
-    apiEntryPoint: string;
+    apiRoot: string;
     apiDir: string;
     srcRoot: string;
-    schemaOutImportPath: string;
-    fetcherClientImportPath: string;
-    validateOnClientImportPath: string | null;
-    config: Required<import("../types.mjs").VovkConfig>;
+    config: import("vovk").VovkStrictConfig;
+    clientImports: {
+        fetcher: string;
+        createRPC: string;
+        validateOnClient: string | null;
+        module: {
+            fetcher: string;
+            createRPC: string;
+            validateOnClient: string | null;
+        };
+    };
     log: {
         info: (msg: string) => void;
         warn: (msg: string) => void;

package/dist/getProjectInfo/index.mjs

@@ -1,20 +1,17 @@
-import path from 'path';
+import path from 'node:path';
 import getConfig from './getConfig.mjs';
 import getLogger from '../utils/getLogger.mjs';
-export default async function getProjectInfo({ port: givenPort, clientOutDir, cwd = process.cwd(), } = {}) {
+export default async function getProjectInfo({ port: givenPort, clientOutDir, configPath, cwd = process.cwd(), } = {}) {
     const port = givenPort?.toString() ?? process.env.PORT ?? '3000';
     // Make PORT available to the config file at getConfig
     process.env.PORT = port;
-    const { config, srcRoot, configAbsolutePaths, userConfig, error } = await getConfig({ clientOutDir, cwd });
-    const apiEntryPoint = `${config.origin ?? ''}/${config.rootEntry}`;
+    const { config, srcRoot, configAbsolutePaths, userConfig, error } = await getConfig({
+        clientOutDir,
+        configPath,
+        cwd,
+    });
+    const apiRoot = `${config.origin ?? ''}/${config.rootEntry}`;
     const apiDir = path.join(srcRoot, 'app', config.rootEntry);
-    const schemaOutImportPath = path.relative(config.clientOutDir, config.schemaOutDir);
-    const fetcherClientImportPath = config.fetcher.startsWith('.')
-        ? path.relative(config.clientOutDir, config.fetcher)
-        : config.fetcher;
-    const validateOnClientImportPath = config.validateOnClient?.startsWith('.')
-        ? path.relative(config.clientOutDir, config.validateOnClient)
-        : config.validateOnClient;
     const log = getLogger(config.logLevel);
     if (configAbsolutePaths.length > 1) {
         log.warn(`Multiple config files found. Using the first one: ${configAbsolutePaths[0]}`);
@@ -22,16 +19,27 @@ export default async function getProjectInfo({ port: givenPort, clientOutDir, cw
     if (!userConfig && configAbsolutePaths.length > 0) {
         log.error(`Error reading config file at ${configAbsolutePaths[0]}: ${error?.message ?? 'Unknown Error'}`);
     }
+    const getImportPath = (p) => (p.startsWith('.') ? path.relative(config.clientOutDir, p) : p);
+    const clientImports = {
+        fetcher: getImportPath(config.imports.fetcher[0]),
+        createRPC: getImportPath(config.imports.createRPC[0]),
+        validateOnClient: config.imports.validateOnClient ? getImportPath(config.imports.validateOnClient[0]) : null,
+        module: {
+            fetcher: getImportPath(config.imports.fetcher[1] ?? config.imports.fetcher[0]),
+            createRPC: getImportPath(config.imports.createRPC[1] ?? config.imports.createRPC[0]),
+            validateOnClient: config.imports.validateOnClient
+                ? getImportPath(config.imports.validateOnClient[1] ?? config.imports.validateOnClient[0])
+                : null,
+        },
+    };
     return {
         cwd,
         port,
-        apiEntryPoint,
+        apiRoot,
         apiDir,
         srcRoot,
-        schemaOutImportPath,
-        fetcherClientImportPath,
-        validateOnClientImportPath,
         config,
+        clientImports,
         log,
     };
 }

package/dist/index.d.mts

@@ -1,30 +1,2 @@
 #!/usr/bin/env node
-import { Command } from 'commander';
-import type { LogLevelNames } from 'loglevel';
-import type { VovkConfig, VovkEnv } from './types.mjs';
 import 'dotenv/config';
-export type { VovkConfig, VovkEnv };
-export interface InitOptions {
-    yes?: boolean;
-    logLevel: LogLevelNames;
-    useNpm?: boolean;
-    useYarn?: boolean;
-    usePnpm?: boolean;
-    useBun?: boolean;
-    skipInstall?: boolean;
-    updateTsConfig?: boolean;
-    updateScripts?: 'implicit' | 'explicit';
-    validationLibrary?: string | null;
-    validateOnClient?: boolean;
-    dryRun?: boolean;
-    channel?: 'latest' | 'beta' | 'dev';
-}
-export interface NewOptions {
-    dryRun?: boolean;
-    template?: string;
-    dir?: string;
-    overwrite?: boolean;
-    noSegmentUpdate?: boolean;
-}
-declare const program: Command;
-export declare function initProgram(p: typeof program, command: string): Command;