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

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' with { type: "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' with { type: "json" };
+<% }}) %>
+
+const segments = {
+  <% Object.values(t.fullSchema.segments).forEach((segment, i) => { %>
+    '<%= segment.segmentName %>': segment<%= i %>,
+  <% }) %>
+};
+
+export const fullSchema = {
+  config,
+  segments,
+};

package/client-templates/main/main.cjs.ejs

@@ -3,12 +3,11 @@ const { fetcher } = require('<%= t.imports.fetcher %>');
 const { createRPC } = require('<%= t.imports.createRPC %>');
 const { fullSchema } = require('./fullSchema.cjs');
 const { validateOnClient = null } = <%- t.imports.validateOnClient ? `require('${t.imports.validateOnClient}')` : '{}'%>;
-const apiRoot = '<%= t.apiRoot %>';
 <% Object.values(t.fullSchema.segments).forEach((segment) => { 
   Object.keys(segment.controllers).forEach((controllerName) => { %>
 exports.<%= controllerName %> = createRPC(
   fullSchema, '<%= segment.segmentName %>', '<%= controllerName %>',
-  { fetcher, validateOnClient, defaultOptions: { apiRoot } }
+  { fetcher, validateOnClient, defaultOptions: { apiRoot: '<%= segment.segmentApiRoot ?? t.apiRoot %>' } }
 );
   <% })
 }) %>

package/client-templates/module/module.mjs.ejs

@@ -7,12 +7,11 @@ import { validateOnClient } from '<%= t.imports.module.validateOnClient %>';
 <% } else { %>
 const validateOnClient = undefined;
 <% } %>
-const apiRoot = '<%= t.apiRoot %>';
 <% Object.values(t.fullSchema.segments).forEach((segment, i) => {
   Object.keys(segment.controllers).forEach((controllerName) => { %>
 export const <%= controllerName %> = createRPC(
   fullSchema, '<%= segment.segmentName %>', '<%= controllerName %>',
-  { fetcher, validateOnClient, defaultOptions: { apiRoot } }
+  { fetcher, validateOnClient, defaultOptions: { apiRoot: '<%= segment.segmentApiRoot ?? t.apiRoot %>' } }
 );
 <% 
   }); 

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.ts';
 <% 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 %>";
 <% }}) %>
@@ -12,12 +12,11 @@ import { validateOnClient } from '<%= t.imports.validateOnClient %>';
 const validateOnClient = undefined;
 <% } %>
 type Options = typeof fetcher extends VovkClientFetcher<infer U> ? U : never;
-const apiRoot = '<%= t.apiRoot %>';
 <% Object.values(t.fullSchema.segments).forEach((segment, i) => { %>
   <% Object.keys(segment.controllers).forEach((controllerName) => { %>
 export const <%= controllerName %> = createRPC<Controllers<%= i %>["<%= controllerName %>"], Options>(
   fullSchema, '<%= segment.segmentName %>', '<%= controllerName %>',
-  { fetcher, validateOnClient, defaultOptions: { apiRoot } }
+  { fetcher, validateOnClient, defaultOptions: { apiRoot: '<%= segment.segmentApiRoot ?? t.apiRoot %>' } }
 );
   <% }) %>
 <% }) %>

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>;