vovk-cli 0.0.1-beta.0 → 0.0.1-beta.2

package/{.eslintrc.js → .eslintrc.mjs}

@@ -1,4 +1,4 @@
-module.exports = {
+export default {
   extends: '../../.eslintrc.js',
   rules: {
     '@typescript-eslint/no-unsafe-argument': 'off',

package/dist/getProjectInfo/directoryExists.mjs

@@ -0,0 +1,10 @@
+import fs from 'fs/promises';
+export default async function directoryExists(dir) {
+    try {
+        const stats = await fs.stat(dir);
+        return stats.isDirectory();
+    }
+    catch (error) {
+        return false;
+    }
+}

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

@@ -1,4 +1,4 @@
-import type { VovkConfig } from '../types';
+import type { VovkConfig } from '../types.mjs';
 export default function getConfig({ clientOutDir }: {
     clientOutDir?: string;
 }): Promise<{

package/dist/getProjectInfo/getConfig.mjs

@@ -0,0 +1,23 @@
+import readConfig from './readConfig.mjs';
+import getCwdPath from './getCwdPath.mjs';
+import getSrcRoot from './getSrcRoot.mjs';
+import path from 'path';
+export default async function getConfig({ clientOutDir }) {
+    const env = process.env;
+    const userConfig = await readConfig();
+    const srcRoot = await getSrcRoot();
+    const cwd = process.cwd();
+    const config = {
+        modulesDir: path.join(cwd, env.VOVK_MODULES_DIR ?? userConfig.modulesDir ?? './' + [srcRoot, 'modules'].filter(Boolean).join('/')),
+        validateOnClient: getCwdPath(env.VOVK_VALIDATE_ON_CLIENT ?? userConfig.validateOnClient ?? null),
+        validationLibrary: getCwdPath(env.VOVK_VALIDATION_LIBRARY ?? userConfig.validationLibrary ?? null),
+        fetcher: getCwdPath(env.VOVK_FETCHER ?? userConfig.fetcher ?? 'vovk/client/defaultFetcher'),
+        metadataOutDir: env.VOVK_METADATA_OUT_DIR ?? userConfig.metadataOutDir ?? './.vovk-schema',
+        clientOutDir: clientOutDir ?? env.VOVK_CLIENT_OUT_DIR ?? userConfig.clientOutDir ?? './node_modules/.vovk',
+        origin: (env.VOVK_ORIGIN ?? userConfig.origin ?? '').replace(/\/$/, ''), // Remove trailing slash
+        rootEntry: env.VOVK_ROOT_ENTRY ?? userConfig.rootEntry ?? 'api',
+        rootSegmentModulesDirName: env.VOVK_ROOT_SEGMENT_MODULES_DIR_NAME ?? userConfig.rootSegmentModulesDirName ?? '',
+        logLevel: env.VOVK_LOG_LEVEL ?? userConfig.logLevel ?? 'debug', // TODO: change to 'warn' when v3 is ready
+    };
+    return { config, srcRoot };
+}

package/dist/getProjectInfo/getCwdPath.mjs

@@ -0,0 +1,13 @@
+import path from 'path';
+// TODO Rename
+export default function getCwdPath(inputPath, baseDir = process.cwd()) {
+    if (inputPath === null) {
+        return null;
+    }
+    // Check if the path is absolute
+    if (path.isAbsolute(inputPath) || inputPath.startsWith('./') || inputPath.startsWith('../')) {
+        return path.resolve(baseDir, inputPath);
+    }
+    // If it's a module or absolute path, keep it as is
+    return inputPath;
+}

package/dist/getProjectInfo/getSrcRoot.mjs

@@ -0,0 +1,13 @@
+import path from 'path';
+import directoryExists from './directoryExists.mjs';
+export default async function getSrcRoot() {
+    const cwd = process.cwd();
+    // Next.js Docs: src/app or src/pages will be ignored if app or pages are present in the root directory.
+    if (await directoryExists(path.join(cwd, 'app'))) {
+        return cwd;
+    }
+    else if (await directoryExists(path.join(cwd, 'src/app'))) {
+        return path.join(cwd, 'src');
+    }
+    throw new Error(`Could not find app router directory. Check Next.js docs for more info.`);
+}

package/dist/getProjectInfo/index.d.mts

@@ -0,0 +1,26 @@
+import loglevel from 'loglevel';
+export type ProjectInfo = Awaited<ReturnType<typeof getProjectInfo>>;
+export default function getProjectInfo({ port: givenPort, clientOutDir, }?: {
+    port?: number;
+    clientOutDir?: string;
+}): Promise<{
+    cwd: string;
+    port: string;
+    vovkPort: string;
+    apiEntryPoint: string;
+    apiPrefix: string;
+    apiDir: string;
+    srcRoot: string;
+    metadataOutFullPath: string;
+    metadataOutImportPath: string;
+    clientOutFullPath: string;
+    fetcherClientImportPath: string;
+    config: Required<import("../types.mjs").VovkConfig>;
+    log: {
+        info: (msg: string) => void;
+        warn: (msg: string) => void;
+        error: (msg: string) => void;
+        debug: (msg: string) => void;
+        raw: loglevel.RootLogger;
+    };
+}>;

package/dist/getProjectInfo/index.mjs

@@ -0,0 +1,45 @@
+import path from 'path';
+import loglevel from 'loglevel';
+import chalk from 'chalk';
+import getConfig from './getConfig.mjs';
+export default async function getProjectInfo({ port: givenPort, clientOutDir, } = {}) {
+    const env = process.env;
+    const port = givenPort?.toString() ?? process.env.PORT ?? '3000';
+    // Make PORT available to the config file at getConfig
+    process.env.PORT = port;
+    const cwd = process.cwd();
+    const { config, srcRoot } = await getConfig({ clientOutDir });
+    const vovkPort = env.VOVK_PORT || (parseInt(port) + 6969).toString();
+    const apiEntryPoint = `${config.origin}/${config.rootEntry}`; // ??? TODO
+    const apiPrefix = `${config.origin}/${config.rootEntry}`; // ??? TODO
+    const apiDir = path.join(srcRoot, 'app', config.rootEntry);
+    const metadataOutFullPath = path.join(cwd, config.metadataOutDir);
+    const metadataOutImportPath = path.relative(config.clientOutDir, metadataOutFullPath);
+    const fetcherClientImportPath = config.fetcher.startsWith('.')
+        ? path.relative(config.clientOutDir, config.fetcher)
+        : config.fetcher;
+    const clientOutFullPath = path.join(cwd, config.clientOutDir);
+    const log = {
+        info: (msg) => loglevel.info(chalk.blueBright(`🐺 ${msg}`)),
+        warn: (msg) => loglevel.warn(chalk.yellowBright(`🐺 ${msg}`)),
+        error: (msg) => loglevel.error(chalk.redBright(`🐺 ${msg}`)),
+        debug: (msg) => loglevel.debug(chalk.gray(`🐺 ${msg}`)),
+        raw: loglevel,
+    };
+    loglevel.setLevel(config.logLevel);
+    return {
+        cwd,
+        port,
+        vovkPort,
+        apiEntryPoint,
+        apiPrefix,
+        apiDir,
+        srcRoot,
+        metadataOutFullPath,
+        metadataOutImportPath,
+        clientOutFullPath,
+        fetcherClientImportPath,
+        config,
+        log,
+    };
+}

package/dist/getProjectInfo/{readConfig.d.ts → readConfig.d.mts}

@@ -1,3 +1,3 @@
-import type { VovkConfig } from '../types';
+import type { VovkConfig } from '../types.mjs';
 declare function readConfig(): Promise<VovkConfig>;
 export default readConfig;

package/dist/getProjectInfo/readConfig.mjs

@@ -0,0 +1,37 @@
+import { promises as fs } from 'fs';
+import path from 'path';
+async function findConfigPath() {
+    const rootDir = process.cwd();
+    const baseName = 'vovk.config';
+    const extensions = ['cjs', 'mjs', 'js'];
+    for (const ext of extensions) {
+        const filePath = path.join(rootDir, `${baseName}.${ext}`);
+        try {
+            await fs.stat(filePath);
+            return filePath; // Return the path if the file exists
+        }
+        catch {
+            // If the file doesn't exist, an error is thrown. Catch it and continue checking.
+        }
+    }
+    return null; // Return null if no config file was found
+}
+async function readConfig() {
+    const configPath = await findConfigPath();
+    let config = {};
+    if (!configPath) {
+        return config;
+    }
+    try {
+        if (configPath.endsWith('.cjs') || configPath.endsWith('.js')) {
+            const cacheBuster = Date.now();
+            ({ default: config } = (await import(`${configPath}?cache=${cacheBuster}`)));
+        }
+    }
+    catch (e) {
+        // eslint-disable-next-line no-console
+        console.error('🐺 ❌ Error reading config file:', e.message);
+    }
+    return config;
+}
+export default readConfig;

package/dist/{index.d.ts → index.d.mts}

@@ -1,3 +1,3 @@
 #!/usr/bin/env node
-import { VovkConfig, VovkEnv } from './types';
+import { VovkConfig, VovkEnv } from './types.mjs';
 export type { VovkConfig, VovkEnv };

package/dist/index.mjs

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import concurrently from 'concurrently';
+import getAvailablePort from './utils/getAvailablePort.mjs';
+import { VovkCLIServer } from './server/index.mjs';
+import getProjectInfo from './getProjectInfo/index.mjs';
+import generateClient from './server/generateClient.mjs';
+import locateSegments from './locateSegments.mjs';
+import path from 'path';
+import { readFileSync } from 'fs';
+const program = new Command();
+const packageJSON = JSON.parse(readFileSync(path.join(import.meta.dirname, '../package.json'), 'utf-8'));
+program.name('vovk').description('Vovk CLI').version(packageJSON.version);
+program
+    .command('dev')
+    .description('Start development server (optional flag --next-dev to start Vovk Server with Next.js)')
+    .option('--project <path>', 'Path to Next.js project', process.cwd())
+    .option('--client-out <path>', 'Path to client output directory')
+    .option('--next-dev', 'Start Vovk Server and Next.js with automatic port allocation', false)
+    .allowUnknownOption(true)
+    .action(async (options, command) => {
+    const portAttempts = 30;
+    const PORT = !options.nextDev
+        ? process.env.PORT
+        : process.env.PORT ||
+            (await getAvailablePort(3000, portAttempts, 0, (failedPort, tryingPort) => 
+            // eslint-disable-next-line no-console
+            console.warn(`🐺 Next.js Port ${failedPort} is in use, trying ${tryingPort} instead.`)).catch(() => {
+                throw new Error(`🐺 ❌ Failed to find available Next port after ${portAttempts} attempts`);
+            }));
+    if (!PORT) {
+        throw new Error('🐺 ❌ PORT env variable is required');
+    }
+    if (options.nextDev) {
+        const { result } = concurrently([
+            {
+                command: `node ${import.meta.dirname}/server/index.mjs`,
+                name: 'Vovk.ts Metadata Server',
+                env: Object.assign({ PORT, __VOVK_START_SERVER_IN_STANDALONE_MODE__: 'true' }, options.clientOut ? { VOVK_CLIENT_OUT_DIR: options.clientOut } : {}),
+            },
+            {
+                command: `cd ${options.project} && npx next dev ${command.args.join(' ')}`,
+                name: 'Next.js Development Server',
+                env: { PORT },
+            },
+        ], {
+            killOthers: ['failure', 'success'],
+            prefix: 'none',
+        });
+        try {
+            await result;
+        }
+        finally {
+            // eslint-disable-next-line no-console
+            console.log('🐺 Exiting...');
+        }
+    }
+    else {
+        void new VovkCLIServer().startServer({ clientOutDir: options.clientOut });
+    }
+});
+program
+    .command('generate')
+    .description('Generate client')
+    .option('--client-out <path>', 'Path to output directory')
+    .action(async (options) => {
+    const projectInfo = await getProjectInfo({ clientOutDir: options.clientOut });
+    const segments = await locateSegments(projectInfo.apiDir);
+    const metadata = (await import(path.join(projectInfo.metadataOutFullPath, 'index.js')));
+    await generateClient(projectInfo, segments, metadata.default);
+});
+program
+    .command('help')
+    .description('Show help message')
+    .action(() => program.help());
+program.parse(process.argv);
+if (!process.argv.slice(2).length) {
+    program.outputHelp();
+}

package/dist/{init.js → init.mjs}

@@ -1,5 +1,4 @@
 #!/usr/bin/env node
-"use strict";
 /*
 npx vovk-cli init
 - Check if the project is already initialized
@@ -57,12 +56,11 @@ npx vovk-cli init
         - Show how to make a request to the example route
     - Show success message
 */
-Object.defineProperty(exports, "__esModule", { value: true });
-const prompts_1 = require("@inquirer/prompts");
+import { confirm } from '@inquirer/prompts';
 // Or
 // import confirm from '@inquirer/confirm';
 // eslint-disable-next-line no-console
-void (0, prompts_1.confirm)({ message: 'Continue?' }).then(console.info);
+void confirm({ message: 'Continue?' }).then(console.info);
 /*
 const wizard = [
   {

package/dist/locateSegments.mjs

@@ -0,0 +1,29 @@
+import { promises as fs } from 'fs';
+import * as path from 'path';
+import fileExists from './utils/fileExists.mjs';
+export default async function locateSegments(dir, rootDir = dir) {
+    let results = [];
+    // Read the contents of the directory
+    const list = await fs.readdir(dir);
+    // Iterate through each item in the directory
+    for (const file of list) {
+        const filePath = path.join(dir, file);
+        const stat = await fs.stat(filePath);
+        if (stat.isDirectory()) {
+            // Check if the directory name matches the pattern [[...something]]
+            if (file.startsWith('[[...') && file.endsWith(']]')) {
+                // Check if there's a route.ts file inside this directory
+                const routeFilePath = path.join(filePath, 'route.ts');
+                if (await fileExists(routeFilePath)) {
+                    // Calculate the basePath relative to the root directory
+                    const segmentName = path.relative(rootDir, dir);
+                    results.push({ routeFilePath, segmentName });
+                }
+            }
+            // Recursively search inside subdirectories
+            const subDirResults = await locateSegments(filePath, rootDir);
+            results = results.concat(subDirResults);
+        }
+    }
+    return results;
+}

package/dist/postinstall.mjs

@@ -0,0 +1,22 @@
+import { promises as fs } from 'fs';
+import path from 'path';
+/**
+ * Checks if a file exists at the given path.
+ * @param {string} filePath - The path to the file.
+ * @returns {Promise<boolean>} - A promise that resolves to true if the file exists, false otherwise.
+ */
+const fileExists = async (filePath) => !!(await fs.stat(filePath).catch(() => false));
+async function postinstall() {
+    const vovk = path.join(import.meta.dirname, '../../.vovk');
+    const js = path.join(vovk, 'client.js');
+    const ts = path.join(vovk, 'client.d.ts');
+    const index = path.join(vovk, 'index.ts');
+    if ((await fileExists(js)) || (await fileExists(ts)) || (await fileExists(index))) {
+        return;
+    }
+    await fs.mkdir(vovk, { recursive: true });
+    await fs.writeFile(js, '/* postinstall */');
+    await fs.writeFile(ts, '/* postinstall */');
+    await fs.writeFile(index, '/* postinstall */');
+}
+void postinstall();

package/dist/server/{createMetadataServer.js → createMetadataServer.mjs}

@@ -1,12 +1,6 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = createMetadataServer;
-const http_1 = __importDefault(require("http"));
-function createMetadataServer(then, catchFn) {
-    return http_1.default.createServer((req, res) => {
+import http from 'http';
+export default function createMetadataServer(then, catchFn) {
+    return http.createServer((req, res) => {
         if (req.method === 'POST' && req.url === '/__metadata') {
             let body = '';
             req.on('data', (chunk) => {

package/dist/server/{diffMetadata.js → diffMetadata.mjs}

@@ -1,10 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.diffHandlers = diffHandlers;
-exports.diffWorkersOrControllers = diffWorkersOrControllers;
-exports.default = diffMetadata;
-const lodash_1 = require("lodash");
-function diffHandlers(oldHandlers, newHandlers, nameOfClass) {
+import isEqual from 'lodash/isEqual.js';
+export function diffHandlers(oldHandlers, newHandlers, nameOfClass) {
     const added = [];
     const removed = [];
     const changed = []; // Array to store changed handlers
@@ -12,7 +7,7 @@ function diffHandlers(oldHandlers, newHandlers, nameOfClass) {
         if (!(handler in oldHandlers)) {
             added.push(handler);
         }
-        else if (!(0, lodash_1.isEqual)(newHandler, oldHandlers[handler])) {
+        else if (!isEqual(newHandler, oldHandlers[handler])) {
             changed.push(handler); // Add to changed if handlers are not shallow equal
         }
     }
@@ -23,7 +18,7 @@ function diffHandlers(oldHandlers, newHandlers, nameOfClass) {
     }
     return { nameOfClass, added, removed, changed };
 }
-function diffWorkersOrControllers(oldItems, newItems) {
+export function diffWorkersOrControllers(oldItems, newItems) {
     const added = [];
     const removed = [];
     const handlersDiff = [];
@@ -67,7 +62,7 @@ example output:
   }
 }
 */
-function diffMetadata(oldJson, newJson) {
+export default function diffMetadata(oldJson, newJson) {
     const workersDiff = diffWorkersOrControllers(oldJson.workers ?? {}, newJson.workers ?? {});
     const controllersDiff = diffWorkersOrControllers(oldJson.controllers ?? {}, newJson.controllers ?? {});
     return {

package/dist/server/{ensureMetadataFiles.d.ts → ensureMetadataFiles.d.mts}

@@ -1,3 +1,3 @@
-import { ProjectInfo } from '../getProjectInfo';
+import { ProjectInfo } from '../getProjectInfo/index.mjs';
 export default function ensureMetadataFiles(metadataOutFullPath: string, segmentNames: string[], projectInfo: ProjectInfo | null): Promise<void>;
 export declare const debouncedEnsureMetadataFiles: import("lodash").DebouncedFunc<typeof ensureMetadataFiles>;

package/dist/server/ensureMetadataFiles.mjs

@@ -0,0 +1,70 @@
+import fs from 'fs/promises';
+import path from 'path';
+import debounce from 'lodash/debounce.js';
+import writeOneMetadataFile, { ROOT_SEGMENT_SCHEMA_NAME } from './writeOneMetadataFile.mjs';
+export default async function ensureMetadataFiles(metadataOutFullPath, segmentNames, projectInfo) {
+    const now = Date.now();
+    let hasChanged = false;
+    // Create index.js file
+    const indexContent = segmentNames
+        .map((segmentName) => {
+        return `module.exports['${segmentName}'] = require('./${segmentName || ROOT_SEGMENT_SCHEMA_NAME}.json');`;
+    })
+        .join('\n');
+    const dTsContent = `import type { VovkMetadata } from 'vovk';
+declare const segmentMetadata: Record<string, VovkMetadata>;
+export default segmentMetadata;`;
+    await fs.mkdir(metadataOutFullPath, { recursive: true });
+    await fs.writeFile(path.join(metadataOutFullPath, 'index.js'), indexContent);
+    await fs.writeFile(path.join(metadataOutFullPath, 'index.d.ts'), dTsContent);
+    // Create JSON files (if not exist) with name [segmentName].json (where segmentName can include /, which means the folder structure can be nested) : {} (empty object)
+    await Promise.all(segmentNames.map(async (segmentName) => {
+        const { isCreated } = await writeOneMetadataFile({
+            metadataOutFullPath,
+            metadata: {
+                emitMetadata: false,
+                segmentName,
+                controllers: {},
+                workers: {},
+            },
+            skipIfExists: true,
+        });
+        if (isCreated) {
+            projectInfo?.log.debug(`Created empty metadata file for segment "${segmentName}"`);
+            hasChanged = true;
+        }
+    }));
+    // Recursive function to delete unnecessary JSON files and folders
+    async function deleteUnnecessaryJsonFiles(dirPath) {
+        const entries = await fs.readdir(dirPath, { withFileTypes: true });
+        await Promise.all(entries.map(async (entry) => {
+            const fullPath = path.join(dirPath, entry.name);
+            if (entry.isDirectory()) {
+                // Recursively delete unnecessary files and folders within nested directories
+                await deleteUnnecessaryJsonFiles(fullPath);
+                // Check if the directory is empty after deletion and remove it if so
+                const remainingEntries = await fs.readdir(fullPath);
+                if (remainingEntries.length === 0) {
+                    await fs.rmdir(fullPath);
+                    projectInfo?.log.debug(`Deleted unnecessary metadata directory "${fullPath}"`);
+                    hasChanged = true;
+                }
+            }
+            else if (entry.isFile() && entry.name.endsWith('.json')) {
+                const relativePath = path.relative(metadataOutFullPath, fullPath);
+                const segmentName = relativePath.replace(/\\/g, '/').slice(0, -5); // Remove '.json' extension
+                if (!segmentNames.includes(segmentName) &&
+                    !segmentNames.includes(segmentName.replace(ROOT_SEGMENT_SCHEMA_NAME, ''))) {
+                    await fs.unlink(fullPath);
+                    projectInfo?.log.debug(`Deleted unnecessary metadata file for segment "${segmentName}"`);
+                    hasChanged = true;
+                }
+            }
+        }));
+    }
+    // Start the recursive deletion from the root directory
+    await deleteUnnecessaryJsonFiles(metadataOutFullPath);
+    if (hasChanged)
+        projectInfo?.log.info(`Metadata files updated in ${Date.now() - now}ms`);
+}
+export const debouncedEnsureMetadataFiles = debounce(ensureMetadataFiles, 1000);

package/dist/server/{generateClient.d.ts → generateClient.d.mts}

@@ -1,5 +1,5 @@
-import type { ProjectInfo } from '../getProjectInfo';
-import type { Segment } from '../locateSegments';
+import type { ProjectInfo } from '../getProjectInfo/index.mjs';
+import type { Segment } from '../locateSegments.mjs';
 import { VovkMetadata } from 'vovk';
 export default function generateClient(projectInfo: ProjectInfo, segments: Segment[], segmentsMetadata: Record<string, VovkMetadata>): Promise<{
     written: boolean;

package/dist/server/{generateClient.js → generateClient.mjs}

@@ -1,16 +1,10 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = generateClient;
-const path_1 = __importDefault(require("path"));
-const promises_1 = __importDefault(require("fs/promises"));
-async function generateClient(projectInfo, segments, segmentsMetadata) {
+import path from 'path';
+import fs from 'fs/promises';
+export default async function generateClient(projectInfo, segments, segmentsMetadata) {
     const now = Date.now();
     const outDir = projectInfo.clientOutFullPath;
     const validatePath = projectInfo.config.validateOnClient?.startsWith('.')
-        ? path_1.default.join(projectInfo.cwd, projectInfo.config.validateOnClient)
+        ? path.join(projectInfo.cwd, projectInfo.config.validateOnClient)
         : projectInfo.config.validateOnClient;
     let dts = `// auto-generated
 /* eslint-disable */
@@ -44,7 +38,7 @@ import metadata from '${projectInfo.metadataOutImportPath}';
         }
         if (!metadata.emitMetadata)
             continue;
-        const importRouteFilePath = path_1.default.relative(projectInfo.config.clientOutDir, routeFilePath);
+        const importRouteFilePath = path.relative(projectInfo.config.clientOutDir, routeFilePath);
         dts += `import type { Controllers as Controllers${i}, Workers as Workers${i} } from "${importRouteFilePath}";\n`;
         ts += `import type { Controllers as Controllers${i}, Workers as Workers${i} } from "${importRouteFilePath}";\n`;
     }
@@ -79,20 +73,20 @@ const prefix = '${projectInfo.apiPrefix}';
             ts += `export const ${key} = promisifyWorker<Workers${i}["${key}"]>(null, metadata['${segmentName}'].workers.${key});\n`;
         }
     }
-    const localJsPath = path_1.default.join(outDir, 'client.js');
-    const localDtsPath = path_1.default.join(outDir, 'client.d.ts');
-    const localTsPath = path_1.default.join(outDir, 'index.ts');
-    const existingJs = await promises_1.default.readFile(localJsPath, 'utf-8').catch(() => '');
-    const existingDts = await promises_1.default.readFile(localDtsPath, 'utf-8').catch(() => '');
-    const existingTs = await promises_1.default.readFile(localTsPath, 'utf-8').catch(() => '');
+    const localJsPath = path.join(outDir, 'client.js');
+    const localDtsPath = path.join(outDir, 'client.d.ts');
+    const localTsPath = path.join(outDir, 'index.ts');
+    const existingJs = await fs.readFile(localJsPath, 'utf-8').catch(() => '');
+    const existingDts = await fs.readFile(localDtsPath, 'utf-8').catch(() => '');
+    const existingTs = await fs.readFile(localTsPath, 'utf-8').catch(() => '');
     if (existingJs === js && existingDts === dts && existingTs === ts) {
         projectInfo.log.info(`Client is up to date and doesn't need to be regenerated (${Date.now() - now}ms).`);
         return { written: false, path: outDir };
     }
-    await promises_1.default.mkdir(outDir, { recursive: true });
-    await promises_1.default.writeFile(localJsPath, js);
-    await promises_1.default.writeFile(localDtsPath, dts);
-    await promises_1.default.writeFile(localTsPath, ts);
+    await fs.mkdir(outDir, { recursive: true });
+    await fs.writeFile(localJsPath, js);
+    await fs.writeFile(localDtsPath, dts);
+    await fs.writeFile(localTsPath, ts);
     projectInfo.log.info(`Client generated in ${Date.now() - now}ms`);
     return { written: true, path: outDir };
 }