vovk-cli 0.0.1-draft.40 → 0.0.1-draft.41

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

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

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

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

package/client-templates/python/__init__.py

@@ -0,0 +1,276 @@
+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/client-templates/ts/index.ts.ejs

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

package/dist/dev/index.mjs

@@ -40,7 +40,11 @@ export class VovkDev {
                 const segmentName = getSegmentName(filePath);
                 this.#segments = this.#segments.find((s) => s.segmentName === segmentName)
                     ? this.#segments
-                    : [...this.#segments, { routeFilePath: filePath, segmentName }];
+                    : [...this.#segments, {
+                            routeFilePath: filePath,
+                            segmentName,
+                            segmentImportPath: path.relative(config.clientOutDir, filePath) // TODO DRY locateSegments 
+                        }];
                 log.info(`${capitalize(formatLoggedSegmentName(segmentName))} has been added`);
                 log.debug(`Full list of segments: ${this.#segments.map((s) => s.segmentName).join(', ')}`);
                 void debouncedEnsureSchemaFiles(this.#projectInfo, schemaOutAbsolutePath, this.#segments.map((s) => s.segmentName));
@@ -54,14 +58,14 @@ export class VovkDev {
         })
             .on('addDir', async (dirPath) => {
             log.debug(`Directory ${dirPath} has been added to segments folder`);
-            this.#segments = await locateSegments(apiDirAbsolutePath);
+            this.#segments = await locateSegments({ dir: apiDirAbsolutePath, config });
             for (const { segmentName } of this.#segments) {
                 void this.#requestSchema(segmentName);
             }
         })
             .on('unlinkDir', async (dirPath) => {
             log.debug(`Directory ${dirPath} has been removed from segments folder`);
-            this.#segments = await locateSegments(apiDirAbsolutePath);
+            this.#segments = await locateSegments({ dir: apiDirAbsolutePath, config });
             for (const { segmentName } of this.#segments) {
                 void this.#requestSchema(segmentName);
             }
@@ -267,11 +271,11 @@ export class VovkDev {
             }
         }
         else if (schema && (!isEmpty(schema.controllers) || !isEmpty(schema.workers))) {
-            log.error(`Non-empty schema provided for ${formatLoggedSegmentName(segment.segmentName)} but emitSchema is false`);
+            log.error(`Non-empty schema provided for ${formatLoggedSegmentName(segment.segmentName)} but "emitSchema" is false`);
         }
         if (this.#segments.every((s) => this.#schemas[s.segmentName])) {
             log.debug(`All segments with "emitSchema" have schema.`);
-            await generateClient(this.#projectInfo, this.#segments, this.#schemas);
+            await generateClient({ projectInfo: this.#projectInfo, segments: this.#segments, segmentsSchema: this.#schemas });
         }
     }
     async start() {
@@ -295,9 +299,9 @@ export class VovkDev {
         });
         const apiDirAbsolutePath = path.join(cwd, apiDir);
         const schemaOutAbsolutePath = path.join(cwd, config.schemaOutDir);
-        this.#segments = await locateSegments(apiDirAbsolutePath);
+        this.#segments = await locateSegments({ dir: apiDirAbsolutePath, config });
         await debouncedEnsureSchemaFiles(this.#projectInfo, schemaOutAbsolutePath, this.#segments.map((s) => s.segmentName));
-        // Request schema every segment in 5 seconds in order to update schema and start watching
+        // Request schema every segment in 5 seconds in order to update schema on start
         setTimeout(() => {
             for (const { segmentName } of this.#segments) {
                 const MAX_ATTEMPTS = 3;

package/dist/generateClient.d.mts

@@ -1,7 +1,12 @@
 import type { VovkSchema } from 'vovk';
 import type { ProjectInfo } from './getProjectInfo/index.mjs';
 import type { Segment } from './locateSegments.mjs';
-export default function generateClient(projectInfo: ProjectInfo, segments: Segment[], segmentsSchema: Record<string, VovkSchema>): Promise<{
+import { GenerateOptions } from './types.mjs';
+export default function generateClient({ projectInfo, segments, segmentsSchema, templates, prettify: prettifyClient, fullSchema, noClient, }: {
+    projectInfo: ProjectInfo;
+    segments: Segment[];
+    segmentsSchema: Record<string, VovkSchema>;
+} & Pick<GenerateOptions, 'templates' | 'prettify' | 'fullSchema' | 'noClient'>): Promise<{
     written: boolean;
     path: string;
 }>;

package/dist/generateClient.mjs

@@ -1,59 +1,32 @@
 import path from 'node:path';
 import fs from 'node:fs/promises';
+import ejs from 'ejs';
 import formatLoggedSegmentName from './utils/formatLoggedSegmentName.mjs';
 import prettify from './utils/prettify.mjs';
-export default async function generateClient(projectInfo, segments, segmentsSchema) {
-    const { config, cwd, log, validateOnClientImportPath, apiEntryPoint, fetcherClientImportPath, schemaOutImportPath } = projectInfo;
-    const now = Date.now();
-    const clientoOutDirAbsolutePath = path.join(cwd, config.clientOutDir);
-    let dts = `// auto-generated
-/* eslint-disable */
-import type { clientizeController } from 'vovk/client';
-import type { promisifyWorker } from 'vovk/worker';
-import type { VovkClientFetcher } from 'vovk/client';
-import type fetcher from '${fetcherClientImportPath}';
-
-`;
-    let js = `// auto-generated
-/* eslint-disable */
-const { clientizeController } = require('vovk/client');
-const { promisifyWorker } = require('vovk/worker');
-const { default: fetcher } = require('${fetcherClientImportPath}');
-const schema = require('${schemaOutImportPath}');
-`;
-    let ts = `// auto-generated
-/* eslint-disable */
-import { clientizeController } from 'vovk/client';
-import { promisifyWorker } from 'vovk/worker';
-import type { VovkClientFetcher } from 'vovk/client';
-import fetcher from '${fetcherClientImportPath}';
-import schema from '${schemaOutImportPath}';
-
-`;
-    for (let i = 0; i < segments.length; i++) {
-        const { routeFilePath, segmentName } = segments[i];
-        const schema = segmentsSchema[segmentName];
-        if (!schema) {
-            throw new Error(`Unable to generate client. No schema found for ${formatLoggedSegmentName(segmentName)}`);
+export default async function generateClient({ projectInfo, segments, segmentsSchema, templates = ['ts', 'compiled'], prettify: prettifyClient, fullSchema, noClient, }) {
+    const { config, cwd, log, validateOnClientImportPath, apiEntryPoint, fetcherClientImportPath, schemaOutImportPath, } = projectInfo;
+    const __dirname = path.dirname(new URL(import.meta.url).pathname);
+    const templatesDir = path.join(__dirname, '..', 'client-templates');
+    const clientOutDirAbsolutePath = path.resolve(cwd, config.clientOutDir);
+    const mapper = (dir) => (name) => ({
+        templatePath: path.resolve(templatesDir, dir, name),
+        outPath: path.join(clientOutDirAbsolutePath, name.replace('.ejs', '')),
+    });
+    const builtInTemplatesMap = {
+        ts: ['index.ts.ejs'].map(mapper('ts')),
+        compiled: ['client.js.ejs', 'client.d.ts.ejs'].map(mapper('compiled')),
+        python: ['__init__.py'].map(mapper('python')),
+    };
+    const templateFiles = templates.reduce((acc, template) => {
+        if (template in builtInTemplatesMap) {
+            return [...acc, ...builtInTemplatesMap[template]];
         }
-        if (!schema.emitSchema)
-            continue;
-        const importRouteFilePath = path.relative(config.clientOutDir, routeFilePath);
-        dts += `import type { Controllers as Controllers${i}, Workers as Workers${i} } from "${importRouteFilePath}";\n`;
-        ts += `import type { Controllers as Controllers${i}, Workers as Workers${i} } from "${importRouteFilePath}";\n`;
-    }
-    dts += `
-type Options = typeof fetcher extends VovkClientFetcher<infer U> ? U : never;
-`;
-    ts += `
-${validateOnClientImportPath ? `import validateOnClient from '${validateOnClientImportPath}';\n` : '\nconst validateOnClient = undefined;'}
-type Options = typeof fetcher extends VovkClientFetcher<infer U> ? U : never;
-const apiRoot = '${apiEntryPoint}';
-`;
-    js += `
-const { default: validateOnClient = null } = ${validateOnClientImportPath ? `require('${validateOnClientImportPath}')` : '{}'};
-const apiRoot = '${apiEntryPoint}';
-`;
+        return [...acc, {
+                templatePath: path.resolve(cwd, template),
+                outPath: path.join(clientOutDirAbsolutePath, path.basename(template).replace('.ejs', ''))
+            }];
+    }, []);
+    // Ensure that each segment has a matching schema if it needs to be emitted:
     for (let i = 0; i < segments.length; i++) {
         const { segmentName } = segments[i];
         const schema = segmentsSchema[segmentName];
@@ -62,36 +35,57 @@ const apiRoot = '${apiEntryPoint}';
         }
         if (!schema.emitSchema)
             continue;
-        for (const key of Object.keys(schema.controllers)) {
-            dts += `export const ${key}: ReturnType<typeof clientizeController<Controllers${i}["${key}"], Options>>;\n`;
-            js += `exports.${key} = clientizeController(schema['${segmentName}'].controllers.${key}, '${segmentName}', { fetcher, validateOnClient, defaultOptions: { apiRoot } });\n`;
-            ts += `export const ${key} = clientizeController<Controllers${i}["${key}"], Options>(schema['${segmentName}'].controllers.${key}, '${segmentName}', { fetcher, validateOnClient, defaultOptions: { apiRoot } });\n`;
-        }
-        for (const key of Object.keys(schema.workers)) {
-            dts += `export const ${key}: ReturnType<typeof promisifyWorker<Workers${i}["${key}"]>>;\n`;
-            js += `exports.${key} = promisifyWorker(null, schema['${segmentName}'].workers.${key});\n`;
-            ts += `export const ${key} = promisifyWorker<Workers${i}["${key}"]>(null, schema['${segmentName}'].workers.${key});\n`;
-        }
     }
-    const localJsAbsolutePath = path.join(clientoOutDirAbsolutePath, 'client.js');
-    const localDtsAbsolutePath = path.join(clientoOutDirAbsolutePath, 'client.d.ts');
-    const localTsAbsolutePath = path.join(clientoOutDirAbsolutePath, 'index.ts');
-    const existingJs = await fs.readFile(localJsAbsolutePath, 'utf-8').catch(() => '');
-    const existingDts = await fs.readFile(localDtsAbsolutePath, 'utf-8').catch(() => '');
-    const existingTs = await fs.readFile(localTsAbsolutePath, 'utf-8').catch(() => '');
-    if (config.prettifyClient) {
-        js = await prettify(js, localJsAbsolutePath);
-        dts = await prettify(dts, localDtsAbsolutePath);
-        ts = await prettify(ts, localTsAbsolutePath);
+    const now = Date.now();
+    // Data for the EJS templates:
+    const ejsData = {
+        apiEntryPoint,
+        fetcherClientImportPath,
+        schemaOutImportPath,
+        validateOnClientImportPath,
+        segments,
+        segmentsSchema,
+    };
+    // 1. Process each template in parallel
+    const processedTemplates = noClient ? [] : await Promise.all(templateFiles.map(async ({ templatePath, outPath }) => {
+        // Read the EJS template
+        const templateContent = await fs.readFile(templatePath, 'utf-8');
+        // Render the template
+        let rendered = templatePath.endsWith('.ejs') ? ejs.render(templateContent, ejsData) : templateContent;
+        // Optionally prettify
+        if (prettifyClient || config.prettifyClient) {
+            rendered = await prettify(rendered, outPath);
+        }
+        // Read existing file content to compare
+        const existingContent = await fs.readFile(outPath, 'utf-8').catch(() => '');
+        // Determine if we need to rewrite the file
+        const needsWriting = existingContent !== rendered;
+        return {
+            outPath,
+            rendered,
+            needsWriting,
+        };
+    }));
+    if (fullSchema) {
+        const fullSchemaOutAbsolutePath = path.resolve(clientOutDirAbsolutePath, typeof fullSchema === 'string' ? fullSchema : 'full-schema.json');
+        await fs.writeFile(fullSchemaOutAbsolutePath, JSON.stringify(segmentsSchema, null, 2));
+        log.info(`Full schema written to ${fullSchemaOutAbsolutePath}`);
     }
-    if (existingJs === js && existingDts === dts && existingTs === ts) {
+    // 2. Check if any file needs rewriting
+    const anyNeedsWriting = processedTemplates.some(({ needsWriting }) => needsWriting);
+    if (!anyNeedsWriting) {
         log.debug(`Client is up to date and doesn't need to be regenerated (${Date.now() - now}ms)`);
-        return { written: false, path: clientoOutDirAbsolutePath };
+        return { written: false, path: clientOutDirAbsolutePath };
     }
-    await fs.mkdir(clientoOutDirAbsolutePath, { recursive: true });
-    await fs.writeFile(localJsAbsolutePath, js);
-    await fs.writeFile(localDtsAbsolutePath, dts);
-    await fs.writeFile(localTsAbsolutePath, ts);
+    // 3. Make sure the output directory exists
+    await fs.mkdir(clientOutDirAbsolutePath, { recursive: true });
+    // 4. Write updated files where needed
+    await Promise.all(processedTemplates.map(({ outPath, rendered, needsWriting }) => {
+        if (needsWriting) {
+            return fs.writeFile(outPath, rendered);
+        }
+        return null;
+    }));
     log.info(`Client generated in ${Date.now() - now}ms`);
-    return { written: true, path: clientoOutDirAbsolutePath };
+    return { written: true, path: clientOutDirAbsolutePath };
 }

package/dist/index.mjs

@@ -63,16 +63,22 @@ program
 });
 program
     .command('generate')
+    .alias('g')
     .description('Generate client')
-    .option('--client-out <path>', 'Path to output directory')
+    .option('--out, --client-out-dir <path>', 'Path to output directory')
+    .option('--template, --templates <templates...>', 'Client code templates')
+    .option('--no-client', 'Do not generate client')
+    .option('--full-schema [fileName]', 'Generate client with full schema')
+    .option('--prettify', 'Prettify output files')
     .action(async (options) => {
-    const projectInfo = await getProjectInfo({ clientOutDir: options.clientOut });
+    const { clientOutDir, templates, prettify, noClient, fullSchema } = options;
+    const projectInfo = await getProjectInfo({ clientOutDir });
     const { cwd, config, apiDir } = projectInfo;
-    const segments = await locateSegments(apiDir);
+    const segments = await locateSegments({ dir: apiDir, config });
     const schemaOutAbsolutePath = path.join(cwd, config.schemaOutDir);
     const schemaImportUrl = pathToFileURL(path.join(schemaOutAbsolutePath, 'index.js')).href;
-    const schema = await import(schemaImportUrl);
-    await generateClient(projectInfo, segments, schema.default);
+    const { default: segmentsSchema } = await import(schemaImportUrl);
+    await generateClient({ projectInfo, segments, segmentsSchema, templates, prettify, noClient, fullSchema });
 });
 program
     .command('new [components...]')

package/dist/locateSegments.d.mts

@@ -1,5 +1,11 @@
+import type { VovkConfig } from './types.mjs';
 export type Segment = {
     routeFilePath: string;
     segmentName: string;
+    segmentImportPath: string;
 };
-export default function locateSegments(dir: string, rootDir?: string): Promise<Segment[]>;
+export default function locateSegments({ dir, rootDir, config }: {
+    dir: string;
+    rootDir?: string;
+    config: Required<VovkConfig> | null;
+}): Promise<Segment[]>;

package/dist/locateSegments.mjs

@@ -1,8 +1,10 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import getFileSystemEntryType from './utils/getFileSystemEntryType.mjs';
-export default async function locateSegments(dir, rootDir = dir) {
+// config: null is used for testing
+export default async function locateSegments({ dir, rootDir, config }) {
     let results = [];
+    rootDir = rootDir ?? dir;
     // Read the contents of the directory
     const list = await fs.readdir(dir);
     // Iterate through each item in the directory
@@ -17,11 +19,12 @@ export default async function locateSegments(dir, rootDir = dir) {
                 if (await getFileSystemEntryType(routeFilePath)) {
                     // Calculate the basePath relative to the root directory
                     const segmentName = path.relative(rootDir, dir).replace(/\\/g, '/'); // windows fix
-                    results.push({ routeFilePath, segmentName });
+                    const segmentImportPath = path.relative(config?.clientOutDir ?? '.__', routeFilePath);
+                    results.push({ routeFilePath, segmentName, segmentImportPath });
                 }
             }
             // Recursively search inside subdirectories
-            const subDirResults = await locateSegments(filePath, rootDir);
+            const subDirResults = await locateSegments({ dir: filePath, rootDir, config });
             results = results.concat(subDirResults);
         }
     }

package/dist/new/newModule.mjs

@@ -49,7 +49,7 @@ export default async function newModule({ what, moduleNameWithOptionalSegment, d
             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(`Unable to create module. Segment "${segmentName}" not found. Run "vovk new segment ${segmentName}" to create it`);

package/dist/new/newSegment.mjs

@@ -13,6 +13,8 @@ export default async function newSegment({ segmentName, overwrite, dryRun, }) {
     }
     const code = await prettify(`import { initVovk } from 'vovk';
 
+export const runtime = 'edge';
+
 const controllers = {};
 const workers = {};
 
@@ -29,5 +31,5 @@ ${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, 'thing'].filter(Boolean).join('/')}`)} to create a new controller`);
+    log.info(`${formatLoggedSegmentName(segmentName, { upperFirst: true })} created at ${absoluteSegmentRoutePath}. Run ${chalkHighlightThing(`npx vovk n s c ${[segmentName, 'thing'].filter(Boolean).join('/')}`)} to create a new controller with service.`);
 }

package/dist/types.d.mts

@@ -48,7 +48,11 @@ export interface DevOptions {
     nextDev?: boolean;
 }
 export interface GenerateOptions {
-    clientOut?: string;
+    clientOutDir?: string;
+    templates?: string[];
+    prettify?: boolean;
+    fullSchema?: string | boolean;
+    noClient?: boolean;
 }
 export interface InitOptions {
     yes?: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vovk-cli",
-  "version": "0.0.1-draft.40",
+  "version": "0.0.1-draft.41",
   "bin": {
     "vovk": "./dist/index.mjs"
   },