VirtusLab/besom

Besom is a Scala SDK for Pulumi that enables developers to write Infrastructure as Code programs using Scala 3. It provides a comprehensive language plugin and runtime that integrates with major build tools like sbt, Gradle, Maven, and Scala CLI, while offering native support for functional programming patterns via Cats Effect and ZIO. The system includes code generation capabilities for cloud providers and Kubernetes, along with utilities for JSON serialization and compile-time configuration validation.

39 changes.

This period marked the initial public beta release of the Besom Scala SDK for Pulumi, establishing the core infrastructure including the language plugin, code generation, and build tool support. It focused on expanding the SDK's capabilities by introducing runtime integrations for Cats Effect and ZIO, alongside comprehensive testing and example projects to validate the new functionality.

26 changes.

The project migrated its core modules to Scala 3 and updated Besom dependencies, while introducing new tools like crd2besom and enhanced error handling in the auto module. This period also saw a significant expansion of the examples library, covering diverse cloud providers and Kubernetes configurations to demonstrate the updated Scala-based infrastructure capabilities.

Added a new Scala-based Pulumi example that demonstrates integrating AWS API Gateway V2 with EventBridge and Lambda. The example provisions an HTTP API that forwards requests to an EventBridge event bus via a proxy integration, with an event rule triggering a Lambda function to process the events. It includes the necessary IAM roles, API Gateway stage, integration, route, and Lambda permission resources, along with a README explaining deployment and verification steps.

examples/aws-apigatewayv2-eventbridge · high confidence

The examples/aws-s3-folder directory now includes a complete Scala-based Pulumi program that provisions an Amazon S3 bucket configured for static website hosting. The example sets up public read access via a bucket policy and public access block, then uploads all files from a local 'www' directory as S3 objects, exporting the resulting bucket name and website URL for user access.

examples/aws-s3-folder · high confidence

Added a new Scala-based Pulumi example that provisions an Amazon EC2 instance running a simple Java web server. The example configures an Amazon Linux AMI, a security group allowing HTTP traffic on port 80 and SSH from the user's IP, and an SSH key pair. It also includes a startup script to install Amazon Corretto JDK 21 and serve a 'Hello, World!' page, with stack outputs for the public IP, hostname, and keys.

examples/aws-webserver, examples/azure-webserver · high confidence

Added a new Scala-based Pulumi example in the \examples/azure-static-website\ directory that provisions an Azure Blob Storage account with static website hosting enabled, along with an Azure Front Door (CDN) profile, endpoint, origin group, and route to serve the content. The example includes sample \index.html\ and \404.html\ files, a \.gitignore\ for build artifacts, and configuration files (\Pulumi.yaml\, \project.scala\) using Besom libraries to define the infrastructure.

examples/azure-static-website · high confidence

Added a new Scala-based Pulumi example in the \examples/azure-synapse\ directory that provisions an Azure Synapse Analytics environment. This example demonstrates creating a Synapse Workspace with a system-assigned managed identity, a SQL Pool, and a Spark Pool (Big Data Pool) with auto-pause and auto-scale settings. It also configures the necessary Azure storage account, blob containers, IP firewall rules, and role assignments to grant the workspace and user access to the storage resources.

examples/azure-synapse · high confidence

New Pulumi project templates are now available for the Besom Scala library, allowing users to quickly scaffold new infrastructure-as-code projects using \pulumi new\. The package includes a default template for generating random resources, and provider-specific templates for AWS (S3 buckets), Google Cloud Platform (GCS buckets), and Kubernetes (Nginx deployments). All templates are configured to use Scala 3.3.7 and Besom core version 0.5.2, with specific provider dependencies for AWS, GCP, and Kubernetes included in the project configuration.

templates · high confidence

Introduces a new \besom-cats\ module that enables Pulumi components to run within the Cats Effect \IO\ monad. This change adds a \CatsRuntime\ implementation and a \CatsEffectModule\ trait, allowing users to leverage Cats Effect features like uncancelable execution and global IORuntime integration. The module exposes a \component\ helper function that bridges Besom's component model with Cats Effect, facilitating asynchronous resource creation in a functional programming style.

besom-cats/src/main · high confidence

Introduces a new example application that demonstrates running a multi-container setup using Docker. The example includes a Scala-based web application that tracks page views using a Redis database, orchestrated via Pulumi infrastructure code. Users can build the app image, deploy the containers (Redis and the app) on a shared network, and access the application via a local URL.

examples/docker-multi-container-app · high confidence

Introduces a new example demonstrating how to deploy a Scala application to Google Cloud Run. The example includes a Dockerfile that builds a GraalVM native image using Scala CLI and a Pulumi infrastructure-as-code program (using Besom) to provision the Cloud Run service, Docker image, and public IAM access.

examples/gcp-cloudrun · high confidence

Added a new Scala-based Pulumi example in the examples/gcp-instance-nginx directory that deploys two Google Cloud Platform virtual machines running Nginx: one using a standard Ubuntu image with a startup script, and another using Google's Container-Optimized OS with a Docker container. The example includes the necessary project configuration (project.scala), Pulumi stack definition (Pulumi.yaml), and documentation (README.md) to guide users through initialization, deployment, and cleanup.

(repo-wide) · high confidence

A new Scala-based example has been added to demonstrate creating and managing tables in Google Cloud BigQuery. The example provisions a BigQuery dataset, a source table, and a GCS bucket, then uses a BigQuery job to load newline-delimited JSON data from GCS into the source table. It subsequently runs a SQL query to filter data (age \> 30) and writes the results to a destination table, exporting the IDs of the jobs and tables for verification.

examples/gcp-big-query · high confidence

Added a new Scala-based Pulumi example in the examples/gcp-firebase directory that provisions a Google Cloud Firestore database in Native mode with Optimistic concurrency, along with two sample documents. The example includes the necessary project configuration (using Besom GCP provider) and documentation to guide users through deployment.

examples/gcp-firebase · high confidence

Added a new Scala-based Pulumi example in the \examples/gcp-gke\ directory that provisions a GKE cluster. The example enables the Kubernetes Engine API, creates a cluster with a single \n1-standard-1\ node, and exports the cluster name and a \kubeconfig\ file for cluster access.

examples/gcp-gke · high confidence

A new Scala-based example has been added that deploys a replicated Nginx server to a Kubernetes cluster using Pulumi and the Besom library. The example defines a Kubernetes Deployment with configurable replica counts and exports the deployment name, providing a reference implementation for stateless applications without requiring YAML.

examples/kubernetes-nginx · high confidence

A new example project has been added to demonstrate deploying a Kubernetes application using plain YAML files. The example provisions a namespace, an Nginx deployment, and a ClusterIP service, allowing users to preview and apply the infrastructure via Pulumi and access the application through port-forwarding.

examples/kubernetes-yaml · high confidence

Introduces a new example demonstrating how to deploy the standard Kubernetes Guestbook application using Pulumi with Scala. The example provides two variants: a 'simple' version that directly maps the original Kubernetes YAML resources, and a 'components' version that uses Scala abstractions to reduce boilerplate. Both variants provision a multi-tier web application consisting of a Redis master, Redis replicas, and web frontend instances, and include configuration options to handle differences between standard Kubernetes clusters and minikube.

examples/kubernetes-guestbook · high confidence

The \besom-json\ module now includes a complete JSON serialization and parsing implementation. This adds support for parsing JSON into an AST (\JsValue\), serializing Scala types (primitives, collections, case classes, options, and either types) to and from JSON, and printing the output in compact, pretty, or sorted formats. The library includes a fast, no-dependency parser with configurable nesting and number-length limits, and provides type classes (\JsonReader\, \JsonWriter\, \JsonFormat\) for custom serialization logic.

besom-json/src/main · high confidence

This location introduces a new Pulumi example that demonstrates how to define and deploy a Kubernetes Custom Resource Definition (CRD) and its associated resources using plain YAML within a Scala program. The example uses the Besom library (specifically besom-core 0.5.2 and besom-kubernetes 4.22.1) to create a CronTab CRD and a sample CronTab instance, providing users with a reference implementation for managing custom Kubernetes resources programmatically.

examples/kubernetes-yaml-crd · high confidence

The model module now includes a \NameMangler\ utility to handle reserved keywords (such as Java/Scala standard methods and packages) by appending an underscore to prevent naming conflicts, and a \SemanticVersion\ class that implements full SemVer 2.0.0 parsing, comparison, and formatting logic with support for pre-release and build metadata. These additions provide foundational support for code generation and dependency management within the besom framework.

model · high confidence

The Besom sbt plugin now supports sbt 2.x alongside the existing sbt 1.x. This is implemented by introducing version-specific plugin implementations (BesomPlugin.scala) in the language-plugin/resources directory, which handle the API differences between sbt versions (such as using java.nio.file.Path in sbt 2.x versus java.io.File in sbt 1.x), while sharing common logic through a base trait (BesomPluginBase.scala). Users can now use the plugin with sbt 2.x projects.

language-plugin/resources · high confidence

The Besom compiler plugin now includes a linting phase that flags when an expression of the 'Output' type is used inside default Scala string interpolators (such as s, f, or raw). This check prevents unintended behavior by requiring developers to use the Pulumi interpolator instead, ensuring that dynamic values are handled correctly during compilation.

compiler-plugin · high confidence

This release introduces Besom, a Scala SDK for Pulumi, now available in public beta (version 0.5.2). The package allows developers to write Infrastructure as Code programs in Scala, leveraging the full power of the Pulumi platform. The release includes the core SDK, extensions for Cats Effect and ZIO, a compiler plugin, and a language host provider plugin. It supports multiple build tools including Scala CLI, sbt, Gradle, and Maven, and provides starter templates and examples for AWS, Azure, GCP, and Kubernetes.

(repo-wide) · high confidence

The besom-json module has been added to the project, providing JSON serialization capabilities. The module is configured to use Scala 3.3.7 and Java 11, with strict compiler warnings enabled. It includes a scalafmt configuration for code formatting and sets up publishing metadata for the org.virtuslab organization.

besom-json · high confidence

This change introduces the \pulumi-language-scala\ plugin, enabling Pulumi to manage infrastructure using Scala projects. The plugin implements the \LanguageRuntimeServer\ interface to communicate with the Pulumi engine via gRPC, leveraging the \besom\ language host to execute Scala build tools (such as sbt). It supports configuration via \ProgramInfo.Options\ (specifically \binary\ and \use-executor\) while maintaining backward compatibility with deprecated CLI flags, and includes improved error handling for external command execution to provide clearer feedback when build processes fail.

language-plugin/pulumi-language-scala · high confidence

The \besom\ package now exposes a unified public API through new \aliases.scala\, \future.scala\, and \types.scala\ files. Users can access core types (such as \Output\, \Input\, \Config\, \Stack\, and resource options) via \import besom.\*\, and the \Pulumi\ object serves as the main entry point for running programs using the \scala.concurrent.Future\ monad, including fatal error handling that terminates the application on uncaught exceptions.

core/src/main/scala/besom · high confidence

Added a new bootstrap module that includes a Scala-based plugin discoverer (PulumiPluginsDiscoverer) to scan the classpath for Besom language plugins and output their metadata as JSON, supporting both stdout and file output modes. The module also defines the build configuration using Scala 3.3.7, Java 11 output, and dependencies on besom-json 0.5.2 and classgraph 4.8.180.

language-plugin/bootstrap · high confidence

Added a new \runtime.scala\ file in the \besom-zio\ module that provides a ZIO-based runtime implementation (\ZIORuntime\) and a \ZIOModule\ trait. This allows users to execute Besom component resources using ZIO effects (\zio.Task\) instead of standard Scala futures. The module exposes a \Pulumi\ object that aggregates the necessary types and given instances, enabling seamless creation of component resources within a ZIO context.

besom-zio/src/main · high confidence

The besom-cfg module adds a new capability to validate application configuration against Docker image schemas at compile time. It introduces a \ConfiguredContainerArgs\ API for Kubernetes that fetches metadata from a Docker image, caches it locally, and uses a macro to diff the provided configuration against the image's expected schema, reporting detailed, color-coded errors for type mismatches or missing fields. The library also includes a type parser and serialization helpers to convert structured configuration into environment variables.

besom-cfg · high confidence

The codegen now supports applying version-specific hotfixes to Pulumi provider schemas before generating Scala code. This allows the tool to automatically remove fields, rename types, or strip methods from resources and providers when upstream schemas change in incompatible ways. Hotfixes are defined as JSON files in the overlays directory, organized by package name and semantic version ranges, and are applied during the package generation process to ensure generated code remains valid across different provider versions.

codegen/src · high confidence

The Pulumi Scala language plugin now includes a new executor system that automatically detects and configures the build tool used by your project. It supports Gradle, Maven, SBT (including both 1.x and 2.x lines), and Scala CLI, allowing Pulumi to correctly build, run, and discover dependencies for your Scala code. The plugin also handles project setup for SBT by installing necessary plugins and ensures compatibility with different Scala versions.

language-plugin/pulumi-language-scala/executors · high confidence

Added a new Scala-based Pulumi example that provisions an Azure Resource Group, Storage Account, and Cosmos DB account (including a SQL database and container), along with an API Connection and a Logic App. The Logic App is configured with an HTTP trigger that writes incoming request bodies as new documents into the Cosmos DB container, demonstrating how to link Azure services using the native Azure provider.

examples/azure-cosmosdb-logicapp · high confidence

A new unified CLI entry point (cli.scala) has been added to the scripts directory, allowing users to manage Besom development tasks via subcommands. This includes fetching and compiling Pulumi gRPC proto files (proto), generating and publishing provider packages (packages), downloading upstream test schemas (schemas), managing version bumps and dependency updates (version), generating test coverage reports (coverage), and validating JAR binary versions (jars). The implementation introduces several new Scala scripts (Coverage, JarVersions, Packages, Proto, Schemas, Version) and a shared common library (common.scala) to support these operations, along with a dedicated project manifest (project.scala) defining the necessary dependencies like os-lib, requests, and scoverage.

scripts · high confidence

Added two new Pulumi infrastructure examples: a Kubernetes-based Keycloak deployment (examples/kubernetes-keycloak) and an Azure Web App setup with VNet injection and Private Endpoints (examples/azure-webapp-privateendpoint-vnet-injection). The Kubernetes example provisions a self-contained environment including a Postgres database, Keycloak identity provider, Nginx ingress controller, and self-signed TLS certificates, allowing users to deploy and test an authenticated web application locally. The Azure example demonstrates a secure front-end/back-end architecture where the front-end app is injected into a VNet and the back-end app is exposed only via a Private Endpoint with private DNS resolution.

examples/kubernetes-keycloak · high confidence

The \besom.util\ package now includes several new utilities: \NonEmptyString\ and \NonEmptySet\ opaque types that enforce non-empty constraints at compile time for string literals and interpolations; \JsonInterpolator\ for constructing JSON structures via string interpolation; \JsonReaderInstances\ to handle deserialization of \Output\-wrapped values; \Validated\ for accumulating validation errors; and \NotProvidedOr\ to represent optional configuration values. These additions provide stricter type safety and new ways to construct and validate data within the core library.

core/src/main/scala/besom/util · high confidence

The auto module now provides detailed, structured error reporting for failed Pulumi operations (up, preview, refresh, destroy) by parsing the engine event log even on failure paths, exposing resource failures, diagnostics, and parse errors via the new OperationFailedError type. It also introduces live event streaming, allowing callers to receive engine events in real-time via the onEvent option, and adds process control capabilities through the ChildProcess handle for graceful cancellation (SIGINT) or termination of the underlying pulumi process.

auto/src · high confidence

The crd2besom module is introduced as a new tool that generates Scala case classes and companion objects from Kubernetes Custom Resource Definition (CRD) YAML files. It parses the openAPIV3Schema to produce typed Scala code (using Scala 3.3.7) with built-in Besom Encoder/Decoder support, handling data types such as strings, integers, numbers, booleans, arrays, objects, and enums. The generated code includes extension methods for accessing fields from Output types and supports optional fields, secret detection, and date/time formats (LocalDate, LocalDateTime).

crd2besom · high confidence

This update introduces new Scala types for Kubernetes Custom Resources and Custom Resource Patches, including \CustomResource\, \CustomResourceArgs\, \CustomResourcePatch\, and \CustomResourcePatchArgs\ in the \kubernetes/apiextensions\ package, enabling users to define and manage custom resource definitions. Additionally, it applies hotfix overlays to several provider packages: it removes the \urn\ field from Azure Native Chaos resources (versions 20240101, 20241101preview, 20250101), DigitalOcean Reserved IPv6 (4.40.1:4.40.2), and OVH Permissions Group (versions 1.6.0:2.0.7 and ^2.7.3); it renames the Azure Native PostgreSQL \StorageAutogrow\ type to \StorageAutoGrowOld\ for version ^2.89.0; and it removes the \urn\ field from Vultr Container Registry (2.23.1).

codegen/resources · high confidence

The internal runtime has been reorganized to introduce \BesomModule\ and \BesomSyntax\ traits, which centralize the \Pulumi.run\ execution flow, provide user-facing syntax helpers (such as \isDryRun\, \config\, \log\, and \component\), and expose extension methods for resource provider access. This change also adds \CodecMacros\ for compile-time derivation of encoders and decoders, a new \Config\ implementation that strictly handles secret redaction, and a \CustomTimeouts\ API for specifying create, update, and delete durations on resources.

core/src/main/scala/besom/internal · high confidence

The besom-cats module has been migrated from the traditional sbt build system to Scala CLI, utilizing a single project.scala file to define dependencies (including besom-core 0.5.2 and cats-effect 3.7.0) and publishing metadata. Additionally, a .scalafmt.conf file has been added to enforce code formatting rules, specifically targeting Scala 3 and excluding RPC source files from formatting.

besom-cats · high confidence

The \besom-rpc\ module has regenerated its Scala protocol buffer bindings using the latest ScalaPB compiler. This update refreshes the generated code for core Google RPC types (such as \Status\) and introduces new bindings for Pulumi-specific RPC services, including \Alias\, \Callback\, and \Diagnostic\ messages. For users, this ensures compatibility with the latest protobuf definitions and provides updated, type-safe Scala interfaces for interacting with Pulumi's callback and resource aliasing mechanisms.

besom-rpc · high confidence

The \proto\ directory has been updated with regenerated \.proto\ files for the Pulumi gRPC layer. This change introduces the standard \google.rpc.Status\ error model and refreshes core service definitions including \ResourceProvider\, \ResourceMonitor\, \LanguageRuntime\, \Engine\, and \Callbacks\, along with supporting messages for aliases, plugins, and source positions. These updates ensure the protocol definitions are synchronized with the current Pulumi SDK version (v3), affecting how language hosts, resource providers, and the engine communicate.

proto · high confidence

The fake standard and external resource plugins used in integration tests have been updated to use Scala 3.3.7. These test fixtures, which define mock language plugin configurations (including \plugin.json\ files for \aci\ and \random\ resources), now target the newer Scala version to ensure compatibility with the updated test environment.

integration-tests/resources/fake-external-resource-plugin, integration-tests/resources/fake-standard-resource-plugin · high confidence

The documentation website has been rebuilt using Docusaurus 3, replacing the previous version. This migration introduces a modern static site generator setup with updated build and deployment workflows, including a new .gitignore for generated files and a README with installation and local development instructions. The site now includes a blog section with initial release announcements and comprehensive documentation covering Besom's architecture, resource constructors, and component definitions.

website · high confidence

Add Cats/Purrl integration test example; Add TLS integration test demonstrating Stack exports; Add integration test for Kubernetes Secrets serialization; Add integration tests for cross-stack references with structured outputs; Add integration tests for typed StackReference exports and per-field secret handling; Added Scala executor integration test for Gradle; Added Scala executor test resources for SBT 1 and SBT 2; Added Scala integration test for Random resource aliases and Get functions; Added Scala logger integration test example; Added ZIO-based integration tests for TLS and compiler plugin resources; Added compile-time and runtime tests for core utility types; Added comprehensive test suite for core internal components; Added config-example integration test for Besom JSON and Stack exports; Added conformance tests for Result execution in Cats Effect and ZIO; Added integration test resources for Gradle, Maven, SBT, and Scala CLI executors; Added integration tests for Pulumi resource memoization and idempotence; Added test scaffolding for generic encoder; Initial test suite for besom-json library; New Scala 3 integration test suite for SDK core, codegen, and language plugins.

This change introduces the Pulumi language plugin for Scala, adding the Go module definition and dependencies for the \language-plugin/pulumi-language-scala\ component. It also sets up the documentation website using Docusaurus 3.9.1, updating the Node.js engine requirement to version 22 or higher and initializing the Gradle version catalog for integration tests.

(dependencies) · high confidence

The core module now targets Scala 3.3.7 and aligns its dependencies with version 0.5.2 of the besom libraries (besom-json, besom-rpc, besom-model). This update also refreshes underlying libraries including gRPC 1.64.0, Netty 4.1.100, ScalaPB 0.11.20, Guava 32.1.2, and Scribe 3.16.0, while configuring the project to enforce stricter compiler warnings and exclude generated RPC code from formatting.

core · high confidence

The auto module has been migrated to Scala 3 (dialect scala3) and updated to use Besom libraries version 0.5.2. This change includes configuration updates in .scalafmt.conf to support Scala 3 formatting and updates to project.scala to reflect the new Scala version, Java output version 11, and updated dependency versions for Besom, scala-yaml, geny, os-lib, JGit, and tailf.

auto · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• First survey — no prior run to compare against. CAI 60.

• Code Health 83
• Architecture 98
• Maturity 69
• Readiness 53
• Security 56

• 300 commits — 221 feature/other, 79 fixes

• core/src — 52 commits
• (repo) — 37 commits
• integration-tests/resources — 23 commits
• (root) — 21 commits
• .github/workflows — 19 commits
• codegen/src — 19 commits
• auto/src — 17 commits
• website/docs — 16 commits
• examples/kubernetes-guestbook — 11 commits
• scripts/Packages.scala — 9 commits
• language-plugin/pulumi-language-scala — 5 commits
• integration-tests/CoreTests.test.scala — 4 commits
• besom-json/src — 3 commits
• examples/aws-eks — 3 commits
• examples/gcp-cloudrun — 3 commits
• examples/kubernetes-helm-release-wordpress — 3 commits
• scripts/Version.scala — 3 commits
• besom-cfg/k8s — 2 commits
• besom-rpc/src — 2 commits
• codegen/resources — 2 commits

• fix: Fix #383 - serializer now skips fields with null value secrets (#386)
• fix: Fix #407 - recurrent type encoder
• fix: Fix AggregateException (#426)
• fix: Fix Output lifts
• fix: Fix URL validation to allow for kubernetes types (#385)
• fix: Fix Version.scala to ignore fake dependencies
• fix: Fix basics.md (#374)
• fix: Fix broken parent context prop, rework packages, turn examples into IT (#570)
• fix: Fix codegen (#373)
• fix: Fix infinite loop in core Resources.add (#363)
• fix: Fix inverted is-snapshot guard in upsert-gh-release (#593)
• fix: Fix issue 397 (#400)
• fix: Fix issue 432 - Add Output type to fields in generated output case classes (#524)
• fix: Fix issue 489 - trace level messages get evaluated to send to Pulumi engine (#492)
• fix: Fix issue 527 - Add to StackReference, methods converting to typed Outputs (#528)
• fix: Fix liftoff example (#442)
• fix: Fix project.scala files
• fix: Fix resource decoders (#364)
• fix: Fix traverse on Output (#360)
• fix: Fix traverse problem from #430, fix component API function too (#441)
• …and 280 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

VirtusLab/besom was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.