GitHub

Copied!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
import time
from dataclasses import dataclass

import jwt
import requests
from functions.api import function
from functions.sources import get_source

API = "https://api.github.com"
APP_ID = "<github_app_id_or_client_id>"
SOURCE_ALIAS = "<source_alias>"


@dataclass
class GitHubIssue:
    number: int
    title: str
    body: str | None
    state: str


def github_headers(github, owner: str, repository: str) -> dict[str, str]:
    now = int(time.time())
    app_jwt = jwt.encode(
        {"iat": now - 60, "exp": now + 540, "iss": APP_ID},
        github.get_secret("Other"),
        algorithm="RS256",
    )
    headers = {
        "Accept": "application/vnd.github+json",
        "X-GitHub-Api-Version": "2022-11-28",
        "Authorization": f"Bearer {app_jwt}",
    }
    installation_id = requests.get(
        f"{API}/repos/{owner}/{repository}/installation", headers=headers
    ).json()["id"]
    token = requests.post(
        f"{API}/app/installations/{installation_id}/access_tokens",
        headers=headers,
    ).json()["token"]
    return {**headers, "Authorization": f"Bearer {token}"}


@function(sources=["<source_alias>"])
def get_issues(owner: str, repository: str) -> list[GitHubIssue]:
    response = requests.get(
        f"{API}/repos/{owner}/{repository}/issues",
        headers=github_headers(get_source(SOURCE_ALIAS), owner, repository),
        params={"state": "all", "per_page": 100},
    )
    response.raise_for_status()
    return [GitHubIssue(issue["number"], issue["title"], issue["body"], issue["state"])
            for issue in response.json()]

Copied!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
import { ExternalSystems, Function, Integer } from "@foundry/functions-api";
import { GitHubSource } from "@foundry/external-systems/sources";
import * as jwt from "jsonwebtoken";

const API = "https://api.github.com";

export interface GitHubIssue {
    number: Integer;
    title: string;
    body?: string;
    state: string;
}

async function githubHeaders(owner: string, repository: string): Promise<Record<string, string>> {
    const now = Math.floor(Date.now() / 1000);
    const appJwt = jwt.sign(
        { iat: now - 60, exp: now + 540, iss: GitHubSource.getSecret("OAuthClientId") },
        GitHubSource.getSecret("Other"),
        { algorithm: "RS256" },
    );
    const headers = {
        Accept: "application/vnd.github+json",
        "X-GitHub-Api-Version": "2022-11-28",
        Authorization: `Bearer ${appJwt}`,
    };
    const installation = await GitHubSource.fetch(
        `${API}/repos/${owner}/${repository}/installation`, { method: "GET", headers }
    );
    const { id } = await installation.json() as { id: number };
    const tokenResponse = await GitHubSource.fetch(
        `${API}/app/installations/${id}/access_tokens`, { method: "POST", headers }
    );
    const { token } = await tokenResponse.json() as { token: string };
    return { ...headers, Authorization: `Bearer ${token}` };
}

export class GitHubFunctions {
    @ExternalSystems({ sources: [GitHubSource] })
    @Function()
    public async getIssues(owner: string, repository: string): Promise<GitHubIssue[]> {
        const response = await GitHubSource.fetch(
            `${API}/repos/${owner}/${repository}/issues?state=all&per_page=100`,
            { method: "GET", headers: await githubHeaders(owner, repository) },
        );
        if (!response.ok) throw new Error(`GitHub returned ${response.status}`);
        const issues = await response.json() as Array<{
            number: number; title: string; body: string | null; state: string;
        }>;
        return issues.map(({ number, title, body, state }) => ({
            number, title, body: body ?? undefined, state,
        }));
    }
}

Copied!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
import { Integer } from "@osdk/functions";
import { getFetch, getSource } from "@palantir/functions-sources";
import jwt from "jsonwebtoken";

const API = "https://api.github.com";
const SOURCE_RID = "<source_rid>";
export const config = { sources: [SOURCE_RID] };

export interface GitHubIssue {
    number: Integer;
    title: string;
    body?: string;
    state: string;
}

async function githubClient(owner: string, repository: string) {
    const source = await getSource({ rid: SOURCE_RID });
    const request = await getFetch(source);
    const now = Math.floor(Date.now() / 1000);
    const appJwt = jwt.sign(
        { iat: now - 60, exp: now + 540, iss: source.secrets.OAuthClientId! },
        source.secrets.Other!,
        { algorithm: "RS256" },
    );
    const headers = {
        Accept: "application/vnd.github+json",
        "X-GitHub-Api-Version": "2022-11-28",
        Authorization: `Bearer ${appJwt}`,
    };
    const installation = await request(
        `${API}/repos/${owner}/${repository}/installation`, { method: "GET", headers }
    );
    const { id } = await installation.json() as { id: number };
    const tokenResponse = await request(
        `${API}/app/installations/${id}/access_tokens`, { method: "POST", headers }
    );
    const { token } = await tokenResponse.json() as { token: string };
    return { request, headers: { ...headers, Authorization: `Bearer ${token}` } };
}

export default async function getIssues(owner: string, repository: string): Promise<GitHubIssue[]> {
    const { request, headers } = await githubClient(owner, repository);
    const response = await request(
        `${API}/repos/${owner}/${repository}/issues?state=all&per_page=100`,
        { method: "GET", headers },
    );
    if (!response.ok) throw new Error(`GitHub returned ${response.status}`);
    const issues = await response.json() as Array<{
        number: number; title: string; body: string | null; state: string;
    }>;
    return issues.map(({ number, title, body, state }) => ({
        number, title, body: body ?? undefined, state,
    }));
}

Copied!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
import time

import jwt
import requests
from functions.api import function
from functions.sources import get_source

API = "https://api.github.com"
APP_ID = "<github_app_id_or_client_id>"
SOURCE_ALIAS = "<source_alias>"


def github_headers(github, owner: str, repository: str) -> dict[str, str]:
    now = int(time.time())
    app_jwt = jwt.encode(
        {"iat": now - 60, "exp": now + 540, "iss": APP_ID},
        github.get_secret("Other"),
        algorithm="RS256",
    )
    headers = {
        "Accept": "application/vnd.github+json",
        "X-GitHub-Api-Version": "2022-11-28",
        "Authorization": f"Bearer {app_jwt}",
    }
    installation_id = requests.get(
        f"{API}/repos/{owner}/{repository}/installation", headers=headers
    ).json()["id"]
    token = requests.post(
        f"{API}/app/installations/{installation_id}/access_tokens",
        headers=headers,
    ).json()["token"]
    return {**headers, "Authorization": f"Bearer {token}"}


@function(sources=["<source_alias>"])
def patch_issue(
    owner: str, repository: str, issue_number: int, body: str
) -> str:
    response = requests.patch(
        f"{API}/repos/{owner}/{repository}/issues/{issue_number}",
        headers=github_headers(get_source(SOURCE_ALIAS), owner, repository),
        json={"body": body},
    )
    response.raise_for_status()
    return body

Copied!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
import { ExternalSystems, Function, Integer } from "@foundry/functions-api";
import { GitHubSource } from "@foundry/external-systems/sources";
import * as jwt from "jsonwebtoken";

const API = "https://api.github.com";

async function githubHeaders(owner: string, repository: string): Promise<Record<string, string>> {
    const now = Math.floor(Date.now() / 1000);
    const appJwt = jwt.sign(
        { iat: now - 60, exp: now + 540, iss: GitHubSource.getSecret("OAuthClientId") },
        GitHubSource.getSecret("Other"),
        { algorithm: "RS256" },
    );
    const headers = {
        Accept: "application/vnd.github+json",
        "X-GitHub-Api-Version": "2022-11-28",
        Authorization: `Bearer ${appJwt}`,
    };
    const installation = await GitHubSource.fetch(
        `${API}/repos/${owner}/${repository}/installation`, { method: "GET", headers }
    );
    const { id } = await installation.json() as { id: number };
    const tokenResponse = await GitHubSource.fetch(
        `${API}/app/installations/${id}/access_tokens`, { method: "POST", headers }
    );
    const { token } = await tokenResponse.json() as { token: string };
    return { ...headers, Authorization: `Bearer ${token}` };
}

export class GitHubFunctions {
    @ExternalSystems({ sources: [GitHubSource] })
    @Function()
    public async patchIssue(
        owner: string, repository: string, issueNumber: Integer, body: string
    ): Promise<string> {
        const response = await GitHubSource.fetch(
            `${API}/repos/${owner}/${repository}/issues/${issueNumber}`,
            {
                method: "PATCH",
                headers: { ...await githubHeaders(owner, repository), "Content-Type": "application/json" },
                body: JSON.stringify({ body }),
            },
        );
        if (!response.ok) throw new Error(`GitHub returned ${response.status}`);
        return body;
    }
}

Copied!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
import { Integer } from "@osdk/functions";
import { getFetch, getSource } from "@palantir/functions-sources";
import jwt from "jsonwebtoken";

const API = "https://api.github.com";
const SOURCE_RID = "<source_rid>";
export const config = { sources: [SOURCE_RID] };

async function githubClient(owner: string, repository: string) {
    const source = await getSource({ rid: SOURCE_RID });
    const request = await getFetch(source);
    const now = Math.floor(Date.now() / 1000);
    const appJwt = jwt.sign(
        { iat: now - 60, exp: now + 540, iss: source.secrets.OAuthClientId! },
        source.secrets.Other!,
        { algorithm: "RS256" },
    );
    const headers = {
        Accept: "application/vnd.github+json",
        "X-GitHub-Api-Version": "2022-11-28",
        Authorization: `Bearer ${appJwt}`,
    };
    const installation = await request(
        `${API}/repos/${owner}/${repository}/installation`, { method: "GET", headers }
    );
    const { id } = await installation.json() as { id: number };
    const tokenResponse = await request(
        `${API}/app/installations/${id}/access_tokens`, { method: "POST", headers }
    );
    const { token } = await tokenResponse.json() as { token: string };
    return { request, headers: { ...headers, Authorization: `Bearer ${token}` } };
}

export default async function patchIssue(
    owner: string, repository: string, issueNumber: Integer, body: string
): Promise<string> {
    const { request, headers } = await githubClient(owner, repository);
    const response = await request(
        `${API}/repos/${owner}/${repository}/issues/${issueNumber}`,
        {
            method: "PATCH",
            headers: { ...headers, "Content-Type": "application/json" },
            body: JSON.stringify({ body }),
        },
    );
    if (!response.ok) throw new Error(`GitHub returned ${response.status}`);
    return body;
}