githubintegration

package
v0.0.40 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Oct 26, 2025 License: Apache-2.0 Imports: 12 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	// File Actions
	GithubActionType_CreateFile domain.IntegrationActionType = "github_create_file"
	GithubActionType_DeleteFile domain.IntegrationActionType = "github_delete_file"
	GithubActionType_EditFile   domain.IntegrationActionType = "github_edit_file"
	GithubActionType_GetFile    domain.IntegrationActionType = "github_get_file"
	GithubActionType_ListFiles  domain.IntegrationActionType = "github_list_files"

	// Organization Actions
	GithubActionType_OrgGetRepositories domain.IntegrationActionType = "github_org_get_repositories"

	// Release Actions
	GithubActionType_CreateRelease domain.IntegrationActionType = "github_create_release"
	GithubActionType_DeleteRelease domain.IntegrationActionType = "github_delete_release"
	GithubActionType_GetRelease    domain.IntegrationActionType = "github_get_release"
	GithubActionType_ListReleases  domain.IntegrationActionType = "github_list_releases"
	GithubActionType_UpdateRelease domain.IntegrationActionType = "github_update_release"

	// Repository Actions
	GithubActionType_GetRepository           domain.IntegrationActionType = "github_get_repository"
	GithubActionType_GetRepositoryIssues     domain.IntegrationActionType = "github_get_repository_issues"
	GithubActionType_GetRepositoryLicense    domain.IntegrationActionType = "github_get_repository_license"
	GithubActionType_GetRepositoryProfile    domain.IntegrationActionType = "github_get_repository_profile"
	GithubActionType_GetRepositoryPRs        domain.IntegrationActionType = "github_get_repository_prs"
	GithubActionType_ListPopularPaths        domain.IntegrationActionType = "github_list_popular_paths"
	GithubActionType_ListRepositoryReferrers domain.IntegrationActionType = "github_list_repository_referrers"

	// Review Actions
	GithubActionType_CreateReview domain.IntegrationActionType = "github_create_review"
	GithubActionType_GetReview    domain.IntegrationActionType = "github_get_review"
	GithubActionType_ListReviews  domain.IntegrationActionType = "github_list_reviews"
	GithubActionType_UpdateReview domain.IntegrationActionType = "github_update_review"

	// User Actions
	GithubActionType_UserGetRepositories domain.IntegrationActionType = "github_user_get_repositories"
	GithubActionType_UserInvite          domain.IntegrationActionType = "github_user_invite"

	// Issue Actions
	GithubActionType_CreateIssue        domain.IntegrationActionType = "github_create_issue"
	GithubActionType_CreateIssueComment domain.IntegrationActionType = "github_create_issue_comment"
	GithubActionType_EditIssue          domain.IntegrationActionType = "github_edit_issue"
	GithubActionType_GetIssue           domain.IntegrationActionType = "github_get_issue"
	GithubActionType_LockIssue          domain.IntegrationActionType = "github_lock_issue"

	// Peekable Types
	GithubPeekable_Repositories domain.IntegrationPeekableType = "github_repositories"
	GithubPeekable_Users        domain.IntegrationPeekableType = "github_users"
	GithubPeekable_Branches     domain.IntegrationPeekableType = "github_branches"
)

Variables

View Source 
var (
	IntegrationEventType_CheckRun                     domain.IntegrationTriggerEventType = "check_run"
	IntegrationEventType_CheckSuite                   domain.IntegrationTriggerEventType = "check_suite"
	IntegrationEventType_CommitComment                domain.IntegrationTriggerEventType = "commit_comment"
	IntegrationEventType_Create                       domain.IntegrationTriggerEventType = "create"
	IntegrationEventType_Delete                       domain.IntegrationTriggerEventType = "delete"
	IntegrationEventType_DeployKey                    domain.IntegrationTriggerEventType = "deploy_key"
	IntegrationEventType_Deployment                   domain.IntegrationTriggerEventType = "deployment"
	IntegrationEventType_DeploymentStatus             domain.IntegrationTriggerEventType = "deployment_status"
	IntegrationEventType_Fork                         domain.IntegrationTriggerEventType = "fork"
	IntegrationEventType_AppAuthorization             domain.IntegrationTriggerEventType = "github_app_authorization" // Matches GitHub's name
	IntegrationEventType_Gollum                       domain.IntegrationTriggerEventType = "gollum"
	IntegrationEventType_Installation                 domain.IntegrationTriggerEventType = "installation"
	IntegrationEventType_InstallationRepositories     domain.IntegrationTriggerEventType = "installation_repositories"
	IntegrationEventType_IssueComment                 domain.IntegrationTriggerEventType = "issue_comment"
	IntegrationEventType_Issues                       domain.IntegrationTriggerEventType = "issues"
	IntegrationEventType_Label                        domain.IntegrationTriggerEventType = "label"
	IntegrationEventType_MarketplacePurchase          domain.IntegrationTriggerEventType = "marketplace_purchase"
	IntegrationEventType_Member                       domain.IntegrationTriggerEventType = "member"
	IntegrationEventType_Membership                   domain.IntegrationTriggerEventType = "membership"
	IntegrationEventType_Meta                         domain.IntegrationTriggerEventType = "meta"
	IntegrationEventType_Milestone                    domain.IntegrationTriggerEventType = "milestone"
	IntegrationEventType_OrgBlock                     domain.IntegrationTriggerEventType = "org_block"
	IntegrationEventType_Organization                 domain.IntegrationTriggerEventType = "organization"
	IntegrationEventType_PageBuild                    domain.IntegrationTriggerEventType = "page_build"
	IntegrationEventType_Project                      domain.IntegrationTriggerEventType = "project"
	IntegrationEventType_ProjectCard                  domain.IntegrationTriggerEventType = "project_card"
	IntegrationEventType_ProjectColumn                domain.IntegrationTriggerEventType = "project_column"
	IntegrationEventType_Public                       domain.IntegrationTriggerEventType = "public"
	IntegrationEventType_PullRequest                  domain.IntegrationTriggerEventType = "pull_request"
	IntegrationEventType_PullRequestReview            domain.IntegrationTriggerEventType = "pull_request_review"
	IntegrationEventType_PullRequestReviewComment     domain.IntegrationTriggerEventType = "pull_request_review_comment"
	IntegrationEventType_Push                         domain.IntegrationTriggerEventType = "push"
	IntegrationEventType_Release                      domain.IntegrationTriggerEventType = "release"
	IntegrationEventType_Repository                   domain.IntegrationTriggerEventType = "repository"
	IntegrationEventType_RepositoryImport             domain.IntegrationTriggerEventType = "repository_import"
	IntegrationEventType_RepositoryVulnerabilityAlert domain.IntegrationTriggerEventType = "repository_vulnerability_alert"
	IntegrationEventType_SecurityAdvisory             domain.IntegrationTriggerEventType = "security_advisory"
	IntegrationEventType_Star                         domain.IntegrationTriggerEventType = "star"
	IntegrationEventType_Status                       domain.IntegrationTriggerEventType = "status"
	IntegrationEventType_Team                         domain.IntegrationTriggerEventType = "team"
	IntegrationEventType_TeamAdd                      domain.IntegrationTriggerEventType = "team_add"
	IntegrationEventType_Watch                        domain.IntegrationTriggerEventType = "watch"

	// Consolidated trigger type (remains as is, specific to FlowBaker)
	IntegrationEventType_GithubUniversalTrigger domain.IntegrationTriggerEventType = "github_universal_trigger"
)
View Source 
var (
	GithubSchema = domain.Integration{
		ID:                domain.IntegrationType_Github,
		Name:              "GitHub",
		Description:       "Manage GitHub repositories, issues, and pull requests.",
		CanTestConnection: true,
		CredentialProperties: []domain.NodeProperty{
			{
				Key:         "github_oauth",
				Name:        "GitHub Account",
				Description: "The GitHub account to use for the integration",
				Required:    false,
				Type:        domain.NodePropertyType_OAuth,
				OAuthType:   domain.OAuthTypeGitHub,
			},
		},
		Actions: []domain.IntegrationAction{

			{
				ID:          "create_issue",
				Name:        "Create Issue",
				Description: "Create an issue in a GitHub repository",
				ActionType:  GithubActionType_CreateIssue,
				Properties: []domain.NodeProperty{
					{
						Key:          "repository_id",
						Name:         "Repository",
						Description:  "The repository to create the issue in (e.g., 'owner/repo')",
						Required:     true,
						Type:         domain.NodePropertyType_String,
						Peekable:     true,
						PeekableType: GithubPeekable_Repositories,
					},
					{
						Key:         "title",
						Name:        "Title",
						Description: "The title of the issue",
						Required:    true,
						Type:        domain.NodePropertyType_String,
					},
					{
						Key:         "body",
						Name:        "Body",
						Description: "The body of the issue",
						Required:    false,
						Type:        domain.NodePropertyType_Text,
					},
					{
						Key:          "assignee",
						Name:         "Assignee",
						Description:  "Login of the user to assign the issue to",
						Required:     false,
						Type:         domain.NodePropertyType_String,
						Peekable:     true,
						PeekableType: GithubPeekable_Users,
					},
					{
						Key:         "labels",
						Name:        "Labels",
						Description: "List of label names to apply to the issue. Stored as a JSON array of strings.",
						Required:    false,
						Type:        domain.NodePropertyType_TagInput,
					},
				},
			},
			{
				ID:          "get_issue",
				Name:        "Get Issue",
				Description: "Get an issue from a GitHub repository",
				ActionType:  GithubActionType_GetIssue,
				Properties: []domain.NodeProperty{
					{
						Key:          "repository_id",
						Name:         "Repository",
						Description:  "The repository to get the issue from (e.g., 'owner/repo')",
						Required:     true,
						Type:         domain.NodePropertyType_String,
						Peekable:     true,
						PeekableType: GithubPeekable_Repositories,
					},
					{
						Key:         "issue_number",
						Name:        "Issue Number",
						Description: "The number of the issue to get",
						Required:    true,
						Type:        domain.NodePropertyType_Integer,
					},
				},
			},
			{
				ID:          "create_issue_comment",
				Name:        "Create Issue Comment",
				Description: "Create a comment on an issue",
				ActionType:  GithubActionType_CreateIssueComment,
				Properties: []domain.NodeProperty{
					{
						Key:          "repository_id",
						Name:         "Repository",
						Description:  "The repository containing the issue (e.g., 'owner/repo')",
						Required:     true,
						Type:         domain.NodePropertyType_String,
						Peekable:     true,
						PeekableType: GithubPeekable_Repositories,
					},
					{
						Key:         "issue_number",
						Name:        "Issue Number",
						Description: "The number of the issue to comment on",
						Required:    true,
						Type:        domain.NodePropertyType_Integer,
					},
					{
						Key:         "body",
						Name:        "Body",
						Description: "The content of the comment",
						Required:    true,
						Type:        domain.NodePropertyType_Text,
					},
				},
			},
			{
				ID:          "edit_issue",
				Name:        "Edit Issue",
				Description: "Edit an existing issue",
				ActionType:  GithubActionType_EditIssue,
				Properties: []domain.NodeProperty{
					{
						Key:          "repository_id",
						Name:         "Repository",
						Description:  "The repository containing the issue (e.g., 'owner/repo')",
						Required:     true,
						Type:         domain.NodePropertyType_String,
						Peekable:     true,
						PeekableType: GithubPeekable_Repositories,
					},
					{
						Key:         "issue_number",
						Name:        "Issue Number",
						Description: "The number of the issue to edit",
						Required:    true,
						Type:        domain.NodePropertyType_Integer,
					},
					{
						Key:         "title",
						Name:        "Title",
						Description: "New title for the issue",
						Required:    false,
						Type:        domain.NodePropertyType_String,
					},
					{
						Key:         "body",
						Name:        "Body",
						Description: "New body for the issue",
						Required:    false,
						Type:        domain.NodePropertyType_Text,
					},
					{
						Key:         "state",
						Name:        "State",
						Description: "State of the issue ('open' or 'closed')",
						Required:    false,
						Type:        domain.NodePropertyType_String,
					},
					{
						Key:          "assignee",
						Name:         "Assignee",
						Description:  "Login of the user to assign. Use empty string to unassign single assignee.",
						Required:     false,
						Type:         domain.NodePropertyType_String,
						Peekable:     true,
						PeekableType: GithubPeekable_Users,
					},
					{
						Key:         "labels",
						Name:        "Labels",
						Description: "List of label names. Replaces all existing labels. Stored as a JSON array of strings.",
						Required:    false,
						Type:        domain.NodePropertyType_TagInput,
					},
				},
			},
			{
				ID:          "lock_issue",
				Name:        "Lock Issue",
				Description: "Lock an issue's conversation",
				ActionType:  GithubActionType_LockIssue,
				Properties: []domain.NodeProperty{
					{
						Key:          "repository_id",
						Name:         "Repository",
						Description:  "The repository containing the issue (e.g., 'owner/repo')",
						Required:     true,
						Type:         domain.NodePropertyType_String,
						Peekable:     true,
						PeekableType: GithubPeekable_Repositories,
					},
					{
						Key:         "issue_number",
						Name:        "Issue Number",
						Description: "The number of the issue to lock",
						Required:    true,
						Type:        domain.NodePropertyType_Integer,
					},
					{
						Key:         "lock_reason",
						Name:        "Lock Reason",
						Description: "Reason for locking ('off-topic', 'too heated', 'resolved', 'spam')",
						Required:    false,
						Type:        domain.NodePropertyType_String,
						Options: []domain.NodePropertyOption{
							{Label: "Off-topic", Value: "off-topic"},
							{Label: "Too heated", Value: "too heated"},
							{Label: "Resolved", Value: "resolved"},
							{Label: "Spam", Value: "spam"},
						},
					},
				},
			},

			{
				ID:          "create_file",
				Name:        "Create File",
				Description: "Create a new file in a repository",
				ActionType:  GithubActionType_CreateFile,
				Properties: []domain.NodeProperty{
					{
						Key:          "repository_id",
						Name:         "Repository",
						Description:  "The repository to create the file in (e.g., 'owner/repo')",
						Required:     true,
						Type:         domain.NodePropertyType_String,
						Peekable:     true,
						PeekableType: GithubPeekable_Repositories,
					},
					{
						Key:         "path",
						Name:        "File Path",
						Description: "The path to the file in the repository",
						Required:    true,
						Type:        domain.NodePropertyType_String,
					},
					{
						Key:         "message",
						Name:        "Commit Message",
						Description: "The commit message",
						Required:    true,
						Type:        domain.NodePropertyType_String,
					},
					{
						Key:         "content",
						Name:        "Content",
						Description: "The content of the file as plain text.",
						Required:    true,
						Type:        domain.NodePropertyType_Text,
					},
					{
						Key:          "branch",
						Name:         "Branch",
						Description:  "The branch name. Default: the repository's default branch.",
						Required:     false,
						Type:         domain.NodePropertyType_String,
						Peekable:     true,
						PeekableType: GithubPeekable_Branches,
						PeekableDependentProperties: []domain.PeekableDependentProperty{
							{
								PropertyKey: "repository_id",
								ValueKey:    "repository_id",
							},
						},
					},
				},
			},
			{
				ID:          "delete_file",
				Name:        "Delete File",
				Description: "Delete a file from a repository",
				ActionType:  GithubActionType_DeleteFile,
				Properties: []domain.NodeProperty{
					{
						Key:          "repository_id",
						Name:         "Repository",
						Description:  "The repository to delete the file from (e.g., 'owner/repo')",
						Required:     true,
						Type:         domain.NodePropertyType_String,
						Peekable:     true,
						PeekableType: GithubPeekable_Repositories,
					},
					{
						Key:         "path",
						Name:        "File Path",
						Description: "The path to the file in the repository",
						Required:    true,
						Type:        domain.NodePropertyType_String,
					},
					{
						Key:         "message",
						Name:        "Commit Message",
						Description: "The commit message",
						Required:    true,
						Type:        domain.NodePropertyType_String,
					},
					{
						Key:         "sha",
						Name:        "SHA",
						Description: "The blob SHA of the file to be deleted",
						Required:    true,
						Type:        domain.NodePropertyType_String,
					},
					{
						Key:          "branch",
						Name:         "Branch",
						Description:  "The branch name. Default: the repository's default branch.",
						Required:     false,
						Type:         domain.NodePropertyType_String,
						Peekable:     true,
						PeekableType: GithubPeekable_Branches,
						PeekableDependentProperties: []domain.PeekableDependentProperty{
							{
								PropertyKey: "repository_id",
								ValueKey:    "repository_id",
							},
						},
					},
				},
			},
			{
				ID:          "update_file",
				Name:        "Update File",
				Description: "Update an existing file in a repository",
				ActionType:  GithubActionType_EditFile,
				Properties: []domain.NodeProperty{
					{
						Key:          "repository_id",
						Name:         "Repository",
						Description:  "The repository where the file exists (e.g., 'owner/repo')",
						Required:     true,
						Type:         domain.NodePropertyType_String,
						Peekable:     true,
						PeekableType: GithubPeekable_Repositories,
					},
					{
						Key:         "path",
						Name:        "File Path",
						Description: "The path to the file in the repository",
						Required:    true,
						Type:        domain.NodePropertyType_String,
					},
					{
						Key:         "message",
						Name:        "Commit Message",
						Description: "The commit message",
						Required:    true,
						Type:        domain.NodePropertyType_String,
					},
					{
						Key:         "content",
						Name:        "Content",
						Description: "The new content of the file as plain text.",
						Required:    true,
						Type:        domain.NodePropertyType_Text,
					},
					{
						Key:         "sha",
						Name:        "SHA",
						Description: "The blob SHA of the file to be updated",
						Required:    true,
						Type:        domain.NodePropertyType_String,
					},
					{
						Key:          "branch",
						Name:         "Branch",
						Description:  "The branch name. Default: the repository's default branch.",
						Required:     false,
						Type:         domain.NodePropertyType_String,
						Peekable:     true,
						PeekableType: GithubPeekable_Branches,
						PeekableDependentProperties: []domain.PeekableDependentProperty{
							{
								PropertyKey: "repository_id",
								ValueKey:    "repository_id",
							},
						},
					},
				},
			},
			{
				ID:          "get_file",
				Name:        "Get File Content",
				Description: "Get the content of a file in a repository",
				ActionType:  GithubActionType_GetFile,
				Properties: []domain.NodeProperty{
					{
						Key:          "repository_id",
						Name:         "Repository",
						Description:  "The repository containing the file (e.g., 'owner/repo')",
						Required:     true,
						Type:         domain.NodePropertyType_String,
						Peekable:     true,
						PeekableType: GithubPeekable_Repositories,
					},
					{
						Key:         "path",
						Name:        "File Path",
						Description: "The path to the file in the repository",
						Required:    true,
						Type:        domain.NodePropertyType_String,
					},
					{
						Key:         "ref",
						Name:        "Reference",
						Description: "The name of the commit/branch/tag. Default: the repository's default branch.",
						Required:    false,
						Type:        domain.NodePropertyType_String,
					},
				},
			},
			{
				ID:          "list_repository_content",
				Name:        "List Repository Content",
				Description: "List content of a directory in a repository",
				ActionType:  GithubActionType_ListFiles,
				Properties: []domain.NodeProperty{
					{
						Key:          "repository_id",
						Name:         "Repository",
						Description:  "The repository to list content from (e.g., 'owner/repo')",
						Required:     true,
						Type:         domain.NodePropertyType_String,
						Peekable:     true,
						PeekableType: GithubPeekable_Repositories,
					},
					{
						Key:         "path",
						Name:        "Directory Path",
						Description: "The path to the directory. Default: root of the repository.",
						Required:    false,
						Type:        domain.NodePropertyType_String,
					},
					{
						Key:         "ref",
						Name:        "Reference",
						Description: "The name of the commit/branch/tag. Default: the repository's default branch.",
						Required:    false,
						Type:        domain.NodePropertyType_String,
					},
				},
			},

			{
				ID:          "org_get_repositories",
				Name:        "List Organization Repositories",
				Description: "List repositories for an organization",
				ActionType:  GithubActionType_OrgGetRepositories,
				Properties: []domain.NodeProperty{
					{
						Key:         "org",
						Name:        "Organization",
						Description: "The name of the GitHub organization",
						Required:    true,
						Type:        domain.NodePropertyType_String,
					},
					{
						Key:         "type",
						Name:        "Type",
						Description: "Type of repositories to list. Default: all",
						Required:    false,
						Type:        domain.NodePropertyType_String,
						Options: []domain.NodePropertyOption{
							{Label: "All", Value: "all"},
							{Label: "Public", Value: "public"},
							{Label: "Private", Value: "private"},
							{Label: "Forks", Value: "forks"},
							{Label: "Sources", Value: "sources"},
							{Label: "Member", Value: "member"},
						},
					},
					{
						Key:         "sort",
						Name:        "Sort By",
						Description: "Sort order. Default: created",
						Required:    false,
						Type:        domain.NodePropertyType_String,
						Options: []domain.NodePropertyOption{
							{Label: "Created", Value: "created"},
							{Label: "Updated", Value: "updated"},
							{Label: "Pushed", Value: "pushed"},
							{Label: "Full Name", Value: "full_name"},
						},
					},
					{
						Key:         "direction",
						Name:        "Direction",
						Description: "Direction of sort. Default: desc if sort is 'created', otherwise 'asc'",
						Required:    false,
						Type:        domain.NodePropertyType_String,
						Options: []domain.NodePropertyOption{
							{Label: "Ascending", Value: "asc"},
							{Label: "Descending", Value: "desc"},
						},
					},
					{
						Key:         "limit",
						Name:        "Limit",
						Description: "Maximum number of repositories to return (1-100). Default: 30",
						Required:    false,
						Type:        domain.NodePropertyType_Integer,
					},
					{
						Key:         "page",
						Name:        "Page",
						Description: "Page number of results to fetch. Default: 1",
						Required:    false,
						Type:        domain.NodePropertyType_Integer,
					},
				},
			},

			{
				ID:          "create_release",
				Name:        "Create Release",
				Description: "Create a new release for a repository",
				ActionType:  GithubActionType_CreateRelease,
				Properties: []domain.NodeProperty{
					{
						Key:          "repository_id",
						Name:         "Repository",
						Description:  "The repository to create the release in (e.g., 'owner/repo')",
						Required:     true,
						Type:         domain.NodePropertyType_String,
						Peekable:     true,
						PeekableType: GithubPeekable_Repositories,
					},
					{
						Key:         "tag_name",
						Name:        "Tag Name",
						Description: "The name of the tag for this release",
						Required:    true,
						Type:        domain.NodePropertyType_String,
					},
					{
						Key:         "target_commitish",
						Name:        "Target Commitish",
						Description: "Specifies the commitish value (branch or commit SHA) that the Git tag is created from. Defaults to the repository's default branch.",
						Required:    false,
						Type:        domain.NodePropertyType_String,
					},
					{
						Key:         "name",
						Name:        "Release Name",
						Description: "The name of the release",
						Required:    false,
						Type:        domain.NodePropertyType_String,
					},
					{
						Key:         "body",
						Name:        "Release Body",
						Description: "Text describing the contents of the release",
						Required:    false,
						Type:        domain.NodePropertyType_Text,
					},
					{
						Key:         "draft",
						Name:        "Draft",
						Description: "Set to true to create a draft (unpublished) release. Default: false",
						Required:    false,
						Type:        domain.NodePropertyType_Boolean,
					},
					{
						Key:         "prerelease",
						Name:        "Prerelease",
						Description: "Set to true to identify the release as a prerelease. Default: false",
						Required:    false,
						Type:        domain.NodePropertyType_Boolean,
					},
				},
			},
			{
				ID:          "delete_release",
				Name:        "Delete Release",
				Description: "Delete a release from a repository",
				ActionType:  GithubActionType_DeleteRelease,
				Properties: []domain.NodeProperty{
					{
						Key:          "repository_id",
						Name:         "Repository",
						Description:  "The repository containing the release (e.g., 'owner/repo')",
						Required:     true,
						Type:         domain.NodePropertyType_String,
						Peekable:     true,
						PeekableType: GithubPeekable_Repositories,
					},
					{
						Key:         "release_id",
						Name:        "Release ID",
						Description: "The unique identifier of the release to delete",
						Required:    true,
						Type:        domain.NodePropertyType_Integer,
					},
				},
			},
			{
				ID:          "get_release",
				Name:        "Get Release",
				Description: "Get a specific release from a repository by ID or tag name",
				ActionType:  GithubActionType_GetRelease,
				Properties: []domain.NodeProperty{
					{
						Key:          "repository_id",
						Name:         "Repository",
						Description:  "The repository containing the release (e.g., 'owner/repo')",
						Required:     true,
						Type:         domain.NodePropertyType_String,
						Peekable:     true,
						PeekableType: GithubPeekable_Repositories,
					},
					{
						Key:         "release_id",
						Name:        "Release Identifier",
						Description: "The unique numeric ID of the release (as a string), the literal string 'latest', or a tag in the format 'tags/YOUR_TAG_NAME'.",
						Required:    true,
						Type:        domain.NodePropertyType_String,
					},
				},
			},
			{
				ID:          "list_releases",
				Name:        "List Releases",
				Description: "List releases for a repository",
				ActionType:  GithubActionType_ListReleases,
				Properties: []domain.NodeProperty{
					{
						Key:          "repository_id",
						Name:         "Repository",
						Description:  "The repository to list releases from (e.g., 'owner/repo')",
						Required:     true,
						Type:         domain.NodePropertyType_String,
						Peekable:     true,
						PeekableType: GithubPeekable_Repositories,
					},
					{
						Key:         "limit",
						Name:        "Limit",
						Description: "Maximum number of releases to return (1-100). Default: 30",
						Required:    false,
						Type:        domain.NodePropertyType_Integer,
					},
					{
						Key:         "page",
						Name:        "Page",
						Description: "Page number of results to fetch. Default: 1",
						Required:    false,
						Type:        domain.NodePropertyType_Integer,
					},
				},
			},
			{
				ID:          "update_release",
				Name:        "Update Release",
				Description: "Update an existing release",
				ActionType:  GithubActionType_UpdateRelease,
				Properties: []domain.NodeProperty{
					{
						Key:          "repository_id",
						Name:         "Repository",
						Description:  "The repository containing the release (e.g., 'owner/repo')",
						Required:     true,
						Type:         domain.NodePropertyType_String,
						Peekable:     true,
						PeekableType: GithubPeekable_Repositories,
					},
					{
						Key:         "release_id",
						Name:        "Release ID",
						Description: "The unique identifier of the release to update",
						Required:    true,
						Type:        domain.NodePropertyType_Integer,
					},
					{
						Key:         "tag_name",
						Name:        "Tag Name",
						Description: "The name of the tag",
						Required:    false,
						Type:        domain.NodePropertyType_String,
					},
					{
						Key:         "target_commitish",
						Name:        "Target Commitish",
						Description: "Specifies the commitish value that determines where the Git tag is created from.",
						Required:    false,
						Type:        domain.NodePropertyType_String,
					},
					{
						Key:         "name",
						Name:        "Release Name",
						Description: "The name of the release",
						Required:    false,
						Type:        domain.NodePropertyType_String,
					},
					{
						Key:         "body",
						Name:        "Release Body",
						Description: "Text describing the contents of the release",
						Required:    false,
						Type:        domain.NodePropertyType_Text,
					},
					{
						Key:         "draft",
						Name:        "Draft",
						Description: "Set to true for a draft release",
						Required:    false,
						Type:        domain.NodePropertyType_Boolean,
					},
					{
						Key:         "prerelease",
						Name:        "Prerelease",
						Description: "Set to true for a prerelease",
						Required:    false,
						Type:        domain.NodePropertyType_Boolean,
					},
				},
			},

			{
				ID:          "get_repository",
				Name:        "Get Repository",
				Description: "Get details of a repository",
				ActionType:  GithubActionType_GetRepository,
				Properties: []domain.NodeProperty{
					{
						Key:          "repository_id",
						Name:         "Repository",
						Description:  "The repository to get details for (e.g., 'owner/repo')",
						Required:     true,
						Type:         domain.NodePropertyType_String,
						Peekable:     true,
						PeekableType: GithubPeekable_Repositories,
					},
				},
			},
			{
				ID:          "list_repository_issues",
				Name:        "List Repository Issues",
				Description: "List issues for a repository",
				ActionType:  GithubActionType_GetRepositoryIssues,
				Properties: []domain.NodeProperty{
					{
						Key:          "repository_id",
						Name:         "Repository",
						Description:  "The repository to list issues from (e.g., 'owner/repo')",
						Required:     true,
						Type:         domain.NodePropertyType_String,
						Peekable:     true,
						PeekableType: GithubPeekable_Repositories,
					},
					{
						Key:         "milestone",
						Name:        "Milestone",
						Description: "Filter by milestone number, '*' for any, or 'none' for no milestone. Default: *",
						Required:    false,
						Type:        domain.NodePropertyType_String,
					},
					{
						Key:         "state",
						Name:        "State",
						Description: "Filter by issue state. Default: all",
						Required:    false,
						Type:        domain.NodePropertyType_String,
						Options: []domain.NodePropertyOption{
							{Label: "Open", Value: "open"},
							{Label: "Closed", Value: "closed"},
							{Label: "All", Value: "all"},
						},
					},
					{
						Key:          "assignee",
						Name:         "Assignee",
						Description:  "Filter by assignee's login name. Use '*' for any, 'none' for no assignee",
						Required:     false,
						Type:         domain.NodePropertyType_String,
						Peekable:     true,
						PeekableType: GithubPeekable_Users,
					},
					{
						Key:          "creator",
						Name:         "Creator",
						Description:  "Filter by creator's login name",
						Required:     false,
						Type:         domain.NodePropertyType_String,
						Peekable:     true,
						PeekableType: GithubPeekable_Users,
					},
					{
						Key:          "mentioned",
						Name:         "Mentioned User",
						Description:  "Filter by login of a user mentioned in the issue.",
						Required:     false,
						Type:         domain.NodePropertyType_String,
						Peekable:     true,
						PeekableType: GithubPeekable_Users,
					},
					{
						Key:         "labels",
						Name:        "Labels",
						Description: "A list of label names to filter by. Stored as a JSON array of strings.",
						Required:    false,
						Type:        domain.NodePropertyType_TagInput,
					},
					{
						Key:         "sort",
						Name:        "Sort By",
						Description: "Sort results by. Default: created",
						Required:    false,
						Type:        domain.NodePropertyType_String,
						Options: []domain.NodePropertyOption{
							{Label: "Created", Value: "created"},
							{Label: "Updated", Value: "updated"},
							{Label: "Comments", Value: "comments"},
						},
					},
					{
						Key:         "direction",
						Name:        "Direction",
						Description: "Direction of sort. Default: desc",
						Required:    false,
						Type:        domain.NodePropertyType_String,
						Options: []domain.NodePropertyOption{
							{Label: "Ascending", Value: "asc"},
							{Label: "Descending", Value: "desc"},
						},
					},
					{
						Key:         "since",
						Name:        "Since",
						Description: "Timestamp (ISO 8601 YYYY-MM-DDTHH:MM:SSZ). Only issues updated at or after this time are returned.",
						Required:    false,
						Type:        domain.NodePropertyType_String,
					},
					{
						Key:         "limit",
						Name:        "Limit",
						Description: "Maximum number of issues to return (1-100). Default: 30",
						Required:    false,
						Type:        domain.NodePropertyType_Integer,
					},
					{
						Key:         "page",
						Name:        "Page",
						Description: "Page number of results to fetch. Default: 1",
						Required:    false,
						Type:        domain.NodePropertyType_Integer,
					},
				},
			},
			{
				ID:          "get_repository_license",
				Name:        "Get Repository License",
				Description: "Get the license for a repository",
				ActionType:  GithubActionType_GetRepositoryLicense,
				Properties: []domain.NodeProperty{
					{
						Key:          "repository_id",
						Name:         "Repository",
						Description:  "The repository to get the license from (e.g., 'owner/repo')",
						Required:     true,
						Type:         domain.NodePropertyType_String,
						Peekable:     true,
						PeekableType: GithubPeekable_Repositories,
					},
				},
			},
			{
				ID:          "get_repository_community_profile",
				Name:        "Get Repository Community Profile",
				Description: "Get community profile metrics for a repository",
				ActionType:  GithubActionType_GetRepositoryProfile,
				Properties: []domain.NodeProperty{
					{
						Key:          "repository_id",
						Name:         "Repository",
						Description:  "The repository to get community profile for (e.g., 'owner/repo')",
						Required:     true,
						Type:         domain.NodePropertyType_String,
						Peekable:     true,
						PeekableType: GithubPeekable_Repositories,
					},
				},
			},
			{
				ID:          "list_pull_requests",
				Name:        "List Pull Requests",
				Description: "List pull requests for a repository",
				ActionType:  GithubActionType_GetRepositoryPRs,
				Properties: []domain.NodeProperty{
					{
						Key:          "repository_id",
						Name:         "Repository",
						Description:  "The repository to list pull requests from (e.g., 'owner/repo')",
						Required:     true,
						Type:         domain.NodePropertyType_String,
						Peekable:     true,
						PeekableType: GithubPeekable_Repositories,
					},
					{
						Key:         "state",
						Name:        "State",
						Description: "State of pull requests. Default: open",
						Required:    false,
						Type:        domain.NodePropertyType_String,
						Options: []domain.NodePropertyOption{
							{Label: "Open", Value: "open"},
							{Label: "Closed", Value: "closed"},
							{Label: "All", Value: "all"},
						},
					},
					{
						Key:         "head",
						Name:        "Head",
						Description: "Filter by head user and branch name ('user:ref-name').",
						Required:    false,
						Type:        domain.NodePropertyType_String,
					},
					{
						Key:         "base",
						Name:        "Base Branch",
						Description: "Filter by base branch name.",
						Required:    false,
						Type:        domain.NodePropertyType_String,
					},
					{
						Key:         "sort",
						Name:        "Sort By",
						Description: "Sort results by. Default: created",
						Required:    false,
						Type:        domain.NodePropertyType_String,
						Options: []domain.NodePropertyOption{
							{Label: "Created", Value: "created"},
							{Label: "Updated", Value: "updated"},
							{Label: "Popularity", Value: "popularity"},
							{Label: "Long-running", Value: "long-running"},
						},
					},
					{
						Key:         "direction",
						Name:        "Direction",
						Description: "Direction of sort. Default: desc",
						Required:    false,
						Type:        domain.NodePropertyType_String,
						Options: []domain.NodePropertyOption{
							{Label: "Ascending", Value: "asc"},
							{Label: "Descending", Value: "desc"},
						},
					},
					{
						Key:         "limit",
						Name:        "Limit",
						Description: "Maximum number of pull requests to return (1-100). Default: 30",
						Required:    false,
						Type:        domain.NodePropertyType_Integer,
					},
					{
						Key:         "page",
						Name:        "Page",
						Description: "Page number of results to fetch. Default: 1",
						Required:    false,
						Type:        domain.NodePropertyType_Integer,
					},
				},
			},
			{
				ID:          "get_top_referral_paths",
				Name:        "Get Top Referral Paths",
				Description: "Get the top 10 popular content paths for a repository (last 14 days).",
				ActionType:  GithubActionType_ListPopularPaths,
				Properties: []domain.NodeProperty{
					{
						Key:          "repository_id",
						Name:         "Repository",
						Description:  "The repository to get top paths for (e.g., 'owner/repo')",
						Required:     true,
						Type:         domain.NodePropertyType_String,
						Peekable:     true,
						PeekableType: GithubPeekable_Repositories,
					},
				},
			},
			{
				ID:          "get_top_referral_sources",
				Name:        "Get Top Referral Sources",
				Description: "Get the top 10 referral sources for a repository (last 14 days).",
				ActionType:  GithubActionType_ListRepositoryReferrers,
				Properties: []domain.NodeProperty{
					{
						Key:          "repository_id",
						Name:         "Repository",
						Description:  "The repository to get top sources for (e.g., 'owner/repo')",
						Required:     true,
						Type:         domain.NodePropertyType_String,
						Peekable:     true,
						PeekableType: GithubPeekable_Repositories,
					},
				},
			},

			{
				ID:          "create_pull_request_review",
				Name:        "Create Pull Request Review",
				Description: "Create a review for a pull request",
				ActionType:  GithubActionType_CreateReview,
				Properties: []domain.NodeProperty{
					{
						Key:          "repository_id",
						Name:         "Repository",
						Description:  "The repository containing the pull request (e.g., 'owner/repo')",
						Required:     true,
						Type:         domain.NodePropertyType_String,
						Peekable:     true,
						PeekableType: GithubPeekable_Repositories,
					},
					{
						Key:         "pull_number",
						Name:        "Pull Request Number",
						Description: "The number of the pull request",
						Required:    true,
						Type:        domain.NodePropertyType_String,
					},
					{
						Key:         "event",
						Name:        "Event",
						Description: "The review action. If 'COMMENT', body is required. If 'APPROVE' or 'REQUEST_CHANGES', body is optional.",
						Required:    false,
						Type:        domain.NodePropertyType_String,
						Options: []domain.NodePropertyOption{
							{Label: "Approve", Value: "APPROVE"},
							{Label: "Request Changes", Value: "REQUEST_CHANGES"},
							{Label: "Comment", Value: "COMMENT"},
						},
					},
					{
						Key:         "body",
						Name:        "Body",
						Description: "The body text of the review. Required if event is 'COMMENT'.",
						Required:    false,
						Type:        domain.NodePropertyType_Text,
					},
					{
						Key:         "commit_id",
						Name:        "Commit ID",
						Description: "The SHA of the commit to review. Defaults to the pull request's latest commit.",
						Required:    false,
						Type:        domain.NodePropertyType_String,
					},
				},
			},
			{
				ID:          "get_pull_request_review",
				Name:        "Get Pull Request Review",
				Description: "Get a specific review for a pull request",
				ActionType:  GithubActionType_GetReview,
				Properties: []domain.NodeProperty{
					{
						Key:          "repository_id",
						Name:         "Repository",
						Description:  "The repository containing the pull request (e.g., 'owner/repo')",
						Required:     true,
						Type:         domain.NodePropertyType_String,
						Peekable:     true,
						PeekableType: GithubPeekable_Repositories,
					},
					{
						Key:         "pull_number",
						Name:        "Pull Request Number",
						Description: "The number of the pull request",
						Required:    true,
						Type:        domain.NodePropertyType_Integer,
					},
					{
						Key:         "review_id",
						Name:        "Review ID",
						Description: "The unique identifier of the review",
						Required:    true,
						Type:        domain.NodePropertyType_String,
					},
				},
			},
			{
				ID:          "list_pull_request_reviews",
				Name:        "List Pull Request Reviews",
				Description: "List reviews for a pull request",
				ActionType:  GithubActionType_ListReviews,
				Properties: []domain.NodeProperty{
					{
						Key:          "repository_id",
						Name:         "Repository",
						Description:  "The repository containing the pull request (e.g., 'owner/repo')",
						Required:     true,
						Type:         domain.NodePropertyType_String,
						Peekable:     true,
						PeekableType: GithubPeekable_Repositories,
					},
					{
						Key:         "pull_number",
						Name:        "Pull Request Number",
						Description: "The number of the pull request",
						Required:    true,
						Type:        domain.NodePropertyType_Integer,
					},
					{
						Key:         "limit",
						Name:        "Limit",
						Description: "Maximum number of reviews to return (1-100). Default: 30",
						Required:    false,
						Type:        domain.NodePropertyType_Integer,
					},
					{
						Key:         "page",
						Name:        "Page",
						Description: "Page number of results to fetch. Default: 1",
						Required:    false,
						Type:        domain.NodePropertyType_Integer,
					},
				},
			},
			{
				ID:          "update_pull_request_review",
				Name:        "Update Pull Request Review",
				Description: "Update the body of an existing review for a pull request",
				ActionType:  GithubActionType_UpdateReview,
				Properties: []domain.NodeProperty{
					{
						Key:          "repository_id",
						Name:         "Repository",
						Description:  "The repository containing the pull request (e.g., 'owner/repo')",
						Required:     true,
						Type:         domain.NodePropertyType_String,
						Peekable:     true,
						PeekableType: GithubPeekable_Repositories,
					},
					{
						Key:         "pull_number",
						Name:        "Pull Request Number",
						Description: "The number of the pull request",
						Required:    true,
						Type:        domain.NodePropertyType_Integer,
					},
					{
						Key:         "review_id",
						Name:        "Review ID",
						Description: "The unique identifier of the review to update",
						Required:    true,
						Type:        domain.NodePropertyType_Integer,
					},
					{
						Key:         "body",
						Name:        "Body",
						Description: "The new body text of the review",
						Required:    true,
						Type:        domain.NodePropertyType_Text,
					},
				},
			},

			{
				ID:          "list_authenticated_user_repositories",
				Name:        "List Authenticated User Repositories",
				Description: "List repositories for the authenticated user",
				ActionType:  GithubActionType_UserGetRepositories,
				Properties: []domain.NodeProperty{
					{
						Key:         "visibility",
						Name:        "Visibility",
						Description: "Repository visibility. Default: all",
						Required:    false,
						Type:        domain.NodePropertyType_String,
						Options: []domain.NodePropertyOption{
							{Label: "All", Value: "all"},
							{Label: "Public", Value: "public"},
							{Label: "Private", Value: "private"},
						},
					},
					{
						Key:         "affiliation",
						Name:        "Affiliation",
						Description: "Comma-separated: owner, collaborator, organization_member. Default: all three.",
						Required:    false,
						Type:        domain.NodePropertyType_String,
					},
					{
						Key:         "type",
						Name:        "Type",
						Description: "Repository type. Default: all. Avoid using with visibility or affiliation.",
						Required:    false,
						Type:        domain.NodePropertyType_String,
						Options: []domain.NodePropertyOption{
							{Label: "All", Value: "all"},
							{Label: "Owner", Value: "owner"},
							{Label: "Public", Value: "public"},
							{Label: "Private", Value: "private"},
							{Label: "Member", Value: "member"},
						},
					},
					{
						Key:         "sort",
						Name:        "Sort By",
						Description: "Sort order. Default: full_name",
						Required:    false,
						Type:        domain.NodePropertyType_String,
						Options: []domain.NodePropertyOption{
							{Label: "Created", Value: "created"},
							{Label: "Updated", Value: "updated"},
							{Label: "Pushed", Value: "pushed"},
							{Label: "Full Name", Value: "full_name"},
						},
					},
					{
						Key:         "direction",
						Name:        "Direction",
						Description: "Direction of sort. Default: asc for full_name, else desc.",
						Required:    false,
						Type:        domain.NodePropertyType_String,
						Options: []domain.NodePropertyOption{
							{Label: "Ascending", Value: "asc"},
							{Label: "Descending", Value: "desc"},
						},
					},
					{
						Key:         "limit",
						Name:        "Limit",
						Description: "Maximum number of repositories to return (1-100). Default: 30",
						Required:    false,
						Type:        domain.NodePropertyType_Integer,
					},
					{
						Key:         "page",
						Name:        "Page",
						Description: "Page number of results to fetch. Default: 1",
						Required:    false,
						Type:        domain.NodePropertyType_Integer,
					},
				},
			},
			{
				ID:          "invite_user_to_repository",
				Name:        "Invite User to Repository",
				Description: "Invite a user to collaborate on a repository",
				ActionType:  GithubActionType_UserInvite,
				Properties: []domain.NodeProperty{
					{
						Key:          "repository_id",
						Name:         "Repository",
						Description:  "The repository to invite the user to (e.g., 'owner/repo')",
						Required:     true,
						Type:         domain.NodePropertyType_String,
						Peekable:     true,
						PeekableType: GithubPeekable_Repositories,
					},
					{
						Key:          "username",
						Name:         "Username",
						Description:  "The GitHub username of the user to invite",
						Required:     true,
						Type:         domain.NodePropertyType_String,
						Peekable:     true,
						PeekableType: GithubPeekable_Users,
					},
					{
						Key:         "permission",
						Name:        "Permission",
						Description: "Permission level. Default: push",
						Required:    false,
						Type:        domain.NodePropertyType_String,
						Options: []domain.NodePropertyOption{
							{Label: "Pull", Value: "pull"},
							{Label: "Push", Value: "push"},
							{Label: "Admin", Value: "admin"},
							{Label: "Maintain", Value: "maintain"},
							{Label: "Triage", Value: "triage"},
						},
					},
				},
			},
		},
		Triggers: []domain.IntegrationTrigger{
			{
				ID:          "github_event_listener",
				Name:        "GitHub Event Listener",
				Description: "Triggers on selected GitHub events for a repository or organization.",
				EventType:   IntegrationEventType_GithubUniversalTrigger,
				Properties: []domain.NodeProperty{
					{
						Key:          "repository_id",
						Name:         "Repository",
						Description:  "The repository to monitor (e.g., 'owner/repo'). If empty, listens to organization/app level events if applicable for selected event types.",
						Required:     true,
						Type:         domain.NodePropertyType_String,
						Peekable:     true,
						PeekableType: GithubPeekable_Repositories,
					},
					{
						Key:         "selected_events",
						Name:        "GitHub Events",
						Description: "Select one or more GitHub events to trigger this flow. The webhook URL for these events will be generated by FlowBaker.",
						Required:    true,
						Type:        domain.NodePropertyType_ListTagInput,
						Options: []domain.NodePropertyOption{
							{Label: "On Check Run", Value: string(IntegrationEventType_CheckRun), Description: "Triggered when a check run is created, reraised, completed, or has a requested_action."},
							{Label: "On Check Suite", Value: string(IntegrationEventType_CheckSuite), Description: "Triggered when a check suite is completed, requested, or rerequested."},
							{Label: "On Commit Comment Created", Value: string(IntegrationEventType_CommitComment), Description: "Triggered when a commit comment is created."},
							{Label: "On Create (Branch/Tag/Repo)", Value: string(IntegrationEventType_Create), Description: "Triggered when a Git branch or tag is created."},
							{Label: "On Delete (Branch/Tag)", Value: string(IntegrationEventType_Delete), Description: "Triggered when a Git branch or tag is deleted."},
							{Label: "On Deploy Key", Value: string(IntegrationEventType_DeployKey), Description: "Triggered when a deploy key is added or removed from a repository."},
							{Label: "On Deployment", Value: string(IntegrationEventType_Deployment), Description: "Triggered when a deployment is created."},
							{Label: "On Deployment Status", Value: string(IntegrationEventType_DeploymentStatus), Description: "Triggered when a deployment status is updated."},
							{Label: "On Fork Event", Value: string(IntegrationEventType_Fork), Description: "Triggered when a repository is forked."},
							{Label: "On GitHub App Authorization Revoked", Value: string(IntegrationEventType_AppAuthorization), Description: "Triggered when a GitHub App's authorization is revoked by a user."},
							{Label: "On Gollum Event (Wiki Updated)", Value: string(IntegrationEventType_Gollum), Description: "Triggered when a Wiki page is created or updated."},
							{Label: "On Installation", Value: string(IntegrationEventType_Installation), Description: "Triggered when a GitHub App is installed or uninstalled."},
							{Label: "On Installation Repositories", Value: string(IntegrationEventType_InstallationRepositories), Description: "Triggered when repositories are added to or removed from an installation."},
							{Label: "On Issue Comment", Value: string(IntegrationEventType_IssueComment), Description: "Triggered when an issue or pull request comment is created, edited, or deleted."},
							{Label: "On Issues", Value: string(IntegrationEventType_Issues), Description: "Triggered when an issue is opened, edited, deleted, transferred, pinned, unpinned, closed, reopened, assigned, unassigned, labeled, unlabeled, milestoned, or demilestoned."},
							{Label: "On Label", Value: string(IntegrationEventType_Label), Description: "Triggered when a label is created, edited, or deleted."},
							{Label: "On Marketplace Purchase", Value: string(IntegrationEventType_MarketplacePurchase), Description: "Triggered when a user purchases, cancels, or changes their GitHub Marketplace plan."},
							{Label: "On Member (Collaborator)", Value: string(IntegrationEventType_Member), Description: "Triggered when a user is added, removed, or has their permissions changed for a repository."},
							{Label: "On Membership (Team)", Value: string(IntegrationEventType_Membership), Description: "Triggered when a user is added or removed from a team."},
							{Label: "On Meta (Webhook Deleted)", Value: string(IntegrationEventType_Meta), Description: "Triggered when this webhook is deleted."},
							{Label: "On Milestone", Value: string(IntegrationEventType_Milestone), Description: "Triggered when a milestone is created, closed, opened, edited, or deleted."},
							{Label: "On Organization Block", Value: string(IntegrationEventType_OrgBlock), Description: "Triggered when an organization blocks or unblocks a user."},
							{Label: "On Organization", Value: string(IntegrationEventType_Organization), Description: "Triggered when an organization is deleted, renamed, or when a user is added, removed, or invited to an organization."},
							{Label: "On Page Build", Value: string(IntegrationEventType_PageBuild), Description: "Triggered on a successful or failed GitHub Pages build."},
							{Label: "On Project", Value: string(IntegrationEventType_Project), Description: "Triggered when a project is created, updated, closed, reopened, or deleted."},
							{Label: "On Project Card", Value: string(IntegrationEventType_ProjectCard), Description: "Triggered when a project card is created, edited, moved, converted, or deleted."},
							{Label: "On Project Column", Value: string(IntegrationEventType_ProjectColumn), Description: "Triggered when a project column is created, updated, moved, or deleted."},
							{Label: "On Public (Repo Open Sourced)", Value: string(IntegrationEventType_Public), Description: "Triggered when a private repository is made public."},
							{Label: "On Pull Request", Value: string(IntegrationEventType_PullRequest), Description: "Triggered when a pull request is opened, closed, reopened, edited, assigned, unassigned, review requested, review request removed, labeled, unlabeled, or synchronized."},
							{Label: "On Pull Request Review", Value: string(IntegrationEventType_PullRequestReview), Description: "Triggered when a pull request review is submitted, edited, or dismissed."},
							{Label: "On Pull Request Review Comment", Value: string(IntegrationEventType_PullRequestReviewComment), Description: "Triggered when a comment on a pull request's unified diff is created, edited, or deleted."},
							{Label: "On Push", Value: string(IntegrationEventType_Push), Description: "Triggered on a Git push to a repository."},
							{Label: "On Release", Value: string(IntegrationEventType_Release), Description: "Triggered when a release is published, unpublished, created, edited, deleted, or prereleased."},
							{Label: "On Repository", Value: string(IntegrationEventType_Repository), Description: "Triggered when a repository is created, deleted, archived, unarchived, made public, made private, or renamed."},
							{Label: "On Repository Import", Value: string(IntegrationEventType_RepositoryImport), Description: "Triggered when a repository import is successful, failed, or cancelled."},
							{Label: "On Repository Vulnerability Alert", Value: string(IntegrationEventType_RepositoryVulnerabilityAlert), Description: "Triggered when a security vulnerability is found or resolved in a repository."},
							{Label: "On Security Advisory", Value: string(IntegrationEventType_SecurityAdvisory), Description: "Triggered when a new security advisory is published, updated, or withdrawn."},
							{Label: "On Star", Value: string(IntegrationEventType_Star), Description: "Triggered when a repository is starred or unstarred."},
							{Label: "On Status (Commit)", Value: string(IntegrationEventType_Status), Description: "Triggered when the status of a Git commit changes."},
							{Label: "On Team", Value: string(IntegrationEventType_Team), Description: "Triggered when a team is created, deleted, edited, added to repository, or removed from repository."},
							{Label: "On Team Add (Repo to Team)", Value: string(IntegrationEventType_TeamAdd), Description: "Triggered when a repository is added to a team."},
							{Label: "On Watch (Legacy Star)", Value: string(IntegrationEventType_Watch), Description: "Triggered when a user stars a repository (legacy event)."},
						},
					},
				},
			},
		},
	}
)

Functions

func NewGitHubConnectionTester 

func NewGitHubConnectionTester(deps domain.IntegrationDeps) domain.IntegrationConnectionTester

func NewGithubIntegrationCreator 

func NewGithubIntegrationCreator(deps domain.IntegrationDeps) domain.IntegrationCreator

Types

type CreateFileParams 

type CreateFileParams struct {
	Owner   string  `json:"repository_id"`
	Repo    string  `json:"-"`
	Path    string  `json:"path"`
	Message string  `json:"message"`
	Content string  `json:"content"` // Plain text content
	Branch  *string `json:"branch,omitempty"`
	SHA     *string `json:"sha,omitempty"` // Required for UpdateFile (EditFile), optional for CreateFile
}

type CreateIssueCommentParams 

type CreateIssueCommentParams struct {
	Owner       string `json:"repository_id"`
	Repo        string `json:"-"`
	IssueNumber int    `json:"issue_number"`
	Body        string `json:"body"`
}

type CreateIssueParams 

type CreateIssueParams struct {
	Owner    string   `json:"repository_id"` // Assuming repository_id is in owner/repo format or just repo name if owner is implicit
	Repo     string   `json:"-"`             // Will be extracted from Owner if in owner/repo format
	Title    string   `json:"title"`
	Body     string   `json:"body,omitempty"`
	Assignee string   `json:"assignee,omitempty"` // Single assignee for simplicity, can be changed to []string
	Labels   []string `json:"labels,omitempty"`
}

type CreateReleaseParams 

type CreateReleaseParams struct {
	Owner                string  `json:"repository_id"`
	Repo                 string  `json:"-"`
	TagName              string  `json:"tag_name"`
	TargetCommitish      *string `json:"target_commitish,omitempty"`
	Name                 *string `json:"name,omitempty"`
	Body                 *string `json:"body,omitempty"`
	Draft                *bool   `json:"draft,omitempty"`
	Prerelease           *bool   `json:"prerelease,omitempty"`
	GenerateReleaseNotes *bool   `json:"generate_release_notes,omitempty"` // Supported in recent go-github versions
}

Release Action Params

type CreateReviewParams 

type CreateReviewParams struct {
	Owner      string                        `json:"repository_id"`
	Repo       string                        `json:"-"`
	PullNumber int                           `json:"pull_number"`
	CommitID   *string                       `json:"commit_id,omitempty"`
	Body       *string                       `json:"body,omitempty"`
	Event      *string                       `json:"event,omitempty"`    // APPROVE, REQUEST_CHANGES, or COMMENT
	Comments   *[]*github.DraftReviewComment `json:"comments,omitempty"` // For pending review comments
}

Review Action Params (Pull Request Reviews)

type DeleteFileParams 

type DeleteFileParams struct {
	Owner   string  `json:"repository_id"`
	Repo    string  `json:"-"`
	Path    string  `json:"path"`
	Message string  `json:"message"`
	SHA     string  `json:"sha"` // SHA of the file to delete
	Branch  *string `json:"branch,omitempty"`
}

type DeleteReleaseParams 

type DeleteReleaseParams struct {
	Owner     string `json:"repository_id"`
	Repo      string `json:"-"`
	ReleaseID int64  `json:"release_id"`
}

type EditIssueParams 

type EditIssueParams struct {
	Owner       string  `json:"repository_id"`
	Repo        string  `json:"-"`
	IssueNumber int     `json:"issue_number"`
	Title       *string `json:"title,omitempty"`
	Body        *string `json:"body,omitempty"`
	State       *string `json:"state,omitempty"`
	// For Assignees, the GitHub API uses a list.
	// If a single 'assignee' string is provided, it will be wrapped in a list.
	// If 'assignees' list is provided, it will be used directly.
	// To clear assignees, provide an empty list for 'assignees' or an empty string for 'assignee'.
	Assignee  *string   `json:"assignee,omitempty"`
	Assignees *[]string `json:"assignees,omitempty"`
	Labels    *[]string `json:"labels,omitempty"`    // To clear, provide an empty list
	Milestone *int      `json:"milestone,omitempty"` // To clear, provide null or omit. GitHub API might require explicit null or 0.
}

type GetFileParams 

type GetFileParams struct {
	Owner string  `json:"repository_id"`
	Repo  string  `json:"-"`
	Path  string  `json:"path"`
	Ref   *string `json:"ref,omitempty"` // Branch, tag, or commit SHA
}

type GetIssueParams 

type GetIssueParams struct {
	Owner       string `json:"repository_id"` // Assuming repository_id is in owner/repo format
	Repo        string `json:"-"`             // Will be extracted from Owner
	IssueNumber int    `json:"issue_number"`
}

type GetReleaseParams 

type GetReleaseParams struct {
	Owner     string `json:"repository_id"`
	Repo      string `json:"-"`
	ReleaseID string `json:"release_id"` // Can be int64 ID, "latest", or "tags/:tag_name"
}

type GetRepositoryIssuesParams 

type GetRepositoryIssuesParams struct {
	Owner     string    `json:"repository_id"`
	Repo      string    `json:"-"`
	Milestone *string   `json:"milestone,omitempty"` // Milestone number or "*" for any, "none" for no milestone
	State     *string   `json:"state,omitempty"`     // open, closed, all. Default: open
	Assignee  *string   `json:"assignee,omitempty"`  // User login, "*" for any, "none" for no assignee
	Creator   *string   `json:"creator,omitempty"`   // User login
	Mentioned *string   `json:"mentioned,omitempty"` // User login
	Labels    *[]string `json:"labels,omitempty"`    // List of label names to filter by.
	Sort      *string   `json:"sort,omitempty"`      // created, updated, comments. Default: created
	Direction *string   `json:"direction,omitempty"` // asc, desc. Default: desc
	Since     *string   `json:"since,omitempty"`     // ISO 8601 timestamp (YYYY-MM-DDTHH:MM:SSZ)
	Limit     *int      `json:"limit,omitempty"`     // Maximum number of issues to return (1-100). Default: 30
	Page      *int      `json:"page,omitempty"`      // Page number of results to fetch. Default: 1
}

type GetRepositoryLicenseParams 

type GetRepositoryLicenseParams struct {
	Owner string `json:"repository_id"`
	Repo  string `json:"-"`
}

type GetRepositoryPRsParams 

type GetRepositoryPRsParams struct {
	Owner     string  `json:"repository_id"`
	Repo      string  `json:"-"`
	State     *string `json:"state,omitempty"`     // open, closed, all. Default: open
	Head      *string `json:"head,omitempty"`      // Filter by head user:branch
	Base      *string `json:"base,omitempty"`      // Filter by base branch
	Sort      *string `json:"sort,omitempty"`      // created, updated, popularity, long-running. Default: created
	Direction *string `json:"direction,omitempty"` // asc, desc. Default: desc
	Limit     *int    `json:"limit,omitempty"`     // Maximum number of pull requests to return (1-100). Default: 30
	Page      *int    `json:"page,omitempty"`      // Page number of results to fetch. Default: 1
}

type GetRepositoryParams 

type GetRepositoryParams struct {
	Owner string `json:"repository_id"`
}

type GetReviewParams 

type GetReviewParams struct {
	Owner      string `json:"repository_id"`
	Repo       string `json:"-"`
	PullNumber int    `json:"pull_number"`
	ReviewID   int64  `json:"review_id"`
}

type GitHubConnectionTester 

type GitHubConnectionTester struct {
	// contains filtered or unexported fields
}

func (*GitHubConnectionTester) TestConnection 

func (c *GitHubConnectionTester) TestConnection(ctx context.Context, params domain.TestConnectionParams) (bool, error)

type GithubIntegration 

type GithubIntegration struct {
	// contains filtered or unexported fields
}

GithubIntegration implements the domain.IntegrationExecutor interface for GitHub. It handles the execution of specific actions (defined in schema.go) like creating issues, fetching files, etc., and provides data for UI elements via peek functions.

Note on Triggers: The triggering of flows based on GitHub events (e.g., push, issues) is primarily managed by FlowBaker's core event dispatching system. The `GithubSchema` in `schema.go` defines a universal trigger (`IntegrationEventType_GithubUniversalTrigger`) that allows users to select multiple GitHub event types. The dispatching system is responsible for:

  1. Receiving webhook events from GitHub.
  2. Matching these events against the `selected_events` configured for the universal trigger in a flow.
  3. Evaluating any `event_filters` specified in the trigger configuration.

This GithubIntegration's `Execute` method is called when an *action* within a flow is run, not directly for trigger event dispatch.

func NewGithubIntegration 

func NewGithubIntegration(ctx context.Context, deps GithubIntegrationDependencies) (*GithubIntegration, error)

func (*GithubIntegration) CreateFile 

func (i *GithubIntegration) CreateFile(ctx context.Context, input domain.IntegrationInput, item domain.Item) (domain.Item, error)

File Actions

func (*GithubIntegration) CreateIssue 

func (i *GithubIntegration) CreateIssue(ctx context.Context, input domain.IntegrationInput, item domain.Item) (domain.Item, error)

func (*GithubIntegration) CreateIssueComment 

func (i *GithubIntegration) CreateIssueComment(ctx context.Context, input domain.IntegrationInput, item domain.Item) (domain.Item, error)

func (*GithubIntegration) CreateRelease 

func (i *GithubIntegration) CreateRelease(ctx context.Context, input domain.IntegrationInput, item domain.Item) (domain.Item, error)

Release Actions

func (*GithubIntegration) CreateReview 

func (i *GithubIntegration) CreateReview(ctx context.Context, input domain.IntegrationInput, item domain.Item) (domain.Item, error)

Review Actions

func (*GithubIntegration) DeleteFile 

func (i *GithubIntegration) DeleteFile(ctx context.Context, input domain.IntegrationInput, item domain.Item) (domain.Item, error)

func (*GithubIntegration) DeleteRelease 

func (i *GithubIntegration) DeleteRelease(ctx context.Context, input domain.IntegrationInput, item domain.Item) (domain.Item, error)

func (*GithubIntegration) EditFile 

func (i *GithubIntegration) EditFile(ctx context.Context, input domain.IntegrationInput, item domain.Item) (domain.Item, error)

func (*GithubIntegration) EditIssue 

func (i *GithubIntegration) EditIssue(ctx context.Context, input domain.IntegrationInput, item domain.Item) (domain.Item, error)

func (*GithubIntegration) Execute 

func (i *GithubIntegration) Execute(ctx context.Context, params domain.IntegrationInput) (domain.IntegrationOutput, error)

func (*GithubIntegration) GetFile 

func (i *GithubIntegration) GetFile(ctx context.Context, input domain.IntegrationInput, item domain.Item) (domain.Item, error)

func (*GithubIntegration) GetIssue 

func (i *GithubIntegration) GetIssue(ctx context.Context, input domain.IntegrationInput, item domain.Item) (domain.Item, error)

func (*GithubIntegration) GetRelease 

func (i *GithubIntegration) GetRelease(ctx context.Context, input domain.IntegrationInput, item domain.Item) (domain.Item, error)

func (*GithubIntegration) GetRepository 

func (i *GithubIntegration) GetRepository(ctx context.Context, input domain.IntegrationInput, item domain.Item) (domain.Item, error)

Repository Actions

func (*GithubIntegration) GetRepositoryIssues 

func (i *GithubIntegration) GetRepositoryIssues(ctx context.Context, input domain.IntegrationInput, item domain.Item) ([]domain.Item, error)

func (*GithubIntegration) GetRepositoryLicense 

func (i *GithubIntegration) GetRepositoryLicense(ctx context.Context, input domain.IntegrationInput, item domain.Item) (domain.Item, error)

func (*GithubIntegration) GetRepositoryPRs 

func (i *GithubIntegration) GetRepositoryPRs(ctx context.Context, input domain.IntegrationInput, item domain.Item) ([]domain.Item, error)

func (*GithubIntegration) GetRepositoryProfile 

func (i *GithubIntegration) GetRepositoryProfile(ctx context.Context, input domain.IntegrationInput, item domain.Item) (domain.Item, error)

func (*GithubIntegration) GetReview 

func (i *GithubIntegration) GetReview(ctx context.Context, input domain.IntegrationInput, item domain.Item) (domain.Item, error)

func (*GithubIntegration) ListFiles 

func (i *GithubIntegration) ListFiles(ctx context.Context, input domain.IntegrationInput, item domain.Item) ([]domain.Item, error)

func (*GithubIntegration) ListPopularPaths 

func (i *GithubIntegration) ListPopularPaths(ctx context.Context, input domain.IntegrationInput, item domain.Item) ([]domain.Item, error)

func (*GithubIntegration) ListReleases 

func (i *GithubIntegration) ListReleases(ctx context.Context, input domain.IntegrationInput, item domain.Item) ([]domain.Item, error)

func (*GithubIntegration) ListRepositoryReferrers 

func (i *GithubIntegration) ListRepositoryReferrers(ctx context.Context, input domain.IntegrationInput, item domain.Item) ([]domain.Item, error)

func (*GithubIntegration) ListReviews 

func (i *GithubIntegration) ListReviews(ctx context.Context, input domain.IntegrationInput, item domain.Item) ([]domain.Item, error)

func (*GithubIntegration) LockIssue 

func (i *GithubIntegration) LockIssue(ctx context.Context, input domain.IntegrationInput, item domain.Item) (domain.Item, error)

func (*GithubIntegration) OrgGetRepositories 

func (i *GithubIntegration) OrgGetRepositories(ctx context.Context, input domain.IntegrationInput, item domain.Item) ([]domain.Item, error)

Organization Actions

func (*GithubIntegration) Peek 

func (i *GithubIntegration) Peek(ctx context.Context, params domain.PeekParams) (domain.PeekResult, error)

func (*GithubIntegration) PeekBranches 

func (i *GithubIntegration) PeekBranches(ctx context.Context, params domain.PeekParams) (domain.PeekResult, error)

func (*GithubIntegration) PeekRepositories 

func (i *GithubIntegration) PeekRepositories(ctx context.Context, params domain.PeekParams) (domain.PeekResult, error)

--- Placeholder Peek Implementations ---

func (*GithubIntegration) PeekUsers 

func (i *GithubIntegration) PeekUsers(ctx context.Context, params domain.PeekParams) (domain.PeekResult, error)

func (*GithubIntegration) UpdateRelease 

func (i *GithubIntegration) UpdateRelease(ctx context.Context, input domain.IntegrationInput, item domain.Item) (domain.Item, error)

func (*GithubIntegration) UpdateReview 

func (i *GithubIntegration) UpdateReview(ctx context.Context, input domain.IntegrationInput, item domain.Item) (domain.Item, error)

func (*GithubIntegration) UserGetRepositories 

func (i *GithubIntegration) UserGetRepositories(ctx context.Context, input domain.IntegrationInput, item domain.Item) ([]domain.Item, error)

User Actions

func (*GithubIntegration) UserInvite 

func (i *GithubIntegration) UserInvite(ctx context.Context, input domain.IntegrationInput, item domain.Item) (domain.Item, error)

type GithubIntegrationCreator 

type GithubIntegrationCreator struct {
	// contains filtered or unexported fields
}

func (*GithubIntegrationCreator) CreateIntegration 

func (c *GithubIntegrationCreator) CreateIntegration(ctx context.Context, p domain.CreateIntegrationParams) (domain.IntegrationExecutor, error)

type GithubIntegrationDependencies 

type GithubIntegrationDependencies struct {
	CredentialID string

	ParameterBinder  domain.IntegrationParameterBinder
	CredentialGetter domain.CredentialGetter[domain.OAuthAccountSensitiveData]
}

type ListFilesParams 

type ListFilesParams struct {
	Owner string  `json:"repository_id"`
	Repo  string  `json:"-"`
	Path  string  `json:"path,omitempty"` // Optional: directory path, defaults to root
	Ref   *string `json:"ref,omitempty"`  // Branch, tag, or commit SHA
}

type ListReleasesParams 

type ListReleasesParams struct {
	Owner string `json:"repository_id"`
	Repo  string `json:"-"`
	Limit *int   `json:"limit,omitempty"` // Maximum number of releases to return (1-100). Default: 30
	Page  *int   `json:"page,omitempty"`  // Page number of results to fetch. Default: 1
}

type ListReviewsParams 

type ListReviewsParams struct {
	Owner      string `json:"repository_id"`
	Repo       string `json:"-"`
	PullNumber int    `json:"pull_number"`
	Limit      *int   `json:"limit,omitempty"` // Maximum number of reviews to return (1-100). Default: 30
	Page       *int   `json:"page,omitempty"`  // Page number of results to fetch. Default: 1
}

type LockIssueParams 

type LockIssueParams struct {
	Owner       string  `json:"repository_id"`
	Repo        string  `json:"-"`
	IssueNumber int     `json:"issue_number"`
	LockReason  *string `json:"lock_reason,omitempty"` // off-topic, too heated, resolved, spam
}

type OrgGetRepositoriesParams 

type OrgGetRepositoriesParams struct {
	Org       string  `json:"org"`
	Type      *string `json:"type,omitempty"`      // all, public, private, forks, sources, member. Default: all
	Sort      *string `json:"sort,omitempty"`      // created, updated, pushed, full_name. Default: created
	Direction *string `json:"direction,omitempty"` // asc, desc. Default: desc for created, else asc
	Limit     *int    `json:"limit,omitempty"`     // Maximum number of repositories to return (1-100). Default: 30
	Page      *int    `json:"page,omitempty"`      // Page number of results to fetch. Default: 1
}

Organization Action Params

type UpdateReleaseParams 

type UpdateReleaseParams struct {
	Owner                string  `json:"repository_id"`
	Repo                 string  `json:"-"`
	ReleaseID            int64   `json:"release_id"`
	TagName              *string `json:"tag_name,omitempty"`
	TargetCommitish      *string `json:"target_commitish,omitempty"`
	Name                 *string `json:"name,omitempty"`
	Body                 *string `json:"body,omitempty"`
	Draft                *bool   `json:"draft,omitempty"`
	Prerelease           *bool   `json:"prerelease,omitempty"`
	GenerateReleaseNotes *bool   `json:"generate_release_notes,omitempty"`
}

type UpdateReviewParams 

type UpdateReviewParams struct {
	Owner      string `json:"repository_id"`
	Repo       string `json:"-"`
	PullNumber int    `json:"pull_number"`
	ReviewID   int64  `json:"review_id"`
	Body       string `json:"body"` // Required
}

type UserGetRepositoriesParams 

type UserGetRepositoriesParams struct {
	Visibility  *string `json:"visibility,omitempty"`  // all, public, private. Default: all
	Affiliation *string `json:"affiliation,omitempty"` // Comma-separated: owner,collaborator,organization_member. Default: owner,collaborator,organization_member
	Type        *string `json:"type,omitempty"`        // all, owner, public, private, member. Default: all. Caution: Using type with visibility or affiliation is not recommended by GitHub.
	Sort        *string `json:"sort,omitempty"`        // created, updated, pushed, full_name. Default: full_name
	Direction   *string `json:"direction,omitempty"`   // asc, desc. Default: asc for full_name, desc for others.
	Limit       *int    `json:"limit,omitempty"`       // Maximum number of repositories to return (1-100). Default: 30
	Page        *int    `json:"page,omitempty"`        // Page number of results to fetch. Default: 1
}

User Action Params

type UserInviteParams 

type UserInviteParams struct {
	Owner      string  `json:"repository_id"`
	Repo       string  `json:"-"`
	Username   string  `json:"username"`
	Permission *string `json:"permission,omitempty"` // pull, push, admin, maintain, triage. Default: push (though API default is read)
}

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.