Flynk.AutoGen.CS2TS 1.0.1

Flynk.AutoGen.CS2TS

Automatic TypeScript code generation from C# using Roslyn

Generate clean, type-safe TypeScript interfaces, enums, and API clients directly from your C# codebase. Perfect for maintaining consistency between your backend and frontend without manual synchronization.

✨ Features

• 🚀 Roslyn-based Analysis - Direct C# source code analysis, no reflection needed
• 📝 YAML Configuration - Simple, declarative configuration files
• 🔄 Incremental Updates - Only regenerates changed files
• 🧹 Automatic Cleanup - Removes obsolete generated files
• 🎯 Nested Enum Support - Correctly handles nested types like Property.DataTypes → PropertyDataTypes
• 🔍 Error Detection - Validates for duplicate method names and circular dependencies
• 📦 Repository-Specific - Each TypeScript repo maintains its own configuration
• 🎨 Clean Output - Generates readable, formatted TypeScript code

📦 Installation

Install as a local .NET tool in your TypeScript project:

# Navigate to your TypeScript repository
cd myproject.common.ts

# Create tool manifest (first time only)
dotnet new tool-manifest

# Install the tool
dotnet tool install Flynk.AutoGen.CS2TS

🚀 Quick Start

1. Create Configuration File

Create codegen.config.yaml in your TypeScript repository:

# Project identification
projectName: "My Project"

# C# Source Configuration
source:
  # Path to .sln file (relative to this config file)
  solutionPath: "../MyProject.Server/MyProject.Server.sln"

  # C# projects to include
  includedProjects:
    - "MyProject.Common"
    - "MyProject.Utils"

  # Namespace prefixes to include
  includedNamespaces:
    - "MyProject"

# TypeScript Output Configuration
output:
  basePath: "."
  directories:
    dtos: "dtos"
    requests: "requests"
    enums: "enums"
    apis: "api"

# Type Mapping Configuration
typeMapping:
  # Types to skip (provided by consuming project)
  skipTypes:
    - "PagedList"
    - "Response"
    - "IRequestConfig"

# Generation Options
generation:
  skipNavigationProperties: true
  skipControllers:
    - "BaseController"
  skipCleanup:
    - "base.ts"
    - "index.ts"

2. Run Code Generation

# Simple generation
dotnet cs2ts --config codegen.config.yaml

# With verbose output
dotnet cs2ts --config codegen.config.yaml --verbose

# Hard reset (delete all outputs first)
dotnet cs2ts --config codegen.config.yaml --hard-reset

# Generate only specific project
dotnet cs2ts --config codegen.config.yaml --project "MyProject.Common"

📋 What Gets Generated?

From your C# code:

namespace MyProject.Common.DTO
{
    public class UserDTO
    {
        public Guid Id { get; set; }
        public string Name { get; set; }
        public string Email { get; set; }
        public UserStatus Status { get; set; }
        public DateTime CreatedAt { get; set; }
    }

    public enum UserStatus
    {
        Active = 1,
        Inactive = 2,
        Suspended = 3
    }
}

Generates TypeScript:

dtos/user-dto.ts:

// Auto-generated from UserDTO
import { UserStatus } from '../enums/user-status'

export interface UserDTO {
    id: string
    name: string
    email: string
    status: UserStatus
    createdAt: string
}

enums/user-status.ts:

// Auto-generated from UserStatus
export enum UserStatus {
    Active = 1,
    Inactive = 2,
    Suspended = 3,
}

🔧 CLI Options

Execution Scope (NOT Configuration)

All project configuration goes in YAML. CLI options control execution:

• --config, -c <path> - Path to codegen.config.yaml
• --hard-reset, -r - Delete all output directories before generation
• --project, -p <name> - Generate only for specific project (overrides config)
• --namespace, -n <name> - Generate only for specific namespace (overrides config)
• --verbose, -v - Enable verbose logging
• --help, -h - Show help message

📝 Type Conversion

🎯 Use Cases

Backend + Frontend Sync

Keep your TypeScript frontend in perfect sync with your C# backend API models.

Multiple Microservices

Generate TypeScript clients for multiple C# services, each with its own configuration.

Shared Libraries

Generate TypeScript definitions from shared C# libraries for consistent types across projects.

🔄 Workflow Integration

Development Script

Create generate-typescript.sh:

#!/bin/bash
set -e

cd "$(dirname "${BASH_SOURCE[0]}")"

echo "Generating TypeScript from C#..."
dotnet cs2ts --config codegen.config.yaml

echo "✅ Generation complete!"

CI/CD Integration

# GitHub Actions example
- name: Install CS2TS
  run: dotnet tool restore

- name: Generate TypeScript
  run: dotnet cs2ts --config codegen.config.yaml

- name: Check for changes
  run: git diff --exit-code || echo "TypeScript definitions updated"

📚 Configuration Reference

Source Configuration

source:
  solutionPath: "../path/to/solution.sln"  # Required
  includedProjects:                        # Required
    - "Project1"
    - "Project2"
  includedNamespaces:                      # Required
    - "MyNamespace"
    - "MyOtherNamespace"

Output Configuration

output:
  basePath: "."                            # Default: current directory
  directories:
    dtos: "dtos"                          # Default: "dtos"
    requests: "requests"                  # Default: "requests"
    enums: "enums"                        # Default: "enums"
    apis: "api"                           # Default: "api"

Type Mapping

typeMapping:
  skipTypes:
    - "TypeName1"    # Types to exclude from generation
    - "TypeName2"    # (assumed to be provided by consuming project)

Generation Options

generation:
  skipNavigationProperties: true          # Avoid circular dependencies
  skipControllers:
    - "BaseController"                   # Controllers to skip
  skipCleanup:
    - "base.ts"                          # Files to preserve during cleanup
    - "index.ts"

Git Integration (Optional)

git:
  autoCommit: false                       # Auto-commit generated changes
  autoPush: false                         # Auto-push after commit
  commitMessage: "Update TypeScript definitions from C# code"

🛠️ Advanced Usage

Multiple Repositories

Each TypeScript repository should have its own configuration:

MyProject/
├── backend/
│   └── MyProject.sln
├── frontend-web/
│   ├── codegen.config.yaml      # Config for web frontend
│   └── .config/
│       └── dotnet-tools.json
└── frontend-mobile/
    ├── codegen.config.yaml      # Config for mobile frontend
    └── .config/
        └── dotnet-tools.json

Filtering During Execution

Override configuration temporarily:

# Generate only Core project
dotnet cs2ts -c codegen.config.yaml -p "MyProject.Core"

# Generate only specific namespace
dotnet cs2ts -c codegen.config.yaml -n "MyProject.Admin"

🤝 Contributing

Issues and pull requests are welcome. Just reach out @ Flynk Support.

📄 License

See LICENSE.txt for details.

🔗 Links

• Flynk
• NuGet Package

Made with ❤️ by Flynk