django-cfg 1.4.89__py3-none-any.whl → 1.5.181__py3-none-any.whl

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

@@ -0,0 +1,106 @@
+/**
+ * Generated API Client
+ * Auto-generated thin wrapper - DO NOT EDIT
+ *
+ * @generated {{ generated_at }}
+ */
+
+{% if models %}
+import type {
+{% for model_name in models | unique | sort %}  {{ model_name }},
+{% endfor %}} from './types';
+{% endif %}
+
+/**
+ * API contract version - changes when methods or models change.
+ * Use checkVersion() to verify client/server compatibility.
+ */
+export const API_VERSION = '{{ api_version }}';
+
+/**
+ * Timestamp when this client was generated.
+ */
+export const GENERATED_AT = '{{ generated_at }}';
+
+// Interface for Centrifugo client with namedRPC
+// Compatible with @djangocfg/centrifugo client
+interface CentrifugoClient {
+  namedRPC<T = any>(method: string, params: any, options?: { timeout?: number }): Promise<T>;
+  /** Optional: fire-and-forget RPC (no response expected) */
+  namedRPCNoWait?(method: string, params: any): void;
+}
+
+// Re-export WsVersionCheckResult from types (generated from Pydantic model)
+export type { WsVersionCheckResult } from './types';
+
+export class APIClient {
+  constructor(private client: CentrifugoClient) {}
+
+  /**
+   * Check if client API version is compatible with server.
+   * Call this after connecting to ensure contract compatibility.
+   *
+   * @throws Error if versions are incompatible
+   * @returns WsVersionCheckResult with compatibility info
+   *
+   * @example
+   * const apiClient = new APIClient(client);
+   * const result = await apiClient.checkVersion();
+   * if (!result.compatible) {
+   *   console.error('API version mismatch! Please regenerate client.');
+   * }
+   */
+  async checkVersion(): Promise<WsVersionCheckResult> {
+    try {
+      const result = await this.client.namedRPC<WsVersionCheckResult>(
+        'system.check_version',
+        { client_version: API_VERSION }
+      );
+      return result;
+    } catch (error) {
+      // If endpoint doesn't exist, assume compatible (for backwards compatibility)
+      return {
+        compatible: true,
+        client_version: API_VERSION,
+        server_version: 'unknown',
+        message: 'Version check endpoint not available',
+      };
+    }
+  }
+
+  /**
+   * Get the API contract version of this client.
+   */
+  getVersion(): string {
+    return API_VERSION;
+  }
+
+{% 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 }}> {
+    {% if method.name.startswith('ai_chat.') %}
+    // AI methods use longer timeout (60s) for safety, though RPC returns immediately
+    return this.client.namedRPC<{{ method.return_type }}>('{{ method.name }}', params, { timeout: 60000 });
+    {% else %}
+    return this.client.namedRPC<{{ method.return_type }}>('{{ method.name }}', params);
+    {% endif %}
+  }
+
+  {% if method.no_wait %}
+  /**
+   * {{ method.docstring.split('\n')[0] if method.docstring else 'No description' }} (fire-and-forget)
+   */
+  {{ method.name_ts }}NoWait(params: {{ method.param_type }}): void {
+    // Fire-and-forget: don't wait for response
+    if (this.client.namedRPCNoWait) {
+      this.client.namedRPCNoWait('{{ method.name }}', params);
+    } else {
+      this.client.namedRPC('{{ method.name }}', params).catch(() => {});
+    }
+  }
+
+  {% endif %}
+{% endfor %}
+}

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

@@ -0,0 +1,23 @@
+/**
+ * Generated TypeScript Client Package
+ * Auto-generated - DO NOT EDIT
+ */
+
+export { APIClient, API_VERSION, GENERATED_AT } from './client';
+{% if enums %}
+export {
+{% for enum_name in enums | unique | sort %}  {{ enum_name }},
+{% endfor %}} from './types';
+{% endif %}
+{% if models %}
+export type {
+{% for model_name in models | unique | sort %}  {{ model_name }},
+{% endfor %}} from './types';
+{% endif %}
+{% if channels %}
+export type {
+{% for channel in channels %}  {{ channel.enum_name }},
+{% for event in channel.event_cases %}  {{ event.type_name }},
+{% endfor %}
+{% endfor %}} from './subscriptions';
+{% endif %}

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

@@ -0,0 +1,276 @@
+/**
+ * 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 channelSubscriptions: Map<string, any> = new Map();
+  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('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) => {
+      let resolved = false;
+
+      // Listen to Centrifuge connection events
+      const onConnected = () => {
+        if (!resolved) {
+          resolved = true;
+          resolve();
+        }
+      };
+
+      const onError = (ctx: any) => {
+        if (!resolved) {
+          resolved = true;
+          reject(new Error(ctx.message || 'Connection error'));
+        }
+      };
+
+      this.centrifuge.on('connected', onConnected);
+      this.centrifuge.on('error', onError);
+
+      // Start connection
+      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', () => {
+        // Subscription successful (optional, we already resolved on 'connected')
+      });
+
+      this.subscription.on('error', (ctx: any) => {
+        // Error code 105 = "already subscribed" (server-side subscription from JWT)
+        // This is not an error - the channel is already active via server-side subscription
+        if (ctx.error?.code === 105) {
+          // This is fine, server-side subscription exists
+        } else {
+          console.error(`Subscription error for ${this.replyChannel}:`, ctx.error);
+        }
+      });
+
+      this.subscription.subscribe();
+    });
+  }
+
+  async disconnect(): Promise<void> {
+    // Unsubscribe from all event channels
+    this.unsubscribeAll();
+
+    // Unsubscribe from RPC reply channel
+    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);
+
+    return promise;
+  }
+
+  private handleResponse(data: any): void {
+    const correlationId = data.correlation_id;
+    if (!correlationId) {
+      return;
+    }
+
+    const pending = this.pendingRequests.get(correlationId);
+    if (!pending) {
+      return;
+    }
+
+    this.pendingRequests.delete(correlationId);
+
+    if (data.error) {
+      pending.reject(new Error(data.error.message || 'RPC error'));
+    } else {
+      pending.resolve(data.result);
+    }
+  }
+
+  private generateCorrelationId(): string {
+    return `${Date.now()}-${Math.random().toString(36).slice(2, 11)}`;
+  }
+
+  // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  // Channel Subscription API (for gRPC events)
+  // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  /**
+   * Subscribe to a Centrifugo channel for real-time events.
+   *
+   * @param channel - Channel name (e.g., 'bot#bot-123#heartbeat')
+   * @param callback - Callback for received messages
+   * @returns Unsubscribe function
+   *
+   * @example
+   * const unsubscribe = client.subscribe('bot#bot-123#heartbeat', (data) => {
+   *   console.log('Heartbeat:', data);
+   * });
+   *
+   * // Later: unsubscribe when done
+   * unsubscribe();
+   */
+  subscribe(channel: string, callback: (data: any) => void): () => void {
+    // Check if already subscribed
+    if (this.channelSubscriptions.has(channel)) {
+      return () => {}; // Return no-op unsubscribe
+    }
+
+    // Create new subscription
+    const sub = this.centrifuge.newSubscription(channel);
+
+    // Handle publications
+    sub.on('publication', (ctx: any) => {
+      callback(ctx.data);
+    });
+
+    // Handle subscription lifecycle
+    sub.on('subscribed', () => {
+      // Subscription successful
+    });
+
+    sub.on('error', (ctx: any) => {
+      console.error(`Subscription error for ${channel}:`, ctx.error);
+    });
+
+    // Start subscription
+    sub.subscribe();
+
+    // Store subscription
+    this.channelSubscriptions.set(channel, sub);
+
+    // Return unsubscribe function
+    return () => this.unsubscribe(channel);
+  }
+
+  /**
+   * Unsubscribe from a channel.
+   *
+   * @param channel - Channel name
+   */
+  unsubscribe(channel: string): void {
+    const sub = this.channelSubscriptions.get(channel);
+    if (!sub) {
+      return;
+    }
+
+    sub.unsubscribe();
+    this.channelSubscriptions.delete(channel);
+  }
+
+  /**
+   * Unsubscribe from all channels.
+   */
+  unsubscribeAll(): void {
+    if (this.channelSubscriptions.size === 0) {
+      return;
+    }
+
+    this.channelSubscriptions.forEach((sub, channel) => {
+      sub.unsubscribe();
+    });
+    this.channelSubscriptions.clear();
+  }
+
+  /**
+   * Get list of active client-side subscriptions.
+   */
+  getActiveSubscriptions(): string[] {
+    return Array.from(this.channelSubscriptions.keys());
+  }
+
+  /**
+   * Get list of server-side subscriptions (from JWT token).
+   *
+   * These are channels automatically subscribed by Centrifugo server
+   * based on the 'channels' claim in the JWT token.
+   */
+  getServerSideSubscriptions(): string[] {
+    try {
+      // Access Centrifuge.js internal state for server-side subs
+      // @ts-ignore - accessing internal property
+      const serverSubs = this.centrifuge._serverSubs || {};
+      return Object.keys(serverSubs);
+    } catch (error) {
+      return [];
+    }
+  }
+
+  /**
+   * Get all active subscriptions (both client-side and server-side).
+   */
+  getAllSubscriptions(): string[] {
+    const clientSubs = this.getActiveSubscriptions();
+    const serverSubs = this.getServerSideSubscriptions();
+
+    // Combine and deduplicate
+    return Array.from(new Set([...clientSubs, ...serverSubs]));
+  }
+}

django_cfg/apps/integrations/centrifugo/codegen/generators/typescript_thin/templates/subscriptions.ts.j2

@@ -0,0 +1,43 @@
+// subscriptions.ts
+// Generated Channel Event Types
+// Auto-generated - DO NOT EDIT
+// Generated at: {{ generated_at }}
+
+{% if nested_types %}
+// =============================================================================
+// Nested Types
+// =============================================================================
+
+{% for nested in nested_types %}
+export interface {{ nested.name }} {
+{% for field in nested.fields %}
+  {{ field.name }}{% if field.optional %}?{% endif %}: {{ field.ts_type }};
+{% endfor %}
+}
+
+{% endfor %}
+{% endif %}
+{% for channel in channels %}
+// =============================================================================
+// {{ channel.enum_name }} - {{ channel.docstring }}
+// =============================================================================
+
+{% for event in channel.event_cases %}
+export interface {{ event.type_name }} {
+  type: '{{ event.type_value }}';
+  message_id: string;
+  client_message_id?: string;
+{% for field in event.fields %}
+  {{ field.name }}{% if field.optional %}?{% endif %}: {{ field.ts_type }};
+{% endfor %}
+}
+
+{% endfor %}
+/** {{ channel.docstring }} */
+export type {{ channel.enum_name }} =
+{% for event in channel.event_cases %}
+  | {{ event.type_name }}{% if not loop.last %}{% endif %}
+
+{% endfor %};
+
+{% endfor %}

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

@@ -0,0 +1,19 @@
+/**
+ * Generated TypeScript Types
+ * Auto-generated - DO NOT EDIT
+ */
+
+{% if enums %}
+// =============================================================================
+// ENUMS
+// =============================================================================
+
+{% for enum in enums %}
+{{ enum.code }}
+
+{% endfor %}
+{% endif %}
+{% for type in types %}
+{{ type.code }}
+
+{% endfor %}

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

@@ -0,0 +1,90 @@
+"""
+Utilities for code generation.
+"""
+
+from .naming import (
+    SWIFT_RESERVED_TYPES,
+    get_safe_swift_type_name,
+    is_swift_reserved_type,
+    sanitize_method_name,
+    to_camel_case,
+    to_pascal_case,
+    to_python_method_name,
+    to_typescript_method_name,
+    to_go_method_name,
+    to_swift_method_name,
+    to_swift_field_name,
+)
+
+from .prefix import (
+    WS_TYPE_PREFIX,
+    add_prefix_to_type_name,
+    add_prefix_to_field_types,
+    add_prefix_to_type_data,
+    collect_type_names_from_models,
+)
+
+# Import from new converters module structure
+from .converters import (
+    # TypeScript
+    convert_json_schema_to_typescript,
+    pydantic_to_typescript,
+    generate_typescript_types,
+    is_int_enum,
+    int_enum_to_typescript,
+    generate_typescript_enums,
+    # Python
+    convert_json_schema_to_python,
+    pydantic_to_python,
+    generate_python_types,
+    # Go
+    convert_json_schema_to_go,
+    pydantic_to_go,
+    generate_go_types,
+    # Swift
+    convert_json_schema_to_swift,
+    pydantic_to_swift,
+    pydantic_to_swift_with_nested,
+    generate_swift_types,
+)
+
+__all__ = [
+    # Naming
+    "SWIFT_RESERVED_TYPES",
+    "get_safe_swift_type_name",
+    "is_swift_reserved_type",
+    "sanitize_method_name",
+    "to_camel_case",
+    "to_pascal_case",
+    "to_python_method_name",
+    "to_typescript_method_name",
+    "to_go_method_name",
+    "to_swift_method_name",
+    "to_swift_field_name",
+    # Prefix utilities
+    "WS_TYPE_PREFIX",
+    "add_prefix_to_type_name",
+    "add_prefix_to_field_types",
+    "add_prefix_to_type_data",
+    "collect_type_names_from_models",
+    # TypeScript converters
+    "convert_json_schema_to_typescript",
+    "pydantic_to_typescript",
+    "generate_typescript_types",
+    "is_int_enum",
+    "int_enum_to_typescript",
+    "generate_typescript_enums",
+    # Python converters
+    "convert_json_schema_to_python",
+    "pydantic_to_python",
+    "generate_python_types",
+    # Go converters
+    "convert_json_schema_to_go",
+    "pydantic_to_go",
+    "generate_go_types",
+    # Swift converters
+    "convert_json_schema_to_swift",
+    "pydantic_to_swift",
+    "pydantic_to_swift_with_nested",
+    "generate_swift_types",
+]

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

@@ -0,0 +1,75 @@
+"""
+Type converters for code generation.
+
+This module provides type conversion utilities for generating code in different
+programming languages from Pydantic models.
+
+Supported languages:
+- TypeScript
+- Python
+- Go
+- Swift
+"""
+
+# TypeScript
+from .typescript import (
+    convert_json_schema_to_typescript,
+    pydantic_to_typescript,
+    generate_typescript_types,
+    # Enum support
+    is_int_enum,
+    int_enum_to_typescript,
+    generate_typescript_enums,
+)
+
+# Python
+from .python import (
+    convert_json_schema_to_python,
+    pydantic_to_python,
+    generate_python_types,
+)
+
+# Go
+from .go import (
+    convert_json_schema_to_go,
+    pydantic_to_go,
+    generate_go_types,
+)
+
+# Swift
+from .swift import (
+    convert_json_schema_to_swift,
+    pydantic_to_swift,
+    pydantic_to_swift_with_nested,
+    generate_swift_types,
+    # Enum support
+    is_int_enum as is_int_enum_swift,
+    int_enum_to_swift,
+    generate_swift_enums,
+)
+
+__all__ = [
+    # TypeScript
+    "convert_json_schema_to_typescript",
+    "pydantic_to_typescript",
+    "generate_typescript_types",
+    "is_int_enum",
+    "int_enum_to_typescript",
+    "generate_typescript_enums",
+    # Python
+    "convert_json_schema_to_python",
+    "pydantic_to_python",
+    "generate_python_types",
+    # Go
+    "convert_json_schema_to_go",
+    "pydantic_to_go",
+    "generate_go_types",
+    # Swift
+    "convert_json_schema_to_swift",
+    "pydantic_to_swift",
+    "pydantic_to_swift_with_nested",
+    "generate_swift_types",
+    "is_int_enum_swift",
+    "int_enum_to_swift",
+    "generate_swift_enums",
+]