vovk-cli 0.0.1-draft.113 → 0.0.1-draft.115

package/README.md

@@ -4,7 +4,7 @@
     <source width="300" media="(prefers-color-scheme: light)" srcset="https://vovk.dev/vovk-logo.svg">
     <img width="300" alt="vovk" src="https://vovk.dev/vovk-logo.svg">
   </picture><br>
-  <strong>REST + RPC = ♥️</strong>
+  <strong>RESTful + RPC = ♥️</strong>
 </p>
 
 <p align="center">

package/client-templates/fullSchema/fullSchema.cjs.ejs

@@ -0,0 +1,13 @@
+<%- `// auto-generated ${new Date().toISOString()}\n/* eslint-disable */` %>
+const config = require('./<%= t.schemaOutDir %>/config.json');
+const segments = {
+  <% Object.values(t.fullSchema.segments).forEach((segment) => { %>
+    '<%= segment.segmentName %>': require('./<%= t.schemaOutDir %>/<%= t.SEGMENTS_SCHEMA_DIR_NAME %>/<%= segment.segmentName || t.ROOT_SEGMENT_SCHEMA_NAME %>.json'),
+  <% }) %>
+};
+const fullSchema = {
+  config,
+  segments,
+};
+
+module.exports.fullSchema = fullSchema;

package/client-templates/fullSchema/fullSchema.d.cts.ejs

@@ -0,0 +1,11 @@
+<%- `// auto-generated ${new Date().toISOString()}\n/* eslint-disable */` %>
+import { VovkStrictConfig, VovkSegmentSchema } from 'vovk';
+
+export const fullSchema: {
+    config: Partial<VovkStrictConfig>;
+    segments: {
+      <% Object.values(t.fullSchema.segments).forEach((segment) => { %>
+      '<%= segment.segmentName %>': VovkSegmentSchema;
+      <% }) %>
+    };
+};

package/client-templates/main/main.cjs.ejs

@@ -1,7 +1,7 @@
 <%- `// auto-generated ${new Date().toISOString()}\n/* eslint-disable */` %>
 const { fetcher } = require('<%= t.imports.fetcher %>');
 const { createRPC } = require('<%= t.imports.createRPC %>');
-const fullSchema = require('<%= t.imports.fullSchema %>');
+const { fullSchema } = require('./fullSchema.cjs');
 const { validateOnClient = null } = <%- t.imports.validateOnClient ? `require('${t.imports.validateOnClient}')` : '{}'%>;
 const apiRoot = '<%= t.apiRoot %>';
 <% Object.values(t.fullSchema.segments).forEach((segment) => { 
@@ -12,3 +12,4 @@ exports.<%= controllerName %> = createRPC(
 );
   <% })
 }) %>
+exports.fullSchema = fullSchema;

package/client-templates/main/main.d.cts.ejs

@@ -12,3 +12,4 @@ type Options = typeof fetcher extends VovkClientFetcher<infer U> ? U : never;
 export const <%= controllerName %>: ReturnType<typeof createRPC<Controllers<%= i %>["<%= controllerName %>"], Options>>;
   <% }) 
 }) %>
+export { fullSchema } from './fullSchema.cjs';

package/client-templates/module/module.d.mts.ejs

@@ -12,3 +12,4 @@ type Options = typeof fetcher extends VovkClientFetcher<infer U> ? U : never;
 export const <%= controllerName %>: ReturnType<typeof createRPC<Controllers<%= i %>["<%= controllerName %>"], Options>>;
   <% }) 
 }) %>
+export { fullSchema } from './fullSchema.cjs';

package/client-templates/module/module.mjs.ejs

@@ -1,7 +1,7 @@
 <%- `// auto-generated ${new Date().toISOString()}\n/* eslint-disable */` %>
 import { fetcher } from '<%= t.imports.module.fetcher %>';
 import { createRPC } from '<%= t.imports.module.createRPC %>';
-import fullSchema from '<%= t.imports.module.fullSchema %>';
+import { fullSchema } from './fullSchema.cjs';
 <% if (t.imports.module.validateOnClient) { %>
 import { validateOnClient } from '<%= t.imports.module.validateOnClient %>';
 <% } else { %>
@@ -18,3 +18,4 @@ export const <%= controllerName %> = createRPC(
   }); 
 });
 %>
+export { fullSchema };

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

@@ -2,7 +2,7 @@
 import type { VovkClientFetcher } from 'vovk';
 import { fetcher } from '<%= t.imports.fetcher %>';
 import { createRPC } from '<%= t.imports.createRPC %>';
-import fullSchema from '<%= t.imports.fullSchema %>';
+import { fullSchema } from './fullSchema.cjs';
 <% Object.values(t.fullSchema.segments).forEach((segment, i) => { if(Object.keys(segment.controllers).length) { %>
 import type { Controllers as Controllers<%= i %> } from "<%= t.segmentMeta[segment.segmentName].segmentImportPath %>";
 <% }}) %>
@@ -21,3 +21,4 @@ export const <%= controllerName %> = createRPC<Controllers<%= i %>["<%= controll
 );
   <% }) %>
 <% }) %>
+export { fullSchema };

package/dist/dev/ensureSchemaFiles.mjs

@@ -11,41 +11,6 @@ export default async function ensureSchemaFiles(projectInfo, schemaOutAbsolutePa
     const now = Date.now();
     let hasChanged = false;
     const schemaJsonOutAbsolutePath = path.join(schemaOutAbsolutePath, SEGMENTS_SCHEMA_DIR_NAME);
-    const jsContent = `// auto-generated ${new Date().toISOString()}
-module.exports.config = require('./config.json');
-module.exports.segments = {
-${segmentNames
-        .map((segmentName) => {
-        return `  '${segmentName}': require('./${SEGMENTS_SCHEMA_DIR_NAME}/${segmentName || ROOT_SEGMENT_SCHEMA_NAME}.json'),`;
-    })
-        .join('\n')}
-}`;
-    const dTsContent = `// auto-generated ${new Date().toISOString()}
-import type { VovkSegmentSchema, VovkStrictConfig } from 'vovk';
-declare const fullSchema: {
-  config: Partial<VovkStrictConfig>;
-  segments: {
-${segmentNames.map((segmentName) => `    '${segmentName}': VovkSegmentSchema;`).join('\n')}
-  };
-};
-export default fullSchema;`;
-    const tsContent = `// auto-generated ${new Date().toISOString()}
-import type { VovkSegmentSchema, VovkStrictConfig } from 'vovk';
-import config from './config.json';
-${segmentNames.map((segmentName, i) => `import segment${i} from './${SEGMENTS_SCHEMA_DIR_NAME}/${segmentName || ROOT_SEGMENT_SCHEMA_NAME}.json';`).join('\n')}
-const fullSchema = {
-  config: config as unknown as Partial<VovkStrictConfig>,
-  segments: {
-${segmentNames.map((segmentName, i) => `    '${segmentName}': segment${i} as unknown as VovkSegmentSchema,`).join('\n')}
-  }
-};
-export default fullSchema;`;
-    const jsAbsolutePath = path.join(schemaOutAbsolutePath, 'main.cjs');
-    const dTsAbsolutePath = path.join(schemaOutAbsolutePath, 'main.d.cts');
-    const tsAbsolutePath = path.join(schemaOutAbsolutePath, 'index.ts');
-    const existingJs = await fs.readFile(jsAbsolutePath, 'utf-8').catch(() => null);
-    const existingDTs = await fs.readFile(dTsAbsolutePath, 'utf-8').catch(() => null);
-    const existingTs = await fs.readFile(tsAbsolutePath, 'utf-8').catch(() => null);
     await fs.mkdir(schemaJsonOutAbsolutePath, { recursive: true });
     await writeConfigJson(schemaOutAbsolutePath, projectInfo);
     // Create JSON files (if not exist) with name [segmentName].json (where segmentName can include /, which means the folder structure can be nested)
@@ -64,16 +29,6 @@ export default fullSchema;`;
             hasChanged = true;
         }
     }));
-    // ignore 1st lines at the files
-    if (existingJs?.split('\n').slice(1).join('\n') !== jsContent.split('\n').slice(1).join('\n')) {
-        await fs.writeFile(jsAbsolutePath, jsContent);
-    }
-    if (existingDTs?.split('\n').slice(1).join('\n') !== dTsContent.split('\n').slice(1).join('\n')) {
-        await fs.writeFile(dTsAbsolutePath, dTsContent);
-    }
-    if (existingTs?.split('\n').slice(1).join('\n') !== tsContent.split('\n').slice(1).join('\n')) {
-        await fs.writeFile(tsAbsolutePath, tsContent);
-    }
     // Recursive function to delete unnecessary JSON files and folders
     async function deleteUnnecessaryJsonFiles(dirPath) {
         const entries = await fs.readdir(dirPath, { withFileTypes: true });

package/dist/dev/index.mjs

@@ -6,7 +6,7 @@ import keyBy from 'lodash/keyBy.js';
 import capitalize from 'lodash/capitalize.js';
 import debounce from 'lodash/debounce.js';
 import once from 'lodash/once.js';
-import { debouncedEnsureSchemaFiles } from './ensureSchemaFiles.mjs';
+import ensureSchemaFiles, { debouncedEnsureSchemaFiles } from './ensureSchemaFiles.mjs';
 import writeOneSegmentSchemaFile from './writeOneSegmentSchemaFile.mjs';
 import logDiffResult from './logDiffResult.mjs';
 import ensureClient from '../generate/ensureClient.mjs';
@@ -193,7 +193,6 @@ export class VovkDev {
             throw new Error('Already watching');
         const { log } = this.#projectInfo;
         log.debug(`Starting segments and modules watcher. Detected initial segments: ${JSON.stringify(this.#segments.map((s) => s.segmentName))}.`);
-        await ensureClient(this.#projectInfo);
         // automatically watches segments and modules
         this.#watchConfig(callback);
     }
@@ -226,7 +225,7 @@ export class VovkDev {
             }
         }
         else {
-            log.debug(`The file does not contain any controller`);
+            log.debug(`The file ${filePath} does not contain any controller`);
         }
     };
     #requestSchema = debounceWithArgs(async (segmentName) => {
@@ -321,7 +320,8 @@ export class VovkDev {
         const apiDirAbsolutePath = path.join(cwd, apiDir);
         const schemaOutAbsolutePath = path.join(cwd, config.schemaOutDir);
         this.#segments = await locateSegments({ dir: apiDirAbsolutePath, config });
-        await debouncedEnsureSchemaFiles(this.#projectInfo, schemaOutAbsolutePath, this.#segments.map((s) => s.segmentName));
+        await ensureSchemaFiles(this.#projectInfo, schemaOutAbsolutePath, this.#segments.map((s) => s.segmentName));
+        await ensureClient(this.#projectInfo);
         const MAX_ATTEMPTS = 5;
         const DELAY = 5000;
         // Request schema every segment in 5 seconds in order to update schema on start

package/dist/generate/getClientTemplates.mjs

@@ -27,6 +27,13 @@ export default async function getClientTemplates({ config, cwd, generateFrom = [
             fullSchema: false,
             origin: null,
         },
+        fullSchema: {
+            templateName: 'fullSchema',
+            templatePath: path.resolve(templatesDir, 'fullSchema/*'),
+            outDir: clientOutDirAbsolutePath,
+            fullSchema: false,
+            origin: null,
+        },
     };
     const generateFromStrict = generateFrom.map((template) => {
         if (typeof template === 'string') {
@@ -49,6 +56,9 @@ export default async function getClientTemplates({ config, cwd, generateFrom = [
             origin: template.origin ?? null,
         };
     });
+    if (['ts', 'main', 'module'].some((template) => generateFromStrict.some((item) => item.templateName === template))) {
+        generateFromStrict.unshift(builtIn.fullSchema);
+    }
     const templateFiles = [];
     for (const generateFromItem of generateFromStrict) {
         const files = await glob(generateFromItem.templatePath);

package/dist/generate/index.mjs

@@ -8,6 +8,7 @@ import prettify from '../utils/prettify.mjs';
 import getClientTemplates, { DEFAULT_FULL_SCHEMA_FILE_NAME } from './getClientTemplates.mjs';
 import chalkHighlightThing from '../utils/chalkHighlightThing.mjs';
 import _ from 'lodash';
+import { ROOT_SEGMENT_SCHEMA_NAME, SEGMENTS_SCHEMA_DIR_NAME } from '../dev/writeOneSegmentSchemaFile.mjs';
 export default async function generate({ projectInfo, segments, forceNothingWrittenLog, templates, prettify: prettifyClient, fullSchema, emitFullSchema, }) {
     const segmentsSchema = fullSchema.segments;
     const generateFrom = templates ?? projectInfo.config.generateFrom;
@@ -25,6 +26,7 @@ export default async function generate({ projectInfo, segments, forceNothingWrit
             continue;
     }
     const now = Date.now();
+    const schemaOutDir = path.relative(config.clientOutDir, config.schemaOutDir).replace(/\\/g, '/'); // windows fix
     // Process each template in parallel
     const processedTemplates = noClient
         ? []
@@ -38,9 +40,12 @@ export default async function generate({ projectInfo, segments, forceNothingWrit
             // Data for the EJS templates:
             const t = {
                 _, // lodash
+                ROOT_SEGMENT_SCHEMA_NAME,
+                SEGMENTS_SCHEMA_DIR_NAME,
                 apiRoot: origin ? `${origin}/${config.rootEntry}` : apiRoot,
                 imports: clientImports,
                 fullSchema,
+                schemaOutDir,
                 segmentMeta: Object.fromEntries(segments.map(({ segmentName, ...s }) => [segmentName, s])),
             };
             if (data.imports instanceof Array) {

package/dist/getProjectInfo/index.d.mts

@@ -12,12 +12,10 @@ export default function getProjectInfo({ port: givenPort, clientOutDir, configPa
     srcRoot: string;
     config: import("vovk").VovkStrictConfig;
     clientImports: {
-        fullSchema: string;
         fetcher: string;
         createRPC: string;
         validateOnClient: string | null;
         module: {
-            fullSchema: string;
             fetcher: string;
             createRPC: string;
             validateOnClient: string | null;

package/dist/getProjectInfo/index.mjs

@@ -12,8 +12,6 @@ export default async function getProjectInfo({ port: givenPort, clientOutDir, co
     });
     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
-        '/main.cjs';
     const log = getLogger(config.logLevel);
     if (configAbsolutePaths.length > 1) {
         log.warn(`Multiple config files found. Using the first one: ${configAbsolutePaths[0]}`);
@@ -23,12 +21,10 @@ export default async function getProjectInfo({ port: givenPort, clientOutDir, co
     }
     const getImportPath = (p) => (p.startsWith('.') ? path.relative(config.clientOutDir, p) : p);
     const clientImports = {
-        fullSchema: schemaOutImportPath,
         fetcher: getImportPath(config.fetcherImport[0]),
         createRPC: getImportPath(config.createRPCImport[0]),
         validateOnClient: config.validateOnClientImport ? getImportPath(config.validateOnClientImport[0]) : null,
         module: {
-            fullSchema: schemaOutImportPath,
             fetcher: getImportPath(config.fetcherImport[1] ?? config.fetcherImport[0]),
             createRPC: getImportPath(config.createRPCImport[1] ?? config.createRPCImport[0]),
             validateOnClient: config.validateOnClientImport

package/dist/index.mjs

@@ -1,7 +1,6 @@
 #!/usr/bin/env node
 import path from 'node:path';
 import { readFileSync } from 'node:fs';
-import { pathToFileURL } from 'node:url';
 import 'dotenv/config';
 import { Command } from 'commander';
 import concurrently from 'concurrently';
@@ -12,6 +11,7 @@ import locateSegments from './locateSegments.mjs';
 import { VovkDev } from './dev/index.mjs';
 import newComponents from './new/index.mjs';
 import initProgram from './initProgram.mjs';
+import { getFullSchemaFromJSON } from './utils/getFullSchemaFromJSON.mjs';
 const program = new Command();
 const packageJSON = JSON.parse(readFileSync(path.join(import.meta.dirname, '../package.json'), 'utf-8'));
 program.name('vovk').description('Vovk CLI').version(packageJSON.version);
@@ -75,7 +75,7 @@ program
     .description('Generate RPC client from schema')
     .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('--emit-full-schema, --full-schema [fileName]', 'generate client with full schema')
+    .option('--emit-full-schema, --full-schema-json [fileName]', 'generate client with full schema')
     .option('--prettify', 'prettify output files')
     .option('--config <config>', 'path to config file')
     .action(async (options) => {
@@ -84,8 +84,7 @@ program
     const { cwd, config, apiDir } = projectInfo;
     const segments = await locateSegments({ dir: apiDir, config });
     const schemaOutAbsolutePath = path.join(cwd, config.schemaOutDir);
-    const schemaImportUrl = pathToFileURL(path.join(schemaOutAbsolutePath, 'main.cjs')).href;
-    const { default: fullSchema } = (await import(schemaImportUrl));
+    const fullSchema = await getFullSchemaFromJSON(schemaOutAbsolutePath, projectInfo);
     await generate({
         projectInfo,
         segments,

package/dist/utils/getFullSchemaFromJSON.d.mts

@@ -0,0 +1,3 @@
+import type { VovkFullSchema } from 'vovk';
+import { ProjectInfo } from '../getProjectInfo/index.mjs';
+export declare function getFullSchemaFromJSON(schemaOutAbsolutePath: string, projectInfo: ProjectInfo): Promise<VovkFullSchema>;

package/dist/utils/getFullSchemaFromJSON.mjs

@@ -0,0 +1,63 @@
+import { glob, readFile, access } from 'node:fs/promises';
+import * as path from 'node:path';
+export async function getFullSchemaFromJSON(schemaOutAbsolutePath, projectInfo) {
+    const result = {
+        config: {},
+        segments: {},
+    };
+    const { log } = projectInfo;
+    // Handle config.json
+    const configPath = path.join(schemaOutAbsolutePath, 'config.json');
+    try {
+        const configContent = await readFile(configPath, 'utf-8');
+        result.config = JSON.parse(configContent);
+    }
+    catch {
+        log.warn(`Warning: config.json not found at ${configPath}. Using empty config as fallback.`);
+        result.config = {};
+    }
+    // Handle segments directory
+    const segmentsDir = path.join(schemaOutAbsolutePath, 'segments');
+    try {
+        await access(segmentsDir); // Check if directory exists
+        // Use glob to get all JSON files recursively
+        const files = await glob(`${segmentsDir}/**/*.json`);
+        // Process each JSON file
+        for await (const filePath of files) {
+            try {
+                const content = await readFile(filePath, 'utf-8');
+                const jsonData = JSON.parse(content);
+                // Get relative path from segments directory and convert to key
+                let relativePath = path
+                    .relative(segmentsDir, filePath)
+                    .replace(/\.json$/, '') // Remove .json extension
+                    .replace(/\\/g, '/'); // Normalize to forward slashes
+                // Special case for _root.json
+                if (path.basename(filePath) === '_root.json' && path.dirname(filePath) === segmentsDir) {
+                    relativePath = '';
+                }
+                result.segments[relativePath] = jsonData;
+            }
+            catch (error) {
+                log.warn(`Warning: Failed to process file ${filePath}: ${error}`);
+            }
+        }
+    }
+    catch {
+        log.warn(`Warning: Segments directory not found at ${segmentsDir}. Using empty segments as fallback.`);
+        result.segments = {};
+    }
+    return result;
+}
+// Example usage:
+/*
+async function main() {
+  try {
+    const schema = await getSchemaFromJSON('/path/to/directory');
+    console.log(schema);
+  } catch (error) {
+    console.error('Error:', error);
+  }
+}
+main();
+*/

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vovk-cli",
-  "version": "0.0.1-draft.113",
+  "version": "0.0.1-draft.115",
   "bin": {
     "vovk": "./dist/index.mjs"
   },
@@ -35,7 +35,7 @@
   },
   "homepage": "https://vovk.dev",
   "peerDependencies": {
-    "vovk": "^3.0.0-draft.97"
+    "vovk": "^3.0.0-draft.108"
   },
   "optionalDependencies": {
     "vovk-python-client": "*"

package/client-templates/python/__init__.py

@@ -1,276 +0,0 @@
-import os
-import json
-import requests
-from jsonschema import validate
-from jsonschema.exceptions import ValidationError
-from typing import Optional
-
-__all__ = []  # We'll populate this dynamically
-
-class ServerError(Exception):
-    """Custom exception for server errors that include statusCode and/or message."""
-    def __init__(self, status_code: int, message: str):
-        super().__init__(f"[{status_code}] {message}")
-        self.status_code = status_code
-        self.server_message = message
-
-def _load_full_schema() -> dict:
-    """
-    Loads the 'full-schema.json' file (which must sit in the same folder as this __init__.py).
-    Returns it as a Python dictionary.
-    """
-    current_dir = os.path.dirname(__file__)
-    schema_path = os.path.join(current_dir, "full-schema.json")
-    with open(schema_path, "r", encoding="utf-8") as f:
-        return json.load(f)
-
-class _RPCBase:
-    """
-    Base class that provides a validated HTTP request mechanism.
-    All dynamic RPC classes will subclass this.
-    """
-    def __init__(self, base_url: str):
-        self.base_url = base_url.rstrip("/")
-
-    def _handle_stream_response(self, resp: requests.Response):
-        """
-        Returns a generator that yields JSON objects from a newline-delimited stream.
-        It attempts to parse each line as valid JSON.
-        If we encounter an 'isError' structure, we raise a ServerError immediately.
-        """
-        buffer = ""
-
-        # We'll use resp.iter_content(...) to handle partial chunks
-        # decode_unicode=True gives us str chunks in Python 3.
-        for chunk in resp.iter_content(chunk_size=None, decode_unicode=True):
-            buffer += chunk
-            lines = buffer.split("\n")
-            # We'll parse every line except the last, which might still be partial
-            for line in lines[:-1]:
-                line = line.strip()
-                if not line:
-                    continue  # skip empty lines
-
-                try:
-                    data = json.loads(line)
-                except json.JSONDecodeError:
-                    # Could happen if line is incomplete, but we got a newline anyway
-                    continue
-
-                # If the server signals an error in-stream
-                if data.get("isError") and "reason" in data:
-                    resp.close()
-                    raise ServerError(resp.status_code, str(data["reason"]))
-
-                yield data
-
-            # The last piece (lines[-1]) may be incomplete
-            buffer = lines[-1]
-
-        # If there's leftover data in the buffer (no trailing newline at end):
-        leftover = buffer.strip()
-        if leftover:
-            try:
-                data = json.loads(leftover)
-                if data.get("isError") and "reason" in data:
-                    resp.close()
-                    raise ServerError(resp.status_code, str(data["reason"]))
-                yield data
-            except json.JSONDecodeError:
-                # Not valid JSON or partial leftover
-                pass
-
-        # End of stream; close the connection
-        resp.close()
-
-    def _request(
-        self,
-        method: str,
-        endpoint_path: str,
-        query: Optional[dict] = None,
-        body: Optional[dict] = None,
-        query_schema: Optional[dict] = None,
-        body_schema: Optional[dict] = None,
-        disable_client_validation: bool = False
-    ):
-        """
-        1. If disable_client_validation is False, validates `query` & `body` (if schemas).
-        2. Makes an HTTP request (using `requests` with stream=True).
-        3. If the response is not 2xx:
-           - parse JSON for a possible error structure
-           - or raise requests.HTTPError if not available
-        4. If 'x-vovk-stream' == 'true', return a generator that yields JSON objects.
-        5. Otherwise, parse and return the actual response (JSON -> dict or fallback to text).
-        """
-        # Validate query and body if schemas are provided AND validation not disabled
-        if not disable_client_validation:
-            if query_schema:
-                validate(instance=query or {}, schema=query_schema)
-            if body_schema:
-                validate(instance=body or {}, schema=body_schema)
-
-        # Build the final URL
-        url = f"{self.base_url}/{endpoint_path}"
-
-        # Make the request (stream=True to handle streaming)
-        resp = requests.request(
-            method=method,
-            url=url,
-            params=query,
-            json=body,
-            stream=True
-        )
-
-        # Check if status is not 2xx
-        if not resp.ok:
-            try:
-                # Attempt to parse JSON error
-                data = resp.json()
-                # Example: { "statusCode": 400, "message": "Zod validation failed...", "isError": true }
-                if data.get("isError"):
-                    status_code = data.get("statusCode", resp.status_code)
-                    message = data.get("message", resp.text)
-                    resp.close()
-                    raise ServerError(status_code, message)
-                else:
-                    # Not the structured error we expect - fallback
-                    resp.raise_for_status()
-            except ValueError:
-                # If parsing fails, fallback
-                resp.raise_for_status()
-
-        # If we get here, resp is 2xx. Check if streaming is requested.
-        if resp.headers.get("x-vovk-stream", "").lower() == "true":
-            return self._handle_stream_response(resp)
-
-        # Non-streaming: parse JSON or return text
-        content_type = resp.headers.get("Content-Type", "").lower()
-        try:
-            if "application/json" in content_type:
-                result = resp.json()  # parse the body as JSON
-            else:
-                result = resp.text  # fallback if not JSON
-        finally:
-            # In either case, we can close the connection now since we're reading full body
-            resp.close()
-
-        return result
-
-
-def _build_controller_class(
-    controller_name: str,
-    controller_spec: dict,
-    segment_name: str
-):
-    """
-    Builds a dynamic class (subclass of _RPCBase) for a single controller.
-    Instead of instance methods, we create class methods so we can call
-    them directly on the class (passing base_url, query, body, etc.).
-
-    The endpoints will be constructed as: `segmentName/prefix/path`.
-    If `prefix` or `path` contain placeholder segments like `:id`, 
-    they can be replaced by passing a `params` dict, e.g. { "id": 123 }
-    which would convert "/foo/:id/bar" --> "/foo/123/bar"
-    """
-    prefix = controller_spec.get("prefix", "").strip("/")
-    handlers = controller_spec.get("handlers", {})
-
-    class_attrs = {}
-
-    for handler_name, handler_data in handlers.items():
-        # HTTP method (e.g., "GET", "POST", etc.)
-        http_method = handler_data["httpMethod"]
-
-        # Path defined in the schema (may contain ":id", etc.)
-        path = handler_data["path"].strip("/")
-
-        # Combine "segmentName/prefix/path" into a single path
-        endpoint_path = f"{segment_name}/{prefix}/{path}".strip("/")
-
-        # Optional JSON schemas (for query/body)
-        validation = handler_data.get("validation", {})
-        query_schema = validation.get("query")
-        body_schema = validation.get("body")
-
-        def make_class_method(
-            m=http_method,
-            ep=endpoint_path,
-            q_schema=query_schema,
-            b_schema=body_schema,
-            name=handler_name
-        ):
-            @classmethod
-            def handler(cls, base_url, *, query=None, body=None, params=None, disable_client_validation=False):
-                """
-                Class method that instantiates the RPC class (with base_url)
-                and immediately calls _request on that instance.
-
-                :param base_url:   The base URL of your API.
-                :param query:      An optional dict for query parameters.
-                :param body:       An optional dict for the request JSON body.
-                :param params:     A dict for path substitutions, e.g. {"id": 42}
-                                   which will replace ":id" in the endpoint path.
-                :param disable_client_validation: If True, skip schema validation.
-                """
-                final_endpoint_path = ep
-
-                # Perform path param substitution if needed
-                for param_key, param_val in (params or {}).items():
-                    final_endpoint_path = final_endpoint_path.replace(
-                        f":{param_key}",
-                        str(param_val)
-                    )
-
-                # Instantiate and make the request
-                temp_instance = cls(base_url)
-                return temp_instance._request(
-                    method=m,
-                    endpoint_path=final_endpoint_path,
-                    query=query,
-                    body=body,
-                    query_schema=q_schema,
-                    body_schema=b_schema,
-                    disable_client_validation=disable_client_validation
-                )
-
-            handler.__name__ = name
-            return handler
-
-        # Attach the generated class method for this handler
-        class_attrs[handler_name] = make_class_method()
-
-    # Dynamically create a new subclass of _RPCBase with those methods
-    return type(controller_name, (_RPCBase,), class_attrs)
-
-def _load_controllers():
-    """
-    Reads the entire 'full-schema.json',
-    iterates over each top-level segment (like 'xxx', 'yyy'),
-    extracts the segmentName + controllers,
-    and dynamically builds classes for each controller.
-    """
-    data = _load_full_schema()
-    all_controllers = {}
-
-    for segment_key, segment_obj in data.items():
-        segment_name = segment_obj.get("segmentName", "").strip("/")
-        controllers = segment_obj.get("controllers", {})
-
-        for ctrl_name, ctrl_spec in controllers.items():
-            dynamic_class = _build_controller_class(
-                controller_name=ctrl_name,
-                controller_spec=ctrl_spec,
-                segment_name=segment_name
-            )
-            all_controllers[ctrl_name] = dynamic_class
-
-    return all_controllers
-
-# Build all controllers at import time
-_controllers_dict = _load_controllers()
-
-# Export them at the top level
-for ctrl_name, ctrl_class in _controllers_dict.items():
-    globals()[ctrl_name] = ctrl_class
-    __all__.append(ctrl_name)
-

package/dist/postinstall.d.mts

@@ -1 +0,0 @@
-export {};

package/dist/postinstall.mjs

@@ -1,21 +0,0 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import getFileSystemEntryType from './utils/getFileSystemEntryType.mjs';
-async function postinstall() {
-    // 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');
-    await fs.mkdir(vovk, { recursive: true });
-    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();