[PLAT-6843] -- Fix publishing for multi module format

.github/workflows/build.yml

@@ -1,6 +1,8 @@
 name: build
 
-on: [pull_request]
+on:
+  push:
+    branches-ignore: [main]
 
 jobs:
   build:
@@ -11,8 +13,5 @@ jobs:
         with: { java-version: 17, distribution: temurin }
       - name: Build and Verify
         run: |
-          # Build the plugin first and check its contents
-          ./gradlew :openapi-generator-plugin:build
-
-          # Now run the full build
-          ./gradlew clean build
+          # With convention plugins, everything is self-contained
+          ./gradlew -PisSnapshot=true clean build

.github/workflows/pr-snapshot.yml

@@ -0,0 +1,45 @@
+name: PR Snapshot
+
+on:
+  push:
+    branches-ignore:
+      - main
+
+jobs:
+  build-and-publish-snapshot:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-java@v4
+        with:
+          java-version: 17
+          distribution: temurin
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+
+      - name: Build and Publish Snapshot
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          GITHUB_ACTOR: ${{ github.actor }}
+           # Sonatype credentials
+          OSSRH_USERNAME: ${{ secrets.MAVEN_CENTRAL_CREDS_TOKEN_USER }}
+          OSSRH_PASSWORD: ${{ secrets.MAVEN_CENTRAL_CREDS_TOKEN_PASS }}
+          # Optional signing environment variables for consistency with publish workflow
+          SIGNING_KEY: ${{ secrets.ORG_GRADLE_PROJECT_signingKey || '' }}
+          SIGNING_PASSWORD: ${{ secrets.ORG_GRADLE_PROJECT_signingPassword || '' }}
+        run: |
+          # Build the plugin first
+          ./gradlew -PisSnapshot=true :openapi-generator-plugin:build :openapi-generator-plugin:publishToMavenLocal
+
+          # Set up parameters based on available secrets
+          GRADLE_PARAMS="-PisSnapshot=true"
+          if [ -n "$SIGNING_KEY" ] && [ -n "$SIGNING_PASSWORD" ]; then
+            GRADLE_PARAMS="$GRADLE_PARAMS -P signingKey=$SIGNING_KEY -P signingPassword=$SIGNING_PASSWORD"
+          fi
+
+          # Publish snapshots to GitHub Packages
+          ./gradlew -PisSnapshot=true \
+            -P ossrhUsername=${{ secrets.MAVEN_CENTRAL_CREDS_TOKEN_USER }} \
+            -P ossrhPassword=${{ secrets.MAVEN_CENTRAL_CREDS_TOKEN_PASS }} \
+            $GRADLE_PARAMS :api-client-library:publishToSonatype

.github/workflows/publish.yml

@@ -35,8 +35,8 @@ jobs:
           ./gradlew \
             -P signingKey=${{ secrets.ORG_GRADLE_PROJECT_signingKey }} \
             -P signingPassword=${{ secrets.ORG_GRADLE_PROJECT_signingPassword }} \
-            -P ossrhUsername=${{ secrets.OSSRH_USERNAME }} \
-            -P ossrhPassword=${{ secrets.OSSRH_PASSWORD }} \
+            -P ossrhUsername=${{ secrets.MAVEN_CENTRAL_CREDS_TOKEN_USER }} \
+            -P ossrhPassword=${{ secrets.MAVEN_CENTRAL_CREDS_TOKEN_PASS }} \
            :api-client-library:publishToSonatype \
-           :api-client-library:closeAndReleaseSonatypeStagingRepository
+           closeAndReleaseSonatypeStagingRepository
           ./scripts/publish.sh

.github/workflows/version-check.yml

@@ -0,0 +1,111 @@
+name: Version Check
+
+on:
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  version-check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0  # Fetch full history to compare branches
+
+      - uses: actions/setup-java@v4
+        with: 
+          java-version: 17
+          distribution: temurin
+
+      - name: Check Version Increment
+        run: |
+          # Extract current version from build.gradle
+          CURRENT_VERSION=$(grep "def projectVersion" build.gradle | sed -E "s/.*def projectVersion = ['\"]([^'\"]*)['\"].*/\1/")
+          echo "Current version: $CURRENT_VERSION"
+
+          # Validate that we extracted current version correctly
+          if [ -z "$CURRENT_VERSION" ]; then
+            echo "❌ Failed to extract current version from build.gradle"
+            exit 1
+          fi
+
+          # Get the latest Git tag from the target branch
+          git fetch origin ${{ github.base_ref }}
+          git checkout origin/${{ github.base_ref }}
+
+          LATEST_TAG=$(git describe --tags --abbrev=0 2>/dev/null || echo "")
+
+          if [ -z "$LATEST_TAG" ]; then
+            echo "No existing tags found. Assuming this is the first release."
+            LATEST_TAG="0.0.0"
+          fi
+
+          # Remove 'v' prefix if present
+          TARGET_VERSION=$(echo "$LATEST_TAG" | sed 's/^v//')
+          echo "Latest tag version: $TARGET_VERSION"
+
+          # Switch back to PR branch
+          git checkout ${{ github.head_ref }}
+
+          # Function to normalize version (ensure 3 parts)
+          normalize_version() {
+            local version=$1
+            IFS='.' read -ra V <<< "$version"
+
+            # Ensure we have 3 parts
+            while [ ${#V[@]} -lt 3 ]; do V+=(0); done
+
+            echo "${V[0]}.${V[1]}.${V[2]}"
+          }
+
+          # Function to compare semantic versions
+          version_compare() {
+            local version1=$1
+            local version2=$2
+
+            # Normalize both versions
+            version1=$(normalize_version "$version1")
+            version2=$(normalize_version "$version2")
+
+            # Split versions into arrays
+            IFS='.' read -ra V1 <<< "$version1"
+            IFS='.' read -ra V2 <<< "$version2"
+
+            # Compare major version
+            if [ "${V1[0]}" -gt "${V2[0]}" ]; then
+              return 0  # version1 > version2
+            elif [ "${V1[0]}" -lt "${V2[0]}" ]; then
+              return 1  # version1 < version2
+            fi
+
+            # Compare minor version
+            if [ "${V1[1]}" -gt "${V2[1]}" ]; then
+              return 0
+            elif [ "${V1[1]}" -lt "${V2[1]}" ]; then
+              return 1
+            fi
+
+            # Compare patch version
+            if [ "${V1[2]}" -gt "${V2[2]}" ]; then
+              return 0
+            elif [ "${V1[2]}" -lt "${V2[2]}" ]; then
+              return 1
+            fi
+
+            # Versions are equal
+            return 2
+          }
+
+          # Compare versions
+          if version_compare "$CURRENT_VERSION" "$TARGET_VERSION"; then
+            echo "✅ Version increment detected: $TARGET_VERSION → $CURRENT_VERSION"
+            exit 0
+          elif [ $? -eq 2 ]; then
+            echo "❌ Version not incremented: $CURRENT_VERSION is the same as $TARGET_VERSION"
+            echo "Please increment the version in build.gradle"
+            exit 1
+          else
+            echo "❌ Version decreased: $TARGET_VERSION → $CURRENT_VERSION"
+            echo "Version should only increase, not decrease"
+            exit 1
+          fi

MULTI_MODULE_README.md

@@ -1,54 +1,26 @@
-# Vertex API Client Java - Multi-Module Project
+# Vertex API Client Java - Project Architecture
 
-This project has been restructured as a multi-module Gradle project with the following modules:
+This project uses a modern Gradle multi-module structure with convention plugins for clean, maintainable builds.
 
-## Modules
+## Project Structure
 
-### 1. `openapi-generator-plugin`
-Custom Gradle plugin for generating Vertex API client code using OpenAPI Generator.
+### Core Modules
 
-**Location**: `openapi-generator-plugin/`
-
-**Purpose**: 
-- Contains custom OpenAPI code generation logic
-- Provides a reusable Gradle plugin for generating the API client
-- Includes any custom templates or generators specific to Vertex API
-
-**Build**: 
-```bash
-./gradlew :openapi-generator-plugin:build
-./gradlew :openapi-generator-plugin:publishToMavenLocal
-```
-
-### 2. `api-client-library`
+#### `api-client-library/`
 The main API client library generated from the OpenAPI specification.
 
-**Location**: `api-client-library/`
-
 **Purpose**:
 - Contains the generated API client code
-- Includes authentication utilities
-- Provides the core SDK functionality
-
-**Build**:
-```bash
-./gradlew :api-client-library:build
-```
+- Includes authentication utilities and models
+- Provides the core SDK functionality that gets published to Maven Central
 
-**Generate API Client**:
-```bash
-./gradlew :api-client-library:openApiGenerate
-```
-
-### 3. `examples`
+#### `examples/`
 Example applications demonstrating how to use the API client library.
 
-**Location**: `examples/`
-
 **Purpose**:
-- Contains example code showing API usage
+- Contains example code showing API usage patterns
 - Includes command-line utilities for common operations
-- Demonstrates best practices for using the API client
+- Demonstrates best practices for authentication and API calls
 
 **Run Examples**:
 ```bash
@@ -57,50 +29,46 @@ Example applications demonstrating how to use the API client library.
 ./gradlew :examples:listExamples
 ```
 
-## Build Order
-
-The modules have dependencies on each other and should be built in this order:
+### Build Infrastructure
 
-1. `openapi-generator-plugin` (standalone)
-2. `api-client-library` (uses the plugin)
-3. `examples` (depends on the library)
+#### `buildSrc/`
+Contains the build logic and custom OpenAPI generator.
 
-## Building the Entire Project
+**Purpose**:
+- Houses convention plugins (`vertex.java-conventions`, `vertex.openapi-generator`)
+- Contains the custom `VertexJavaClientCodegen` generator
+- Provides shared build configuration across all modules
+- Eliminates circular dependencies and external plugin publishing
 
-To build all modules:
-```bash
-./gradlew build
-```
+**Key Files**:
+- `src/main/java/com/vertexvis/codegen/VertexJavaClientCodegen.java` - Custom OpenAPI generator
+- `src/main/groovy/vertex.java-conventions.gradle` - Common Java build settings
+- `src/main/groovy/vertex.openapi-generator.gradle` - OpenAPI generation configuration
 
-To clean and rebuild everything:
-```bash
-./gradlew clean build
-```
+## Architecture Benefits
 
-## Publishing
+### Convention Plugins
+- **Self-contained**: No need to publish plugins separately
+- **Consistent**: Shared configuration across all modules
+- **Maintainable**: Build logic lives with the code it serves
 
-The library can be published to Maven repositories:
-```bash
-./gradlew :api-client-library:publishToMavenLocal
-./gradlew publish
-```
+### Simplified Dependencies
+- **No circular dependencies**: buildSrc → modules (not modules → plugins → modules)
+- **Faster builds**: No separate plugin build/publish cycle
+- **Easier development**: Make changes and build immediately
 
 ## Development Workflow
 
-1. Make changes to the OpenAPI generator plugin if needed
-2. Build and publish the plugin locally: `./gradlew :openapi-generator-plugin:publishToMavenLocal`
-3. Regenerate the API client: `./gradlew :api-client-library:openApiGenerate`
-4. Build the library: `./gradlew :api-client-library:build`
-5. Test with examples: `./gradlew :examples:run`
+The build is completely self-contained:
 
-## Migration Notes
+```bash
+# Everything needed is built automatically
+./gradlew build
 
-This project was converted from a single-module to a multi-module structure:
+# Test examples
+./gradlew :examples:run
 
-- **Original structure**: All code in `src/main/java/com/vertexvis/`
-- **New structure**: 
-  - Code generation logic → `openapi-generator-plugin/`
-  - Core API client → `api-client-library/`
-  - Examples → `examples/`
+# Publish locally for testing
+./gradlew :api-client-library:publishToMavenLocal
+```
 
-The functionality remains the same, but the code is now better organized and the generator can be reused across projects.