@knpkv/jira-api-client 1.0.1 → 2.0.0

package/src/index.ts

@@ -4,8 +4,10 @@
  * @packageDocumentation
  */
 
-export { JiraApiClient, type JiraApiClientShape, layer, make, type UploadAttachmentInput } from "./JiraApiClient.js"
+export { JiraApiClient, type JiraApiClientContract, layer, make, type UploadAttachmentInput } from "./JiraApiClient.js"
 
-export { JiraApiConfig, type JiraApiConfigShape } from "./JiraApiConfig.js"
+export { JiraApiConfig, type JiraApiConfigContract, type JiraApiCredential } from "./JiraApiConfig.js"
 
 export * as JiraApi from "./generated/JiraApi.js"
+
+export { ownOptionalKey, type PrototypeKey } from "./OwnOptionalKey.js"

package/test/JiraApiClient.test.ts

@@ -1,14 +1,14 @@
 import { describe, expect, it } from "@effect/vitest"
 import * as Effect from "effect/Effect"
+import * as HttpClient from "effect/http/HttpClient"
+import type * as HttpClientRequest from "effect/http/HttpClientRequest"
+import * as HttpClientResponse from "effect/http/HttpClientResponse"
 import * as Layer from "effect/Layer"
 import * as Redacted from "effect/Redacted"
-import * as HttpClient from "effect/unstable/http/HttpClient"
-import type * as HttpClientRequest from "effect/unstable/http/HttpClientRequest"
-import * as HttpClientResponse from "effect/unstable/http/HttpClientResponse"
-import { JiraApiClient, JiraApiConfig, type JiraApiConfigShape } from "../src/index.js"
+import { JiraApiClient, JiraApiConfig, type JiraApiConfigContract } from "../src/index.js"
 
 const clientLayer = (
-  config: JiraApiConfigShape,
+  config: JiraApiConfigContract,
   response: { readonly status: number; readonly body?: unknown },
   requests: Array<HttpClientRequest.HttpClientRequest>
 ) =>
@@ -31,7 +31,7 @@ const clientLayer = (
     ))
   )
 
-const basicConfig: JiraApiConfigShape = {
+const basicConfig: JiraApiConfigContract = {
   baseUrl: "https://jira.test",
   auth: {
     type: "basic",

package/test/JiraApiCredential.test.ts

@@ -0,0 +1,103 @@
+/**
+ * How a request proves who is asking, and when that proof is re-read.
+ *
+ * These build the client with {@link make} rather than through its Layer, because the credential is
+ * resolved inside request preprocessing — the thing under test is what reaches the wire on the
+ * *second* call, which needs nothing from the environment to observe.
+ */
+import { describe, expect, it } from "@effect/vitest"
+import * as Effect from "effect/Effect"
+import { Base64 } from "effect/encoding"
+import * as HttpClient from "effect/http/HttpClient"
+import type * as HttpClientRequest from "effect/http/HttpClientRequest"
+import * as HttpClientResponse from "effect/http/HttpClientResponse"
+import * as Redacted from "effect/Redacted"
+import { type JiraApiCredential, make } from "../src/index.js"
+
+/** An http client that answers every request the same way and records what it was asked. */
+const recording = (requests: Array<HttpClientRequest.HttpClientRequest>) =>
+  HttpClient.make((request) =>
+    Effect.sync(() => {
+      requests.push(request)
+      return HttpClientResponse.fromWeb(
+        request,
+        new Response(JSON.stringify({ id: "10001", key: "PROJ-1", fields: {} }), {
+          status: 200,
+          headers: { "content-type": "application/json" }
+        })
+      )
+    })
+  )
+
+const staleCredential: JiraApiCredential = {
+  type: "oauth2",
+  accessToken: Redacted.make("stale"),
+  cloudId: "cloud-123"
+}
+
+describe("JiraApiClient credentials", () => {
+  // A client is built once and can outlive its credential: `jcf watch` runs all day on an access
+  // token good for about an hour. Before this, the token was read once when the client was built and
+  // baked into a header, so every request after the first expiry 401ed for the life of the process.
+  it.effect("re-reads a refreshing credential on every request", () =>
+    Effect.gen(function*() {
+      const requests: Array<HttpClientRequest.HttpClientRequest> = []
+      let issued = 0
+      const client = make(recording(requests), {
+        baseUrl: "",
+        auth: staleCredential,
+        resolveAuth: Effect.sync(() => {
+          issued += 1
+          return { type: "oauth2", accessToken: Redacted.make(`token-${issued}`), cloudId: "cloud-123" }
+        })
+      })
+
+      yield* client.getIssue("PROJ-1", undefined)
+      yield* client.getIssue("PROJ-1", undefined)
+
+      expect(requests.map((request) => request.headers.authorization)).toEqual([
+        "Bearer token-1",
+        "Bearer token-2"
+      ])
+    }))
+
+  // The host comes from the same value as the header, so a resolver cannot address one site while
+  // authenticating against another.
+  it.effect("routes a refreshed credential at its own cloud id", () =>
+    Effect.gen(function*() {
+      const requests: Array<HttpClientRequest.HttpClientRequest> = []
+      const client = make(recording(requests), {
+        baseUrl: "",
+        auth: staleCredential,
+        resolveAuth: Effect.succeed({
+          type: "oauth2",
+          accessToken: Redacted.make("fresh"),
+          cloudId: "cloud-999"
+        })
+      })
+
+      yield* client.getIssue("PROJ-1", undefined)
+
+      expect(requests[0]?.url).toBe("https://api.atlassian.com/ex/jira/cloud-999/rest/api/3/issue/PROJ-1")
+      expect(requests[0]?.headers.authorization).toBe("Bearer fresh")
+    }))
+
+  // Omitting `resolveAuth` must keep the previous behaviour exactly — right for a basic-auth API
+  // token, which cannot expire and so has nothing to re-read.
+  it.effect("uses the given credential unchanged when no resolver is supplied", () =>
+    Effect.gen(function*() {
+      const requests: Array<HttpClientRequest.HttpClientRequest> = []
+      const client = make(recording(requests), {
+        baseUrl: "https://jira.test",
+        auth: { type: "basic", email: "user@example.com", apiToken: Redacted.make("test-token") }
+      })
+
+      yield* client.getIssue("PROJ-1", undefined)
+      yield* client.getIssue("PROJ-1", undefined)
+
+      // The exact RFC 7617 value for the configured email and token, on every request.
+      const expected = `Basic ${Base64.encode("user@example.com:test-token")}`
+      expect(requests[0]?.url).toBe("https://jira.test/rest/api/3/issue/PROJ-1")
+      expect(requests.map((request) => request.headers.authorization)).toEqual([expected, expected])
+    }))
+})

package/test/OwnOptionalKey.test.ts

@@ -0,0 +1,24 @@
+import { assert, describe, it } from "@effect/vitest"
+import * as Schema from "effect/Schema"
+import { JiraApi } from "../src/index.js"
+
+const decodeChange = Schema.decodeUnknownSync(JiraApi.ChangeDetails)
+
+describe("ownOptionalKey", () => {
+  // Effect reads declared keys with `in`; JSON omitting `toString` must not decode Object.prototype.toString.
+  it("decodes an omitted toString as an absent key", () => {
+    const change = decodeChange(JSON.parse(`{"field":"Comment","fromString":"Previous comment"}`))
+    assert.isFalse(Object.hasOwn(change, "toString"))
+    assert.deepStrictEqual({ ...change }, { field: "Comment", fromString: "Previous comment" })
+  })
+
+  it("keeps an own toString value", () => {
+    const change = decodeChange(JSON.parse(`{"field":"status","toString":"Done"}`))
+    assert.isTrue(Object.hasOwn(change, "toString"))
+    assert.strictEqual(change.toString, "Done")
+  })
+
+  it("rejects an own non-string toString", () => {
+    assert.throws(() => decodeChange(JSON.parse(`{"field":"status","toString":42}`)))
+  })
+})

package/test/RecursiveSchemas.test.ts

@@ -0,0 +1,26 @@
+import { assert, describe, it } from "@effect/vitest"
+import * as Schema from "effect/Schema"
+import { JiraApi } from "../src/index.js"
+
+// @effect/openapi-generator 4.0.0 emits Schema.Never for these recursive unions; the committed client keeps them usable.
+describe("recursive generated schemas", () => {
+  it("decodes a nested JQL query clause", () => {
+    const clause = {
+      clauses: [
+        { field: { name: "project" }, operator: "=", operand: { value: "KNP" } },
+        { clauses: [{ field: { name: "status" }, operator: "!=", operand: { value: "Done" } }], operator: "not" }
+      ],
+      operator: "and"
+    }
+    assert.deepStrictEqual(Schema.decodeUnknownSync(JiraApi.JqlQueryClause)(clause), clause)
+  })
+
+  it("decodes a nested workflow condition tree", () => {
+    const condition = {
+      conditions: [{ nodeType: "simple", type: "PermissionCondition", configuration: { permissionKey: "BROWSE" } }],
+      nodeType: "compound",
+      operator: "AND"
+    }
+    assert.deepStrictEqual(Schema.decodeUnknownSync(JiraApi.WorkflowCondition)(condition), condition)
+  })
+})