@knpkv/jira-api-client 0.4.0 → 1.0.1

package/dist/index.d.ts

@@ -1,18 +1,9 @@
 /**
- * Root barrel export for `@knpkv/jira-api-client` -- openapi-fetch + Effect Jira REST client.
- *
- * **Mental model**
- *
- * - **Namespaced version**: `V3` re-exports the generated OpenAPI types (paths, components, operations).
- * - **Config + client split**: {@link JiraApiConfig} is provided separately from the
- *   generated client to support auth-polymorphic usage.
- * - **openapi-fetch wrapper**: {@link OpenApiFetchClient} provides Effect-based `execute` method
- *   around raw openapi-fetch clients.
+ * Schema-validated Effect client for Jira Cloud REST API v3.
  *
  * @packageDocumentation
  */
-export { JiraApiClient, type JiraApiClientShape, layer } from "./JiraApiClient.js";
+export { JiraApiClient, type JiraApiClientShape, layer, make, type UploadAttachmentInput } from "./JiraApiClient.js";
 export { JiraApiConfig, type JiraApiConfigShape } from "./JiraApiConfig.js";
-export { FetchClientError, type OpenApiFetchClient, type SuccessData, toEffect } from "./OpenApiFetchClient.js";
-export type * as V3 from "./generated/v3/index.js";
+export * as JiraApi from "./generated/JiraApi.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,aAAa,EAAE,KAAK,kBAAkB,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAA;AAElF,OAAO,EAAE,aAAa,EAAE,KAAK,kBAAkB,EAAE,MAAM,oBAAoB,CAAA;AAE3E,OAAO,EAAE,gBAAgB,EAAE,KAAK,kBAAkB,EAAE,KAAK,WAAW,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAA;AAG/G,YAAY,KAAK,EAAE,MAAM,yBAAyB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,aAAa,EAAE,KAAK,kBAAkB,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,qBAAqB,EAAE,MAAM,oBAAoB,CAAA;AAEpH,OAAO,EAAE,aAAa,EAAE,KAAK,kBAAkB,EAAE,MAAM,oBAAoB,CAAA;AAE3E,OAAO,KAAK,OAAO,MAAM,wBAAwB,CAAA"}

package/dist/index.js

@@ -1,17 +1,9 @@
 /**
- * Root barrel export for `@knpkv/jira-api-client` -- openapi-fetch + Effect Jira REST client.
- *
- * **Mental model**
- *
- * - **Namespaced version**: `V3` re-exports the generated OpenAPI types (paths, components, operations).
- * - **Config + client split**: {@link JiraApiConfig} is provided separately from the
- *   generated client to support auth-polymorphic usage.
- * - **openapi-fetch wrapper**: {@link OpenApiFetchClient} provides Effect-based `execute` method
- *   around raw openapi-fetch clients.
+ * Schema-validated Effect client for Jira Cloud REST API v3.
  *
  * @packageDocumentation
  */
-export { JiraApiClient, layer } from "./JiraApiClient.js";
+export { JiraApiClient, layer, make } from "./JiraApiClient.js";
 export { JiraApiConfig } from "./JiraApiConfig.js";
-export { FetchClientError, toEffect } from "./OpenApiFetchClient.js";
+export * as JiraApi from "./generated/JiraApi.js";
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,aAAa,EAA2B,KAAK,EAAE,MAAM,oBAAoB,CAAA;AAElF,OAAO,EAAE,aAAa,EAA2B,MAAM,oBAAoB,CAAA;AAE3E,OAAO,EAAE,gBAAgB,EAA6C,QAAQ,EAAE,MAAM,yBAAyB,CAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,aAAa,EAA2B,KAAK,EAAE,IAAI,EAA8B,MAAM,oBAAoB,CAAA;AAEpH,OAAO,EAAE,aAAa,EAA2B,MAAM,oBAAoB,CAAA;AAE3E,OAAO,KAAK,OAAO,MAAM,wBAAwB,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@knpkv/jira-api-client",
-  "version": "0.4.0",
+  "version": "1.0.1",
   "description": "Effect-based Jira Cloud REST API v3 client",
   "license": "MIT",
   "author": "knpkv",
@@ -30,27 +30,27 @@
       "import": "./dist/JiraApiConfig.js",
       "types": "./dist/JiraApiConfig.d.ts"
     },
-    "./v3": {
-      "import": "./dist/generated/v3/index.js",
-      "types": "./dist/generated/v3/index.d.ts"
+    "./generated": {
+      "import": "./dist/generated/JiraApi.js",
+      "types": "./dist/generated/JiraApi.d.ts"
     }
   },
   "publishConfig": {
     "access": "public"
   },
   "peerDependencies": {
-    "effect": "4.0.0-beta.93"
+    "effect": "4.0.0-beta.98"
   },
   "devDependencies": {
-    "@effect/platform-node": "4.0.0-beta.93",
-    "@effect/vitest": "4.0.0-beta.93",
+    "@effect/openapi-generator": "4.0.0-beta.98",
+    "@effect/platform-node": "4.0.0-beta.98",
+    "@effect/vitest": "4.0.0-beta.98",
     "@types/node": "latest",
-    "effect": "4.0.0-beta.93",
-    "openapi-typescript": "^7.13.0",
-    "openapi-typescript-helpers": "^0.1.0",
+    "effect": "4.0.0-beta.98",
+    "prettier": "^3.9.5",
     "tsx": "^4.23.0",
     "typescript": "~6.0.3",
-    "vitest": "^4.1.9"
+    "vitest": "^4.1.10"
   },
   "keywords": [
     "effect",
@@ -60,17 +60,14 @@
     "api-client",
     "openapi"
   ],
-  "dependencies": {
-    "openapi-fetch": "^0.17.0"
-  },
   "scripts": {
-    "build": "tsc && cp src/generated/v3/schema.d.ts dist/generated/v3/schema.d.ts",
+    "build": "tsc",
     "clean": "rimraf dist dist-test .tsbuildinfo",
     "test": "vitest run",
     "test:watch": "vitest",
     "lint": "eslint src",
     "lint:fix": "eslint src --fix",
-    "check": "tsc --noEmit",
+    "check": "tsc --noEmit && tsc -p scripts/tsconfig.json",
     "regenerate": "tsx scripts/regenerate.ts",
     "regenerate:check": "tsx scripts/regenerate.ts --check"
   }

package/scripts/regenerate.ts

@@ -1,39 +1,30 @@
 #!/usr/bin/env tsx
 /**
- * Regeneration script for Jira API types.
+ * Fetch, compare, patch, normalize, and regenerate the Jira Cloud API client.
  *
- * Fetches OpenAPI specs from Atlassian and regenerates openapi-typescript types.
+ * The committed OpenAPI document is the unmodified upstream document. RFC 6902
+ * patches and deterministic compatibility normalizations are applied in memory.
  */
-import { NodeRuntime, NodeServices } from "@effect/platform-node"
-import * as NodeHttpClient from "@effect/platform-node/NodeHttpClient"
+import * as OpenApiGenerator from "@effect/openapi-generator/OpenApiGenerator"
+import * as OpenApiPatch from "@effect/openapi-generator/OpenApiPatch"
+import { NodeHttpClient, NodeRuntime, NodeServices } from "@effect/platform-node"
 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 type * as JsonSchema from "effect/JsonSchema"
+import * as Layer from "effect/Layer"
 import * as Path from "effect/Path"
-import type * as PlatformError from "effect/PlatformError"
+import * as Predicate from "effect/Predicate"
 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: Readonly<Record<"v3", string>> = {
-  v3: "https://dac-static.atlassian.com/cloud/jira/platform/swagger-v3.v3.json"
-}
-
-interface SpecInfo {
-  version: string
-  title: string
-}
+import * as Command from "effect/unstable/cli/Command"
+import * as Flag from "effect/unstable/cli/Flag"
+import * as HttpClient from "effect/unstable/http/HttpClient"
+import type { OpenAPISpec } from "effect/unstable/httpapi/OpenApi"
+import { format as formatSource } from "prettier"
 
-interface ScriptPaths {
-  readonly packageDir: string
-  readonly specsDir: string
-  readonly versionV3File: string
-  readonly generatedDir: string
-}
+const SPEC_URL = "https://dac-static.atlassian.com/cloud/jira/platform/swagger-v3.v3.json"
+const METHODS = new Set(["get", "put", "post", "delete", "options", "head", "patch", "trace"])
 
 class RegenerateError extends Data.TaggedError("RegenerateError")<{
   readonly message: string
@@ -42,207 +33,224 @@ class RegenerateError extends Data.TaggedError("RegenerateError")<{
 
 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 OpenApiDocument = Schema.declare<OpenAPISpec>(
+  (value): value is OpenAPISpec =>
+    Predicate.hasProperty(value, "paths") &&
+    Predicate.isObject(value.paths) &&
+    Predicate.hasProperty(value, "openapi"),
+  { identifier: "OpenApiDocument" }
+)
 
-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 SpecInfo = Schema.Struct({ info: Schema.Struct({ version: Schema.String }) })
 
-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 }))
-  )
+interface ScriptPaths {
+  readonly specFile: string
+  readonly patchFile: string
+  readonly outputFile: string
+}
 
-const scriptPaths: Effect.Effect<ScriptPaths, RegenerateError, Path.Path> = Effect.gen(function*() {
+const paths = 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 }))
+    Effect.mapError((cause) => new RegenerateError({ message: "Could not resolve script path", cause }))
   )
-  const scriptDir = path.dirname(scriptFile)
-  const packageDir = path.join(scriptDir, "..")
+  const packageDir = path.join(path.dirname(scriptFile), "..")
   const specsDir = path.join(packageDir, ".specs")
-
   return {
-    packageDir,
-    specsDir,
-    versionV3File: path.join(specsDir, "VERSION_V3"),
-    generatedDir: path.join(packageDir, "src", "generated", "v3")
-  }
+    specFile: path.join(specsDir, "jira-v3.json"),
+    patchFile: path.join(specsDir, "jira-v3.patch.json"),
+    outputFile: path.join(packageDir, "src", "generated", "JiraApi.ts")
+  } satisfies ScriptPaths
 })
 
-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 fetchUpstream = HttpClient.get(SPEC_URL).pipe(
+  Effect.flatMap((response) =>
+    response.status >= 200 && response.status < 300
+      ? response.text.pipe(
+        Effect.mapError((cause) => new RegenerateError({ message: "Could not read Jira response", cause }))
+      )
+      : Effect.fail(new RegenerateError({ message: `Jira spec request failed with status ${response.status}` }))
+  ),
+  Effect.flatMap(Schema.decodeUnknownEffect(JsonString)),
+  Effect.mapError((cause) => new RegenerateError({ message: "Could not fetch or decode Jira spec", cause }))
+)
 
-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 canonicalJson = (value: Schema.Json) =>
+  Schema.encodeEffect(JsonString)(value).pipe(
+    Effect.map((json) => `${json}\n`),
+    Effect.mapError((cause) => new RegenerateError({ message: "Could not encode Jira spec", cause }))
+  )
 
-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 formattedJson = (value: Schema.Json) =>
+  Schema.encodeEffect(JsonString)(value).pipe(
+    Effect.flatMap((source) =>
+      Effect.tryPromise({
+        try: () => formatSource(source, { parser: "json", printWidth: 120, trailingComma: "none", semi: false }),
+        catch: (cause) => new RegenerateError({ message: "Could not format Jira spec", cause })
+      })
+    ),
+    Effect.mapError((cause) => new RegenerateError({ message: "Could not format Jira spec", 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 }))
-    )
-  })
+/**
+ * Jira marks mixed objects as open. The generator's intersection type cannot
+ * combine an unrestricted JSON index signature with optional known fields, so
+ * close only those mixed objects. Pure map schemas such as IssueBean.fields
+ * retain their schema-valued additionalProperties and remain dynamic.
+ *
+ * Jira also publishes defaults that contradict enum/array schemas. Defaults
+ * and examples are documentation metadata, not response-validation rules.
+ */
+const normalizeSchema = (schema: JsonSchema.JsonSchema): JsonSchema.JsonSchema => {
+  const { default: _default, examples: _examples, ...normalized } = schema
+  return normalized.additionalProperties === true && Predicate.isObject(normalized.properties)
+    ? { ...normalized, additionalProperties: false }
+    : normalized
+}
 
-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 }))
-    )
+const bodylessErrorContent: Schema.Json = {
+  "application/json": { schema: {} }
+}
 
-    if (exitCode !== 0) {
-      return yield* Effect.fail(new RegenerateError({ message: "Type generation failed", cause: { exitCode } }))
-    }
-  })
+/**
+ * A 204 response can never contain a message body, but Jira attaches empty JSON
+ * schemas to many of them. Remove that misleading content so the generator
+ * emits `void` handlers instead of JSON decoders.
+ *
+ * Atlassian also omits bodies from many documented 4xx/5xx responses. Without
+ * a content schema the generator treats those statuses as successful voids.
+ * Give them a permissive JSON body so they remain failures with status-bearing
+ * generated JiraApiError values.
+ */
+const normalizeResponses = (document: Schema.Json): Schema.Json => {
+  if (!Predicate.isObject(document)) return document
+  const root = document
+  const rootPaths = root.paths
+  if (!Predicate.isObject(rootPaths)) return document
+
+  const normalizedPaths = Object.fromEntries(
+    Object.entries(rootPaths).map(([path, pathItem]) => {
+      if (!Predicate.isObject(pathItem)) return [path, pathItem]
+      const normalizedPathItem = Object.fromEntries(
+        Object.entries(pathItem).map(([key, operation]) => {
+          if (!METHODS.has(key) || !Predicate.isObject(operation) || !Predicate.isObject(operation.responses)) {
+            return [key, operation]
+          }
+          const responses = Object.fromEntries(
+            Object.entries(operation.responses).map(([status, response]) => {
+              const code = Number(status)
+              if (code === 204 && Predicate.isObject(response)) {
+                return [
+                  status,
+                  Object.fromEntries(
+                    Object.entries(response).filter(([key]) => key !== "content")
+                  )
+                ]
+              }
+              if (!Number.isInteger(code) || code < 400 || !Predicate.isObject(response) || "content" in response) {
+                return [status, response]
+              }
+              return [status, { ...response, content: bodylessErrorContent }]
+            })
+          )
+          return [key, { ...operation, responses }]
+        })
+      )
+      return [path, normalizedPathItem]
+    })
+  )
 
-const commandExitCode = (
-  command: ChildProcess.Command
-): Effect.Effect<ChildProcessSpawner.ExitCode, PlatformError.PlatformError, ChildProcessSpawner.ChildProcessSpawner> =>
-  ChildProcessSpawner.ChildProcessSpawner.pipe(
-    Effect.flatMap((spawner) => spawner.exitCode(command))
+  return Schema.decodeUnknownSync(Schema.Json)(
+    Object.fromEntries([...Object.entries(root), ["paths", normalizedPaths]])
   )
+}
 
-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 }))
-    )
+const stripTrailingWhitespace = (source: string): string => source.replace(/[ \t]+$/gm, "")
 
-    if (exitCode !== 0) {
-      return yield* Effect.fail(new RegenerateError({ message: "Formatting failed", cause: { exitCode } }))
-    }
+const generate = Effect.fn("Jira.regenerate.generate")(function*(scriptPaths: ScriptPaths, upstream: Schema.Json) {
+  const fs = yield* FileSystem.FileSystem
+  const patch = yield* OpenApiPatch.parsePatchInput(scriptPaths.patchFile).pipe(
+    Effect.mapError((cause) => new RegenerateError({ message: "Could not parse Jira JSON patch", cause }))
+  )
+  const patched = yield* OpenApiPatch.applyPatches(
+    [{ source: scriptPaths.patchFile, patch }],
+    upstream
+  ).pipe(
+    Effect.mapError((cause) => new RegenerateError({ message: "Could not apply Jira JSON patch", cause }))
+  )
+  const normalized = normalizeResponses(patched)
+  const document = yield* Schema.decodeUnknownEffect(OpenApiDocument)(normalized).pipe(
+    Effect.mapError((cause) => new RegenerateError({ message: "Normalized Jira document is not OpenAPI", cause }))
+  )
+  const generator = yield* OpenApiGenerator.OpenApiGenerator
+  const warnings: Array<OpenApiGenerator.OpenApiGeneratorWarning> = []
+  const generated = yield* generator.generate(document, {
+    name: "JiraApi",
+    format: "httpclient",
+    onEnter: normalizeSchema,
+    onWarning: (warning) => warnings.push(warning)
   })
+  yield* Effect.forEach(
+    warnings,
+    (warning) => Console.warn(`[${warning.code}] ${warning.method ?? ""} ${warning.path ?? ""}: ${warning.message}`),
+    { discard: true }
+  )
+  yield* fs.writeFileString(scriptPaths.outputFile, stripTrailingWhitespace(generated)).pipe(
+    Effect.mapError((cause) => new RegenerateError({ message: "Could not write generated Jira client", cause }))
+  )
+})
 
-const checkOnly = Options.boolean("check").pipe(
-  Options.withDescription("Check only, exit 1 if outdated"),
-  Options.withDefault(false)
+const check = Flag.boolean("check").pipe(
+  Flag.withDescription("Exit non-zero when the committed upstream spec differs from Jira")
 )
 
-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(paths.versionV3File)
-
-    yield* Console.log(`V3: current=${currentV3 ?? "none"}, remote=${v3Info.version}`)
-
-    const v3Changed = currentV3 !== v3Info.version
-
-    if (!v3Changed) {
-      yield* Console.log("Spec is up to date.")
-      return
-    }
-
-    if (checkOnly) {
-      yield* Console.log("Spec is outdated!")
-      yield* Console.log(`  V3: ${currentV3} -> ${v3Info.version}`)
-      return yield* Effect.fail(new RegenerateError({ message: "Spec outdated" }))
-    }
-
-    yield* ensureDir(paths.specsDir)
-    yield* ensureDir(paths.generatedDir)
-
-    const specPath = path.join(paths.specsDir, `jira-v3-${v3Info.version}.json`)
-
-    yield* Console.log(`Fetching V3 spec (${v3Info.version})...`)
-    yield* fetchAndSaveSpec(paths.packageDir, SPEC_URLS.v3, specPath)
-    yield* Console.log(`Saved: ${specPath}`)
-
-    yield* Console.log("Generating types...")
-    yield* generateTypes(paths.packageDir, paths.generatedDir, specPath)
-    yield* Console.log(`Generated: src/generated/v3/schema.d.ts`)
+const local = Flag.boolean("local").pipe(
+  Flag.withDescription("Regenerate from the committed spec without contacting Jira")
+)
 
-    yield* writeVersion(paths.versionV3File, v3Info.version)
-    yield* Console.log("Done!")
-  })).pipe(Command.withDescription("Regenerate Jira API types from OpenAPI specs"))
+const root = Command.make("jira-api-regenerate", { check, local }).pipe(
+  Command.withHandler(
+    Effect.fn("Jira.regenerate")(function*({ check, local }) {
+      const fs = yield* FileSystem.FileSystem
+      const scriptPaths = yield* paths
+      const upstream = local
+        ? yield* fs.readFileString(scriptPaths.specFile).pipe(
+          Effect.flatMap(Schema.decodeUnknownEffect(JsonString)),
+          Effect.mapError((cause) => new RegenerateError({ message: "Could not read committed Jira spec", cause }))
+        )
+        : yield* fetchUpstream
+      const encoded = yield* canonicalJson(upstream)
+      const current = yield* fs.readFileString(scriptPaths.specFile).pipe(
+        Effect.flatMap(Schema.decodeUnknownEffect(JsonString)),
+        Effect.flatMap(canonicalJson),
+        Effect.orElseSucceed(() => "")
+      )
+
+      if (check) {
+        if (local) return yield* new RegenerateError({ message: "--check and --local cannot be combined" })
+        if (current === encoded) return yield* Console.log("Jira OpenAPI spec is current.")
+        return yield* new RegenerateError({
+          message: "Jira OpenAPI spec changed; run `pnpm --filter @knpkv/jira-api-client regenerate`"
+        })
+      }
+
+      const { info } = yield* Schema.decodeUnknownEffect(SpecInfo)(upstream).pipe(
+        Effect.mapError((cause) => new RegenerateError({ message: "Jira spec has no version", cause }))
+      )
+      yield* fs.writeFileString(scriptPaths.specFile, yield* formattedJson(upstream))
+      yield* generate(scriptPaths, upstream)
+      yield* Console.log(`Generated Jira ${info.version} client from ${local ? "the committed spec" : SPEC_URL}`)
+    })
+  )
+)
 
-const cli = Command.run(regenerate, {
-  name: pkg.name,
-  version: pkg.version
-})
+const MainLayer = Layer.mergeAll(
+  OpenApiGenerator.layerTransformerSchema,
+  NodeHttpClient.layerFetch,
+  NodeServices.layer
+)
 
-cli.pipe(
-  Effect.provide(NodeHttpClient.layerFetch),
-  Effect.provide(NodeServices.layer),
+Command.run(root, { version: "1.0.0" }).pipe(
+  Effect.provide(MainLayer),
   NodeRuntime.runMain
 )

package/scripts/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "extends": "../../../tsconfig.base.jsonc",
+  "compilerOptions": {
+    "composite": false,
+    "declaration": false,
+    "declarationMap": false,
+    "incremental": false,
+    "noEmit": true,
+    "rootDir": "..",
+    "types": ["node"]
+  },
+  "include": ["./**/*.ts"]
+}