Introducing Resource Methods for Pulumi Packages

const cluster = new eks.Cluster("mycluster");
const kubeconfig = cluster.getKubeconfig(...);

cluster = eks.Cluster("mycluster")
kubeconfig = cluster.get_kubeconfig(...)

var cluster = new Cluster("mycluster");
var kubeconfig = cluster.GetKubeconfig(...);

cluster, err := eks.NewCluster(ctx, "mycluster", nil)
if err != nil {
    return err
}
kubeconfig, err := cluster.GetKubeconfig(ctx, &eks.ClusterGetKubeconfigArgs{...})
if err != nil {
    return err
}

import * as pulumi from "@pulumi/pulumi";

interface MessageArgs {
    message: pulumi.Input<string>;
}

class Message extends pulumi.ComponentResource {
    public readonly message!: pulumi.Output<string>;

    constructor(name: string, args: MessageArgs, opts?: pulumi.ComponentResourceOptions) {
        const props = { message: args?.message }
        super("example:index:Message", name, props, opts);

        if (opts?.urn) {
            // Skip further initialization when being constructed from a resource reference.
            return;
        }

        this.registerOutputs(props);
    }

    getMessage(recipient: pulumi.Input<string>): pulumi.Output<string> {
        return pulumi.iterpolate `${recipient}, ${this.message}!`;
    }
}

from typing import Optional

import pulumi

class Message(pulumi.ComponentResource):
    @property
    @pulumi.getter
    def message(self) -> pulumi.Output[str]:
        return pulumi.get(self, "message")

    def __init__(self,
                 resource_name: str,
                 opts: Optional[pulumi.ResourceOptions] = None,
                 message: Optional[pulumi.Input[str]] = None) -> None:

        args = {"message": message}
        super().__init__("example:index:Message", resource_name, args, opts)

        if opts and opts.urn:
            # Skip further initialization when being constructed from a resource reference.
            return

        self.register_outputs(args)

    def get_message(self, recipient: pulumi.Input[str]) -> pulumi.Output[str]:
        return pulumi.Output.concat(recipient, ", ", self.message, "!")

import (
	"errors"

	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

type Message struct {
	pulumi.ResourceState
	Message  pulumi.StringOutput `pulumi:"message"`
}

type MessageArgs struct {
	Message  pulumi.StringInput `pulumi:"message"`
}

func NewMessage(ctx *pulumi.Context, name string, args *MessageArgs, opts ...pulumi.ResourceOption) (*Message, error) {
	if args == nil {
		return nil, errors.New("args is required")
	}

	message := &Message{}
	err := ctx.RegisterComponentResource("example:index:Message", name, message, opts...)
	if err != nil {
		return nil, err
	}

	message.Message = args.Message.ToStringOutput()
	if err := ctx.RegisterResourceOutputs(message, pulumi.Map{
		"message":  args.Message,
	}); err != nil {
		return nil, err
	}

	return message, nil
}

type GetMessageArgs struct {
	Recipient pulumi.StringInput `pulumi:"recipient"`
}

func (c *Message) GetMessage(args *GetMessageArgs) StringOutput {
	return pulumi.Sprintf("%s, %s!", args.Recipient, c.Message)
}

import * as pulumi from "@pulumi/pulumi";
import * as provider from "@pulumi/pulumi/provider";

class Provider implements provider.Provider {
    public readonly version = "0.0.1";

    constructor() {
        // Register any resources that can come back as resource references that need to be rehydrated.
        pulumi.runtime.registerResourceModule("example", "index", {
            version: this.version,
            construct: (name, type, urn) => {
                switch (type) {
                    case "example:index:Message":
                        return new Component(name, <any>undefined, { urn });
                    default:
                        throw new Error(`unknown resource type ${type}`);
                }
            },
        });
    }

    async construct(name: string, type: string, inputs: pulumi.Inputs,
              options: pulumi.ComponentResourceOptions): Promise<provider.ConstructResult> {
        if (type != "example:index:Message") {
            throw new Error(`unknown resource type ${type}`);
        }

        const message = new Message(name, <MessageArgs>inputs, options);
        return {
            urn: message.urn,
            state: inputs,
        };
    }

    async call(token: string, inputs: pulumi.Inputs): Promise<provider.InvokeResult> {
        switch (token) {
            case "example:index:Message/getMessage":
                const self: Component = inputs.__self__;
                return {
                    outputs: {
                        result: self.getMessage(inputs.recipient),
                    },
                };

            default:
                throw new Error(`unknown method ${token}`);
        }
    }
}

export function main(args: string[]) {
    return provider.main(new Provider(), args);
}

main(process.argv.slice(2));

from typing import Optional
import sys

import pulumi
import pulumi.provider as provider


class Provider(provider.Provider):
    VERSION = "0.0.1"

    class Module(pulumi.runtime.ResourceModule):
        def version(self):
            return Provider.VERSION

        def construct(self, name: str, typ: str, urn: str) -> pulumi.Resource:
            if typ == "example:index:Message":
                return Component(name, pulumi.ResourceOptions(urn=urn))
            else:
                raise Exception(f"unknown resource type {typ}")

    def __init__(self):
        super().__init__(Provider.VERSION)
        pulumi.runtime.register_resource_module("example", "index", Provider.Module())

    def construct(self, name: str, resource_type: str, inputs: pulumi.Inputs,
                  options: Optional[pulumi.ResourceOptions] = None) -> provider.ConstructResult:

        if resource_type != "example:index:Message":
            raise Exception(f"unknown resource type {resource_type}")

        message = Message(name, opts=options, message=inputs["message"])

        return provider.ConstructResult(
            urn=component.urn,
            state=inputs)

    def call(self, token: str, args: pulumi.Inputs) -> provider.CallResult:
        if token != "example:index:Message/getMessage":
            raise Exception(f'unknown method {token}')

        message: Message = args["__self__"]
        outputs = {
            "result": message.get_message(args["recipient"])
        }
        return provider.CallResult(outputs=outputs)


if __name__ == "__main__":
    provider.main(Provider(), sys.argv[1:])

import (
	"errors"
	"fmt"

	"github.com/blang/semver"

	"github.com/pulumi/pulumi/pkg/v3/resource/provider"
	"github.com/pulumi/pulumi/sdk/v3/go/common/util/cmdutil"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	pulumiprovider "github.com/pulumi/pulumi/sdk/v3/go/pulumi/provider"
)

const providerName = "example"
const version = "0.0.1"

type module struct {
	version semver.Version
}

func (m *module) Version() semver.Version {
	return m.version
}

func (m *module) Construct(ctx *pulumi.Context, name, typ, urn string) (r pulumi.Resource, err error) {
	if typ != "example:index:Message" {
		return nil, fmt.Errorf("unknown resource type: %s", typ)
	}
	r = &Component{}
	err = ctx.RegisterResource(typ, name, nil, r, pulumi.URN_(urn))
	return
}

type GetMessageResult struct {
	Result pulumi.StringOutput `pulumi:"result"`
}

func main() {
	pulumi.RegisterResourceModule("example", "index", &module{semver.MustParse(version)})

	if err := provider.MainWithOptions(provider.Options{
		Name:    providerName,
		Version: version,
		Construct: func(ctx *pulumi.Context, typ, name string, inputs pulumiprovider.ConstructInputs,
			options pulumi.ResourceOption) (*pulumiprovider.ConstructResult, error) {

			if typ != "example:index:Message" {
				return nil, fmt.Errorf("unknown resource type %s", typ)
			}

			args := &MessageArgs{}
			if err := inputs.CopyTo(args); err != nil {
				return nil, fmt.Errorf("setting args: %w", err)
			}

			message, err := NewMessage(ctx, name, args, options)
			if err != nil {
				return nil, fmt.Errorf("creating component: %w", err)
			}

			return pulumiprovider.NewConstructResult(message)
		},
		Call: func(ctx *pulumi.Context, tok string, args pulumiprovider.CallArgs) (*pulumiprovider.CallResult, error) {
			if tok != "example:index:Message/getMessage" {
				return nil, fmt.Errorf("unknown method %s", tok)
			}

			methodArgs := &GetMessageArgs{}
			res, err := args.CopyTo(methodArgs)
			if err != nil {
				return nil, fmt.Errorf("setting args: %w", err)
			}
			message := res.(*Message)

			result, message.GetMessage(methodArgs)
			return pulumiprovider.NewCallResult(&GetMessageResult{
                Result: result
            })
		},
	}); err != nil {
		cmdutil.ExitError(err.Error())
	}
}

const component = new example.Message("mycomponent", {
    message: "hello world",
});
export const message = component.getMessage({ recipient: "Alice" }); // Exports "Alice, hello world!"

component = example.Message("mycomponent", message="hello world")
message = component.get_message(recipient="Alice")
pulumi.export("message", message) # Exports "Alice, hello world!"

var component = new Message("mycomponent", new MessageArgs
{
    Message = "hello world",
});
// Exports "Alice, hello world!"
this.Message = component.GetMessage(new MessageGetMessageArgs
{
    Recipient = "Alice",
});

component, err := example.NewMessage(ctx, "mycomponent", &example.MessageArgs{
	Message: "hello world",
})
if err != nil {
	return err
}
message, err := component.GetMessage(ctx, &example.MessageGetMessageArgs{Recipient: "Alice"})
if err != nil {
	return err
}
pulumi.Export("message", message) // Exports "Alice, hello world!"