pulumi changelogs since pulumi | diffwithgpt
AI Summary
The commit updates the h11 package version from 0.14.0 to 0.16.0 in the documentation requirements. This change ensures compatibility with newer features or security fixes in h11, but may introduce breaking changes if the new version has incompatible API changes.
Commit Log
Bump h11 from 0.14.0 to 0.16.0 in /docs in the pip group across 1 directory (#19403) Updates `h11` from 0.14.0 to 0.16.0 Closes #19316
AI Summary
The code diff updates the version number across multiple files to 3.168.0, indicating a new release. This change is likely part of a version bump to reflect the latest features and bug fixes in the Pulumi SDK.
Commit Log
Freeze 3.167.0 (#19390) ## (2025-05-01) ### Features - [pkg] Allow for hyphens in function names [#19352](https://github.com/pulumi/pulumi/pull/19352) - [auto/python] Add the ability to configure a remote executor image [#19304](https://github.com/pulumi/pulumi/pull/19304) - [sdk/yaml] Update pulumi-yaml to v1.18.0 [#19381](https://github.com/pulumi/pulumi/pull/19381) ### Bug Fixes - [auto/nodejs] Fix flag mismatch with preview-only refresh operations
AI Summary
The code allows creating analyzer plugins without requiring configuration, addressing an issue where `pulumi policy publish` couldn't spawn analyzers without project/stack context. The change modifies `NewPolicyAnalyzer` to conditionally include config and metadata only when options are provided, ensuring compatibility with scenarios like `pulumi policy publish`.
Commit Log
Allow creating analyzer plugins without config (#19392) When running `pulumi policy publish` we are not running in the context of a project stack, but we have to be able to spawn an Analyzer to call `GetAnalyzerInfo`. Fixes https://github.com/pulumi/pulumi/issues/19383
AI Summary
The code allows hyphens in function names, particularly for provider methods, by updating the schema to include a new functionToken with a regex that permits hyphens. This change introduces a new test suite to validate the new functionToken pattern, ensuring compatibility with both existing and new function naming conventions.
Commit Log
Allow for hyphens in function names (#19352) This pull request introduces a new schema definition for function types. Currently, function tokens may not have any hyphens in their final part. For most existing functions, this is fine, since we habitually do not create functions that have hyphens in them. However, for provider-level Methods, which are of the token format `pulumi:providers/packageName/functionName`, sometimes the provider has a hyphen. Famous example: `terraform-provider` - the base name for our provider parameterization. Rather than widening the regex scope for all tokens, this pull request adds a new `functionToken` to the metaschema with an additional allowed `-` in the regex pattern. Adds tests to confirm this is permissible for all function tokens, as well as the special provider methods.
AI Summary
The code introduces a new function `GetDefaultOrg` that retrieves a user's default organization, preferring local configuration and falling back to backend lookup if needed. This change aims to improve consistency and performance by reducing API calls during stack operations. The implementation includes a fallback mechanism to ensure compatibility with backends that do not support the `GetDefaultOrg` API, preserving existing behavior by returning an empty string when no default org is configured. Potential risks include unexpected behavior if the backend API changes or if the fallback logic does not handle all edge cases, such as incorrect default org determination or performance issues in large-scale organizations.
Commit Log
Add default org lookup against the backend if not locally configured by user (#19324) Essentially a copy of https://github.com/pulumi/pulumi/pull/19249 but with commits re-organized for readability. This work is part of Project Hockeystick (https://github.com/orgs/pulumi/projects/274) This PR updates the call sites for workspace.GetBackendConfigDefaultOrg to a wrapper `backend.GetDefaultOrg` that includes a fallback lookup to the backend for default org. If the backend does not support the GetDefaultOrg API, or if it has no opinion, `backend.GetDefaultOrg` will preserve existing behavior by returning an empty string for call sites to evaluate appropriately. It additionally introduces a new call site: cloudBackend.ListStacks` -- This upfront call will reduce the number of API calls made in `cloudBackendReference.String()` to check the workspace against the default organization when eliding stack route, reducing performance impact for large scale organizations.
AI Summary
The code fixes an issue where the `--yes` flag was not removed when using `previewOnly: true` in the NodeJS Automation API's refresh command. It ensures the correct flags are passed based on whether the refresh is preview-only or not, and adds a test to verify the fix.
Commit Log
Fix `refresh --preview-only` in the Automation API (#19370) In #19354, it was reported that doing a `previewOnly: true` `refresh` in the NodeJS Automation API failed because the `--yes` flag wasn't removed under these circumstances. This PR fixes this, and adds a little test to be sure. Fixes #19354.
AI Summary
The code adds the `type_token` decorator to resources and enums to improve type handling and enable future features like schema generation. This change replaces manual annotations and ensures compatibility with the latest Pulumi version (v3.165.0) and related issues.
Commit Log
Decorate resources and enums with their type token (#19357) Use the `type_token` decorator added in https://github.com/pulumi/pulumi/pull/19309 and released with [v3.165.0](https://github.com/pulumi/pulumi/releases/tag/v3.165.0). This replaces the manual annotation for classes and also adds it to enums, which will help us implement https://github.com/pulumi/pulumi/issues/19297. Code changes are in https://github.com/pulumi/pulumi/pull/19357/commits/4e433035f7a57ff69c138c5beabe7abb75e65afb `_enums.py` had a double `import builtins` (since https://github.com/pulumi/pulumi/pull/19035), I fixed that while I was already updating all the test snapshots. `tests/testdata/codegen/dashed-import-schema/python/pulumi_plant/_enums.py` shows an example of the decorator on enums.
AI Summary
The code change ensures that fully qualified stack names are saved to settings, preventing incorrect stack selection when the default organization changes. This fix addresses a bug where abbreviated stack names were stored, leading to potential mismatches when the default org is updated.
Commit Log
Always save fully qualified stack names to settings (#19336) Noticed in https://github.com/pulumi/pulumi/pull/19324/files/aa1c465e08639c1578cc43e62fa7ea86879a8634#r2059990017 We need to save fully qualified stack names to the settings to prevent the following issue. Imagine the default org is currently "foo" and we create and save a stack "bar". Historically this would save the abbreviated name to the settings so just "bar". If we then change the default org to "qux" and run `up` it will load the name from settings and reconstruct "bar" into "qux/bar" instead of "foo/bar" which is the stack that had actually been selected! This fixes that to just always save the fully qualified name to stack settings.
AI Summary
The code adds tests for the `GetLanguageTypeString` method in the `DocLanguageHelper` to ensure it produces correct type strings across different languages. The tests cover various type scenarios including primitives, objects, enums, and arrays, with expected outputs for each language.
Commit Log
Add tests for `(DocLanguageHelper).GetLanguageTypeString` (#19332) This is in preparation for https://github.com/pulumi/pulumi/pull/19306, which changes the signature and implementation of `GetLanguageTypeString`, but should generally preserve the result.
AI Summary
The code updates import-related tests to align with a new import system, adding explicit failure checks and output validation. The changes ensure tests are compatible with the new system by modifying how errors are handled and verifying expected outputs.
Commit Log
Update some import tests (#19340) In preparation for the new import system this changes a few tests such that they are still valid today, but have extra checks that we want to assert on for the new system as well. `TestContinueOnErrorImport` is changed to explicitly fail the read, rather than relying on the diff failure that is being removed in the new system. `TestImportOption` adds some checks that the outputs we see in the program are what we expect to see.
AI Summary
The code change modifies the error handling in the plugin loading logic to correctly identify private Git plugins and provide a more informative error message. It introduces a custom error type to distinguish between plugin version not found errors and other errors, improving error handling for private repositories.
Commit Log
treat private plugins as Git Plugins still (#19331) In IsLocalPluginPath, we check if a plugin is a remote plugin. To do that, we parse the PluginSpec first, and then check based on that. However, when the plugin is in a private Git repo, we get an error here, because we fail to fetch the latest tag of the Git repo. Instead, return a special error for that, and look for it specifically here, so we can correctly determine that it's a local plugin, or remote, and thus give a good error message to the user down the line. Fixes https://github.com/pulumi/pulumi/issues/19325
AI Summary
The code change removes the 'deletes' field from the SnapshotManager and replaces it with 'dones', treating deletions as a subset of 'done' operations. This simplifies the logic for tracking resource states and aligns with future support for multiple operations per resource, such as import followed by update. The change includes a copy of the resource state in some test cases and ensures that 'SameStep' objects are distinct to avoid unintended behavior.
Commit Log
Remove the 'deletes' field, just use 'dones' (#19284) Rather than tracking deletes as a special case we can just treat them the same as things being "done" generally. This is really useful when we start allowing multiple operations per-resource (e.g. import then update) as the done semantics just work. There were comments about "If this is a delete-replace operation, we don't want to mark the resource as deleted because we want to keep the new resource." but I can't recall the reasoning for those comments and removing them hasn't broken any tests. If anyone can come up with a test case that depended on these things share, but otherwise I think this is safe. The only other change needed was when we make `SameSteps` the two state pointers have to be different objects. This requires a copy in `getDependencySteps`. I've also added an assert to the same step constructor to ensure we don't break that.
AI Summary
The `GetFunctionName` method in `DocLanguageHelper` has been simplified by removing the `modName` parameter, as the necessary bookkeeping is now managed internally by `go_gen.DocLanguageHelper`. This change reduces complexity for callers and ensures that the logic for determining the module name is encapsulated within the `DocLanguageHelper` itself.
Commit Log
Simplify `DocLanguageHelper.GetFunctionName` (#19268) ```patch - GetFunctionName(modName string, f *schema.Function) string + GetFunctionName(f *schema.Function) string ``` The special bookkeeping that `modName` requires is used only within Go's `DocLanguageHelper`, and `go_gen.DocLanguageHelper` should manage the bookkeeping as necessary here. This complexity does not need to be exposed to callers of the function. If this change is approved, I'll update the `GetFunctionName` method in pulumi-dotnet and pulumi-yaml.
AI Summary
The code change fixes a test that was failing due to a missing error assertion when importing an existing resource with a matching ID. The fix involves modifying the import logic to handle existing resources correctly and ensuring the test passes by returning the error properly.
Commit Log
Test and fix running the import command for existing resources (#19290) While looking into other import changes noticed that this test was missing an error assertion, and so what was expected to work actually failed. This fixes the test and the code to pass it.
AI Summary
The code sets the `GOBIN` environment variable for the `dist` target in the Node.js and Python SDK Makefiles to ensure scripts are installed correctly. This change was made to fix a regression where the `GOBIN` variable was no longer set, breaking the script installation process.
Commit Log
sdk/{nodejs,python}/Makefile: export GOBIN before using it (#19278) In https://github.com/pulumi/pulumi/pull/19250 we stopped setting `GOBIN` for the `dist` target in the makefiles for `sdk/{nodejs,python}`. This is fine for the `go install` part, but are also using the same env variable to drop more scripts into this directory. Having it not set breaks this target. Fix that by re-adding setting the `GOBIN` variable for the target.
AI Summary
The code change updates Node.js component provider tests to use the `packages` section in `Pulumi.yaml` instead of the deprecated `plugins` section to hook up the local component provider. This change improves test setup by aligning with the current Pulumi provider configuration mechanism, making the tests more maintainable and future-proof.
Commit Log
Tidy up Node.js component provider tests (#19251) Similar to https://github.com/pulumi/pulumi/pull/19210, use the `packages` section in `Pulumi.yaml` to hook up the local component provider.
AI Summary
The code change replaces the use of ID with ImportID in import-related logic to better align with the actual import process and avoid confusion with resource IDs. This change ensures that import operations use the ImportID field instead of the ID field, which is more semantically accurate for import strings.
Commit Log
Use ImportID not ID for import strings (#19244) Just trying to be a bit more consistent that import strings aren't IDs really. This uses the actual ImportID field for them instead, and sets ID once the import step has run.
AI Summary
The code adds an ID field to both Stack and StackSummary structs to expose the ProgramID as the logical ID of the stack. This change aligns with Pulumi Cloud's requirement to use ProgramID as the stack ID in its APIs.
Commit Log
Update type to start exposing the program id (#19260) Re: https://github.com/pulumi/pulumi-service/issues/27563 We are starting to expose the ProgramID as the stack's ID on the cloud's APIs, as Pulumi Cloud relies on these types we need to update them in order to expose the new ID field.
AI Summary
The code fixes the component construct in Pulumi's Node.js provider to handle namespaces in the `name` field of `package.json` correctly. The change updates the validation logic to use the `name` property instead of the `packageJSON.name` field, ensuring compatibility with namespaced components.
Commit Log
fix component construct when package.json includes namespace (#19242) In https://github.com/pulumi/pulumi/pull/19066, we fixed component schema generation to work correctly when the `name` field in the `package.json` file includes the namespace. However we missed that we also need to fix up construct, so we can correctly construct a component. Fix that now. Fixes https://github.com/pulumi/pulumi/issues/19055
AI Summary
The commit removes two unused PulumiPlugin.yaml files from the test data directory. These files were likely left over from a previous rebase or code change and are no longer needed.
Commit Log
Remove unused testfiles (#19229) I think these were leftover from a rebase when the python analyzer was changed to take a list of components.
AI Summary
The PR adds a 'dependencies' field to the schema to allow specifying package dependencies once across languages, improving code generation and reducing redundancy. This change introduces new functions to check and manage dependencies, and updates codegen tools to handle the new field, ensuring compatibility with existing workflows.
Commit Log
add dependencies field to the schema (#19071) Add a dependencies field that can be used to set dependencies across languages. Currently we only support doing language specific dependencies, however at least for components and conformance tests it would be nicer to not have to specify the dependencies per language, but instead specify them once and let codegen do the rest. This PR implements that for `pulumi` dependencies only (though the schema would allow for namespaces to be added). This implements that in the schema and adds a conformance test using the option. Part of https://github.com/pulumi/pulumi/issues/19150
AI Summary
The code change allows retrieving organization-level templates without requiring the user to be logged in, addressing issues related to login requirements for template access. It modifies error handling and backend interactions to ensure that template retrieval is possible even when the user is not authenticated. Potential risks include compatibility issues with existing code that assumes login is required for template operations, and edge cases where the absence of login might lead to unexpected behavior in other parts of the system.
Commit Log
Don't require to be logged in to retrieve templates (#19196) Don't attempt to retrieve organization level templates when we are not logged in. Fixes https://github.com/pulumi/pulumi/issues/19073 Fixes https://github.com/pulumi/pulumi/issues/19180
AI Summary
The code change replaces output<T> with [unknown] in diffs to avoid misleading users about the type of computed or output properties. This change improves clarity by displaying [unknown] instead of output<T> for properties that are not known at the time of display, especially for computed or output values.
Commit Log
Display [unknown] rather than output<T> (#19204) This was commented on in https://github.com/pulumi/pulumi/issues/17418 and https://github.com/pulumi/pulumi/issues/17180. Rather then displaying output\<string\> (which often isn't even right because the property is a number of other type) we just display [unknown] to match secrets that display as [secret].
AI Summary
The code fixes issues with the DBR (Delete Before Replace) logic in Pulumi to ensure that ReplaceOnChanges and IgnoreChanges are properly respected during resource diffs. The changes involve updating multiple internal structures and tests to include ReplaceOnChanges alongside IgnoreChanges, ensuring correct behavior during resource replacement decisions. Potential risks include compatibility issues with older versions of Pulumi that may not handle the new ReplaceOnChanges field correctly, and edge cases where the logic might not behave as expected if not fully tested.
Commit Log
Fix ReplaceOnChanges and IgnoreChanges being respected during DBR diffs (#19188) Fixes #19056 This fixes two bugs with DBR logic. Firstly that ReplaceOnChanges would never trigger a replace as part of DBR even if the field was being changed, secondly that IgnoreChanges wouldn't prevent a replace if a field changed (but shouldn't have because of ignore changes). Doing this requires that ReplaceOnChanges is saved to state with IgnoreChanges so that we have access to it at the point DBR is checking dependencies from state to see if they need replacing.
AI Summary
The code change ensures each test copies the test project to its own temporary directory to prevent interference between tests. This addresses flaky tests caused by shared temporary config files and improves test isolation.
Commit Log
stack_test: make each test copy testproj to its own temp dir (#19195) Multiple tests are using this test project for their testing, and drop temporary config files there in some cases. This leads to flaky tests, such as in https://github.com/pulumi/pulumi/issues/19194. Fix that by copying the test project to a temporary directory for each of the tests, which makes sure they do not interfere with eachother. Fixes https://github.com/pulumi/pulumi/issues/19194
AI Summary
The PR adds functionality to the `pulumi package add` command to automatically update the `packages` section in Pulumi.yaml with the added package's source, version, and parameters. The update logic uses heuristics to decide between short and long format for package references based on parameters and existing package formats. This change introduces a side effect to the `package add` command, modifying the Pulumi.yaml file directly to reflect the added package.
Commit Log
Save package source to `packages` in Pulumi.yaml on `package add` (#19157) This PR adds a side effect to the `pulumi package add` command. It will now modify (or add) the `packages` section in Pulumi.yaml to point to the added package. It will fill the following properties: - `source` will be set to whatever the first parameter of `package add` command was, but without a version - `version` will be set to the schema version or parameterized provider's base provider version - `parameters` will be set to the parameter values passed to `package add` The command will use either the short or the long version of the reference with some heuristics to pick the right one: - Short by default - Long if parameters were set - Long if there was a reference to the same package already and it had long form
AI Summary
The code adds HCL2 support for the ImportID resource option and other related resource options during serialization and deserialization. This enables interactive import functionality by allowing the ImportID to be serialized and deserialized correctly in HCL2 format.
Commit Log
Add HCL2 support for importID resource option serialization (#19163) Needed for interactive import. Also adds support for a number of other values which are bound in `bindResourceOptions` when binding pcl. * retainOnDelete * IgnoreChanges * DeletedWith * ImportID (as well as adding this to `bindResourceOptions`) Related #19037 Related #19038
AI Summary
The `queryable` module is being restored to support `@pulumi/policy` which relies on `ResolvedResource`. This change was reverted in a previous commit but is now re-added to maintain compatibility and functionality.
Commit Log
[sdk/nodejs] Add back the queryable module (#19172) Add back the `queryable` module. `@pulumi/policy` depends on `ResolvedResource`. This was removed in #19130 as part of cleaning up StreamInvoke code, but this part should have been kept. Fixes #19171
AI Summary
The commit updates the Pulumi version to v3.161.0, including SDK upgrades and bug fixes across multiple languages and components. It introduces new features like `property.Path` and immutability for `property.Value` in Go, and adds enum support in Python. Several bug fixes address performance, schema inference, and compatibility issues across different Pulumi components.
Commit Log
Changelog and go.mod updates for v3.161.0 (#19168)
AI Summary
The change removes code that incorrectly overrides the schema version when retrieving package schemas, ensuring the correct version is used. This fix addresses an issue where the schema version was being set to the plugin version instead of the package version, leading to inconsistencies.
Commit Log
don't override schema version in `package *` (#19159) Since https://github.com/pulumi/pulumi/pull/19043 we're overriding this when getting the schema when necessary, so we don't need to override it here. In fact overriding it here causes issues e.g. for terraform providers, which use the version in the schema differently. ``` $ pulumi package get-schema terraform-provider hashicorp/random 3.6.0 | jq -r '.version' 3.6.0 $ pulumi package get-schema [email protected] hashicorp/random 3.6.0 | jq -r '.version' 0.10.0 ``` The second call here should also 3.6.0, not 0.10.0. This PR makes it so.
AI Summary
The code adds support for handling TypeScript's optional boolean types (true | false | undefined) in schema inference. It introduces a new helper function to detect such types and updates the analyzer to treat them as optional boolean properties.
Commit Log
[components/nodejs] Fix schema inference for optional boolean properties (#19133) TypeScript represents optional booleans as `true | false | undefined` and our current code isn't prepared to handle 3-case unions. This PR introduces a new check to handle this situation as it should. Fix https://github.com/pulumi/pulumi/issues/19064
AI Summary
The code makes `property.Value` immutable, which improves API clarity and reduces bugs by enforcing immutability across all operations. This change introduces new immutable structures like `Array` and `Map` with associated methods, and updates existing functions to work with these new types. Potential risks include breaking existing code that relies on mutability, and ensuring all related functions and tests are updated to handle the new immutable behavior.
Commit Log
Make `property.Value` immutable (#17500) tldr: making all `property.Value`s immutable will make the API less idiomatic, but it will make API design and usage of `property.Value` clearer and less bug prone. We can do it without sacrificing too much performance. This change is stacked on top of https://github.com/pulumi/pulumi/pull/17374. There are two major concerns to address with this PR: - The API is unidiomatic. ☝️ explains why I think the change is worth it from that perspective. - The change is not performant. ## API Usage Regardless of this PR, all APIs that manipulate `property.Value` *must* be of the shape:
AI Summary
The PR updates the Python conformance tests to use `uv` for dependency installation instead of `pip`, aiming to reduce CI job runtime. This change introduces a new `toolchain` parameter in several functions and test cases, which is used to specify the toolchain (e.g., `uv`) for dependency management. The addition of `toolchain` support in the codebase may require updates to documentation or tooling to ensure compatibility and correct usage.
Commit Log
install dependencies in python conformance tests using uv (#19109) In previous PRs we started using `uv` more in conformance tests, e.g. for building the Python wheel, which got us to run the conformance tests in 24 minutes in CI. That still seemed kinda slow, so I did some more digging, and found that we are still installing all our dependencies using `pip`. This PR changes the python conformance tests, so they install dependencies via `uv` instead. This assumes `uv` is available, but I expect that to be the case in developer environments. This brings the total time for the CI job running the conformance tests to ~16min, shaving off another 8 minutes.
AI Summary
The code diff removes StreamInvoke-related code and deprecated query mode functionality across multiple files, likely to clean up unused or obsolete features. This change may affect any existing code relying on StreamInvoke or query mode, potentially leading to breaking changes if not properly handled.
Commit Log
Remove some more StreamInvoke code (#19130) Missed a few bits in https://github.com/pulumi/pulumi/pull/19129.
AI Summary
The code introduces caching for SDK artifacts in conformance tests to avoid redundant generation and improve performance. It uses a sync.Map to cache artifacts and per-sdk locks to ensure thread safety, reducing flakes caused by non-deterministic packing.
Commit Log
cache SDK artifacts in conformance tests (#19112) In conformance tests we curently generate all the SDKs once, but we re-pack them for each test run. This seems unnecessary, as the packed artifacts shouldn't change. Only pack them once, to save time. Also `uv` seems to be non-deterministic when packing these artifacts, which seems to result in flakes in https://github.com/pulumi/pulumi/pull/19109. Cache the artifacts instead, and re-use them for various tests. Note that we currently simply overwrite artifacts in the same directory, so if the artifacts were any different, our tests would already be broken, since any test we're running would get a random artifact to use. I expect this brings some performance improvements in all languages. Let's see what CI says. Fixes #16079
AI Summary
The code diff removes the StreamInvoke method from the Provider and ResourceMonitor services across multiple language bindings and internal implementations, as part of a feature removal. This change removes all references to StreamInvoke, including method definitions, tests, and protocol buffer files, indicating that the feature is no longer supported or needed.
Commit Log
Remove StreamInvoke (#19129) We removed the query command in [v3.157](https://github.com/pulumi/pulumi/releases/tag/v3.157.0). This finishes that removal be cleaning up the remaining references to `StreamInvoke`.
AI Summary
The commit updates the version of the golang-jwt/jwt library from v5.2.1 to v5.2.2 across multiple Go modules to address a dependency security advisory. This change is likely to fix a vulnerability or bug in the JWT library, improving the security and stability of the project.
Commit Log
Update github.com/golang-jwt/jwt/ (#19117) Address https://github.com/pulumi/pulumi/security/dependabot/1791
AI Summary
The code change adds support for excluding the virtual environment path from mypy typechecking to avoid errors when using custom virtualenv locations. It introduces a new method `VirtualEnvPath` in the toolchain interfaces and implementations to retrieve the virtualenv path, which is then used to construct mypy exclusion flags.
Commit Log
exclude virtualenv from being checked by mypy (#19107) Mypy doesn't exclude the virtualenv by default when typechecking. It does exclude only hidden files, starting with a `.`. At the same time, `uv` installs a file into the virtualenv that doesn't typecheck correctly. By default that's fine, as `uv` uses `.venv` as its virtualenv location, but it breaks when someone uses a custom venv location, and uses mypy. For example in conformance tests, we use `venv` as the virtual env location, which in turn makes the tests fail because of `mypy`. This could also happen to someone using a custom venv location with `uv`.
AI Summary
The code optimizes the workspace.DetectProjectFromPath function by replacing a directory scan with a more direct search for Pulumi.yaml files, significantly reducing the time required in large directory structures. This change improves performance by avoiding unnecessary file system checks, especially in scenarios with many files, such as during pulumi convert operations.
Commit Log
Speed up workspace.DetectProjectFromPath (#19082) There is a utility function workspace.DetectProjectFromPath that attempts to scan the file system starting at a given path to find the deepest containing ancestor directory that appears to have a Pulumi.yaml or a similar project file present. Before this change it did not scale well for situations where ancestor folders have a lot of entries. It would scan each ancestor directory and examine every entry to test it for being the Pulumi project file. For example, in a `pulumi convert` scenario a Mac M3 Pro was taking 10-15 seconds to perform 300000 file system checks here in a situation where tempdirs had a lot of entries, dominating the cost of any other calls. With this change the function no longer scans directories but instead probes for possible Pulumi.yaml file locations more directly. ---------
AI Summary
The commit removes the 'six' library dependency and replaces its usage with Python 3-compatible equivalents. This change aligns with the project's decision to drop support for Python 2 and eliminate the need for 'six'.
Commit Log
We only support python3, there's no need to use six anymore (#19100) Replaces six with its PY3 equivalent values.
AI Summary
The code adds a test to verify that null values can be returned in PCL and handled correctly in the output structure. It also modifies an existing test to return an array of null to work around issues with handling null values in resource properties.
Commit Log
Add l1-output-null test (#19001) `null` is a valid value in the PCL model, and stacks should be able to return outputs of null directly, or with null nested inside other structures. Unfortunately that breaks a load of the rest of the model where we treat optional resource args which in the runtime language will just be null as not sent fields. So for now this test just checks that we can write null in PCL and return an array of null. This also changes the l1-builtin-try test to return an array of null, rather than null directly to work around the above issue. ---------
AI Summary
The code adds support for running a `pulumi refresh` operation by executing the user program, allowing the engine to refresh resources and update provider configurations. New features include running refreshes before other operations and skipping other custom resource operations to ensure only refreshes are performed. Potential risks include compatibility issues with existing workflows, as the behavior of refresh operations may change, and the introduction of new edge cases related to resource deletions and provider configurations.
Commit Log
Add Refresh program support to the engine (#18868) This adds two new features to the step generator, which together allow you to run a `pulumi refresh` operation (if it was actually plumbed into the CLI layer) by running the user program. The first feature is the ability to run refreshes on resources before processing the rest of their step generation logic. This could be a replacement for `preview/up --refresh` but currently is only used for the full program refresh mode. This works similarly to the parallel diff logic where we send a step (a real step in this case because we do want the refresh reported and snapshot'd) and then when it completes it sends an event back to the step generator. The second feature is the ability to skip all other custom resource operations, so we _only_ refresh, this also triggers refresh operations for anything left in state that was registered at the end of the deployment, as opposed to triggering deletes. ---------
AI Summary
The code improves the pulumi watch command's output by adding more informative messages, consistent color schemes, and visual enhancements to make the output more engaging and useful for users. It introduces a deterministic colorization scheme for resource names in watch mode to help users distinguish between different resource streams. The changes also ensure better formatting and eliminate stray newlines, improving the overall readability and consistency of the output.
Commit Log
Improve watch output (#19083) This change improves the watch command's output to make it a little more engaging, informative, and useful. Namely: - Emit the fully qualified stack name. - Print the update permalink in the usual "View Live" manner. - Use a consistent color scheme with SpecHeadline, with some specific uses of colors, bolds, and underlines, to make things visually pop. - Eliminate stray newlines that can lead to double newlines depending on the outputs of the program, language host, or providers. - Colorize the watch events resource names gutter, to make it easier to see at a glance the interleaved message streams associated with certain resources. This is just done by hashing the name and indexing into a list of possible colors to ensure it is deterministic.
AI Summary
The code ensures that `RegisterResourceOutputs` is idempotent by tracking registered outputs and making subsequent calls no-ops. This prevents redundant RPC calls and avoids provider failures when the method is called multiple times for the same resource.
Commit Log
[sdk/go] Ensure RegisterResourceOutputs is Idempotent (#19058) This PR builds on #19019 by adding additional unit tests and slight refactoring. This work ensures that `RegisterResourceOutputs` can be called multiple times for the same resource URN without triggering multiple RPC calls. Any subsequent calls become no-ops, preventing provider failures caused by redundant output registrations. While a broader fix at the engine level is desirable, this SDK-level change is necessary to support the components work in `pulumi-go-provider`. Previously, the `pulumi-go-provider``infer` framework handled output registration for components. However, a recent update allows converting existing Pulumi component programs into providers, where outputs may already be explicitly registered within the program code. This can result in duplicate calls to `RegisterResourceOutputs`. Since we cannot remove automatic output registration in `pulumi-go-provider` without breaking existing users, and requiring manual changes for new users would introduce friction when they convert
AI Summary
The commit updates the minimum supported .NET version from 6 to 8, aligning with the end-of-life of .NET 6. It simplifies version sets by dynamically generating the minimum version from the ALL_VERSION_SET, reducing redundancy.
Commit Log
Minimum dotnet version is now 8, not 6 (#19057) dotnet 6 is no longer in support, we can move tests to just test against 8 and 9. Also rewrote the version sets to not repeat the version numbers in each set. ---------
AI Summary
The code change ensures that variable names in resource attributes are correctly renamed to avoid conflicts with reserved keywords like 'this' in TypeScript. The fix introduces a new method to specifically handle variable renaming during resource attribute generation, avoiding unintended rewrites of valid references.
Commit Log
Fix this being incorrectly renamed in typescript when instantiating resources (#19041) When creating resources/variables when generating typescript from PCL, the instantiation is renamed but references is when assigning attributes specifically were overlooked. Simply always renaming within lowering is not acceptable since it will rewrite legitamate references to `this`. Instead, specifically when referencing pcl attribute assigns (which cannot reference `this` in the typescript sense, as these are only doable when generating code as in the case of parent assign) rename variables with valid names. Fixes #18542
AI Summary
The code change modifies the `component_provider_host` to accept an explicit list of components instead of searching for them in the plugin's source directory. This change aligns with TypeScript's behavior and improves control over which components are analyzed and hosted. The Analyzer class now processes a list of components directly, parsing their source code to extract docstrings and infer schemas.
Commit Log
Pass list of components to component_provider_host (#19021) Pass an explicit list of components to `component_provider_host` instead of searching the plugin's source directory for components. This behaviour matches that of TypeScript with https://github.com/pulumi/pulumi/pull/18996 To find the docstrings of properties (which are not available at runtime), we use `inspect.getsource` and parse that using the `ast` module as before. In a 2nd step, we can introduce a bootstrap-less mode, that detects component plugins and runs `component_provider_host` automatically.
AI Summary
The code adds the `--preview-only` option to the `destroy` command in the NodeJS Automation API, allowing users to preview a destroy without executing it. This change introduces a new `previewOnly` option in the `DestroyOptions` interface and modifies the command-line argument handling to support the preview-only mode.
Commit Log
Add the `--preview-only` option for `destroy` in the NodeJS API (#19030) Part of #18725. This PR adds the ability to run destroy `--preview-only` via the NodeJS automation API.
AI Summary
The code adds documentation for using `pulumi package add` with Git plugins, explaining how to specify Git repo URLs and versions. It clarifies the different ways to provide a provider, including local paths, files, and Git references.
Commit Log
package add: document the usage for git plugins (#19032) Add some docs for how package add can be used for git plugins.
AI Summary
The code change allows the use of GITHUB_TOKEN and GITLAB_TOKEN environment variables for authentication when cloning Git repositories in the pulumi package add command. It modifies the auth handling logic to check for these tokens if no auth is provided in the URL, improving convenience and security for users.
Commit Log
gitutil: use access tokens from environment if possible (#18991) When cloning using our gitutil, we try to paste the URL and get access tokens. However we currently don't support such URLs in `package add`, and it's often more convenient to set the authentication in the environment. Allow setting the `GITHUB_TOKEN` and `GITLAB_TOKEN` environment variables for authentication.
AI Summary
This PR enables `pulumi new` to fetch org-wide templates from `app.pulumi.com` by introducing a new API for template retrieval in the CLI, replacing the old `workspace.RetrieveTemplates` method. The changes include refactoring template handling logic, introducing new types and functions for managing templates, and updating test cases to support the new functionality.
Commit Log
Fetch Org-wide Project Templates from `app.pulumi.com` (#18627) This PR allows `pulumi new` to fetch org-wide templates from `app.pulumi.com` when they are enabled. Part of https://github.com/pulumi/pulumi-service/issues/25732. Conceptually, there are 2 parts to this PR: - Wraps `workspace.RetrieveTemplates` in a new API specific for `cmd`: ```go // Create a new [Template] [Source] associated with a given [Scope]. func New( ctx context.Context, templateNamePathOrURL string, scope Scope, templateKind workspace.TemplateKind, interactive bool, ) *Source { ... } ``` This is necessary because `workspace.RetrieveTemplates` is in `sdk`:
AI Summary
The code change adds a newline character to the output messages of the `gen-sdk` command to fix formatting issues. This ensures that the output messages are properly formatted and more readable, especially when combined with other output.
Commit Log
`pulumi package gen-sdk`: newline character (#19012) A fix for a formatting issue with the `gen-sdk` command. Given a make routine that generates SDK code before running some gotests, we see the phrase `SDK has been written to sdk/go` with improper formatting: ```plain ❯ make examples/random-login/test go build -C examples/random-login -o ../../bin/examples/pulumi-resource-random-login github.com/pulumi/pulumi-go-provider/examples/random-login pulumi package get-schema ./bin/examples/pulumi-resource-random-login > examples/random-login/schema.json SDK has been written to sdk/gook github.com/pulumi/pulumi-go-provider/examples/random-login (cached) ? github.com/pulumi/pulumi-go-provider/examples/random-login/sdk/go/randomlogin [no test files] ? github.com/pulumi/pulumi-go-provider/examples/random-login/sdk/go/randomlogin/config [no test files] ? github.com/pulumi/pulumi-go-provider/examples/random-login/sdk/go/randomlogin/internal [no test files] ```
AI Summary
This commit updates the Pulumi version to v3.158.0, introducing several new features and bug fixes across various components like the CLI, SDKs, and engine. The changes include experimental package publishing, improved error handling, and enhancements to resource management and dependency handling.
Commit Log
Changelog and go.mod updates for v3.158.0 (#19014)
AI Summary
The code introduces an experimental `pulumi package publish` command to publish packages to the Pulumi Registry, supporting both providers and schemas. The implementation includes backend support for the command, with HTTP endpoints and client logic for publishing packages, along with test coverage for various scenarios. The feature is hidden behind an experimental flag and depends on related changes in the pulumi-service repository.
Commit Log
Add experimental package publishing command (#18818) ## Overview This PR introduces a new `pulumi package publish` command that enables direct publishing of packages to the Pulumi Registry. The command allows publishing both providers (including components) and schemas (json and yaml). The command has similar semantics to `pulumi package add` or `pulumi package get-schema` in terms of how the schema is extracted/fetched. This feature is currently hidden behind the experimental flag. This depends on https://github.com/pulumi/pulumi-service/pull/26396 Fixes https://github.com/pulumi/pulumi-service/issues/26018 ## Usage Examples ``` ~ pulumi package publish path/to/schema.json --readme ./docs/_index.md ~ pulumi package publish https://github.com/flostadler/[email protected] --readme README.md
AI Summary
The commit updates the documentation to clarify how the `pulumi-terraform-provider` dynamically bridges Terraform providers at runtime. It emphasizes that the provider translates Pulumi's gRPC to Terraform's gRPC, enabling integration with any Terraform provider.
Commit Log
[dev docs] Correct `Example uses of parameterization` Terraform (#18981)
AI Summary
The commit updates the uv.lock file to include pytest-watch in both the dependencies and dev sections, aligning with changes from another pull request. This change ensures that pytest-watch is properly locked as a dependency for both testing and development purposes.
Commit Log
Update uv.lock (#18974) Update uv.lock to match the changes in https://github.com/pulumi/pulumi/pull/18966
AI Summary
The code updates Go versions in multiple modules to 1.24.1 and replaces context.Background() with t.Context() in test files to use the test's context. This change aligns with Go's modernization recommendations and ensures tests use the correct context for test execution.
Commit Log
Update languages and conformance tests to use `T.Context()` (#18945) This required updating these to go 1.24, but these aren't depended on as libraries so that should be fine. One of the recommendations of https://pkg.go.dev/golang.org/x/tools/gopls/internal/analysis/modernize
AI Summary
The code adds support for the 'default-org' capability to the Capabilities API, allowing the service to indicate if it can provide a default organization. This change is intended to enable the GetDefaultOrg API by distinguishing between backends that support this feature.
Commit Log
Add default orgs as an API capability (#18928) Fix https://github.com/pulumi/pulumi-service/issues/26811 Follow-up from [Slack conversation](https://pulumi.slack.com/archives/C02VCJEBT2N/p1741979075342809): Update the Capabilities API schema to include default orgs, to distinguish between backends that will support the new `GetDefaultOrg` API. See https://github.com/pulumi/pulumi/pull/18908 for the `GetDefaultOrg` API response type.
AI Summary
The code introduces an environment variable PULUMI_PARALLEL_DIFF to enable parallel diff calculations during resource operations, improving performance for slow diff methods. It implements parallel diffing by using a DiffStep that leverages a bounded step executor, allowing diffs to run concurrently while managing async events and completion sources.
Commit Log
Run diff in parallel (#18872) This adds a new envvar `PULUMI_PARALLEL_DIFF` which if set to true runs step diffs in parallel. We'll roll this out as opt-in to start (defaulting the envvar to false) but would eventually like to make this the default because the performance wins should be significant especially for providers with slow Diff methods. This works by yielding from the step generator when we need to do the diff and passing a `DiffStep` to the step executors to run in parallel. Once the `DiffStep` runs it fulfills a `promise.CompletionSource` which posts an event back to the step generator which is then picked up and continues with the rest of step generation. We're abusing Steps here to get access to the parallel but bounded step executor workers. The DiffStep skips all the pre and post work that normal steps would hit. This was born out of the "run the program for refresh" workstream which has a similar requirement for doing async work within the step
AI Summary
The code removes duplicate logic for handling resource import matching in the importResources function. The removed code checks if an existing resource matches the import ID and handles it by marking it as 'Same'.
Commit Log
Delete duplicate code (#18910) This code got duplicated in https://github.com/pulumi/pulumi/pull/14467. The lines above are exactly the same as the deleted lines.
AI Summary
The code diff upgrades the Pulumi .NET SDK version to 3.76.1 to align with AWSX dependencies and resolve test failures. The change updates version constants in multiple files to reflect the new SDK version, ensuring consistency across the project.
Commit Log
upgrade pulumi dotnet to 3.76.1 (#18853) This has been released and Awsx has started to rely on it, so our tests break without this being updated.
AI Summary
The code change updates the Go version in CI to 1.23 and 1.24 to align with the latest supported versions. It modifies multiple configuration files to ensure compatibility with Go 1.23 and 1.24, including CI workflows, dependency installation, and version matrices.
Commit Log
Update Go in CI to 1.23 and 1.24 (#18841) Go 1.24 was released in early Feb: https://tip.golang.org/doc/go1.24 We should be testing against that, and 1.23 as the two supported versions.
AI Summary
The code extends the `Handshake` gRPC method to allow providers to return more detailed configuration flags, such as support for secrets, resources, outputs, and autonaming. This change aims to improve compatibility and flexibility by allowing providers to explicitly declare their capabilities rather than implicitly assuming support for all features.
Commit Log
Extend `Handshake` responses to allow more configuration (#18809) When we initially introduced the `Handshake` gRPC method for negotiating communication with providers, we anticipated that any provider implementing `Handshake` would implicitly support all the features we had until that point supported flagging in `Configure`. However, this turns out not to be the case -- the bridge, for instance, supports the very new autonaming but still doesn't support secrets (or at least, indicate that it does). This PR thus gives providers the ability to return a bit more fine-grained configuration in the `Handshake` response, hopefully smoothing the path to introduction/broadly making `Handshake` more useful. Note that we leave `SupportsPreview` implicit -- this is a bit of a hand-wavy decision since the bridge supports it and the bridge underpins the majority of our providers.
AI Summary
The commit upgrades the pulumi-yaml dependency to version 1.14.1, which likely includes bug fixes, performance improvements, or new features. The change updates the version in the script to ensure the correct version is used when downloading language providers.
Commit Log
Update pulumi-yaml to 1.14.1 (#18819)
AI Summary
The Makefile change updates the build process to copy the binary to the correct 'bin' directory within the GOPATH. This fixes a typo from a previous commit that incorrectly placed the binary in the 'pulumi' directory instead of 'bin'.
Commit Log
Fix make build to copy to go bin (#18806) https://github.com/pulumi/pulumi/pull/18728 discussed the correct way to set this, but then typo'd out the "bin" at some point.
AI Summary
The code adds the `stack rename` command to the Go Automation API, enabling renaming of stacks with various configuration options. It introduces new options like StackName, ErrorProgressStreams, and ShowSecrets to customize the rename operation.
Commit Log
Add the `stack rename` command to the Go Automation API. (#18723) To match both TypeScript and Python, this PR adds the `stack rename` command to the Automation API for Go. * #15357 * #18696 * #18712 Fixes #15357. ---------
AI Summary
The code introduces a health check mechanism to avoid false positives when detecting plugin crashes by checking if the plugin is still alive via a gRPC health check service. The health check is implemented as a background goroutine that attempts to call the plugin's health check endpoint, treating unimplemented services as healthy.
Commit Log
Fix plugin "exited prematurely" false positives (#18793) When closing a plugin, the plugin's connection state is used to determine whether the plugin had crashed, where a connection state other than `Ready` is presumed crashed. This can lead to false positives, as it's possible for the connection state to change from `Ready` to `Idle` after an idle timeout (e.g. 5 minutes) for plugins that have not crashed. This leads to incorrect messages reported to users, such as: ``` Detected that /Users/user/.pulumi/plugins/resource-random-v4.18.0/pulumi-resource-random exited prematurely. This is *always* a bug in the provider. Please report the issue to the provider author as appropriate. ``` This change avoids the false positives by making a request to a health check service on the plugin as a way of determining if the plugin is still alive. Most plugins don't and won't implement this service, but that's OK because we treat an unimplemented status as OK. If we get any
AI Summary
This change introduces program override support in conformance tests, allowing specific tests to use pre-generated programs instead of relying on code generation. The feature is useful for testing SDK functionality when code generation is incomplete, such as in Java, by enabling manual program specification.
Commit Log
Support overriding programs in conformance tests (#18787) This change adds the ability to specific that one or more conformance tests in a suite should use hardcoded or pre-generated programs, rather than relying on a language host's `GenerateProject` functionality. This is useful in cases where e.g. a language's core SDK supports functionality which we'd like to test, but its code generation features are not fleshed out enough to produce programs capable of exercising those features -- Java is a good example of this. With this feature, such tests can now be made to pass by hand-writing the relevant programs and supplying these paths as overrides. Aside from not generating a program, all other functionality -- snapshot checking, assertions, etc. is the same. This is verified with a metatest that overrides the program for the `l1-empty` with a mocked language host. Fixes #18235
AI Summary
The code adds comprehensive documentation on Pulumi's converter plugins, explaining how they facilitate conversion of infrastructure as code from other ecosystems like Terraform into Pulumi. It introduces detailed explanations of program and state conversion processes, including schema loading, mapping, and how providers interact with converters.
Commit Log
Flesh out documentation on converters (#18797) Following the recent work on `pulumi convert` and supporting more Terraform conversion than ever, this change bulks out the developer documentation on how conversion and converter plugins work under the hood, in order to capture some of the details discovered and introduced as part of this effort.
AI Summary
The commit removes the dependency on @opentelemetry/semantic-conventions to avoid CI flakes and reduce unnecessary complexity. Constants like ATTR_SERVICE_NAME and ATTR_SERVICE_VERSION are now defined locally instead of being imported from the external package.
Commit Log
nodejs: remove dependency on @opentelemetry/semantic-conventions (#18795) We seem to be using this package *only* for importing a couple of constants and nothing else. However it causes a huge amount of flakes in CI for some reason that's not obvious. Instead of spending a lot of time to try and figure out why this is flaky, let's just drop this dependency, as it doesn't provide a lot of value anyway, and we don't expect these constants to ever really change. Fixes: https://github.com/pulumi/pulumi/issues/17823
AI Summary
The commit adds documentation for crypters in Pulumi's secret management system, explaining how secrets are encrypted and decrypted using various crypter implementations. It also updates development documentation to ensure tools are up to date and includes changes to .gitignore and VSCode settings for better project management. The documentation covers key concepts like secret managers, crypters, and their use in different scenarios such as cloud and local secret handling.
Commit Log
Add dev documentation for crypters (#18794) Also based on work pending in https://github.com/pulumi/pulumi/pull/18743 Closes https://github.com/pulumi/home/issues/3897 ---------
AI Summary
The code adds a `make test_watch` command to run pytest tests automatically when Python files change, improving development efficiency. It introduces dependencies like `pytest-watch` and updates test logic to use the current test organization, ensuring compatibility with the latest Pulumi setup. Potential risks include version incompatibilities with `pytest-watch` or its dependencies, and changes in test organization handling might affect existing test workflows.
Commit Log
Add `make test_watch`, a test-watching command for Python (#18758) Very similar PR to #18750: this allows us to run specific pytests every time a code or test file is updated. This also gets the tests to pass on my machine.
AI Summary
The code updates the `can` function in PCL to return an output boolean only when the input is dynamic or an output, otherwise it returns a plain boolean. This change ensures type consistency and correct behavior when dealing with outputs and dynamic values in PCL.
Commit Log
Only lift can to output space if needed (#18791) This updates the PCL signature of `can` to only be an `output(bool)` when the input argument is either dynamic or an output itself. If the input argument is a plain value then the return value of `can` just be a plain `bool`.
AI Summary
The code adds support for the --diff flag in the Go Automation API's refresh operation, allowing users to display changes as a rich diff. A new Diff option is introduced in the Options struct and used to conditionally append the --diff argument to the command line.
Commit Log
Automation API for Go now permits setting --diff flag on refresh (#18792) Automation API for Go now permits setting --diff flag on refresh
AI Summary
The code adds a new field 'numAccounts' to the PolicyGroupSummary struct to track the number of accounts in a policy group. This change was made to support the new capability of Policy Groups containing accounts, as required by the Pulumi Cloud API.
Commit Log
add num accounts to policy group summary (#18789) Policy Groups can now contain accounts as well as stacks. We need this field to be returned from the pulumi cloud API
AI Summary
The code renames 'Bulk' to 'Batch' in method and type names across multiple files to align with the service API's terminology, improving naming consistency. This change affects numerous files and requires corresponding updates on the service side to maintain compatibility, as the API endpoints and related structures may need to be updated to match the new naming convention.
Commit Log
Rename batch crypt types (#18776) Make naming of types and methods consistent with the actual service API route (which we can't easily change). 1. Rename BulkDecrypt to BatchDecrypt 2. Rename "bulk" api types to "batch" This will require some additional fixes on the service side on the next update.
AI Summary
The code updates the CONTRIBUTING.md file to improve the formatting of a note about building multiple binaries in the Pulumi repository. The change ensures that the note block renders correctly, enhancing readability and clarity for contributors.
Commit Log
Update CONTRIBUTING.md (#18774) This gets the note block to render correctly.
AI Summary
The code change fixes an issue where `pulumi.get_organization()` returns `None` when using older Python SDK versions with newer CLI versions. The fix involves dynamically inspecting the `Settings` class to handle parameter compatibility across different SDK versions.
Commit Log
[sdk/python] Fix `get_organization` returning `None` (#18769) When versions v3.152.0 and earlier of the `pulumi` python SDK are used with v3.153.0 of the CLI, the `pulumi.get_organization()` function returns `None` rather than the expected organization. This is a regression that was introduced by #18595. This is what's happening: `pulumi-language-python-exec` ships with the CLI. In v3.153.0, it tries to create an instance of `pulumi.runtime.Settings`, passing a new parameter: `root_directory`. However, older versions of the `pulumi` python SDK do not support this parameter. An error is raised, which is caught and we fall back to default values, which doesn't have the `organization`, so it ends up being `None`. This change fixes the problem in `pulumi-language-python-exec`. We first try to create `Settings` with all possible parameters. If it runs into an error, it falls back to a slower path that inspects the signature of `Settings.__init__` to determine the supported parameters, and then tries to create `Settings` again with only the parameters it supports.
AI Summary
The code change replaces the use of the Publisher field with the Namespace field to generate Go package paths in code generation. This change is intended to align with the intended use of Namespace for package naming, which is more reliable than Publisher.
Commit Log
use namespace instead of publisher for Go package generation (#18755) If we don't have a better way to generate the module path for Go in codegen, we currently use the Publisher field to do so. However the Publisher field in the schema is free-form text, and doesn't necessarily fit into a package name. Use the namespace that was set up for this purpose instead. Note that this is technically a breaking change, however it's expected that this is not used very much. This is because most providers would also set the Repository field, which overrides the Publisher/Namespace. Part of https://github.com/pulumi/pulumi/issues/18369
AI Summary
The PR modifies the Makefile to de-duplicate the build process for `make build` and `make install` by using a shared binary build target. It introduces a `bin/pulumi` target that builds the binary once and reuses it for both `make build` and `make install` to reduce redundant work.
Commit Log
De-duplicate the build for `make build` and `make test` (#18728) Both `make build` and `make install` install the `pulumi` binary to a global location (using `go install` under the hood). This PR adds a `bin/pulumi` target that will build a local copy of Pulumi. It also changes the implementation of `make build` and `make install` to use the copy generated with `make bin/pulumi`. Since I often run `make build install`, this cuts build time for me in half.
AI Summary
The code adds a 'namespace' field to the pulumi.json file to allow disambiguation of package names, enabling imports like '@example/xyz' instead of '@pulumi/xyz'. The 'namespace' field is integrated into the code generation schema, including new methods to retrieve it and updates to data structures to store and marshal it. This change introduces a new field in the schema and related code, which may require updates to dependent systems and code generators to ensure compatibility.
Commit Log
add namespace field to pulumi.json (#18720) Add a namespace field to the `pulumi.json` file. This will be used to disambiguate package names for components, any TF provider and anyone else that wants to use it. The idea is to use this to generate packages that can be imported as `@example/xyz` or `example_xyz` instead of `@pulumi/xyz` or `pulumi_xyz`, when they are really not coming from pulumi. Pulumiverse packages will also be able to use this. The codegen implementations for each of the languages will follow in separate PRs. Part of https://github.com/pulumi/pulumi/issues/18624 ---------
AI Summary
The code introduces a helper function `ErrorWithStderr` to enhance error messages by including stderr output from `exec.ExitError` in Go, improving debuggability. This function is used in multiple places, including Go and Python toolchain components, to replace custom error formatting with a centralized and consistent approach.
Commit Log
introduce helper function for exiterr, and use it in language tests (#18690) In Go, `exec.ExitErr` contains the whole Stderr of a command. However it's `Error()` function unfortunately only returns the exit status, which in most cases is not enough to debug the problem. In most cases we want to format these errors including the stderr to make the problems more debuggable. Factor out the helper function we already have for the python toolchain, and make it available to other places as well. Start using it in the Go conformance tests, where I ran into this today. We should spread the usage of this to wherever we deal with ExitErrors, but let's start here for now.
AI Summary
The Makefile was updated to correctly set the GOBIN variable for the dist target, ensuring proper build and installation of Python language components. The stray OBIN file was removed as it was incorrectly checked in and had no functional value.
Commit Log
fix sdk/python/Makefile, remove stray file (#18722) The dist target in sdk/python/Makefile was wrong, because target local variables can't just be defined in the target, but have a special syntax that I was not aware of. Fix that. The current version of this accidentally produced a `sdk/python/OBIN` file, which got checked in, but has no value. Delete that.
AI Summary
The code update increments the Pulumi SDK version from 3.152.1 to 3.153.0 across multiple languages and components. A new OBIN script for Python adds support for virtual environment handling in policy execution, improving isolation and dependency management.
Commit Log
Prepare for 3.153.0 (#18711) ## (2025-02-25) ### Features - [sdk/{dotnet,go,java,nodejs,python,yaml}] Add the ability to lookup project root from sdks, equivalent to path.root in Terraform [#18595](https://github.com/pulumi/pulumi/pull/18595) ### Bug Fixes - [cli] Make policy rm and stack rm non-interactive when requested [#18708](https://github.com/pulumi/pulumi/pull/18708) - [cli/new] Report all errors from git clone for multiple refs. [#18702](https://github.com/pulumi/pulumi/pull/18702)
AI Summary
The code change modifies the RetrieveGitFolder function to collect and report all errors from git clone attempts for multiple references instead of just the last one. It also adds more detailed logging to track failed clone operations and improves error handling by joining all errors into a single error message.
Commit Log
Report all errors back from git clone (#18702) Currently when we try a git clone for a given url without a reference we try both master and main. If the clone for master _and_ main both fail we only report back the error that happened for main. This changes it so we report both errors. I also added some more log lines.
AI Summary
The code change ensures that plugins located in subdirectories are correctly handled by adjusting the path when no version is specified, improving compatibility with versionless plugins. The fix applies unconditionally to all plugins, not just prerelease ones, which was previously limited to commit hash-based versions, addressing a potential issue with versionless Git plugins.
Commit Log
correctly run versionless plugins in subdirs (#18605) When we have plugins that are located in a subdir of a repository, we need to fix up the path to include that subdir, as we install the whole repository into `~/.pulumi/plugins`, and then use the plugin from a subdir. Currently we only do that for "prerelease plugins", which means plugins whose version is referenced by a commit hash. This is however not correct, as plugins from Git plugins don't necessarily have a version number, or they can be referenced by a regular semver version. Fix up the path unconditionally if we have a subdir instead. Fixes https://github.com/pulumi/pulumi/issues/18557
AI Summary
The code adds support for optional types in unions by allowing `| undefined` in TypeScript, in addition to the existing `?` syntax. It introduces a new function `isOptionalType` to detect union types with `undefined` and ensures the union has exactly one non-undefined type.
Commit Log
[Experimental/Component]: support optional types in unions (#18654) We currently support optional types in typescript by adding `?` to the symbol name. Also allow optional types by adding `| undefined` instead. Part of https://github.com/pulumi/pulumi/issues/18365 Ref https://github.com/pulumi/pulumi/issues/15939
AI Summary
The code change fixes an issue where generating SDKs for .NET projects using pulumi convert was not dynamically calling the language host, leading to incomplete SDK generation. The fix involves replacing the static call to `dotnet.GenerateProject` with a dynamic orchestration of `GenerateProject`, `GetSchema`, and `GeneratePackage` to ensure proper handling of parameterized packages.
Commit Log
[programgen/dotnet] Fix generating SDKs for .NET projects with pulumi convert (#18510) Fixes #18463 The problem is that when the target language for convert is `dotnet`, we use the statically linked `GenerateProject` function from dotnet codegen and call it a day rather than dynamically calling the language host (i.e. `pulumi-language-dotnet`) and orchestrating `GenerateProject`, `GetSchema` and `GeneratePackage` which _does_ lookup parameterized packages and generates sdks for them
AI Summary
The change adds support for hardcoded mappings in the `basePluginMapper` to ensure they take priority over plugin mappings, fixing a regression introduced in a previous refactor. A test case was added to verify that hardcoded entries are correctly used when available, ensuring future changes do not break this behavior.
Commit Log
Fix mapping in the presence of hardcoded entries (#18680) In adding parameterization support to the `Mapper` interface (#18671), we broke the ability to use hardcoded mappings as an alternative to plugin mappings. This change restores that and adds a test so that we hopefully won't miss it again.
AI Summary
The code fixes an issue where the `stack history` command fails when decrypting nested secrets in a config file due to an unexpected JSON parsing error. The fix involves modifying the `buildUpdatesJSON` function to handle decryption errors gracefully and avoid JSON unmarshaling when decryption fails.
Commit Log
[auto] Fix `up` with nested secret in config file (#18676) At the end of running an `up` operation from Automation API, the `pulumi stack history` command is invoked to retrieve an update summary of the operation. We want the `stack history --json` command to succeed even if there are problems decrypting secrets in the config, which can happen when the `stack history` command doesn't have the encryption salt (because it is stored in a separate config file). If there is an error decrypting a config secret, the config's value is replaced with `ERROR_UNABLE_TO_DECRYPT` rather than having the command fail. Unfortunately, this does not work when there is a config value with a nested secret. In that case, an obscure "unexpected end of JSON input" error is returned and the command fails. This happens because we attempt to unmarshal the nested value, which is represented as a JSON string, regardless of whether the decrypt succeeded
AI Summary
The change prevents overwriting existing schema versions unless they are missing, aligning with the original intention of only adding versions when necessary. This avoids incorrect version assignments in parameterized providers where plugin and package versions may differ.
Commit Log
Don't overwrite schema versions if they exist (#18672) When loading a schema from a provider, we previously added logic that would overwrite the version in the returned schema with the plugin version if the schema had an older version. It's not clear why we did this, and is a bit odd when the plugin name and the package name match, but in the case of parameterized providers where plugin and package are different, it's outright wrong. This change thus adapts this behaviour to match its original intention -- adding a version only when one is missing (and moreover, only when parameterization is not involved). Part of #18187
AI Summary
The code change simplifies the handling of empty IDs by moving the logic to 'providers.NewReference' to always use 'UnknownID' when the ID is empty, reducing redundancy in test code. This change improves consistency across tests and reduces code duplication, but requires ensuring that 'providers.NewReference' correctly handles empty IDs and maintains backward compatibility with existing usage. Potential risks include unintended behavior if other parts of the codebase rely on the previous logic for handling empty IDs, or if the 'UnknownID' value is not properly supported in all contexts.
Commit Log
Default to UnknownID in providers.NewReference (#18630) We were a little inconsistent in the tests if we bothered to check if ID was empty and setting it to UnknownID or if we just passed the ID directly. There was also a lot of duplicate code doing that empty check. This moves the empty check to "providers.NewReference" so we can just always pass ID directly.
AI Summary
The commit updates the version number across multiple files to 3.151.0, indicating a new release. This change is likely part of a release process to prepare for the 3.151.0 version of the Pulumi SDK.
Commit Log
Prepare for 3.151.0 (#18663)
AI Summary
The code adds support for detecting and handling Asset and Archive types in the components analyzer for Pulumi's Node.js SDK. It introduces helper functions to identify these types based on their symbol names and source file locations, and updates the analyzer to return appropriate type definitions.
Commit Log
Experimental/Components]: Handle assets and archives (#18639) Handle assets and archives in the components analyzer. Part of https://github.com/pulumi/pulumi/issues/18365 Ref https://github.com/pulumi/pulumi/issues/15939 Stacked on top of https://github.com/pulumi/pulumi/pull/18631
AI Summary
The code fixes a panic in the `help new` command when local templates are not present by using `context.Background()` instead of `cmd.Context()`. This change was made because cobra does not propagate the context from the parent help command to the child command, leading to a panic when templates are missing.
Commit Log
Fix panic in help new (#18661) Fixes https://github.com/pulumi/pulumi/issues/18659 Comment in code pretty much covers it, but repeating here: You'd think you could use cmd.Context() in the help function but cobra doesn't set context on the cmd even though the parent help command has it. I've raised https://github.com/spf13/cobra/issues/2240 to see about fixing it.
AI Summary
The code adds a preview-only option for importing resources in the Pulumi Go SDK, allowing users to preview imports without executing them. It also introduces an option to specify an import file and a diff option to show the import diff, enhancing the import functionality. The changes include updating the ImportResources function to handle these new options and adding a test case for the preview-only feature.
Commit Log
Fixes: #18610 - feat(sdk/go): add preview-only option for import resources (#18609) Fixes: #18610 This pull request includes several enhancements to the Go SDK, specifically adding new options for importing resources and improving test coverage. The most important changes are summarized below: ### New Import Options: * Added a new option `PreviewOnly` to allow previewing the import without executing it. (`sdk/go/auto/optimport/optimport.go`) * Introduced `ImportFile` option to specify the file from which to import resources. (`sdk/go/auto/optimport/optimport.go`) ### Updates to ImportResources Function: * Modified `ImportResources` function to handle `PreviewOnly` and `ImportFile` options. (`sdk/go/auto/stack.go`) [[1]](diffhunk://#diff-033162b77df0df934fbf08c531cea9cd417f28e252ff84596651424e1606af74L509-R515)
AI Summary
The code adds deferred calls to remove stacks created during HTTP state backend tests to prevent them from lingering in Pulumi Cloud. This change ensures cleanup after test execution, avoiding resource leaks and potential conflicts in future tests.
Commit Log
remove stacks after we created them in the httpstate backend tests (#18657) We need to remove these stacks at the end of the test, otherwise they will linger forever in Pulumi Cloud. There might be other places where we have similar problems, but this is the most obvious one.
AI Summary
The code fixes unbalanced quotes in error messages to improve readability and consistency. The changes ensure that error messages are properly formatted with balanced quotes.
Commit Log
[Experimental/Components]: Fix up unbalanced quotes (#18656) These quotes are unbalanced, leading to a slightly ugly error message. Fix that.
AI Summary
The code change updates the error formatting from using %g to %w to properly wrap the error when setting config. This ensures the error is correctly wrapped for propagation and handling in the calling context.
Commit Log
Fix format specifier for config set error (#18621) This is wrapping an error so should be %w, not %g which is for floats.
AI Summary
The code adds a Stringer method to the PackageDescriptor struct to provide a more readable string representation of package descriptors. This change improves debugging and logging by displaying package names, versions, and parameterizations in a structured format.
Commit Log
Add Stringer function to loaders PackageDescriptor (#18617) While looking at https://github.com/pulumi/pulumi/issues/18615 I noticed the string output we got for PackageDescriptor wasn't that useful: ``` '&{terraform-provider 0.8.1 0xc000d8f810}' ``` This updates it so we should now get something like: ``` [email protected] ([email protected]) ```