@knpkv/clockify-api-client 0.3.0 → 1.0.1

package/src/ClockifyApiClient.ts

@@ -1,50 +1,40 @@
 /**
- * Effect Layer wrapping openapi-fetch Clockify v1 client with auth and base URL.
+ * Schema-validated Clockify API client.
  *
- * **Mental model**
- *
- * - **Auth via X-Api-Key**: The layer reads {@link ClockifyApiConfig} to build the
- *   `X-Api-Key` header and derive the base URL.
- * - **openapi-fetch wrapper**: Uses {@link OpenApiFetchClient} for type-safe HTTP calls.
- * - **Method-based interface**: Exposes convenience methods (getUser, createTimeEntry, etc.)
- *   for backwards compatibility with jira-clockify consumers.
- * - **Raw API access**: `.api` exposes the raw `OpenApiFetchClient<paths>` for direct access.
- *
- * **Common tasks**
- *
- * - Use the client: `const clockify = yield* ClockifyApiClient`
- * - Call a method: `clockify.getProjects(workspaceId)`
- * - Raw access: `toEffect(clockify.api.client.GET("/v1/user"))`
- * - Provide the layer: `Effect.provide(ClockifyApiClient.layer)`
+ * The OpenAPI generator owns request construction and response decoding. This
+ * module only applies Clockify authentication and provides domain conveniences
+ * used by the timer application.
  *
  * @module
  */
 import * as Context from "effect/Context"
 import * as Effect from "effect/Effect"
+import { flow } from "effect/Function"
 import * as Layer from "effect/Layer"
 import * as Redacted from "effect/Redacted"
+import type { SchemaError } from "effect/Schema"
+import * as HttpClient from "effect/unstable/http/HttpClient"
+import type * as HttpClientError from "effect/unstable/http/HttpClientError"
+import * as HttpClientRequest from "effect/unstable/http/HttpClientRequest"
+import * as HttpClientResponse from "effect/unstable/http/HttpClientResponse"
 import { ClockifyApiConfig } from "./ClockifyApiConfig.js"
-import type { components, paths } from "./generated/schema.js"
-import {
-  type FetchClientError,
-  makeOpenApiFetchClient,
-  type OpenApiFetchClient,
-  toEffect
-} from "./OpenApiFetchClient.js"
-
-// ---------------------------------------------------------------------------
-// Domain types — derived from patched OpenAPI spec schema
-// ---------------------------------------------------------------------------
-
-export type User = components["schemas"]["UserDto"]
-export type Workspace = components["schemas"]["WorkspaceDtoV1"]
-export type Project = components["schemas"]["ProjectDtoV1"]
-export type Tag = components["schemas"]["TagDto"]
-export type TimeInterval = components["schemas"]["TimeIntervalDto"]
-export type TimeEntry = components["schemas"]["TimeEntryDto"]
-export type CreateTimeEntryParams = components["schemas"]["CreateTimeEntryRequest"]
-export type StopTimeEntryParams = components["schemas"]["StopTimeEntryRequest"]
-export type UpdateTimeEntryParams = components["schemas"]["UpdateTimeEntryRequest"]
+import * as Generated from "./generated/ClockifyApi.js"
+
+export type ClockifyClientError = HttpClientError.HttpClientError | SchemaError
+
+export type User = Generated.GetLoggedUser200
+export type Workspace = Generated.GetWorkspacesOfUser200[number]
+export type Project = Generated.GetProjects200[number]
+export type Tag = Generated.GetTags200[number]
+export type TimeEntry = Generated.GetTimeEntries200[number] | Generated.CreateTimeEntry201
+export type TimeInterval = NonNullable<TimeEntry["timeInterval"]>
+export type CreateTimeEntryParams = Generated.CreateTimeEntryRequestJson
+export type StopTimeEntryParams = Generated.StopRunningTimeEntryRequestJson
+export type UpdateTimeEntryParams = Generated.UpdateTimeEntryRequestJson
+
+export type AuthenticatedClockifyApi = Omit<Generated.ClockifyApi, "uploadImage"> & {
+  readonly uploadImage: (input: { readonly file: Blob }) => Effect.Effect<Generated.UploadImage200, ClockifyClientError>
+}
 
 export interface GetTimeEntriesParams {
   readonly start?: string | undefined
@@ -53,226 +43,135 @@ export interface GetTimeEntriesParams {
   readonly pageSize?: number | undefined
 }
 
-// ---------------------------------------------------------------------------
-// Client shape
-// ---------------------------------------------------------------------------
-
 export interface ClockifyApiClientShape {
-  /** Raw openapi-fetch client for direct type-safe API access. */
-  readonly api: OpenApiFetchClient<paths>
-
-  readonly getUser: () => Effect.Effect<User, FetchClientError>
-  readonly getWorkspaces: () => Effect.Effect<ReadonlyArray<Workspace>, FetchClientError>
-  readonly getProjects: (workspaceId: string) => Effect.Effect<ReadonlyArray<Project>, FetchClientError>
-  readonly getProjectByName: (workspaceId: string, name: string) => Effect.Effect<Project | null, FetchClientError>
+  readonly getUser: () => Effect.Effect<User, ClockifyClientError>
+  readonly getWorkspaces: () => Effect.Effect<ReadonlyArray<Workspace>, ClockifyClientError>
+  readonly getProjects: (workspaceId: string) => Effect.Effect<ReadonlyArray<Project>, ClockifyClientError>
+  readonly getProjectByName: (workspaceId: string, name: string) => Effect.Effect<Project | null, ClockifyClientError>
   readonly createTimeEntry: (
     workspaceId: string,
     params: CreateTimeEntryParams
-  ) => Effect.Effect<TimeEntry, FetchClientError>
+  ) => Effect.Effect<Generated.CreateTimeEntry201, ClockifyClientError>
   readonly stopTimer: (
     workspaceId: string,
     userId: string,
     params: StopTimeEntryParams
-  ) => Effect.Effect<TimeEntry, FetchClientError>
+  ) => Effect.Effect<Generated.StopRunningTimeEntry200, ClockifyClientError>
   readonly getTimeEntries: (
     workspaceId: string,
     userId: string,
     params?: GetTimeEntriesParams
-  ) => Effect.Effect<ReadonlyArray<TimeEntry>, FetchClientError>
+  ) => Effect.Effect<Generated.GetTimeEntries200, ClockifyClientError>
   readonly getRunningTimer: (
     workspaceId: string,
     userId: string
-  ) => Effect.Effect<TimeEntry | null, FetchClientError>
-  readonly getTags: (workspaceId: string) => Effect.Effect<ReadonlyArray<Tag>, FetchClientError>
-  readonly createTag: (workspaceId: string, name: string) => Effect.Effect<Tag, FetchClientError>
-  readonly findOrCreateTag: (workspaceId: string, name: string) => Effect.Effect<Tag, FetchClientError>
+  ) => Effect.Effect<Generated.GetTimeEntries200[number] | null, ClockifyClientError>
+  readonly getTags: (workspaceId: string) => Effect.Effect<Generated.GetTags200, ClockifyClientError>
+  readonly createTag: (
+    workspaceId: string,
+    name: string
+  ) => Effect.Effect<Generated.CreateNewTag201, ClockifyClientError>
+  readonly findOrCreateTag: (
+    workspaceId: string,
+    name: string
+  ) => Effect.Effect<Generated.GetTags200[number] | Generated.CreateNewTag201, ClockifyClientError>
   readonly getTimeEntry: (
     workspaceId: string,
     timeEntryId: string
-  ) => Effect.Effect<TimeEntry, FetchClientError>
-  readonly deleteTimeEntry: (workspaceId: string, timeEntryId: string) => Effect.Effect<void, FetchClientError>
+  ) => Effect.Effect<Generated.GetTimeEntry200, ClockifyClientError>
+  readonly deleteTimeEntry: (workspaceId: string, timeEntryId: string) => Effect.Effect<void, ClockifyClientError>
   readonly updateTimeEntry: (
     workspaceId: string,
     timeEntryId: string,
     params: UpdateTimeEntryParams
-  ) => Effect.Effect<TimeEntry, FetchClientError>
+  ) => Effect.Effect<Generated.UpdateTimeEntry200, ClockifyClientError>
 }
 
-// ---------------------------------------------------------------------------
-// Service tag + layer
-// ---------------------------------------------------------------------------
+export const make = (
+  httpClient: HttpClient.HttpClient,
+  options: { readonly apiKey: Redacted.Redacted<string>; readonly baseUrl: string }
+): AuthenticatedClockifyApi => {
+  const api = Generated.make(httpClient.pipe(
+    HttpClient.mapRequest(flow(
+      HttpClientRequest.prependUrl(options.baseUrl),
+      HttpClientRequest.setHeader("X-Api-Key", Redacted.value(options.apiKey))
+    ))
+  ))
+  return {
+    ...api,
+    uploadImage: (input) => {
+      const form = new FormData()
+      form.append("file", input.file)
+      return api.httpClient.execute(
+        HttpClientRequest.post("/v1/file/image").pipe(HttpClientRequest.bodyFormData(form))
+      ).pipe(
+        Effect.flatMap(HttpClientResponse.filterStatusOk),
+        Effect.flatMap(HttpClientResponse.schemaBodyJson(Generated.UploadImage200))
+      )
+    }
+  }
+}
 
 export class ClockifyApiClient extends Context.Service<ClockifyApiClient, ClockifyApiClientShape>()(
   "@knpkv/clockify-api-client/ClockifyApiClient"
 ) {
-  static readonly layer: Layer.Layer<ClockifyApiClient, never, ClockifyApiConfig> = Layer.effect(
-    ClockifyApiClient,
-    Effect.gen(function*() {
-      const config = yield* ClockifyApiConfig
-
-      const headers = {
-        "X-Api-Key": Redacted.value(config.apiKey),
-        "Content-Type": "application/json"
-      }
-
-      const api = makeOpenApiFetchClient<paths>(config.baseUrl, headers)
-      const { client } = api
-
-      return {
-        api,
-
-        getUser: () => toEffect(client.GET("/v1/user")) as Effect.Effect<User, FetchClientError>,
-
-        getWorkspaces: () =>
-          toEffect(client.GET("/v1/workspaces")) as unknown as Effect.Effect<
-            ReadonlyArray<Workspace>,
-            FetchClientError
-          >,
-
-        getProjects: (workspaceId) =>
-          toEffect(
-            client.GET("/v1/workspaces/{workspaceId}/projects", {
+  static readonly layer: Layer.Layer<ClockifyApiClient, never, ClockifyApiConfig | HttpClient.HttpClient> = Layer
+    .effect(
+      ClockifyApiClient,
+      Effect.gen(function*() {
+        const config = yield* ClockifyApiConfig
+        const httpClient = yield* HttpClient.HttpClient
+        const api = make(httpClient, config)
+
+        const getProjects = (workspaceId: string) =>
+          api.getProjects(workspaceId, { params: { archived: false, "page-size": 500 } })
+
+        const getTags = (workspaceId: string) =>
+          api.getTags(workspaceId, { params: { archived: false, "page-size": 200 } })
+
+        return ClockifyApiClient.of({
+          getUser: () => api.getLoggedUser(undefined),
+          getWorkspaces: () => api.getWorkspacesOfUser(undefined),
+          getProjects,
+          getProjectByName: (workspaceId, name) =>
+            api.getProjects(workspaceId, { params: { name, archived: false } }).pipe(
+              Effect.map((projects) =>
+                projects.find((project) => project.name.toLowerCase() === name.toLowerCase()) ?? null
+              )
+            ),
+          createTimeEntry: (workspaceId, payload) => api.createTimeEntry(workspaceId, { payload }),
+          stopTimer: (workspaceId, userId, payload) => api.stopRunningTimeEntry(workspaceId, userId, { payload }),
+          getTimeEntries: (workspaceId, userId, params) =>
+            api.getTimeEntries(workspaceId, userId, {
               params: {
-                path: { workspaceId },
-                query: { archived: false, "page-size": 500 }
+                ...(params?.start !== undefined ? { start: params.start } : {}),
+                ...(params?.end !== undefined ? { end: params.end } : {}),
+                ...(params?.page !== undefined ? { page: params.page } : {}),
+                ...(params?.pageSize !== undefined ? { "page-size": params.pageSize } : {})
               }
-            })
-          ) as Effect.Effect<ReadonlyArray<Project>, FetchClientError>,
-
-        getProjectByName: (workspaceId, name) =>
-          Effect.gen(function*() {
-            const projects = yield* toEffect(
-              client.GET("/v1/workspaces/{workspaceId}/projects", {
-                params: {
-                  path: { workspaceId },
-                  query: { name, archived: false }
-                }
+            }),
+          getRunningTimer: (workspaceId, userId) =>
+            api.getTimeEntries(workspaceId, userId, {
+              params: { "in-progress": "true", "page-size": 1 }
+            }).pipe(Effect.map((entries) => entries[0] ?? null)),
+          getTags,
+          createTag: (workspaceId, name) => api.createNewTag(workspaceId, { payload: { name } }),
+          findOrCreateTag: (workspaceId, name) =>
+            api.getTags(workspaceId, { params: { name, archived: false } }).pipe(
+              Effect.flatMap((tags) => {
+                const existing = tags.find((tag) => tag.name?.toLowerCase() === name.toLowerCase())
+                return existing === undefined
+                  ? api.createNewTag(workspaceId, { payload: { name } })
+                  : Effect.succeed(existing)
               })
-            ) as Effect.Effect<ReadonlyArray<Project>, FetchClientError>
-            return projects.find((p) => p.name.toLowerCase() === name.toLowerCase()) ?? null
-          }),
-
-        createTimeEntry: (workspaceId, params) =>
-          toEffect(
-            client.POST("/v1/workspaces/{workspaceId}/time-entries", {
-              params: { path: { workspaceId } },
-              body: {
-                description: params.description,
-                start: params.start,
-                ...(params.end ? { end: params.end } : {}),
-                ...(params.projectId ? { projectId: params.projectId } : {}),
-                ...(params.taskId ? { taskId: params.taskId } : {}),
-                ...(params.billable !== undefined ? { billable: params.billable } : {}),
-                ...(params.tagIds !== undefined ? { tagIds: [...params.tagIds] } : {})
-              }
-            })
-          ) as Effect.Effect<TimeEntry, FetchClientError>,
-
-        stopTimer: (workspaceId, userId, params) =>
-          toEffect(
-            client.PATCH("/v1/workspaces/{workspaceId}/user/{userId}/time-entries", {
-              params: { path: { workspaceId, userId } },
-              body: { end: params.end }
-            })
-          ) as Effect.Effect<TimeEntry, FetchClientError>,
-
-        getTimeEntries: (workspaceId, userId, params) =>
-          toEffect(
-            client.GET("/v1/workspaces/{workspaceId}/user/{userId}/time-entries", {
-              params: {
-                path: { workspaceId, userId },
-                query: {
-                  ...(params?.start !== undefined ? { start: params.start } : {}),
-                  ...(params?.end !== undefined ? { end: params.end } : {}),
-                  ...(params?.page !== undefined ? { page: params.page } : {}),
-                  ...(params?.pageSize !== undefined ? { "page-size": params.pageSize } : {})
-                }
-              }
-            })
-          ) as Effect.Effect<ReadonlyArray<TimeEntry>, FetchClientError>,
-
-        getRunningTimer: (workspaceId, userId) =>
-          Effect.gen(function*() {
-            const entries = yield* toEffect(
-              client.GET("/v1/workspaces/{workspaceId}/user/{userId}/time-entries", {
-                params: {
-                  path: { workspaceId, userId },
-                  query: { "in-progress": true, "page-size": 1 }
-                }
-              })
-            ) as Effect.Effect<ReadonlyArray<TimeEntry>, FetchClientError>
-            return entries.length > 0 ? entries[0]! : null
-          }),
-
-        getTimeEntry: (workspaceId, timeEntryId) =>
-          toEffect(
-            client.GET("/v1/workspaces/{workspaceId}/time-entries/{id}", {
-              params: { path: { workspaceId, id: timeEntryId } }
-            })
-          ) as Effect.Effect<TimeEntry, FetchClientError>,
-
-        updateTimeEntry: (workspaceId, timeEntryId, params) =>
-          toEffect(
-            client.PUT("/v1/workspaces/{workspaceId}/time-entries/{id}", {
-              params: { path: { workspaceId, id: timeEntryId } },
-              body: {
-                start: params.start,
-                ...(params.end !== undefined ? { end: params.end } : {}),
-                ...(params.description !== undefined ? { description: params.description } : {}),
-                ...(params.projectId !== undefined ? { projectId: params.projectId } : {}),
-                ...(params.billable !== undefined ? { billable: params.billable } : {}),
-                ...(params.tagIds !== undefined ? { tagIds: [...params.tagIds] } : {})
-              }
-            })
-          ) as Effect.Effect<TimeEntry, FetchClientError>,
-
-        getTags: (workspaceId) =>
-          toEffect(
-            client.GET("/v1/workspaces/{workspaceId}/tags", {
-              params: {
-                path: { workspaceId },
-                query: { archived: false, "page-size": 200 }
-              }
-            })
-          ) as Effect.Effect<ReadonlyArray<Tag>, FetchClientError>,
-
-        createTag: (workspaceId, name) =>
-          toEffect(
-            client.POST("/v1/workspaces/{workspaceId}/tags", {
-              params: { path: { workspaceId } },
-              body: { name }
-            })
-          ) as Effect.Effect<Tag, FetchClientError>,
-
-        findOrCreateTag: (workspaceId, name) =>
-          Effect.gen(function*() {
-            const tags = yield* toEffect(
-              client.GET("/v1/workspaces/{workspaceId}/tags", {
-                params: {
-                  path: { workspaceId },
-                  query: { name, archived: false }
-                }
-              })
-            ) as Effect.Effect<ReadonlyArray<Tag>, FetchClientError>
-            const existing = tags.find((t) => t.name.toLowerCase() === name.toLowerCase())
-            if (existing) return existing
-            return yield* toEffect(
-              client.POST("/v1/workspaces/{workspaceId}/tags", {
-                params: { path: { workspaceId } },
-                body: { name }
-              })
-            ) as Effect.Effect<Tag, FetchClientError>
-          }),
-
-        deleteTimeEntry: (workspaceId, timeEntryId) =>
-          toEffect(
-            client.DELETE("/v1/workspaces/{workspaceId}/time-entries/{id}", {
-              params: { path: { workspaceId, id: timeEntryId } }
-            })
-          ) as Effect.Effect<void, FetchClientError>
-      }
-    })
-  )
+            ),
+          getTimeEntry: (workspaceId, timeEntryId) => api.getTimeEntry(workspaceId, timeEntryId, undefined),
+          deleteTimeEntry: (workspaceId, timeEntryId) => api.deleteTimeEntry(workspaceId, timeEntryId, undefined),
+          updateTimeEntry: (workspaceId, timeEntryId, payload) =>
+            api.updateTimeEntry(workspaceId, timeEntryId, { payload })
+        })
+      })
+    )
 }
 
 export const layer = ClockifyApiClient.layer