vovk-cli 0.0.1-beta.18 → 0.0.1-beta.19

package/dist/generateClient.mjs

@@ -1,34 +1,33 @@
 import path from 'path';
 import fs from 'fs/promises';
 import formatLoggedSegmentName from './utils/formatLoggedSegmentName.mjs';
+import prettify from './utils/prettify.mjs';
 export default async function generateClient(projectInfo, segments, segmentsSchema) {
+    const { config, cwd, log, validateOnClientImportPath, apiEntryPoint, fetcherClientImportPath, schemaOutImportPath } = projectInfo;
     const now = Date.now();
-    const clientoOutDirFullPath = path.join(projectInfo.cwd, projectInfo.config.clientOutDir);
-    const validateFullPath = projectInfo.config.validateOnClient?.startsWith('.')
-        ? path.join(projectInfo.cwd, projectInfo.config.validateOnClient)
-        : projectInfo.config.validateOnClient;
+    const clientoOutDirAbsolutePath = path.join(cwd, config.clientOutDir);
     let dts = `// auto-generated
 /* eslint-disable */
 import type { clientizeController } from 'vovk/client';
 import type { promisifyWorker } from 'vovk/worker';
 import type { VovkClientFetcher } from 'vovk/client';
-import type fetcher from '${projectInfo.fetcherClientImportPath}';
+import type fetcher from '${fetcherClientImportPath}';
 
 `;
     let js = `// auto-generated
 /* eslint-disable */
 const { clientizeController } = require('vovk/client');
 const { promisifyWorker } = require('vovk/worker');
-const { default: fetcher } = require('${projectInfo.fetcherClientImportPath}');
-const schema = require('${projectInfo.schemaOutImportPath}');
+const { default: fetcher } = require('${fetcherClientImportPath}');
+const schema = require('${schemaOutImportPath}');
 `;
     let ts = `// auto-generated
 /* eslint-disable */
 import { clientizeController } from 'vovk/client';
 import { promisifyWorker } from 'vovk/worker';
 import type { VovkClientFetcher } from 'vovk/client';
-import fetcher from '${projectInfo.fetcherClientImportPath}';
-import schema from '${projectInfo.schemaOutImportPath}';
+import fetcher from '${fetcherClientImportPath}';
+import schema from '${schemaOutImportPath}';
 
 `;
     for (let i = 0; i < segments.length; i++) {
@@ -39,7 +38,7 @@ import schema from '${projectInfo.schemaOutImportPath}';
         }
         if (!schema.emitSchema)
             continue;
-        const importRouteFilePath = path.relative(projectInfo.config.clientOutDir, routeFilePath);
+        const importRouteFilePath = path.relative(config.clientOutDir, routeFilePath);
         dts += `import type { Controllers as Controllers${i}, Workers as Workers${i} } from "${importRouteFilePath}";\n`;
         ts += `import type { Controllers as Controllers${i}, Workers as Workers${i} } from "${importRouteFilePath}";\n`;
     }
@@ -47,13 +46,13 @@ import schema from '${projectInfo.schemaOutImportPath}';
 type Options = typeof fetcher extends VovkClientFetcher<infer U> ? U : never;
 `;
     ts += `
-${validateFullPath ? `import validateOnClient from '${validateFullPath}';\n` : '\nconst validateOnClient = undefined;'}
+${validateOnClientImportPath ? `import validateOnClient from '${validateOnClientImportPath}';\n` : '\nconst validateOnClient = undefined;'}
 type Options = typeof fetcher extends VovkClientFetcher<infer U> ? U : never;
-const prefix = '${projectInfo.apiEntryPoint}';
+const prefix = '${apiEntryPoint}';
 `;
     js += `
-const { default: validateOnClient = null } = ${validateFullPath ? `require('${validateFullPath}')` : '{}'};
-const prefix = '${projectInfo.apiEntryPoint}';
+const { default: validateOnClient = null } = ${validateOnClientImportPath ? `require('${validateOnClientImportPath}')` : '{}'};
+const prefix = '${apiEntryPoint}';
 `;
     for (let i = 0; i < segments.length; i++) {
         const { segmentName } = segments[i];
@@ -74,20 +73,23 @@ const prefix = '${projectInfo.apiEntryPoint}';
             ts += `export const ${key} = promisifyWorker<Workers${i}["${key}"]>(null, schema['${segmentName}'].workers.${key});\n`;
         }
     }
-    const localJsPath = path.join(clientoOutDirFullPath, 'client.js');
-    const localDtsPath = path.join(clientoOutDirFullPath, 'client.d.ts');
-    const localTsPath = path.join(clientoOutDirFullPath, 'index.ts');
-    const existingJs = await fs.readFile(localJsPath, 'utf-8').catch(() => '');
-    const existingDts = await fs.readFile(localDtsPath, 'utf-8').catch(() => '');
-    const existingTs = await fs.readFile(localTsPath, 'utf-8').catch(() => '');
+    const localJsAbsolutePath = path.join(clientoOutDirAbsolutePath, 'client.js');
+    const localDtsAbsolutePath = path.join(clientoOutDirAbsolutePath, 'client.d.ts');
+    const localTsAbsolutePath = path.join(clientoOutDirAbsolutePath, 'index.ts');
+    const existingJs = await fs.readFile(localJsAbsolutePath, 'utf-8').catch(() => '');
+    const existingDts = await fs.readFile(localDtsAbsolutePath, 'utf-8').catch(() => '');
+    const existingTs = await fs.readFile(localTsAbsolutePath, 'utf-8').catch(() => '');
+    js = await prettify(js, localJsAbsolutePath);
+    dts = await prettify(dts, localDtsAbsolutePath);
+    ts = await prettify(ts, localTsAbsolutePath);
     if (existingJs === js && existingDts === dts && existingTs === ts) {
-        projectInfo.log.info(`Client is up to date and doesn't need to be regenerated (${Date.now() - now}ms)`);
-        return { written: false, path: clientoOutDirFullPath };
+        log.info(`Client is up to date and doesn't need to be regenerated (${Date.now() - now}ms)`);
+        return { written: false, path: clientoOutDirAbsolutePath };
     }
-    await fs.mkdir(clientoOutDirFullPath, { recursive: true });
-    await fs.writeFile(localJsPath, js);
-    await fs.writeFile(localDtsPath, dts);
-    await fs.writeFile(localTsPath, ts);
-    projectInfo.log.info(`Client generated in ${Date.now() - now}ms`);
-    return { written: true, path: clientoOutDirFullPath };
+    await fs.mkdir(clientoOutDirAbsolutePath, { recursive: true });
+    await fs.writeFile(localJsAbsolutePath, js);
+    await fs.writeFile(localDtsAbsolutePath, dts);
+    await fs.writeFile(localTsAbsolutePath, ts);
+    log.info(`Client generated in ${Date.now() - now}ms`);
+    return { written: true, path: clientoOutDirAbsolutePath };
 }

package/dist/getProjectInfo/getConfig.d.mts

@@ -2,6 +2,6 @@ import type { VovkConfig } from '../types.mjs';
 export default function getConfig({ clientOutDir }: {
     clientOutDir?: string;
 }): Promise<{
-    config: Required<VovkConfig>;
+    config: Required<Omit<VovkConfig, "_devForceAppDir">>;
     srcRoot: string;
 }>;

package/dist/getProjectInfo/getConfig.mjs

@@ -15,6 +15,14 @@ export default async function getConfig({ clientOutDir }) {
         rootEntry: env.VOVK_ROOT_ENTRY ?? userConfig.rootEntry ?? 'api',
         rootSegmentModulesDirName: env.VOVK_ROOT_SEGMENT_MODULES_DIR_NAME ?? userConfig.rootSegmentModulesDirName ?? '',
         logLevel: env.VOVK_LOG_LEVEL ?? userConfig.logLevel ?? 'debug', // TODO: change to 'warn' when v3 is ready
+        custom: userConfig.custom ?? {},
+        templates: {
+            service: 'vovk-cli/templates/service.ejs',
+            controller: 'vovk-cli/templates/controller.ejs',
+            worker: 'vovk-cli/templates/worker.ejs',
+            ...userConfig.templates,
+        },
     };
+    // forceAppDir is used for testing purposes
     return { config, srcRoot };
 }

package/dist/getProjectInfo/index.d.mts

@@ -10,7 +10,8 @@ export default function getProjectInfo({ port: givenPort, clientOutDir, }?: {
     srcRoot: string;
     schemaOutImportPath: string;
     fetcherClientImportPath: string;
-    config: Required<import("../types.mjs").VovkConfig>;
+    validateOnClientImportPath: string | null;
+    config: Required<Omit<import("../types.mjs").VovkConfig, "_devForceAppDir">>;
     log: {
         info: (msg: string) => void;
         warn: (msg: string) => void;

package/dist/getProjectInfo/index.mjs

@@ -13,6 +13,9 @@ export default async function getProjectInfo({ port: givenPort, clientOutDir, }
     const fetcherClientImportPath = config.fetcher.startsWith('.')
         ? path.relative(config.clientOutDir, config.fetcher)
         : config.fetcher;
+    const validateOnClientImportPath = config.validateOnClient?.startsWith('.')
+        ? path.relative(config.clientOutDir, config.validateOnClient)
+        : config.validateOnClient;
     const log = getLogger(config.logLevel);
     return {
         cwd,
@@ -22,6 +25,7 @@ export default async function getProjectInfo({ port: givenPort, clientOutDir, }
         srcRoot,
         schemaOutImportPath,
         fetcherClientImportPath,
+        validateOnClientImportPath,
         config,
         log,
     };

package/dist/index.d.mts

@@ -1,8 +1,11 @@
 #!/usr/bin/env node
-import { VovkConfig, VovkEnv } from './types.mjs';
 import type { LogLevelNames } from 'loglevel';
+import type { VovkConfig, VovkEnv } from './types.mjs';
 export type { VovkConfig, VovkEnv };
 export interface InitOptions {
     yes: boolean;
     logLevel: LogLevelNames;
 }
+export interface NewOptions {
+    dryRun: boolean;
+}

package/dist/index.mjs

@@ -1,14 +1,15 @@
 #!/usr/bin/env node
+import path from 'path';
 import { Command } from 'commander';
+import { readFileSync } from 'fs';
 import concurrently from 'concurrently';
 import getAvailablePort from './utils/getAvailablePort.mjs';
-import { VovkCLIWatcher } from './watcher/index.mjs';
 import getProjectInfo from './getProjectInfo/index.mjs';
 import generateClient from './generateClient.mjs';
 import locateSegments from './locateSegments.mjs';
-import path from 'path';
-import { readFileSync } from 'fs';
+import { VovkCLIWatcher } from './watcher/index.mjs';
 import { Init } from './init/index.mjs';
+import newComponents from './new/index.mjs';
 const program = new Command();
 const packageJSON = JSON.parse(readFileSync(path.join(import.meta.dirname, '../package.json'), 'utf-8'));
 program.name('vovk').description('Vovk CLI').version(packageJSON.version);
@@ -66,8 +67,8 @@ program
     const projectInfo = await getProjectInfo({ clientOutDir: options.clientOut });
     const { cwd, config, apiDir } = projectInfo;
     const segments = await locateSegments(apiDir);
-    const schemaOutFullPath = path.join(cwd, config.schemaOutDir);
-    const schema = (await import(path.join(schemaOutFullPath, 'index.js')));
+    const schemaOutAbsolutePath = path.join(cwd, config.schemaOutDir);
+    const schema = (await import(path.join(schemaOutAbsolutePath, 'index.js')));
     await generateClient(projectInfo, segments, schema.default);
 });
 program
@@ -75,13 +76,25 @@ program
     .description('Initialize Vovk project')
     .option('-Y, --yes', 'Skip all prompts and use default values')
     .option('--log-level <level>', 'Set log level', 'info')
-    .action(async (prefix = '.', options) => {
-    await Init.main(prefix, options);
-});
+    .action((prefix = '.', options) => Init.main(prefix, options));
+program
+    .command('new [components...]')
+    .alias('n')
+    .description('Create new components. "vovk new [...components] [segmentName/]moduleName" to create a new module or "vovk new segment [segmentName]" to create a new segment')
+    .option('--dry-run', 'Do not write files to disk')
+    .action((components, options) => newComponents(components, options));
 program
     .command('help')
     .description('Show help message')
     .action(() => program.help());
+/*
+vovk new segment [segmentName]
+vovk new controller service [segmentName/]moduleName
+vovk new c s w [segmentName/]moduleName
+
+vovk c s w userApi/user
+vovk new c s w user
+*/
 program.parse(process.argv);
 if (!process.argv.slice(2).length) {
     program.outputHelp();

package/dist/init/installDependencies.mjs

@@ -3,19 +3,19 @@ import { promisify } from 'util';
 import * as path from 'path';
 const execPromise = promisify(exec);
 export default async function installDependencies(installDir, dependencies, devDependencies) {
-    const fullPath = path.resolve(installDir);
+    const absolutePath = path.resolve(installDir);
     try {
         if (dependencies.length > 0) {
-            console.log(`Installing dependencies in ${fullPath}...`);
-            const { stdout, stderr } = await execPromise(`npm install ${dependencies.join(' ')} --prefix ${fullPath}`);
+            console.log(`Installing dependencies in ${absolutePath}...`);
+            const { stdout, stderr } = await execPromise(`npm install ${dependencies.join(' ')} --prefix ${absolutePath}`);
             console.log(stdout);
             if (stderr) {
                 console.error(stderr);
             }
         }
         if (devDependencies.length > 0) {
-            console.log(`Installing dev dependencies in ${fullPath}...`);
-            const { stdout, stderr } = await execPromise(`npm install --save-dev ${devDependencies.join(' ')} --prefix ${fullPath}`);
+            console.log(`Installing dev dependencies in ${absolutePath}...`);
+            const { stdout, stderr } = await execPromise(`npm install --save-dev ${devDependencies.join(' ')} --prefix ${absolutePath}`);
             console.log(stdout);
             if (stderr) {
                 console.error(stderr);

package/dist/new/addClassToSegmentCode.d.mts

@@ -0,0 +1,6 @@
+export default function addClassToSegmentCode(segmentSourceCode: string, { className, rpcName, type, importPath, }: {
+    className: string;
+    rpcName: string;
+    type: 'worker' | 'controller';
+    importPath: string;
+}): string;

package/dist/new/addClassToSegmentCode.mjs

@@ -0,0 +1,32 @@
+import { Project, SyntaxKind } from 'ts-morph';
+export default function addClassToSegmentCode(segmentSourceCode, { className, rpcName, type, importPath, }) {
+    const project = new Project();
+    const sourceFile = project.createSourceFile('route.ts', segmentSourceCode, { overwrite: true });
+    // Add the import if it doesn't exist
+    let importDeclaration = sourceFile.getImportDeclaration((imp) => {
+        return imp.getModuleSpecifierValue() === importPath;
+    });
+    if (!importDeclaration) {
+        importDeclaration = sourceFile.addImportDeclaration({
+            defaultImport: className,
+            moduleSpecifier: importPath,
+        });
+    }
+    // Get the variable declaration for controllers or workers
+    const variableDeclaration = sourceFile.getVariableDeclaration(`${type}s`);
+    if (variableDeclaration) {
+        const initializer = variableDeclaration.getInitializer();
+        if (initializer && initializer.getKind() === SyntaxKind.ObjectLiteralExpression) {
+            const objectLiteral = initializer.asKindOrThrow(SyntaxKind.ObjectLiteralExpression);
+            // Check if the property already exists
+            const existingProperty = objectLiteral.getProperty(rpcName);
+            if (!existingProperty) {
+                objectLiteral.addPropertyAssignment({
+                    name: rpcName,
+                    initializer: className,
+                });
+            }
+        }
+    }
+    return sourceFile.getFullText();
+}

package/dist/{generate/addCommonTerms.js → new/addCommonTerms.mjs}

@@ -1,4 +1,5 @@
 import pluralize from 'pluralize';
+// feel free to open a direct PR if you have more common terms to add
 const terms = [
     ['entity', 'entities'],
     ['regex', 'regexes'],

package/dist/new/index.d.mts

@@ -0,0 +1,2 @@
+import type { NewOptions } from '../index.mjs';
+export default function newComponents(components: string[], options: NewOptions): Promise<void>;

package/dist/new/index.mjs

@@ -0,0 +1,24 @@
+import newModule from './newModule.mjs';
+import newSegment from './newSegment.mjs';
+export default async function newComponents(components, options) {
+    if (components[0] === 'segment' || components[0] === 'segments') {
+        let segmentNames = components.slice(1);
+        if (!segmentNames.length) {
+            segmentNames = [''];
+        }
+        for (const segmentName of segmentNames) {
+            await newSegment({ segmentName, dryRun: options.dryRun });
+        }
+    }
+    else {
+        if (components.length < 2) {
+            throw new Error('Invalid command invocation. Please provide at least two arguments.');
+        }
+        const what = components.slice(0, -1);
+        const moduleNameWithOptionalSegment = components[components.length - 1];
+        if (!moduleNameWithOptionalSegment) {
+            throw new Error('A module name with an optional segment cannot be empty');
+        }
+        await newModule({ what, moduleNameWithOptionalSegment, dryRun: options.dryRun });
+    }
+}

package/dist/new/newModule.d.mts

@@ -0,0 +1,5 @@
+export default function newModule({ what, moduleNameWithOptionalSegment, dryRun, }: {
+    what: string[];
+    moduleNameWithOptionalSegment: string;
+    dryRun: boolean;
+}): Promise<void>;

package/dist/new/newModule.mjs

@@ -0,0 +1,89 @@
+import path from 'path';
+import fs from 'fs/promises';
+import getProjectInfo from '../getProjectInfo/index.mjs';
+import render from './render.mjs';
+import chalkHighlightThing from '../utils/chalkHighlightThing.mjs';
+import formatLoggedSegmentName from '../utils/formatLoggedSegmentName.mjs';
+import locateSegments from '../locateSegments.mjs';
+import addClassToSegmentCode from './addClassToSegmentCode.mjs';
+import fileExists from '../utils/fileExists.mjs';
+import prettify from '../utils/prettify.mjs';
+function splitByLast(str, delimiter = '/') {
+    const index = str.lastIndexOf(delimiter);
+    if (index === -1) {
+        // Delimiter not found; return empty string and the original string
+        return ['', str];
+    }
+    const before = str.substring(0, index);
+    const after = str.substring(index + delimiter.length);
+    return [before, after];
+}
+export default async function newModule({ what, moduleNameWithOptionalSegment, dryRun, }) {
+    const { config, log, apiDir, cwd } = await getProjectInfo();
+    const templates = config.templates;
+    const [segmentName, moduleName] = splitByLast(moduleNameWithOptionalSegment);
+    // replace c by controller, s by service, w by worker, everything else keeps the same
+    what = what.map((s) => {
+        switch (s) {
+            case 'c':
+                return 'controller';
+            case 's':
+                return 'service';
+            case 'w':
+                return 'worker';
+            default:
+                return s;
+        }
+    });
+    // check if template exists
+    for (const type of what) {
+        if (!templates[type]) {
+            throw new Error(`Template for ${type} not found in config`);
+        }
+    }
+    const segments = await locateSegments(apiDir);
+    const segment = segments.find((s) => s.segmentName === segmentName);
+    if (!segment) {
+        throw new Error(`Segment ${segmentName} not found`);
+    }
+    for (const type of what) {
+        const templatePath = templates[type];
+        const templateAbsolutePath = path.join(cwd, '../..', templatePath); // TODO WRONG, use import.meta.resolve, also in other modules for fetcher, validateOnClient, etc.
+        const templateCode = await fs.readFile(templateAbsolutePath, 'utf-8');
+        const { fileName, className, rpcName, code } = await render(templateCode, {
+            config,
+            withService: what.includes('service'),
+            segmentName,
+            moduleName,
+        });
+        console.log(config.modulesDir, fileName);
+        const absoluteModulePath = path.join(config.modulesDir, fileName);
+        const dirName = path.dirname(absoluteModulePath);
+        const prettiedCode = await prettify(code, absoluteModulePath);
+        if (!dryRun) {
+            if (await fileExists(absoluteModulePath)) {
+                log.warn(`File ${chalkHighlightThing(absoluteModulePath)} already exists, skipping this "${type}"`);
+            }
+            else {
+                await fs.mkdir(dirName, { recursive: true });
+                await fs.writeFile(absoluteModulePath, prettiedCode);
+            }
+        }
+        if (type === 'controller' || type === 'worker') {
+            const { routeFilePath } = segment;
+            const segmentSourceCode = await fs.readFile(routeFilePath, 'utf-8');
+            const importPath = path.relative(dirName, fileName); // TODO WRONG
+            const newSegmentCode = addClassToSegmentCode(segmentSourceCode, {
+                className,
+                rpcName,
+                type,
+                importPath,
+            });
+            if (!dryRun) {
+                await fs.writeFile(routeFilePath, newSegmentCode);
+            }
+            log.info(`Added ${chalkHighlightThing(className)} ${type} to ${formatLoggedSegmentName(segmentName)} as ${chalkHighlightThing(rpcName)}`);
+        }
+        log.info(`Created ${chalkHighlightThing(fileName)} with ${chalkHighlightThing(type)} template for ${formatLoggedSegmentName(segmentName)}`);
+    }
+}

package/dist/new/newSegment.d.mts

@@ -0,0 +1,4 @@
+export default function newSegment({ segmentName, dryRun }: {
+    segmentName: string;
+    dryRun: boolean;
+}): Promise<void>;

package/dist/new/newSegment.mjs

@@ -0,0 +1,33 @@
+import path from 'path';
+import fs from 'fs/promises';
+import getProjectInfo from '../getProjectInfo/index.mjs';
+import fileExists from '../utils/fileExists.mjs';
+import chalkHighlightThing from '../utils/chalkHighlightThing.mjs';
+import formatLoggedSegmentName from '../utils/formatLoggedSegmentName.mjs';
+import prettify from '../utils/prettify.mjs';
+export default async function newSegment({ segmentName, dryRun }) {
+    const { apiDir, cwd, log } = await getProjectInfo();
+    const absoluteSegmentRoutePath = path.join(cwd, apiDir, segmentName, '[[...vovk]]/route.ts');
+    if (await fileExists(absoluteSegmentRoutePath)) {
+        return log.error(`Unable to create new segment. ${formatLoggedSegmentName(segmentName, { upperFirst: true })} already exists.`);
+    }
+    const code = await prettify(`import { initVovk } from 'vovk';
+
+const controllers = {};
+const workers = {};
+
+export type Controllers = typeof controllers;
+export type Workers = typeof workers;
+
+export const { GET, POST, PATCH, PUT, HEAD, OPTIONS, DELETE } = initVovk({
+  emitSchema: true,
+  workers,
+  controllers,
+});
+`, absoluteSegmentRoutePath);
+    if (!dryRun) {
+        await fs.mkdir(path.dirname(absoluteSegmentRoutePath), { recursive: true });
+        await fs.writeFile(absoluteSegmentRoutePath, code);
+    }
+    log.info(`${formatLoggedSegmentName(segmentName, { upperFirst: true })} created at ${absoluteSegmentRoutePath}. Run ${chalkHighlightThing(`vovk new controller ${segmentName}/someName`)} to create a controller or modify the segment file manually`);
+}

package/dist/new/render.d.mts

@@ -0,0 +1,12 @@
+import type { VovkConfig } from '../types.mjs';
+export default function render(codeTemplate: string, { config, withService, segmentName, moduleName, }: {
+    config: VovkConfig;
+    withService: boolean;
+    segmentName: string;
+    moduleName: string;
+}): Promise<{
+    fileName: string;
+    className: string;
+    rpcName: string;
+    code: string;
+}>;

package/dist/new/render.mjs

@@ -0,0 +1,28 @@
+import ejs from 'ejs';
+import matter from 'gray-matter';
+import _ from 'lodash';
+import pluralize from 'pluralize';
+import addCommonTerms from './addCommonTerms.mjs';
+addCommonTerms();
+export default async function render(codeTemplate, { config, withService, segmentName, moduleName, }) {
+    const getFileDir = (givenSegmentName, givenModuleName) => [_.camelCase(givenModuleName), givenSegmentName || config.rootSegmentModulesDirName].filter(Boolean).join('/') +
+        '/';
+    const templateVars = {
+        // input
+        config,
+        withService,
+        segmentName,
+        moduleName,
+        // utils
+        getFileDir,
+        // libraries
+        _, // lodash
+        pluralize,
+    };
+    // first, render the front matter because it can use ejs variables
+    const parsed = matter((await ejs.render(codeTemplate, templateVars, { async: true })).trim());
+    const { fileName, className, rpcName } = parsed.data;
+    const templateContent = parsed.content;
+    const code = await ejs.render(templateContent, templateVars, { async: true });
+    return { fileName, className, rpcName, code };
+}

package/dist/types.d.mts

@@ -26,4 +26,11 @@ export type VovkConfig = {
     origin?: string;
     rootSegmentModulesDirName?: string;
     logLevel?: LogLevelNames;
+    custom?: KnownAny;
+    templates?: {
+        service?: string;
+        controller?: string;
+        worker?: string;
+        [key: string]: string | undefined;
+    };
 };

package/dist/utils/chalkHighlightThing.mjs

@@ -1,4 +1,4 @@
 import chalk from 'chalk';
 export default function chalkHighlightThing(str) {
-    return chalk.cyan.bold(str);
+    return chalk.whiteBright.bold(str);
 }

package/dist/utils/formatLoggedSegmentName.d.mts

@@ -1 +1,4 @@
-export default function formatLoggedSegmentName(segmentName: string, withChalk?: boolean): string;
+export default function formatLoggedSegmentName(segmentName: string, { withChalk, upperFirst }?: {
+    withChalk?: boolean;
+    upperFirst?: boolean;
+}): string;

package/dist/utils/formatLoggedSegmentName.mjs

@@ -1,5 +1,7 @@
 import chalkHighlightThing from './chalkHighlightThing.mjs';
-export default function formatLoggedSegmentName(segmentName, withChalk = false) {
-    const text = segmentName ? `segment "${segmentName}"` : 'the root segment';
+import upperFirstLodash from 'lodash/upperFirst.js';
+export default function formatLoggedSegmentName(segmentName, { withChalk = true, upperFirst = false } = {}) {
+    let text = segmentName ? `segment "${segmentName}"` : 'the root segment';
+    text = upperFirst ? upperFirstLodash(text) : text;
     return withChalk ? chalkHighlightThing(text) : text;
 }

package/dist/utils/prettify.d.mts

@@ -0,0 +1 @@
+export default function prettify(code: string, absoluteFilePath: string): Promise<string>;

package/dist/utils/prettify.mjs

@@ -0,0 +1,10 @@
+import prettier from 'prettier';
+export default async function prettify(code, absoluteFilePath) {
+    const options = await prettier.resolveConfig(absoluteFilePath);
+    const finalOptions = {
+        ...options,
+        filepath: absoluteFilePath, // for selecting the correct parser
+    };
+    const formattedCode = await prettier.format(code, finalOptions);
+    return formattedCode;
+}

package/dist/watcher/ensureSchemaFiles.d.mts

@@ -1,3 +1,3 @@
 import { ProjectInfo } from '../getProjectInfo/index.mjs';
-export default function ensureSchemaFiles(schemaOutFullPath: string, segmentNames: string[], projectInfo: ProjectInfo | null): Promise<void>;
+export default function ensureSchemaFiles(projectInfo: ProjectInfo | null, schemaOutAbsolutePath: string, segmentNames: string[]): Promise<void>;
 export declare const debouncedEnsureSchemaFiles: import("lodash").DebouncedFunc<typeof ensureSchemaFiles>;

package/dist/watcher/ensureSchemaFiles.mjs

@@ -3,7 +3,7 @@ import path from 'path';
 import debounce from 'lodash/debounce.js';
 import writeOneSchemaFile, { ROOT_SEGMENT_SCHEMA_NAME } from './writeOneSchemaFile.mjs';
 import formatLoggedSegmentName from '../utils/formatLoggedSegmentName.mjs';
-export default async function ensureSchemaFiles(schemaOutFullPath, segmentNames, projectInfo) {
+export default async function ensureSchemaFiles(projectInfo, schemaOutAbsolutePath, segmentNames) {
     const now = Date.now();
     let hasChanged = false;
     // Create index.js file
@@ -15,13 +15,13 @@ export default async function ensureSchemaFiles(schemaOutFullPath, segmentNames,
     const dTsContent = `import type { VovkSchema } from 'vovk';
 declare const segmentSchema: Record<string, VovkSchema>;
 export default segmentSchema;`;
-    await fs.mkdir(schemaOutFullPath, { recursive: true });
-    await fs.writeFile(path.join(schemaOutFullPath, 'index.js'), indexContent);
-    await fs.writeFile(path.join(schemaOutFullPath, 'index.d.ts'), dTsContent);
-    // Create JSON files (if not exist) with name [segmentName].json (where segmentName can include /, which means the folder structure can be nested) : {} (empty object)
+    await fs.mkdir(schemaOutAbsolutePath, { recursive: true });
+    await fs.writeFile(path.join(schemaOutAbsolutePath, 'index.js'), indexContent);
+    await fs.writeFile(path.join(schemaOutAbsolutePath, 'index.d.ts'), dTsContent);
+    // 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({
-            schemaOutFullPath,
+            schemaOutAbsolutePath,
             schema: {
                 emitSchema: false,
                 segmentName,
@@ -31,7 +31,7 @@ export default segmentSchema;`;
             skipIfExists: true,
         });
         if (isCreated) {
-            projectInfo?.log.debug(`Created empty schema file for ${formatLoggedSegmentName(segmentName, true)}`);
+            projectInfo?.log.debug(`Created empty schema file for ${formatLoggedSegmentName(segmentName)}`);
             hasChanged = true;
         }
     }));
@@ -39,32 +39,32 @@ export default segmentSchema;`;
     async function deleteUnnecessaryJsonFiles(dirPath) {
         const entries = await fs.readdir(dirPath, { withFileTypes: true });
         await Promise.all(entries.map(async (entry) => {
-            const fullPath = path.join(dirPath, entry.name);
+            const absolutePath = path.join(dirPath, entry.name);
             if (entry.isDirectory()) {
                 // Recursively delete unnecessary files and folders within nested directories
-                await deleteUnnecessaryJsonFiles(fullPath);
+                await deleteUnnecessaryJsonFiles(absolutePath);
                 // Check if the directory is empty after deletion and remove it if so
-                const remainingEntries = await fs.readdir(fullPath);
+                const remainingEntries = await fs.readdir(absolutePath);
                 if (remainingEntries.length === 0) {
-                    await fs.rmdir(fullPath);
-                    projectInfo?.log.debug(`Deleted unnecessary schema directory "${fullPath}"`);
+                    await fs.rmdir(absolutePath);
+                    projectInfo?.log.debug(`Deleted unnecessary schema directory "${absolutePath}"`);
                     hasChanged = true;
                 }
             }
             else if (entry.isFile() && entry.name.endsWith('.json')) {
-                const relativePath = path.relative(schemaOutFullPath, fullPath);
+                const relativePath = path.relative(schemaOutAbsolutePath, absolutePath);
                 const segmentName = relativePath.replace(/\\/g, '/').slice(0, -5); // Remove '.json' extension
                 if (!segmentNames.includes(segmentName) &&
                     !segmentNames.includes(segmentName.replace(ROOT_SEGMENT_SCHEMA_NAME, ''))) {
-                    await fs.unlink(fullPath);
-                    projectInfo?.log.debug(`Deleted unnecessary schema file for ${formatLoggedSegmentName(segmentName, true)}`);
+                    await fs.unlink(absolutePath);
+                    projectInfo?.log.debug(`Deleted unnecessary schema file for ${formatLoggedSegmentName(segmentName)}`);
                     hasChanged = true;
                 }
             }
         }));
     }
     // Start the recursive deletion from the root directory
-    await deleteUnnecessaryJsonFiles(schemaOutFullPath);
+    await deleteUnnecessaryJsonFiles(schemaOutAbsolutePath);
     if (hasChanged)
         projectInfo?.log.info(`Schema files updated in ${Date.now() - now}ms`);
 }

package/dist/watcher/index.mjs

@@ -23,12 +23,12 @@ export class VovkCLIWatcher {
     #watchSegments = () => {
         const segmentReg = /\/?\[\[\.\.\.[a-zA-Z-_]+\]\]\/route.ts$/;
         const { cwd, log, config, apiDir } = this.#projectInfo;
-        const schemaOutFullPath = path.join(cwd, config.schemaOutDir);
-        const apiDirFullPath = path.join(cwd, apiDir);
-        const getSegmentName = (filePath) => path.relative(apiDirFullPath, filePath).replace(segmentReg, '');
-        log.debug(`Watching segments in ${apiDirFullPath}`);
+        const schemaOutAbsolutePath = path.join(cwd, config.schemaOutDir);
+        const apiDirAbsolutePath = path.join(cwd, apiDir);
+        const getSegmentName = (filePath) => path.relative(apiDirAbsolutePath, filePath).replace(segmentReg, '');
+        log.debug(`Watching segments in ${apiDirAbsolutePath}`);
         this.#segmentWatcher = chokidar
-            .watch(apiDirFullPath, {
+            .watch(apiDirAbsolutePath, {
             persistent: true,
             ignoreInitial: true,
         })
@@ -39,10 +39,9 @@ export class VovkCLIWatcher {
                 this.#segments = this.#segments.find((s) => s.segmentName === segmentName)
                     ? this.#segments
                     : [...this.#segments, { routeFilePath: filePath, segmentName }];
-                log.info(`${capitalize(formatLoggedSegmentName(segmentName, true))} has been added`);
+                log.info(`${capitalize(formatLoggedSegmentName(segmentName))} has been added`);
                 log.debug(`Full list of segments: ${this.#segments.map((s) => s.segmentName).join(', ')}`);
-                void debouncedEnsureSchemaFiles(schemaOutFullPath, this.#segments.map((s) => s.segmentName), this.#projectInfo // TODO refactor
-                );
+                void debouncedEnsureSchemaFiles(this.#projectInfo, schemaOutAbsolutePath, this.#segments.map((s) => s.segmentName));
             }
         })
             .on('change', (filePath) => {
@@ -54,7 +53,7 @@ export class VovkCLIWatcher {
             // eslint-disable-next-line @typescript-eslint/no-misused-promises
             .on('addDir', async (dirPath) => {
             log.debug(`Directory ${dirPath} has been added to segments folder`);
-            this.#segments = await locateSegments(apiDirFullPath);
+            this.#segments = await locateSegments(apiDirAbsolutePath);
             for (const { segmentName } of this.#segments) {
                 void this.#requestSchema(segmentName);
             }
@@ -62,7 +61,7 @@ export class VovkCLIWatcher {
             // eslint-disable-next-line @typescript-eslint/no-misused-promises
             .on('unlinkDir', async (dirPath) => {
             log.debug(`Directory ${dirPath} has been removed from segments folder`);
-            this.#segments = await locateSegments(apiDirFullPath);
+            this.#segments = await locateSegments(apiDirAbsolutePath);
             for (const { segmentName } of this.#segments) {
                 void this.#requestSchema(segmentName);
             }
@@ -72,10 +71,9 @@ export class VovkCLIWatcher {
             if (segmentReg.test(filePath)) {
                 const segmentName = getSegmentName(filePath);
                 this.#segments = this.#segments.filter((s) => s.segmentName !== segmentName);
-                log.info(`${capitalize(formatLoggedSegmentName(segmentName, true))} has been removed`);
+                log.info(`${formatLoggedSegmentName(segmentName, { upperFirst: true })} has been removed`);
                 log.debug(`Full list of segments: ${this.#segments.map((s) => s.segmentName).join(', ')}`);
-                void debouncedEnsureSchemaFiles(schemaOutFullPath, this.#segments.map((s) => s.segmentName), this.#projectInfo // TODO refactor
-                );
+                void debouncedEnsureSchemaFiles(this.#projectInfo, schemaOutAbsolutePath, this.#segments.map((s) => s.segmentName));
             }
         })
             .on('ready', () => {
@@ -87,10 +85,10 @@ export class VovkCLIWatcher {
     };
     #watchModules = () => {
         const { config, cwd, log } = this.#projectInfo;
-        const modulesDirFullPath = path.join(cwd, config.modulesDir);
-        log.debug(`Watching modules in ${modulesDirFullPath}`);
+        const modulesDirAbsolutePath = path.join(cwd, config.modulesDir);
+        log.debug(`Watching modules in ${modulesDirAbsolutePath}`);
         this.#modulesWatcher = chokidar
-            .watch(modulesDirFullPath, {
+            .watch(modulesDirAbsolutePath, {
             persistent: true,
             ignoreInitial: true,
         })
@@ -193,10 +191,10 @@ export class VovkCLIWatcher {
     #requestSchema = debounceWithArgs(async (segmentName) => {
         const { apiEntryPoint, log, port } = this.#projectInfo;
         const endpoint = `${apiEntryPoint.startsWith('http') ? apiEntryPoint : `http://localhost:${port}${apiEntryPoint}`}/${segmentName ? `${segmentName}/` : ''}_schema_`;
-        log.debug(`Requesting schema for ${formatLoggedSegmentName(segmentName, true)} at ${endpoint}`);
+        log.debug(`Requesting schema for ${formatLoggedSegmentName(segmentName)} at ${endpoint}`);
         const resp = await fetch(endpoint);
         if (resp.status !== 200) {
-            log.warn(`Schema request to ${formatLoggedSegmentName(segmentName, true)} failed with status code ${resp.status}. Expected 200.`);
+            log.warn(`Schema request to ${formatLoggedSegmentName(segmentName)} failed with status code ${resp.status}. Expected 200.`);
             return;
         }
         let schema = null;
@@ -204,7 +202,7 @@ export class VovkCLIWatcher {
             ({ schema } = (await resp.json()));
         }
         catch (error) {
-            log.error(`Error parsing schema for ${formatLoggedSegmentName(segmentName, true)}: ${error.message}`);
+            log.error(`Error parsing schema for ${formatLoggedSegmentName(segmentName)}: ${error.message}`);
         }
         await this.#handleSchema(schema);
     }, 500);
@@ -215,7 +213,7 @@ export class VovkCLIWatcher {
             log.warn('Segment schema is null');
             return;
         }
-        const schemaOutFullPath = path.join(cwd, config.schemaOutDir);
+        const schemaOutAbsolutePath = path.join(cwd, config.schemaOutDir);
         const segment = this.#segments.find((s) => s.segmentName === schema.segmentName);
         if (!segment) {
             log.warn(`Segment "${schema.segmentName}" not found`);
@@ -225,18 +223,18 @@ export class VovkCLIWatcher {
         if (schema.emitSchema) {
             const now = Date.now();
             const { diffResult } = await writeOneSchemaFile({
-                schemaOutFullPath,
+                schemaOutAbsolutePath,
                 schema,
                 skipIfExists: false,
             });
             const timeTook = Date.now() - now;
             if (diffResult) {
                 logDiffResult(segment.segmentName, diffResult, this.#projectInfo);
-                log.info(`Schema for ${formatLoggedSegmentName(segment.segmentName, true)} has been updated in ${timeTook}ms`);
+                log.info(`Schema for ${formatLoggedSegmentName(segment.segmentName)} has been updated in ${timeTook}ms`);
             }
         }
         else if (schema && (!isEmpty(schema.controllers) || !isEmpty(schema.workers))) {
-            log.error(`Non-empty schema provided for ${formatLoggedSegmentName(segment.segmentName, true)} but emitSchema is false`);
+            log.error(`Non-empty schema provided for ${formatLoggedSegmentName(segment.segmentName)} but emitSchema is false`);
         }
         if (this.#segments.every((s) => this.#schemas[s.segmentName])) {
             log.debug(`All segments with "emitSchema" have schema.`);
@@ -252,10 +250,10 @@ export class VovkCLIWatcher {
         process.on('unhandledRejection', (reason) => {
             log.error(`Unhandled Rejection: ${String(reason)}`);
         });
-        const apiDirFullPath = path.join(cwd, apiDir);
-        const schemaOutFullPath = path.join(cwd, config.schemaOutDir);
-        this.#segments = await locateSegments(apiDirFullPath);
-        await debouncedEnsureSchemaFiles(schemaOutFullPath, this.#segments.map((s) => s.segmentName), this.#projectInfo);
+        const apiDirAbsolutePath = path.join(cwd, apiDir);
+        const schemaOutAbsolutePath = path.join(cwd, config.schemaOutDir);
+        this.#segments = await locateSegments(apiDirAbsolutePath);
+        await debouncedEnsureSchemaFiles(this.#projectInfo, schemaOutAbsolutePath, this.#segments.map((s) => s.segmentName));
         // Request schema every segment in 3 seconds in order to update schema and start watching
         setTimeout(() => {
             for (const { segmentName } of this.#segments) {

package/dist/watcher/logDiffResult.mjs

@@ -31,43 +31,43 @@ export default function logDiffResult(segmentName, diffResult, projectInfo) {
             case 'worker':
                 switch (diffNormalizedItem.type) {
                     case 'added':
-                        projectInfo.log.info(`Schema for worker ${chalkHighlightThing(diffNormalizedItem.name)} has been added at ${formatLoggedSegmentName(segmentName, true)}`);
+                        projectInfo.log.info(`Schema for worker ${chalkHighlightThing(diffNormalizedItem.name)} has been added at ${formatLoggedSegmentName(segmentName)}`);
                         break;
                     case 'removed':
-                        projectInfo.log.info(`Schema for worker ${chalkHighlightThing(diffNormalizedItem.name)} has been removed from ${formatLoggedSegmentName(segmentName, true)}`);
+                        projectInfo.log.info(`Schema for worker ${chalkHighlightThing(diffNormalizedItem.name)} has been removed from ${formatLoggedSegmentName(segmentName)}`);
                         break;
                 }
                 break;
             case 'controller':
                 switch (diffNormalizedItem.type) {
                     case 'added':
-                        projectInfo.log.info(`Schema for controller ${chalkHighlightThing(diffNormalizedItem.name)} has been added at ${formatLoggedSegmentName(segmentName, true)}`);
+                        projectInfo.log.info(`Schema for controller ${chalkHighlightThing(diffNormalizedItem.name)} has been added at ${formatLoggedSegmentName(segmentName)}`);
                         break;
                     case 'removed':
-                        projectInfo.log.info(`Schema for controller ${chalkHighlightThing(diffNormalizedItem.name)} has been removed from ${formatLoggedSegmentName(segmentName, true)}`);
+                        projectInfo.log.info(`Schema for controller ${chalkHighlightThing(diffNormalizedItem.name)} has been removed from ${formatLoggedSegmentName(segmentName)}`);
                         break;
                 }
                 break;
             case 'workerHandler':
                 switch (diffNormalizedItem.type) {
                     case 'added':
-                        projectInfo.log.info(`Schema for worker method ${chalkHighlightThing(diffNormalizedItem.name)} has been added at ${formatLoggedSegmentName(segmentName, true)}`);
+                        projectInfo.log.info(`Schema for worker method ${chalkHighlightThing(diffNormalizedItem.name)} has been added at ${formatLoggedSegmentName(segmentName)}`);
                         break;
                     case 'removed':
-                        projectInfo.log.info(`Schema for worker method ${chalkHighlightThing(diffNormalizedItem.name)} has been removed from ${formatLoggedSegmentName(segmentName, true)}`);
+                        projectInfo.log.info(`Schema for worker method ${chalkHighlightThing(diffNormalizedItem.name)} has been removed from ${formatLoggedSegmentName(segmentName)}`);
                         break;
                 }
                 break;
             case 'controllerHandler':
                 switch (diffNormalizedItem.type) {
                     case 'added':
-                        projectInfo.log.info(`Schema for controller method ${chalkHighlightThing(diffNormalizedItem.name)} has been added at ${formatLoggedSegmentName(segmentName, true)}`);
+                        projectInfo.log.info(`Schema for controller method ${chalkHighlightThing(diffNormalizedItem.name)} has been added at ${formatLoggedSegmentName(segmentName)}`);
                         break;
                     case 'removed':
-                        projectInfo.log.info(`Schema for controller method ${chalkHighlightThing(diffNormalizedItem.name)} has been removed from ${formatLoggedSegmentName(segmentName, true)}`);
+                        projectInfo.log.info(`Schema for controller method ${chalkHighlightThing(diffNormalizedItem.name)} has been removed from ${formatLoggedSegmentName(segmentName)}`);
                         break;
                     case 'changed':
-                        projectInfo.log.info(`Schema for controller method ${chalkHighlightThing(diffNormalizedItem.name)} has been changed at ${formatLoggedSegmentName(segmentName, true)}`);
+                        projectInfo.log.info(`Schema for controller method ${chalkHighlightThing(diffNormalizedItem.name)} has been changed at ${formatLoggedSegmentName(segmentName)}`);
                         break;
                 }
                 break;

package/dist/watcher/writeOneSchemaFile.d.mts

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

package/dist/watcher/writeOneSchemaFile.mjs

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vovk-cli",
-  "version": "0.0.1-beta.18",
+  "version": "0.0.1-beta.19",
   "bin": {
     "vovk": "./dist/index.mjs"
   },
@@ -40,13 +40,18 @@
     "chokidar": "^3.6.0",
     "commander": "^12.1.0",
     "concurrently": "^8.2.2",
+    "ejs": "^3.1.10",
+    "gray-matter": "^4.0.3",
     "inflection": "^3.0.0",
     "jsonc-parser": "^3.3.1",
     "lodash": "^4.17.21",
     "loglevel": "^1.9.2",
-    "pluralize": "^8.0.0"
+    "pluralize": "^8.0.0",
+    "prettier": "^3.3.3",
+    "ts-morph": "^23.0.0"
   },
   "devDependencies": {
+    "@types/ejs": "^3.1.5",
     "@types/npmcli__package-json": "^4.0.4",
     "@types/pluralize": "^0.0.33",
     "type-fest": "^4.26.0"

package/templates/controller.ejs

@@ -0,0 +1,85 @@
+<% var modulePascalName = _.upperFirst(_.camelCase(moduleName)); %>
+<% var modulePascalNamePlural = pluralize(modulePascalName); %>
+<% var ControllerName = modulePascalName + 'Controller'; %>
+<% var RPCName = modulePascalName + 'RPC'; %>
+<% var ServiceName = modulePascalName + 'Service'; %>
+---
+# Relative to modules dir
+fileName: <%= getFileDir(segmentName, moduleName) + ControllerName + '.ts' %>
+className: <%= ControllerName %> # Used to define a controller in a segment
+rpcName: <%= RPCName %> # Used to define an exported RPC class in a segment
+---
+
+import { prefix, get, put, post, del<%= !config.validationLibrary ? ', type VovkRequest' : '' %> } from 'vovk';
+<% if(withService) { %>
+import <%= ServiceName %> from './<%= ServiceName %>';
+<% } %>
+<% if(config.validationLibrary === 'vovk-zod') { %>
+import { withZod } from 'vovk-zod';
+import { z } from 'zod';
+<% } %>
+
+@prefix('<%= _.kebabCase(moduleName).toLowerCase() %>')
+export default class <%= ControllerName %> {
+    @get()
+    <% if(config.validationLibrary === 'vovk-zod') { %>
+    async get<%= modulePascalNamePlural %> = withZod(null, z.object({ q: z.string() }), (req) => {
+        const q = req.nextUrl.searchParams.get('q');
+        <% if(withService) { %>
+        return <%= ServiceName %>.getMyThingsExample(q);
+        <% } else { %>
+        return { q };
+        <% } %>
+    });
+    <% } else { %>
+    static get<%= modulePascalNamePlural %> = async (req: VovkRequest<null, { q: string }>) => {
+        const q = req.nextUrl.searchParams.get('q');
+        <% if(withService) { %>
+        return <%= ServiceName %>.getMyThingsExample(q);
+        <% } else { %>
+        return { q };
+        <% } %>
+    }
+    <% } %>
+
+    @put(':id')
+    <% if(config.validationLibrary === 'vovk-zod') { %>
+    static update<%= modulePascalNamePlural %> = withZod(
+        z.object({
+        foo: z.union([z.literal('bar'), z.literal('baz')]),
+        }),
+        z.object({ q: z.string() }),
+        async (req, params: { id: string }) => {
+        const { id } = params;
+        const body = await req.json();
+        const q = req.nextUrl.searchParams.get('q');
+        <% if(withService) { %>
+        return MyThingService.updateMyThingExample(id, q, body);
+        <% } else { %>
+        return { id, body, q };
+        <% } %>
+        }
+    );
+    <% } else { %>
+    static update<%= modulePascalNamePlural %> = async (req: VovkRequest<{ foo: 'bar' | 'baz' }, { q: string }>, params: { id: string }) => {
+        const { id } = params;
+        const body = await req.json();
+        const q = req.nextUrl.searchParams.get('q');
+        <% if(withService) { %>
+        return MyThingService.updateMyThingExample(id, q, body);
+        <% } else { %>
+        return { id, body, q };
+        <% } %>
+    };
+    <% } %>
+
+    @post()
+    static create<%= modulePascalNamePlural %> = () => {
+        // ...
+    };
+
+    @del(':id')
+    static delete<%= modulePascalNamePlural %> = () => {
+        // ...
+    };
+}

package/templates/service.ejs

@@ -0,0 +1,9 @@
+<% var modulePascalName = _.upperFirst(_.camelCase(moduleName); %>
+<% var ServiceName = modulePascalName + 'Service'; %>
+
+---
+# Relative to modules dir
+fileName: <%= getFileDir(segmentName, moduleName) + ServiceName + '.ts' %>
+---
+
+// TO DO: Implement <%= ServiceName %>

package/templates/worker.ejs

@@ -0,0 +1,9 @@
+<% var modulePascalName = _.upperFirst(_.camelCase(moduleName); %>
+<% var WorkerName = modulePascalName + 'Worker'; %>
+
+---
+# Relative to modules dir
+fileName: <%= getFileDir(segmentName, moduleName) + WorkerName + '.ts' %>
+---
+
+// TO DO: Implement <%= WorkerName %>

package/templates/zod/MyThingController.c.only.template.ts

@@ -0,0 +1,32 @@
+import { prefix, get, put, post, del, type VovkRequest } from 'vovk';
+
+@prefix('my-thing')
+export default class MyThingController {
+  @get()
+  static getMyThingsExample = (req: VovkRequest<null, { q: string }>) => {
+    const q = req.nextUrl.searchParams.get('q');
+    return { q };
+  };
+
+  @put(':id')
+  static updateMyThingExample = async (
+    req: VovkRequest<{ foo: 'bar' | 'baz' }, { q: string }>,
+    params: { id: string }
+  ) => {
+    const { id } = params;
+    const body = await req.json();
+    const q = req.nextUrl.searchParams.get('q');
+
+    return { id, q, body };
+  };
+
+  @post()
+  static createMyThingExample = () => {
+    // ...
+  };
+
+  @del(':id')
+  static deleteMyThingExample = () => {
+    // ...
+  };
+}

package/templates/zod/MyThingController.c.template.ts

@@ -0,0 +1,39 @@
+import { prefix, get, put, post, del } from 'vovk';
+import { z } from 'zod';
+import { withZod } from 'vovk-zod';
+import MyThingService from './MyThingService.s.template';
+
+@prefix('my-thing')
+export default class MyThingController {
+  @get()
+  static getMyThingsExample = withZod(null, z.object({ q: z.string() }), (req) => {
+    const q = req.nextUrl.searchParams.get('q');
+
+    return MyThingService.getMyThingsExample(q);
+  });
+
+  @put(':id')
+  static updateMyThingExample = withZod(
+    z.object({
+      foo: z.union([z.literal('bar'), z.literal('baz')]),
+    }),
+    z.object({ q: z.string() }),
+    async (req, params: { id: string }) => {
+      const { id } = params;
+      const body = await req.json();
+      const q = req.nextUrl.searchParams.get('q');
+
+      return MyThingService.updateMyThingExample(id, q, body);
+    }
+  );
+
+  @post()
+  static async createMyThingExample() {
+    // ...
+  }
+
+  @del(':id')
+  static deleteMyThingExample() {
+    // ...
+  }
+}

package/templates/zod/MyThingService.s.template.ts

@@ -0,0 +1,18 @@
+import type { VovkControllerBody, VovkControllerQuery } from 'vovk';
+import type MyThingController from './MyThingController.c.template';
+
+export default class MyThingService {
+  static getMyThingsExample = (q: VovkControllerQuery<typeof MyThingController.getMyThingsExample>['q']) => {
+    return { q };
+  };
+
+  static updateMyThingExample = (
+    id: string,
+    q: VovkControllerQuery<typeof MyThingController.updateMyThingExample>['q'],
+    body: VovkControllerBody<typeof MyThingController.updateMyThingExample>
+  ) => {
+    return { id, q, body };
+  };
+
+  // ...
+}

package/dist/generate/replaceOccurrences.d.mts

@@ -1 +0,0 @@
-export default function replaceOccurrences(code: string, replacementSingular: string): string;

package/dist/generate/replaceOccurrences.mjs

@@ -1,49 +0,0 @@
-import camelCase from 'lodash/camelCase.js';
-import kebabCase from 'lodash/kebabCase.js';
-import snakeCase from 'lodash/snakeCase.js';
-import upperFirst from 'lodash/upperFirst.js';
-import pluralize from 'pluralize';
-import addCommonTerms from './addCommonTerms';
-addCommonTerms();
-console.log('WoRD', pluralize('entity'));
-export default function replaceOccurrences(code, replacementSingular) {
-    const replacementPlural = pluralize(replacementSingular);
-    // Different cases of the replacement string
-    const replacements = {
-        camelPlural: camelCase(replacementPlural),
-        camel: camelCase(replacementSingular),
-        pascalPlural: upperFirst(camelCase(replacementPlural)),
-        pascal: upperFirst(camelCase(replacementSingular)),
-        kebabPlural: kebabCase(replacementPlural),
-        kebab: kebabCase(replacementSingular),
-        snakePlural: snakeCase(replacementPlural),
-        snake: snakeCase(replacementSingular),
-        screamingSnakePlural: snakeCase(replacementPlural).toUpperCase(),
-        screamingSnake: snakeCase(replacementSingular).toUpperCase(),
-        screamingKebabPlural: kebabCase(replacementPlural).toUpperCase(),
-        screamingKebab: kebabCase(replacementSingular).toUpperCase(),
-    };
-    // Create a map of original patterns to their replacements
-    const originalPatterns = {
-        camelPlural: 'myThings',
-        camel: 'myThing',
-        pascalPlural: 'MyThings',
-        pascal: 'MyThing',
-        kebabPlural: 'my-things',
-        kebab: 'my-thing',
-        snakePlural: 'my_things',
-        snake: 'my_thing',
-        screamingSnakePlural: 'MY_THINGS',
-        screamingSnake: 'MY_THING',
-        screamingKebabPlural: 'MY-THINGS',
-        screamingKebab: 'MY-THING',
-    };
-    // Replace all occurrences in the code
-    Object.keys(originalPatterns).forEach((key) => {
-        const pattern = originalPatterns[key];
-        const replacementValue = replacements[key];
-        const regex = new RegExp(pattern, 'g');
-        code = code.replace(regex, replacementValue);
-    });
-    return code;
-}