vovk-cli 0.0.1-draft.96 → 0.0.1-draft.98

package/dist/dev/ensureSchemaFiles.mjs

@@ -1,7 +1,7 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import debounce from 'lodash/debounce.js';
-import writeOneSchemaFile, { ROOT_SEGMENT_SCHEMA_NAME } from './writeOneSchemaFile.mjs';
+import writeOneSchemaFile, { JSON_DIR_NAME, ROOT_SEGMENT_SCHEMA_NAME } from './writeOneSchemaFile.mjs';
 import formatLoggedSegmentName from '../utils/formatLoggedSegmentName.mjs';
 /**
  * Ensure that the schema files are created to avoid any import errors.
@@ -9,10 +9,11 @@ import formatLoggedSegmentName from '../utils/formatLoggedSegmentName.mjs';
 export default async function ensureSchemaFiles(projectInfo, schemaOutAbsolutePath, segmentNames) {
     const now = Date.now();
     let hasChanged = false;
+    const schemaJsonOutAbsolutePath = path.join(schemaOutAbsolutePath, JSON_DIR_NAME);
     const jsContent = `// auto-generated ${new Date().toISOString()}
 ${segmentNames
         .map((segmentName) => {
-        return `module.exports['${segmentName}'] = require('./${segmentName || ROOT_SEGMENT_SCHEMA_NAME}.json');`;
+        return `module.exports['${segmentName}'] = require('./${JSON_DIR_NAME}/${segmentName || ROOT_SEGMENT_SCHEMA_NAME}.json');`;
     })
         .join('\n')}`;
     const dTsContent = `// auto-generated ${new Date().toISOString()}
@@ -23,7 +24,7 @@ ${segmentNames.map((segmentName) => `  '${segmentName}': VovkSchema;`).join('\n'
 export default fullSchema;`;
     const tsContent = `// auto-generated ${new Date().toISOString()}
 import type { VovkSchema } from 'vovk';
-${segmentNames.map((segmentName, i) => `import segment${i} from './${segmentName || ROOT_SEGMENT_SCHEMA_NAME}.json';`).join('\n')}
+${segmentNames.map((segmentName, i) => `import segment${i} from './${JSON_DIR_NAME}/${segmentName || ROOT_SEGMENT_SCHEMA_NAME}.json';`).join('\n')}
 const fullSchema = {
 ${segmentNames.map((segmentName, i) => `  '${segmentName}': segment${i} as VovkSchema,`).join('\n')}
 };
@@ -48,7 +49,7 @@ export default fullSchema;`;
     // Create JSON files (if not exist) with name [segmentName].json (where segmentName can include /, which means the folder structure can be nested)
     await Promise.all(segmentNames.map(async (segmentName) => {
         const { isCreated } = await writeOneSchemaFile({
-            schemaOutAbsolutePath,
+            schemaJsonOutAbsolutePath,
             schema: {
                 emitSchema: false,
                 segmentName,
@@ -90,7 +91,7 @@ export default fullSchema;`;
         }));
     }
     // Start the recursive deletion from the root directory
-    await deleteUnnecessaryJsonFiles(schemaOutAbsolutePath);
+    await deleteUnnecessaryJsonFiles(schemaJsonOutAbsolutePath);
     if (hasChanged)
         projectInfo?.log.info(`Created empty schema files in ${Date.now() - now}ms`);
 }

package/dist/dev/index.mjs

@@ -7,7 +7,7 @@ import capitalize from 'lodash/capitalize.js';
 import debounce from 'lodash/debounce.js';
 import once from 'lodash/once.js';
 import { debouncedEnsureSchemaFiles } from './ensureSchemaFiles.mjs';
-import writeOneSchemaFile from './writeOneSchemaFile.mjs';
+import writeOneSchemaFile, { JSON_DIR_NAME } from './writeOneSchemaFile.mjs';
 import logDiffResult from './logDiffResult.mjs';
 import ensureClient from '../generate/ensureClient.mjs';
 import getProjectInfo from '../getProjectInfo/index.mjs';
@@ -260,7 +260,7 @@ export class VovkDev {
             return;
         }
         log.debug(`Handling received schema from ${formatLoggedSegmentName(schema.segmentName)}`);
-        const schemaOutAbsolutePath = path.join(cwd, config.schemaOutDir);
+        const schemaJsonOutAbsolutePath = path.join(cwd, config.schemaOutDir, JSON_DIR_NAME);
         const segment = this.#segments.find((s) => s.segmentName === schema.segmentName);
         if (!segment) {
             log.warn(`Segment "${schema.segmentName}" not found`);
@@ -270,7 +270,7 @@ export class VovkDev {
         if (schema.emitSchema) {
             const now = Date.now();
             const { diffResult } = await writeOneSchemaFile({
-                schemaOutAbsolutePath,
+                schemaJsonOutAbsolutePath,
                 schema,
                 skipIfExists: false,
             });

package/dist/dev/writeOneSchemaFile.d.mts

@@ -1,8 +1,9 @@
 import type { VovkSchema } from 'vovk';
 import { type DiffResult } from './diffSchema.mjs';
 export declare const ROOT_SEGMENT_SCHEMA_NAME = "_root";
-export default function writeOneSchemaFile({ schemaOutAbsolutePath, schema, skipIfExists, }: {
-    schemaOutAbsolutePath: string;
+export declare const JSON_DIR_NAME = "json";
+export default function writeOneSchemaFile({ schemaJsonOutAbsolutePath, schema, skipIfExists, }: {
+    schemaJsonOutAbsolutePath: string;
     schema: VovkSchema;
     skipIfExists?: boolean;
 }): Promise<{

package/dist/dev/writeOneSchemaFile.mjs

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

package/dist/generate/ensureClient.mjs

@@ -7,18 +7,18 @@ export default async function ensureClient({ config, cwd, log }) {
     const { clientOutDirAbsolutePath, templateFiles } = getClientTemplates({
         config,
         cwd,
-        templateNames: config.experimental_clientGenerateTemplateNames,
+        generateFrom: config.generateFrom,
     });
     let usedTemplateNames = [];
     const text = `// auto-generated ${new Date().toISOString()}
-// This is a temporary placeholder to avoid errors if client is imported before it's generated.
+// 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);
         if (!existing) {
             await fs.mkdir(clientOutDirAbsolutePath, { recursive: true });
-            await fs.writeFile(outPath, text);
+            await fs.writeFile(outPath, outPath.endsWith('.py') ? text.replace(/\/\//g, '#') : text);
             usedTemplateNames.push(templateName);
         }
     }

package/dist/generate/getClientTemplates.d.mts

@@ -1,13 +1,14 @@
-import { VovkConfig } from '../types.mjs';
+import type { VovkStrictConfig } from '../types.mjs';
 interface ClientTemplate {
     templateName: string;
     templatePath: string;
     outPath: string;
+    fullSchema?: string | boolean;
 }
-export default function getClientTemplates({ config, cwd, templateNames, }: {
-    config: Required<VovkConfig>;
+export default function getClientTemplates({ config, cwd, generateFrom, }: {
+    config: VovkStrictConfig;
     cwd: string;
-    templateNames?: string[];
+    generateFrom?: VovkStrictConfig['generateFrom'];
 }): {
     clientOutDirAbsolutePath: string;
     templateFiles: ClientTemplate[];

package/dist/generate/getClientTemplates.mjs

@@ -1,5 +1,5 @@
 import path from 'node:path';
-export default function getClientTemplates({ config, cwd, templateNames = [], }) {
+export default function getClientTemplates({ config, cwd, generateFrom = [], }) {
     const templatesDir = path.join(import.meta.dirname, '../..', 'client-templates');
     const clientOutDirAbsolutePath = path.resolve(cwd, config.clientOutDir);
     const mapper = (dir) => (name) => ({
@@ -13,16 +13,28 @@ export default function getClientTemplates({ config, cwd, templateNames = [], })
         module: ['module.mjs.ejs', 'module.d.mts.ejs'].map(mapper('module')),
         python: ['__init__.py'].map(mapper('python')),
     };
-    const templateFiles = (templateNames ?? config.experimental_clientGenerateTemplateNames).reduce((acc, template) => {
-        if (template in builtInTemplatesMap) {
-            return [...acc, ...builtInTemplatesMap[template]];
+    const templateFiles = (generateFrom ?? config.generateFrom).reduce((acc, template) => {
+        if (typeof template === 'string') {
+            if (template in builtInTemplatesMap) {
+                return [...acc, ...builtInTemplatesMap[template]];
+            }
+            return [
+                ...acc,
+                {
+                    templateName: template,
+                    templatePath: path.resolve(cwd, template),
+                    outPath: path.join(clientOutDirAbsolutePath, path.basename(template).replace('.ejs', '')),
+                },
+            ];
         }
+        const outDirAbsolutePath = template.outDir ? path.resolve(cwd, template.outDir) : clientOutDirAbsolutePath;
         return [
             ...acc,
             {
-                templateName: template,
-                templatePath: path.resolve(cwd, template),
-                outPath: path.join(clientOutDirAbsolutePath, path.basename(template).replace('.ejs', '')),
+                templateName: template.templateName ?? template.templatePath,
+                templatePath: path.resolve(cwd, template.templatePath),
+                outPath: path.join(outDirAbsolutePath, path.basename(template.templatePath).replace('.ejs', '')),
+                fullSchema: template.fullSchema,
             },
         ];
     }, []);

package/dist/generate/index.mjs

@@ -7,10 +7,10 @@ import getClientTemplates from './getClientTemplates.mjs';
 import chalkHighlightThing from '../utils/chalkHighlightThing.mjs';
 import uniq from 'lodash/uniq.js';
 export default async function generate({ projectInfo, segments, segmentsSchema, forceNothingWrittenLog, templates, prettify: prettifyClient, fullSchema, }) {
-    templates = templates ?? projectInfo.config.experimental_clientGenerateTemplateNames;
+    const generateFrom = templates ?? projectInfo.config.generateFrom;
     const noClient = templates?.[0] === 'none';
     const { config, cwd, log, clientImports, apiRoot } = projectInfo;
-    const { clientOutDirAbsolutePath, templateFiles } = getClientTemplates({ config, cwd, templateNames: templates });
+    const { clientOutDirAbsolutePath, templateFiles } = 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];
@@ -57,14 +57,25 @@ export default async function generate({ projectInfo, segments, segmentsSchema,
             };
         }));
     const usedTemplateNames = uniq(processedTemplates.filter(({ needsWriting }) => needsWriting).map(({ templateName }) => templateName));
-    if (fullSchema || usedTemplateNames.length > 0) {
+    let fullSchemaNames = [];
+    const DEFAULT_NAME = 'full-schema.json';
+    if (fullSchema) {
+        fullSchemaNames.push(typeof fullSchema === 'string' ? fullSchema : DEFAULT_NAME);
+        fullSchemaNames.push(...templateFiles
+            .filter(({ fullSchema }) => fullSchema)
+            .map(({ fullSchema }) => (typeof fullSchema === 'string' ? fullSchema : DEFAULT_NAME)));
+    }
+    fullSchemaNames = uniq(fullSchemaNames);
+    if (fullSchemaNames.length || usedTemplateNames.length > 0) {
         // Make sure the output directory exists
         await fs.mkdir(clientOutDirAbsolutePath, { recursive: true });
     }
-    if (fullSchema) {
-        const fullSchemaOutAbsolutePath = path.resolve(clientOutDirAbsolutePath, typeof fullSchema === 'string' ? fullSchema : 'full-schema.json');
-        await fs.writeFile(fullSchemaOutAbsolutePath, JSON.stringify(segmentsSchema, null, 2));
-        log.info(`Full schema has ben written to ${fullSchemaOutAbsolutePath}`);
+    if (fullSchemaNames.length) {
+        await Promise.all(fullSchemaNames.map(async (name) => {
+            const fullSchemaOutAbsolutePath = path.resolve(clientOutDirAbsolutePath, name);
+            await fs.writeFile(fullSchemaOutAbsolutePath, JSON.stringify(segmentsSchema, null, 2));
+            log.info(`Full schema has ben written to ${fullSchemaOutAbsolutePath}`);
+        }));
     }
     if (usedTemplateNames.length === 0) {
         const logOrDebug = forceNothingWrittenLog ? log.info : log.debug;

package/dist/getProjectInfo/getConfig.mjs

@@ -8,6 +8,7 @@ export default async function getConfig({ clientOutDir, cwd }) {
     const validateOnClientImport = env.VOVK_VALIDATE_ON_CLIENT_PATH ?? conf.validateOnClientImport ?? null;
     const fetcherImport = env.VOVK_FETCHER_PATH ?? conf.fetcherImport ?? 'vovk/dist/client/defaultFetcher.js';
     const createRPCImport = env.VOVK_CREATE_RPC_PATH ?? conf.createRPCImport ?? 'vovk/dist/client/createRPC.js';
+    const defaultClientTemplates = ['ts', 'module', 'main'];
     const config = {
         modulesDir: env.VOVK_MODULES_DIR ?? conf.modulesDir ?? './' + [srcRoot, 'modules'].filter(Boolean).join('/'),
         validateOnClientImport: typeof validateOnClientImport === 'string' ? [validateOnClientImport] : validateOnClientImport,
@@ -21,7 +22,9 @@ export default async function getConfig({ clientOutDir, cwd }) {
         logLevel: env.VOVK_LOG_LEVEL ?? conf.logLevel ?? 'info',
         prettifyClient: (env.VOVK_PRETTIFY_CLIENT ? !!env.VOVK_PRETTIFY_CLIENT : null) ?? conf.prettifyClient ?? false,
         devHttps: (env.VOVK_DEV_HTTPS ? !!env.VOVK_DEV_HTTPS : null) ?? conf.devHttps ?? false,
-        experimental_clientGenerateTemplateNames: conf.experimental_clientGenerateTemplateNames ?? ['ts', 'module', 'main'],
+        generateFrom: typeof conf.generateFrom === 'function'
+            ? conf.generateFrom(defaultClientTemplates)
+            : (conf.generateFrom ?? ['ts', 'module', 'main']),
         templates: {
             service: 'vovk-cli/templates/service.ejs',
             controller: 'vovk-cli/templates/controller.ejs',

package/dist/types.d.mts

@@ -18,6 +18,12 @@ export type VovkEnv = {
     __VOVK_START_WATCHER_IN_STANDALONE_MODE__?: 'true';
     __VOVK_EXIT__?: 'true' | 'false';
 };
+type GenerateFrom = (string | {
+    templatePath: string;
+    outDir?: string;
+    templateName?: string;
+    fullSchema?: string | boolean;
+})[];
 export type VovkConfig = {
     clientOutDir?: string;
     schemaOutDir?: string;
@@ -31,17 +37,18 @@ export type VovkConfig = {
     logLevel?: LogLevelNames;
     prettifyClient?: boolean;
     devHttps?: boolean;
-    experimental_clientGenerateTemplateNames?: string[];
+    generateFrom?: GenerateFrom | ((value: GenerateFrom) => GenerateFrom);
     templates?: {
         service?: string;
         controller?: string;
         [key: string]: string | undefined;
     };
 };
-export type VovkStrictConfig = Required<Omit<VovkConfig, 'validateOnClientImport' | 'fetcherImport' | 'createRPCImport'>> & {
+export type VovkStrictConfig = Required<Omit<VovkConfig, 'validateOnClientImport' | 'fetcherImport' | 'createRPCImport' | 'generateFrom'>> & {
     validateOnClientImport: string[] | null;
     fetcherImport: string[];
     createRPCImport: string[];
+    generateFrom: GenerateFrom;
 };
 export type VovkModuleRenderResult = {
     fileName: string;
@@ -84,3 +91,4 @@ export interface NewOptions {
     noSegmentUpdate?: boolean;
     empty?: boolean;
 }
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vovk-cli",
-  "version": "0.0.1-draft.96",
+  "version": "0.0.1-draft.98",
   "bin": {
     "vovk": "./dist/index.mjs"
   },
@@ -36,7 +36,7 @@
   },
   "homepage": "https://vovk.dev",
   "peerDependencies": {
-    "vovk": "^3.0.0-draft.83"
+    "vovk": "^3.0.0-draft.87"
   },
   "dependencies": {
     "@inquirer/prompts": "^7.3.1",