vovk-cli 0.0.1-draft.143 → 0.0.1-draft.144

package/client-templates/{fullSchema → fullSchemaCjs}/fullSchema.d.cts.ejs

@@ -1,5 +1,5 @@
 <%- `// auto-generated ${new Date().toISOString()}\n/* eslint-disable */` %>
-import { VovkStrictConfig, VovkSegmentSchema } from 'vovk';
+import type { VovkStrictConfig, VovkSegmentSchema } from 'vovk';
 
 export const fullSchema: {
     config: Partial<VovkStrictConfig>;

package/client-templates/fullSchemaJson/full-schema.json.ejs

@@ -0,0 +1 @@
+<%- JSON.stringify(t.fullSchema, null, 2) %>

package/client-templates/fullSchemaTs/fullSchema.ts.ejs

@@ -0,0 +1,18 @@
+<%- `// auto-generated ${new Date().toISOString()}\n/* eslint-disable */` %>
+import type { VovkStrictConfig, VovkSegmentSchema } from 'vovk';
+import config from './<%= t.schemaOutDir %>/config.json';
+
+<% Object.values(t.fullSchema.segments).forEach((segment, i) => { if(Object.keys(segment.controllers).length) { %>
+  import segment<%= i %> from './<%= t.schemaOutDir %>/<%= t.SEGMENTS_SCHEMA_DIR_NAME %>/<%= segment.segmentName || t.ROOT_SEGMENT_SCHEMA_NAME %>.json';
+<% }}) %>
+
+const segments = {
+  <% Object.values(t.fullSchema.segments).forEach((segment, i) => { %>
+    '<%= segment.segmentName %>': segment<%= i %>,
+  <% }) %>
+};
+
+export const fullSchema = {
+  config,
+  segments,
+};

package/client-templates/package/package.json.ejs

@@ -0,0 +1 @@
+<%- JSON.stringify(t.package, null, 2) %>

package/client-templates/ts/index.ts.ejs

@@ -2,7 +2,7 @@
 import type { VovkClientFetcher } from 'vovk';
 import { fetcher } from '<%= t.imports.fetcher %>';
 import { createRPC } from '<%= t.imports.createRPC %>';
-import { fullSchema } from './fullSchema.cjs';
+import { fullSchema } from './fullSchema';
 <% Object.values(t.fullSchema.segments).forEach((segment, i) => { if(Object.keys(segment.controllers).length) { %>
 import type { Controllers as Controllers<%= i %> } from "<%= t.segmentMeta[segment.segmentName].segmentImportPath %>";
 <% }}) %>

package/dist/dev/index.mjs

@@ -50,7 +50,6 @@ export class VovkDev {
                         {
                             routeFilePath: filePath,
                             segmentName,
-                            segmentImportPath: path.relative(config.clientOutDir, filePath), // TODO DRY locateSegments
                         },
                     ];
                 log.info(`${capitalize(formatLoggedSegmentName(segmentName))} has been added`);

package/dist/generate/ensureClient.d.mts

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

package/dist/generate/ensureClient.mjs

@@ -1,69 +1,22 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import getClientTemplates, { BuiltInTemplateName } from './getClientTemplates.mjs';
-import chalkHighlightThing from '../utils/chalkHighlightThing.mjs';
-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);
+import generate from './index.mjs';
+const getEmptySegmentRecordSchema = (segments) => {
+    const result = {};
+    for (const { segmentName } of segments) {
+        result[segmentName] = {
+            segmentName,
+            emitSchema: false,
+            controllers: {},
+        };
     }
-}
-export default async function ensureClient({ config, cwd, log, segments }) {
-    const now = Date.now();
-    const { clientOutDirAbsolutePath, templateFiles } = await getClientTemplates({
-        config,
-        cwd,
-        generateFrom: config.generateFrom,
-        log,
+    return result;
+};
+export default async function ensureClient(projectInfo) {
+    return generate({
+        isEnsuringClient: true,
+        projectInfo,
+        fullSchema: {
+            config: {},
+            segments: getEmptySegmentRecordSchema(projectInfo.segments),
+        },
     });
-    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`;
-    await Promise.all(templateFiles.map(async (clientTemplate) => {
-        const { templatePath, templateName, outDir } = clientTemplate;
-        if (!templatePath)
-            return;
-        const outPath = path.join(outDir, path.basename(templatePath).replace('.ejs', ''));
-        if (config.generateFullClient) {
-            await writeOnePlaceholder({
-                outPath,
-                defaultText,
-                templateName,
-                usedTemplateNames,
-            });
-        }
-        if (config.generateSegmentClient) {
-            // 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`);
-    }
-    return { written: !!usedTemplateNames.size };
 }

package/dist/generate/getClientTemplateFiles.d.mts

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

package/dist/generate/getClientTemplateFiles.mjs

@@ -0,0 +1,61 @@
+import path from 'node:path';
+import { glob } from 'glob';
+import resolveAbsoluteModulePath from '../utils/resolveAbsoluteModulePath.mjs';
+import getFileSystemEntryType, { FileSystemEntryType } from '../utils/getFileSystemEntryType.mjs';
+export default async function getClientTemplateFiles({ config, cwd, log, configKey, cliOptions, }) {
+    const usedTemplateDefs = {};
+    const fromTemplates = configKey === 'fullClient'
+        ? (cliOptions?.fullClientFrom ?? config.fullClient.fromTemplates)
+        : (cliOptions?.segmentedClientFrom ?? config.segmentedClient.fromTemplates);
+    const outDir = configKey === 'fullClient'
+        ? (cliOptions?.fullClientOut ?? config.fullClient.outDir)
+        : (cliOptions?.segmentedClientOut ?? config.segmentedClient.outDir);
+    for (const templateName of fromTemplates) {
+        if (!(templateName in config.clientTemplateDefs)) {
+            throw new Error(`Unknown template name: ${templateName}`);
+        }
+        usedTemplateDefs[templateName] = config.clientTemplateDefs[templateName];
+    }
+    const templateFiles = [];
+    const entries = Object.entries(usedTemplateDefs);
+    for (let i = 0; i < entries.length; i++) {
+        const [templateName, templateDef, forceOutCwdRelativeDir] = entries[i];
+        const templateAbsolutePath = resolveAbsoluteModulePath(templateDef.templatePath, cwd);
+        const entryType = await getFileSystemEntryType(templateDef.templatePath);
+        if (!entryType)
+            throw new Error(`Unable to locate template path ${templateDef.templatePath}`);
+        const defOutDir = configKey === 'fullClient' ? templateDef.fullClient?.outDir : templateDef.segmentedClient?.outDir;
+        let files;
+        if (entryType === FileSystemEntryType.FILE) {
+            files = [templateAbsolutePath];
+        }
+        else {
+            const globPath = path.join(templateAbsolutePath, '**/*.*');
+            files = await glob(globPath);
+        }
+        if (files.length === 0) {
+            log.error(`Template "${templateAbsolutePath}" not found`);
+            continue;
+        }
+        const outCwdRelativeDir = forceOutCwdRelativeDir ?? defOutDir ?? outDir;
+        for (const filePath of files) {
+            templateFiles.push({
+                templateName,
+                templateFilePath: filePath,
+                relativeDir: path.relative(templateAbsolutePath, path.dirname(filePath)),
+                outCwdRelativeDir,
+                templateDef,
+            });
+        }
+        if (templateDef.requires) {
+            for (const [tName, reqRelativeDir] of Object.entries(templateDef.requires)) {
+                const def = config.clientTemplateDefs[tName];
+                if (!def) {
+                    throw new Error(`Template "${tName}" required by "${templateName}" not found`);
+                }
+                entries.push([tName, def, path.join(outCwdRelativeDir, reqRelativeDir)]);
+            }
+        }
+    }
+    return templateFiles;
+}

package/dist/generate/getTemplateClientImports.d.mts

@@ -0,0 +1,19 @@
+import type { VovkStrictConfig } from 'vovk';
+import type { Segment } from '../locateSegments.mjs';
+export type ClientImports = {
+    fetcher: string;
+    validateOnClient: string | null;
+    createRPC: string;
+};
+export default function getTemplateClientImports({ config, segments, outCwdRelativeDir, }: {
+    config: VovkStrictConfig;
+    segments: Segment[];
+    outCwdRelativeDir: string;
+}): {
+    fullClient: ClientImports & {
+        module: ClientImports;
+    };
+    segmentedClient: Record<string, ClientImports & {
+        module: ClientImports;
+    }>;
+};

package/dist/generate/getTemplateClientImports.mjs

@@ -0,0 +1,38 @@
+import path from 'node:path';
+import { ROOT_SEGMENT_SCHEMA_NAME } from '../dev/writeOneSegmentSchemaFile.mjs';
+export default function getTemplateClientImports({ config, segments, outCwdRelativeDir, }) {
+    const { imports } = config;
+    const getImportPath = (p, s = '') => p.startsWith('.') ? path.relative(path.join(outCwdRelativeDir, s), p) : p;
+    const clientImports = {
+        fullClient: {
+            fetcher: getImportPath(imports.fetcher[0]),
+            createRPC: getImportPath(imports.createRPC[0]),
+            validateOnClient: imports.validateOnClient ? getImportPath(imports.validateOnClient[0]) : null,
+            module: {
+                fetcher: getImportPath(imports.fetcher[1] ?? imports.fetcher[0]),
+                createRPC: getImportPath(imports.createRPC[1] ?? imports.createRPC[0]),
+                validateOnClient: imports.validateOnClient
+                    ? getImportPath(imports.validateOnClient[1] ?? imports.validateOnClient[0])
+                    : null,
+            },
+        },
+        segmentedClient: Object.fromEntries(segments.map((segment) => [
+            segment.segmentName,
+            {
+                fetcher: getImportPath(imports.fetcher[0], segment.segmentName || ROOT_SEGMENT_SCHEMA_NAME),
+                createRPC: getImportPath(imports.createRPC[0], segment.segmentName || ROOT_SEGMENT_SCHEMA_NAME),
+                validateOnClient: imports.validateOnClient
+                    ? getImportPath(imports.validateOnClient[0], segment.segmentName || ROOT_SEGMENT_SCHEMA_NAME)
+                    : null,
+                module: {
+                    fetcher: getImportPath(imports.fetcher[1] ?? imports.fetcher[0], segment.segmentName || ROOT_SEGMENT_SCHEMA_NAME),
+                    createRPC: getImportPath(imports.createRPC[1] ?? imports.createRPC[0], segment.segmentName || ROOT_SEGMENT_SCHEMA_NAME),
+                    validateOnClient: imports.validateOnClient
+                        ? getImportPath(imports.validateOnClient[1] ?? imports.validateOnClient[0], segment.segmentName || ROOT_SEGMENT_SCHEMA_NAME)
+                        : null,
+                },
+            },
+        ])),
+    };
+    return clientImports;
+}

package/dist/generate/index.d.mts

@@ -1,13 +1,10 @@
 import type { VovkFullSchema } from 'vovk';
 import type { ProjectInfo } from '../getProjectInfo/index.mjs';
 import type { GenerateOptions } from '../types.mjs';
-export type ClientImports = {
-    fetcher: string;
-    validateOnClient: string | null;
-    createRPC: string;
-};
-export default function generate({ projectInfo, forceNothingWrittenLog, templates, prettify: prettifyClient, fullSchema, fullSchemaJson, }: {
+export default function generate({ isEnsuringClient, projectInfo, forceNothingWrittenLog, fullSchema, cliOptions, }: {
+    isEnsuringClient?: boolean;
     projectInfo: ProjectInfo;
     forceNothingWrittenLog?: boolean;
     fullSchema: VovkFullSchema;
-} & Pick<GenerateOptions, 'templates' | 'prettify' | 'fullSchemaJson'>): Promise<void>;
+    cliOptions?: GenerateOptions;
+}): Promise<void>;

package/dist/generate/index.mjs

@@ -1,80 +1,54 @@
 import path from 'node:path';
 import fs from 'node:fs/promises';
-import ejs from 'ejs';
 import matter from 'gray-matter';
 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 getClientTemplateFiles from './getClientTemplateFiles.mjs';
 import chalkHighlightThing from '../utils/chalkHighlightThing.mjs';
-import { ROOT_SEGMENT_SCHEMA_NAME, SEGMENTS_SCHEMA_DIR_NAME } from '../dev/writeOneSegmentSchemaFile.mjs';
 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;
-    if (!templatePath) {
-        throw new Error(`Template path is not defined for ${clientTemplate.templateName} but used at writeOneClientFile`);
+import getTemplateClientImports from './getTemplateClientImports.mjs';
+import mergePackages from './mergePackages.mjs';
+import writeOneClientFile from './writeOneClientFile.mjs';
+const getIncludedSegmentNames = (config, segments, configKey) => {
+    if ('includeSegments' in config[configKey] &&
+        'excludeSegments' in config[configKey]) {
+        throw new Error(`Both includeSegments and excludeSegments are set in ${configKey} config. Please use only one of them.`);
     }
-    const outPath = path.join(outDir, typeof segmentName === 'string' ? segmentName || ROOT_SEGMENT_SCHEMA_NAME : '', path.basename(templatePath).replace('.ejs', ''));
-    // 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: typeof segmentName === 'string'
-            ? path.relative(path.join(outDir, segmentName || ROOT_SEGMENT_SCHEMA_NAME), config.schemaOutDir)
-            : path.relative(outDir, config.schemaOutDir),
-        segmentMeta: Object.fromEntries(segments.map(({ segmentName: sName, routeFilePath, segmentImportPath }) => [
-            sName,
-            {
-                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,
+    const includedSegmentNames = 'includeSegments' in config[configKey] &&
+        Array.isArray(config[configKey].includeSegments)
+        ? config[configKey].includeSegments.map((segmentName) => {
+            const segment = segments.find(({ segmentName: sName }) => sName === segmentName);
+            if (!segment) {
+                throw new Error(`Segment "${segmentName}" not found in the config for ${configKey}`);
+            }
+            return segment.segmentName;
         })
-        : templateContent;
-    // Optionally prettify
-    if (prettifyClient || config.prettifyClient) {
-        rendered = await prettify(rendered, outPath);
+        : 'excludeSegments' in config[configKey] &&
+            Array.isArray(config[configKey].excludeSegments)
+            ? segments
+                .filter(({ segmentName }) => !config[configKey].excludeSegments?.includes(segmentName))
+                .map(({ segmentName }) => segmentName)
+            : segments.map(({ segmentName }) => segmentName);
+    return includedSegmentNames;
+};
+function logClientGenerationResults({ results, log, isEnsuringClient = false, forceNothingWrittenLog = false, clientType = 'Full', startTime, }) {
+    const writtenResults = results.filter(({ written }) => written);
+    const duration = Date.now() - startTime;
+    if (writtenResults.length) {
+        const groupedByDir = _.groupBy(writtenResults, ({ outAbsoluteDir }) => outAbsoluteDir);
+        for (const [outAbsoluteDir, dirResults] of Object.entries(groupedByDir)) {
+            const templateNames = _.uniq(dirResults.map(({ templateName }) => templateName));
+            log.info(`${clientType} client${isEnsuringClient ? ' placeholder' : ''} is generated to ${chalkHighlightThing(outAbsoluteDir)} from template${templateNames.length !== 1 ? 's' : ''} ${chalkHighlightThing(templateNames.map((s) => `"${s}"`).join(', '))} in ${duration}ms`);
+        }
     }
-    // Read existing file content to compare
-    const existingContent = await fs.readFile(outPath, 'utf-8').catch(() => null);
-    // Determine if we need to rewrite the file, ignore 1st line
-    const needsWriting = !existingContent ||
-        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);
+    else if (!isEnsuringClient) {
+        const logOrDebug = forceNothingWrittenLog ? log.info : log.debug;
+        logOrDebug(`${clientType} client is up to date and doesn't need to be regenerated (${duration}ms)`);
     }
-    return { written: needsWriting };
 }
-export default async function generate({ projectInfo, forceNothingWrittenLog, templates, prettify: prettifyClient = false, fullSchema, fullSchemaJson, }) {
-    const now = Date.now();
-    const generateFrom = templates ?? projectInfo.config.generateFrom;
-    const noClient = templates?.[0] === 'none';
-    const { config, cwd, log, clientImports, segments } = projectInfo;
-    const { clientOutDirAbsolutePath, templateFiles } = await getClientTemplates({ config, cwd, generateFrom, log });
+export default async function generate({ isEnsuringClient = false, projectInfo, forceNothingWrittenLog, fullSchema, cliOptions, }) {
+    const { config, cwd, log, segments } = projectInfo;
     // 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];
@@ -85,105 +59,129 @@ export default async function generate({ projectInfo, forceNothingWrittenLog, te
         if (!schema.emitSchema)
             continue;
     }
-    let written = false;
-    const fullSchemaOutAbsolutePaths = new Map();
-    const usedTemplateNames = new Set();
-    // Process each template in parallel
-    await Promise.all(templateFiles.map(async (clientTemplate) => {
-        const { templatePath, templateName, outDir, fullSchemaJSONFileName } = clientTemplate;
-        if (!noClient && templatePath) {
-            // Read the EJS template
-            const templateContent = await fs.readFile(templatePath, 'utf-8');
-            const matterResult = templatePath.endsWith('.ejs')
+    if (config.fullClient.enabled) {
+        const now = Date.now();
+        const segmentNames = getIncludedSegmentNames(config, segments, 'fullClient');
+        const fullClientTemplateFiles = await getClientTemplateFiles({
+            config,
+            cwd,
+            log,
+            cliOptions,
+            configKey: 'fullClient',
+        });
+        const fullClientResults = await Promise.all(fullClientTemplateFiles.map(async (clientTemplateFile) => {
+            const { templateFilePath, templateName, templateDef, outCwdRelativeDir } = clientTemplateFile;
+            const templateContent = await fs.readFile(templateFilePath, 'utf-8');
+            const matterResult = templateFilePath.endsWith('.ejs')
                 ? matter(templateContent)
                 : { data: { imports: [] }, content: templateContent };
-            if (config.generateFullClient) {
-                const { written: isWritten } = await writeOneClientFile({
+            const clientImports = await getTemplateClientImports({
+                config,
+                segments,
+                outCwdRelativeDir,
+            });
+            const packageJson = await mergePackages({
+                cwd,
+                config,
+                packages: [config.fullClient.package, templateDef.fullClient?.package],
+            });
+            const { written } = await writeOneClientFile({
+                cwd,
+                projectInfo,
+                clientTemplateFile,
+                fullSchema: pickSegmentFullSchema(fullSchema, segmentNames),
+                prettifyClient: config.prettifyClient,
+                segmentName: null,
+                imports: clientImports.fullClient,
+                templateContent,
+                matterResult,
+                package: packageJson,
+                isEnsuringClient,
+                outCwdRelativeDir,
+                origin: config.origin ?? templateDef?.origin ?? null,
+            });
+            const outAbsoluteDir = path.join(cwd, outCwdRelativeDir);
+            return {
+                written,
+                templateName,
+                outAbsoluteDir,
+            };
+        }));
+        logClientGenerationResults({
+            results: fullClientResults,
+            log,
+            isEnsuringClient,
+            forceNothingWrittenLog,
+            clientType: 'Full',
+            startTime: now,
+        });
+    }
+    if (config.segmentedClient.enabled) {
+        const now = Date.now();
+        const segmentNames = getIncludedSegmentNames(config, segments, 'segmentedClient');
+        const segmentedClientTemplateFiles = await getClientTemplateFiles({
+            config,
+            cwd,
+            log,
+            cliOptions,
+            configKey: 'segmentedClient',
+        });
+        const segmentedClientResults = await Promise.all(segmentedClientTemplateFiles.map(async (clientTemplateFile) => {
+            const { templateFilePath, templateName, templateDef, outCwdRelativeDir } = clientTemplateFile;
+            const templateContent = await fs.readFile(templateFilePath, 'utf-8');
+            const matterResult = templateFilePath.endsWith('.ejs')
+                ? matter(templateContent)
+                : { data: { imports: [] }, content: templateContent };
+            const results = await Promise.all(segmentNames.map(async (segmentName) => {
+                const clientImports = await getTemplateClientImports({
+                    config,
+                    segments,
+                    outCwdRelativeDir,
+                });
+                const packageJson = await mergePackages({
+                    cwd,
+                    config,
+                    packages: [
+                        config.segmentedClient.packages?.[segmentName],
+                        templateDef.segmentedClient?.packages?.[segmentName],
+                    ],
+                });
+                const { written } = await writeOneClientFile({
+                    cwd,
                     projectInfo,
-                    clientTemplate,
-                    fullSchema,
-                    prettifyClient,
-                    segmentName: null,
-                    imports: clientImports.fullClient,
+                    clientTemplateFile,
+                    fullSchema: pickSegmentFullSchema(fullSchema, [segmentName]),
+                    prettifyClient: config.prettifyClient,
+                    segmentName,
+                    imports: clientImports.segmentedClient[segmentName],
                     templateContent,
                     matterResult,
+                    package: packageJson,
+                    isEnsuringClient,
+                    outCwdRelativeDir,
+                    origin: config.origin ?? templateDef?.origin ?? null,
                 });
-                if (isWritten) {
-                    usedTemplateNames.add(templateName);
-                }
-                written ||= isWritten;
-            }
-            // TODO Remove files if generateFullClient is false ???
-            if (config.generateSegmentClient) {
-                // 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));
-            }
-            else {
-                await removeUnlistedDirectories(outDir, []);
-            }
-        }
-        if (config.generateFullClient) {
-            const fullSchemaOutAbsolutePath = fullSchemaJSONFileName ? path.resolve(outDir, fullSchemaJSONFileName) : null;
-            if (fullSchemaOutAbsolutePath) {
-                fullSchemaOutAbsolutePaths.set(null, fullSchemaOutAbsolutePath);
-            }
-        }
-        if (config.generateSegmentClient) {
-            segments.forEach(({ segmentName }) => {
-                const fullSchemaOutAbsolutePath = fullSchemaJSONFileName
-                    ? path.resolve(outDir, segmentName || ROOT_SEGMENT_SCHEMA_NAME, fullSchemaJSONFileName)
-                    : null;
-                if (fullSchemaOutAbsolutePath) {
-                    fullSchemaOutAbsolutePaths.set(segmentName, fullSchemaOutAbsolutePath);
-                }
-            });
-        }
-    }));
-    if (fullSchemaJson) {
-        const fullSchemaOutAbsolutePath = fullSchemaJson
-            ? path.resolve(clientOutDirAbsolutePath, typeof fullSchemaJson === 'string' ? fullSchemaJson : DEFAULT_FULL_SCHEMA_FILE_NAME)
-            : null;
-        if (fullSchemaOutAbsolutePath) {
-            fullSchemaOutAbsolutePaths.set(null, fullSchemaOutAbsolutePath);
-        }
-    }
-    if (fullSchemaOutAbsolutePaths.size) {
-        await Promise.all(Array.from(fullSchemaOutAbsolutePaths.entries()).map(async ([segmentName, outPath]) => {
-            const schema = typeof segmentName === 'string' ? pickSegmentFullSchema(fullSchema, segmentName) : fullSchema;
-            await fs.mkdir(path.dirname(outPath), { recursive: true });
-            await fs.writeFile(outPath, JSON.stringify(schema, null, 2));
+                return {
+                    written,
+                    templateName,
+                };
+            }));
+            const outAbsoluteDir = path.join(cwd, outCwdRelativeDir);
+            // Remove unlisted directories in the output directory
+            await removeUnlistedDirectories(outAbsoluteDir, segmentNames);
+            return {
+                written: results.some(({ written }) => written),
+                templateName,
+                outAbsoluteDir,
+            };
         }));
-        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`);
-    }
-    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)`);
+        logClientGenerationResults({
+            results: segmentedClientResults,
+            log,
+            isEnsuringClient,
+            forceNothingWrittenLog,
+            clientType: 'Segmented',
+            startTime: now,
+        });
     }
 }