vovk 0.2.3-beta.6 → 0.2.3-beta.60

package/Segment.js

@@ -39,6 +39,9 @@ class _Segment {
     #callMethod = async (httpMethod, req, params) => {
         const controllers = this._routes[httpMethod];
         const methodParams = {};
+        if (params[Object.keys(params)[0]]?.[0] === '__ping') {
+            return this.#respond(200, { message: 'pong' });
+        }
         // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
         const handlers = Object.fromEntries([...controllers.entries()]
             .map(([controller, staticMethods]) => {

package/cli/.eslintrc.js

@@ -7,6 +7,6 @@ module.exports = {
         '@typescript-eslint/no-unsafe-call': 'off',
         '@typescript-eslint/no-unsafe-member-access': 'off',
         '@typescript-eslint/no-unsafe-return': 'off',
-        'no-console': ['error', { allow: ['info', 'error'] }]
+        'no-console': ['error', { allow: ['info', 'error', 'warn'] }]
     }
 }

package/cli/generateClient.js

@@ -1,54 +1,97 @@
+// @ts-check
 const fs = require('fs/promises');
 const path = require('path');
-const getVovkrc = require('./getVovkrc');
+
+function canRequire(moduleName) {
+  try {
+    require.resolve(moduleName);
+    return true; // The module exists and can be required
+  } catch (e) {
+    return false; // The module does not exist
+  }
+}
+
 /**
- * Generates client code with string concatenation so it should be super fast
- * @type {(rcPath: string) => Promise<void>}
+ * Generates client code with string concatenation so it should be much faster than using AST
+ * TODO: Check fetcher and streamFetcher for existence
+ * @type {(rcPath: import('../src').VovkEnv) => Promise<boolean>}
  */
-async function generateClient(rcPath) {
-  const vovkrc = getVovkrc(rcPath);
+async function generateClient({ ...env }) {
+  const jsonPath = '../../.vovk.json';
+  const localJsonPath = path.join('..', jsonPath);
+  const fetcherPath = env.VOVK_FETCHER.startsWith('.') ? path.join('../..', env.VOVK_FETCHER) : env.VOVK_FETCHER;
+
+  const streamFetcherPath = env.VOVK_STREAM_FETCHER.startsWith('.')
+    ? path.join('../..', env.VOVK_STREAM_FETCHER)
+    : env.VOVK_STREAM_FETCHER;
+  const validatePath = env.VOVK_VALIDATE_ON_CLIENT.startsWith('.')
+    ? path.join(__dirname, '../..', env.VOVK_VALIDATE_ON_CLIENT)
+    : env.VOVK_VALIDATE_ON_CLIENT;
+  const localValidatePath = env.VOVK_VALIDATE_ON_CLIENT.startsWith('.') ? path.join('..', validatePath) : validatePath;
+
+  if (!env.VOVK_VALIDATE_ON_CLIENT) {
+    env.VOVK_VALIDATE_ON_CLIENT = canRequire('vovk-zod/zodValidateOnClient') ? 'vovk-zod/zodValidateOnClient' : '';
+  } else if (env.VOVK_VALIDATE_ON_CLIENT && !canRequire(localValidatePath)) {
+    throw new Error(
+      `Unble to generate Vovk Client: cannot find "validateOnClient" module '${env.VOVK_VALIDATE_ON_CLIENT}'. Check your .vovkrc.js file`
+    );
+  }
 
-  const fetcherPath = vovkrc.fetcher.startsWith('.') ? path.join(process.cwd(), vovkrc.fetcher) : vovkrc.fetcher;
-  const streamFetcherPath = vovkrc.streamFetcher.startsWith('.')
-    ? path.join(process.cwd(), vovkrc.streamFetcher)
-    : vovkrc.streamFetcher;
+  if (!canRequire(localJsonPath)) {
+    throw new Error(`Unble to generate Vovk Client: cannot find ".vovk.json" file '${jsonPath}'.`);
+  }
 
-  const controllersPath = path.join('..', vovkrc.route).replace(/\.ts$/, '');
-  let ts = `import type { Controllers } from "${controllersPath}";
+  const controllersPath = path.join('../..', env.VOVK_ROUTE).replace(/\.ts$/, '');
+  let ts = `/* auto-generated */
+import type { Controllers, Workers } from "${controllersPath}";
 import type { clientizeController } from 'vovk/client';
 import type { promisifyWorker } from 'vovk/worker';
-import type { VovkFetcherOptions } from 'vovk/client';
+import type { VovkClientFetcher } from 'vovk/client';
 import type fetcher from '${fetcherPath}';
 
-type Options = typeof fetcher extends VovkFetcherOptions<infer U> ? U : never;
+type Options = typeof fetcher extends VovkClientFetcher<infer U> ? U : never;
 `;
-  let js = `const { clientizeController } = require('vovk/client');
+  let js = `/* auto-generated */
+const { clientizeController } = require('vovk/client');
 const { promisifyWorker } = require('vovk/worker');
-const metadata = require('./vovk-metadata.json');
-const fetcher = require('${fetcherPath}');
-const streamFetcher = require('${streamFetcherPath}');
-const prefix = '${vovkrc.prefix ?? '/api'}';
-const validateOnClient = ${vovkrc.validateOnClient ? `require('${vovkrc.validateOnClient}')` : 'null'};
+const metadata = require('${jsonPath}');
+const { default: fetcher } = require('${fetcherPath}');
+const { default: streamFetcher } = require('${streamFetcherPath}');
+const prefix = '${env.VOVK_PREFIX ?? '/api'}';
+const { default: validateOnClient = null } = ${
+    env.VOVK_VALIDATE_ON_CLIENT ? `require('${env.VOVK_VALIDATE_ON_CLIENT}')` : '{}'
+  };
 
 `;
-  const metadataJson = await fs
-    .readFile(path.join(__dirname, '../../.vovk/vovk-metadata.json'), 'utf-8')
-    .catch(() => null);
+  const metadataJson = await fs.readFile(path.join(__dirname, localJsonPath), 'utf-8').catch(() => null);
   const metadata = JSON.parse(metadataJson || '{}');
 
   for (const key of Object.keys(metadata)) {
     if (key !== 'workers') {
-      ts += `export type ${key} = ReturnType<typeof clientizeController<Controllers["${key}"], Options>>;\n`;
+      ts += `export const ${key}: ReturnType<typeof clientizeController<Controllers["${key}"], Options>>;\n`;
       js += `exports.${key} = clientizeController(metadata.${key}, { fetcher, streamFetcher, validateOnClient, defaultOptions: { prefix } });\n`;
     }
   }
 
-  /* for(const key of Object.keys(metadata.workers ?? {})) {
-    code += `export const ${key} = promisifyWorker<${key}>(metadata.workers.${key});\n`;
-} */
-  await fs.mkdir('../../.vovk');
-  await fs.writeFile(path.join(__dirname, '../../.vovk/index.d.ts'), ts);
-  await fs.writeFile(path.join(__dirname, '../../.vovk/index.js'), js);
+  for (const key of Object.keys(metadata.workers ?? {})) {
+    ts += `export const ${key}: ReturnType<typeof promisifyWorker<Workers["${key}"]>>;\n`;
+    js += `exports.${key} = promisifyWorker(null, metadata.workers.${key});\n`;
+  }
+
+  js += `
+if(typeof window !== 'undefined') fetch(prefix + '/__ping', { method: 'POST' });
+  `;
+
+  const jsPath = path.join(__dirname, '../../.vovk/index.js');
+  const tsPath = path.join(__dirname, '../../.vovk/index.d.ts');
+  await fs.mkdir('../../.vovk', { recursive: true });
+  const existingJs = await fs.readFile(jsPath, 'utf-8').catch(() => '');
+  const existingTs = await fs.readFile(tsPath, 'utf-8').catch(() => '');
+  if (existingJs === js && existingTs === ts) return false;
+  await fs.writeFile(tsPath, ts);
+  await fs.writeFile(jsPath, js);
+
+  return true;
 }
 
 module.exports = generateClient;

package/cli/getVars.js

@@ -0,0 +1,29 @@
+// @ts-check
+/** @type {(rcPath: string) => import('../src').VovkEnv} */
+function getVars(rcPath) {
+  /** @type {Required<import('../src').VovkRc>} */
+  const vovkRc = {
+    route: 'src/app/api/[[...]]/route.ts',
+    fetcher: 'vovk/client/defaultFetcher',
+    streamFetcher: 'vovk/client/defaultStreamFetcher',
+    prefix: '/api',
+    validateOnClient: '',
+  };
+
+  try {
+    Object.assign(vovkRc, require(rcPath));
+  } catch {
+    console.info(` 🐺 No .vovkrc.js file found in the root directory`);
+  }
+
+  return {
+    VOVK_PORT: process.env.VOVK_PORT || '3420',
+    VOVK_ROUTE: process.env.VOVK_ROUTE || vovkRc.route,
+    VOVK_FETCHER: process.env.VOVK_FETCHER || vovkRc.fetcher,
+    VOVK_STREAM_FETCHER: process.env.VOVK_STREAM_FETCHER || vovkRc.streamFetcher,
+    VOVK_PREFIX: process.env.VOVK_PREFIX || vovkRc.prefix,
+    VOVK_VALIDATE_ON_CLIENT: process.env.VOVK_VALIDATE_ON_CLIENT || vovkRc.validateOnClient,
+  };
+}
+
+module.exports = getVars;

package/cli/index.js

@@ -1,9 +1,12 @@
 #!/usr/bin/env node
+// @ts-check
 const yargs = require('yargs/yargs');
 const { hideBin } = require('yargs/helpers');
-const { concurrently } = require('concurrently');
 const generateClient = require('./generateClient');
 const path = require('path');
+const concurrent = require('./lib/concurrent');
+const getAvailablePort = require('./lib/getAvailablePort');
+const getVars = require('./getVars');
 
 const builder = {
   rc: {
@@ -17,61 +20,63 @@ const builder = {
     default: process.cwd(),
     describe: 'Path to Next.js project',
   },
-
-  output: {
-    type: 'string',
-    default: path.join(__dirname, '../.vovk/index.d.ts'),
-    describe: 'Path to the wildcard route file',
-  },
 };
 
-const options = {
-  outputStream: process.stdout,
-  raw: true,
-  killOthers: ['failure', 'success'],
-};
-/** @type {{ rc: string, project: string, output: string }} */
-const argv = yargs(hideBin(process.argv))
-  .command('dev', 'Run development server', builder)
-  .command('build', 'Build the app', builder)
+/** @type {{ vovkrc: string, project: string }} */
+// @ts-expect-error yargs
+const argv = yargs(hideBin(process.argv)) // @ts-expect-error yargs
+  .command('dev', 'Run development server', builder) // @ts-expect-error yargs
+  .command('build', 'Build the app', builder) // @ts-expect-error yargs
   .command('generate', 'Generate client', builder).argv;
 
 const nextArgs = process.argv.join(' ').split(' -- ')[1] ?? '';
 
-if (argv._.includes('dev')) {
-  const { result } = concurrently(
-    [
-      { command: `node ${__dirname}/server.js`, name: 'Vovk' },
-      { command: `node ${__dirname}/watchMetadata.js --rc ${argv.rc} --output ${argv.output}`, name: 'Watch metadata' },
-      { command: `cd ${argv.project} && npx next dev ${nextArgs}`, name: 'Next' },
-    ],
-    options
-  );
+const env = getVars(argv.vovkrc);
 
-  void result.then(() => {
-    console.info(' 🐺 All processes have completed.');
-  });
+let VOVK_PORT = parseInt(env.VOVK_PORT);
+
+// @ts-expect-error yargs
+if (argv._.includes('dev')) {
+  void (async () => {
+    env.VOVK_PORT = await getAvailablePort(VOVK_PORT, 20).catch(() => {
+      throw new Error(' 🐺 Failed to find available port');
+    });
+    await concurrent(
+      [
+        {
+          command: `node ${__dirname}/server.js`,
+          name: 'Vovk',
+        },
+        { command: `cd ${argv.project} && npx next dev ${nextArgs}`, name: 'Next' },
+      ],
+      env
+    ).catch((e) => console.error(e));
+    console.info(' 🐺 All processes have completed');
+  })();
 }
 
+// @ts-expect-error yargs
 if (argv._.includes('build')) {
-  const { result } = concurrently(
-    [
-      { command: `node ${__dirname}/server.js --once`, name: 'Vovk' },
-      { command: `cd ${argv.project} && npx next build ${nextArgs}`, name: 'Next' },
-    ],
-    options
-  );
-
-  void result
-    .catch((e) => console.error(e))
-    .then(async () => {
-      await generateClient(argv.rc, argv.output);
-      console.info(' 🐺 Both processes have completed and the client is generated.');
+  void (async () => {
+    env.VOVK_PORT = await getAvailablePort(VOVK_PORT, 20).catch(() => {
+      throw new Error(' 🐺 Failed to find available port');
     });
+    await concurrent(
+      [
+        {
+          command: `node ${__dirname}/server.js --once`,
+          name: 'Vovk',
+        },
+        { command: `cd ${argv.project} && npx next build ${nextArgs}`, name: 'Next' },
+      ],
+      env
+    ).catch((e) => console.error(e));
+  })();
 }
 
+// @ts-expect-error yargs
 if (argv._.includes('generate')) {
-  void generateClient(argv.rc, argv.output).then(() => {
-    console.info(' 🐺 Client generated.');
+  void generateClient(env).then(() => {
+    console.info(' 🐺 Client generated');
   });
 }

package/cli/lib/concurrent.js

@@ -0,0 +1,42 @@
+// @ts-check
+const { spawn } = require('child_process');
+
+/** @type {(commands: { command: string; name: string; }[], env: import('../../src').VovkEnv) => Promise<void>} */
+function concurrent(commands, env) {
+  return new Promise((resolve, reject) => {
+    /** @type {{ name: string; process: import('child_process').ChildProcess; }[]} */
+    let processes = [];
+
+    commands.forEach((cmd) => {
+      const processObj = {
+        name: cmd.name,
+        process: runCommand(cmd.command, cmd.name, (code) => handleProcessExit(code, cmd.name)),
+      };
+      processes.push(processObj);
+    });
+
+    function runCommand(command, name, onExit) {
+      const proc = spawn(command, { shell: true, env: { ...env, ...process.env }, stdio: 'inherit' });
+
+      proc.on('exit', onExit);
+
+      return proc;
+    }
+
+    function handleProcessExit(code, name) {
+      processes = processes.filter((p) => p.name !== name);
+
+      if (code !== 0) {
+        processes.forEach((p) => p.name !== name && p.process.kill('SIGINT'));
+        processes = [];
+        return reject(new Error(`Process ${name} exited with code ${code}`));
+      }
+
+      if (!processes.length) {
+        resolve();
+      }
+    }
+  });
+}
+
+module.exports = concurrent;

package/cli/lib/getAvailablePort.js

@@ -0,0 +1,31 @@
+const net = require('net');
+
+function checkPort(port, callback) {
+  const server = net.createServer();
+
+  server.listen(port, () => {
+    server.close(() => {
+      callback(true); // Port is available
+    });
+  });
+
+  server.on('error', () => {
+    callback(false);
+  });
+}
+
+function getAvailablePort(startPort, maxAttempts, attempt = 1) {
+  return new Promise((resolve, reject) => {
+    checkPort(startPort, (isAvailable) => {
+      if (isAvailable) {
+        resolve(startPort); // Found an available port
+      } else if (attempt < maxAttempts) {
+        getAvailablePort(startPort + 1, maxAttempts, attempt + 1).then(resolve, reject);
+      } else {
+        reject(null);
+      }
+    });
+  });
+}
+
+module.exports = getAvailablePort;

package/cli/postinstall.js

@@ -0,0 +1,21 @@
+// @ts-check
+const fs = require('fs/promises');
+const path = require('path');
+
+const fileExists = async (path) => !!(await fs.stat(path).catch(() => false));
+
+async function postinstall() {
+  const vovk = path.join(__dirname, '../../.vovk');
+  const js = path.join(vovk, 'index.js');
+  const ts = path.join(vovk, 'index.d.ts');
+
+  if ((await fileExists(js)) || (await fileExists(ts))) {
+    return;
+  }
+
+  await fs.mkdir(vovk, { recursive: true });
+  await fs.writeFile(js, '/* postinstall */');
+  await fs.writeFile(ts, '/* postinstall */');
+}
+
+void postinstall();

package/cli/server.js

@@ -1,9 +1,14 @@
+// @ts-check
 const http = require('http');
 const fs = require('fs/promises');
 const path = require('path');
 const yargs = require('yargs/yargs');
 const { hideBin } = require('yargs/helpers');
+const generateClient = require('./generateClient');
+const getVars = require('./getVars');
 
+/** @type {{ once?: boolean; vovkrc: string }} */
+// @ts-expect-error yargs
 const argv = yargs(hideBin(process.argv)).argv;
 
 const once = argv.once ?? false;
@@ -36,9 +41,33 @@ const isEqual = (obj1, obj2) => {
 const writeMetadata = async (metadataPath, metadata) => {
   await fs.mkdir(path.dirname(metadataPath), { recursive: true });
   const existingMetadata = await fs.readFile(metadataPath, 'utf-8').catch(() => '{}');
-  if (isEqual(JSON.parse(existingMetadata), metadata)) return;
+  if (isEqual(JSON.parse(existingMetadata), metadata)) return false;
   await fs.writeFile(metadataPath, JSON.stringify(metadata, null, 2));
-  console.info(' 🐺 JSON data received and metadata file created');
+  return true;
+};
+
+let pingInterval;
+
+const vars = getVars(argv.vovkrc);
+
+const startPinging = (port) => {
+  clearInterval(pingInterval);
+  pingInterval = setInterval(() => {
+    let prefix = vars.VOVK_PREFIX;
+    prefix = prefix.startsWith('http://')
+      ? prefix
+      : `http://localhost:${port}/${prefix.startsWith('/') ? prefix.slice(1) : prefix}`;
+    const endpoint = `${prefix.endsWith('/') ? prefix.slice(0, -1) : prefix}/__ping`;
+    // Create the HTTP GET request
+    const req = http.get(endpoint, () => {
+      // noop
+    });
+
+    // Error handling for the request
+    req.on('error', (err) => {
+      console.error(`🐺 Error during HTTP request made to ${endpoint}:`, err.message);
+    });
+  }, 1000 * 3);
 };
 
 const server = http.createServer((req, res) => {
@@ -46,23 +75,37 @@ const server = http.createServer((req, res) => {
     let body = '';
 
     req.on('data', (chunk) => {
-      body += chunk.toString(); // Convert Buffer to string
+      body += chunk.toString();
     });
 
     // eslint-disable-next-line @typescript-eslint/no-misused-promises
     req.on('end', async () => {
       try {
-        const metadata = JSON.parse(body); // Parse the JSON data
-        const filePath = path.join(__dirname, '../../.vovk/vovk-metadata.json');
-        await writeMetadata(filePath, metadata);
+        const { metadata, PORT } = JSON.parse(body); // Parse the JSON data
+        const filePath = path.join(__dirname, '../../../.vovk.json');
+        const metadataWritten = await writeMetadata(filePath, metadata);
+
+        const codeWritten = await generateClient(vars);
         res.writeHead(200, { 'Content-Type': 'text/plain' });
         res.end('JSON data received and file created');
+        if (metadataWritten || codeWritten) {
+          console.info(' 🐺 JSON metadata received and the client is generated');
+        } else if (once) {
+          console.info(' 🐺 JSON metadata received and the client is not changed');
+        }
+
+        if (PORT && !once) {
+          startPinging(PORT);
+        }
+
+        if (once && metadata) server.close();
       } catch (err) {
         res.writeHead(400, { 'Content-Type': 'text/plain' });
         res.end('Invalid JSON');
         console.error(' ❌ ' + err.message);
+
+        if (once) server.close();
       }
-      if (once) server.close();
     });
   } else {
     res.writeHead(404, { 'Content-Type': 'text/plain' });
@@ -70,7 +113,11 @@ const server = http.createServer((req, res) => {
   }
 });
 
-const PORT = process.env.VOVK_PORT || 3420;
-server.listen(PORT, () => {
-  console.info(` 🐺 Vovk Server running on port ${PORT}`);
+const VOVK_PORT = process.env.VOVK_PORT;
+if (!VOVK_PORT) {
+  console.error(' 🐺 Unable to run Vovk Metadata Server: no port specified');
+  process.exit(1);
+}
+server.listen(VOVK_PORT, () => {
+  console.info(` 🐺 Vovk Metadata Server is running on port ${VOVK_PORT}`);
 });

package/client/clientizeController.d.ts

@@ -1,4 +1,22 @@
 import { type _VovkControllerMetadataJson as VovkControllerMetadataJson } from '../types';
-import { type _VovkClientOptions as VovkClientOptions, type _VovkClient as VovkClient } from './types';
+import { type _VovkClientOptions as VovkClientOptions, type _VovkClient as VovkClient, type _StreamAsyncIterator as StreamAsyncIterator } from './types';
 import { type _DefaultFetcherOptions as DefaultFetcherOptions } from './defaultFetcher';
-export declare const _clientizeController: <T, OPTS extends Record<string, any> = DefaultFetcherOptions>(givenController: VovkControllerMetadataJson, options?: VovkClientOptions<OPTS> | undefined) => VovkClient<T, OPTS>;
+export declare const _clientizeController: <T, OPTS extends Record<string, any> = DefaultFetcherOptions>(givenController: VovkControllerMetadataJson, options?: VovkClientOptions<OPTS> | undefined) => { [K_1 in keyof { [K in keyof T]: T[K] extends (...args: any) => any ? <R>(options: (import("./types")._StaticMethodInput<T[K]> extends {
+    body?: null | undefined;
+    query?: undefined;
+    params?: undefined;
+} ? unknown : Parameters<T[K]>[0] extends void ? import("./types")._StaticMethodInput<T[K]>["params"] extends object ? {
+    params: import("./types")._StaticMethodInput<T[K]>["params"];
+} : unknown : import("./types")._StaticMethodInput<T[K]>) & (void | Partial<OPTS>)) => ReturnType<T[K]> extends import("../StreamResponse")._StreamResponse<infer U> | Iterator<infer U, any, undefined> | AsyncIterator<infer U, any, undefined> | Promise<import("../StreamResponse")._StreamResponse<infer U>> ? Promise<StreamAsyncIterator<U>> : R extends object ? Promise<R> : ReturnType<T[K]> extends infer T_1 ? T_1 extends ReturnType<T[K]> ? T_1 extends PromiseLike<unknown> ? T_1 : Promise<T_1> : never : never : never; } as { [K in keyof T]: T[K] extends (...args: any) => any ? <R>(options: (import("./types")._StaticMethodInput<T[K]> extends {
+    body?: null | undefined;
+    query?: undefined;
+    params?: undefined;
+} ? unknown : Parameters<T[K]>[0] extends void ? import("./types")._StaticMethodInput<T[K]>["params"] extends object ? {
+    params: import("./types")._StaticMethodInput<T[K]>["params"];
+} : unknown : import("./types")._StaticMethodInput<T[K]>) & (void | Partial<OPTS>)) => ReturnType<T[K]> extends import("../StreamResponse")._StreamResponse<infer U> | Iterator<infer U, any, undefined> | AsyncIterator<infer U, any, undefined> | Promise<import("../StreamResponse")._StreamResponse<infer U>> ? Promise<StreamAsyncIterator<U>> : R extends object ? Promise<R> : ReturnType<T[K]> extends infer T_2 ? T_2 extends ReturnType<T[K]> ? T_2 extends PromiseLike<unknown> ? T_2 : Promise<T_2> : never : never : never; }[K_1] extends never ? never : K_1]: { [K in keyof T]: T[K] extends (...args: any) => any ? <R>(options: (import("./types")._StaticMethodInput<T[K]> extends {
+    body?: null | undefined;
+    query?: undefined;
+    params?: undefined;
+} ? unknown : Parameters<T[K]>[0] extends void ? import("./types")._StaticMethodInput<T[K]>["params"] extends object ? {
+    params: import("./types")._StaticMethodInput<T[K]>["params"];
+} : unknown : import("./types")._StaticMethodInput<T[K]>) & (void | Partial<OPTS>)) => ReturnType<T[K]> extends import("../StreamResponse")._StreamResponse<infer U> | Iterator<infer U, any, undefined> | AsyncIterator<infer U, any, undefined> | Promise<import("../StreamResponse")._StreamResponse<infer U>> ? Promise<StreamAsyncIterator<U>> : R extends object ? Promise<R> : ReturnType<T[K]> extends infer T_3 ? T_3 extends ReturnType<T[K]> ? T_3 extends PromiseLike<unknown> ? T_3 : Promise<T_3> : never : never : never; }[K_1]; };

package/client/clientizeController.js

@@ -32,10 +32,8 @@ const _clientizeController = (givenController, options) => {
     const { fetcher = defaultFetcher_1.default, streamFetcher = defaultStreamFetcher_1.default } = options ?? {};
     for (const [staticMethodName, { path, httpMethod, clientValidators }] of Object.entries(metadata)) {
         const getPath = (params, query) => getHandlerPath([prefix, path].filter(Boolean).join('/'), params, query);
-        const validate = ({ body, query }) => {
-            if (options?.disableClientValidation)
-                return;
-            return options?.validateOnClient?.({ body, query }, clientValidators ?? {});
+        const validate = async ({ body, query }) => {
+            await options?.validateOnClient?.({ body, query }, clientValidators ?? {});
         };
         const handler = (input = {}) => {
             const internalOptions = {
@@ -57,9 +55,11 @@ const _clientizeController = (givenController, options) => {
                 const fetcherPromise = streamFetcher(internalOptions, internalInput);
                 return fetcherPromise;
             }
+            if (!fetcher)
+                throw new Error('Fetcher is not provided');
             const fetcherPromise = fetcher(internalOptions, internalInput);
             if (!(fetcherPromise instanceof Promise))
-                throw new Error('Fetcher must return a promise');
+                return Promise.resolve(fetcherPromise);
             return fetcherPromise;
         };
         // @ts-expect-error TODO: Fix this

package/client/defaultFetcher.d.ts

@@ -2,6 +2,7 @@ import { type _VovkClientFetcher as VovkClientFetcher } from './types';
 export interface _DefaultFetcherOptions extends Omit<RequestInit, 'body' | 'method'> {
     prefix?: string;
     isStream?: boolean;
+    disableClientValidation?: true;
 }
 export declare const DEFAULT_ERROR_MESSAGE = "Unknown error at defaultFetcher";
 declare const defaultFetcher: VovkClientFetcher<_DefaultFetcherOptions>;

package/client/defaultFetcher.js

@@ -10,15 +10,17 @@ const defaultFetcher = async ({ httpMethod, getPath, validate }, { params, query
     const endpoint = (prefix.startsWith('http://') || prefix.startsWith('https://') || prefix.startsWith('/') ? '' : '/') +
         (prefix.endsWith('/') ? prefix : `${prefix}/`) +
         getPath(params, query);
-    try {
-        validate({ body, query });
-    }
-    catch (e) {
-        // if HttpException is thrown, rethrow it
-        if (e instanceof HttpException_1._HttpException)
-            throw e;
-        // otherwise, throw HttpException with status 0
-        throw new HttpException_1._HttpException(types_1._HttpStatus.NULL, e.message ?? exports.DEFAULT_ERROR_MESSAGE);
+    if (!options.disableClientValidation) {
+        try {
+            await validate({ body, query });
+        }
+        catch (e) {
+            // if HttpException is thrown, rethrow it
+            if (e instanceof HttpException_1._HttpException)
+                throw e;
+            // otherwise, throw HttpException with status 0
+            throw new HttpException_1._HttpException(types_1._HttpStatus.NULL, e.message ?? exports.DEFAULT_ERROR_MESSAGE);
+        }
     }
     const init = {
         method: httpMethod,

package/client/defaultStreamFetcher.js

@@ -10,7 +10,7 @@ const defaultStreamFetcher = async ({ httpMethod, getPath, validate }, { params,
         (prefix.endsWith('/') ? prefix : `${prefix}/`) +
         getPath(params, query);
     try {
-        validate({ body, query });
+        await validate({ body, query });
     }
     catch (e) {
         // if HttpException is thrown, rethrow it

package/client/types.d.ts

@@ -27,11 +27,17 @@ type ClientMethod<T extends (...args: KnownAny[]) => void | object | StreamRespo
 } ? unknown : Parameters<T>[0] extends void ? _StaticMethodInput<T>['params'] extends object ? {
     params: _StaticMethodInput<T>['params'];
 } : unknown : _StaticMethodInput<T>) & (Partial<OPTS> | void)) => ReturnType<T> extends Promise<StreamResponse<infer U>> | StreamResponse<infer U> | Iterator<infer U> | AsyncIterator<infer U> ? Promise<_StreamAsyncIterator<U>> : R extends object ? Promise<R> : ToPromise<ReturnType<T>>;
-export type _VovkClient<T, OPTS extends {
+type OmitNever<T> = {
+    [K in keyof T as T[K] extends never ? never : K]: T[K];
+};
+type _VovkClientWithNever<T, OPTS extends {
     [key: string]: KnownAny;
 }> = {
     [K in keyof T]: T[K] extends (...args: KnownAny) => KnownAny ? ClientMethod<T[K], OPTS> : never;
 };
+export type _VovkClient<T, OPTS extends {
+    [key: string]: KnownAny;
+}> = OmitNever<_VovkClientWithNever<T, OPTS>>;
 export type _VovkClientFetcher<OPTS extends Record<string, KnownAny> = Record<string, never>, T = KnownAny> = (options: {
     name: keyof T;
     httpMethod: HttpMethod;
@@ -43,7 +49,7 @@ export type _VovkClientFetcher<OPTS extends Record<string, KnownAny> = Record<st
     validate: (input: {
         body?: unknown;
         query?: unknown;
-    }) => void;
+    }) => void | Promise<void>;
 }, input: {
     body: unknown;
     query: {
@@ -54,7 +60,6 @@ export type _VovkClientFetcher<OPTS extends Record<string, KnownAny> = Record<st
     };
 } & OPTS) => KnownAny;
 export type _VovkClientOptions<OPTS extends Record<string, KnownAny> = Record<string, never>> = {
-    disableClientValidation?: boolean;
     fetcher?: _VovkClientFetcher<OPTS>;
     streamFetcher?: _VovkClientFetcher<OPTS>;
     validateOnClient?: (input: {

package/config.d.ts

@@ -0,0 +1 @@
+declare function config(): void;