vovk-cli 0.0.1-draft.7 → 0.0.1-draft.70

package/dist/new/newModule.mjs

@@ -1,11 +1,11 @@
-import path from 'path';
-import fs from 'fs/promises';
-import getProjectInfo from '../getProjectInfo/index.mjs';
+import path from 'node:path';
+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 locateSegments from '../locateSegments.mjs';
-import addClassToSegmentCode from './addClassToSegmentCode.mjs';
 import getFileSystemEntryType from '../utils/getFileSystemEntryType.mjs';
 import prettify from '../utils/prettify.mjs';
 function splitByLast(str, delimiter = '/') {
@@ -18,49 +18,61 @@ function splitByLast(str, delimiter = '/') {
     const after = str.substring(index + delimiter.length);
     return [before, after];
 }
-export default async function newModule({ what, moduleNameWithOptionalSegment, dryRun, dirName: dirNameFlag, template: templateFlag, noSegmentUpdate, overwrite, }) {
+export default async function newModule({ what, moduleNameWithOptionalSegment, dryRun, dir: dirFlag, templates: templatesFlag, noSegmentUpdate, overwrite, }) {
     const { config, log, apiDir, cwd } = await getProjectInfo();
-    const templates = config.templates;
+    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;
         }
     });
-    // check if template exists
+    if (templatesFlag) {
+        if (templatesFlag.length > what.length) {
+            throw new Error('Too many templates provided');
+        }
+        templates = templatesFlag.reduce((acc, templatePath, index) => ({
+            ...acc,
+            [what[index]]: templatePath,
+        }), templates);
+    }
     for (const type of what) {
         if (!templates[type]) {
-            throw new Error(`Template for ${type} not found in config`);
+            throw new Error(`Template for "${type}" not found`);
         }
     }
-    const segments = await locateSegments(apiDir);
+    const segments = await locateSegments({ dir: apiDir, config });
     const segment = segments.find((s) => s.segmentName === segmentName);
     if (!segment) {
-        throw new Error(`Segment ${segmentName} not found`);
+        throw new Error(`Unable to create module. Segment "${segmentName}" not found. Run "vovk new segment ${segmentName}" to create it`);
     }
     for (const type of what) {
-        const templatePath = templateFlag ?? templates[type];
+        const templatePath = templates[type];
         const templateAbsolutePath = templatePath.startsWith('/') || templatePath.startsWith('.')
             ? path.resolve(cwd, templatePath)
             : path.resolve(cwd, './node_modules', templatePath);
         const templateCode = await fs.readFile(templateAbsolutePath, 'utf-8');
-        const { dirName: renderedDirName, fileName, sourceName, compiledName, code, } = await render(templateCode, {
+        const { dir: renderedDir, fileName, sourceName, compiledName, code, } = await render(templateCode, {
             cwd,
             config,
             withService: what.includes('service'),
             segmentName,
             moduleName,
         });
-        const dirName = dirNameFlag || renderedDirName;
-        const absoluteModuleDir = path.join(cwd, config.modulesDir, dirName);
+        const dir = dirFlag || renderedDir;
+        if (!dir) {
+            throw new Error(`The template for "${type}" does not provide a dir`);
+        }
+        if (!fileName) {
+            throw new Error(`The template for "${type}" does not provide a fileName`);
+        }
+        const absoluteModuleDir = path.join(cwd, dir);
         const absoluteModulePath = path.join(absoluteModuleDir, fileName);
         const prettiedCode = await prettify(code, absoluteModulePath);
         if (!dryRun) {
@@ -70,31 +82,30 @@ export default async function newModule({ what, moduleNameWithOptionalSegment, d
             else {
                 await fs.mkdir(absoluteModuleDir, { recursive: true });
                 await fs.writeFile(absoluteModulePath, prettiedCode);
+                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('sourceName is required');
+                throw new Error(`The template for "${type}" does not provide a sourceName`);
             }
             if (!compiledName) {
-                throw new Error('compiledName is required');
+                throw new Error(`The template for "${type}" does not provide a compiledName`);
             }
             const { routeFilePath } = segment;
             const segmentSourceCode = await fs.readFile(routeFilePath, 'utf-8');
-            const importPath = path.relative(absoluteModuleDir, absoluteModulePath).replace(/\.(ts|tsx)$/, '');
+            const importPath = path.relative(path.dirname(routeFilePath), absoluteModulePath).replace(/\.(ts|tsx)$/, '');
             if (!noSegmentUpdate) {
-                const newSegmentCode = addClassToSegmentCode(segmentSourceCode, {
+                const newSegmentCode = await prettify(addClassToSegmentCode(segmentSourceCode, {
                     sourceName,
                     compiledName,
-                    type,
                     importPath,
-                });
+                }), routeFilePath);
                 if (!dryRun) {
                     await fs.writeFile(routeFilePath, newSegmentCode);
                 }
             }
-            log.info(`Added ${chalkHighlightThing(sourceName)} ${type} to ${formatLoggedSegmentName(segmentName)} as ${chalkHighlightThing(compiledName)}`);
+            log.info(`Added ${chalkHighlightThing(sourceName)} ${type} as ${chalkHighlightThing(compiledName)} to ${formatLoggedSegmentName(segmentName)}`);
         }
-        log.info(`Created ${chalkHighlightThing(fileName)} using "${chalkHighlightThing(type)}" template for ${formatLoggedSegmentName(segmentName)}`);
     }
 }

package/dist/new/newSegment.mjs

@@ -1,10 +1,11 @@
-import path from 'path';
-import fs from 'fs/promises';
+import path from 'node:path';
+import fs from 'node:fs/promises';
 import getProjectInfo from '../getProjectInfo/index.mjs';
 import getFileSystemEntryType from '../utils/getFileSystemEntryType.mjs';
 import chalkHighlightThing from '../utils/chalkHighlightThing.mjs';
 import formatLoggedSegmentName from '../utils/formatLoggedSegmentName.mjs';
 import prettify from '../utils/prettify.mjs';
+import chalk from 'chalk';
 export default async function newSegment({ segmentName, overwrite, dryRun, }) {
     const { apiDir, cwd, log } = await getProjectInfo();
     const absoluteSegmentRoutePath = path.join(cwd, apiDir, segmentName, '[[...vovk]]/route.ts');
@@ -13,15 +14,14 @@ export default async function newSegment({ segmentName, overwrite, dryRun, }) {
     }
     const code = await prettify(`import { initVovk } from 'vovk';
 
+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);
@@ -29,5 +29,7 @@ ${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(`vovk new controller ${segmentName}/someName`)} to create a controller or modify the segment file manually`);
+    log.info(`${formatLoggedSegmentName(segmentName, { upperFirst: true })} created at ${absoluteSegmentRoutePath}.`);
+    const dir = chalk.cyanBright([segmentName, 'thing'].filter(Boolean).join('/'));
+    log.info(`Run ${chalkHighlightThing(`npx vovk new service controller ${dir}`)} to create a new controller with a service at modules/${dir} folder for this segment`);
 }

package/dist/new/render.mjs

@@ -20,14 +20,11 @@ export default async function render(codeTemplate, { config, withService, segmen
         _, // 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 { dirName, fileName, sourceName, compiledName } = parsed.data;
+    const { dir, fileName, sourceName, compiledName } = parsed.data;
     const code = parsed.content;
-    // const templateContent = parsed.content; TODO
-    // const code = await ejs.render(templateContent, templateVars, { async: true });
     return {
-        dirName,
+        dir,
         fileName,
         sourceName,
         compiledName,

package/dist/postinstall.mjs

@@ -1,24 +1,21 @@
-import { promises as fs } from 'fs';
-import path from 'path';
-/**
- * Checks if a file exists at the given path.
- * @param {string} filePath - The path to the file.
- * @returns {Promise<boolean>} - A promise that resolves to true if the file exists, false otherwise.
- */
-const getFileSystemEntryType = async (filePath) => !!(await fs.stat(filePath).catch(() => false));
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import getFileSystemEntryType from './utils/getFileSystemEntryType.mjs';
 async function postinstall() {
-    const vovk = path.join(import.meta.dirname, '../../.vovk');
-    const js = path.join(vovk, 'client.js');
-    const ts = path.join(vovk, 'client.d.ts');
+    // TODO: The function doesn't consider client templates, how to do that?
+    const vovk = path.join(import.meta.dirname, '../../.vovk-client');
+    const js = path.join(vovk, 'compiled.js');
+    const ts = path.join(vovk, 'compiled.d.ts');
     const index = path.join(vovk, 'index.ts');
-    if ((await getFileSystemEntryType(js)) ||
-        (await getFileSystemEntryType(ts)) ||
-        (await getFileSystemEntryType(index))) {
-        return;
-    }
     await fs.mkdir(vovk, { recursive: true });
-    await fs.writeFile(js, '/* postinstall */');
-    await fs.writeFile(ts, '/* postinstall */');
-    await fs.writeFile(index, '/* postinstall */');
+    if (!(await getFileSystemEntryType(js))) {
+        await fs.writeFile(js, '/* postinstall */');
+    }
+    if (!(await getFileSystemEntryType(ts))) {
+        await fs.writeFile(ts, '/* postinstall */');
+    }
+    if (!(await getFileSystemEntryType(index))) {
+        await fs.writeFile(index, '/* postinstall */');
+    }
 }
 void postinstall();

package/dist/types.d.mts

@@ -1,13 +1,13 @@
-import { LogLevelNames } from 'loglevel';
+import type { LogLevelNames } from 'loglevel';
 export type KnownAny = any;
 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;
@@ -16,31 +16,70 @@ export type VovkEnv = {
     VOVK_PRETTIFY_CLIENT?: string;
     VOVK_DEV_HTTPS?: string;
     __VOVK_START_WATCHER_IN_STANDALONE_MODE__?: 'true';
+    __VOVK_EXIT__?: 'true' | 'false';
 };
 export type VovkConfig = {
     clientOutDir?: string;
     schemaOutDir?: string;
-    fetcher?: string;
-    validateOnClient?: string | null;
+    fetcherImport?: string | string[];
+    validateOnClientImport?: string | string[] | null;
+    createRPCImport?: string | string[];
     modulesDir?: string;
-    validationLibrary?: string | null;
     rootEntry?: string;
     origin?: string;
     rootSegmentModulesDirName?: string;
     logLevel?: LogLevelNames;
     prettifyClient?: boolean;
     devHttps?: boolean;
+    experimental_clientGenerateTemplateNames?: string[];
     templates?: {
         service?: string;
         controller?: string;
-        worker?: string;
         [key: string]: string | undefined;
     };
 };
+export type VovkStrictConfig = Required<Omit<VovkConfig, 'validateOnClientImport' | 'fetcherImport' | 'createRPCImport'>> & {
+    validateOnClientImport: string[] | null;
+    fetcherImport: string[];
+    createRPCImport: string[];
+};
 export type VovkModuleRenderResult = {
     fileName: string;
-    dirName: string;
+    dir: string;
     sourceName?: string;
     compiledName?: string;
     code: string;
 };
+export interface DevOptions {
+    nextDev?: boolean;
+    exit?: boolean;
+}
+export interface GenerateOptions {
+    clientOutDir?: string;
+    templates?: string[];
+    prettify?: boolean;
+    fullSchema?: string | boolean;
+}
+export interface InitOptions {
+    yes?: boolean;
+    logLevel: LogLevelNames;
+    useNpm?: boolean;
+    useYarn?: boolean;
+    usePnpm?: boolean;
+    useBun?: boolean;
+    skipInstall?: boolean;
+    updateTsConfig?: boolean;
+    updateScripts?: 'implicit' | 'explicit';
+    validationLibrary?: string | null;
+    reactQuery?: boolean;
+    validateOnClient?: boolean;
+    dryRun?: boolean;
+    channel?: 'latest' | 'beta' | 'draft';
+}
+export interface NewOptions {
+    dryRun?: boolean;
+    templates?: string[];
+    dir?: string;
+    overwrite?: boolean;
+    noSegmentUpdate?: boolean;
+}

package/dist/utils/debounceWithArgs.d.mts

@@ -1,2 +1,2 @@
 import { KnownAny } from '../types.mjs';
-export default function debounceWithArgs<T extends (...args: KnownAny[]) => KnownAny>(fn: T, wait: number): (...args: Parameters<T>) => void | Promise<void>;
+export default function debounceWithArgs<Callback extends (...args: KnownAny[]) => KnownAny>(callback: Callback, wait: number): (...args: Parameters<Callback>) => Promise<Awaited<ReturnType<Callback>>>;

package/dist/utils/debounceWithArgs.mjs

@@ -1,14 +1,29 @@
-import debounce from 'lodash/debounce.js';
-export default function debounceWithArgs(fn, wait) {
-    const debouncedFunctions = new Map();
+export default function debounceWithArgs(callback, wait) {
+    // Stores timeouts keyed by the stringified arguments
+    const timeouts = new Map();
     return (...args) => {
+        // Convert arguments to a JSON string (or any other stable key generation)
         const key = JSON.stringify(args);
-        if (!debouncedFunctions.has(key)) {
-            debouncedFunctions.set(key, debounce(fn, wait));
-        }
-        const debouncedFn = debouncedFunctions.get(key);
-        if (debouncedFn) {
-            debouncedFn(...args);
+        // Clear any existing timer for this specific key
+        if (timeouts.has(key)) {
+            clearTimeout(timeouts.get(key));
         }
+        // Return a promise that resolves/rejects after the debounce delay
+        return new Promise((resolve, reject) => {
+            const timeoutId = setTimeout(async () => {
+                try {
+                    const result = await callback(...args);
+                    resolve(result);
+                }
+                catch (error) {
+                    reject(error);
+                }
+                finally {
+                    // Remove the entry once the callback is invoked
+                    timeouts.delete(key);
+                }
+            }, wait);
+            timeouts.set(key, timeoutId);
+        });
     };
 }

package/dist/utils/formatLoggedSegmentName.mjs

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

package/dist/utils/getAvailablePort.mjs

@@ -1,4 +1,5 @@
-import net from 'net';
+import net from 'node:net';
+// Created with AI
 /**
  * Checks if a port is available.
  * @param {number} port - The port to check.
@@ -34,7 +35,7 @@ function getAvailablePort(startPort, maxAttempts, attempt, onWarning) {
                 getAvailablePort(startPort + 1, maxAttempts, attempt + 1, onWarning).then(resolve, reject);
             }
             else {
-                reject('No available ports found');
+                reject(new Error('No available ports found'));
             }
         });
     });

package/dist/utils/getFileSystemEntryType.mjs

@@ -1,4 +1,4 @@
-import fs from 'fs/promises';
+import fs from 'node:fs/promises';
 export var FileSystemEntryType;
 (function (FileSystemEntryType) {
     FileSystemEntryType["FILE"] = "FILE";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vovk-cli",
-  "version": "0.0.1-draft.7",
+  "version": "0.0.1-draft.70",
   "bin": {
     "vovk": "./dist/index.mjs"
   },
@@ -10,10 +10,13 @@
   "prefix": ".",
   "scripts": {
     "build": "rm -rf dist tsconfig.build.tsbuildinfo && tsc -P tsconfig.build.json",
+    "postbuild": "chmod +x ./dist/index.mjs",
     "build-test": "rm -rf test_dist && tsc -P tsconfig.test.json",
-    "test": "npm run build && chmod +x ./dist/index.mjs && npm run build-test && node --test --test-only test_dist/test/**/*.mjs",
-    "test_": "npm run build && chmod +x ./dist/index.mjs && NODE_OPTIONS=\"--loader ts-node/esm\" TS_NODE_PROJECT=./tsconfig.test.json node --test --test-only test/**.mts",
-    "ncu": "npm-check-updates -u",
+    "pre-test": "npm run build && npm run build-test",
+    "test-only": "npm run pre-test && node --test --test-only test_dist/test/**/*.mjs",
+    "test": "npm run pre-test && node --test --test-concurrency=1 test_dist/test/**/*.mjs",
+    "tsc": "tsc --noEmit",
+    "ncu": "npm-check-updates -u -x commander",
     "npm-publish": "npm publish"
   },
   "repository": {
@@ -33,27 +36,27 @@
   },
   "homepage": "https://vovk.dev",
   "peerDependencies": {
-    "vovk": "^3.0.0-draft.10"
+    "vovk": "^3.0.0-draft.71"
   },
   "dependencies": {
-    "@inquirer/prompts": "^7.0.1",
-    "@npmcli/package-json": "^6.0.1",
-    "chalk": "^5.3.0",
-    "chokidar": "^4.0.1",
-    "commander": "^12.1.0",
-    "concurrently": "^9.0.1",
-    "dotenv": "^16.4.5",
+    "@inquirer/prompts": "^7.3.1",
+    "@npmcli/package-json": "^6.1.1",
+    "chalk": "^5.4.1",
+    "chokidar": "^4.0.3",
+    "commander": "^13.1.0",
+    "concurrently": "^9.1.2",
+    "dotenv": "^16.4.7",
     "ejs": "^3.1.10",
     "gray-matter": "^4.0.3",
-    "inflection": "^3.0.0",
+    "inflection": "^3.0.2",
     "jsonc-parser": "^3.3.1",
     "lodash": "^4.17.21",
     "loglevel": "^1.9.2",
     "pluralize": "^8.0.0",
-    "prettier": "^3.3.3",
+    "prettier": "^3.4.2",
     "tar-stream": "^3.1.7",
-    "ts-morph": "^24.0.0",
-    "undici": "^6.20.1"
+    "ts-morph": "^25.0.0",
+    "undici": "^7.3.0"
   },
   "devDependencies": {
     "@types/concat-stream": "^2.0.3",
@@ -62,8 +65,8 @@
     "@types/pluralize": "^0.0.33",
     "@types/tar-stream": "^3.1.3",
     "concat-stream": "^2.0.0",
-    "create-next-app": "^15.0.1",
+    "create-next-app": "^15.1.6",
     "node-pty": "^1.0.0",
-    "type-fest": "^4.26.1"
+    "type-fest": "^4.33.0"
   }
 }

package/templates/controller.ejs

@@ -3,11 +3,12 @@
 <% var controllerName = modulePascalName + 'Controller'; %>
 <% var compiledName = modulePascalName + 'RPC'; %>
 <% var serviceName = modulePascalName + 'Service'; %>
+<% var prefix = pluralize(_.kebabCase(moduleName).toLowerCase()); %>
 ---
-dirName: <%= getModuleDirName(segmentName, moduleName) %> # Relative to the root dir
+dir: <%= getModuleDirName(segmentName, moduleName) %>
 fileName: <%= controllerName + '.ts' %>
-sourceName: <%= controllerName %> # Used to define import declaration in a segment route file for the given class
-compiledName: <%= compiledName %> # Used to define a compiled object name
+sourceName: <%= controllerName %>
+compiledName: <%= compiledName %>
 ---
 
 import { prefix, get, put, post, del, type VovkRequest } from 'vovk';
@@ -15,15 +16,15 @@ import { prefix, get, put, post, del, type VovkRequest } from 'vovk';
 import <%= serviceName %> from './<%= serviceName %>';
 <% } %>
 
-@prefix('<%= _.kebabCase(moduleName).toLowerCase() %>')
+@prefix('<%= prefix %>')
 export default class <%= controllerName %> {
     @get()
-    static get<%= modulePascalNamePlural %> = async (req: VovkRequest<null, { q: string }>) => {
-        const q = req.nextUrl.searchParams.get('q');
+    static get<%= modulePascalNamePlural %> = async (req: VovkRequest<null, { search: string }>) => {
+        const search = req.nextUrl.searchParams.get('search');
         <% if(withService) { %>
-        return <%= serviceName %>.get<%= modulePascalNamePlural %>(q);
+        return <%= serviceName %>.get<%= modulePascalNamePlural %>(search);
         <% } else { %>
-        return { q };
+        return { results: [], search };
         <% } %>
     }
 
@@ -33,19 +34,19 @@ export default class <%= controllerName %> {
         const body = await req.json();
         const q = req.nextUrl.searchParams.get('q');
         <% if(withService) { %>
-        return MyThingService.update<%= modulePascalName %>(id, q, body);
+        return <%= serviceName %>.update<%= modulePascalName %>(id, q, body);
         <% } else { %>
         return { id, body, q };
         <% } %>
     };
 
     @post()
-    static create<%= modulePascalNamePlural %> = () => {
+    static create<%= modulePascalName %> = () => {
         // ...
     };
 
     @del(':id')
-    static delete<%= modulePascalNamePlural %> = () => {
+    static delete<%= modulePascalName %> = () => {
         // ...
     };
 }

package/templates/service.ejs

@@ -3,22 +3,22 @@
 <% var serviceName = modulePascalName + 'Service'; %>
 <% var controllerName = modulePascalName + 'Controller'; %>
 ---
-dirName: <%= getModuleDirName(segmentName, moduleName) %> # Relative to the root dir
+dir: <%= getModuleDirName(segmentName, moduleName) %>
 fileName: <%= serviceName + '.ts' %>
 ---
 
 import type { VovkControllerBody, VovkControllerQuery } from 'vovk';
-import <%= controllerName %> from './<%= controllerName %>';
+import type <%= controllerName %> from './<%= controllerName %>';
 
 export default class <%= serviceName %> {
-  static get<%= modulePascalNamePlural %> = (q: VovkControllerQuery<typeof <%= controllerName %>.get<%= modulePascalNamePlural %>>['q']) => {
-    return [];
+  static get<%= modulePascalNamePlural %> = (search: VovkControllerQuery<typeof <%= controllerName %>.get<%= modulePascalNamePlural %>>['search']) => {
+    return { results: [], search };
   };
 
   static update<%= modulePascalName %> = (
     id: string,
-    q: VovkControllerQuery<typeof <%= controllerName %>.get<%= modulePascalNamePlural %>>['q'],
-    body: VovkControllerBody<typeof <%= controllerName %>.get<%= modulePascalNamePlural %>>
+    q: VovkControllerQuery<typeof <%= controllerName %>.update<%= modulePascalName %>>['q'],
+    body: VovkControllerBody<typeof <%= controllerName %>.update<%= modulePascalName %>>
   ) => {
     return { id, q, body };
   };

package/dist/generateClient.d.mts

@@ -1,7 +0,0 @@
-import type { ProjectInfo } from './getProjectInfo/index.mjs';
-import type { Segment } from './locateSegments.mjs';
-import type { VovkSchema } from 'vovk';
-export default function generateClient(projectInfo: ProjectInfo, segments: Segment[], segmentsSchema: Record<string, VovkSchema>): Promise<{
-    written: boolean;
-    path: string;
-}>;