ya-git-jira 1.2.0 → 1.3.0

package/lib/gitlab.ts

@@ -0,0 +1,86 @@
+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}`)
+}

package/lib/jira.ts

@@ -1,12 +1,29 @@
 
-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> {
     const method = "GET"
@@ -26,14 +43,6 @@ export async function get(endpoint: string): Promise<JSONValue> {
     return await response.json()
 }
 
-type Issue = JSONValue & {
-    key: string,
-    self: string,
-    fields: {
-        summary: string
-    }
-}
-
 export async function getIssue(issue: string): Promise<Issue> {
     return await get(`/issue/${issue}`) as Issue
 }

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,18 +1,23 @@
 {
   "name": "ya-git-jira",
   "description": "git extensions for Jira integration. Assumes bun is installed.",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "module": "dist/index.js",
   "type": "module",
   "bin": {
-    "gitj": "dist/bin/gitj.js",
-    "git-jira": "dist/bin/git-jira.js",
-    "git-jira-start": "dist/bin/git-jira-start.js",
+    "git-bump": "dist/bin/git-bump.js",
+    "git-jira-issue": "dist/bin/git-jira-issue.js",
     "git-jira-issues": "dist/bin/git-jira-issues.js",
-    "git-bump": "dist/bin/git-bump.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-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",
@@ -25,7 +30,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/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)
+})
+
+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)
+})

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("A set of 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);