“Hello World” Example

About this example: Despite the name, this example covers many features: validation, streaming, clients in several languages, and OpenAPI output. For the minimal setup, see the Quick Start guide first.

The “Hello World” app at hello-world.vovk.dev is a Next.js app built with Vovk.ts. It shows the core features with:

Back-end:
- UserController with an updateUser procedure (POST /api/users/{id}).
- StreamController with a JSON Lines procedure, streamTokens (GET /api/streams/tokens).
- OpenApiController with getSpec (GET /api/static/openapi.json), which serves the generated OpenAPI spec. The /openapi page shows it as documentation.
Front-end:
- A form, with a JSON Lines streaming demo above it.
Configuration:
- Client-side validation, the segmented and composed TypeScript clients, Rust and Python clients, an npm bundle, and OpenAPI metadata (info and servers).

The source is in the GitHub repository . The generated files are committed under dist , tmp_prebundle , dist_rust and dist_python , so you can read them. In a real project, list them in .gitignore.

The code on this page comes from the repository on GitHub. The live pages are embedded as iframes.

Running the Example Locally

Copy the example. This also installs its dependencies:


npx create-next-app@latest --example https://github.com/finom/vovk/tree/main/examples/hello-world vovk-hello-world
cd vovk-hello-world

Start the dev server:


npm run dev

Then open http://localhost:3000 .

Topics and Concepts Covered

Zod validation with the procedure function: body, query and params for input, output and iteration for output, with description and examples from Zod meta .
Client-side validation of RPC input, described in the customization article.
Composed and segmented TypeScript clients.
JSON Lines streaming.
Type inference between the service and the controller.
useQuery and useMutation with queryKey.
A TypeScript client bundle, published on npm (see bundlephobia ).
Rust and Python clients, published on crates.io and PyPI .
An OpenAPI spec, served from a static segment and rendered with Scalar .

Live Demo

The demo has a form without native validation attributes, and a “Disable client-side input validation” checkbox that toggles the disableClientValidation option. “Notification type” has an invalid value on purpose, so you can see both the client and the server validation fail.

https://hello-world.vovk.dev

`UserController` and `UserService`

UserController and UserService implement /api/users/{id} with updateUser.

The procedure maps POST with @post, and procedure() validates body, params, query and output with Zod. Each schema calls meta to add description and examples to the OpenAPI output. To show nesting, body holds email and a profile object (name, age).

The service method takes its parameter types from the procedure. The handler returns the service result directly, which avoids implicit any errors from self-reference.

user-controller.ts

src/modules/user/user-controller.ts


import { operation, post, prefix, procedure } from 'vovk';
import { z } from 'zod';
import UserService from './user-service';
 
@prefix('users')
export default class UserController {
  @operation({
    summary: 'Update user',
    description: 'Update user by ID',
  })
  @post('{id}')
  static updateUser = procedure({
    body: z
      .object({
        email: z.email().meta({
          description: 'User email',
          examples: ['john@example.com', 'jane@example.com'],
        }),
        profile: z
          .object({
            name: z
              .string()
              .min(2)
              .meta({
                description: 'User full name',
                examples: ['John Doe', 'Jane Smith'],
              }),
            age: z
              .int()
              .min(16)
              .max(120)
              .meta({ description: 'User age', examples: [25, 30] }),
          })
          .meta({ description: 'User profile object' }),
      })
      .meta({ description: 'User data object' }),
    params: z
      .object({
        id: z.uuid().meta({
          description: 'User ID',
          examples: ['123e4567-e89b-12d3-a456-426614174000'],
        }),
      })
      .meta({
        description: 'Path parameters',
      }),
    query: z
      .object({
        notify: z
          .enum(['email', 'push', 'none'])
          .meta({ description: 'Notification type' }),
      })
      .meta({
        description: 'Query parameters',
      }),
    output: z
      .object({
        success: z.boolean().meta({ description: 'Success status' }),
        id: z.uuid().meta({ description: 'User ID' }),
        notify: z.enum(['email', 'push', 'none']).meta({
          description: 'Notification type',
        }),
      })
      .meta({ description: 'Response object' }),
  }).handle(async (req, { id }) => {
    const body = await req.vovk.body();
    const { notify } = req.vovk.query();
 
    return UserService.updateUser(id, body, notify);
  });
}

The code above is fetched from GitHub repository.

user-service.ts

src/modules/user/user-service.ts


import type { VovkBody, VovkOutput, VovkParams, VovkQuery } from 'vovk';
import type UserController from './user-controller';
 
export default class UserService {
  static updateUser = (
    id: VovkParams<typeof UserController.updateUser>['id'],
    body: VovkBody<typeof UserController.updateUser>,
    notify: VovkQuery<typeof UserController.updateUser>['notify'],
  ) => {
    console.log(
      id satisfies string,
      body satisfies { email: string; profile: { name: string; age: number } },
      notify satisfies 'email' | 'push' | 'none',
    );
    return {
      id,
      notify,
      success: true,
    } satisfies VovkOutput<typeof UserController.updateUser>;
  };
}

The code above is fetched from GitHub repository.

route.ts

src/app/api/[[...vovk]]/route.ts


import { initSegment } from 'vovk';
import StreamController from '../../../modules/stream/stream-controller';
import UserController from '../../../modules/user/user-controller';
 
const controllers = {
  UserRPC: UserController,
  StreamRPC: StreamController,
};
 
export type Controllers = typeof controllers;
 
export const { GET, POST, PATCH, PUT, HEAD, OPTIONS, DELETE } = initSegment({
  emitSchema: true,
  controllers,
  onError: console.error,
});

The code above is fetched from GitHub repository.

`StreamController` and `StreamService`

/api/streams/tokens streams tokens. Its procedure is a generator that delegates to the service with yield*. The iteration schema validates each streamed item. setTimeout adds a delay between tokens.

stream-controller.ts

src/modules/stream/stream-controller.ts


import { get, operation, prefix, procedure } from 'vovk';
import { z } from 'zod';
import StreamService from './stream-service';
 
@prefix('streams')
export default class StreamController {
  @operation({
    summary: 'Stream tokens',
    description: 'Stream tokens to the client',
  })
  @get('tokens')
  static streamTokens = procedure({
    validateEachIteration: true,
    iteration: z
      .object({
        message: z.string().meta({ description: 'Message from the token' }),
      })
      .meta({
        description: 'Streamed token object',
      }),
  }).handle(async function* () {
    yield* StreamService.streamTokens();
  });
}

The code above is fetched from GitHub repository.

stream-service.ts

src/modules/stream/stream-service.ts


import type { VovkIteration } from 'vovk';
import type StreamController from './stream-controller';
 
export default class StreamService {
  static async *streamTokens() {
    const tokens: VovkIteration<typeof StreamController.streamTokens>[] =
      'Vovk.ts is a RESTful back-end meta-framework with RPC, built on top of the Next.js App Router. This text is a JSONLines stream demo.'
        .match(/[^\s-]+-?(?:\s+)?/g)
        ?.map((message) => ({ message })) || [];
 
    for (const token of tokens) {
      yield token;
      await new Promise((resolve) => setTimeout(resolve, 200));
    }
  }
}

The code above is fetched from GitHub repository.

route.ts

src/app/api/[[...vovk]]/route.ts


import { initSegment } from 'vovk';
import StreamController from '../../../modules/stream/stream-controller';
import UserController from '../../../modules/user/user-controller';
 
const controllers = {
  UserRPC: UserController,
  StreamRPC: StreamController,
};
 
export type Controllers = typeof controllers;
 
export const { GET, POST, PATCH, PUT, HEAD, OPTIONS, DELETE } = initSegment({
  emitSchema: true,
  controllers,
  onError: console.error,
});

The code above is fetched from GitHub repository.

React Components

The demo uses @tanstack/react-query for both standard requests and streaming.

index.tsx

src/components/demo/index.tsx


'use client';
import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
import StreamDemo from './stream-demo';
import UserFormDemo from './user-form-demo';
 
const queryClient = new QueryClient();
 
const Demo = () => {
  return (
    <QueryClientProvider client={queryClient}>
      <StreamDemo />
      <h2 className="text-lg font-bold mb-1 text-center">
        &quot;Update User&quot; Demo
      </h2>
      <p className="text-xs mb-4 text-center">
        <strong>*</strong> form validation isn&apos;t enabled for demo purposes
      </p>
      <UserFormDemo />
    </QueryClientProvider>
  );
};
 
export default Demo;

The code above is fetched from GitHub repository.

user-form-demo.tsx

src/components/demo/user-form-demo.tsx


'use client';
import { useMutation } from '@tanstack/react-query';
import type React from 'react';
import { useState } from 'react';
import type { VovkQuery } from 'vovk';
import { UserRPC } from '../../client/root'; // segmented client
 
const UserFormDemo = () => {
  const [disableClientValidation, setDisableClientValidation] = useState(false);
  const [name, setName] = useState('John Doe');
  const [age, setAge] = useState(35);
  const [email, setEmail] = useState('john@example.com');
  const [id, setId] = useState('a937629d-e8f6-4b1e-a819-7669358650a0');
  const [notify, setNotify] = useState<
    VovkQuery<typeof UserRPC.updateUser>['notify']
  >(
    'sms' as 'email', // intentionally use an invalid value
  );
 
  const updateUserMutation = useMutation({
    mutationFn: UserRPC.updateUser,
  });
 
  const handleSubmit = (e: React.FormEvent) => {
    e.preventDefault();
 
    updateUserMutation.mutate({
      body: {
        email,
        profile: {
          name,
          age,
        },
      },
      query: { notify },
      params: { id },
      disableClientValidation,
    });
  };
  return (
    <form onSubmit={handleSubmit}>
      <h3>Body</h3>
      <div>
        <label htmlFor="email">User email</label>
        <input
          id="email"
          name="email"
          placeholder="john@example.com"
          value={email}
          onChange={(e) => setEmail(e.target.value)}
        />
      </div>
      <div>
        <label htmlFor="name">User full name</label>
        <input
          id="name"
          name="name"
          type="text"
          placeholder="John Doe"
          value={name}
          onChange={(e) => setName(e.target.value)}
        />
      </div>
      <div>
        <label htmlFor="age">User age</label>
        <input
          id="age"
          name="age"
          type="number"
          placeholder="35"
          value={age}
          onChange={(e) => setAge(Number(e.target.value))}
        />
      </div>
 
      <h3>Params</h3>
      <div>
        <label htmlFor="id">User ID</label>
        <input
          id="id"
          name="id"
          type="text"
          placeholder="123e4567-e89b-12d3-a456-426614174000"
          value={id}
          onChange={(e) => setId(e.target.value)}
        />
      </div>
      <h3>Query</h3>
      <div>
        <label htmlFor="notify">Notification type</label>
        <select
          id="notify"
          name="notify"
          value={notify}
          onChange={(e) =>
            setNotify(e.target.value as 'email' | 'push' | 'none')
          }
        >
          <option value="none">None</option>
          <option value="email">Email</option>
          <option value="push">Push</option>
          <option value="sms">SMS (error)</option>
        </select>
      </div>
      <br />
      <label>
        <input
          type="checkbox"
          onChange={({ target }) => setDisableClientValidation(target.checked)}
          checked={disableClientValidation}
        />{' '}
        Disable client-side input validation
      </label>
      <button type="submit">Submit</button>
      {(updateUserMutation.data || updateUserMutation.error) && (
        <output>
          <strong>Response:</strong>{' '}
          {updateUserMutation.error ? (
            <div className="text-red-500">
              {updateUserMutation.error.message}
            </div>
          ) : (
            <div className="text-green-500">
              {JSON.stringify(updateUserMutation.data)}
            </div>
          )}
        </output>
      )}
    </form>
  );
};
 
export default UserFormDemo;

The code above is fetched from GitHub repository.

stream-demo.tsx

src/components/demo/stream-demo.tsx


'use client';
import {
  experimental_streamedQuery as streamedQuery,
  useQuery,
} from '@tanstack/react-query';
import { StreamRPC } from '../../client/root'; // segmented client, just for demo
 
const StreamDemo = () => {
  const { data, refetch } = useQuery({
    queryKey: StreamRPC.streamTokens.queryKey(),
    queryFn: streamedQuery({
      streamFn: () => StreamRPC.streamTokens(),
    }),
  });
 
  return (
    // biome-ignore lint/a11y/noStaticElementInteractions: ignore for refetch demo
    // biome-ignore lint/a11y/useKeyWithClickEvents: ignore for refetch demo
    <div className="h-20 cursor-pointer" onClick={() => refetch()}>
      {data?.map((token, index) => (
        <span key={index}>{token.message}</span>
      ))}
    </div>
  );
};
export default StreamDemo;

The code above is fetched from GitHub repository.

Config

The app is configured to:

Validate on the client with Ajv, the main client-side validation library, described in the customization article. The bundle has no validation, to stay small.
Generate Rust and Python code when you run vovk dev or vovk generate.
Show the segmented client, which has RPC modules per segment.
Generate the clients and the bundle with a package field and an explicit origin:
- Python and Rust clients: https://hello-world.vovk.dev.
- TypeScript bundle: https://hello-world.vovk.dev.
- Composed TypeScript client:
  - In development: http://localhost:PORT, so Node.js code can call the local server through the generated @/client.
  - In production: an empty origin, so requests go to the current origin.
- Segmented client: an empty origin, so requests go to the current origin.

vovk.config.js


// @ts-check
 
const PROD_ORIGIN = 'https://hello-world.vovk.dev';
// Commented lines indicate default values
/** @type {import('vovk').VovkConfig} */
const config = {
  logLevel: 'debug',
  outputConfig: {
    imports: {
      validateOnClient: 'vovk-ajv',
    },
    openAPIObject: {
      info: {
        title: '"Hello World" app API',
        description:
          'API for "Hello World" app hosted at https://hello-world.vovk.dev/. Source code is available on Github https://github.com/finom/vovk/tree/main/examples/hello-world. For more information about this app, visit the documentation page https://vovk.dev/hello-world.',
        license: {
          name: 'MIT',
          url: 'https://opensource.org/licenses/MIT',
        },
        version: '1.0.0',
      },
      servers: [
        {
          url: 'https://hello-world.vovk.dev',
          description: 'Production',
        },
        {
          url: 'http://localhost:3000',
          description: 'Localhost',
        },
      ],
    },
  },
  composedClient: {
    fromTemplates: ['ts', 'py', 'rs'],
    // enabled: true,
    // outDir: "./src/client",
    outputConfig: {
      origin:
        process.env.NODE_ENV === 'production'
          ? null
          : `http://localhost:${process.env.PORT ?? 3000}`,
    },
    // prettifyClient: true,
  },
  segmentedClient: {
    // fromTemplates: ["ts"],
    enabled: true,
    // outDir: "./src/client",
    // outputConfig: { origin: '' },
    // prettifyClient: true,
  },
  bundle: {
    outputConfig: {
      origin: PROD_ORIGIN,
      imports: { validateOnClient: null },
      package: {
        type: 'module',
        main: './index.js',
        types: './index.d.ts',
        exports: {
          '.': {
            default: './index.js',
            types: './index.d.ts',
          },
        },
      },
    },
    keepPrebundleDir: true,
    build: async ({ entry, outDir }) => {
      const { build } = await import('tsdown');
      // the code and the types build in two passes: one pass writes an extra chunk.js
      for (const dts of [false, { emitDtsOnly: true }]) {
        await build({
          entry,
          dts,
          format: 'esm',
          hash: false,
          fixedExtension: true,
          clean: !dts,
          outDir,
          platform: 'neutral',
          outExtensions: () => ({ js: '.js', dts: '.d.ts' }),
          outputOptions: {
            codeSplitting: false,
          },
          inputOptions: {
            resolve: {
              mainFields: ['module', 'main'],
            },
          },
          deps: { alwaysBundle: ['!next/**'] },
        });
      }
    },
  },
  clientTemplateDefs: {
    py: {
      extends: 'py',
      outputConfig: { origin: PROD_ORIGIN },
      // composedClient: { outDir: "./dist_python" },
    },
    rs: {
      extends: 'rs',
      outputConfig: { origin: PROD_ORIGIN },
      // composedClient: { outDir: "./dist_rust" },
    },
  },
};
 
module.exports = config;

The code above is fetched from GitHub repository.

package.json

The package files listed below take their metadata (repository, homepage, bugs and more) from this package.json.

package.json


{
  "name": "vovk-hello-world",
  "version": "0.0.89",
  "description": "A \"Hello World!\" app built with Next.js, Vovk.ts and Zod. For details, visit https://vovk.dev/hello-world",
  "scripts": {
    "dev": "vovk dev --next-dev",
    "prebuild": "vovk generate",
    "build": "next build",
    "start": "next start",
    "lint": "biome check",
    "test:node": "tsx --test --test-concurrency=1",
    "test:python": "python3 -m pip install -q -r test/python/requirements.txt && python3 -m unittest discover -s test/python -p local_test.py && python3 -m unittest discover -s test/python -p packaged_test.py",
    "test:rust": "RUST_BACKTRACE=full RUST_TEST_THREADS=1 cargo test --manifest-path ./test/rust/Cargo.toml --tests -- --nocapture --show-output",
    "pretest": "next build",
    "test": "concurrently 'next start' \"sleep 10 && printf '\\n\\033[1;96mNode tests\\033[0m\\n' && npm run test:node && printf '\\n\\033[1;96mPython tests\\033[0m\\n' && npm run test:python && printf '\\n\\033[1;96mRust tests\\033[0m\\n' && npm run test:rust\" --kill-others --success first",
    "publish:node": "npm publish ./dist",
    "publish:rust": "cargo publish --manifest-path dist_rust/Cargo.toml --allow-dirty",
    "publish:python": "python3 -m build ./dist_python --wheel --sdist && python3 -m twine upload ./dist_python/dist/*",
    "git-tag": "git add . && git commit -m \"chore: release v$(node -p \"require('./package.json').version\")\" && git tag vovk-hello-world-v$(node -p \"require('./package.json').version\")",
    "check-uncommitted": "git diff --quiet && git diff --cached --quiet || (echo '❌ Uncommitted changes!' && exit 1)",
    "postversion": "vovk generate && vovk bundle && npm run publish:node && npm run publish:rust && npm run publish:python && npm run git-tag",
    "patch": "npm run check-uncommitted && npm version patch --no-git-tag-version --no-workspaces-update",
    "ncu": "npm-check-updates -u"
  },
  "license": "MIT",
  "repository": {
    "type": "git",
    "url": "https://github.com/finom/vovk.git",
    "directory": "examples/hello-world"
  },
  "homepage": "https://vovk.dev/hello-world",
  "bugs": {
    "url": "https://github.com/finom/vovk/issues"
  },
  "author": "Andrey Gubanov",
  "keywords": [
    "vovk",
    "openapi",
    "zod",
    "api"
  ],
  "dependencies": {
    "@scalar/api-reference-react": "^0.9.77",
    "@standard-schema/spec": "^1.1.0",
    "@tanstack/react-query": "^5.104.1",
    "ajv": "^8.20.0",
    "ajv-errors": "^3.0.0",
    "next": "^16.3.8",
    "react": "^19.3.0",
    "react-dom": "^19.3.0",
    "vovk": "^4.1.3",
    "vovk-ajv": "^0.2.1",
    "zod": "^4.6.5"
  },
  "devDependencies": {
    "@biomejs/biome": "^2.5.15",
    "@tailwindcss/postcss": "^4.3.3",
    "@types/node": "^26",
    "@types/react": "^19",
    "@types/react-dom": "^19",
    "postcss": "^8",
    "prettier": "^3.9.9",
    "tailwindcss": "^4.3.3",
    "tsdown": "^0.23.0",
    "tsx": "^4.23.15",
    "typescript": "^7",
    "vovk-cli": "^0.3.5",
    "vovk-hello-world-published": "npm:vovk-hello-world@^0.0.88",
    "vovk-python": "^0.0.5",
    "vovk-rust": "^0.0.6"
  }
}

The code above is fetched from GitHub repository.

OpenAPI Specification

A GET endpoint serves the OpenAPI specification . It returns the generated spec, openapi from @/client/openapi.

openapi-controller.ts

src/modules/static/openapi/openapi-controller.ts


import { get, operation } from 'vovk';
import { openapi } from '@/client/openapi';
 
export default class OpenApiController {
  @operation({
    summary: 'OpenAPI spec',
    description: 'Get the OpenAPI spec for the "Hello World" app API',
  })
  @get('openapi.json', { cors: true })
  static getSpec = () => openapi;
}

The code above is fetched from GitHub repository.

The spec includes code samples that Scalar shows, ready to copy.

https://hello-world.vovk.dev/openapi

Building and Packaging

The example also builds the packages it publishes on npm , PyPI and crates.io . The templates write each package with the files its language needs, such as package.json , Cargo.toml and pyproject.toml , and a README whose code samples document the API and the client.

npm run patch:

Verifies a clean working tree.
Bumps the patch version.
Triggers postversion to regenerate clients, bundle TypeScript, create package files and README files, publish all packages, and create a commit + tag.

vovk generate writes the Python and Rust packages to dist_python and dist_rust, because composedClient.fromTemplates lists py and rs. vovk bundle builds the npm package into dist. Each package has its own publish script:


"scripts": {
  // ...
  "publish:node": "npm publish ./dist",
  "publish:rust": "cargo publish --manifest-path dist_rust/Cargo.toml --allow-dirty",
  "publish:python": "python3 -m build ./dist_python --wheel --sdist && python3 -m twine upload ./dist_python/dist/*",
  "git-tag": "git add . && git commit -m \"chore: release v$(node -p \"require('./package.json').version\")\" && git tag vovk-hello-world-v$(node -p \"require('./package.json').version\")",
  "check-uncommitted": "git diff --quiet && git diff --cached --quiet || (echo '❌ Uncommitted changes!' && exit 1)",
  "postversion": "vovk generate && vovk bundle && npm run publish:node && npm run publish:rust && npm run publish:python && npm run git-tag",
  "patch": "npm run check-uncommitted && npm version patch --no-git-tag-version --no-workspaces-update"
}

vovk generate and vovk bundle rewrite the READMEs on each run: TypeScript , Rust and Python .

The generated package files:

package.json

dist/package.json


{
  "name": "vovk-hello-world",
  "version": "0.0.89",
  "description": "A \"Hello World!\" app built with Next.js, Vovk.ts and Zod. For details, visit https://vovk.dev/hello-world",
  "license": "MIT",
  "repository": {
    "type": "git",
    "url": "https://github.com/finom/vovk.git",
    "directory": "examples/hello-world"
  },
  "homepage": "https://vovk.dev/hello-world",
  "bugs": {
    "url": "https://github.com/finom/vovk/issues"
  },
  "author": "Andrey Gubanov",
  "keywords": [
    "vovk",
    "openapi",
    "zod",
    "api"
  ],
  "type": "module",
  "main": "./index.js",
  "types": "./index.d.ts",
  "exports": {
    ".": {
      "default": "./index.js",
      "types": "./index.d.ts"
    }
  }
}

The code above is fetched from GitHub repository.

Cargo.toml

dist_rust/Cargo.toml


# Generated by vovk-cli v0.3.0-beta.0
 
[package]
name = "vovk_hello_world"
version = "0.0.89"
edition = "2021"
rust-version = "1.85"
resolver = "3"
description = 'A "Hello World!" app built with Next.js, Vovk.ts and Zod. For details, visit https://vovk.dev/hello-world'
license = "MIT"
repository = "https://github.com/finom/vovk.git"
homepage = "https://vovk.dev/hello-world"
authors = [ "Andrey Gubanov" ]
keywords = [ "vovk", "openapi", "zod", "api" ]
 
[package.metadata.package]
bugs = "https://github.com/finom/vovk/issues"
 
[dependencies]
serde_json = "1.0.143"
futures-util = "0.3"
urlencoding = "2.1"
once_cell = "1.17"
 
  [dependencies.serde]
  version = "1.0.164"
  features = [ "derive" ]
 
  [dependencies.reqwest]
  version = "0.12"
  features = [ "json", "multipart", "stream" ]
 
  [dependencies.tokio]
  version = "1.49"
  features = [ "macros", "rt-multi-thread", "io-util" ]
 
  [dependencies.tokio-util]
  version = "0.7"
  features = [ "codec" ]
 
  [dependencies.jsonschema]
  version = "0.57"
  default-features = false

The code above is fetched from GitHub repository.

pyproject.toml

dist_python/pyproject.toml


# Generated by vovk-cli v0.3.0-beta.0
 
[build-system]
requires = [ "hatchling" ]
build-backend = "hatchling.build"
 
[project]
name = "vovk_hello_world"
version = "0.0.89"
description = 'A "Hello World!" app built with Next.js, Vovk.ts and Zod. For details, visit https://vovk.dev/hello-world'
requires-python = ">=3.9"
keywords = [ "vovk", "openapi", "zod", "api" ]
dependencies = [
  "requests",
  "jsonschema[format-nongpl]",
  "typing_extensions>=4.0.0; python_version < '3.11'"
]
readme = "README.md"
 
  [project.license]
  text = "MIT"
 
  [[project.authors]]
  name = "Andrey Gubanov"
 
  [project.optional-dependencies]
  dev = [ "types-requests", "types-jsonschema" ]
 
  [project.urls]
  Homepage = "https://vovk.dev/hello-world"
  Source = "https://github.com/finom/vovk.git"
  Issues = "https://github.com/finom/vovk/issues"
 
 
[tool.setuptools.packages.find]
where = ["src"]
 
[tool.setuptools.package-data]
"*" = ["py.typed"]
 
[tool.mypy]
warn_return_any = true
warn_unused_configs = true

The code above is fetched from GitHub repository.

Tests

Tests in test/node , test/rust and test/python cover both the local and the published clients.


npm run test


pnpm run test


yarn run test


bun run test

The command builds the Next.js app, starts the server and runs the tests.

“Hello World” Example

Running the Example Locally

Topics and Concepts Covered

Live Demo

UserController and UserService

user-controller.ts

user-service.ts

route.ts

StreamController and StreamService

stream-controller.ts

stream-service.ts

route.ts

React Components

index.tsx

user-form-demo.tsx

stream-demo.tsx

Config

vovk.config.js

package.json

OpenAPI Specification

openapi-controller.ts

route.ts

Building and Packaging

package.json

Cargo.toml

pyproject.toml

Tests

`UserController` and `UserService`

`StreamController` and `StreamService`