@getarbiter/cli 0.5.0

package/dist/templates/contract-testing/graphql/graphql-inspector.test.ts.ejs

@@ -0,0 +1,20 @@
+import { execFileSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+
+describe('<%= projectName %> GraphQL schema compatibility', () => {
+  const referenceSchema = path.resolve(process.cwd(), 'contracts', 'schema-reference.graphql');
+  const currentSchema = path.resolve(process.cwd(), 'contracts', 'schema-current.graphql');
+
+  it('has no breaking schema changes', () => {
+    if (!existsSync(referenceSchema) || !existsSync(currentSchema)) {
+      console.warn('[WARN] GraphQL schema files not found — skipping diff');
+      return;
+    }
+    execFileSync(
+      'npx',
+      ['@graphql-inspector/cli', 'diff', referenceSchema, currentSchema],
+      { encoding: 'utf-8', stdio: 'inherit' },
+    );
+  });
+});

package/dist/templates/contract-testing/graphql/graphql_schema_test.go.ejs

@@ -0,0 +1,27 @@
+//go:build contract
+// +build contract
+
+package contracts_test
+
+import (
+	"os"
+	"os/exec"
+	"testing"
+)
+
+func TestNoBreakingGraphQLChanges(t *testing.T) {
+	if _, err := os.Stat("contracts/schema-reference.graphql"); os.IsNotExist(err) {
+		t.Skip("GraphQL reference schema not found")
+	}
+	if _, err := os.Stat("contracts/schema-current.graphql"); os.IsNotExist(err) {
+		t.Skip("GraphQL current schema not found")
+	}
+
+	cmd := exec.Command("npx", "@graphql-inspector/cli", "diff",
+		"contracts/schema-reference.graphql",
+		"contracts/schema-current.graphql")
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		t.Fatalf("Breaking GraphQL schema changes:\n%s", out)
+	}
+}

package/dist/templates/contract-testing/graphql/graphql_schema_test.rs.ejs

@@ -0,0 +1,27 @@
+#[cfg(test)]
+mod graphql_schema_tests {
+    use std::path::Path;
+    use std::process::Command;
+
+    #[test]
+    fn no_breaking_schema_changes() {
+        let reference = Path::new("contracts/schema-reference.graphql");
+        let current = Path::new("contracts/schema-current.graphql");
+
+        if !reference.exists() || !current.exists() {
+            println!("[WARN] GraphQL schema files not found — skipping diff");
+            return;
+        }
+
+        let output = Command::new("npx")
+            .args(["@graphql-inspector/cli", "diff",
+                   "contracts/schema-reference.graphql",
+                   "contracts/schema-current.graphql"])
+            .output()
+            .expect("Failed to run graphql-inspector");
+
+        assert!(output.status.success(),
+            "Breaking GraphQL schema changes:\n{}",
+            String::from_utf8_lossy(&output.stdout));
+    }
+}

package/dist/templates/contract-testing/graphql/test_graphql_schema.py.ejs

@@ -0,0 +1,21 @@
+import subprocess
+import os
+import pytest
+
+
+@pytest.mark.skipif(
+    not (os.path.exists("contracts/schema-reference.graphql") and
+         os.path.exists("contracts/schema-current.graphql")),
+    reason="GraphQL schema files not found",
+)
+def test_no_breaking_schema_changes():
+    result = subprocess.run(
+        ["npx", "@graphql-inspector/cli", "diff",
+         "contracts/schema-reference.graphql",
+         "contracts/schema-current.graphql"],
+        capture_output=True,
+        text=True,
+    )
+    assert result.returncode == 0, (
+        f"Breaking GraphQL schema changes:\n{result.stdout}\n{result.stderr}"
+    )

package/dist/templates/contract-testing/grpc/GrpcContractTest.java.ejs

@@ -0,0 +1,23 @@
+package <%= basePackage || 'com.example' %>.contracts;
+
+import org.junit.jupiter.api.Test;
+
+import java.io.File;
+import java.io.IOException;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class GrpcContractTest {
+
+    @Test
+    void noBreakingProtobufChanges() throws IOException, InterruptedException {
+        if (!new File("proto").exists()) {
+            System.out.println("[WARN] proto/ directory not found — skipping buf check");
+            return;
+        }
+        ProcessBuilder pb = new ProcessBuilder("buf", "breaking", "--against", ".git#branch=main");
+        pb.inheritIO();
+        int exitCode = pb.start().waitFor();
+        assertEquals(0, exitCode, "Breaking Protobuf changes detected by buf");
+    }
+}

package/dist/templates/contract-testing/grpc/buf-breaking.yml.ejs

@@ -0,0 +1,6 @@
+# buf breaking change detection
+# Run: buf breaking --against .git#branch=main
+# This file configures which rules apply.
+version: v2
+use:
+  - FILE

package/dist/templates/contract-testing/grpc/buf.yaml.ejs

@@ -0,0 +1,11 @@
+# buf configuration for <%= projectName %>
+# See https://buf.build/docs/configuration/v2/buf-yaml
+version: v2
+modules:
+  - path: proto
+lint:
+  use:
+    - DEFAULT
+breaking:
+  use:
+    - FILE

package/dist/templates/contract-testing/grpc/grpc-contract.test.ts.ejs

@@ -0,0 +1,16 @@
+import { execFileSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+
+describe('<%= projectName %> gRPC Protobuf breaking-change detection', () => {
+  it('has no breaking Protobuf changes vs main branch', () => {
+    if (!existsSync('proto')) {
+      console.warn('[WARN] proto/ directory not found — skipping buf check');
+      return;
+    }
+    execFileSync(
+      'buf',
+      ['breaking', '--against', '.git#branch=main'],
+      { encoding: 'utf-8', stdio: 'inherit' },
+    );
+  });
+});

package/dist/templates/contract-testing/grpc/grpc_contract_test.go.ejs

@@ -0,0 +1,22 @@
+//go:build contract
+// +build contract
+
+package contracts_test
+
+import (
+	"os"
+	"os/exec"
+	"testing"
+)
+
+func TestNoBreakingProtobufChanges(t *testing.T) {
+	if _, err := os.Stat("proto"); os.IsNotExist(err) {
+		t.Skip("proto/ directory not found — skipping buf check")
+	}
+
+	cmd := exec.Command("buf", "breaking", "--against", ".git#branch=main")
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		t.Fatalf("Breaking Protobuf changes detected:\n%s", out)
+	}
+}

package/dist/templates/contract-testing/grpc/grpc_contract_test.rs.ejs

@@ -0,0 +1,22 @@
+#[cfg(test)]
+mod grpc_contract_tests {
+    use std::path::Path;
+    use std::process::Command;
+
+    #[test]
+    fn no_breaking_protobuf_changes() {
+        if !Path::new("proto").exists() {
+            println!("[WARN] proto/ directory not found — skipping buf check");
+            return;
+        }
+
+        let output = Command::new("buf")
+            .args(["breaking", "--against", ".git#branch=main"])
+            .output()
+            .expect("Failed to run buf");
+
+        assert!(output.status.success(),
+            "Breaking Protobuf changes detected:\n{}",
+            String::from_utf8_lossy(&output.stdout));
+    }
+}

package/dist/templates/contract-testing/grpc/test_grpc_contract.py.ejs

@@ -0,0 +1,18 @@
+import subprocess
+import os
+import pytest
+
+
+@pytest.mark.skipif(
+    not os.path.exists("proto"),
+    reason="proto/ directory not found — skipping buf check",
+)
+def test_no_breaking_protobuf_changes():
+    result = subprocess.run(
+        ["buf", "breaking", "--against", ".git#branch=main"],
+        capture_output=True,
+        text=True,
+    )
+    assert result.returncode == 0, (
+        f"Breaking Protobuf changes detected:\n{result.stdout}\n{result.stderr}"
+    )

package/dist/templates/contract-testing/message-queue/SchemaRegistryCheckIT.java.ejs

@@ -0,0 +1,44 @@
+package <%= basePackage || 'com.example' %>.contracts;
+
+import io.confluent.kafka.schemaregistry.client.CachedSchemaRegistryClient;
+import io.confluent.kafka.schemaregistry.client.SchemaRegistryClient;
+import io.confluent.kafka.schemaregistry.client.rest.exceptions.RestClientException;
+import org.junit.jupiter.api.Test;
+
+import java.io.IOException;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+/**
+ * Schema Registry compatibility integration test (INV-41).
+ * Calls testCompatibility() — not just a reachability ping.
+ */
+class SchemaRegistryCheckIT {
+
+    private static final String SUBJECT = "<%= projectName %>-events-value";
+
+    @Test
+    void schemaIsBackwardOrFullCompatible() throws IOException, RestClientException {
+        String registryUrl = System.getenv("SCHEMA_REGISTRY_URL");
+        if (registryUrl == null || registryUrl.isBlank()) {
+            System.out.println("[WARN] SCHEMA_REGISTRY_URL not set — skipping");
+            return;
+        }
+
+        SchemaRegistryClient client = new CachedSchemaRegistryClient(registryUrl, 100);
+
+        // Verify compat level is BACKWARD or FULL (INV-41)
+        String compatLevel = client.getCompatibility(SUBJECT);
+        List<String> allowed = List.of("BACKWARD", "FULL", "BACKWARD_TRANSITIVE", "FULL_TRANSITIVE");
+        assertTrue(allowed.contains(compatLevel),
+            "Expected BACKWARD or FULL compat for " + SUBJECT + " but got: " + compatLevel);
+
+        // Fetch latest schema and run real compatibility check
+        int latestId = client.getLatestSchemaMetadata(SUBJECT).getId();
+        var latestSchema = client.getSchemaById(latestId);
+
+        boolean compatible = client.testCompatibility(SUBJECT, latestSchema);
+        assertTrue(compatible, "Schema is not compatible with latest version for subject: " + SUBJECT);
+    }
+}

package/dist/templates/contract-testing/message-queue/schema-registry-check.ts.ejs

@@ -0,0 +1,42 @@
+import { SchemaRegistry } from '@kafkajs/confluent-schema-registry';
+
+/**
+ * Contract test: verify schema compatibility with the Schema Registry (INV-41).
+ *
+ * Calls testCompatibility() — not just a reachability ping.
+ * Requires SCHEMA_REGISTRY_URL environment variable.
+ * Subject convention: <%= projectName %>-events-value
+ */
+describe('<%= projectName %> Schema Registry compatibility', () => {
+  const registryUrl = process.env['SCHEMA_REGISTRY_URL'];
+
+  beforeAll(() => {
+    if (!registryUrl) {
+      console.warn('[WARN] SCHEMA_REGISTRY_URL not set — skipping schema registry checks');
+    }
+  });
+
+  it('schema is BACKWARD or FULL compatible with latest registered version', async () => {
+    if (!registryUrl) return;
+
+    const registry = new SchemaRegistry({ host: registryUrl });
+    const subject = '<%= projectName %>-events-value';
+
+    // Fetch current compat level for this subject (falls back to global config)
+    const configUrl = `${registryUrl}/config/${encodeURIComponent(subject)}`;
+    const resp = await fetch(configUrl);
+    if (resp.ok) {
+      const { compatibilityLevel } = (await resp.json()) as { compatibilityLevel: string };
+      const allowed = ['BACKWARD', 'FULL', 'BACKWARD_TRANSITIVE', 'FULL_TRANSITIVE'];
+      expect(allowed).toContain(compatibilityLevel);
+    }
+
+    // Retrieve the latest registered schema and run testCompatibility
+    const latestId = await registry.getRegistryId(subject, 'latest');
+    expect(latestId).toBeGreaterThan(0);
+
+    const schema = await registry.getSchema(latestId);
+    const isCompatible = await registry.testCompatibility(subject, schema);
+    expect(isCompatible).toBe(true);
+  });
+});

package/dist/templates/contract-testing/message-queue/schema_registry_test.go.ejs

@@ -0,0 +1,71 @@
+//go:build contract
+// +build contract
+
+package contracts_test
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"testing"
+)
+
+// TestSchemaRegistryCompatibility verifies schema is BACKWARD or FULL compatible (INV-41).
+// Calls the /compatibility/ endpoint — not just a reachability ping.
+func TestSchemaRegistryCompatibility(t *testing.T) {
+	registryURL := os.Getenv("SCHEMA_REGISTRY_URL")
+	if registryURL == "" {
+		t.Skip("SCHEMA_REGISTRY_URL not set — skipping schema registry check")
+	}
+
+	subject := "<%= projectName %>-events-value"
+
+	// Fetch current compat level for this subject
+	configURL := fmt.Sprintf("%s/config/%s", registryURL, subject)
+	resp, err := http.Get(configURL)
+	if err != nil {
+		t.Fatalf("failed to fetch compat config: %v", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode == http.StatusOK {
+		var cfg struct {
+			CompatibilityLevel string `json:"compatibilityLevel"`
+		}
+		body, _ := io.ReadAll(resp.Body)
+		_ = json.Unmarshal(body, &cfg)
+		allowed := map[string]bool{"BACKWARD": true, "FULL": true, "BACKWARD_TRANSITIVE": true, "FULL_TRANSITIVE": true}
+		if !allowed[cfg.CompatibilityLevel] {
+			t.Errorf("expected BACKWARD or FULL compat for %s, got %s", subject, cfg.CompatibilityLevel)
+		}
+	}
+
+	// Fetch latest schema version and run compatibility check
+	versionsURL := fmt.Sprintf("%s/subjects/%s/versions/latest", registryURL, subject)
+	vResp, err := http.Get(versionsURL)
+	if err != nil {
+		t.Fatalf("failed to fetch latest schema: %v", err)
+	}
+	defer vResp.Body.Close()
+	latestBody, _ := io.ReadAll(vResp.Body)
+
+	// POST to /compatibility/ with the latest schema as the candidate
+	compatURL := fmt.Sprintf("%s/compatibility/subjects/%s/versions/latest", registryURL, subject)
+	postResp, err := http.Post(compatURL, "application/vnd.schemaregistry.v1+json", bytes.NewReader(latestBody))
+	if err != nil {
+		t.Fatalf("compatibility check request failed: %v", err)
+	}
+	defer postResp.Body.Close()
+
+	var result struct {
+		IsCompatible bool `json:"is_compatible"`
+	}
+	body, _ := io.ReadAll(postResp.Body)
+	_ = json.Unmarshal(body, &result)
+	if !result.IsCompatible {
+		t.Errorf("schema is not compatible with latest version for subject %s", subject)
+	}
+}

package/dist/templates/contract-testing/message-queue/schema_registry_test.rs.ejs

@@ -0,0 +1,61 @@
+#[cfg(test)]
+mod schema_registry_tests {
+    use reqwest::Client;
+    use serde::Deserialize;
+
+    const SUBJECT: &str = "<%= projectName %>-events-value";
+
+    #[derive(Deserialize)]
+    struct CompatibilityResult {
+        is_compatible: bool,
+    }
+
+    /// Verify schema is BACKWARD or FULL compatible with the latest version (INV-41).
+    /// Calls POST /compatibility/ — not just a reachability ping.
+    #[tokio::test]
+    async fn schema_registry_compatibility() {
+        let registry_url = match std::env::var("SCHEMA_REGISTRY_URL") {
+            Ok(url) => url,
+            Err(_) => {
+                println!("[WARN] SCHEMA_REGISTRY_URL not set — skipping");
+                return;
+            }
+        };
+
+        let client = Client::new();
+
+        // Fetch latest schema version to use as candidate
+        let latest_url = format!(
+            "{}/subjects/{}/versions/latest",
+            registry_url, SUBJECT
+        );
+        let latest_resp = client
+            .get(&latest_url)
+            .send()
+            .await
+            .expect("failed to fetch latest schema");
+        let latest_body = latest_resp.text().await.expect("failed to read body");
+
+        // POST to /compatibility/ with the latest schema as the candidate
+        let compat_url = format!(
+            "{}/compatibility/subjects/{}/versions/latest",
+            registry_url, SUBJECT
+        );
+        let result: CompatibilityResult = client
+            .post(&compat_url)
+            .header("Content-Type", "application/vnd.schemaregistry.v1+json")
+            .body(latest_body)
+            .send()
+            .await
+            .expect("compatibility check request failed")
+            .json()
+            .await
+            .expect("failed to parse compatibility response");
+
+        assert!(
+            result.is_compatible,
+            "Schema is not compatible with latest version for subject: {}",
+            SUBJECT
+        );
+    }
+}

package/dist/templates/contract-testing/message-queue/test_schema_registry.py.ejs

@@ -0,0 +1,31 @@
+import os
+import pytest
+from confluent_kafka.schema_registry import SchemaRegistryClient
+
+
+@pytest.mark.skipif(
+    not os.environ.get("SCHEMA_REGISTRY_URL"),
+    reason="SCHEMA_REGISTRY_URL not set — skipping schema registry check",
+)
+def test_schema_registry_compatibility():
+    """Verify schema is BACKWARD or FULL compatible with the latest version (INV-41)."""
+    url = os.environ["SCHEMA_REGISTRY_URL"]
+    client = SchemaRegistryClient({"url": url})
+
+    subject = "<%= projectName %>-events-value"
+
+    # Verify compat level is BACKWARD or FULL
+    allowed = {"BACKWARD", "FULL", "BACKWARD_TRANSITIVE", "FULL_TRANSITIVE"}
+    compat = client.get_compatibility(subject_name=subject)
+    assert compat in allowed, (
+        f"Expected BACKWARD or FULL compat for {subject}, got {compat}"
+    )
+
+    # Fetch latest schema and run real compatibility check
+    latest = client.get_latest_version(subject)
+    is_compatible = client.test_compatibility(
+        subject_name=subject, schema=latest.schema
+    )
+    assert is_compatible, (
+        f"Schema is not compatible with latest version for subject: {subject}"
+    )

package/dist/templates/contract-testing/pact-samples/assignment-response.json.ejs

@@ -0,0 +1,7 @@
+{
+  "uuid": "00000000-0000-4000-8000-000000000001",
+  "resourceUuid": "00000000-0000-4000-8000-000000000002",
+  "startTime": "2026-01-01T09:00:00",
+  "endTime": "2026-01-01T17:00:00",
+  "status": "CONFIRMED"
+}

package/dist/templates/contract-testing/pact-samples/availability-response.json.ejs

@@ -0,0 +1,13 @@
+{
+  "resources": [
+    {
+      "resourceId": "00000000-0000-4000-8000-000000000002",
+      "slots": [
+        {
+          "start": "2026-01-02T09:00:00",
+          "end": "2026-01-02T17:00:00"
+        }
+      ]
+    }
+  ]
+}

package/dist/templates/contract-testing/pact-samples/availability-rule-response.json.ejs

@@ -0,0 +1,8 @@
+{
+  "uuid": "00000000-0000-4000-8000-000000000005",
+  "resourceUuid": "00000000-0000-4000-8000-000000000002",
+  "dayOfWeek": 1,
+  "startTime": "09:00",
+  "endTime": "17:00",
+  "effectiveFrom": "2026-01-01"
+}

package/dist/templates/contract-testing/pact-samples/capacity-response.json.ejs

@@ -0,0 +1,11 @@
+{
+  "resources": [
+    {
+      "resourceUuid": "00000000-0000-4000-8000-000000000002",
+      "totalMinutes": 480,
+      "bookedMinutes": 0,
+      "availableMinutes": 480,
+      "utilizationPercent": 0.0
+    }
+  ]
+}

package/dist/templates/contract-testing/pact-samples/fully-booked-response.json.ejs

@@ -0,0 +1,6 @@
+{
+  "resourceUuid": "00000000-0000-4000-8000-000000000002",
+  "from": "2026-01-01",
+  "to": "2026-01-31",
+  "fullyBookedPeriods": []
+}

package/dist/templates/contract-testing/pact-samples/schedule-override-response.json.ejs

@@ -0,0 +1,7 @@
+{
+  "uuid": "00000000-0000-4000-8000-000000000006",
+  "resourceUuid": "00000000-0000-4000-8000-000000000002",
+  "overrideType": "BLOCK",
+  "startTime": "2030-01-01T10:00:00",
+  "endTime": "2030-01-01T12:00:00"
+}

package/dist/templates/contract-testing/rest-owned/PactVerificationIT.java.ejs

@@ -0,0 +1,31 @@
+package <%= basePackage || 'com.example' %>.contracts;
+
+import au.com.dius.pact.provider.junit5.PactVerificationContext;
+import au.com.dius.pact.provider.junit5.PactVerificationInvocationContextProvider;
+import au.com.dius.pact.provider.junitsupport.Provider;
+import au.com.dius.pact.provider.junitsupport.loader.PactFolder;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.TestTemplate;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.boot.test.web.server.LocalServerPort;
+
+@Provider("<%= projectName %>-provider")
+@PactFolder("pacts")
+@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
+class PactVerificationIT {
+
+    @LocalServerPort
+    private int port;
+
+    @BeforeEach
+    void before(PactVerificationContext context) {
+        context.setTarget(new au.com.dius.pact.provider.junit5.HttpTestTarget("localhost", port));
+    }
+
+    @TestTemplate
+    @ExtendWith(PactVerificationInvocationContextProvider.class)
+    void pactVerificationTestTemplate(PactVerificationContext context) {
+        context.verifyInteraction();
+    }
+}

package/dist/templates/contract-testing/rest-owned/pact-consumer.test.ts.ejs

@@ -0,0 +1,36 @@
+import { MatchersV3, PactV3 } from '@pact-foundation/pact'
+import { describe, expect, it } from 'vitest'
+import path from 'node:path'
+
+const provider = new PactV3({
+  consumer: '<%= projectName %>-consumer',
+  provider: '<%= projectName %>-provider',
+  dir: path.resolve(process.cwd(), 'pacts'),
+})
+
+describe('<%= projectName %> Pact Consumer', () => {
+  it('gets a resource', async () => {
+    provider.addInteraction({
+      state: 'a resource exists',
+      uponReceiving: 'a request for a resource',
+      withRequest: {
+        method: 'GET',
+        path: '/api/resource',
+        headers: { Accept: 'application/json' },
+      },
+      willRespondWith: {
+        status: 200,
+        headers: { 'Content-Type': 'application/json' },
+        body: MatchersV3.like({ id: 1, name: 'example' }),
+      },
+    })
+
+    await provider.executeTest(async (mockServer) => {
+      const response = await fetch(`${mockServer.url}/api/resource`, {
+        headers: { Accept: 'application/json' },
+      })
+      expect(response.status).toBe(200)
+      expect(await response.json()).toEqual({ id: 1, name: 'example' })
+    })
+  })
+})

package/dist/templates/contract-testing/rest-owned/pact-deps.gradle.ejs

@@ -0,0 +1,15 @@
+// Pact provider verification dependencies (M28 contract testing)
+dependencies {
+    testImplementation 'au.com.dius.pact.provider:junit5:4.6.14'
+    testImplementation 'au.com.dius.pact.provider:junit5spring:4.6.14'
+}
+
+test {
+    systemProperty 'pact.provider.version', project.version
+    systemProperty 'pact.verifier.publishResults', System.getProperty('pact.verifier.publishResults', 'false')
+    // INV-42: broker URL/token read from env — gate skips when PACT_BROKER_BASE_URL unset
+    if (System.getenv('PACT_BROKER_BASE_URL')) {
+        systemProperty 'pact.broker.url', System.getenv('PACT_BROKER_BASE_URL')
+        systemProperty 'pact.broker.auth.token', System.getenv('PACT_BROKER_TOKEN') ?: ''
+    }
+}