vovk-cli 0.0.1-draft.136 → 0.0.1-draft.138

package/dist/dev/index.mjs

@@ -66,14 +66,22 @@ export class VovkDev {
         })
             .on('addDir', async (dirPath) => {
             log.debug(`Directory ${dirPath} has been added to segments folder`);
-            this.#projectInfo.segments = await locateSegments({ dir: apiDirAbsolutePath, config });
+            this.#projectInfo.segments = await locateSegments({
+                dir: apiDirAbsolutePath,
+                config,
+                log: this.#projectInfo.log,
+            });
             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.#projectInfo.segments = await locateSegments({ dir: apiDirAbsolutePath, config });
+            this.#projectInfo.segments = await locateSegments({
+                dir: apiDirAbsolutePath,
+                config,
+                log: this.#projectInfo.log,
+            });
             for (const { segmentName } of this.#projectInfo.segments) {
                 void this.#requestSchema(segmentName);
             }

package/dist/generate/ensureClient.mjs

@@ -27,6 +27,7 @@ export default async function ensureClient({ config, cwd, log, segments }) {
         config,
         cwd,
         generateFrom: config.generateFrom,
+        log,
     });
     const usedTemplateNames = new Set();
     const defaultText = `// auto-generated ${new Date().toISOString()}
@@ -35,6 +36,8 @@ export default async function ensureClient({ config, cwd, log, segments }) {
 // 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.emitFullClient) {
             await writeOnePlaceholder({

package/dist/generate/getClientTemplates.d.mts

@@ -1,8 +1,9 @@
 import type { VovkStrictConfig } from 'vovk';
+import type { ProjectInfo } from '../getProjectInfo/index.mjs';
 export declare const DEFAULT_FULL_SCHEMA_FILE_NAME = "full-schema.json";
 export interface ClientTemplate {
     templateName: string;
-    templatePath: string;
+    templatePath: string | null;
     outDir: string;
     fullSchemaJSONFileName: string | null;
     origin?: string | null;
@@ -13,10 +14,11 @@ export declare enum BuiltInTemplateName {
     module = "module",
     fullSchema = "fullSchema"
 }
-export default function getClientTemplates({ config, cwd, generateFrom, }: {
+export default function getClientTemplates({ config, cwd, generateFrom, log, }: {
     config: VovkStrictConfig;
     cwd: string;
     generateFrom?: VovkStrictConfig['generateFrom'];
+    log: ProjectInfo['log'];
 }): Promise<{
     clientOutDirAbsolutePath: string;
     templateFiles: ClientTemplate[];

package/dist/generate/getClientTemplates.mjs

@@ -9,55 +9,64 @@ export var BuiltInTemplateName;
     BuiltInTemplateName["module"] = "module";
     BuiltInTemplateName["fullSchema"] = "fullSchema";
 })(BuiltInTemplateName || (BuiltInTemplateName = {}));
-export default async function getClientTemplates({ config, cwd, generateFrom = [], }) {
+export default async function getClientTemplates({ config, cwd, generateFrom = [], log, }) {
     const templatesDir = path.join(import.meta.dirname, '../..', 'client-templates');
     const clientOutDirAbsolutePath = path.resolve(cwd, config.clientOutDir);
     const builtIn = {
         ts: {
             templateName: BuiltInTemplateName.ts,
-            templatePath: path.resolve(templatesDir, 'ts/*'),
+            templateGlob: path.resolve(templatesDir, 'ts/*'),
             outDir: clientOutDirAbsolutePath,
             fullSchemaJSON: false,
             origin: null,
         },
         main: {
             templateName: BuiltInTemplateName.main,
-            templatePath: path.resolve(templatesDir, 'main/*'),
+            templateGlob: path.resolve(templatesDir, 'main/*'),
             outDir: clientOutDirAbsolutePath,
             fullSchemaJSON: false,
             origin: null,
         },
         module: {
             templateName: BuiltInTemplateName.module,
-            templatePath: path.resolve(templatesDir, 'module/*'),
+            templateGlob: path.resolve(templatesDir, 'module/*'),
             outDir: clientOutDirAbsolutePath,
             fullSchemaJSON: false,
             origin: null,
         },
         fullSchema: {
             templateName: BuiltInTemplateName.fullSchema,
-            templatePath: path.resolve(templatesDir, 'fullSchema/*'),
+            templateGlob: path.resolve(templatesDir, 'fullSchema/*'),
             outDir: clientOutDirAbsolutePath,
             fullSchemaJSON: false,
             origin: null,
         },
     };
     const generateFromStrict = generateFrom.map((template) => {
+        if (template === 'none') {
+            return {
+                templateName: template,
+                templateGlob: null,
+                outDir: clientOutDirAbsolutePath,
+                fullSchemaJSON: false,
+                origin: null,
+            };
+        }
         if (typeof template === 'string') {
             if (template in builtIn) {
                 return builtIn[template];
             }
             return {
                 templateName: template,
-                templatePath: resolveAbsoluteModulePath(template, cwd),
+                templateGlob: resolveAbsoluteModulePath(template, cwd),
                 outDir: clientOutDirAbsolutePath,
                 fullSchemaJSON: false,
                 origin: null,
             };
         }
         return {
-            templateName: template.templateName ?? template.templatePath,
-            templatePath: resolveAbsoluteModulePath(template.templatePath, cwd),
+            templateName: template.templateName ?? template.templateGlob ?? 'none',
+            templateGlob: template.templateGlob ? resolveAbsoluteModulePath(template.templateGlob, cwd) : null,
             outDir: template.outDir ? path.resolve(cwd, template.outDir) : clientOutDirAbsolutePath,
             fullSchemaJSON: template.fullSchemaJSON ?? false,
             origin: template.origin ?? null,
@@ -68,17 +77,34 @@ export default async function getClientTemplates({ config, cwd, generateFrom = [
     }
     const templateFiles = [];
     for (const generateFromItem of generateFromStrict) {
-        const files = await glob(generateFromItem.templatePath);
+        let files = [];
+        const fullSchemaJSONFileName = generateFromItem.fullSchemaJSON
+            ? generateFromItem.fullSchemaJSON === 'string'
+                ? generateFromItem.fullSchemaJSON
+                : DEFAULT_FULL_SCHEMA_FILE_NAME
+            : null;
+        if (generateFromItem.templateGlob) {
+            files = await glob(generateFromItem.templateGlob);
+            if (files.length === 0) {
+                log.error(`Template "${generateFromItem.templateGlob}" not found`);
+                continue;
+            }
+        }
+        else {
+            templateFiles.push({
+                templateName: generateFromItem.templateName,
+                templatePath: null,
+                outDir: generateFromItem.outDir,
+                fullSchemaJSONFileName,
+                origin: generateFromItem.origin,
+            });
+        }
         for await (const templatePath of files) {
             templateFiles.push({
                 templateName: generateFromItem.templateName,
                 templatePath,
                 outDir: generateFromItem.outDir,
-                fullSchemaJSONFileName: generateFromItem.fullSchemaJSON
-                    ? generateFromItem.fullSchemaJSON === 'string'
-                        ? generateFromItem.fullSchemaJSON
-                        : DEFAULT_FULL_SCHEMA_FILE_NAME
-                    : null,
+                fullSchemaJSONFileName,
                 origin: generateFromItem.origin,
             });
         }

package/dist/generate/index.d.mts

@@ -6,8 +6,8 @@ export type ClientImports = {
     validateOnClient: string | null;
     createRPC: string;
 };
-export default function generate({ projectInfo, forceNothingWrittenLog, templates, prettify: prettifyClient, fullSchema, emitFullSchema, }: {
+export default function generate({ projectInfo, forceNothingWrittenLog, templates, prettify: prettifyClient, fullSchema, fullSchemaJson, }: {
     projectInfo: ProjectInfo;
     forceNothingWrittenLog?: boolean;
     fullSchema: VovkFullSchema;
-} & Pick<GenerateOptions, 'templates' | 'prettify' | 'emitFullSchema'>): Promise<void>;
+} & Pick<GenerateOptions, 'templates' | 'prettify' | 'fullSchemaJson'>): Promise<void>;

package/dist/generate/index.mjs

@@ -13,6 +13,9 @@ 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`);
+    }
     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 = {
@@ -56,21 +59,22 @@ async function writeOneClientFile({ projectInfo, clientTemplate, fullSchema, pre
         rendered = await prettify(rendered, outPath);
     }
     // Read existing file content to compare
-    const existingContent = await fs.readFile(outPath, 'utf-8').catch(() => '');
+    const existingContent = await fs.readFile(outPath, 'utf-8').catch(() => null);
     // 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');
+    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);
     }
     return { written: needsWriting };
 }
-export default async function generate({ projectInfo, forceNothingWrittenLog, templates, prettify: prettifyClient = false, fullSchema, emitFullSchema, }) {
+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 });
+    const { clientOutDirAbsolutePath, templateFiles } = await getClientTemplates({ config, cwd, generateFrom, log });
     // 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];
@@ -87,10 +91,12 @@ export default async function generate({ projectInfo, forceNothingWrittenLog, te
     // Process each template in parallel
     await Promise.all(templateFiles.map(async (clientTemplate) => {
         const { templatePath, templateName, outDir, fullSchemaJSONFileName } = clientTemplate;
-        if (!noClient) {
+        if (!noClient && templatePath) {
             // Read the EJS template
             const templateContent = await fs.readFile(templatePath, 'utf-8');
-            const matterResult = matter(templateContent);
+            const matterResult = templatePath.endsWith('.ejs')
+                ? matter(templateContent)
+                : { data: { imports: [] }, content: templateContent };
             if (config.emitFullClient) {
                 const { written: isWritten } = await writeOneClientFile({
                     projectInfo,
@@ -153,9 +159,9 @@ export default async function generate({ projectInfo, forceNothingWrittenLog, te
             });
         }
     }));
-    if (emitFullSchema) {
-        const fullSchemaOutAbsolutePath = emitFullSchema
-            ? path.resolve(clientOutDirAbsolutePath, emitFullSchema === 'string' ? emitFullSchema : DEFAULT_FULL_SCHEMA_FILE_NAME)
+    if (fullSchemaJson) {
+        const fullSchemaOutAbsolutePath = fullSchemaJson
+            ? path.resolve(clientOutDirAbsolutePath, typeof fullSchemaJson === 'string' ? fullSchemaJson : DEFAULT_FULL_SCHEMA_FILE_NAME)
             : null;
         if (fullSchemaOutAbsolutePath) {
             fullSchemaOutAbsolutePaths.set(null, fullSchemaOutAbsolutePath);
@@ -163,7 +169,7 @@ export default async function generate({ projectInfo, forceNothingWrittenLog, te
     }
     if (fullSchemaOutAbsolutePaths.size) {
         await Promise.all(Array.from(fullSchemaOutAbsolutePaths.entries()).map(async ([segmentName, outPath]) => {
-            const schema = segmentName ? pickSegmentFullSchema(fullSchema, segmentName) : fullSchema;
+            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));
         }));

package/dist/getProjectInfo/getConfig.mjs

@@ -5,9 +5,9 @@ export default async function getConfig({ clientOutDir, configPath, cwd, }) {
     const { configAbsolutePaths, error, userConfig } = await getUserConfig({ configPath, cwd });
     const conf = userConfig ?? {};
     const srcRoot = await getRelativeSrcRoot({ cwd });
-    const validateOnClientImport = env.VOVK_VALIDATE_ON_CLIENT_PATH ?? conf.imports?.validateOnClient ?? null;
-    const fetcherImport = env.VOVK_FETCHER_PATH ?? conf.imports?.fetcher ?? 'vovk';
-    const createRPCImport = env.VOVK_CREATE_RPC_PATH ?? conf.imports?.createRPC ?? 'vovk';
+    const validateOnClientImport = env.VOVK_IMPORTS_VALIDATE_ON_CLIENT ?? conf.imports?.validateOnClient ?? null;
+    const fetcherImport = env.VOVK_IMPORTS_FETCHER ?? conf.imports?.fetcher ?? 'vovk';
+    const createRPCImport = env.VOVK_IMPORTS_CREATE_RPC ?? conf.imports?.createRPC ?? 'vovk';
     const defaultClientTemplates = ['module', 'main'];
     const config = {
         emitConfig: [],

package/dist/getProjectInfo/index.mjs

@@ -23,7 +23,7 @@ export default async function getProjectInfo({ port: givenPort, clientOutDir, co
     }
     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 });
+    const segments = await locateSegments({ dir: apiDirAbsolutePath, config, log });
     // TODO Refactor
     const clientImports = {
         fullClient: {

package/dist/index.mjs

@@ -74,11 +74,11 @@ program
     .description('Generate RPC client from schema')
     .option('--out, --client-out-dir <path>', 'path to output directory')
     .option('--template, --templates <templates...>', 'client code templates ("ts", "compiled", "python", "none", a custom path)')
-    .option('--emit-full-schema, --full-schema-json [fileName]', 'generate client with full schema')
+    .option('--full-schema-json [fileName]', 'generate client with full schema')
     .option('--prettify', 'prettify output files')
     .option('--config <config>', 'path to config file')
     .action(async (options) => {
-    const { clientOutDir, templates, prettify, emitFullSchema, config: configPath } = options;
+    const { clientOutDir, templates, prettify, fullSchemaJson, config: configPath } = options;
     const projectInfo = await getProjectInfo({ clientOutDir, configPath });
     const { cwd, config } = projectInfo;
     const schemaOutAbsolutePath = path.join(cwd, config.schemaOutDir);
@@ -89,7 +89,7 @@ program
         templates,
         prettify,
         forceNothingWrittenLog: true,
-        emitFullSchema,
+        fullSchemaJson,
     });
 });
 program

package/dist/locateSegments.d.mts

@@ -1,11 +1,13 @@
 import type { VovkStrictConfig } from 'vovk';
+import type { ProjectInfo } from './getProjectInfo/index.mjs';
 export type Segment = {
     routeFilePath: string;
     segmentName: string;
     segmentImportPath: string;
 };
-export default function locateSegments({ dir, rootDir, config, }: {
+export default function locateSegments({ dir, rootDir, config, log, }: {
     dir: string;
     rootDir?: string;
     config: VovkStrictConfig | null;
+    log: ProjectInfo['log'];
 }): Promise<Segment[]>;

package/dist/locateSegments.mjs

@@ -1,11 +1,18 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import getFileSystemEntryType from './utils/getFileSystemEntryType.mjs';
-export default async function locateSegments({ dir, rootDir, config, }) {
+export default async function locateSegments({ dir, rootDir, config, log, }) {
     let results = [];
     rootDir = rootDir ?? dir;
+    let list = [];
     // Read the contents of the directory
-    const list = await fs.readdir(dir);
+    try {
+        list = await fs.readdir(dir);
+    }
+    catch {
+        // do nothing
+        return results;
+    }
     // Iterate through each item in the directory
     for (const file of list) {
         const filePath = path.join(dir, file);
@@ -23,7 +30,7 @@ export default async function locateSegments({ dir, rootDir, config, }) {
                 }
             }
             // Recursively search inside subdirectories
-            const subDirResults = await locateSegments({ dir: filePath, rootDir, config });
+            const subDirResults = await locateSegments({ dir: filePath, rootDir, config, log });
             results = results.concat(subDirResults);
         }
     }

package/dist/new/newModule.mjs

@@ -3,7 +3,6 @@ import fs from 'node:fs/promises';
 import render from './render.mjs';
 import addClassToSegmentCode from './addClassToSegmentCode.mjs';
 import getProjectInfo from '../getProjectInfo/index.mjs';
-import locateSegments from '../locateSegments.mjs';
 import chalkHighlightThing from '../utils/chalkHighlightThing.mjs';
 import formatLoggedSegmentName from '../utils/formatLoggedSegmentName.mjs';
 import getFileSystemEntryType from '../utils/getFileSystemEntryType.mjs';
@@ -20,7 +19,7 @@ function splitByLast(str, delimiter = '/') {
     return [before, after];
 }
 export default async function newModule({ what, moduleNameWithOptionalSegment, dryRun, dir: dirFlag, templates: templatesFlag, noSegmentUpdate, overwrite, empty, }) {
-    const { config, log, apiDir, cwd } = await getProjectInfo();
+    const { config, log, cwd, segments } = await getProjectInfo();
     let templates = config.templates;
     const [segmentName, moduleName] = splitByLast(moduleNameWithOptionalSegment);
     // replace c by controller, s by service, everything else keeps the same
@@ -48,7 +47,6 @@ export default async function newModule({ what, moduleNameWithOptionalSegment, d
             throw new Error(`Template for "${type}" not found`);
         }
     }
-    const segments = await locateSegments({ dir: apiDir, config });
     const segment = segments.find((s) => s.segmentName === segmentName);
     if (!segment) {
         throw new Error(`Unable to create module. Segment "${segmentName}" not found. Run "vovk new segment ${segmentName}" to create it`);

package/dist/types.d.mts

@@ -14,7 +14,7 @@ export interface GenerateOptions {
     clientOutDir?: string;
     templates?: string[];
     prettify?: boolean;
-    emitFullSchema?: string | boolean;
+    fullSchemaJson?: string | boolean;
     config?: string;
 }
 export interface InitOptions {

package/dist/utils/removeUnlistedDirectories.mjs

@@ -1,5 +1,6 @@
 import fs from 'fs/promises';
 import path from 'path';
+import getFileSystemEntryType, { FileSystemEntryType } from './getFileSystemEntryType.mjs';
 /**
  * Removes all directories in a folder that aren't in the provided allowlist
  * Supports nested directory paths like 'foo/bar/baz'
@@ -23,6 +24,12 @@ async function removeUnlistedDirectories(folderPath, allowedDirs) {
  */
 async function processDirectory(basePath, relativePath, allowedDirs) {
     const currentDirPath = path.join(basePath, relativePath);
+    // check if the current path is a directory
+    const type = await getFileSystemEntryType(currentDirPath);
+    if (type !== FileSystemEntryType.DIRECTORY) {
+        // If it's not a directory, return early
+        return;
+    }
     // Read all entries in the current directory
     const entries = await fs.readdir(currentDirPath, { withFileTypes: true });
     // Process only directories

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vovk-cli",
-  "version": "0.0.1-draft.136",
+  "version": "0.0.1-draft.138",
   "bin": {
     "vovk": "./dist/index.mjs"
   },
@@ -35,10 +35,10 @@
   },
   "homepage": "https://vovk.dev",
   "peerDependencies": {
-    "vovk": "^3.0.0-draft.110"
+    "vovk": "^3.0.0-draft.112"
   },
   "optionalDependencies": {
-    "vovk-python-client": "*"
+    "vovk-python-client": "^0.0.1-draft.6"
   },
   "dependencies": {
     "@inquirer/prompts": "^7.3.1",
@@ -70,6 +70,6 @@
     "concat-stream": "^2.0.0",
     "create-next-app": "^15.1.6",
     "node-pty": "^1.0.0",
-    "type-fest": "^4.33.0"
+    "type-fest": "^4.37.0"
   }
 }