getRecords

import * as pulumi from "@pulumi/pulumi";
import * as digitalocean from "@pulumi/digitalocean";
import * as std from "@pulumi/std";
const example = digitalocean.getRecords({
    domain: "example.com",
    filters: [{
        key: "type",
        values: ["MX"],
    }],
});
export const mailServers = example.then(example => std.join({
    separator: ",",
    input: example.records.map(__item => __item.value),
})).then(invoke => invoke.result);

import pulumi
import pulumi_digitalocean as digitalocean
import pulumi_std as std
example = digitalocean.get_records(domain="example.com",
    filters=[{
        "key": "type",
        "values": ["MX"],
    }])
pulumi.export("mailServers", std.join(separator=",",
    input=[__item.value for __item in example.records]).result)

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using DigitalOcean = Pulumi.DigitalOcean;
using Std = Pulumi.Std;
return await Deployment.RunAsync(() =>
{
    var example = DigitalOcean.GetRecords.Invoke(new()
    {
        Domain = "example.com",
        Filters = new[]
        {
            new DigitalOcean.Inputs.GetRecordsFilterInputArgs
            {
                Key = "type",
                Values = new[]
                {
                    "MX",
                },
            },
        },
    });
    return new Dictionary<string, object?>
    {
        ["mailServers"] = Std.Join.Invoke(new()
        {
            Separator = ",",
            Input = example.Apply(getRecordsResult => getRecordsResult.Records).Select(__item => __item.Value).ToList(),
        }).Apply(invoke => invoke.Result),
    };
});

package main
import (
	"github.com/pulumi/pulumi-digitalocean/sdk/v4/go/digitalocean"
	"github.com/pulumi/pulumi-std/sdk/go/std"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
example, err := digitalocean.GetRecords(ctx, &digitalocean.GetRecordsArgs{
Domain: "example.com",
Filters: []digitalocean.GetRecordsFilter{
{
Key: "type",
Values: []string{
"MX",
},
},
},
}, nil);
if err != nil {
return err
}
ctx.Export("mailServers", pulumi.String(std.Join(ctx, &std.JoinArgs{
Separator: ",",
Input: %!v(PANIC=Format method: fatal: A failure has occurred: unlowered splat expression @ example.pp:11,17-41),
}, nil).Result))
return nil
})
}

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.digitalocean.DigitaloceanFunctions;
import com.pulumi.digitalocean.inputs.GetRecordsArgs;
import com.pulumi.std.StdFunctions;
import com.pulumi.std.inputs.JoinArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }
    public static void stack(Context ctx) {
        final var example = DigitaloceanFunctions.getRecords(GetRecordsArgs.builder()
            .domain("example.com")
            .filters(GetRecordsFilterArgs.builder()
                .key("type")
                .values("MX")
                .build())
            .build());
        ctx.export("mailServers", StdFunctions.join(JoinArgs.builder()
            .separator(",")
            .input(example.records().stream().map(element -> element.value()).collect(toList()))
            .build()).result());
    }
}