@knpkv/jira-api-client 0.3.0 → 0.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@knpkv/jira-api-client",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Effect-based Jira Cloud REST API v3 client",
   "license": "MIT",
   "author": "knpkv",
@@ -39,16 +39,16 @@
     "access": "public"
   },
   "peerDependencies": {
-    "effect": "4.0.0-beta.87"
+    "effect": "4.0.0-beta.93"
   },
   "devDependencies": {
-    "@effect/platform-node": "4.0.0-beta.87",
-    "@effect/vitest": "4.0.0-beta.87",
+    "@effect/platform-node": "4.0.0-beta.93",
+    "@effect/vitest": "4.0.0-beta.93",
     "@types/node": "latest",
-    "effect": "4.0.0-beta.87",
+    "effect": "4.0.0-beta.93",
     "openapi-typescript": "^7.13.0",
     "openapi-typescript-helpers": "^0.1.0",
-    "tsx": "^4.22.4",
+    "tsx": "^4.23.0",
     "typescript": "~6.0.3",
     "vitest": "^4.1.9"
   },

package/scripts/regenerate.ts

@@ -4,23 +4,24 @@
  *
  * Fetches OpenAPI specs from Atlassian and regenerates openapi-typescript types.
  */
-import { Command, Flag as Options } from "effect/unstable/cli"
 import { NodeRuntime, NodeServices } from "@effect/platform-node"
 import * as NodeHttpClient from "@effect/platform-node/NodeHttpClient"
 import * as Console from "effect/Console"
+import * as Data from "effect/Data"
 import * as Effect from "effect/Effect"
 import * as FileSystem from "effect/FileSystem"
 import * as Path from "effect/Path"
-import * as PlatformError from "effect/PlatformError"
-import * as Stdio from "effect/Stdio"
+import type * as PlatformError from "effect/PlatformError"
+import * as Schema from "effect/Schema"
+import { Command, Flag as Options } from "effect/unstable/cli"
 import { HttpClient } from "effect/unstable/http"
 import * as ChildProcess from "effect/unstable/process/ChildProcess"
 import * as ChildProcessSpawner from "effect/unstable/process/ChildProcessSpawner"
 import pkg from "../package.json" with { type: "json" }
 
-const SPEC_URLS = {
+const SPEC_URLS: Readonly<Record<"v3", string>> = {
   v3: "https://dac-static.atlassian.com/cloud/jira/platform/swagger-v3.v3.json"
-} as const
+}
 
 interface SpecInfo {
   version: string
@@ -34,30 +35,48 @@ interface ScriptPaths {
   readonly generatedDir: string
 }
 
-const fetchText = (url: string): Effect.Effect<string, Error, HttpClient.HttpClient> =>
+class RegenerateError extends Data.TaggedError("RegenerateError")<{
+  readonly message: string
+  readonly cause?: unknown
+}> {}
+
+const JsonString = Schema.fromJsonString(Schema.Json)
+
+const SpecInfoResponse = Schema.Struct({
+  info: Schema.Struct({
+    version: Schema.String,
+    title: Schema.String
+  })
+})
+
+const fetchText = (url: string): Effect.Effect<string, RegenerateError, HttpClient.HttpClient> =>
   HttpClient.get(url).pipe(
     Effect.flatMap((response) =>
       response.status >= 200 && response.status < 300
         ? response.text
-        : Effect.fail(new Error(`Failed to fetch ${url}: ${response.status}`))
+        : Effect.fail(new RegenerateError({ message: `Failed to fetch ${url}`, cause: { status: response.status } }))
     ),
-    Effect.mapError((e) => e instanceof Error ? e : new Error(`Fetch failed: ${e}`))
+    Effect.mapError((cause) => new RegenerateError({ message: `Fetch failed: ${url}`, cause }))
   )
 
-const fetchJson = <A>(url: string): Effect.Effect<A, Error, HttpClient.HttpClient> =>
+const fetchSpecInfo = (url: string): Effect.Effect<SpecInfo, RegenerateError, HttpClient.HttpClient> =>
   fetchText(url).pipe(
-    Effect.flatMap((text) =>
-      Effect.try({
-        try: () => JSON.parse(text) as A,
-        catch: (e) => new Error(`JSON parse failed: ${e}`)
-      })
-    )
+    Effect.flatMap(Schema.decodeUnknownEffect(Schema.fromJsonString(SpecInfoResponse))),
+    Effect.map(({ info }) => ({ version: info.version, title: info.title })),
+    Effect.mapError((cause) => new RegenerateError({ message: "JSON decode failed", cause }))
+  )
+
+const formatJson = (text: string): Effect.Effect<string, RegenerateError> =>
+  Schema.decodeUnknownEffect(JsonString)(text).pipe(
+    Effect.flatMap(Schema.encodeEffect(JsonString)),
+    Effect.map((encoded) => `${encoded}\n`),
+    Effect.mapError((cause) => new RegenerateError({ message: "JSON format failed", cause }))
   )
 
-const scriptPaths: Effect.Effect<ScriptPaths, Error, Path.Path> = Effect.gen(function*() {
+const scriptPaths: Effect.Effect<ScriptPaths, RegenerateError, Path.Path> = Effect.gen(function*() {
   const path = yield* Path.Path
   const scriptFile = yield* path.fromFileUrl(new URL(import.meta.url)).pipe(
-    Effect.mapError((e) => new Error(`Script path resolution failed: ${e.message}`))
+    Effect.mapError((cause) => new RegenerateError({ message: "Script path resolution failed", cause }))
   )
   const scriptDir = path.dirname(scriptFile)
   const packageDir = path.join(scriptDir, "..")
@@ -71,50 +90,52 @@ const scriptPaths: Effect.Effect<ScriptPaths, Error, Path.Path> = Effect.gen(fun
   }
 })
 
-const fetchSpecInfo = (url: string): Effect.Effect<SpecInfo, Error, HttpClient.HttpClient> =>
-  fetchJson<{ info: { version: string; title: string } }>(url).pipe(
-    Effect.map((spec) => ({ version: spec.info.version, title: spec.info.title }))
-  )
-
 const fetchAndSaveSpec = (
+  packageDir: string,
   url: string,
   outputPath: string
-): Effect.Effect<void, Error, FileSystem.FileSystem | HttpClient.HttpClient> =>
+): Effect.Effect<
+  void,
+  RegenerateError,
+  ChildProcessSpawner.ChildProcessSpawner | FileSystem.FileSystem | HttpClient.HttpClient
+> =>
   Effect.gen(function*() {
     const fs = yield* FileSystem.FileSystem
     const spec = yield* fetchText(url)
-    yield* fs.writeFileString(outputPath, spec).pipe(
-      Effect.mapError((e) => new Error(`Save failed: ${e.message}`))
+    const formattedSpec = yield* formatJson(spec)
+    yield* fs.writeFileString(outputPath, formattedSpec).pipe(
+      Effect.mapError((cause) => new RegenerateError({ message: "Save failed", cause }))
     )
+    yield* formatFile(packageDir, outputPath)
   })
 
-const readVersion = (file: string): Effect.Effect<string | null, Error, FileSystem.FileSystem> =>
+const readVersion = (file: string): Effect.Effect<string | null, RegenerateError, FileSystem.FileSystem> =>
   Effect.gen(function*() {
     const fs = yield* FileSystem.FileSystem
     const exists = yield* fs.exists(file).pipe(
-      Effect.mapError((e) => new Error(`Version lookup failed: ${e.message}`))
+      Effect.mapError((cause) => new RegenerateError({ message: "Version lookup failed", cause }))
     )
     if (!exists) return null
 
     return yield* fs.readFileString(file).pipe(
       Effect.map((version) => version.trim()),
-      Effect.mapError((e) => new Error(`Version read failed: ${e.message}`))
+      Effect.mapError((cause) => new RegenerateError({ message: "Version read failed", cause }))
     )
   })
 
-const writeVersion = (file: string, version: string): Effect.Effect<void, Error, FileSystem.FileSystem> =>
+const writeVersion = (file: string, version: string): Effect.Effect<void, RegenerateError, FileSystem.FileSystem> =>
   Effect.gen(function*() {
     const fs = yield* FileSystem.FileSystem
     yield* fs.writeFileString(file, version).pipe(
-      Effect.mapError((e) => new Error(`Version write failed: ${e.message}`))
+      Effect.mapError((cause) => new RegenerateError({ message: "Version write failed", cause }))
     )
   })
 
-const ensureDir = (dir: string): Effect.Effect<void, Error, FileSystem.FileSystem> =>
+const ensureDir = (dir: string): Effect.Effect<void, RegenerateError, FileSystem.FileSystem> =>
   Effect.gen(function*() {
     const fs = yield* FileSystem.FileSystem
     yield* fs.makeDirectory(dir, { recursive: true }).pipe(
-      Effect.mapError((e) => new Error(`Directory creation failed: ${e.message}`))
+      Effect.mapError((cause) => new RegenerateError({ message: "Directory creation failed", cause }))
     )
   })
 
@@ -122,7 +143,7 @@ const generateTypes = (
   packageDir: string,
   generatedDir: string,
   specPath: string
-): Effect.Effect<void, Error, ChildProcessSpawner.ChildProcessSpawner | Path.Path> =>
+): Effect.Effect<void, RegenerateError, ChildProcessSpawner.ChildProcessSpawner | Path.Path> =>
   Effect.gen(function*() {
     const path = yield* Path.Path
     const outputFile = path.join(generatedDir, "schema.d.ts")
@@ -133,11 +154,11 @@ const generateTypes = (
       stderr: "inherit"
     })
     const exitCode = yield* commandExitCode(command).pipe(
-      Effect.mapError((e) => new Error(`Type generation failed: ${e.message}`))
+      Effect.mapError((cause) => new RegenerateError({ message: "Type generation failed", cause }))
     )
 
     if (exitCode !== 0) {
-      return yield* Effect.fail(new Error(`Type generation failed with exit code ${exitCode}`))
+      return yield* Effect.fail(new RegenerateError({ message: "Type generation failed", cause: { exitCode } }))
     }
   })
 
@@ -148,9 +169,25 @@ const commandExitCode = (
     Effect.flatMap((spawner) => spawner.exitCode(command))
   )
 
-const readArgv: Effect.Effect<ReadonlyArray<string>, never, Stdio.Stdio> = Stdio.Stdio.pipe(
-  Effect.flatMap((stdio) => stdio.args)
-)
+const formatFile = (
+  packageDir: string,
+  file: string
+): Effect.Effect<void, RegenerateError, ChildProcessSpawner.ChildProcessSpawner> =>
+  Effect.gen(function*() {
+    const command = ChildProcess.make("pnpm", ["exec", "prettier", "--write", file], {
+      cwd: packageDir,
+      stdin: "inherit",
+      stdout: "inherit",
+      stderr: "inherit"
+    })
+    const exitCode = yield* commandExitCode(command).pipe(
+      Effect.mapError((cause) => new RegenerateError({ message: "Formatting failed", cause }))
+    )
+
+    if (exitCode !== 0) {
+      return yield* Effect.fail(new RegenerateError({ message: "Formatting failed", cause: { exitCode } }))
+    }
+  })
 
 const checkOnly = Options.boolean("check").pipe(
   Options.withDescription("Check only, exit 1 if outdated"),
@@ -179,7 +216,7 @@ const regenerate = Command.make("regenerate", { checkOnly }, ({ checkOnly }) =>
     if (checkOnly) {
       yield* Console.log("Spec is outdated!")
       yield* Console.log(`  V3: ${currentV3} -> ${v3Info.version}`)
-      return yield* Effect.fail(new Error("Spec outdated"))
+      return yield* Effect.fail(new RegenerateError({ message: "Spec outdated" }))
     }
 
     yield* ensureDir(paths.specsDir)
@@ -188,7 +225,7 @@ const regenerate = Command.make("regenerate", { checkOnly }, ({ checkOnly }) =>
     const specPath = path.join(paths.specsDir, `jira-v3-${v3Info.version}.json`)
 
     yield* Console.log(`Fetching V3 spec (${v3Info.version})...`)
-    yield* fetchAndSaveSpec(SPEC_URLS.v3, specPath)
+    yield* fetchAndSaveSpec(paths.packageDir, SPEC_URLS.v3, specPath)
     yield* Console.log(`Saved: ${specPath}`)
 
     yield* Console.log("Generating types...")
@@ -197,18 +234,14 @@ const regenerate = Command.make("regenerate", { checkOnly }, ({ checkOnly }) =>
 
     yield* writeVersion(paths.versionV3File, v3Info.version)
     yield* Console.log("Done!")
-  })
-).pipe(Command.withDescription("Regenerate Jira API types from OpenAPI specs"))
+  })).pipe(Command.withDescription("Regenerate Jira API types from OpenAPI specs"))
 
 const cli = Command.run(regenerate, {
   name: pkg.name,
   version: pkg.version
 })
 
-Effect.gen(function*() {
-  const argv = yield* readArgv
-  yield* cli(argv)
-}).pipe(
+cli.pipe(
   Effect.provide(NodeHttpClient.layerFetch),
   Effect.provide(NodeServices.layer),
   NodeRuntime.runMain

package/src/JiraApiClient.ts

@@ -110,8 +110,7 @@ export class JiraApiClient extends Context.Service<JiraApiClient, JiraApiClientS
 
       const headers = {
         Authorization: authHeader,
-        Accept: "application/json",
-        "Content-Type": "application/json"
+        Accept: "application/json"
       }
 
       return {

package/src/OpenApiFetchClient.ts

@@ -31,8 +31,20 @@ export class FetchClientError extends Data.TaggedError("FetchClientError")<{
 
 /** Extract success `data` from a FetchResponse discriminated union. */
 export type SuccessData<T> = T extends { data: infer D; error?: undefined } ? D
-  : T extends { data?: infer D } ? NonNullable<D>
-  : never
+  : T extends { data?: infer D } ? D | undefined
+  : undefined
+
+const isRecord = (value: unknown): value is Readonly<Record<PropertyKey, unknown>> =>
+  typeof value === "object" && value !== null
+
+const errorPayload = (value: unknown): unknown => isRecord(value) && "error" in value ? value.error : value
+
+const errorStatus = (value: unknown): number => isRecord(value) && typeof value.status === "number" ? value.status : 0
+
+const errorMessage = (value: unknown): string => {
+  const payload = errorPayload(value)
+  return typeof payload === "string" ? payload : JSON.stringify(payload)
+}
 
 /**
  * Wrap an openapi-fetch `Promise<FetchResponse>` in Effect.
@@ -57,15 +69,13 @@ export const toEffect = <T extends Record<string | number, any>, O, M extends Me
         if (error !== undefined || !response.ok) {
           throw { error, status: response.status }
         }
-        return data as SuccessData<FetchResponse<T, O, M>>
+        return data
       }),
     catch: (e) =>
       new FetchClientError({
-        error: (e as Record<string, unknown>).error ?? e,
-        status: ((e as Record<string, unknown>).status as number | undefined) ?? 0,
-        message: typeof (e as Record<string, unknown>).error === "string"
-          ? (e as Record<string, unknown>).error as string
-          : JSON.stringify((e as Record<string, unknown>).error ?? e)
+        error: errorPayload(e),
+        status: errorStatus(e),
+        message: errorMessage(e)
       })
   })
 
@@ -76,7 +86,7 @@ export const toEffect = <T extends Record<string | number, any>, O, M extends Me
  */
 export interface OpenApiFetchClient<Paths extends {}> {
   /** Type-safe openapi-fetch client. Use with `toEffect()` to get Effect. */
-  readonly client: Client<Paths, "application/json">
+  readonly client: Client<Paths>
 }
 
 /**
@@ -88,5 +98,5 @@ export const makeOpenApiFetchClient = <Paths extends {}>(
   baseUrl: string,
   headers: Record<string, string>
 ): OpenApiFetchClient<Paths> => ({
-  client: createClient<Paths, "application/json">({ baseUrl, headers })
+  client: createClient<Paths>({ baseUrl, headers })
 })