vercel.getFile

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

// In this example, we are assuming that a single index.html file
// is being deployed. This file lives directly next to the terraform file.
const example = vercel.getFile({
    path: "index.html",
});
const exampleGetProject = vercel.getProject({
    name: "my-project",
});
const exampleDeployment = new vercel.Deployment("example", {
    projectId: exampleGetProject.then(exampleGetProject => exampleGetProject.id),
    files: example.then(example => example.file),
});

import pulumi
import pulumi_vercel as vercel
import pulumiverse_vercel as vercel

# In this example, we are assuming that a single index.html file
# is being deployed. This file lives directly next to the terraform file.
example = vercel.get_file(path="index.html")
example_get_project = vercel.get_project(name="my-project")
example_deployment = vercel.Deployment("example",
    project_id=example_get_project.id,
    files=example.file)

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumiverse/pulumi-vercel/sdk/v3/go/vercel"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// In this example, we are assuming that a single index.html file
		// is being deployed. This file lives directly next to the terraform file.
		example, err := vercel.GetFile(ctx, &vercel.GetFileArgs{
			Path: "index.html",
		}, nil)
		if err != nil {
			return err
		}
		exampleGetProject, err := vercel.LookupProject(ctx, &vercel.LookupProjectArgs{
			Name: "my-project",
		}, nil)
		if err != nil {
			return err
		}
		_, err = vercel.NewDeployment(ctx, "example", &vercel.DeploymentArgs{
			ProjectId: pulumi.String(exampleGetProject.Id),
			Files:     pulumi.StringMap(example.File),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Vercel = Pulumi.Vercel;
using Vercel = Pulumiverse.Vercel;

return await Deployment.RunAsync(() => 
{
    // In this example, we are assuming that a single index.html file
    // is being deployed. This file lives directly next to the terraform file.
    var example = Vercel.GetFile.Invoke(new()
    {
        Path = "index.html",
    });

    var exampleGetProject = Vercel.GetProject.Invoke(new()
    {
        Name = "my-project",
    });

    var exampleDeployment = new Vercel.Deployment("example", new()
    {
        ProjectId = exampleGetProject.Apply(getProjectResult => getProjectResult.Id),
        Files = example.Apply(getFileResult => getFileResult.File),
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.vercel.VercelFunctions;
import com.pulumi.vercel.inputs.GetFileArgs;
import com.pulumi.vercel.inputs.GetProjectArgs;
import com.pulumi.vercel.Deployment;
import com.pulumi.vercel.DeploymentArgs;
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) {
        // In this example, we are assuming that a single index.html file
        // is being deployed. This file lives directly next to the terraform file.
        final var example = VercelFunctions.getFile(GetFileArgs.builder()
            .path("index.html")
            .build());

        final var exampleGetProject = VercelFunctions.getProject(GetProjectArgs.builder()
            .name("my-project")
            .build());

        var exampleDeployment = new Deployment("exampleDeployment", DeploymentArgs.builder()
            .projectId(exampleGetProject.applyValue(getProjectResult -> getProjectResult.id()))
            .files(example.applyValue(getFileResult -> getFileResult.file()))
            .build());

    }
}

resources:
  exampleDeployment:
    type: vercel:Deployment
    name: example
    properties:
      projectId: ${exampleGetProject.id}
      files: ${example.file}
variables:
  # In this example, we are assuming that a single index.html file
  # is being deployed. This file lives directly next to the terraform file.
  example:
    fn::invoke:
      Function: vercel:getFile
      Arguments:
        path: index.html
  exampleGetProject:
    fn::invoke:
      Function: vercel:getProject
      Arguments:
        name: my-project

function getFile(args: GetFileArgs, opts?: InvokeOptions): Promise<GetFileResult>
function getFileOutput(args: GetFileOutputArgs, opts?: InvokeOptions): Output<GetFileResult>

def get_file(path: Optional[str] = None,
             opts: Optional[InvokeOptions] = None) -> GetFileResult
def get_file_output(path: Optional[pulumi.Input[str]] = None,
             opts: Optional[InvokeOptions] = None) -> Output[GetFileResult]

func GetFile(ctx *Context, args *GetFileArgs, opts ...InvokeOption) (*GetFileResult, error)
func GetFileOutput(ctx *Context, args *GetFileOutputArgs, opts ...InvokeOption) GetFileResultOutput

public static class GetFile 
{
    public static Task<GetFileResult> InvokeAsync(GetFileArgs args, InvokeOptions? opts = null)
    public static Output<GetFileResult> Invoke(GetFileInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetFileResult> getFile(GetFileArgs args, InvokeOptions options)
public static Output<GetFileResult> getFile(GetFileArgs args, InvokeOptions options)

fn::invoke:
  function: vercel:index/getFile:getFile
  arguments:
    # arguments dictionary