vovk-cli 0.0.1-draft.130 → 0.0.1-draft.131

package/dist/dev/index.mjs

@@ -19,7 +19,6 @@ import isSegmentSchemaEmpty from './isSegmentSchemaEmpty.mjs';
 import writeConfigJson from './writeConfigJson.mjs';
 export class VovkDev {
     #projectInfo;
-    #segments = [];
     #fullSchema = {
         segments: {},
         config: {},
@@ -44,10 +43,10 @@ export class VovkDev {
             log.debug(`File ${filePath} has been added to segments folder`);
             if (segmentReg.test(filePath)) {
                 const segmentName = getSegmentName(filePath);
-                this.#segments = this.#segments.find((s) => s.segmentName === segmentName)
-                    ? this.#segments
+                this.#projectInfo.segments = this.#projectInfo.segments.find((s) => s.segmentName === segmentName)
+                    ? this.#projectInfo.segments
                     : [
-                        ...this.#segments,
+                        ...this.#projectInfo.segments,
                         {
                             routeFilePath: filePath,
                             segmentName,
@@ -55,8 +54,8 @@ export class VovkDev {
                         },
                     ];
                 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));
+                log.debug(`Full list of segments: ${this.#projectInfo.segments.map((s) => s.segmentName).join(', ')}`);
+                void debouncedEnsureSchemaFiles(this.#projectInfo, schemaOutAbsolutePath, this.#projectInfo.segments.map((s) => s.segmentName));
             }
         })
             .on('change', (filePath) => {
@@ -67,15 +66,15 @@ export class VovkDev {
         })
             .on('addDir', async (dirPath) => {
             log.debug(`Directory ${dirPath} has been added to segments folder`);
-            this.#segments = await locateSegments({ dir: apiDirAbsolutePath, config });
-            for (const { segmentName } of this.#segments) {
+            this.#projectInfo.segments = await locateSegments({ dir: apiDirAbsolutePath, config });
+            for (const { segmentName } of this.#projectInfo.segments) {
                 void this.#requestSchema(segmentName);
             }
         })
             .on('unlinkDir', async (dirPath) => {
             log.debug(`Directory ${dirPath} has been removed from segments folder`);
-            this.#segments = await locateSegments({ dir: apiDirAbsolutePath, config });
-            for (const { segmentName } of this.#segments) {
+            this.#projectInfo.segments = await locateSegments({ dir: apiDirAbsolutePath, config });
+            for (const { segmentName } of this.#projectInfo.segments) {
                 void this.#requestSchema(segmentName);
             }
         })
@@ -83,10 +82,10 @@ export class VovkDev {
             log.debug(`File ${filePath} has been removed from segments folder`);
             if (segmentReg.test(filePath)) {
                 const segmentName = getSegmentName(filePath);
-                this.#segments = this.#segments.filter((s) => s.segmentName !== segmentName);
+                this.#projectInfo.segments = this.#projectInfo.segments.filter((s) => s.segmentName !== segmentName);
                 log.info(`${formatLoggedSegmentName(segmentName, { upperFirst: true })} has been removed`);
-                log.debug(`Full list of segments: ${this.#segments.map((s) => s.segmentName).join(', ')}`);
-                void debouncedEnsureSchemaFiles(this.#projectInfo, schemaOutAbsolutePath, this.#segments.map((s) => s.segmentName));
+                log.debug(`Full list of segments: ${this.#projectInfo.segments.map((s) => s.segmentName).join(', ')}`);
+                void debouncedEnsureSchemaFiles(this.#projectInfo, schemaOutAbsolutePath, this.#projectInfo.segments.map((s) => s.segmentName));
             }
         })
             .on('ready', () => {
@@ -119,12 +118,12 @@ export class VovkDev {
             log.debug(`File ${filePath} has been removed from modules folder`);
         })
             .on('addDir', () => {
-            for (const { segmentName } of this.#segments) {
+            for (const { segmentName } of this.#projectInfo.segments) {
                 void this.#requestSchema(segmentName);
             }
         })
             .on('unlinkDir', () => {
-            for (const { segmentName } of this.#segments) {
+            for (const { segmentName } of this.#projectInfo.segments) {
                 void this.#requestSchema(segmentName);
             }
         })
@@ -192,7 +191,7 @@ export class VovkDev {
         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))}.`);
+        log.debug(`Starting segments and modules watcher. Detected initial segments: ${JSON.stringify(this.#projectInfo.segments.map((s) => s.segmentName))}.`);
         // automatically watches segments and modules
         this.#watchConfig(callback);
     }
@@ -207,7 +206,7 @@ export class VovkDev {
         const namesOfClasses = [...code.matchAll(nameOfClasReg)].map((match) => match[1]);
         const importRegex = /import\s*{[^}]*\b(get|post|put|del|head|options)\b[^}]*}\s*from\s*['"]vovk['"]/;
         if (importRegex.test(code) && namesOfClasses.length) {
-            const affectedSegments = this.#segments.filter((s) => {
+            const affectedSegments = this.#projectInfo.segments.filter((s) => {
                 const segmentSchema = this.#fullSchema.segments[s.segmentName];
                 if (!segmentSchema)
                     return false;
@@ -257,7 +256,7 @@ export class VovkDev {
         }
         return { isError: false };
     }, 500);
-    #generate = debounce(() => generate({ projectInfo: this.#projectInfo, segments: this.#segments, fullSchema: this.#fullSchema }).then(this.#onFirstTimeGenerate), 1000);
+    #generate = debounce(() => generate({ projectInfo: this.#projectInfo, fullSchema: this.#fullSchema }).then(this.#onFirstTimeGenerate), 1000);
     async #handleSegmentSchema(segmentName, segmentSchema) {
         const { log, config, cwd } = this.#projectInfo;
         if (!segmentSchema) {
@@ -266,7 +265,7 @@ export class VovkDev {
         }
         log.debug(`Handling received schema from ${formatLoggedSegmentName(segmentName)}`);
         const schemaOutAbsolutePath = path.join(cwd, config.schemaOutDir);
-        const segment = this.#segments.find((s) => s.segmentName === segmentName);
+        const segment = this.#projectInfo.segments.find((s) => s.segmentName === segmentName);
         if (!segment) {
             log.warn(`${formatLoggedSegmentName(segmentName)} not found`);
             return;
@@ -288,7 +287,7 @@ export class VovkDev {
         else if (segmentSchema && !isSegmentSchemaEmpty(segmentSchema)) {
             log.error(`Non-empty schema provided for ${formatLoggedSegmentName(segment.segmentName)} but "emitSchema" is false`);
         }
-        if (this.#segments.every((s) => this.#fullSchema.segments[s.segmentName])) {
+        if (this.#projectInfo.segments.every((s) => this.#fullSchema.segments[s.segmentName])) {
             log.debug(`All segments with "emitSchema" have schema.`);
             this.#generate();
         }
@@ -296,7 +295,7 @@ export class VovkDev {
     async start({ exit }) {
         const now = Date.now();
         this.#projectInfo = await getProjectInfo();
-        const { log, config, cwd, apiDir } = this.#projectInfo;
+        const { log, config, cwd } = this.#projectInfo;
         log.info('Starting...');
         if (exit) {
             this.#onFirstTimeGenerate = once(() => {
@@ -317,16 +316,14 @@ export class VovkDev {
         process.on('unhandledRejection', (reason) => {
             log.error(`Unhandled Rejection: ${String(reason)}`);
         });
-        const apiDirAbsolutePath = path.join(cwd, apiDir);
         const schemaOutAbsolutePath = path.join(cwd, config.schemaOutDir);
-        this.#segments = await locateSegments({ dir: apiDirAbsolutePath, config });
-        await ensureSchemaFiles(this.#projectInfo, schemaOutAbsolutePath, this.#segments.map((s) => s.segmentName));
+        await ensureSchemaFiles(this.#projectInfo, schemaOutAbsolutePath, this.#projectInfo.segments.map((s) => s.segmentName));
         await ensureClient(this.#projectInfo);
         const MAX_ATTEMPTS = 5;
         const DELAY = 5000;
         // Request schema every segment in 5 seconds in order to update schema on start
         setTimeout(() => {
-            for (const { segmentName } of this.#segments) {
+            for (const { segmentName } of this.#projectInfo.segments) {
                 let attempts = 0;
                 void this.#requestSchema(segmentName).then(({ isError }) => {
                     if (isError) {

package/dist/generate/ensureClient.d.mts

@@ -1,4 +1,4 @@
 import type { ProjectInfo } from '../getProjectInfo/index.mjs';
-export default function ensureClient({ config, cwd, log }: ProjectInfo): Promise<{
+export default function ensureClient({ config, cwd, log, segments }: ProjectInfo): Promise<{
     written: boolean;
 }>;

package/dist/generate/ensureClient.mjs

@@ -1,41 +1,66 @@
 import fs from 'node:fs/promises';
+import path from 'node:path';
 import getClientTemplates, { BuiltInTemplateName } from './getClientTemplates.mjs';
-import uniq from 'lodash/uniq.js';
 import chalkHighlightThing from '../utils/chalkHighlightThing.mjs';
-import path from 'node:path';
-export default async function ensureClient({ config, cwd, log }) {
+import { ROOT_SEGMENT_SCHEMA_NAME } from '../dev/writeOneSegmentSchemaFile.mjs';
+async function writeOnePlaceholder({ outPath, defaultText, templateName, usedTemplateNames, }) {
+    const existing = await fs.readFile(outPath, 'utf-8').catch(() => null);
+    if (!existing) {
+        let text = defaultText;
+        await fs.mkdir(path.dirname(outPath), { recursive: true });
+        // a workaround that prevents compilation error when client is not yet generated but back-end imports fullSchema
+        if (Object.keys(BuiltInTemplateName).includes(templateName)) {
+            if (outPath.endsWith('.cjs')) {
+                text += '\nmodule.exports.fullSchema = {};';
+            }
+            else {
+                text += '\nexport const fullSchema = {};';
+            }
+        }
+        await fs.writeFile(outPath, outPath.endsWith('.py') ? text.replace(/\/\//g, '#') : text);
+        usedTemplateNames.add(templateName);
+    }
+}
+export default async function ensureClient({ config, cwd, log, segments }) {
     const now = Date.now();
     const { clientOutDirAbsolutePath, templateFiles } = await getClientTemplates({
         config,
         cwd,
         generateFrom: config.generateFrom,
     });
-    let usedTemplateNames = [];
+    const usedTemplateNames = new Set();
     const defaultText = `// auto-generated ${new Date().toISOString()}
 // This is a temporary placeholder to avoid compilation errors if client is imported before it's generated.
 // If you still see this text, the client is not generated yet because of an unknown problem.
 // Feel free to report an issue at https://github.com/finom/vovk/issues`;
-    for (const { outPath, templateName } of templateFiles) {
-        const existing = await fs.readFile(outPath, 'utf-8').catch(() => null);
-        let text = defaultText;
-        if (!existing) {
-            await fs.mkdir(path.dirname(outPath), { recursive: true });
-            // a workaround that prevents compilation error when client is not yet generated but back-end imports fullSchema
-            if (Object.keys(BuiltInTemplateName).includes(templateName)) {
-                if (outPath.endsWith('.cjs')) {
-                    text += '\nmodule.exports.fullSchema = {};';
-                }
-                else {
-                    text += '\nexport const fullSchema = {};';
-                }
-            }
-            await fs.writeFile(outPath, outPath.endsWith('.py') ? text.replace(/\/\//g, '#') : text);
-            usedTemplateNames.push(templateName);
+    await Promise.all(templateFiles.map(async (clientTemplate) => {
+        const { templatePath, templateName, outDir } = clientTemplate;
+        const outPath = path.join(outDir, path.basename(templatePath).replace('.ejs', ''));
+        if (config.emitFullClient) {
+            await writeOnePlaceholder({
+                outPath,
+                defaultText,
+                templateName,
+                usedTemplateNames,
+            });
         }
+        if (config.emitSegmentClient) {
+            // Generate client files for each segment
+            await Promise.all(segments.map(async ({ segmentName }) => {
+                const outPath = path.join(outDir, segmentName || ROOT_SEGMENT_SCHEMA_NAME, path.basename(templatePath).replace('.ejs', ''));
+                return writeOnePlaceholder({
+                    outPath,
+                    defaultText,
+                    templateName,
+                    usedTemplateNames,
+                });
+            }));
+        }
+    }));
+    if (usedTemplateNames.size) {
+        log.info(`Placeholder client files from template${usedTemplateNames.size !== 1 ? 's' : ''} ${chalkHighlightThing(Array.from(usedTemplateNames)
+            .map((s) => `"${s}"`)
+            .join(', '))} are generated at ${clientOutDirAbsolutePath} in ${Date.now() - now}ms`);
     }
-    usedTemplateNames = uniq(usedTemplateNames);
-    if (usedTemplateNames.length) {
-        log.info(`Placeholder client files from template${usedTemplateNames.length !== 1 ? 's' : ''} ${chalkHighlightThing(usedTemplateNames.map((s) => `"${s}"`).join(', '))} are generated at ${clientOutDirAbsolutePath} in ${Date.now() - now}ms`);
-    }
-    return { written: !!usedTemplateNames.length };
+    return { written: !!usedTemplateNames.size };
 }

package/dist/generate/getClientTemplates.d.mts

@@ -1,10 +1,10 @@
 import type { VovkStrictConfig } from 'vovk';
 export declare const DEFAULT_FULL_SCHEMA_FILE_NAME = "full-schema.json";
-interface ClientTemplate {
+export interface ClientTemplate {
     templateName: string;
     templatePath: string;
-    outPath: string;
-    fullSchemaOutAbsolutePath: string | null;
+    outDir: string;
+    fullSchemaJSONFileName: string | null;
     origin?: string | null;
 }
 export declare enum BuiltInTemplateName {
@@ -21,4 +21,3 @@ export default function getClientTemplates({ config, cwd, generateFrom, }: {
     clientOutDirAbsolutePath: string;
     templateFiles: ClientTemplate[];
 }>;
-export {};

package/dist/generate/getClientTemplates.mjs

@@ -17,28 +17,28 @@ export default async function getClientTemplates({ config, cwd, generateFrom = [
             templateName: BuiltInTemplateName.ts,
             templatePath: path.resolve(templatesDir, 'ts/*'),
             outDir: clientOutDirAbsolutePath,
-            fullSchema: false,
+            fullSchemaJSON: false,
             origin: null,
         },
         main: {
             templateName: BuiltInTemplateName.main,
             templatePath: path.resolve(templatesDir, 'main/*'),
             outDir: clientOutDirAbsolutePath,
-            fullSchema: false,
+            fullSchemaJSON: false,
             origin: null,
         },
         module: {
             templateName: BuiltInTemplateName.module,
             templatePath: path.resolve(templatesDir, 'module/*'),
             outDir: clientOutDirAbsolutePath,
-            fullSchema: false,
+            fullSchemaJSON: false,
             origin: null,
         },
         fullSchema: {
             templateName: BuiltInTemplateName.fullSchema,
             templatePath: path.resolve(templatesDir, 'fullSchema/*'),
             outDir: clientOutDirAbsolutePath,
-            fullSchema: false,
+            fullSchemaJSON: false,
             origin: null,
         },
     };
@@ -51,7 +51,7 @@ export default async function getClientTemplates({ config, cwd, generateFrom = [
                 templateName: template,
                 templatePath: resolveAbsoluteModulePath(template, cwd),
                 outDir: clientOutDirAbsolutePath,
-                fullSchema: false,
+                fullSchemaJSON: false,
                 origin: null,
             };
         }
@@ -59,7 +59,7 @@ export default async function getClientTemplates({ config, cwd, generateFrom = [
             templateName: template.templateName ?? template.templatePath,
             templatePath: resolveAbsoluteModulePath(template.templatePath, cwd),
             outDir: template.outDir ? path.resolve(cwd, template.outDir) : clientOutDirAbsolutePath,
-            fullSchema: template.fullSchema ?? false,
+            fullSchemaJSON: template.fullSchemaJSON ?? false,
             origin: template.origin ?? null,
         };
     });
@@ -70,14 +70,15 @@ export default async function getClientTemplates({ config, cwd, generateFrom = [
     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,
+                outDir: generateFromItem.outDir,
+                fullSchemaJSONFileName: generateFromItem.fullSchemaJSON
+                    ? generateFromItem.fullSchemaJSON === 'string'
+                        ? generateFromItem.fullSchemaJSON
+                        : DEFAULT_FULL_SCHEMA_FILE_NAME
+                    : null,
                 origin: generateFromItem.origin,
             });
         }

package/dist/generate/index.d.mts

@@ -1,13 +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, }: {
+export type ClientImports = {
+    fetcher: string;
+    validateOnClient: string | null;
+    createRPC: string;
+};
+export default function generate({ projectInfo, forceNothingWrittenLog, templates, prettify: prettifyClient, fullSchema, emitFullSchema, }: {
     projectInfo: ProjectInfo;
-    segments: Segment[];
     forceNothingWrittenLog?: boolean;
     fullSchema: VovkFullSchema;
-} & Pick<GenerateOptions, 'templates' | 'prettify' | 'emitFullSchema'>): Promise<{
-    written: boolean;
-    path: string;
-}>;
+} & Pick<GenerateOptions, 'templates' | 'prettify' | 'emitFullSchema'>): Promise<void>;

package/dist/generate/index.mjs

@@ -2,114 +2,181 @@ 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 _ from 'lodash';
 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;
+import pickSegmentFullSchema from '../utils/pickSegmentFullSchema.mjs';
+import removeUnlistedDirectories from '../utils/removeUnlistedDirectories.mjs';
+async function writeOneClientFile({ projectInfo, clientTemplate, fullSchema, prettifyClient, segmentName, imports, templateContent, matterResult: { data, content }, }) {
+    const { config, apiRoot, segments } = projectInfo;
+    const { templatePath, outDir, origin } = clientTemplate;
+    const outPath = path.join(outDir, typeof segmentName === 'string' ? segmentName || ROOT_SEGMENT_SCHEMA_NAME : '', path.basename(templatePath).replace('.ejs', ''));
+    const schemaOutDir = path.relative(config.clientOutDir, config.schemaOutDir).replace(/\\/g, '/'); // windows fix
+    // Data for the EJS templates:
+    const t = {
+        _, // lodash
+        ROOT_SEGMENT_SCHEMA_NAME,
+        SEGMENTS_SCHEMA_DIR_NAME,
+        apiRoot: origin ? `${origin}/${config.rootEntry}` : apiRoot,
+        imports,
+        fullSchema,
+        schemaOutDir,
+        segmentMeta: Object.fromEntries(segments.map(({ segmentName, routeFilePath, segmentImportPath }) => [
+            segmentName,
+            {
+                routeFilePath,
+                segmentImportPath: typeof segmentName === 'string'
+                    ? `${_.times((segmentName.match(/\//g)?.length ?? 0) + 1)
+                        .map(() => '..')
+                        .join('/')}/${segmentImportPath}`
+                    : segmentImportPath,
+            },
+        ])),
+    };
+    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');
+    if (needsWriting) {
+        await fs.mkdir(path.dirname(outPath), { recursive: true });
+        await fs.writeFile(outPath, rendered);
+    }
+    return { written: needsWriting };
+}
+export default async function generate({ projectInfo, forceNothingWrittenLog, templates, prettify: prettifyClient = false, fullSchema, emitFullSchema, }) {
+    const now = Date.now();
     const generateFrom = templates ?? projectInfo.config.generateFrom;
     const noClient = templates?.[0] === 'none';
-    const { config, cwd, log, clientImports, apiRoot } = projectInfo;
+    const { config, cwd, log, clientImports, segments } = 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];
+        const schema = fullSchema.segments[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
+    let written = false;
+    const fullSchemaOutAbsolutePaths = new Map();
+    const usedTemplateNames = new Set();
     // 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;*/
+    await Promise.all(templateFiles.map(async (clientTemplate) => {
+        const { templatePath, templateName, outDir, fullSchemaJSONFileName } = clientTemplate;
+        if (!noClient) {
             // 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),
-                    };
+            const matterResult = matter(templateContent);
+            if (config.emitFullClient) {
+                const { written: isWritten } = await writeOneClientFile({
+                    projectInfo,
+                    clientTemplate,
+                    fullSchema,
+                    prettifyClient,
+                    segmentName: null,
+                    imports: clientImports.fullClient,
+                    templateContent,
+                    matterResult,
+                });
+                if (isWritten) {
+                    usedTemplateNames.add(templateName);
                 }
+                written ||= isWritten;
             }
-            // 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);
+            // TODO Remove files if emitFullClient is false ???
+            if (config.emitSegmentClient) {
+                // Generate client files for each segment
+                await Promise.all(segments.map(async ({ segmentName }) => {
+                    const segmentFullSchema = {
+                        config: fullSchema.config,
+                        segments: { [segmentName]: fullSchema.segments[segmentName] },
+                    };
+                    const { written: isWritten } = await writeOneClientFile({
+                        projectInfo,
+                        clientTemplate,
+                        fullSchema: segmentFullSchema,
+                        prettifyClient,
+                        segmentName,
+                        imports: clientImports.schemaClient[segmentName],
+                        templateContent,
+                        matterResult,
+                    });
+                    if (isWritten) {
+                        usedTemplateNames.add(templateName);
+                    }
+                    written ||= isWritten;
+                }));
+                await removeUnlistedDirectories(outDir, segments.map(({ segmentName }) => segmentName || ROOT_SEGMENT_SCHEMA_NAME));
             }
-            // 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);
+            else {
+                await removeUnlistedDirectories(outDir, []);
+            }
+        }
+        if (config.emitFullClient) {
+            const fullSchemaOutAbsolutePath = fullSchemaJSONFileName ? path.resolve(outDir, fullSchemaJSONFileName) : null;
+            if (fullSchemaOutAbsolutePath) {
+                fullSchemaOutAbsolutePaths.set(null, fullSchemaOutAbsolutePath);
+            }
+        }
+        if (config.emitSegmentClient) {
+            segments.forEach(({ segmentName }) => {
+                const fullSchemaOutAbsolutePath = fullSchemaJSONFileName
+                    ? path.resolve(outDir, segmentName || ROOT_SEGMENT_SCHEMA_NAME, fullSchemaJSONFileName)
+                    : null;
+                if (fullSchemaOutAbsolutePath) {
+                    fullSchemaOutAbsolutePaths.set(segmentName, fullSchemaOutAbsolutePath);
+                }
+            });
+        }
+    }));
     if (emitFullSchema) {
         const fullSchemaOutAbsolutePath = emitFullSchema
             ? path.resolve(clientOutDirAbsolutePath, emitFullSchema === 'string' ? emitFullSchema : DEFAULT_FULL_SCHEMA_FILE_NAME)
             : null;
         if (fullSchemaOutAbsolutePath) {
-            schemaPaths.push(fullSchemaOutAbsolutePath);
+            fullSchemaOutAbsolutePaths.set(null, 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));
+    if (fullSchemaOutAbsolutePaths.size) {
+        await Promise.all(Array.from(fullSchemaOutAbsolutePaths.entries()).map(async ([segmentName, outPath]) => {
+            const schema = segmentName ? pickSegmentFullSchema(fullSchema, segmentName) : fullSchema;
+            await fs.mkdir(path.dirname(outPath), { recursive: true });
+            await fs.writeFile(outPath, JSON.stringify(schema, null, 2));
         }));
-        log.info(`Full schema has been written to ${schemaPaths.map((s) => `"${s}"`).join(', ')}`);
+        log.info(`Full schema has been written to ${Array.from(fullSchemaOutAbsolutePaths)
+            .map((s) => `"${s}"`)
+            .join(', ')}`);
+    }
+    if (written) {
+        log.info(`Client generated from template${usedTemplateNames.size !== 1 ? 's' : ''} ${chalkHighlightThing(Array.from(usedTemplateNames)
+            .map((s) => `"${s}"`)
+            .join(', '))} in ${Date.now() - now}ms`);
     }
-    if (usedTemplateNames.length === 0) {
+    else {
         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.mjs

@@ -11,6 +11,8 @@ export default async function getConfig({ clientOutDir, configPath, cwd, }) {
     const defaultClientTemplates = ['module', 'main'];
     const config = {
         emitConfig: [],
+        emitFullClient: 'VOVK_EMIT_FULL_CLIENT' in env ? !!env.VOVK_EMIT_FULL_CLIENT : (conf.emitFullClient ?? true),
+        emitSegmentClient: 'VOVK_EMIT_SEGMENT_CLIENT' in env ? !!env.VOVK_EMIT_SEGMENT_CLIENT : (conf.emitSegmentClient ?? false),
         modulesDir: env.VOVK_MODULES_DIR ?? conf.modulesDir ?? './' + [srcRoot, 'modules'].filter(Boolean).join('/'),
         imports: {
             fetcher: typeof fetcherImport === 'string' ? [fetcherImport] : fetcherImport,

package/dist/getProjectInfo/index.d.mts

@@ -1,3 +1,4 @@
+import type { ClientImports } from '../generate/index.mjs';
 export type ProjectInfo = Awaited<ReturnType<typeof getProjectInfo>>;
 export default function getProjectInfo({ port: givenPort, clientOutDir, configPath, cwd, }?: {
     port?: number;
@@ -12,14 +13,12 @@ export default function getProjectInfo({ port: givenPort, clientOutDir, configPa
     srcRoot: string;
     config: import("vovk").VovkStrictConfig;
     clientImports: {
-        fetcher: string;
-        createRPC: string;
-        validateOnClient: string | null;
-        module: {
-            fetcher: string;
-            createRPC: string;
-            validateOnClient: string | null;
+        fullClient: ClientImports & {
+            module: ClientImports;
         };
+        schemaClient: Record<string, ClientImports & {
+            module: ClientImports;
+        }>;
     };
     log: {
         info: (msg: string) => void;
@@ -28,4 +27,5 @@ export default function getProjectInfo({ port: givenPort, clientOutDir, configPa
         debug: (msg: string) => void;
         raw: import("loglevel").RootLogger;
     };
+    segments: import("../locateSegments.mjs").Segment[];
 }>;

package/dist/getProjectInfo/index.mjs

@@ -1,6 +1,8 @@
 import path from 'node:path';
 import getConfig from './getConfig.mjs';
 import getLogger from '../utils/getLogger.mjs';
+import locateSegments from '../locateSegments.mjs';
+import { ROOT_SEGMENT_SCHEMA_NAME } from '../dev/writeOneSegmentSchemaFile.mjs';
 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
@@ -19,18 +21,40 @@ export default async function getProjectInfo({ port: givenPort, clientOutDir, co
     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 getImportPath = (p, s = '') => p.startsWith('.') ? path.relative(path.join(config.clientOutDir, s), p) : p;
+    const apiDirAbsolutePath = path.join(cwd, apiDir);
+    const segments = await locateSegments({ dir: apiDirAbsolutePath, config });
+    // TODO Refactor
     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,
+        fullClient: {
+            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,
+            },
         },
+        schemaClient: Object.fromEntries(segments.map((segment) => [
+            segment.segmentName,
+            {
+                fetcher: getImportPath(config.imports.fetcher[0], segment.segmentName || ROOT_SEGMENT_SCHEMA_NAME),
+                createRPC: getImportPath(config.imports.createRPC[0], segment.segmentName || ROOT_SEGMENT_SCHEMA_NAME),
+                validateOnClient: config.imports.validateOnClient
+                    ? getImportPath(config.imports.validateOnClient[0], segment.segmentName || ROOT_SEGMENT_SCHEMA_NAME)
+                    : null,
+                module: {
+                    fetcher: getImportPath(config.imports.fetcher[1] ?? config.imports.fetcher[0], segment.segmentName || ROOT_SEGMENT_SCHEMA_NAME),
+                    createRPC: getImportPath(config.imports.createRPC[1] ?? config.imports.createRPC[0], segment.segmentName || ROOT_SEGMENT_SCHEMA_NAME),
+                    validateOnClient: config.imports.validateOnClient
+                        ? getImportPath(config.imports.validateOnClient[1] ?? config.imports.validateOnClient[0], segment.segmentName || ROOT_SEGMENT_SCHEMA_NAME)
+                        : null,
+                },
+            },
+        ])),
     };
     return {
         cwd,
@@ -41,5 +65,6 @@ export default async function getProjectInfo({ port: givenPort, clientOutDir, co
         config,
         clientImports,
         log,
+        segments,
     };
 }

package/dist/index.mjs

@@ -7,7 +7,6 @@ import concurrently from 'concurrently';
 import getAvailablePort from './utils/getAvailablePort.mjs';
 import getProjectInfo from './getProjectInfo/index.mjs';
 import generate from './generate/index.mjs';
-import locateSegments from './locateSegments.mjs';
 import { VovkDev } from './dev/index.mjs';
 import newComponents from './new/index.mjs';
 import initProgram from './initProgram.mjs';
@@ -81,13 +80,11 @@ program
     .action(async (options) => {
     const { clientOutDir, templates, prettify, emitFullSchema, config: configPath } = options;
     const projectInfo = await getProjectInfo({ clientOutDir, configPath });
-    const { cwd, config, apiDir } = projectInfo;
-    const segments = await locateSegments({ dir: apiDir, config });
+    const { cwd, config } = projectInfo;
     const schemaOutAbsolutePath = path.join(cwd, config.schemaOutDir);
     const fullSchema = await getFullSchemaFromJSON(schemaOutAbsolutePath, projectInfo);
     await generate({
         projectInfo,
-        segments,
         fullSchema,
         templates,
         prettify,

package/dist/locateSegments.mjs

@@ -1,7 +1,6 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import getFileSystemEntryType from './utils/getFileSystemEntryType.mjs';
-// config: null is used for testing
 export default async function locateSegments({ dir, rootDir, config, }) {
     let results = [];
     rootDir = rootDir ?? dir;
@@ -19,7 +18,7 @@ export default async function locateSegments({ dir, rootDir, config, }) {
                 if (await getFileSystemEntryType(routeFilePath)) {
                     // Calculate the basePath relative to the root directory
                     const segmentName = path.relative(rootDir, dir).replace(/\\/g, '/'); // windows fix
-                    const segmentImportPath = path.relative(config?.clientOutDir ?? '.__', routeFilePath);
+                    const segmentImportPath = path.relative(config?.clientOutDir ?? '.__error', routeFilePath);
                     results.push({ routeFilePath, segmentName, segmentImportPath });
                 }
             }

package/dist/utils/pickSegmentFullSchema.d.mts

@@ -0,0 +1,2 @@
+import type { VovkFullSchema } from 'vovk';
+export default function pickSegmentFullSchema(fullSchema: VovkFullSchema, segmentName: string): VovkFullSchema;

package/dist/utils/pickSegmentFullSchema.mjs

@@ -0,0 +1,8 @@
+export default function pickSegmentFullSchema(fullSchema, segmentName) {
+    return {
+        config: fullSchema.config,
+        segments: {
+            [segmentName]: fullSchema.segments[segmentName],
+        },
+    };
+}

package/dist/utils/removeUnlistedDirectories.d.mts

@@ -0,0 +1,10 @@
+/**
+ * Removes all directories in a folder that aren't in the provided allowlist
+ * Supports nested directory paths like 'foo/bar/baz'
+ *
+ * @param folderPath - The path to the folder to process
+ * @param allowedDirs - Array of relative directory paths to keep
+ * @returns Promise that resolves when all operations are complete
+ */
+declare function removeUnlistedDirectories(folderPath: string, allowedDirs: string[]): Promise<void>;
+export default removeUnlistedDirectories;

package/dist/utils/removeUnlistedDirectories.mjs

@@ -0,0 +1,54 @@
+import fs from 'fs/promises';
+import path from 'path';
+/**
+ * Removes all directories in a folder that aren't in the provided allowlist
+ * Supports nested directory paths like 'foo/bar/baz'
+ *
+ * @param folderPath - The path to the folder to process
+ * @param allowedDirs - Array of relative directory paths to keep
+ * @returns Promise that resolves when all operations are complete
+ */
+async function removeUnlistedDirectories(folderPath, allowedDirs) {
+    // Normalize all allowed paths to use the system-specific separator
+    const normalizedAllowedDirs = allowedDirs.map((dir) => dir.split('/').join(path.sep));
+    // Process the directory tree recursively
+    await processDirectory(folderPath, '', normalizedAllowedDirs);
+}
+/**
+ * Recursively processes directories to determine which should be kept or removed
+ *
+ * @param basePath - The absolute base path being processed
+ * @param relativePath - The current relative path from the base
+ * @param allowedDirs - Normalized list of allowed directory paths
+ */
+async function processDirectory(basePath, relativePath, allowedDirs) {
+    const currentDirPath = path.join(basePath, relativePath);
+    // Read all entries in the current directory
+    const entries = await fs.readdir(currentDirPath, { withFileTypes: true });
+    // Process only directories
+    const dirEntries = entries.filter((entry) => entry.isDirectory());
+    // Check each directory
+    for (const dir of dirEntries) {
+        // Calculate the new relative path
+        const newRelativePath = relativePath ? path.join(relativePath, dir.name) : dir.name;
+        // Check if this directory or any of its subdirectories should be kept
+        const shouldKeep = allowedDirs.some((allowedDir) => {
+            // Direct match
+            if (allowedDir === newRelativePath)
+                return true;
+            // Check if it's a parent path of an allowed directory
+            // e.g. "foo" is a parent of "foo/bar/baz"
+            return allowedDir.startsWith(newRelativePath + path.sep);
+        });
+        if (shouldKeep) {
+            // Recursively process this directory's contents
+            await processDirectory(basePath, newRelativePath, allowedDirs);
+        }
+        else {
+            // Remove this directory since it's not in the allowed list
+            const fullPath = path.join(basePath, newRelativePath);
+            await fs.rm(fullPath, { recursive: true, force: true });
+        }
+    }
+}
+export default removeUnlistedDirectories;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vovk-cli",
-  "version": "0.0.1-draft.130",
+  "version": "0.0.1-draft.131",
   "bin": {
     "vovk": "./dist/index.mjs"
   },
@@ -35,7 +35,7 @@
   },
   "homepage": "https://vovk.dev",
   "peerDependencies": {
-    "vovk": "^3.0.0-draft.109"
+    "vovk": "^3.0.0-draft.110"
   },
   "optionalDependencies": {
     "vovk-python-client": "*"