getProjectIssue

GitLab v9.10.0, Mar 9 26

Viewing docs for GitLab v9.10.0
published on Monday, Mar 9, 2026 by Pulumi

Schema (JSON)

pulumi/pulumi-gitlab

Viewing docs for GitLab v9.10.0
published on Monday, Mar 9, 2026 by Pulumi

Schema (JSON)

pulumi/pulumi-gitlab

Example Usage

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

const foo = gitlab.getProject({
    pathWithNamespace: "foo/bar/baz",
});
const welcomeIssue = foo.then(foo => gitlab.getProjectIssue({
    project: foo.id,
    iid: 1,
}));
export const welcomeIssueWebUrl = webUrl;

import pulumi
import pulumi_gitlab as gitlab

foo = gitlab.get_project(path_with_namespace="foo/bar/baz")
welcome_issue = gitlab.get_project_issue(project=foo.id,
    iid=1)
pulumi.export("welcomeIssueWebUrl", web_url)

package main

import (
	"github.com/pulumi/pulumi-gitlab/sdk/v9/go/gitlab"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		foo, err := gitlab.LookupProject(ctx, &gitlab.LookupProjectArgs{
			PathWithNamespace: pulumi.StringRef("foo/bar/baz"),
		}, nil)
		if err != nil {
			return err
		}
		_, err = gitlab.LookupProjectIssue(ctx, &gitlab.LookupProjectIssueArgs{
			Project: foo.Id,
			Iid:     1,
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("welcomeIssueWebUrl", webUrl)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var foo = GitLab.GetProject.Invoke(new()
    {
        PathWithNamespace = "foo/bar/baz",
    });

    var welcomeIssue = GitLab.GetProjectIssue.Invoke(new()
    {
        Project = foo.Apply(getProjectResult => getProjectResult.Id),
        Iid = 1,
    });

    return new Dictionary<string, object?>
    {
        ["welcomeIssueWebUrl"] = webUrl,
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gitlab.GitlabFunctions;
import com.pulumi.gitlab.inputs.GetProjectArgs;
import com.pulumi.gitlab.inputs.GetProjectIssueArgs;
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 foo = GitlabFunctions.getProject(GetProjectArgs.builder()
            .pathWithNamespace("foo/bar/baz")
            .build());

        final var welcomeIssue = GitlabFunctions.getProjectIssue(GetProjectIssueArgs.builder()
            .project(foo.id())
            .iid(1)
            .build());

        ctx.export("welcomeIssueWebUrl", webUrl);
    }
}

variables:
  foo:
    fn::invoke:
      function: gitlab:getProject
      arguments:
        pathWithNamespace: foo/bar/baz
  welcomeIssue:
    fn::invoke:
      function: gitlab:getProjectIssue
      arguments:
        project: ${foo.id}
        iid: 1
outputs:
  welcomeIssueWebUrl: ${webUrl}

Using getProjectIssue

Two invocation forms are available. The direct form accepts plain arguments and either blocks until the result value is available, or returns a Promise-wrapped result. The output form accepts Input-wrapped arguments and returns an Output-wrapped result.

function getProjectIssue(args: GetProjectIssueArgs, opts?: InvokeOptions): Promise<GetProjectIssueResult>
function getProjectIssueOutput(args: GetProjectIssueOutputArgs, opts?: InvokeOptions): Output<GetProjectIssueResult>

def get_project_issue(iid: Optional[int] = None,
                      project: Optional[str] = None,
                      opts: Optional[InvokeOptions] = None) -> GetProjectIssueResult
def get_project_issue_output(iid: Optional[pulumi.Input[int]] = None,
                      project: Optional[pulumi.Input[str]] = None,
                      opts: Optional[InvokeOptions] = None) -> Output[GetProjectIssueResult]

func LookupProjectIssue(ctx *Context, args *LookupProjectIssueArgs, opts ...InvokeOption) (*LookupProjectIssueResult, error)
func LookupProjectIssueOutput(ctx *Context, args *LookupProjectIssueOutputArgs, opts ...InvokeOption) LookupProjectIssueResultOutput

> Note: This function is named LookupProjectIssue in the Go SDK.

public static class GetProjectIssue 
{
    public static Task<GetProjectIssueResult> InvokeAsync(GetProjectIssueArgs args, InvokeOptions? opts = null)
    public static Output<GetProjectIssueResult> Invoke(GetProjectIssueInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetProjectIssueResult> getProjectIssue(GetProjectIssueArgs args, InvokeOptions options)
public static Output<GetProjectIssueResult> getProjectIssue(GetProjectIssueArgs args, InvokeOptions options)

fn::invoke:
  function: gitlab:index/getProjectIssue:getProjectIssue
  arguments:
    # arguments dictionary

The following arguments are supported:

Iid int: The internal ID of the project's issue.
Project string: The name or ID of the project.

Iid int: The internal ID of the project's issue.
Project string: The name or ID of the project.

iid Integer: The internal ID of the project's issue.
project String: The name or ID of the project.

iid number: The internal ID of the project's issue.
project string: The name or ID of the project.

iid int: The internal ID of the project's issue.
project str: The name or ID of the project.

iid Number: The internal ID of the project's issue.
project String: The name or ID of the project.