django-cfg 1.4.62__py3-none-any.whl → 1.4.64__py3-none-any.whl

django_cfg/apps/centrifugo/codegen/generators/typescript_thin/generator.py

@@ -0,0 +1,124 @@
+"""
+TypeScript thin wrapper client generator.
+"""
+
+import logging
+from pathlib import Path
+from typing import List, Type
+from pydantic import BaseModel
+from jinja2 import Environment, FileSystemLoader, select_autoescape
+
+from ...discovery import RPCMethodInfo
+from ...utils import to_typescript_method_name, pydantic_to_typescript
+
+logger = logging.getLogger(__name__)
+
+
+class TypeScriptThinGenerator:
+    """Generator for TypeScript thin wrapper clients."""
+
+    def __init__(
+        self,
+        methods: List[RPCMethodInfo],
+        models: List[Type[BaseModel]],
+        output_dir: Path,
+    ):
+        self.methods = methods
+        self.models = models
+        self.output_dir = Path(output_dir)
+
+        templates_dir = Path(__file__).parent / "templates"
+        self.jinja_env = Environment(
+            loader=FileSystemLoader(str(templates_dir)),
+            autoescape=select_autoescape(),
+            trim_blocks=True,
+            lstrip_blocks=True,
+        )
+
+    def generate(self):
+        """Generate all TypeScript files."""
+        self.output_dir.mkdir(parents=True, exist_ok=True)
+
+        self._generate_types()
+        self._generate_rpc_client()
+        self._generate_client()
+        self._generate_index()
+        self._generate_package_json()
+        self._generate_tsconfig()
+        self._generate_readme()
+
+        logger.info(f"✅ Generated TypeScript client in {self.output_dir}")
+
+    def _generate_types(self):
+        """Generate types.ts file."""
+        template = self.jinja_env.get_template("types.ts.j2")
+
+        types_data = []
+        for model in self.models:
+            ts_interface = pydantic_to_typescript(model)
+            types_data.append({
+                'name': model.__name__,
+                'code': ts_interface,
+            })
+
+        content = template.render(types=types_data)
+        (self.output_dir / "types.ts").write_text(content)
+
+    def _generate_rpc_client(self):
+        """Generate rpc-client.ts base class."""
+        template = self.jinja_env.get_template("rpc-client.ts.j2")
+        content = template.render()
+        (self.output_dir / "rpc-client.ts").write_text(content)
+
+    def _generate_client(self):
+        """Generate client.ts thin wrapper."""
+        template = self.jinja_env.get_template("client.ts.j2")
+
+        methods_data = []
+        for method in self.methods:
+            param_type = method.param_type.__name__ if method.param_type else "any"
+            return_type = method.return_type.__name__ if method.return_type else "any"
+            method_name_ts = to_typescript_method_name(method.name)
+
+            methods_data.append({
+                'name': method.name,
+                'name_ts': method_name_ts,
+                'param_type': param_type,
+                'return_type': return_type,
+                'docstring': method.docstring or f"Call {method.name} RPC method",
+            })
+
+        model_names = [m.__name__ for m in self.models]
+
+        content = template.render(methods=methods_data, models=model_names)
+        (self.output_dir / "client.ts").write_text(content)
+
+    def _generate_index(self):
+        """Generate index.ts file."""
+        template = self.jinja_env.get_template("index.ts.j2")
+        model_names = [m.__name__ for m in self.models]
+        content = template.render(models=model_names)
+        (self.output_dir / "index.ts").write_text(content)
+
+    def _generate_package_json(self):
+        """Generate package.json file."""
+        template = self.jinja_env.get_template("package.json.j2")
+        content = template.render()
+        (self.output_dir / "package.json").write_text(content)
+
+    def _generate_tsconfig(self):
+        """Generate tsconfig.json file."""
+        template = self.jinja_env.get_template("tsconfig.json.j2")
+        content = template.render()
+        (self.output_dir / "tsconfig.json").write_text(content)
+
+    def _generate_readme(self):
+        """Generate README.md file."""
+        template = self.jinja_env.get_template("README.md.j2")
+        methods_data = [{'name': m.name, 'name_ts': to_typescript_method_name(m.name)} for m in self.methods[:3]]
+        model_names = [m.__name__ for m in self.models]
+        content = template.render(methods=methods_data, models=model_names)
+        (self.output_dir / "README.md").write_text(content)
+
+
+__all__ = ['TypeScriptThinGenerator']

django_cfg/apps/centrifugo/codegen/generators/typescript_thin/templates/README.md.j2

@@ -0,0 +1,38 @@
+# Generated TypeScript Client
+
+Auto-generated type-safe TypeScript client for Centrifugo WebSocket RPC.
+
+## Installation
+
+```bash
+npm install centrifuge
+```
+
+## Usage
+
+```typescript
+import { CentrifugoRPCClient, APIClient } from './client';
+
+async function main() {
+  const rpc = new CentrifugoRPCClient(
+    'ws://localhost:8000/connection/websocket',
+    'your-jwt-token',
+    'user-123'
+  );
+
+  await rpc.connect();
+
+  const api = new APIClient(rpc);
+  
+{% if methods %}
+{% for method in methods %}
+  const result = await api.{{ method.name_ts }}(params);
+{% endfor %}
+{% endif %}
+
+  await rpc.disconnect();
+}
+```
+
+---
+**Generated by django_cfg.apps.centrifugo.codegen**

django_cfg/apps/centrifugo/codegen/generators/typescript_thin/templates/client.ts.j2

@@ -0,0 +1,25 @@
+/**
+ * Generated API Client
+ * Auto-generated thin wrapper - DO NOT EDIT
+ */
+
+import { CentrifugoRPCClient } from './rpc-client';
+{% if models %}
+import type {
+{% for model_name in models | unique | sort %}  {{ model_name }},
+{% endfor %}} from './types';
+{% endif %}
+
+export class APIClient {
+  constructor(private rpc: CentrifugoRPCClient) {}
+
+{% for method in methods %}
+  /**
+   * {{ method.docstring.split('\n')[0] if method.docstring else 'No description' }}
+   */
+  async {{ method.name_ts }}(params: {{ method.param_type }}): Promise<{{ method.return_type }}> {
+    return this.rpc.call<{{ method.return_type }}>('{{ method.name }}', params);
+  }
+
+{% endfor %}
+}

django_cfg/apps/centrifugo/codegen/generators/typescript_thin/templates/index.ts.j2

@@ -0,0 +1,12 @@
+/**
+ * Generated TypeScript Client Package
+ * Auto-generated - DO NOT EDIT
+ */
+
+export { CentrifugoRPCClient } from './rpc-client';
+export { APIClient } from './client';
+{% if models %}
+export type {
+{% for model_name in models | unique | sort %}  {{ model_name }},
+{% endfor %}} from './types';
+{% endif %}

django_cfg/apps/centrifugo/codegen/generators/typescript_thin/templates/package.json.j2

@@ -0,0 +1,13 @@
+{
+  "name": "centrifugo-client",
+  "version": "1.0.0",
+  "description": "Generated Centrifugo WebSocket RPC client",
+  "main": "index.ts",
+  "types": "index.ts",
+  "dependencies": {
+    "centrifuge": "^5.0.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.0.0"
+  }
+}

django_cfg/apps/centrifugo/codegen/generators/typescript_thin/templates/rpc-client.ts.j2

@@ -0,0 +1,137 @@
+/**
+ * Base Centrifugo RPC Client
+ *
+ * Handles WebSocket connection and RPC call correlation.
+ * Auto-generated - DO NOT EDIT
+ */
+
+import { Centrifuge } from 'centrifuge';
+
+export class CentrifugoRPCClient {
+  private centrifuge: Centrifuge;
+  private subscription: any;
+  private pendingRequests: Map<string, { resolve: Function; reject: Function }> = new Map();
+  private readonly replyChannel: string;
+  private readonly timeout: number;
+
+  constructor(
+    url: string,
+    token: string,
+    userId: string,
+    timeout: number = 30000
+  ) {
+    this.replyChannel = `user#${userId}`;
+    this.timeout = timeout;
+
+    this.centrifuge = new Centrifuge(url, {
+      token,
+    });
+
+    this.centrifuge.on('connected', (ctx) => {
+      console.log('✅ Connected to Centrifugo');
+    });
+
+    this.centrifuge.on('disconnected', (ctx) => {
+      console.warn('Disconnected:', ctx);
+      // Reject all pending requests
+      this.pendingRequests.forEach(({ reject }) => {
+        reject(new Error('Disconnected from Centrifugo'));
+      });
+      this.pendingRequests.clear();
+    });
+  }
+
+  async connect(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      this.centrifuge.connect();
+
+      // Subscribe to reply channel
+      this.subscription = this.centrifuge.newSubscription(this.replyChannel);
+
+      this.subscription.on('publication', (ctx: any) => {
+        this.handleResponse(ctx.data);
+      });
+
+      this.subscription.on('subscribed', () => {
+        resolve();
+      });
+
+      this.subscription.on('error', (ctx: any) => {
+        reject(new Error(ctx.error?.message || 'Subscription error'));
+      });
+
+      this.subscription.subscribe();
+    });
+  }
+
+  async disconnect(): Promise<void> {
+    if (this.subscription) {
+      this.subscription.unsubscribe();
+    }
+    this.centrifuge.disconnect();
+  }
+
+  async call<T = any>(method: string, params: any): Promise<T> {
+    const correlationId = this.generateCorrelationId();
+
+    const message = {
+      method,
+      params,
+      correlation_id: correlationId,
+      reply_to: this.replyChannel,
+    };
+
+    // Create promise for response
+    const promise = new Promise<T>((resolve, reject) => {
+      const timeoutId = setTimeout(() => {
+        this.pendingRequests.delete(correlationId);
+        reject(new Error(`RPC timeout: ${method}`));
+      }, this.timeout);
+
+      this.pendingRequests.set(correlationId, {
+        resolve: (result: T) => {
+          clearTimeout(timeoutId);
+          resolve(result);
+        },
+        reject: (error: Error) => {
+          clearTimeout(timeoutId);
+          reject(error);
+        },
+      });
+    });
+
+    // Publish request
+    await this.centrifuge.publish('rpc.requests', message);
+
+    console.log(`📤 RPC call: ${method} (${correlationId})`);
+
+    return promise;
+  }
+
+  private handleResponse(data: any): void {
+    const correlationId = data.correlation_id;
+    if (!correlationId) {
+      console.warn('Received response without correlation_id');
+      return;
+    }
+
+    const pending = this.pendingRequests.get(correlationId);
+    if (!pending) {
+      console.warn(`Received response for unknown correlation_id: ${correlationId}`);
+      return;
+    }
+
+    this.pendingRequests.delete(correlationId);
+
+    if (data.error) {
+      pending.reject(new Error(data.error.message || 'RPC error'));
+    } else {
+      console.log(`📥 RPC response: ${correlationId}`);
+      pending.resolve(data.result);
+    }
+  }
+
+  private generateCorrelationId(): string {
+    return `${Date.now()}-${Math.random().toString(36).slice(2, 11)}`;
+  }
+}

django_cfg/apps/centrifugo/codegen/generators/typescript_thin/templates/tsconfig.json.j2

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  }
+}

django_cfg/apps/centrifugo/codegen/generators/typescript_thin/templates/types.ts.j2

@@ -0,0 +1,9 @@
+/**
+ * Generated TypeScript Types
+ * Auto-generated - DO NOT EDIT
+ */
+
+{% for type in types %}
+{{ type.code }}
+
+{% endfor %}

django_cfg/apps/centrifugo/codegen/utils/__init__.py

@@ -0,0 +1,37 @@
+"""
+Utilities for code generation.
+"""
+
+from .naming import (
+    sanitize_method_name,
+    to_camel_case,
+    to_pascal_case,
+    to_python_method_name,
+    to_typescript_method_name,
+    to_go_method_name,
+)
+from .type_converter import (
+    pydantic_to_typescript,
+    pydantic_to_python,
+    pydantic_to_go,
+    generate_typescript_types,
+    generate_python_types,
+    generate_go_types,
+)
+
+__all__ = [
+    # Naming
+    "sanitize_method_name",
+    "to_camel_case",
+    "to_pascal_case",
+    "to_python_method_name",
+    "to_typescript_method_name",
+    "to_go_method_name",
+    # Type conversion
+    "pydantic_to_typescript",
+    "pydantic_to_python",
+    "pydantic_to_go",
+    "generate_typescript_types",
+    "generate_python_types",
+    "generate_go_types",
+]

django_cfg/apps/centrifugo/codegen/utils/naming.py

@@ -0,0 +1,155 @@
+"""
+Naming utilities for code generation.
+
+Provides functions to convert RPC method names to valid identifiers
+in different programming languages.
+"""
+
+
+def sanitize_method_name(name: str) -> str:
+    """
+    Sanitize method name by replacing dots with underscores.
+
+    This handles namespaced method names (e.g., "workspace.file_changed")
+    and converts them to valid identifiers by replacing dots with underscores.
+
+    Args:
+        name: Original method name (may contain dots)
+
+    Returns:
+        Sanitized name with underscores instead of dots
+
+    Examples:
+        >>> sanitize_method_name("workspace.file_changed")
+        'workspace_file_changed'
+        >>> sanitize_method_name("send_email")
+        'send_email'
+    """
+    return name.replace('.', '_')
+
+
+def to_camel_case(snake_str: str) -> str:
+    """
+    Convert snake_case to camelCase.
+
+    Args:
+        snake_str: String in snake_case format
+
+    Returns:
+        String in camelCase format
+
+    Examples:
+        >>> to_camel_case("workspace_file_changed")
+        'workspaceFileChanged'
+        >>> to_camel_case("send_email")
+        'sendEmail'
+        >>> to_camel_case("user_update_profile")
+        'userUpdateProfile'
+    """
+    components = snake_str.split('_')
+    return components[0] + ''.join(x.title() for x in components[1:])
+
+
+def to_typescript_method_name(rpc_name: str) -> str:
+    """
+    Convert RPC method name to valid TypeScript method name.
+
+    Handles namespaced methods by replacing dots with underscores,
+    then converts to camelCase.
+
+    Args:
+        rpc_name: Original RPC method name (may contain dots)
+
+    Returns:
+        Valid TypeScript method name in camelCase
+
+    Examples:
+        >>> to_typescript_method_name("workspace.file_changed")
+        'workspaceFileChanged'
+        >>> to_typescript_method_name("session.message")
+        'sessionMessage'
+        >>> to_typescript_method_name("send_email")
+        'sendEmail'
+    """
+    sanitized = sanitize_method_name(rpc_name)
+    return to_camel_case(sanitized)
+
+
+def to_python_method_name(rpc_name: str) -> str:
+    """
+    Convert RPC method name to valid Python method name.
+
+    Handles namespaced methods by replacing dots with underscores.
+    Python uses snake_case, so we just sanitize the name.
+
+    Args:
+        rpc_name: Original RPC method name (may contain dots)
+
+    Returns:
+        Valid Python method name in snake_case
+
+    Examples:
+        >>> to_python_method_name("workspace.file_changed")
+        'workspace_file_changed'
+        >>> to_python_method_name("session.message")
+        'session_message'
+        >>> to_python_method_name("send_email")
+        'send_email'
+    """
+    return sanitize_method_name(rpc_name)
+
+
+def to_pascal_case(snake_str: str) -> str:
+    """
+    Convert snake_case to PascalCase.
+
+    Args:
+        snake_str: String in snake_case format
+
+    Returns:
+        String in PascalCase format
+
+    Examples:
+        >>> to_pascal_case("workspace_file_changed")
+        'WorkspaceFileChanged'
+        >>> to_pascal_case("send_email")
+        'SendEmail'
+        >>> to_pascal_case("user_update_profile")
+        'UserUpdateProfile'
+    """
+    return ''.join(word.capitalize() for word in snake_str.split('_'))
+
+
+def to_go_method_name(rpc_name: str) -> str:
+    """
+    Convert RPC method name to valid Go method name.
+
+    Handles namespaced methods by replacing dots with underscores,
+    then converts to PascalCase (Go exported methods must start with capital).
+
+    Args:
+        rpc_name: Original RPC method name (may contain dots)
+
+    Returns:
+        Valid Go method name in PascalCase
+
+    Examples:
+        >>> to_go_method_name("workspace.file_changed")
+        'WorkspaceFileChanged'
+        >>> to_go_method_name("session.message")
+        'SessionMessage'
+        >>> to_go_method_name("send_email")
+        'SendEmail'
+    """
+    sanitized = sanitize_method_name(rpc_name)
+    return to_pascal_case(sanitized)
+
+
+__all__ = [
+    'sanitize_method_name',
+    'to_camel_case',
+    'to_pascal_case',
+    'to_typescript_method_name',
+    'to_python_method_name',
+    'to_go_method_name',
+]