@knpkv/jira-api-client 0.2.0 → 0.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@knpkv/jira-api-client",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "Effect-based Jira Cloud REST API v3 client",
   "license": "MIT",
   "author": "knpkv",
@@ -39,19 +39,18 @@
     "access": "public"
   },
   "peerDependencies": {
-    "effect": "^3.19.3"
+    "effect": "4.0.0-beta.93"
   },
   "devDependencies": {
-    "@effect/cli": "latest",
-    "@effect/platform-node": "latest",
-    "@effect/vitest": "latest",
+    "@effect/platform-node": "4.0.0-beta.93",
+    "@effect/vitest": "4.0.0-beta.93",
     "@types/node": "latest",
-    "effect": "latest",
+    "effect": "4.0.0-beta.93",
     "openapi-typescript": "^7.13.0",
     "openapi-typescript-helpers": "^0.1.0",
-    "tsx": "^4.19.4",
-    "typescript": "~5.9.0",
-    "vitest": "^4.0.13"
+    "tsx": "^4.23.0",
+    "typescript": "~6.0.3",
+    "vitest": "^4.1.9"
   },
   "keywords": [
     "effect",

package/scripts/regenerate.ts

@@ -4,21 +4,21 @@
  *
  * Fetches OpenAPI specs from Atlassian and regenerates openapi-typescript types.
  */
-import { Command, Options } from "@effect/cli"
-import { NodeContext, NodeRuntime } from "@effect/platform-node"
+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 { execSync } from "node:child_process"
-import * as fs from "node:fs"
-import * as path from "node:path"
-import { fileURLToPath } from "node:url"
+import * as FileSystem from "effect/FileSystem"
+import * as Path from "effect/Path"
+import * as PlatformError from "effect/PlatformError"
+import * as Schema from "effect/Schema"
+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 __dirname = path.dirname(fileURLToPath(import.meta.url))
-const SPECS_DIR = path.join(__dirname, "..", ".specs")
-const VERSION_V3_FILE = path.join(SPECS_DIR, "VERSION_V3")
-const GENERATED_DIR = path.join(__dirname, "..", "src", "generated", "v3")
-
 const SPEC_URLS = {
   v3: "https://dac-static.atlassian.com/cloud/jira/platform/swagger-v3.v3.json"
 } as const
@@ -28,61 +28,165 @@ interface SpecInfo {
   title: string
 }
 
-const fetchSpecInfo = (url: string): Effect.Effect<SpecInfo, Error> =>
-  Effect.tryPromise({
-    try: async () => {
-      const response = await fetch(url)
-      if (!response.ok) {
-        throw new Error(`Failed to fetch ${url}: ${response.status}`)
-      }
-      const spec = await response.json() as { info: { version: string; title: string } }
-      return { version: spec.info.version, title: spec.info.title }
-    },
-    catch: (e) => new Error(`Fetch failed: ${e}`)
+interface ScriptPaths {
+  readonly packageDir: string
+  readonly specsDir: string
+  readonly versionV3File: string
+  readonly generatedDir: string
+}
+
+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 RegenerateError({ message: `Failed to fetch ${url}`, cause: { status: response.status } }))
+    ),
+    Effect.mapError((cause) => new RegenerateError({ message: `Fetch failed: ${url}`, cause }))
+  )
+
+const fetchSpecInfo = (url: string): Effect.Effect<SpecInfo, RegenerateError, HttpClient.HttpClient> =>
+  fetchText(url).pipe(
+    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, RegenerateError, Path.Path> = Effect.gen(function*() {
+  const path = yield* Path.Path
+  const scriptFile = yield* path.fromFileUrl(new URL(import.meta.url)).pipe(
+    Effect.mapError((cause) => new RegenerateError({ message: "Script path resolution failed", cause }))
+  )
+  const scriptDir = path.dirname(scriptFile)
+  const packageDir = path.join(scriptDir, "..")
+  const specsDir = path.join(packageDir, ".specs")
+
+  return {
+    packageDir,
+    specsDir,
+    versionV3File: path.join(specsDir, "VERSION_V3"),
+    generatedDir: path.join(packageDir, "src", "generated", "v3")
+  }
+})
 
-const fetchAndSaveSpec = (url: string, outputPath: string): Effect.Effect<void, Error> =>
-  Effect.tryPromise({
-    try: async () => {
-      const response = await fetch(url)
-      if (!response.ok) {
-        throw new Error(`Failed to fetch ${url}: ${response.status}`)
-      }
-      const spec = await response.text()
-      fs.writeFileSync(outputPath, spec, "utf-8")
-    },
-    catch: (e) => new Error(`Fetch/save failed: ${e}`)
+const fetchAndSaveSpec = (
+  packageDir: string,
+  url: string,
+  outputPath: string
+): Effect.Effect<
+  void,
+  RegenerateError,
+  ChildProcessSpawner.ChildProcessSpawner | FileSystem.FileSystem | HttpClient.HttpClient
+> =>
+  Effect.gen(function*() {
+    const fs = yield* FileSystem.FileSystem
+    const spec = yield* fetchText(url)
+    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> =>
-  Effect.sync(() => {
-    try {
-      return fs.readFileSync(file, "utf-8").trim()
-    } catch {
-      return null
-    }
+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((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((cause) => new RegenerateError({ message: "Version read failed", cause }))
+    )
   })
 
-const writeVersion = (file: string, version: string): Effect.Effect<void> =>
-  Effect.sync(() => fs.writeFileSync(file, version, "utf-8"))
+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((cause) => new RegenerateError({ message: "Version write failed", cause }))
+    )
+  })
+
+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((cause) => new RegenerateError({ message: "Directory creation failed", cause }))
+    )
+  })
 
-const ensureDir = (dir: string): Effect.Effect<void> =>
-  Effect.sync(() => {
-    if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true })
+const generateTypes = (
+  packageDir: string,
+  generatedDir: string,
+  specPath: string
+): Effect.Effect<void, RegenerateError, ChildProcessSpawner.ChildProcessSpawner | Path.Path> =>
+  Effect.gen(function*() {
+    const path = yield* Path.Path
+    const outputFile = path.join(generatedDir, "schema.d.ts")
+    const command = ChildProcess.make("pnpm", ["exec", "openapi-typescript", specPath, "-o", outputFile], {
+      cwd: packageDir,
+      stdin: "inherit",
+      stdout: "inherit",
+      stderr: "inherit"
+    })
+    const exitCode = yield* commandExitCode(command).pipe(
+      Effect.mapError((cause) => new RegenerateError({ message: "Type generation failed", cause }))
+    )
+
+    if (exitCode !== 0) {
+      return yield* Effect.fail(new RegenerateError({ message: "Type generation failed", cause: { exitCode } }))
     }
   })
 
-const generateTypes = (specPath: string): Effect.Effect<void, Error> =>
-  Effect.tryPromise({
-    try: async () => {
-      const outputFile = path.join(GENERATED_DIR, "schema.d.ts")
-      execSync(
-        `pnpm exec openapi-typescript "${specPath}" -o "${outputFile}"`,
-        { cwd: path.join(__dirname, "..") }
-      )
-    },
-    catch: (e) => new Error(`Type generation failed: ${e}`)
+const commandExitCode = (
+  command: ChildProcess.Command
+): Effect.Effect<ChildProcessSpawner.ExitCode, PlatformError.PlatformError, ChildProcessSpawner.ChildProcessSpawner> =>
+  ChildProcessSpawner.ChildProcessSpawner.pipe(
+    Effect.flatMap((spawner) => spawner.exitCode(command))
+  )
+
+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(
@@ -92,10 +196,13 @@ const checkOnly = Options.boolean("check").pipe(
 
 const regenerate = Command.make("regenerate", { checkOnly }, ({ checkOnly }) =>
   Effect.gen(function*() {
+    const path = yield* Path.Path
+    const paths = yield* scriptPaths
+
     yield* Console.log("Fetching Jira API spec version...")
 
     const v3Info = yield* fetchSpecInfo(SPEC_URLS.v3)
-    const currentV3 = yield* readVersion(VERSION_V3_FILE)
+    const currentV3 = yield* readVersion(paths.versionV3File)
 
     yield* Console.log(`V3: current=${currentV3 ?? "none"}, remote=${v3Info.version}`)
 
@@ -109,23 +216,23 @@ 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(SPECS_DIR)
-    yield* ensureDir(GENERATED_DIR)
+    yield* ensureDir(paths.specsDir)
+    yield* ensureDir(paths.generatedDir)
 
-    const specPath = path.join(SPECS_DIR, `jira-v3-${v3Info.version}.json`)
+    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...")
-    yield* generateTypes(specPath)
+    yield* generateTypes(paths.packageDir, paths.generatedDir, specPath)
     yield* Console.log(`Generated: src/generated/v3/schema.d.ts`)
 
-    yield* writeVersion(VERSION_V3_FILE, v3Info.version)
+    yield* writeVersion(paths.versionV3File, v3Info.version)
     yield* Console.log("Done!")
   })
 ).pipe(Command.withDescription("Regenerate Jira API types from OpenAPI specs"))
@@ -135,7 +242,8 @@ const cli = Command.run(regenerate, {
   version: pkg.version
 })
 
-Effect.suspend(() => cli(process.argv)).pipe(
-  Effect.provide(NodeContext.layer),
+cli.pipe(
+  Effect.provide(NodeHttpClient.layerFetch),
+  Effect.provide(NodeServices.layer),
   NodeRuntime.runMain
 )

package/src/JiraApiClient.ts

@@ -85,9 +85,9 @@ export interface JiraApiClientShape {
  *
  * @category Client
  */
-export class JiraApiClient extends Context.Tag(
+export class JiraApiClient extends Context.Service<JiraApiClient, JiraApiClientShape>()(
   "@knpkv/jira-api-client/JiraApiClient"
-)<JiraApiClient, JiraApiClientShape>() {
+) {
   /**
    * Layer that provides JiraApiClient.
    *

package/src/JiraApiConfig.ts

@@ -46,6 +46,6 @@ export interface JiraApiConfigShape {
  *
  * @category Config
  */
-export class JiraApiConfig extends Context.Tag(
+export class JiraApiConfig extends Context.Service<JiraApiConfig, JiraApiConfigShape>()(
   "@knpkv/jira-api-client/JiraApiConfig"
-)<JiraApiConfig, JiraApiConfigShape>() {}
+) {}