vovk-cli 0.0.1-draft.47 → 0.0.1-draft.48

package/README.md

@@ -24,6 +24,6 @@ npm install -D vovk-cli
 - [vovk dev](https://vovk.dev/cli/vovk-dev) - starts the development script that watches the changes in controllers and regenerates the schema and client.
 - [vovk generate](https://vovk.dev/cli/vovk-generate) - generates the client based on the schema.
 - [vovk init](https://vovk.dev/cli/vovk-init) - initializes the Vovk.ts project.
-- [vovk new](https://vovk.dev/cli/vovk-new) - generates a new controller, service, worker or a custom module.
+- [vovk new](https://vovk.dev/cli/vovk-new) - generates a new controller, service or a custom module.
 
 For more information, please visit the [CLI documentation](https://vovk.dev/cli) or use `npx vovk-cli --help` to get the list of available commands and options.

package/client-templates/compiled/compiled.d.ts.ejs

@@ -1,24 +1,15 @@
 
 <%- '// auto-generated\n/* eslint-disable */' %>
-import type { createRPC, createWPC, VovkClientFetcher } from 'vovk';
+import type { VovkClientFetcher } from 'vovk';
 import type fetcher from '<%= fetcherClientImportPath %>';
-<% segments.forEach((segment, i) => { 
-  const hasWorkers = !!Object.keys(segmentsSchema[segment.segmentName].workers).length;
-%>
-import type { Controllers as Controllers<%= i %><% if(hasWorkers) { %>, Workers as Workers<%= i %> <% } %> } from "<%= segment.segmentImportPath %>";
-<% }) %>
+import type createRPC from '<%= createRPCImportPath %>';
+<% segments.forEach((segment, i) => { if(Object.keys(segmentsSchema[segment.segmentName].controllers).length) { %>
+  import type { Controllers as Controllers<%= i %> } from "<%= segment.segmentImportPath %>";
+  <% }}) %>
 type Options = typeof fetcher extends VovkClientFetcher<infer U> ? U : never;
 
-<% segments.forEach((segment, i) => {
-    const segSchema = segmentsSchema[segment.segmentName];
-    if (!segSchema || !segSchema.emitSchema) return;
-    const controllers = Object.keys(segSchema.controllers);
-    const workers     = Object.keys(segSchema.workers);
-%>
-  <% controllers.forEach((key) => { %>
+<% segments.forEach((segment, i) => { %>
+  <% Object.keys(segmentsSchema[segment.segmentName].controllers).forEach((key) => { %>
 export const <%= key %>: ReturnType<typeof createRPC<Controllers<%= i %>["<%= key %>"], Options>>;
   <% }) %>
-  <% workers.forEach((key) => { %>
-export const <%= key %>: ReturnType<typeof createWPC<Workers<%= i %>["<%= key %>"]>>;
-  <% }) %>
 <% }) %>

package/client-templates/compiled/compiled.js.ejs

@@ -1,25 +1,16 @@
 <%- '// auto-generated\n/* eslint-disable */' %>
-const { createRPC, createWPC } = require('vovk');
 const { default: fetcher } = require('<%= fetcherClientImportPath %>');
+const { default: createRPC } = require('<%= createRPCImportPath %>');
 const schema = require('<%= schemaOutImportPath %>');
 
 const { default: validateOnClient = null } = <%- validateOnClientImportPath ? `require('${validateOnClientImportPath}')` : '{}'%>;
 const apiRoot = '<%= apiRoot %>';
-
-<% segments.forEach((segment) => {
-    const segSchema = segmentsSchema[segment.segmentName];
-    if (!segSchema || !segSchema.emitSchema) return;
-    const controllers = Object.keys(segSchema.controllers);
-    const workers     = Object.keys(segSchema.workers);
-%>
-  <% controllers.forEach((key) => { %>
+<% segments.forEach((segment) => { %>
+  <% Object.keys(segmentsSchema[segment.segmentName].controllers).forEach((key) => { %>
 exports.<%= key %> = createRPC(
   schema['<%= segment.segmentName %>'].controllers.<%= key %>, 
   '<%= segment.segmentName %>', 
   { fetcher, validateOnClient, defaultOptions: { apiRoot } }
 );
   <% }) %>
-  <% workers.forEach((key) => { %>
-exports.<%= key %> = createWPC(schema['<%= segment.segmentName %>'].workers.<%= key %>);
-  <% }) %>
 <% }) %>

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

@@ -1,12 +1,11 @@
 <%- '// auto-generated\n/* eslint-disable */' %>
-import { createRPC, createWPC, type VovkClientFetcher } from 'vovk';
+import type { VovkClientFetcher } from 'vovk';
 import fetcher from '<%= fetcherClientImportPath %>';
+import createRPC from '<%= createRPCImportPath %>';
 import schema from '<%= schemaOutImportPath %>';
-<% segments.forEach((segment, i) => { 
-  const hasWorkers = !!Object.keys(segmentsSchema[segment.segmentName].workers).length;
-%>
-import type { Controllers as Controllers<%= i %><% if(hasWorkers) { %>, Workers as Workers<%= i %> <% } %> } from "<%= segment.segmentImportPath %>";
-<% }) %>
+<% segments.forEach((segment, i) => { if(Object.keys(segmentsSchema[segment.segmentName].controllers).length) { %>
+import type { Controllers as Controllers<%= i %> } from "<%= segment.segmentImportPath %>";
+<% }}) %>
 <% if (validateOnClientImportPath) { %>
 import validateOnClient from '<%= validateOnClientImportPath %>';
 <% } else { %>
@@ -15,22 +14,12 @@ const validateOnClient = undefined;
 type Options = typeof fetcher extends VovkClientFetcher<infer U> ? U : never;
 const apiRoot = '<%= apiRoot %>';
 
-<% segments.forEach((segment, i) => {
-    const segSchema = segmentsSchema[segment.segmentName];
-    if (!segSchema || !segSchema.emitSchema) return;
-    const hasWorkers = !!Object.keys(segmentsSchema[segment.segmentName].workers).length;
-%>
-  <% Object.keys(segSchema.controllers).forEach((key) => { %>
+<% segments.forEach((segment, i) => { %>
+  <% Object.keys(segmentsSchema[segment.segmentName].controllers).forEach((key) => { %>
 export const <%= key %> = createRPC<Controllers<%= i %>["<%= key %>"], Options>(
   schema['<%= segment.segmentName %>'].controllers.<%= key %>, 
   '<%= segment.segmentName %>', 
   { fetcher, validateOnClient, defaultOptions: { apiRoot } }
-);
-  <% }) %>
-
-  <% Object.keys(segSchema.workers).forEach((key) => { %>
-export const <%= key %> = createWPC<Workers<%= i %>["<%= key %>"]>(
-  schema['<%= segment.segmentName %>'].workers.<%= key %>
 );
   <% }) %>
 <% }) %>

package/dist/dev/diffSchema.d.mts

@@ -1,29 +1,23 @@
-import type { VovkControllerSchema, VovkWorkerSchema, VovkSchema } from 'vovk';
+import type { VovkControllerSchema, VovkSchema } from 'vovk';
 interface HandlersDiff {
     nameOfClass: string;
     added: string[];
     removed: string[];
     changed: string[];
 }
-interface WorkersOrControllersDiff {
+interface ControllersDiff {
     added: string[];
     removed: string[];
     handlers: HandlersDiff[];
 }
 export interface DiffResult {
-    workers: WorkersOrControllersDiff;
-    controllers: WorkersOrControllersDiff;
+    controllers: ControllersDiff;
 }
-export declare function diffHandlers<T extends VovkWorkerSchema['handlers'] | VovkControllerSchema['handlers']>(oldHandlers: T, newHandlers: T, nameOfClass: string): HandlersDiff;
-export declare function diffWorkersOrControllers<T extends VovkSchema['controllers'] | VovkSchema['workers']>(oldItems: T, newItems: T): WorkersOrControllersDiff;
+export declare function diffHandlers<T extends VovkControllerSchema['handlers']>(oldHandlers: T, newHandlers: T, nameOfClass: string): HandlersDiff;
+export declare function diffControllers<T extends VovkSchema['controllers']>(oldItems: T, newItems: T): ControllersDiff;
 /**
 example output:
 {
-  workers: {
-    added: ["WorkerC"],
-    removed: ["WorkerA"],
-    handlers: []
-  },
   controllers: {
     added: ["ControllerC"],
     removed: ["ControllerB"],

package/dist/dev/diffSchema.mjs

@@ -18,7 +18,7 @@ export function diffHandlers(oldHandlers, newHandlers, nameOfClass) {
     }
     return { nameOfClass, added, removed, changed };
 }
-export function diffWorkersOrControllers(oldItems, newItems) {
+export function diffControllers(oldItems, newItems) {
     const added = [];
     const removed = [];
     const handlersDiff = [];
@@ -43,11 +43,6 @@ export function diffWorkersOrControllers(oldItems, newItems) {
 /**
 example output:
 {
-  workers: {
-    added: ["WorkerC"],
-    removed: ["WorkerA"],
-    handlers: []
-  },
   controllers: {
     added: ["ControllerC"],
     removed: ["ControllerB"],
@@ -63,10 +58,7 @@ example output:
 }
 */
 export default function diffSchema(oldJson, newJson) {
-    const workersDiff = diffWorkersOrControllers(oldJson.workers ?? {}, newJson.workers ?? {});
-    const controllersDiff = diffWorkersOrControllers(oldJson.controllers ?? {}, newJson.controllers ?? {});
     return {
-        workers: workersDiff,
-        controllers: controllersDiff,
+        controllers: diffControllers(oldJson.controllers ?? {}, newJson.controllers ?? {}),
     };
 }

package/dist/dev/ensureSchemaFiles.mjs

@@ -41,7 +41,6 @@ export default segmentSchema;`;
                 emitSchema: false,
                 segmentName,
                 controllers: {},
-                workers: {},
             },
             skipIfExists: true,
         });

package/dist/dev/index.mjs

@@ -199,21 +199,17 @@ export class VovkDev {
         }
         const nameOfClasReg = /\bclass\s+([A-Za-z_]\w*)(?:\s*<[^>]*>)?\s*\{/g;
         const namesOfClasses = [...code.matchAll(nameOfClasReg)].map((match) => match[1]);
-        const importRegex = /import\s*{[^}]*\b(get|post|put|del|head|options|worker)\b[^}]*}\s*from\s*['"]vovk['"]/;
+        const importRegex = /import\s*{[^}]*\b(get|post|put|del|head|options)\b[^}]*}\s*from\s*['"]vovk['"]/;
         if (importRegex.test(code) && namesOfClasses.length) {
             const affectedSegments = this.#segments.filter((s) => {
                 const schema = this.#schemas[s.segmentName];
                 if (!schema)
                     return false;
                 const controllersByOriginalName = keyBy(schema.controllers, 'originalControllerName');
-                const workersByOriginalName = keyBy(schema.workers, 'originalWorkerName');
-                return namesOfClasses.some((name) => schema.controllers[name] ||
-                    schema.workers[name] ||
-                    controllersByOriginalName[name] ||
-                    workersByOriginalName[name]);
+                return namesOfClasses.some((name) => schema.controllers[name] || controllersByOriginalName[name]);
             });
             if (affectedSegments.length) {
-                log.debug(`A file with controller or worker ${namesOfClasses.join(', ')} have been modified at path "${filePath}". Segment(s) affected: ${JSON.stringify(affectedSegments.map((s) => s.segmentName))}`);
+                log.debug(`A file with controller ${namesOfClasses.join(', ')} have been modified at path "${filePath}". Segment(s) affected: ${JSON.stringify(affectedSegments.map((s) => s.segmentName))}`);
                 for (const segment of affectedSegments) {
                     await this.#requestSchema(segment.segmentName);
                 }
@@ -223,7 +219,7 @@ export class VovkDev {
             }
         }
         else {
-            log.debug(`The file does not contain any controller or worker`);
+            log.debug(`The file does not contain any controller`);
         }
     };
     #requestSchema = debounceWithArgs(async (segmentName) => {
@@ -283,7 +279,7 @@ export class VovkDev {
                 log.info(`Schema for ${formatLoggedSegmentName(segment.segmentName)} has been updated in ${timeTook}ms`);
             }
         }
-        else if (schema && (!isEmpty(schema.controllers) || !isEmpty(schema.workers))) {
+        else if (schema && !isEmpty(schema.controllers)) {
             log.error(`Non-empty schema provided for ${formatLoggedSegmentName(segment.segmentName)} but "emitSchema" is false`);
         }
         if (this.#segments.every((s) => this.#schemas[s.segmentName])) {

package/dist/dev/isMetadataEmpty.mjs

@@ -1,4 +1,4 @@
 import isEmpty from 'lodash/isEmpty.js';
 export default function isSchemaEmpty(schema) {
-    return isEmpty(schema.controllers) && isEmpty(schema.workers);
+    return isEmpty(schema.controllers);
 }

package/dist/dev/logDiffResult.mjs

@@ -3,23 +3,6 @@ import formatLoggedSegmentName from '../utils/formatLoggedSegmentName.mjs';
 import chalkHighlightThing from '../utils/chalkHighlightThing.mjs';
 export default function logDiffResult(segmentName, diffResult, projectInfo) {
     const diffNormalized = [];
-    diffResult.workers.added.forEach((name) => {
-        diffNormalized.push({ what: 'worker', type: 'added', name });
-    });
-    diffResult.workers.removed.forEach((name) => {
-        diffNormalized.push({ what: 'worker', type: 'removed', name });
-    });
-    diffResult.workers.handlers.forEach((handler) => {
-        handler.added.forEach((name) => {
-            diffNormalized.push({ what: 'workerHandler', type: 'added', name: `${handler.nameOfClass}.${name}` });
-        });
-        handler.removed.forEach((name) => {
-            diffNormalized.push({ what: 'workerHandler', type: 'removed', name: `${handler.nameOfClass}.${name}` });
-        });
-        handler.changed.forEach((name) => {
-            diffNormalized.push({ what: 'workerHandler', type: 'changed', name: `${handler.nameOfClass}.${name}` });
-        });
-    });
     diffResult.controllers.added.forEach((name) => {
         diffNormalized.push({ what: 'controller', type: 'added', name });
     });
@@ -43,16 +26,6 @@ export default function logDiffResult(segmentName, diffResult, projectInfo) {
     const changedText = chalk.cyan('changed');
     for (const diffNormalizedItem of diffNormalized.slice(0, LIMIT)) {
         switch (diffNormalizedItem.what) {
-            case 'worker':
-                switch (diffNormalizedItem.type) {
-                    case 'added':
-                        projectInfo.log.info(`Schema for WPC ${chalkHighlightThing(diffNormalizedItem.name)} has been ${addedText} at ${formatLoggedSegmentName(segmentName)}`);
-                        break;
-                    case 'removed':
-                        projectInfo.log.info(`Schema for WPC ${chalkHighlightThing(diffNormalizedItem.name)} has been ${removedText} from ${formatLoggedSegmentName(segmentName)}`);
-                        break;
-                }
-                break;
             case 'controller':
                 switch (diffNormalizedItem.type) {
                     case 'added':
@@ -63,16 +36,6 @@ export default function logDiffResult(segmentName, diffResult, projectInfo) {
                         break;
                 }
                 break;
-            case 'workerHandler':
-                switch (diffNormalizedItem.type) {
-                    case 'added':
-                        projectInfo.log.info(`Schema for WPC method ${chalkHighlightThing(diffNormalizedItem.name)} has been ${addedText} at ${formatLoggedSegmentName(segmentName)}`);
-                        break;
-                    case 'removed':
-                        projectInfo.log.info(`Schema for WPC method ${chalkHighlightThing(diffNormalizedItem.name)} has been ${removedText} from ${formatLoggedSegmentName(segmentName)}`);
-                        break;
-                }
-                break;
             case 'controllerHandler':
                 switch (diffNormalizedItem.type) {
                     case 'added':

package/dist/generate/index.mjs

@@ -7,7 +7,7 @@ import getClientTemplates from './getClientTemplates.mjs';
 export default async function generate({ projectInfo, segments, segmentsSchema, templates, prettify: prettifyClient, fullSchema, }) {
     templates = templates ?? projectInfo.config.experimental_clientGenerateTemplateNames;
     const noClient = templates?.[0] === 'none';
-    const { config, cwd, log, validateOnClientImportPath, apiRoot, fetcherClientImportPath, schemaOutImportPath } = projectInfo;
+    const { config, cwd, log, validateOnClientImportPath, apiRoot, fetcherClientImportPath, createRPCImportPath, schemaOutImportPath, } = projectInfo;
     const clientOutDirAbsolutePath = path.resolve(cwd, config.clientOutDir);
     const templateFiles = getClientTemplates({ config, cwd, templateNames: templates });
     // Ensure that each segment has a matching schema if it needs to be emitted:
@@ -27,6 +27,7 @@ export default async function generate({ projectInfo, segments, segmentsSchema,
         fetcherClientImportPath,
         schemaOutImportPath,
         validateOnClientImportPath,
+        createRPCImportPath,
         segments,
         segmentsSchema,
     };

package/dist/getProjectInfo/getConfig.mjs

@@ -7,9 +7,9 @@ export default async function getConfig({ clientOutDir, cwd }) {
     const srcRoot = await getRelativeSrcRoot({ cwd });
     const config = {
         modulesDir: env.VOVK_MODULES_DIR ?? conf.modulesDir ?? './' + [srcRoot, 'modules'].filter(Boolean).join('/'),
-        validateOnClient: env.VOVK_VALIDATE_ON_CLIENT ?? conf.validateOnClient ?? null,
-        validationLibrary: env.VOVK_VALIDATION_LIBRARY ?? conf.validationLibrary ?? null,
-        fetcher: env.VOVK_FETCHER ?? conf.fetcher ?? 'vovk/dist/client/defaultFetcher',
+        validateOnClientPath: env.VOVK_VALIDATE_ON_CLIENT_PATH ?? conf.validateOnClientPath ?? null,
+        fetcherPath: env.VOVK_FETCHER_PATH ?? conf.fetcherPath ?? 'vovk/dist/client/defaultFetcher',
+        createRPCPath: env.VOVK_CREATE_RPC_PATH ?? conf.createRPCPath ?? 'vovk/dist/client/createRPC',
         schemaOutDir: env.VOVK_SCHEMA_OUT_DIR ?? conf.schemaOutDir ?? './.vovk-schema',
         clientOutDir: clientOutDir ?? env.VOVK_CLIENT_OUT_DIR ?? conf.clientOutDir ?? './node_modules/.vovk-client',
         origin: (env.VOVK_ORIGIN ?? conf.origin ?? '').replace(/\/$/, ''), // Remove trailing slash
@@ -22,7 +22,6 @@ export default async function getConfig({ clientOutDir, cwd }) {
         templates: {
             service: 'vovk-cli/templates/service.ejs',
             controller: 'vovk-cli/templates/controller.ejs',
-            worker: 'vovk-cli/templates/worker.ejs',
             ...conf.templates,
         },
     };

package/dist/getProjectInfo/index.d.mts

@@ -11,6 +11,7 @@ export default function getProjectInfo({ port: givenPort, clientOutDir, cwd, }?:
     srcRoot: string;
     schemaOutImportPath: string;
     fetcherClientImportPath: string;
+    createRPCImportPath: string;
     validateOnClientImportPath: string | null;
     config: Required<import("../types.mjs").VovkConfig>;
     log: {

package/dist/getProjectInfo/index.mjs

@@ -9,12 +9,15 @@ export default async function getProjectInfo({ port: givenPort, clientOutDir, cw
     const apiRoot = `${config.origin ?? ''}/${config.rootEntry}`;
     const apiDir = path.join(srcRoot, 'app', config.rootEntry);
     const schemaOutImportPath = path.relative(config.clientOutDir, config.schemaOutDir).replace(/\\/g, '/'); // windows fix
-    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 fetcherClientImportPath = config.fetcherPath.startsWith('.')
+        ? path.relative(config.clientOutDir, config.fetcherPath)
+        : config.fetcherPath;
+    const createRPCImportPath = config.createRPCPath.startsWith('.')
+        ? path.relative(config.clientOutDir, config.createRPCPath)
+        : config.createRPCPath;
+    const validateOnClientImportPath = config.validateOnClientPath?.startsWith('.')
+        ? path.relative(config.clientOutDir, config.validateOnClientPath)
+        : config.validateOnClientPath;
     const log = getLogger(config.logLevel);
     if (configAbsolutePaths.length > 1) {
         log.warn(`Multiple config files found. Using the first one: ${configAbsolutePaths[0]}`);
@@ -30,6 +33,7 @@ export default async function getProjectInfo({ port: givenPort, clientOutDir, cw
         srcRoot,
         schemaOutImportPath,
         fetcherClientImportPath,
+        createRPCImportPath,
         validateOnClientImportPath,
         config,
         log,

package/dist/index.mjs

@@ -19,9 +19,9 @@ initProgram(program.command('init'));
 program
     .command('dev')
     .alias('d')
-    .description('Start schema watcher (optional flag --next-dev to start it with Next.js)')
-    .option('--next-dev', 'Start schema watcher and Next.js with automatic port allocation')
-    .option('--exit', 'Kill the processe when schema and client is generated')
+    .description('start schema watcher (optional flag --next-dev to start it with Next.js)')
+    .option('--next-dev', 'start schema watcher and Next.js with automatic port allocation')
+    .option('--exit', 'kill the processe when schema and client is generated')
     .allowUnknownOption(true)
     .action(async (options, command) => {
     const { nextDev, exit = false } = options;
@@ -31,8 +31,8 @@ program
         : process.env.PORT ||
             (await getAvailablePort(3000, portAttempts, 0, (failedPort, tryingPort) => 
             // eslint-disable-next-line no-console
-            console.warn(`🐺 Next.js Port ${failedPort} is in use, trying ${tryingPort} instead.`)).catch(() => {
-                throw new Error(`🐺 ❌ Failed to find available Next port after ${portAttempts} attempts`);
+            console.warn(`🐺 Port ${failedPort} is in use, trying ${tryingPort} instead.`)).catch(() => {
+                throw new Error(`🐺 ❌ Failed to find an available port after ${portAttempts} attempts`);
             }));
     if (!PORT) {
         throw new Error('🐺 ❌ PORT env variable is required');
@@ -73,10 +73,10 @@ program
     .command('generate')
     .alias('g')
     .description('Generate client')
-    .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('--full-schema [fileName]', 'Generate client with full schema')
-    .option('--prettify', 'Prettify output files')
+    .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('--full-schema [fileName]', 'generate client with full schema')
+    .option('--prettify', 'prettify output files')
     .action(async (options) => {
     const { clientOutDir, templates, prettify, fullSchema } = options;
     const projectInfo = await getProjectInfo({ clientOutDir });
@@ -90,12 +90,12 @@ program
 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('-o, --overwrite', 'Overwrite existing files')
-    .option('--template, --templates <templates...>', 'Override config template. Accepts an array of strings that correspond the order of the components')
-    .option('--dir <dirname>', 'Override dirName in template file. Relative to the root of the project')
-    .option('--no-segment-update', 'Do not update segment files when creating a new module')
-    .option('--dry-run', 'Do not write files to disk')
+    .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('-o, --overwrite', 'overwrite existing files')
+    .option('--template, --templates <templates...>', 'override config template; accepts an array of strings that correspond the order of the components')
+    .option('--dir <dirname>', 'override dirName in template file; relative to the root of the project')
+    .option('--no-segment-update', 'do not update segment files when creating a new module')
+    .option('--dry-run', 'do not write files to disk')
     .action((components, options) => newComponents(components, options));
 program
     .command('help')

package/dist/init/createConfig.mjs

@@ -14,12 +14,10 @@ export default async function createConfig({ root, log, options: { validationLib
     const templates = {
         controller: 'vovk-cli/templates/controller.ejs',
         service: 'vovk-cli/templates/service.ejs',
-        worker: 'vovk-cli/templates/worker.ejs',
     };
     if (validationLibrary) {
-        config.validationLibrary = validationLibrary;
         if (validateOnClient) {
-            config.validateOnClient = `${validationLibrary}/validateOnClient`;
+            config.validateOnClientPath = `${validationLibrary}/validateOnClient`;
         }
         try {
             const validationTemplates = await getTemplateFilesFromPackage(validationLibrary, channel);

package/dist/new/addClassToSegmentCode.d.mts

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

package/dist/new/addClassToSegmentCode.mjs

@@ -1,5 +1,5 @@
 import { Project, QuoteKind, SyntaxKind } from 'ts-morph';
-export default function addClassToSegmentCode(segmentSourceCode, { sourceName, compiledName, type, importPath, }) {
+export default function addClassToSegmentCode(segmentSourceCode, { sourceName, compiledName, importPath, }) {
     const project = new Project({
         manipulationSettings: {
             quoteKind: QuoteKind.Single,
@@ -16,8 +16,8 @@ export default function addClassToSegmentCode(segmentSourceCode, { sourceName, c
             moduleSpecifier: importPath,
         });
     }
-    // Get the variable declaration for controllers or workers
-    const variableDeclaration = sourceFile.getVariableDeclaration(`${type}s`);
+    // Get the variable declaration for controllers
+    const variableDeclaration = sourceFile.getVariableDeclaration('controllers');
     if (variableDeclaration) {
         const initializer = variableDeclaration.getInitializer();
         if (initializer && initializer.getKind() === SyntaxKind.ObjectLiteralExpression) {

package/dist/new/newModule.mjs

@@ -22,15 +22,13 @@ export default async function newModule({ what, moduleNameWithOptionalSegment, d
     const { config, log, apiDir, cwd } = await getProjectInfo();
     let templates = config.templates;
     const [segmentName, moduleName] = splitByLast(moduleNameWithOptionalSegment);
-    // replace c by controller, s by service, w by worker, everything else keeps the same
+    // replace c by controller, s by service, 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;
         }
@@ -87,12 +85,12 @@ export default async function newModule({ what, moduleNameWithOptionalSegment, d
                 log.info(`Created ${chalkHighlightThing(fileName)} using ${chalkHighlightThing(`"${type}"`)} template for ${formatLoggedSegmentName(segmentName)}`);
             }
         }
-        if (type === 'controller' || type === 'worker') {
+        if (type === 'controller') {
             if (!sourceName) {
                 throw new Error(`The template for "${type}" does not provide a sourceName`);
             }
             if (!compiledName) {
-                throw new Error('The template for "${type}" does not provide a compiledName');
+                throw new Error(`The template for "${type}" does not provide a compiledName`);
             }
             const { routeFilePath } = segment;
             const segmentSourceCode = await fs.readFile(routeFilePath, 'utf-8');
@@ -101,7 +99,6 @@ export default async function newModule({ what, moduleNameWithOptionalSegment, d
                 const newSegmentCode = await prettify(addClassToSegmentCode(segmentSourceCode, {
                     sourceName,
                     compiledName,
-                    type,
                     importPath,
                 }), routeFilePath);
                 if (!dryRun) {

package/dist/new/newSegment.mjs

@@ -16,14 +16,11 @@ export default async function newSegment({ segmentName, overwrite, dryRun, }) {
 export const runtime = 'edge';
 
 const controllers = {};
-const workers = {};
 
 export type Controllers = typeof controllers;
-export type Workers = typeof workers;
 
 export const { GET, POST, PATCH, PUT, HEAD, OPTIONS, DELETE } = initVovk({
 ${segmentName ? `  segmentName: '${segmentName}',\n` : ''}  emitSchema: true,
-  workers,
   controllers,
 });
 `, absoluteSegmentRoutePath);
@@ -31,5 +28,6 @@ ${segmentName ? `  segmentName: '${segmentName}',\n` : ''}  emitSchema: true,
         await fs.mkdir(path.dirname(absoluteSegmentRoutePath), { recursive: true });
         await fs.writeFile(absoluteSegmentRoutePath, code);
     }
-    log.info(`${formatLoggedSegmentName(segmentName, { upperFirst: true })} created at ${absoluteSegmentRoutePath}. Run ${chalkHighlightThing(`npx vovk n s c ${[segmentName, 'thing'].filter(Boolean).join('/')}`)} to create a new controller with service.`);
+    log.info(`${formatLoggedSegmentName(segmentName, { upperFirst: true })} created at ${absoluteSegmentRoutePath}.`);
+    log.info(`Run ${chalkHighlightThing(`npx vovk new service controller ${[segmentName, 'thing'].filter(Boolean).join('/')}`)} to create a new controller with a service at /modules/thing/ folder.`);
 }

package/dist/types.d.mts

@@ -4,10 +4,10 @@ export type VovkEnv = {
     PORT?: string;
     VOVK_CLIENT_OUT_DIR?: string;
     VOVK_SCHEMA_OUT_DIR?: string;
-    VOVK_FETCHER?: string;
-    VOVK_VALIDATE_ON_CLIENT?: string;
+    VOVK_FETCHER_PATH?: string;
+    VOVK_VALIDATE_ON_CLIENT_PATH?: string;
+    VOVK_CREATE_RPC_PATH?: string;
     VOVK_MODULES_DIR?: string;
-    VOVK_VALIDATION_LIBRARY?: string;
     VOVK_ORIGIN?: string;
     VOVK_ROOT_ENTRY?: string;
     VOVK_API_ENTRY_POINT?: string;
@@ -21,10 +21,10 @@ export type VovkEnv = {
 export type VovkConfig = {
     clientOutDir?: string;
     schemaOutDir?: string;
-    fetcher?: string;
-    validateOnClient?: string | null;
+    fetcherPath?: string;
+    validateOnClientPath?: string | null;
+    createRPCPath?: string;
     modulesDir?: string;
-    validationLibrary?: string | null;
     rootEntry?: string;
     origin?: string;
     rootSegmentModulesDirName?: string;
@@ -35,7 +35,6 @@ export type VovkConfig = {
     templates?: {
         service?: string;
         controller?: string;
-        worker?: string;
         [key: string]: string | undefined;
     };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vovk-cli",
-  "version": "0.0.1-draft.47",
+  "version": "0.0.1-draft.48",
   "bin": {
     "vovk": "./dist/index.mjs"
   },
@@ -36,10 +36,10 @@
   },
   "homepage": "https://vovk.dev",
   "peerDependencies": {
-    "vovk": "^3.0.0-draft.53"
+    "vovk": "^3.0.0-draft.57"
   },
   "dependencies": {
-    "@inquirer/prompts": "^7.2.3",
+    "@inquirer/prompts": "^7.3.1",
     "@npmcli/package-json": "^6.1.1",
     "chalk": "^5.4.1",
     "chokidar": "^4.0.3",

package/templates/worker.ejs

@@ -1,24 +0,0 @@
-<% var modulePascalName = _.upperFirst(_.camelCase(moduleName)); %>
-<% var modulePascalNamePlural = pluralize(modulePascalName); %>
-<% var workerName = modulePascalName + 'Worker'; %>
-<% var compiledName = modulePascalName + 'WPC'; %>
----
-dir: <%= getModuleDirName(segmentName, moduleName) %>
-fileName: <%= workerName + '.ts' %>
-sourceName: <%= workerName %>
-compiledName: <%= compiledName %>
----
-import { worker } from 'vovk';
-
-@worker()
-export default class <%= workerName %> {
-    static heavyComputation = () => {
-       return 'Hello, World';
-    };
-
-    static heavyComputationGenerator = function* () {
-        for(const str of ['Hello', 'World'] as const) {
-            yield str;
-        }
-    };
-}