vovk-cli 0.0.1-draft.4 → 0.0.1-draft.41

package/dist/{watcher → dev}/index.mjs

@@ -1,33 +1,34 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
 import * as chokidar from 'chokidar';
-import fs from 'fs/promises';
-import getProjectInfo from '../getProjectInfo/index.mjs';
-import path from 'path';
+import { Agent, setGlobalDispatcher } from 'undici';
+import keyBy from 'lodash/keyBy.js';
+import capitalize from 'lodash/capitalize.js';
+import debounce from 'lodash/debounce.js';
+import isEmpty from 'lodash/isEmpty.js';
 import { debouncedEnsureSchemaFiles } from './ensureSchemaFiles.mjs';
 import writeOneSchemaFile from './writeOneSchemaFile.mjs';
 import logDiffResult from './logDiffResult.mjs';
+import ensureClient from './ensureClient.mjs';
+import getProjectInfo from '../getProjectInfo/index.mjs';
 import generateClient from '../generateClient.mjs';
 import locateSegments from '../locateSegments.mjs';
 import debounceWithArgs from '../utils/debounceWithArgs.mjs';
-import debounce from 'lodash/debounce.js';
-import isEmpty from 'lodash/isEmpty.js';
 import formatLoggedSegmentName from '../utils/formatLoggedSegmentName.mjs';
-import keyBy from 'lodash/keyBy.js';
-import capitalize from 'lodash/capitalize.js';
-import { Agent, setGlobalDispatcher } from 'undici';
-export class VovkCLIWatcher {
+export class VovkDev {
     #projectInfo;
     #segments = [];
     #schemas = {};
     #isWatching = false;
     #modulesWatcher = null;
     #segmentWatcher = null;
-    #watchSegments = () => {
+    #watchSegments = (callback) => {
         const segmentReg = /\/?\[\[\.\.\.[a-zA-Z-_]+\]\]\/route.ts$/;
         const { cwd, log, config, apiDir } = this.#projectInfo;
         const schemaOutAbsolutePath = path.join(cwd, config.schemaOutDir);
         const apiDirAbsolutePath = path.join(cwd, apiDir);
         const getSegmentName = (filePath) => path.relative(apiDirAbsolutePath, filePath).replace(segmentReg, '');
-        log.debug(`Watching segments in ${apiDirAbsolutePath}`);
+        log.debug(`Watching segments at ${apiDirAbsolutePath}`);
         this.#segmentWatcher = chokidar
             .watch(apiDirAbsolutePath, {
             persistent: true,
@@ -39,7 +40,11 @@ export class VovkCLIWatcher {
                 const segmentName = getSegmentName(filePath);
                 this.#segments = this.#segments.find((s) => s.segmentName === segmentName)
                     ? this.#segments
-                    : [...this.#segments, { routeFilePath: filePath, segmentName }];
+                    : [...this.#segments, {
+                            routeFilePath: filePath,
+                            segmentName,
+                            segmentImportPath: path.relative(config.clientOutDir, filePath) // TODO DRY locateSegments 
+                        }];
                 log.info(`${capitalize(formatLoggedSegmentName(segmentName))} has been added`);
                 log.debug(`Full list of segments: ${this.#segments.map((s) => s.segmentName).join(', ')}`);
                 void debouncedEnsureSchemaFiles(this.#projectInfo, schemaOutAbsolutePath, this.#segments.map((s) => s.segmentName));
@@ -51,18 +56,16 @@ export class VovkCLIWatcher {
                 void this.#requestSchema(getSegmentName(filePath));
             }
         })
-            // eslint-disable-next-line @typescript-eslint/no-misused-promises
             .on('addDir', async (dirPath) => {
             log.debug(`Directory ${dirPath} has been added to segments folder`);
-            this.#segments = await locateSegments(apiDirAbsolutePath);
+            this.#segments = await locateSegments({ dir: apiDirAbsolutePath, config });
             for (const { segmentName } of this.#segments) {
                 void this.#requestSchema(segmentName);
             }
         })
-            // eslint-disable-next-line @typescript-eslint/no-misused-promises
             .on('unlinkDir', async (dirPath) => {
             log.debug(`Directory ${dirPath} has been removed from segments folder`);
-            this.#segments = await locateSegments(apiDirAbsolutePath);
+            this.#segments = await locateSegments({ dir: apiDirAbsolutePath, config });
             for (const { segmentName } of this.#segments) {
                 void this.#requestSchema(segmentName);
             }
@@ -78,16 +81,17 @@ export class VovkCLIWatcher {
             }
         })
             .on('ready', () => {
+            callback();
             log.debug('Segments watcher is ready');
         })
             .on('error', (error) => {
-            log.error(`Error watching segments folder: ${error.message}`);
+            log.error(`Error watching segments folder: ${error?.message ?? 'Unknown error'}`);
         });
     };
-    #watchModules = () => {
+    #watchModules = (callback) => {
         const { config, cwd, log } = this.#projectInfo;
         const modulesDirAbsolutePath = path.join(cwd, config.modulesDir);
-        log.debug(`Watching modules in ${modulesDirAbsolutePath}`);
+        log.debug(`Watching modules at ${modulesDirAbsolutePath}`);
         const processControllerChange = debounceWithArgs(this.#processControllerChange, 500);
         this.#modulesWatcher = chokidar
             .watch(modulesDirAbsolutePath, {
@@ -116,30 +120,37 @@ export class VovkCLIWatcher {
             }
         })
             .on('ready', () => {
+            callback();
             log.debug('Modules watcher is ready');
         })
             .on('error', (error) => {
-            log.error(`Error watching modules folder: ${error.message}`);
+            log.error(`Error watching modules folder: ${error?.message ?? 'Unknown error'}`);
         });
     };
-    #watchConfig = () => {
+    #watchConfig = (callback) => {
         const { log, cwd } = this.#projectInfo;
         log.debug(`Watching config files`);
         let isInitial = true;
+        let isReady = false;
         const handle = debounce(async () => {
             this.#projectInfo = await getProjectInfo();
-            if (!isInitial) {
-                log.info('Config file has been updated');
-                isInitial = false;
-            }
             await this.#modulesWatcher?.close();
             await this.#segmentWatcher?.close();
-            this.#watchModules();
-            this.#watchSegments();
+            await Promise.all([
+                new Promise((resolve) => this.#watchModules(() => resolve(0))),
+                new Promise((resolve) => this.#watchSegments(() => resolve(0)))
+            ]);
+            if (isInitial) {
+                callback();
+            }
+            else {
+                log.info('Config file has been updated');
+            }
+            isInitial = false;
         }, 1000);
-        let ready = false;
         chokidar
-            .watch(['vovk.config.{js,mjs,cjs}', '.config/vovk.config.{js,mjs,cjs}'], {
+            // .watch(['vovk.config.{js,mjs,cjs}', '.config/vovk.config.{js,mjs,cjs}'], {
+            .watch(['vovk.config.js', 'vovk.config.mjs', 'vovk.config.cjs', '.config/vovk.config.js', '.config/vovk.config.mjs', '.config/vovk.config.cjs'], {
             persistent: true,
             cwd,
             ignoreInitial: false,
@@ -149,24 +160,23 @@ export class VovkCLIWatcher {
             .on('change', () => void handle())
             .on('unlink', () => void handle())
             .on('ready', () => {
-            if (ready)
+            if (isReady)
                 return;
             // for some reason this watcher triggers ready event twice
             log.debug('Config files watcher is ready');
-            ready = true;
+            isReady = true;
         })
-            .on('error', (error) => {
-            log.error(`Error watching config files: ${error.message}`);
-        });
+            .on('error', (error) => log.error(`Error watching config files: ${error?.message ?? 'Unknown error'}`));
         void handle();
     };
-    #watch() {
+    async #watch(callback) {
         if (this.#isWatching)
             throw new Error('Already watching');
         const { log } = this.#projectInfo;
         log.debug(`Starting segments and modules watcher. Detected initial segments: ${JSON.stringify(this.#segments.map((s) => s.segmentName))}.`);
+        await ensureClient(this.#projectInfo);
         // automatically watches segments and modules
-        this.#watchConfig();
+        this.#watchConfig(callback);
     }
     #processControllerChange = async (filePath) => {
         const { log } = this.#projectInfo;
@@ -183,8 +193,8 @@ export class VovkCLIWatcher {
                 const schema = this.#schemas[s.segmentName];
                 if (!schema)
                     return false;
-                const controllersByOriginalName = keyBy(schema.controllers, '_originalControllerName');
-                const workersByOriginalName = keyBy(schema.workers, '_originalWorkerName');
+                const controllersByOriginalName = keyBy(schema.controllers, 'originalControllerName');
+                const workersByOriginalName = keyBy(schema.workers, 'originalWorkerName');
                 return namesOfClasses.some((name) => schema.controllers[name] ||
                     schema.workers[name] ||
                     controllersByOriginalName[name] ||
@@ -196,6 +206,9 @@ export class VovkCLIWatcher {
                     await this.#requestSchema(segment.segmentName);
                 }
             }
+            else {
+                log.debug(`The class ${namesOfClasses.join(', ')} does not belong to any segment`);
+            }
         }
         else {
             log.debug(`The file does not contain any controller or worker`);
@@ -206,23 +219,29 @@ export class VovkCLIWatcher {
         const { devHttps } = config;
         const endpoint = `${apiEntryPoint.startsWith(`http${devHttps ? 's' : ''}://`) ? apiEntryPoint : `http${devHttps ? 's' : ''}://localhost:${port}${apiEntryPoint}`}/${segmentName ? `${segmentName}/` : ''}_schema_`;
         log.debug(`Requesting schema for ${formatLoggedSegmentName(segmentName)} at ${endpoint}`);
-        const resp = await fetch(endpoint);
-        if (resp.status !== 200) {
-            const probableCause = {
-                404: 'The segment is not compiled.',
-                500: 'Syntax error in one of controllers.',
-            }[resp.status];
-            log.warn(`Schema request to ${formatLoggedSegmentName(segmentName)} failed with status code ${resp.status} but expected 200.${probableCause ? ` Probable cause: ${probableCause}` : ''}`);
-            return;
-        }
-        let schema = null;
         try {
-            ({ schema } = (await resp.json()));
+            const resp = await fetch(endpoint);
+            if (resp.status !== 200) {
+                const probableCause = {
+                    404: 'The segment did not compile or config.origin is wrong.',
+                }[resp.status];
+                log.warn(`Schema request to ${formatLoggedSegmentName(segmentName)} failed with status code ${resp.status} but expected 200.${probableCause ? ` Probable cause: ${probableCause}` : ''}`);
+                return { isError: true };
+            }
+            let schema = null;
+            try {
+                ({ schema } = (await resp.json()));
+            }
+            catch (error) {
+                log.error(`Error parsing schema for ${formatLoggedSegmentName(segmentName)}: ${error.message}`);
+            }
+            await this.#handleSchema(schema);
         }
         catch (error) {
-            log.error(`Error parsing schema for ${formatLoggedSegmentName(segmentName)}: ${error.message}`);
+            log.error(`Error requesting schema for ${formatLoggedSegmentName(segmentName)}: ${error.message}`);
+            return { isError: true };
         }
-        await this.#handleSchema(schema);
+        return { isError: false };
     }, 500);
     async #handleSchema(schema) {
         const { log, config, cwd } = this.#projectInfo;
@@ -252,16 +271,18 @@ export class VovkCLIWatcher {
             }
         }
         else if (schema && (!isEmpty(schema.controllers) || !isEmpty(schema.workers))) {
-            log.error(`Non-empty schema provided for ${formatLoggedSegmentName(segment.segmentName)} but emitSchema is false`);
+            log.error(`Non-empty schema provided for ${formatLoggedSegmentName(segment.segmentName)} but "emitSchema" is false`);
         }
         if (this.#segments.every((s) => this.#schemas[s.segmentName])) {
             log.debug(`All segments with "emitSchema" have schema.`);
-            await generateClient(this.#projectInfo, this.#segments, this.#schemas);
+            await generateClient({ projectInfo: this.#projectInfo, segments: this.#segments, segmentsSchema: this.#schemas });
         }
     }
-    async start({ clientOutDir } = {}) {
-        this.#projectInfo = await getProjectInfo({ clientOutDir });
+    async start() {
+        const now = Date.now();
+        this.#projectInfo = await getProjectInfo();
         const { log, config, cwd, apiDir } = this.#projectInfo;
+        log.info('Starting...');
         if (config.devHttps) {
             const agent = new Agent({
                 connect: {
@@ -278,18 +299,38 @@ export class VovkCLIWatcher {
         });
         const apiDirAbsolutePath = path.join(cwd, apiDir);
         const schemaOutAbsolutePath = path.join(cwd, config.schemaOutDir);
-        this.#segments = await locateSegments(apiDirAbsolutePath);
+        this.#segments = await locateSegments({ dir: apiDirAbsolutePath, config });
         await debouncedEnsureSchemaFiles(this.#projectInfo, schemaOutAbsolutePath, this.#segments.map((s) => s.segmentName));
-        // Request schema every segment in 3 seconds in order to update schema and start watching
+        // Request schema every segment in 5 seconds in order to update schema on start
         setTimeout(() => {
             for (const { segmentName } of this.#segments) {
-                void this.#requestSchema(segmentName);
+                const MAX_ATTEMPTS = 3;
+                let attempts = 0;
+                void this.#requestSchema(segmentName).then(({ isError }) => {
+                    if (isError) {
+                        const interval = setInterval(() => {
+                            attempts++;
+                            if (attempts >= MAX_ATTEMPTS) {
+                                clearInterval(interval);
+                                log.error(`Failed to request schema for ${formatLoggedSegmentName(segmentName)} after ${MAX_ATTEMPTS} attempts`);
+                                return;
+                            }
+                            void this.#requestSchema(segmentName).then(({ isError: isError2 }) => {
+                                if (!isError2) {
+                                    clearInterval(interval);
+                                }
+                            });
+                        }, 5000);
+                    }
+                });
             }
-            this.#watch();
-        }, 3000);
+        }, 5000);
+        this.#watch(() => {
+            log.info(`Ready in ${Date.now() - now}ms`);
+        });
     }
 }
 const env = process.env;
 if (env.__VOVK_START_WATCHER_IN_STANDALONE_MODE__ === 'true') {
-    void new VovkCLIWatcher().start();
+    void new VovkDev().start();
 }

package/dist/{watcher → dev}/logDiffResult.d.mts

@@ -1,3 +1,3 @@
-import { ProjectInfo } from '../getProjectInfo/index.mjs';
-import { DiffResult } from './diffSchema.mjs';
+import type { DiffResult } from './diffSchema.mjs';
+import type { ProjectInfo } from '../getProjectInfo/index.mjs';
 export default function logDiffResult(segmentName: string, diffResult: DiffResult, projectInfo: ProjectInfo): void;

package/dist/{watcher → dev}/logDiffResult.mjs

@@ -1,3 +1,4 @@
+import chalk from 'chalk';
 import formatLoggedSegmentName from '../utils/formatLoggedSegmentName.mjs';
 import chalkHighlightThing from '../utils/chalkHighlightThing.mjs';
 export default function logDiffResult(segmentName, diffResult, projectInfo) {
@@ -37,48 +38,51 @@ export default function logDiffResult(segmentName, diffResult, projectInfo) {
         });
     });
     const LIMIT = diffNormalized.length < 12 ? diffNormalized.length : 10;
+    const addedText = chalk.green('added');
+    const removedText = chalk.red('removed');
+    const changedText = chalk.cyan('changed');
     for (const diffNormalizedItem of diffNormalized.slice(0, LIMIT)) {
         switch (diffNormalizedItem.what) {
             case 'worker':
                 switch (diffNormalizedItem.type) {
                     case 'added':
-                        projectInfo.log.info(`Schema for worker ${chalkHighlightThing(diffNormalizedItem.name)} has been added at ${formatLoggedSegmentName(segmentName)}`);
+                        projectInfo.log.info(`Schema for worker ${chalkHighlightThing(diffNormalizedItem.name)} has been ${addedText} at ${formatLoggedSegmentName(segmentName)}`);
                         break;
                     case 'removed':
-                        projectInfo.log.info(`Schema for worker ${chalkHighlightThing(diffNormalizedItem.name)} has been removed from ${formatLoggedSegmentName(segmentName)}`);
+                        projectInfo.log.info(`Schema for worker ${chalkHighlightThing(diffNormalizedItem.name)} has been ${removedText} from ${formatLoggedSegmentName(segmentName)}`);
                         break;
                 }
                 break;
             case 'controller':
                 switch (diffNormalizedItem.type) {
                     case 'added':
-                        projectInfo.log.info(`Schema for controller ${chalkHighlightThing(diffNormalizedItem.name)} has been added at ${formatLoggedSegmentName(segmentName)}`);
+                        projectInfo.log.info(`Schema for controller ${chalkHighlightThing(diffNormalizedItem.name)} has been ${addedText} at ${formatLoggedSegmentName(segmentName)}`);
                         break;
                     case 'removed':
-                        projectInfo.log.info(`Schema for controller ${chalkHighlightThing(diffNormalizedItem.name)} has been removed from ${formatLoggedSegmentName(segmentName)}`);
+                        projectInfo.log.info(`Schema for controller ${chalkHighlightThing(diffNormalizedItem.name)} has been ${removedText} from ${formatLoggedSegmentName(segmentName)}`);
                         break;
                 }
                 break;
             case 'workerHandler':
                 switch (diffNormalizedItem.type) {
                     case 'added':
-                        projectInfo.log.info(`Schema for worker method ${chalkHighlightThing(diffNormalizedItem.name)} has been added at ${formatLoggedSegmentName(segmentName)}`);
+                        projectInfo.log.info(`Schema for worker method ${chalkHighlightThing(diffNormalizedItem.name)} has been ${addedText} at ${formatLoggedSegmentName(segmentName)}`);
                         break;
                     case 'removed':
-                        projectInfo.log.info(`Schema for worker method ${chalkHighlightThing(diffNormalizedItem.name)} has been removed from ${formatLoggedSegmentName(segmentName)}`);
+                        projectInfo.log.info(`Schema for worker method ${chalkHighlightThing(diffNormalizedItem.name)} has been ${removedText} from ${formatLoggedSegmentName(segmentName)}`);
                         break;
                 }
                 break;
             case 'controllerHandler':
                 switch (diffNormalizedItem.type) {
                     case 'added':
-                        projectInfo.log.info(`Schema for controller method ${chalkHighlightThing(diffNormalizedItem.name)} has been added at ${formatLoggedSegmentName(segmentName)}`);
+                        projectInfo.log.info(`Schema for controller method ${chalkHighlightThing(diffNormalizedItem.name)} has been ${addedText} at ${formatLoggedSegmentName(segmentName)}`);
                         break;
                     case 'removed':
-                        projectInfo.log.info(`Schema for controller method ${chalkHighlightThing(diffNormalizedItem.name)} has been removed from ${formatLoggedSegmentName(segmentName)}`);
+                        projectInfo.log.info(`Schema for controller method ${chalkHighlightThing(diffNormalizedItem.name)} has been ${removedText} from ${formatLoggedSegmentName(segmentName)}`);
                         break;
                     case 'changed':
-                        projectInfo.log.info(`Schema for controller method ${chalkHighlightThing(diffNormalizedItem.name)} has been changed at ${formatLoggedSegmentName(segmentName)}`);
+                        projectInfo.log.info(`Schema for controller method ${chalkHighlightThing(diffNormalizedItem.name)} has been ${changedText} at ${formatLoggedSegmentName(segmentName)}`);
                         break;
                 }
                 break;

package/dist/{watcher → dev}/writeOneSchemaFile.d.mts

@@ -1,5 +1,5 @@
 import type { VovkSchema } from 'vovk';
-import { DiffResult } from './diffSchema.mjs';
+import { type DiffResult } from './diffSchema.mjs';
 export declare const ROOT_SEGMENT_SCHEMA_NAME = "_root";
 export default function writeOneSchemaFile({ schemaOutAbsolutePath, schema, skipIfExists, }: {
     schemaOutAbsolutePath: string;

package/dist/{watcher → dev}/writeOneSchemaFile.mjs

@@ -1,10 +1,11 @@
-import path from 'path';
-import fs from 'fs/promises';
+import path from 'node:path';
+import fs from 'node:fs/promises';
 import diffSchema from './diffSchema.mjs';
+import getFileSystemEntryType from '../utils/getFileSystemEntryType.mjs';
 export const ROOT_SEGMENT_SCHEMA_NAME = '_root';
 export default async function writeOneSchemaFile({ schemaOutAbsolutePath, schema, skipIfExists = false, }) {
     const segmentPath = path.join(schemaOutAbsolutePath, `${schema.segmentName || ROOT_SEGMENT_SCHEMA_NAME}.json`);
-    if (skipIfExists) {
+    if (skipIfExists && (await getFileSystemEntryType(segmentPath))) {
         try {
             await fs.stat(segmentPath);
             return { isCreated: false, diffResult: null };

package/dist/generateClient.d.mts

@@ -1,7 +1,12 @@
+import type { VovkSchema } from 'vovk';
 import type { ProjectInfo } from './getProjectInfo/index.mjs';
 import type { Segment } from './locateSegments.mjs';
-import type { VovkSchema } from 'vovk';
-export default function generateClient(projectInfo: ProjectInfo, segments: Segment[], segmentsSchema: Record<string, VovkSchema>): Promise<{
+import { GenerateOptions } from './types.mjs';
+export default function generateClient({ projectInfo, segments, segmentsSchema, templates, prettify: prettifyClient, fullSchema, noClient, }: {
+    projectInfo: ProjectInfo;
+    segments: Segment[];
+    segmentsSchema: Record<string, VovkSchema>;
+} & Pick<GenerateOptions, 'templates' | 'prettify' | 'fullSchema' | 'noClient'>): Promise<{
     written: boolean;
     path: string;
 }>;

package/dist/generateClient.mjs

@@ -1,59 +1,32 @@
-import path from 'path';
-import fs from 'fs/promises';
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import ejs from 'ejs';
 import formatLoggedSegmentName from './utils/formatLoggedSegmentName.mjs';
 import prettify from './utils/prettify.mjs';
-export default async function generateClient(projectInfo, segments, segmentsSchema) {
-    const { config, cwd, log, validateOnClientImportPath, apiEntryPoint, fetcherClientImportPath, schemaOutImportPath } = projectInfo;
-    const now = Date.now();
-    const clientoOutDirAbsolutePath = path.join(cwd, config.clientOutDir);
-    let dts = `// auto-generated
-/* eslint-disable */
-import type { clientizeController } from 'vovk/client';
-import type { promisifyWorker } from 'vovk/worker';
-import type { VovkClientFetcher } from 'vovk/client';
-import type fetcher from '${fetcherClientImportPath}';
-
-`;
-    let js = `// auto-generated
-/* eslint-disable */
-const { clientizeController } = require('vovk/client');
-const { promisifyWorker } = require('vovk/worker');
-const { default: fetcher } = require('${fetcherClientImportPath}');
-const schema = require('${schemaOutImportPath}');
-`;
-    let ts = `// auto-generated
-/* eslint-disable */
-import { clientizeController } from 'vovk/client';
-import { promisifyWorker } from 'vovk/worker';
-import type { VovkClientFetcher } from 'vovk/client';
-import fetcher from '${fetcherClientImportPath}';
-import schema from '${schemaOutImportPath}';
-
-`;
-    for (let i = 0; i < segments.length; i++) {
-        const { routeFilePath, segmentName } = segments[i];
-        const schema = segmentsSchema[segmentName];
-        if (!schema) {
-            throw new Error(`Unable to generate client. No schema found for ${formatLoggedSegmentName(segmentName)}`);
+export default async function generateClient({ projectInfo, segments, segmentsSchema, templates = ['ts', 'compiled'], prettify: prettifyClient, fullSchema, noClient, }) {
+    const { config, cwd, log, validateOnClientImportPath, apiEntryPoint, fetcherClientImportPath, schemaOutImportPath, } = projectInfo;
+    const __dirname = path.dirname(new URL(import.meta.url).pathname);
+    const templatesDir = path.join(__dirname, '..', 'client-templates');
+    const clientOutDirAbsolutePath = path.resolve(cwd, config.clientOutDir);
+    const mapper = (dir) => (name) => ({
+        templatePath: path.resolve(templatesDir, dir, name),
+        outPath: path.join(clientOutDirAbsolutePath, name.replace('.ejs', '')),
+    });
+    const builtInTemplatesMap = {
+        ts: ['index.ts.ejs'].map(mapper('ts')),
+        compiled: ['client.js.ejs', 'client.d.ts.ejs'].map(mapper('compiled')),
+        python: ['__init__.py'].map(mapper('python')),
+    };
+    const templateFiles = templates.reduce((acc, template) => {
+        if (template in builtInTemplatesMap) {
+            return [...acc, ...builtInTemplatesMap[template]];
         }
-        if (!schema.emitSchema)
-            continue;
-        const importRouteFilePath = path.relative(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`;
-    }
-    dts += `
-type Options = typeof fetcher extends VovkClientFetcher<infer U> ? U : never;
-`;
-    ts += `
-${validateOnClientImportPath ? `import validateOnClient from '${validateOnClientImportPath}';\n` : '\nconst validateOnClient = undefined;'}
-type Options = typeof fetcher extends VovkClientFetcher<infer U> ? U : never;
-const prefix = '${apiEntryPoint}';
-`;
-    js += `
-const { default: validateOnClient = null } = ${validateOnClientImportPath ? `require('${validateOnClientImportPath}')` : '{}'};
-const prefix = '${apiEntryPoint}';
-`;
+        return [...acc, {
+                templatePath: path.resolve(cwd, template),
+                outPath: path.join(clientOutDirAbsolutePath, path.basename(template).replace('.ejs', ''))
+            }];
+    }, []);
+    // 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];
@@ -62,36 +35,57 @@ const prefix = '${apiEntryPoint}';
         }
         if (!schema.emitSchema)
             continue;
-        for (const key of Object.keys(schema.controllers)) {
-            dts += `export const ${key}: ReturnType<typeof clientizeController<Controllers${i}["${key}"], Options>>;\n`;
-            js += `exports.${key} = clientizeController(schema['${segmentName}'].controllers.${key}, '${segmentName}', { fetcher, validateOnClient, defaultOptions: { prefix } });\n`;
-            ts += `export const ${key} = clientizeController<Controllers${i}["${key}"], Options>(schema['${segmentName}'].controllers.${key}, '${segmentName}', { fetcher, validateOnClient, defaultOptions: { prefix } });\n`;
-        }
-        for (const key of Object.keys(schema.workers)) {
-            dts += `export const ${key}: ReturnType<typeof promisifyWorker<Workers${i}["${key}"]>>;\n`;
-            js += `exports.${key} = promisifyWorker(null, schema['${segmentName}'].workers.${key});\n`;
-            ts += `export const ${key} = promisifyWorker<Workers${i}["${key}"]>(null, schema['${segmentName}'].workers.${key});\n`;
-        }
     }
-    const localJsAbsolutePath = path.join(clientoOutDirAbsolutePath, 'client.js');
-    const localDtsAbsolutePath = path.join(clientoOutDirAbsolutePath, 'client.d.ts');
-    const localTsAbsolutePath = path.join(clientoOutDirAbsolutePath, 'index.ts');
-    const existingJs = await fs.readFile(localJsAbsolutePath, 'utf-8').catch(() => '');
-    const existingDts = await fs.readFile(localDtsAbsolutePath, 'utf-8').catch(() => '');
-    const existingTs = await fs.readFile(localTsAbsolutePath, 'utf-8').catch(() => '');
-    if (config.prettifyClient) {
-        js = await prettify(js, localJsAbsolutePath);
-        dts = await prettify(dts, localDtsAbsolutePath);
-        ts = await prettify(ts, localTsAbsolutePath);
+    const now = Date.now();
+    // Data for the EJS templates:
+    const ejsData = {
+        apiEntryPoint,
+        fetcherClientImportPath,
+        schemaOutImportPath,
+        validateOnClientImportPath,
+        segments,
+        segmentsSchema,
+    };
+    // 1. Process each template in parallel
+    const processedTemplates = noClient ? [] : await Promise.all(templateFiles.map(async ({ templatePath, outPath }) => {
+        // Read the EJS template
+        const templateContent = await fs.readFile(templatePath, 'utf-8');
+        // Render the template
+        let rendered = templatePath.endsWith('.ejs') ? ejs.render(templateContent, ejsData) : 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
+        const needsWriting = existingContent !== rendered;
+        return {
+            outPath,
+            rendered,
+            needsWriting,
+        };
+    }));
+    if (fullSchema) {
+        const fullSchemaOutAbsolutePath = path.resolve(clientOutDirAbsolutePath, typeof fullSchema === 'string' ? fullSchema : 'full-schema.json');
+        await fs.writeFile(fullSchemaOutAbsolutePath, JSON.stringify(segmentsSchema, null, 2));
+        log.info(`Full schema written to ${fullSchemaOutAbsolutePath}`);
     }
-    if (existingJs === js && existingDts === dts && existingTs === ts) {
+    // 2. Check if any file needs rewriting
+    const anyNeedsWriting = processedTemplates.some(({ needsWriting }) => needsWriting);
+    if (!anyNeedsWriting) {
         log.debug(`Client is up to date and doesn't need to be regenerated (${Date.now() - now}ms)`);
-        return { written: false, path: clientoOutDirAbsolutePath };
+        return { written: false, path: clientOutDirAbsolutePath };
     }
-    await fs.mkdir(clientoOutDirAbsolutePath, { recursive: true });
-    await fs.writeFile(localJsAbsolutePath, js);
-    await fs.writeFile(localDtsAbsolutePath, dts);
-    await fs.writeFile(localTsAbsolutePath, ts);
+    // 3. Make sure the output directory exists
+    await fs.mkdir(clientOutDirAbsolutePath, { recursive: true });
+    // 4. Write updated files where needed
+    await Promise.all(processedTemplates.map(({ outPath, rendered, needsWriting }) => {
+        if (needsWriting) {
+            return fs.writeFile(outPath, rendered);
+        }
+        return null;
+    }));
     log.info(`Client generated in ${Date.now() - now}ms`);
-    return { written: true, path: clientoOutDirAbsolutePath };
+    return { written: true, path: clientOutDirAbsolutePath };
 }

package/dist/getProjectInfo/getConfig.mjs

@@ -15,7 +15,7 @@ export default async function getConfig({ clientOutDir, cwd }) {
         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,
         templates: {

package/dist/getProjectInfo/getConfigAbsolutePaths.mjs

@@ -1,5 +1,5 @@
-import fs from 'fs/promises';
-import path from 'path';
+import fs from 'node:fs/promises';
+import path from 'node:path';
 export default async function getConfigAbsolutePaths({ cwd, relativePath, }) {
     const rootDir = path.resolve(cwd, relativePath || '');
     const baseName = 'vovk.config';

package/dist/getProjectInfo/getRelativeSrcRoot.mjs

@@ -1,11 +1,11 @@
-import path from 'path';
-import directoryExists from './directoryExists.mjs';
+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.
-    if (await directoryExists(path.join(cwd, 'app'))) {
+    if ((await getFileSystemEntryType(path.join(cwd, 'app'))) === FileSystemEntryType.DIRECTORY) {
         return '.';
     }
-    else if (await directoryExists(path.join(cwd, 'src/app'))) {
+    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.`);