CI/CD Code Generation with OpenAPI Generator — Automate API Code in Pipelines

# .github/workflows/codegen.yml
name: API Code Generation
on:
  push:
    branches: [main]
    paths:
      - 'specs/openapi.yaml'
  workflow_dispatch:

jobs:
  generate:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        generator:
          - python-fastapi
          - typescript-fetch
          - swift5
          - kotlin

    steps:
      - uses: actions/checkout@v4

      - name: Setup Java
        uses: actions/setup-java@v4
        with:
          distribution: 'temurin'
          java-version: '17'

      - name: Generate ${{ matrix.generator }}
        uses: openapi-generators/openapitools-generator-action@v1
        with:
          generator: ${{ matrix.generator }}
          openapi-file: specs/openapi.yaml
          config-file: codegen/${{ matrix.generator }}.yaml

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

      - name: Build generated code
        run: |
          cd generated
          if [ -f package.json ]; then npm install && npm run build; fi
          if [ -f pom.xml ]; then mvn compile; fi
          if [ -f Package.swift ]; then swift build; fi

# Expected behavior:
# - Triggers on spec changes to main
# - Generates 4 SDKs in parallel
# - Uploads each as a build artifact
# - Verifies generated code compiles

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

variables:
  SPEC_FILE: specs/openapi.yaml
  JAVA_HOME: /usr/lib/jvm/java-17-openjdk-amd64

validate-spec:
  stage: validate
  script:
    - openapi-generator validate -i $SPEC_FILE
  only:
    changes:
      - specs/openapi.yaml

generate-python:
  stage: generate
  script:
    - openapi-generator generate -i $SPEC_FILE -g python-fastapi -o gen/python/
  artifacts:
    paths:
      - gen/python/

generate-typescript:
  stage: generate
  script:
    - openapi-generator generate -i $SPEC_FILE -g typescript-fetch -o gen/typescript/
  artifacts:
    paths:
      - gen/typescript/

test-generated:
  stage: test
  script:
    - cd gen/python && pip install -r requirements.txt && python -m pytest
    - cd gen/typescript && npm install && npm test
  needs:
    - generate-python
    - generate-typescript

publish:
  stage: publish
  script:
    - npm publish gen/typescript/
    - twine upload gen/python/dist/*
  only:
    - main
  needs:
    - test-generated

# Dockerfile.codegen
FROM openapitools/openapi-generator-cli:v7.5.0

WORKDIR /workspace

COPY specs/ specs/
COPY codegen/ codegen/

# Generate all targets
RUN for gen in python-fastapi typescript-fetch swift5 kotlin; do \
      openapi-generator generate \
        -i specs/openapi.yaml \
        -g $gen \
        -o /output/$gen \
        -c codegen/$gen.yaml; \
    done

CMD ["echo", "Generation complete"]

# Build and run the Docker codegen image:
docker build -t api-codegen -f Dockerfile.codegen .
docker run --rm -v $(pwd)/output:/output api-codegen

# List generated SDKs:
ls output/
# Expected output:
# python-fastapi/
# typescript-fetch/
# swift5/
# kotlin/

# publish_sdks.py - Automate SDK publishing after generation
import os
import subprocess
import json

def publish_sdk(language, output_dir, registry_config):
    """Publish generated SDK to appropriate package registry."""
    print(f"Publishing {language} SDK from {output_dir}")

    if language == "python":
        # Build and publish to PyPI
        subprocess.run(["python", "setup.py", "sdist", "bdist_wheel"],
                      cwd=output_dir, check=True)
        subprocess.run(["twine", "upload", "dist/*"], cwd=output_dir, check=True)
        print(f"Published to PyPI: {output_dir}")

    elif language == "typescript":
        # Publish to npm
        subprocess.run(["npm", "publish"], cwd=output_dir, check=True)
        print(f"Published to npm: {output_dir}")

    elif language == "swift":
        # Publish Swift package
        tag = f"sdk-{language}-{os.environ.get('VERSION', 'latest')}"
        subprocess.run(["git", "tag", tag], check=True)
        subprocess.run(["git", "push", "origin", tag], check=True)
        print(f"Tagged for SPM: {tag}")

    elif language == "kotlin":
        # Publish to Maven Central
        subprocess.run(["./gradlew", "publish"], cwd=output_dir, check=True)
        print(f"Published to Maven Central: {output_dir}")

# Run in CI pipeline:
# python publish_sdks.py
print("SDK publishing script ready")