Pulumi Go Provider SDK

func main() {
	provider, err := infer.NewProviderBuilder().
		WithResources(infer.Resource(&HelloWorld{})).
		Build()
	if err != nil {
		log.Fatal(err)
	}
	if err := provider.Run(context.Background(), "greetings", "0.1.0"); err != nil {
		log.Fatal(err)
	}
}

// Each resource has a controlling struct.
type HelloWorld struct{}

// Each resource has an input struct, defining what arguments it accepts.
type HelloWorldArgs struct {
	// Fields projected into Pulumi must be public and have a `pulumi:"..."` tag.
	Name string `pulumi:"name"`
	// Fields marked `optional` are optional, so they should have a pointer ahead of their type.
	Loud *bool `pulumi:"loud,optional"`
}

// Each resource has a state struct, describing the fields that exist on the created resource.
type HelloWorldState struct {
	// It is generally a good idea to embed args in outputs, but it isn't strictly necessary.
	HelloWorldArgs
	// Here we define a required output called message.
	Message string `pulumi:"message"`
}

// All resources must implement Create at a minimum.
func (HelloWorld) Create(
	ctx context.Context, name string, input HelloWorldArgs, preview bool,
) (string, HelloWorldState, error) {
	state := HelloWorldState{HelloWorldArgs: input}
	if preview {
		return name, state, nil
	}
	state.Message = fmt.Sprintf("Hello, %s", input.Name)
	if input.Loud != nil && *input.Loud {
		state.Message = strings.ToUpper(state.Message)
	}
	return name, state, nil
}

func main() {
	provider, err := infer.NewProviderBuilder().
		WithFunctions(infer.Function(&Replace{})).
		Build()
	if err != nil {
		log.Fatal(err)
	}
	if err := provider.Run(context.Background(), "str", "0.1.0"); err != nil {
		log.Fatal(err)
	}
}

type Replace struct{}

type ReplaceArgs struct {
	S   string `pulumi:"s"`
	Old string `pulumi:"old"`
	New string `pulumi:"new"`
}

type ReplaceResult struct {
	Out string `pulumi:"out"`
}

func (Replace) Invoke(
	ctx context.Context, req infer.FunctionRequest[ReplaceArgs],
) (infer.FunctionResponse[ReplaceResult], error) {
	return infer.FunctionResponse[ReplaceResult]{
		Output: ReplaceResult{
			Out: strings.ReplaceAll(req.Input.S, req.Input.Old, req.Input.New),
		},
	}, nil
}