@ioka-technologies/asyncapi-ts-client-template 0.0.7

package/examples/simple/asyncapi.yaml

@@ -0,0 +1,256 @@
+# yaml-language-server: $schema=https://raw.githubusercontent.com/asyncapi/spec-json-schemas/refs/heads/master/schemas/all.schema-store.json
+asyncapi: 3.0.0
+info:
+  title: Simple Chat API
+  version: 1.0.0
+  description: A simple chat API for testing the TypeScript client generator
+
+servers:
+  websocket:
+    host: localhost:8080
+    protocol: ws
+    description: WebSocket server for real-time chat
+  http:
+    host: localhost:8080
+    protocol: http
+    description: HTTP server for REST API
+
+channels:
+  chatSend:
+    address: chat/send
+    messages:
+      SendMessage:
+        $ref: '#/components/messages/SendMessage'
+      MessageAck:
+        $ref: '#/components/messages/MessageAck'
+
+  chatReceive:
+    address: chat/receive
+    messages:
+      MessageReceived:
+        $ref: '#/components/messages/MessageReceived'
+
+  userProfile:
+    address: user/profile
+    messages:
+      GetUserProfile:
+        $ref: '#/components/messages/GetUserProfile'
+      UserProfile:
+        $ref: '#/components/messages/UserProfile'
+
+  userStatus:
+    address: user/status
+    messages:
+      UpdateStatus:
+        $ref: '#/components/messages/UpdateStatus'
+      StatusUpdated:
+        $ref: '#/components/messages/StatusUpdated'
+
+operations:
+  # Request/Response pattern - send message and wait for acknowledgment
+  sendMessage:
+    action: send
+    channel:
+      $ref: '#/channels/chatSend'
+    messages:
+      - $ref: '#/channels/chatSend/messages/SendMessage'
+    reply:
+      channel:
+        $ref: '#/channels/chatSend'
+      messages:
+        - $ref: '#/channels/chatSend/messages/MessageAck'
+
+  # Regular receive operation - listen for incoming messages
+  onMessageReceived:
+    action: receive
+    channel:
+      $ref: '#/channels/chatReceive'
+    messages:
+      - $ref: '#/channels/chatReceive/messages/MessageReceived'
+
+  # Request/Response pattern - get user profile and wait for response
+  getUserProfile:
+    action: send
+    channel:
+      $ref: '#/channels/userProfile'
+    messages:
+      - $ref: '#/channels/userProfile/messages/GetUserProfile'
+    reply:
+      channel:
+        $ref: '#/channels/userProfile'
+      messages:
+        - $ref: '#/channels/userProfile/messages/UserProfile'
+
+  # Regular send operation - fire and forget status update
+  updateStatus:
+    action: send
+    channel:
+      $ref: '#/channels/userStatus'
+    messages:
+      - $ref: '#/channels/userStatus/messages/UpdateStatus'
+
+  # Regular receive operation - listen for status updates from other users
+  onStatusUpdated:
+    action: receive
+    channel:
+      $ref: '#/channels/userStatus'
+    messages:
+      - $ref: '#/channels/userStatus/messages/StatusUpdated'
+
+components:
+  messages:
+    SendMessage:
+      name: SendMessage
+      title: Send Message
+      summary: Send a chat message
+      payload:
+        type: object
+        properties:
+          roomId:
+            type: string
+            description: The chat room ID
+          content:
+            type: string
+            description: The message content
+          timestamp:
+            type: string
+            format: date-time
+            description: When the message was sent
+        required:
+          - roomId
+          - content
+
+    MessageAck:
+      name: MessageAck
+      title: Message Acknowledgment
+      summary: Acknowledgment of a sent message
+      payload:
+        type: object
+        properties:
+          messageId:
+            type: string
+            description: The unique message ID
+          status:
+            type: string
+            enum: [sent, delivered, failed]
+            description: The message status
+          timestamp:
+            type: string
+            format: date-time
+        required:
+          - messageId
+          - status
+          - timestamp
+
+    MessageReceived:
+      name: MessageReceived
+      title: Message Received
+      summary: A message received in a chat room
+      payload:
+        type: object
+        properties:
+          messageId:
+            type: string
+          roomId:
+            type: string
+          senderId:
+            type: string
+          senderName:
+            type: string
+          content:
+            type: string
+          timestamp:
+            type: string
+            format: date-time
+        required:
+          - messageId
+          - roomId
+          - senderId
+          - senderName
+          - content
+          - timestamp
+
+    GetUserProfile:
+      name: GetUserProfile
+      title: Get User Profile
+      summary: Request to get a user's profile
+      payload:
+        type: object
+        properties:
+          userId:
+            type: string
+            description: The user ID to fetch
+        required:
+          - userId
+
+    UserProfile:
+      name: UserProfile
+      title: User Profile
+      summary: User profile information
+      payload:
+        type: object
+        properties:
+          id:
+            type: string
+          username:
+            type: string
+          displayName:
+            type: string
+          email:
+            type: string
+          status:
+            type: string
+            enum: [online, away, busy, offline]
+          avatar:
+            type: string
+            description: URL to user avatar
+          joinedAt:
+            type: string
+            format: date-time
+          lastSeen:
+            type: string
+            format: date-time
+        required:
+          - id
+          - username
+          - displayName
+          - status
+          - joinedAt
+
+    UpdateStatus:
+      name: UpdateStatus
+      title: Update Status
+      summary: Update user status
+      payload:
+        type: object
+        properties:
+          status:
+            type: string
+            enum: [online, away, busy, offline]
+          message:
+            type: string
+            description: Optional status message
+        required:
+          - status
+
+    StatusUpdated:
+      name: StatusUpdated
+      title: Status Updated
+      summary: User status has been updated
+      payload:
+        type: object
+        properties:
+          userId:
+            type: string
+          status:
+            type: string
+            enum: [online, away, busy, offline]
+          message:
+            type: string
+          updatedAt:
+            type: string
+            format: date-time
+        required:
+          - userId
+          - status
+          - updatedAt

package/package.json

@@ -0,0 +1,97 @@
+{
+    "name": "@ioka-technologies/asyncapi-ts-client-template",
+    "version": "0.0.7",
+    "description": "TypeScript AsyncAPI client generator template compatible with rust-asyncapi patterns",
+    "main": "template/index.js",
+    "scripts": {
+        "test": "npm run test:generate",
+        "test:generate": "asyncapi generate fromTemplate examples/simple/asyncapi.yaml . -o test-output-simple --force-write -p enableAuth=true",
+        "clean": "rm -rf test-output-*"
+    },
+    "keywords": [
+        "asyncapi",
+        "typescript",
+        "websocket",
+        "http",
+        "client",
+        "generator",
+        "template",
+        "rust-asyncapi"
+    ],
+    "author": "AsyncAPI TypeScript Generator",
+    "license": "Apache-2.0",
+    "devDependencies": {
+        "@asyncapi/cli": "^1.18.0"
+    },
+    "generator": {
+        "renderer": "react",
+        "apiVersion": "v3",
+        "supportedProtocols": [
+            "http",
+            "https",
+            "ws",
+            "wss"
+        ],
+        "parameters": {
+            "clientName": {
+                "description": "Name of the generated client class",
+                "default": "",
+                "required": false
+            },
+            "packageName": {
+                "description": "Name of the generated npm package",
+                "default": "",
+                "required": false
+            },
+            "packageVersion": {
+                "description": "Version of the generated package",
+                "default": "",
+                "required": false
+            },
+            "author": {
+                "description": "Package author",
+                "default": "AsyncAPI Generator",
+                "required": false
+            },
+            "license": {
+                "description": "Package license",
+                "default": "Apache-2.0",
+                "required": false
+            },
+            "enableAuth": {
+                "description": "Enable authentication middleware",
+                "default": true,
+                "required": false
+            },
+            "transports": {
+                "description": "Comma-separated list of transports to include",
+                "default": "websocket,http",
+                "required": false
+            },
+            "generateTests": {
+                "description": "Generate unit tests",
+                "default": true,
+                "required": false
+            },
+            "includeExamples": {
+                "description": "Include usage examples",
+                "default": true,
+                "required": false
+            }
+        },
+        "nonRenderableFiles": [
+            "examples/**/*",
+            "test-output-*/**/*",
+            "*.md",
+            "LICENSE"
+        ],
+        "generator": ">=1.15.0 <3.0.0"
+    },
+    "files": [
+        "template/**/*",
+        "examples/**/*",
+        "README.md",
+        "USAGE.md",
+        "PROJECT_SUMMARY.md"
+    ]
+}

package/template/index.js

@@ -0,0 +1,284 @@
+const { File } = require('@asyncapi/generator-react-sdk');
+const React = require('react');
+
+module.exports = function ({ asyncapi, params }) {
+    // Extract info from AsyncAPI spec
+    let title, version, description;
+    try {
+        const info = asyncapi.info();
+        title = info.title();
+        version = info.version();
+        description = info.description();
+    } catch (error) {
+        title = 'UnknownAPI';
+        version = '1.0.0';
+        description = 'Generated API client';
+    }
+
+    // Helper function to check if a parameter contains unresolved template variables
+    function isTemplateVariable(value) {
+        return typeof value === 'string' && value.includes('{{') && value.includes('}}');
+    }
+
+    // Helper function to convert title to kebab-case
+    function toKebabCase(str) {
+        return str.toLowerCase().replace(/[^a-z0-9]/g, '-').replace(/-+/g, '-').replace(/^-|-$/g, '');
+    }
+
+    // Resolve parameters, falling back to extracted values if parameters contain template variables
+    const clientName = (params.clientName && !isTemplateVariable(params.clientName))
+        ? params.clientName
+        : `${title.replace(/[^a-zA-Z0-9]/g, '')}Client`;
+
+    const packageName = (params.packageName && !isTemplateVariable(params.packageName))
+        ? params.packageName
+        : `${toKebabCase(title)}-client`;
+
+    const packageVersion = (params.packageVersion && !isTemplateVariable(params.packageVersion))
+        ? params.packageVersion
+        : version;
+
+    const transports = (params.transports || 'websocket,http').split(',').map(t => t.trim());
+
+    // Generate all files from the main index.js
+    return [
+        React.createElement(File, { name: "package.json" },
+            JSON.stringify({
+                name: packageName,
+                version: packageVersion,
+                description: `${description || title} - TypeScript AsyncAPI Client`,
+                main: "dist/index.js",
+                types: "dist/index.d.ts",
+                scripts: {
+                    build: "tsc",
+                    dev: "tsc --watch",
+                    test: "jest",
+                    lint: "eslint src/**/*.ts",
+                    prepare: "npm run build"
+                },
+                keywords: [
+                    "asyncapi",
+                    "websocket",
+                    "http",
+                    "client",
+                    "typescript",
+                    title.toLowerCase().replace(/[^a-z0-9]/g, '-')
+                ],
+                author: params.author || "AsyncAPI Generator",
+                license: params.license || "Apache-2.0",
+                dependencies: {
+                    uuid: "^9.0.0"
+                },
+                optionalDependencies: {
+                    ws: "^8.14.0"
+                },
+                devDependencies: {
+                    "@types/ws": "^8.5.0",
+                    "@types/uuid": "^9.0.0",
+                    "@types/node": "^20.0.0",
+                    typescript: "^5.0.0",
+                    eslint: "^8.0.0",
+                    "@typescript-eslint/eslint-plugin": "^6.0.0",
+                    "@typescript-eslint/parser": "^6.0.0",
+                    ...(params.generateTests && {
+                        jest: "^29.0.0",
+                        "@types/jest": "^29.0.0",
+                        "ts-jest": "^29.0.0"
+                    })
+                },
+                files: [
+                    "dist/**/*",
+                    "README.md",
+                    "USAGE.md"
+                ]
+            }, null, 2)
+        ),
+
+        React.createElement(File, { name: "tsconfig.json" },
+            JSON.stringify({
+                compilerOptions: {
+                    target: "ES2020",
+                    module: "ES2020",
+                    lib: ["ES2020", "DOM"],
+                    outDir: "./dist",
+                    rootDir: "./src",
+                    strict: true,
+                    esModuleInterop: true,
+                    skipLibCheck: true,
+                    forceConsistentCasingInFileNames: true,
+                    declaration: true,
+                    declarationMap: true,
+                    sourceMap: true,
+                    moduleResolution: "node",
+                    allowSyntheticDefaultImports: true,
+                    experimentalDecorators: true,
+                    emitDecoratorMetadata: true,
+                    resolveJsonModule: true,
+                    typeRoots: ["node_modules/@types"]
+                },
+                include: [
+                    "src/**/*"
+                ],
+                exclude: [
+                    "node_modules",
+                    "dist",
+                    "**/*.test.ts",
+                    "**/*.spec.ts"
+                ]
+            }, null, 2)
+        ),
+
+        React.createElement(File, { name: "README.md" },
+            `# ${title}
+
+${description || 'Generated TypeScript AsyncAPI client'}
+
+## Installation
+
+\`\`\`bash
+npm install ${packageName}
+\`\`\`
+
+## Quick Start
+
+See [USAGE.md](./USAGE.md) for detailed usage instructions.
+
+## Generated from AsyncAPI
+
+This client was generated from an AsyncAPI specification using the TypeScript AsyncAPI Client Generator.
+
+- AsyncAPI Version: ${asyncapi.version()}
+- Generated: ${new Date().toISOString()}
+`
+        ),
+
+        React.createElement(File, { name: "USAGE.md" },
+            `# ${title} - Usage Guide
+
+This document shows how to use the generated TypeScript AsyncAPI client.
+
+## Installation
+
+### Browser Usage
+For browser environments, install the package normally:
+\`\`\`bash
+npm install ${packageName}
+\`\`\`
+
+### Node.js Usage
+For Node.js environments, you'll also need the WebSocket library:
+\`\`\`bash
+npm install ${packageName} ws
+\`\`\`
+
+## Environment Compatibility
+
+This client automatically detects the environment and uses the appropriate WebSocket implementation:
+- **Browser**: Uses the native \`WebSocket\` API
+- **Node.js**: Uses the \`ws\` library (must be installed separately)
+
+## WebSocket Usage
+
+\`\`\`typescript
+import { ${clientName} } from '${packageName}';
+
+const client = new ${clientName}({
+    type: 'websocket',
+    url: 'ws://localhost:8080',
+    headers: {
+        'Authorization': 'Bearer your-token'
+    }
+});
+
+// Connect to the WebSocket
+await client.connect();
+
+// Send a message and wait for response
+try {
+    const response = await client.sendMessage({
+        text: 'Hello, World!',
+        userId: '123'
+    });
+    console.log('Response:', response);
+} catch (error) {
+    console.error('Error:', error);
+}
+
+// Disconnect when done
+await client.disconnect();
+\`\`\`
+
+## HTTP Usage
+
+\`\`\`typescript
+import { ${clientName} } from '${packageName}';
+
+const client = new ${clientName}({
+    type: 'http',
+    url: 'http://localhost:8080/api',
+    headers: {
+        'Authorization': 'Bearer your-token'
+    }
+});
+
+// Send HTTP request
+try {
+    const response = await client.sendMessage({
+        text: 'Hello, World!',
+        userId: '123'
+    });
+    console.log('Response:', response);
+} catch (error) {
+    console.error('Error:', error);
+}
+\`\`\`
+
+## Configuration Options
+
+\`\`\`typescript
+interface TransportConfig {
+    type: 'websocket' | 'http';
+    url: string;
+    headers?: Record<string, string>;
+    timeout?: number;
+}
+\`\`\`
+
+## Error Handling
+
+The client throws specific error types:
+
+- \`TransportError\`: General transport errors
+- \`ConnectionError\`: Connection-related errors
+- \`TimeoutError\`: Request timeout errors
+
+\`\`\`typescript
+import { TransportError, ConnectionError, TimeoutError } from '${packageName}';
+
+try {
+    await client.sendMessage(payload);
+} catch (error) {
+    if (error instanceof ConnectionError) {
+        console.error('Connection failed:', error.message);
+    } else if (error instanceof TimeoutError) {
+        console.error('Request timed out:', error.message);
+    } else if (error instanceof TransportError) {
+        console.error('Transport error:', error.message);
+    }
+}
+\`\`\`
+
+## Troubleshooting
+
+### WebSocket Issues in Node.js
+If you get an error like "WebSocket implementation not available", make sure you have installed the \`ws\` package:
+\`\`\`bash
+npm install ws
+\`\`\`
+
+### Browser Compatibility
+The client uses the native WebSocket API in browsers, which is supported in all modern browsers. No additional dependencies are required.
+`
+        )
+    ];
+};