planetscale.BranchSafeMigrations

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

// Enable safe_migrations on default branch:
const example = new planetscale.Database("example", {
    organization: "example",
    defaultBranch: "main",
});
const main = new planetscale.BranchSafeMigrations("main", {
    organization: planetscale_branch.example.organization,
    database: planetscale_branch.example.database,
    branch: planetscale_branch.example.default_branch,
    enabled: true,
});
// Enable safe_migrations on a branch:
const stagingBranch = new planetscale.Branch("stagingBranch", {
    organization: planetscale_branch.example.organization,
    database: planetscale_branch.example.database,
    parentBranch: planetscale_branch.example.default_branch,
});
const stagingBranchSafeMigrations = new planetscale.BranchSafeMigrations("stagingBranchSafeMigrations", {
    database: example.name,
    organization: example.organization,
    branch: stagingBranch.name,
    enabled: true,
});

import pulumi
import pulumi_planetscale as planetscale

# Enable safe_migrations on default branch:
example = planetscale.Database("example",
    organization="example",
    default_branch="main")
main = planetscale.BranchSafeMigrations("main",
    organization=planetscale_branch["example"]["organization"],
    database=planetscale_branch["example"]["database"],
    branch=planetscale_branch["example"]["default_branch"],
    enabled=True)
# Enable safe_migrations on a branch:
staging_branch = planetscale.Branch("stagingBranch",
    organization=planetscale_branch["example"]["organization"],
    database=planetscale_branch["example"]["database"],
    parent_branch=planetscale_branch["example"]["default_branch"])
staging_branch_safe_migrations = planetscale.BranchSafeMigrations("stagingBranchSafeMigrations",
    database=example.name,
    organization=example.organization,
    branch=staging_branch.name,
    enabled=True)

package main

import (
	"github.com/pulumi/pulumi-terraform-provider/sdks/go/planetscale/planetscale"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Enable safe_migrations on default branch:
		example, err := planetscale.NewDatabase(ctx, "example", &planetscale.DatabaseArgs{
			Organization:  pulumi.String("example"),
			DefaultBranch: pulumi.String("main"),
		})
		if err != nil {
			return err
		}
		_, err = planetscale.NewBranchSafeMigrations(ctx, "main", &planetscale.BranchSafeMigrationsArgs{
			Organization: pulumi.Any(planetscale_branch.Example.Organization),
			Database:     pulumi.Any(planetscale_branch.Example.Database),
			Branch:       pulumi.Any(planetscale_branch.Example.Default_branch),
			Enabled:      pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		// Enable safe_migrations on a branch:
		stagingBranch, err := planetscale.NewBranch(ctx, "stagingBranch", &planetscale.BranchArgs{
			Organization: pulumi.Any(planetscale_branch.Example.Organization),
			Database:     pulumi.Any(planetscale_branch.Example.Database),
			ParentBranch: pulumi.Any(planetscale_branch.Example.Default_branch),
		})
		if err != nil {
			return err
		}
		_, err = planetscale.NewBranchSafeMigrations(ctx, "stagingBranchSafeMigrations", &planetscale.BranchSafeMigrationsArgs{
			Database:     example.Name,
			Organization: example.Organization,
			Branch:       stagingBranch.Name,
			Enabled:      pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Planetscale = Pulumi.Planetscale;

return await Deployment.RunAsync(() => 
{
    // Enable safe_migrations on default branch:
    var example = new Planetscale.Database("example", new()
    {
        Organization = "example",
        DefaultBranch = "main",
    });

    var main = new Planetscale.BranchSafeMigrations("main", new()
    {
        Organization = planetscale_branch.Example.Organization,
        Database = planetscale_branch.Example.Database,
        Branch = planetscale_branch.Example.Default_branch,
        Enabled = true,
    });

    // Enable safe_migrations on a branch:
    var stagingBranch = new Planetscale.Branch("stagingBranch", new()
    {
        Organization = planetscale_branch.Example.Organization,
        Database = planetscale_branch.Example.Database,
        ParentBranch = planetscale_branch.Example.Default_branch,
    });

    var stagingBranchSafeMigrations = new Planetscale.BranchSafeMigrations("stagingBranchSafeMigrations", new()
    {
        Database = example.Name,
        Organization = example.Organization,
        Branch = stagingBranch.Name,
        Enabled = true,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.planetscale.Database;
import com.pulumi.planetscale.DatabaseArgs;
import com.pulumi.planetscale.BranchSafeMigrations;
import com.pulumi.planetscale.BranchSafeMigrationsArgs;
import com.pulumi.planetscale.Branch;
import com.pulumi.planetscale.BranchArgs;
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) {
        // Enable safe_migrations on default branch:
        var example = new Database("example", DatabaseArgs.builder()
            .organization("example")
            .defaultBranch("main")
            .build());

        var main = new BranchSafeMigrations("main", BranchSafeMigrationsArgs.builder()
            .organization(planetscale_branch.example().organization())
            .database(planetscale_branch.example().database())
            .branch(planetscale_branch.example().default_branch())
            .enabled(true)
            .build());

        // Enable safe_migrations on a branch:
        var stagingBranch = new Branch("stagingBranch", BranchArgs.builder()
            .organization(planetscale_branch.example().organization())
            .database(planetscale_branch.example().database())
            .parentBranch(planetscale_branch.example().default_branch())
            .build());

        var stagingBranchSafeMigrations = new BranchSafeMigrations("stagingBranchSafeMigrations", BranchSafeMigrationsArgs.builder()
            .database(example.name())
            .organization(example.organization())
            .branch(stagingBranch.name())
            .enabled(true)
            .build());

    }
}

resources:
  # Enable safe_migrations on default branch:
  example:
    type: planetscale:Database
    properties:
      organization: example
      defaultBranch: main
  main:
    type: planetscale:BranchSafeMigrations
    properties:
      organization: ${planetscale_branch.example.organization}
      database: ${planetscale_branch.example.database}
      branch: ${planetscale_branch.example.default_branch}
      enabled: true
  # Enable safe_migrations on a branch:
  stagingBranch:
    type: planetscale:Branch
    properties:
      organization: ${planetscale_branch.example.organization}
      database: ${planetscale_branch.example.database}
      parentBranch: ${planetscale_branch.example.default_branch}
  stagingBranchSafeMigrations:
    type: planetscale:BranchSafeMigrations
    properties:
      database: ${example.name}
      organization: ${example.organization}
      branch: ${stagingBranch.name}
      enabled: true

var branchSafeMigrationsResource = new Planetscale.BranchSafeMigrations("branchSafeMigrationsResource", new()
{
    Branch = "string",
    Database = "string",
    Enabled = false,
    Organization = "string",
});

example, err := planetscale.NewBranchSafeMigrations(ctx, "branchSafeMigrationsResource", &planetscale.BranchSafeMigrationsArgs{
	Branch:       pulumi.String("string"),
	Database:     pulumi.String("string"),
	Enabled:      pulumi.Bool(false),
	Organization: pulumi.String("string"),
})

var branchSafeMigrationsResource = new BranchSafeMigrations("branchSafeMigrationsResource", BranchSafeMigrationsArgs.builder()
    .branch("string")
    .database("string")
    .enabled(false)
    .organization("string")
    .build());

branch_safe_migrations_resource = planetscale.BranchSafeMigrations("branchSafeMigrationsResource",
    branch="string",
    database="string",
    enabled=False,
    organization="string")

const branchSafeMigrationsResource = new planetscale.BranchSafeMigrations("branchSafeMigrationsResource", {
    branch: "string",
    database: "string",
    enabled: false,
    organization: "string",
});

type: planetscale:BranchSafeMigrations
properties:
    branch: string
    database: string
    enabled: false
    organization: string