ya-git-jira 1.2.0 → 1.4.0

package/lib/gitlab.ts

@@ -0,0 +1,209 @@
+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 }
+}
+
+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;
+}
+
+export type User = JSONValue & {
+    id: number
+    name: string
+    username: string
+    email: string
+}
+
+export async function whoami(): Promise<User> {
+    return await gitlabApi("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(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}`
+    console.debug(`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()
+}
+
+export async function getMergeRequest(id: string): Promise<JSONValue> {
+    return await projectScopedGet(`merge_requests/${id}`)
+}
+
+export async function getNamespaces(): Promise<JSONValue> {
+    return await gitlabApi(`namespaces`)
+}
+
+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>
+}
+
+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 getMergeRequestsAssignedToMe() : Promise<Array<MergeRequest>>
+{
+    const me = await whoami()
+    return await gitlabApi(`merge_requests?state=opened&reviewer_id=${me.id}`) as Array<MergeRequest>
+}
+
+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()
+    console.debug(`updated: ${updated}`)
+    return await projectScopedGet(`pipelines?status=${status}&username=${username}&updated_after=${updated}`) as Array<Pipeline>
+}

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

@@ -1,18 +1,38 @@
 
-import { getJiraConfig } from "../lib/git"
+import { getConfig } from "../lib/git"
+import type { JSONValue } from "../lib/json"
 
-type JSONValue =
-    | string
-    | number
-    | boolean
-    | { [x: string]: JSONValue }
-    | Array<JSONValue>
+export type Issue = JSONValue & {
+    key: string,
+    self: string,
+    fields: {
+        summary: string
+    }
+}
+export interface JiraConfig {
+    host: string
+    token: string
+}
+
+export async function getJiraConfig(): Promise<JiraConfig> {
+    const host = await getConfig("jira.host")
+    if (!host) throw new Error("jira.host not in git config")
+    const user = await getConfig("jira.user") || await getConfig("user.email")
+    if (!user) throw new Error("jira.user or user.email not in git config")
+    const pat = await getConfig("jira.pat")
+    if (!pat) throw new Error("jira.pat not in git config")
+    const token = Buffer.from(`${user}:${pat}`).toString('base64')
+    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)
@@ -23,19 +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()
-}
-
-type Issue = JSONValue & {
-    key: string,
-    self: string,
-    fields: {
-        summary: string
-    }
+    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 & {
@@ -43,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 & {
@@ -54,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/json.ts

@@ -0,0 +1,6 @@
+export type JSONValue =
+    | string
+    | number
+    | boolean
+    | { [x: string]: JSONValue }
+    | Array<JSONValue>

package/lib/spawn.ts

@@ -1,10 +1,36 @@
+import { Subprocess } from "bun"
 
+export interface SpawnResult {
+    out: string
+    err: string
+    code: number
+}
 
-export async function doCommand(args: string[]): Promise<string> {
-    const proc = Bun.spawn(args)
+export interface SpawnOptions {
+    expectQuiet?: boolean
+}
+
+const defaultOptions: SpawnOptions = {
+    expectQuiet: false,
+}
+
+export async function spawn(args: string[], options: SpawnOptions = defaultOptions): Promise<SpawnResult> {
+    const proc: Subprocess<"ignore", "pipe", "pipe"> = Bun.spawn(args, { stdout: "pipe", stderr: "pipe" })
     const stdout = new Response(proc.stdout)
     const stderr = new Response(proc.stderr)
-    const [out, err] = await Promise.all([stdout.text(), stderr.text()])
+    const [out, err, exitCode, signal] = await Promise.all([stdout.text(), stderr.text(), proc.exitCode, proc.signalCode])
+    let code = 0
+    if (exitCode !== null) {
+        code = exitCode
+    }
+    if (!out && !err && !options.expectQuiet) {
+        console.warn(`No output from ${args.join(" ")}`)
+    }
+    return { out: out.trim(), err: err.trim(), code }
+}
+
+export async function doCommand(args: string[]): Promise<string> {
+    const { out, err } = await spawn(args)
     if (err) console.error(err)
-    return out.trim()
+    return out
 }

package/package.json

@@ -1,22 +1,39 @@
 {
   "name": "ya-git-jira",
   "description": "git extensions for Jira integration. Assumes bun is installed.",
-  "version": "1.2.0",
+  "version": "1.4.0",
   "module": "dist/index.js",
   "type": "module",
   "bin": {
-    "gitj": "dist/bin/gitj.js",
-    "git-jira": "dist/bin/git-jira.js",
+    "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-start": "dist/bin/git-jira-start.js",
-    "git-jira-issues": "dist/bin/git-jira-issues.js",
-    "git-bump": "dist/bin/git-bump.js"
+    "git-jira": "dist/bin/git-jira.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": "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"
   },
   "scripts": {
-    "preinstall": "bun build index.ts bin/gitj.ts bin/git-jira.ts bin/git-jira-start.ts bin/git-jira-issues.ts bin/git-bump.ts --outdir dist"
+    "preinstall": "bun run build.ts",
+    "build": "bun run build.ts"
   },
   "devDependencies": {
     "@types/commander": "^2.12.2",
-    "bun-types": "latest"
+    "bun-types": "latest",
+    "typescript": "latest"
   },
   "directories": {
     "lib": "lib"
@@ -25,7 +42,9 @@
     "typescript": "^5.0.0"
   },
   "dependencies": {
-    "commander": "^11.0.0"
+    "commander": "^11.0.0",
+    "cuid": "^3.0.0",
+    "glob": "^10.3.4"
   },
   "main": "dist/start.js dist/bump.js",
   "repository": {

package/tests/all-help.test.ts

@@ -0,0 +1,19 @@
+import { readdirSync } from 'fs';
+import { describe, expect, test } from 'bun:test';
+import { doCommand } from '..';
+
+describe('bin scripts', () => {
+    const binDir = './bin';
+
+    const scripts = readdirSync(binDir).filter((file) => {
+        return file.endsWith('.ts');
+    });
+
+    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}`);
+        });
+    });
+});

package/tests/git.test.ts

@@ -0,0 +1,25 @@
+import { test, expect } from "bun:test"
+import { findProject, getRemote } from ".."
+
+test("testing works", async (): Promise<void> => {
+    expect(true).toBe(true)
+})
+
+test("getRemote", async (): Promise<void> => {
+    const url = await getRemote()
+    expect(url).toBe("git@github.com:jimlloyd/ya-git-jira.git")
+})
+
+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)
+}, 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)
+}, 15000)

package/tests/gitj.test.ts

@@ -0,0 +1,43 @@
+import { test, expect, describe, beforeEach, afterEach } from "bun:test"
+import { getCurrentBranch, spawn, type SpawnResult } from ".."
+import cuid from "cuid"
+
+test("testing works", async (): Promise<void> => {
+    expect(true).toBe(true)
+})
+
+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("Commands for working with Jira")
+    expect(code).toBe(0)
+})
+
+test("gitj bump --help works", async (): Promise<void> => {
+    const { out, code }: SpawnResult = await spawn(["bun", "run", "bin/gitj.ts", "bump", "--help"])
+    expect(out).toMatch("Usage:")
+    expect(out).toMatch("Bump the version number in the current branch")
+    expect(code).toBe(0)
+})
+
+describe("gitj bump", (): void => {
+    let priorBranch: string
+    let testBranch = cuid()
+    beforeEach(async (): Promise<void> => {
+        priorBranch = await getCurrentBranch()
+        await spawn(["git", "checkout", "-b", testBranch])
+    })
+
+    test("gitj bump works", async (): Promise<void> => {
+        const { code }: SpawnResult = await spawn(["bun", "run", "bin/gitj.ts", "bump"])
+        expect(code).toBe(0)
+        expect(await getCurrentBranch()).toMatch(testBranch + '.v1')
+    })
+
+    afterEach(async (): Promise<void> => {
+        await spawn(["git", "checkout", priorBranch])
+        await spawn(["git", "branch", "-D", testBranch])
+        await spawn(["git", "branch", "-D", testBranch + '.v1'])
+    })
+})

package/dist/bin/bundo.js

@@ -1,45 +0,0 @@
-#!/usr/bin/env bun run
-// @bun
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getProtoOf = Object.getPrototypeOf;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __toESM = (mod, isNodeMode, target) => {
-  target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: () => mod[key],
-        enumerable: true
-      });
-  return to;
-};
-var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
-var __require = (id) => {
-  return import.meta.require(id);
-};
-
-// lib/debug.ts
-function dargv() {
-  if (Bun.env.DEBUG && Bun.env.DEBUG.toLowerCase().includes("gitjira")) {
-    console.log(Bun.argv);
-  }
-}
-
-// lib/spawn.ts
-async function doCommand(args) {
-  const proc = Bun.spawn(args);
-  const stdout = new Response(proc.stdout);
-  const stderr = new Response(proc.stderr);
-  const [out, err] = await Promise.all([stdout.text(), stderr.text()]);
-  if (err)
-    console.error(err);
-  return out.trim();
-}
-
-// bin/bundo.ts
-dargv();
-var args = ["sh", "-c", ...Bun.argv.slice(2)];
-await doCommand(args);