ya-git-jira 1.3.0 → 1.5.0

package/index.ts

@@ -1,6 +1,6 @@
 export * from "./lib/json.ts"
 export * from "./lib/git.ts"
-export * from "./lib/gitlab.ts"
+export * from "./lib/gitlab"
 export * from "./lib/is_main.ts"
 export * from "./lib/jira.ts"
 export * from "./lib/spawn.ts"

package/lib/gitlab/api.ts

@@ -0,0 +1,46 @@
+import type { JSONValue } from "../json"
+import { getGitlabConfig } from "./config"
+
+function getNextLink(link: string | null): string | undefined {
+    if (!link) {
+        return undefined
+    }
+    const regex = /<([^>]+)>; rel="next"/
+    const match = link.match(regex)
+    const next = match ? match[1] : undefined
+    return next
+}
+
+export async function gitlabApi(endpoint: string): Promise<JSONValue> {
+    if (endpoint.startsWith("/")) {
+        console.warn(`gitlabApi: endpoint ${endpoint} starts with /, removing it`)
+        endpoint = endpoint.slice(1)
+    }
+    const method = "GET"
+    const { host, token } = await getGitlabConfig()
+    const base = `https://${host}/api/v4`
+    const requested = 100
+    const sep = endpoint.includes('?') ? '&' : '?'
+    const uri = `${base}/${endpoint}${sep}per_page=${requested}`
+    const headers = new Headers()
+    headers.append("Accept", "application/json")
+    headers.append('Private-Token', token)
+    const options = {
+        method,
+        headers,
+    }
+    let request = new Request(uri, options)
+    const response = await fetch(request)
+    let link = getNextLink(response.headers.get('Link'))
+    let partial = (await response.json()) as Array<JSONValue>
+    let result: Array<JSONValue> = partial
+    while (partial.length == requested && link)
+    {
+        let request = new Request(link, options)
+        const next_response = await fetch(request)
+        link = getNextLink(next_response.headers.get('Link'))
+        partial = (await next_response.json()) as Array<JSONValue>
+        result = result.concat(partial)
+    }
+    return result;
+}

package/lib/gitlab/config.ts

@@ -0,0 +1,21 @@
+import { getConfig } from "../git"
+
+export interface GitlabConfig {
+    host: string
+    user: string
+    token: string
+}
+
+const hostP = getConfig("gitlab.host")
+const userP = getConfig("user.email")
+const tokenP = getConfig("gitlab.token")
+
+export async function getGitlabConfig(): Promise<GitlabConfig> {
+    const host = await hostP
+    if (!host) throw new Error("gitlab.host not in git config")
+    const user = await userP
+    if (!user) throw new Error("user.email not in git config")
+    const token = await tokenP
+    if (!token) throw new Error("gitlab.token not in git config")
+    return { host, user, token }
+}

package/lib/gitlab/dlog.ts

@@ -0,0 +1,2 @@
+import debug from 'debug'
+export const dlog = debug('gitlab')

package/lib/gitlab/group.ts

@@ -0,0 +1,12 @@
+import { gitlabApi } from './api'
+import { JSONValue } from '../json'
+
+export type Group = JSONValue & {
+    id: number
+    name: string
+    full_path: string
+}
+
+export async function getGroups(): Promise<Array<Group>> {
+    return await gitlabApi(`groups`) as Array<Group>
+}

package/lib/gitlab/index.ts

@@ -0,0 +1,8 @@
+export * from './api'
+export * from './config'
+export * from './group'
+export * from './merge-request'
+export * from './namespace'
+export * from './pipeline'
+export * from './project'
+export * from './user'

package/lib/gitlab/merge-request.ts

@@ -0,0 +1,31 @@
+import { projectScopedGet } from './project'
+import type { JSONValue } from '../json'
+import { whoami } from './user'
+import { gitlabApi } from './api'
+
+export type MergeRequest = JSONValue & {
+    id: number
+    title : string
+    description : string
+    state : string
+    source_branch: string
+    target_branch: string
+    web_url: string
+    merge_status: string
+}
+
+export async function getMergeRequest(id: string): Promise<MergeRequest> {
+    return await projectScopedGet(`merge_requests/${id}`) as MergeRequest
+}
+
+export async function getMyMergeRequestsInProgress() : Promise<Array<MergeRequest>>
+{
+    const me = await whoami()
+    return await gitlabApi(`merge_requests?state=opened&author_id=${me.id}`) as Array<MergeRequest>
+}
+
+export async function getMyMergeRequestsToReview() : Promise<Array<MergeRequest>>
+{
+    const me = await whoami()
+    return await gitlabApi(`merge_requests?state=opened&reviewer_id=${me.id}`) as Array<MergeRequest>
+}

package/lib/gitlab/merge-trains.ts

@@ -0,0 +1,19 @@
+import { projectScopedGet } from './project'
+import type { JSONValue } from '../json'
+
+export type MergeTrain = JSONValue & {
+    id: number
+    merge_request: {
+        title: string
+        web_url: string
+    }
+    user: {
+        username: string
+    }
+    target_branch: string
+    status: string
+}
+
+export async function getMergeTrains(): Promise<MergeTrain[]> {
+    return await projectScopedGet(`merge_trains`) as MergeTrain[]
+}

package/lib/gitlab/namespace.ts

@@ -0,0 +1,12 @@
+import { gitlabApi } from "./api"
+import { JSONValue } from "../json"
+
+type Namespace = JSONValue & {
+    id: number
+    name: string
+    full_path: string
+}
+
+export async function getNamespaces(): Promise<Namespace[]> {
+    return await gitlabApi(`namespaces`) as Namespace[]
+}

package/lib/gitlab/pipeline.ts

@@ -0,0 +1,32 @@
+import { dlog } from "./dlog"
+import { projectScopedGet } from "./project"
+import { whoami } from "./user"
+import type { JSONValue } from "../json"
+
+export type Pipeline = JSONValue & {
+    id: number
+    status: string
+    ref: string
+    sha: string
+    web_url: string
+    updated_at: string  // datetime string like "2021-03-18T15:00:00.000Z"
+}
+
+export type PipelineStatus = 'success' | 'running'
+
+export interface GetPipelineOptions {
+    days: number
+    status: PipelineStatus
+}
+
+export async function getProjectPipelines(options: GetPipelineOptions): Promise<Array<Pipeline>> {
+    const { days, status } = options
+    const me = await whoami()
+    const username = me.username
+    const date = new Date()
+    const pastDate = date.getDate() - days;
+    date.setDate(pastDate)
+    const updated = date.toISOString()
+    dlog(`updated: ${updated}`)
+    return await projectScopedGet(`pipelines?status=${status}&username=${username}&updated_after=${updated}`) as Array<Pipeline>
+}

package/lib/gitlab/project.ts

@@ -0,0 +1,78 @@
+import { getGitlabConfig } from "./config"
+import { getRemote } from "../git"
+import { gitlabApi } from "./api"
+import { type JSONValue } from "../json"
+import path from 'node:path'
+import { dlog } from "./dlog"
+
+export type Project = JSONValue & {
+    id: number
+    name: string
+    path: string
+    path_with_namespace: string
+    visibility: string
+    ssh_url_to_repo: string
+}
+
+export async function getProjects(match: string): Promise<Array<Project>> {
+    let search = ''
+    if (match) {
+        const m = encodeURIComponent(match)
+        search = `&search=${m}`
+    }
+    const projects = await gitlabApi(`projects?membership=true&simple=true${search}`)
+    if (!projects) {
+        throw new Error(`No projects!`)
+    } else if (!Array.isArray(projects)) {
+        console.log(projects)
+        throw new Error(`Projects is not an array!`)
+    }
+    const projs = projects as Array<Project>
+
+    const filtered = projs.filter((p: Project): boolean => {
+        return p.path_with_namespace.toLowerCase().includes(match.toLowerCase())
+    })
+    return filtered
+}
+
+// git@gitlab.com:etagen-internal/linear-generator-config.git
+export async function findProject(ssh_url: string): Promise<Project | undefined> {
+    const parts = ssh_url.split(':')
+    if (parts.length != 2) {
+        throw new Error(`${ssh_url} is invalid, could not be split into two parts at :`)
+    }
+    const name = path.basename(parts[1], '.git')
+
+    const projects = await getProjects(name) as Array<Project>
+    const project = projects.find((p: Project): boolean => {
+        return p.ssh_url_to_repo === ssh_url
+    })
+    return project
+}
+
+export async function projectScopedGet(endpoint: string): Promise<JSONValue> {
+    if (endpoint.startsWith("/")) {
+        console.warn(`gitlabApi: endpoint ${endpoint} starts with /, removing it`)
+        endpoint = endpoint.slice(1)
+    }
+    const method = "GET"
+    const { host, token } = await getGitlabConfig()
+    const remote = await getRemote()
+    const project = await findProject(remote)
+    if (!project) {
+        throw new Error(`Could not find project for remote ${remote}`)
+    }
+    const base = `https://${host}/api/v4/projects/${project.id}`
+    const uri = `${base}/${endpoint}`
+    dlog(`projectScopedGet uri: ${uri}`)
+    const headers = new Headers()
+    headers.append("Accept", "application/json")
+    headers.append('Private-Token', token)
+    const options = {
+        method,
+        headers,
+    }
+    const request = new Request(uri, options)
+    const response = await fetch(request)
+    return await response.json()
+}

package/lib/gitlab/user.ts

@@ -0,0 +1,13 @@
+import type { JSONValue } from "../json"
+import { gitlabApi } from "./api"
+
+export type User = JSONValue & {
+    id: number
+    name: string
+    username: string
+    email: string
+}
+
+export async function whoami(): Promise<User> {
+    return await gitlabApi("user") as User
+}

package/lib/is_main.ts

@@ -1,5 +1,24 @@
 import path from 'node:path'
+
+function justBase(filename: string): string {
+    const ext = path.extname(filename)
+    const base = path.basename(filename, ext)
+    return base
+}
+
 export function isMain(self: string): boolean {
-    const exe = path.basename(Bun.argv[1]).split('.')[0]
-    return exe == self || import.meta.main
+    const arg1 = Bun.argv[1]
+    const argv1Base = justBase(arg1)
+    const selfBase = justBase(self)
+    const result = argv1Base === selfBase
+    // if (result) {
+    //     console.log({
+    //         arg1,
+    //         self,
+    //         argv1Base,
+    //         selfBase,
+    //         result,
+    //     })
+    // }
+    return result
 }

package/lib/jira.ts

@@ -25,11 +25,14 @@ export async function getJiraConfig(): Promise<JiraConfig> {
     return { host, token }
 }
 
-export async function get(endpoint: string): Promise<JSONValue> {
+export async function jiraApi(endpoint: string): Promise<JSONValue> {
+    if (endpoint.startsWith("/")) {
+        console.warn(`jiraApi: endpoint ${endpoint} starts with /`)
+        endpoint = endpoint.slice(1)
+    }
     const method = "GET"
     const { host, token } = await getJiraConfig()
-    const base = `https://${host}/rest/api/3`
-    const uri = `${base}/${endpoint}`
+    const uri = `https://${host}/rest/api/3/${endpoint}`
     const auth = `Basic ${token}`
     const headers = new Headers()
     headers.append("Authorization", auth)
@@ -40,11 +43,13 @@ export async function get(endpoint: string): Promise<JSONValue> {
     }
     const request = new Request(uri, options)
     const response = await fetch(request)
-    return await response.json()
+    const result = await response.json()
+    return result;
 }
 
 export async function getIssue(issue: string): Promise<Issue> {
-    return await get(`/issue/${issue}`) as Issue
+    const result = await jiraApi(`issue/${issue}`) as Issue
+    return result
 }
 
 type Myself = JSONValue & {
@@ -52,7 +57,7 @@ type Myself = JSONValue & {
 }
 
 export async function getMyself(): Promise<Myself> {
-    return await get("/myself") as Myself
+    return await jiraApi("/myself") as Myself
 }
 
 type SearchResponse = JSONValue & {
@@ -63,6 +68,6 @@ export async function myUnresolvedIssues(): Promise<Array<Issue>> {
     const myself = await getMyself()
     const myselfId = myself.accountId
     const jql = `assignee = ${myselfId} AND resolution = Unresolved`
-    const issues = await get(`/search?jql=${encodeURIComponent(jql)}`) as SearchResponse
+    const issues = await jiraApi(`/search?jql=${encodeURIComponent(jql)}`) as SearchResponse
     return issues.issues
 }

package/lib/package.ts

@@ -0,0 +1,35 @@
+
+import path from 'node:path'
+import fs from 'node:fs'
+
+export function findPackageJson()
+{
+    const cwd = import.meta.dir
+    let dir = cwd
+    while (dir !== '/') {
+        const packageJson = path.join(dir, 'package.json')
+        if (fs.existsSync(packageJson)) {
+            return packageJson
+        }
+        dir = path.dirname(dir)
+    }
+    return null
+}
+
+export async function getPackageJson()
+{
+    const packagePath = findPackageJson()
+    if (!packagePath) {
+        throw new Error(`No package.json found in ${import.meta.dir} or any parent directory`)
+    }
+    const packageJsonText = fs.readFileSync(packagePath, 'utf8')
+    return JSON.parse(packageJsonText)
+}
+
+const packageJsonPromise = getPackageJson()
+
+export async function getPackageVersion()
+{
+    const packageJson = await packageJsonPromise
+    return packageJson.version
+}

package/package.json

@@ -1,16 +1,30 @@
 {
   "name": "ya-git-jira",
   "description": "git extensions for Jira integration. Assumes bun is installed.",
-  "version": "1.3.0",
+  "version": "1.5.0",
   "module": "dist/index.js",
   "type": "module",
   "bin": {
     "git-bump": "dist/bin/git-bump.js",
+    "git-jira-issue-list": "dist/bin/git-jira-issue-list.js",
+    "git-jira-issue-show": "dist/bin/git-jira-issue-show.js",
     "git-jira-issue": "dist/bin/git-jira-issue.js",
-    "git-jira-issues": "dist/bin/git-jira-issues.js",
     "git-jira-start": "dist/bin/git-jira-start.js",
     "git-jira": "dist/bin/git-jira.js",
-    "git-lab-projects": "dist/bin/git-lab-projects.js",
+    "git-lab-group-list": "dist/bin/git-lab-group-list.js",
+    "git-lab-group": "dist/bin/git-lab-group.js",
+    "git-lab-merge-active": "dist/bin/git-lab-merge-active.js",
+    "git-lab-merge-todo": "dist/bin/git-lab-merge-todo.js",
+    "git-lab-merge-train-list": "dist/bin/git-lab-merge-train-list.js",
+    "git-lab-merge-train": "dist/bin/git-lab-merge-train.js",
+    "git-lab-merge": "dist/bin/git-lab-merge.js",
+    "git-lab-namespace-list": "dist/bin/git-lab-namespace-list.js",
+    "git-lab-namespace": "dist/bin/git-lab-namespace.js",
+    "git-lab-project-list": "dist/bin/git-lab-project-list.js",
+    "git-lab-project-pipeline": "dist/bin/git-lab-project-pipeline.js",
+    "git-lab-project-pipeline-list": "dist/bin/git-lab-project-pipeline-list.js",
+    "git-lab-project-whereami": "dist/bin/git-lab-project-whereami.js",
+    "git-lab-project": "dist/bin/git-lab-project.js",
     "git-lab-whoami": "dist/bin/git-lab-whoami.js",
     "git-lab": "dist/bin/git-lab.js",
     "gitj": "dist/bin/gitj.js"
@@ -21,7 +35,9 @@
   },
   "devDependencies": {
     "@types/commander": "^2.12.2",
-    "bun-types": "latest"
+    "@types/debug": "^4.1.8",
+    "bun-types": "latest",
+    "typescript": "latest"
   },
   "directories": {
     "lib": "lib"
@@ -32,6 +48,7 @@
   "dependencies": {
     "commander": "^11.0.0",
     "cuid": "^3.0.0",
+    "debug": "^4.3.4",
     "glob": "^10.3.4"
   },
   "main": "dist/start.js dist/bump.js",

package/tests/all-help.test.ts

@@ -0,0 +1,46 @@
+import { readdirSync } from 'fs';
+import { describe, expect, test } from 'bun:test';
+import { doCommand } from '..';
+
+import { getPackageJson, getPackageVersion } from '../lib/package'
+const version = await getPackageVersion()
+
+
+describe('bin scripts', () => {
+    const binDir = './bin';
+
+    const scripts = readdirSync(binDir).filter((file) => {
+        return file.endsWith('.ts');
+    });
+
+    describe('--help', () => {
+        scripts.forEach((script) => {
+            const stem = script.split('/').pop()?.split('-').pop()?.split('.').shift();
+            test(`"${script} --help" should contain 'Usage: ${stem}'"`, async () => {
+                const output = await doCommand(['bun', 'run', `${binDir}/${script}`, '--help']);
+                expect(output).toContain(`Usage: ${stem}`);
+            });
+        });
+    });
+
+    describe('--version', () => {
+        scripts.forEach((script) => {
+            test(`"${script} --version" should contain '${version}'"`, async () => {
+                const output = await doCommand(['bun', 'run', `${binDir}/${script}`, '--version']);
+                expect(output).toContain(version);
+            });
+        });
+    });
+
+    describe('all bin/* exist in package.json', async () => {
+        const packageJson = await getPackageJson();
+        const bin = packageJson.bin;
+        scripts.forEach((script) => {
+            test(`"${script}" should be in package.json`, () => {
+                expect(script).toEndWith('.ts')
+                script = script.slice(0, -3)
+                expect(bin[script]).toBeDefined();
+            });
+        });
+    })
+});

package/tests/git.test.ts

@@ -1,5 +1,6 @@
 import { test, expect } from "bun:test"
-import { findProject, getRemote } from ".."
+import { findProject } from "../lib/gitlab/project"
+import { getRemote } from "../lib/git"
 
 test("testing works", async (): Promise<void> => {
     expect(true).toBe(true)
@@ -13,13 +14,13 @@ test("getRemote", async (): Promise<void> => {
 test("findProject linear-generator", async (): Promise<void> => {
     const ssh_url = "git@gitlab.com:etagen-internal/linear-generator.git"
     const project = await findProject(ssh_url)
-    expect(project.ssh_url_to_repo).toBe(ssh_url)
-    expect(project.id).toBe(4053065)
-})
+    expect(project?.ssh_url_to_repo).toBe(ssh_url)
+    expect(project?.id).toBe(4053065)
+}, 15000)
 
 test("findProject eta-lib/base", async (): Promise<void> => {
     const ssh_url = "git@gitlab.com:etagen-internal/eta-lib/base.git"
     const project = await findProject(ssh_url)
-    expect(project.ssh_url_to_repo).toBe(ssh_url)
-    expect(project.id).toBe(42470523)
-})
+    expect(project?.ssh_url_to_repo).toBe(ssh_url)
+    expect(project?.id).toBe(42470523)
+}, 15000)

package/tests/gitj.test.ts

@@ -10,7 +10,7 @@ test("gitj works", async (): Promise<void> => {
     const { out, code }: SpawnResult = await spawn(["bun", "run", "bin/gitj.ts"])
     expect(out).toMatch("Usage:")
     expect(out).toMatch("Bump the version number in the current branch")
-    expect(out).toMatch("A set of commands for working with Jira")
+    expect(out).toMatch("Commands for working with Jira")
     expect(code).toBe(0)
 })
 

package/lib/gitlab.ts

@@ -1,86 +0,0 @@
-import { getConfig, getRemote } from "./git"
-import type { JSONValue } from "./json"
-import path from 'node:path'
-
-export interface GitlabConfig {
-    host: string
-    user: string
-    token: string
-}
-
-export async function getGitlabConfig(): Promise<GitlabConfig> {
-    const host = await getConfig("gitlab.host")
-    if (!host) throw new Error("gitlab.host not in git config")
-    const user = await getConfig("user.email")
-    if (!user) throw new Error("user.email not in git config")
-    const token = await getConfig("gitlab.token")
-    if (!token) throw new Error("gitlab.token not in git config")
-    return { host, user, token }
-}
-
-export async function get(endpoint: string): Promise<JSONValue> {
-    const method = "GET"
-    const { host, token } = await getGitlabConfig()
-    const base = `https://${host}/api/v4`
-    const uri = `${base}/${endpoint}`
-    const headers = new Headers()
-    headers.append("Accept", "application/json")
-    headers.append('Private-Token', token)
-    const options = {
-        method,
-        headers,
-    }
-    const request = new Request(uri, options)
-    const response = await fetch(request)
-    return await response.json()
-}
-
-export type User = JSONValue & {
-    id: number
-    name: string
-    username: string
-    email: string
-}
-
-export async function whoami(): Promise<User> {
-    return await get("/user") as User
-}
-
-export type Project = JSONValue & {
-    id: number
-    name: string
-    path: string
-    path_with_namespace: string
-    visibility: string
-    ssh_url_to_repo: string
-}
-
-export async function getProjects(paths: string[]): Promise<Array<Project>> {
-    let search: string = ""
-    if (paths.length > 0) {
-        search = '&search=' + paths.join(",")
-    }
-    return await get(`/projects?visibility=private&membership=true&simple=true${search}`) as Array<Project>
-}
-
-// git@gitlab.com:etagen-internal/linear-generator-config.git
-export async function findProject(ssh_url: string): Promise<Project> {
-    const parts = ssh_url.split(':')
-    if (parts.length != 2) {
-        throw new Error(`${ssh_url} is invalid, could not be split into two parts at :`)
-    }
-    const name = path.basename(parts[1], '.git')
-
-    const projects = await getProjects([name])
-    const project = projects.find((p: Project): boolean => {
-        return p.ssh_url_to_repo === ssh_url
-    })
-    if (!project) {
-        throw new Error(`No project with ssh_url_to_repo ${ssh_url} found`)
-    }
-    return project
-}
-
-export async function getMergeRequest(id: string): Promise<JSONValue> {
-    return await get(`/merge_requests/${id}`)
-}