OpenAPI Generator Workflows — Automating Code Generation with GitHub Actions and CI/CD

# .github/workflows/openapi-generate.yml
name: Generate SDKs from OpenAPI Spec

on:
  push:
    paths:
      - 'openapi/**/*.yaml'
      - 'openapi/**/*.json'
  workflow_dispatch:

jobs:
  validate:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Validate OpenAPI spec
        run: |
          npm install -g @redocly/cli
          redocly lint openapi/spec.yaml

  generate:
    needs: validate
    strategy:
      matrix:
        language: [python, typescript-axios, java, go, csharp-netcore]
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Set up Java
        uses: actions/setup-java@v4
        with:
          java-version: '17'

      - name: Generate ${{ matrix.language }} SDK
        run: |
          mkdir -p generated/${{ matrix.language }}
          openapi-generator-cli generate \
            -i openapi/spec.yaml \
            -g ${{ matrix.language }} \
            -o generated/${{ matrix.language }} \
            --additional-properties=packageName=dodatech-${{ matrix.language }}

      - name: Upload ${{ matrix.language }} SDK
        uses: actions/upload-artifact@v4
        with:
          name: sdk-${{ matrix.language }}
          path: generated/${{ matrix.language }}

  test:
    needs: generate
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Download all SDKs
        uses: actions/download-artifact@v4
        with:
          pattern: sdk-*
          path: generated
      - name: Run contract tests
        run: |
          python scripts/test-sdks.py \
            --spec openapi/spec.yaml \
            --sdk-dir generated

# .gitlab-ci.yml
stages:
  - validate
  - generate
  - test
  - publish

variables:
  SPEC_FILE: openapi/spec.yaml
  GENERATED_DIR: generated

validate-spec:
  stage: validate
  image: node:20
  script:
    - npm install -g @redocly/cli
    - redocly lint $SPEC_FILE

generate-python:
  stage: generate
  image: openapitools/openapi-generator-cli:v7.0
  script:
    - mkdir -p $GENERATED_DIR/python
    - openapi-generator-cli generate
      -i $SPEC_FILE
      -g python
      -o $GENERATED_DIR/python
      --additional-properties=packageName=dodatech_client
  artifacts:
    paths:
      - $GENERATED_DIR/python

generate-typescript:
  stage: generate
  image: openapitools/openapi-generator-cli:v7.0
  script:
    - mkdir -p $GENERATED_DIR/typescript
    - openapi-generator-cli generate
      -i $SPEC_FILE
      -g typescript-axios
      -o $GENERATED_DIR/typescript
  artifacts:
    paths:
      - $GENERATED_DIR/typescript

test-sdks:
  stage: test
  image: python:3.11
  script:
    - cd $GENERATED_DIR/python
    - pip install -e .
    - python -m pytest -v test/
    - cd ../../

publish-pypi:
  stage: publish
  image: python:3.11
  script:
    - cd $GENERATED_DIR/python
    - python setup.py sdist bdist_wheel
    - TWINE_PASSWORD=$PYPI_TOKEN twine upload --username __token__ dist/*
  only:
    - main

import subprocess
import json
import sys
from pathlib import Path
from datetime import datetime

class OpenAPIWorkflow:
    def __init__(self, spec_path, config_path):
        self.spec_path = Path(spec_path)
        with open(config_path) as f:
            self.config = json.load(f)

    def run(self):
        """Run the complete generation workflow."""
        print(f"Starting workflow for {self.spec_path}")
        start_time = datetime.now()

        # Step 1: Validate spec
        print("\n[1/5] Validating spec...")
        self._validate_spec()

        # Step 2: Generate SDKs
        print("\n[2/5] Generating SDKs...")
        for lang_config in self.config['generators']:
            self._generate_sdk(lang_config)

        # Step 3: Generate server stubs
        print("\n[3/5] Generating server stubs...")
        for server_config in self.config.get('servers', []):
            self._generate_server(server_config)

        # Step 4: Run tests
        print("\n[4/5] Running tests...")
        self._run_tests()

        # Step 5: Package artifacts
        print("\n[5/5] Packaging artifacts...")
        self._package_artifacts()

        elapsed = (datetime.now() - start_time).total_seconds()
        print(f"\nWorkflow completed in {elapsed:.1f} seconds")

    def _validate_spec(self):
        result = subprocess.run([
            'redocly', 'lint', str(self.spec_path)
        ], capture_output=True, text=True)
        if result.returncode != 0:
            print("Spec validation failed:")
            print(result.stdout)
            sys.exit(1)
        print("Spec validation passed")

    def _generate_sdk(self, lang_config):
        lang = lang_config['language']
        output = self.config['output_dir'] / lang
        output.mkdir(parents=True, exist_ok=True)

        cmd = [
            'openapi-generator-cli', 'generate',
            '-i', str(self.spec_path),
            '-g', lang,
            '-o', str(output)
        ]
        for key, value in lang_config.get('properties', {}).items():
            cmd.extend(['--additional-properties', f"{key}={value}"])

        result = subprocess.run(cmd, capture_output=True, text=True)
        if result.returncode == 0:
            print(f"  {lang}: generated successfully")
        else:
            print(f"  {lang}: FAILED - {result.stderr[:200]}")

    def _run_tests(self):
        for lang_config in self.config['generators']:
            lang = lang_config['language']
            output = self.config['output_dir'] / lang
            test_dir = output / 'test'

            if test_dir.exists():
                result = subprocess.run([
                    'pytest', str(test_dir), '-v', '--tb=short'
                ], capture_output=True, text=True)
                if result.returncode == 0:
                    print(f"  {lang}: tests passed")
                else:
                    print(f"  {lang}: tests FAILED")

    def _package_artifacts(self):
        artifact_dir = self.config['output_dir'] / 'artifacts'
        artifact_dir.mkdir(exist_ok=True)
        for lang_config in self.config['generators']:
            lang = lang_config['language']
            source = self.config['output_dir'] / lang
            target = artifact_dir / f"sdk-{lang}.zip"
            subprocess.run(['zip', '-r', str(target), str(source)])

# Usage
workflow = OpenAPIWorkflow(
    'openapi/spec.yaml',
    'openapi/workflow-config.json'
)
workflow.run()