@cycleplatform/api-client-typescript 0.2.5 → 0.3.4

package/src/index.ts

@@ -3,6 +3,8 @@ import type { paths, components, operations } from "./generated/types";
 
 export { paths, components, operations };
 
+export { trackJob, getJobProgress } from "./jobs";
+
 export function getClient({
     apiKey,
     baseUrl = "https://api.cycle.io",
@@ -20,10 +22,10 @@ export function getClient({
     });
 
     const authMiddleware: Middleware = {
-        async onRequest(req) {
-            req.headers.set("Authorization", `Bearer ${apiKey}`);
-            req.headers.set("X-Hub-Id", hubId);
-            return req;
+        async onRequest({ request }) {
+            request.headers.set("Authorization", `Bearer ${apiKey}`);
+            request.headers.set("X-Hub-Id", hubId);
+            return request;
         },
     };
 

package/src/jobs.ts

@@ -0,0 +1,167 @@
+import { getClient } from ".";
+import { type components } from "./generated/types";
+
+type TrackJobSettings = {
+    pollingInterval?: number;
+};
+
+type JobProgressEvent = ReturnType<typeof getJobProgress> & {
+    state: components["schemas"]["JobState"]["current"];
+};
+
+class JobTracker extends EventTarget {
+    promise: Promise<components["schemas"]["Job"]>;
+
+    constructor(
+        client: ReturnType<typeof getClient>,
+        job: string | { id: string },
+        customSettings?: TrackJobSettings
+    ) {
+        super();
+        this.promise = this.track(client, job, customSettings);
+    }
+
+    private async track(
+        client: ReturnType<typeof getClient>,
+        job: string | { id: string },
+        customSettings?: TrackJobSettings
+    ): Promise<components["schemas"]["Job"]> {
+        const jobId = typeof job === "object" ? job.id : job;
+        const settings: TrackJobSettings = {
+            pollingInterval: 2000,
+            ...customSettings,
+        };
+
+        let retryCounter = 0;
+
+        while (true) {
+            const jresp = await client.GET("/v1/jobs/{jobId}", {
+                params: { path: { jobId } },
+            });
+
+            if (jresp.error) {
+                if (retryCounter < 5 && jresp.error.error.code === "404.job") {
+                    retryCounter++;
+                    await this.delay(settings.pollingInterval);
+                    continue;
+                }
+                throw jresp.error;
+            }
+
+            const jobData = jresp.data.data;
+
+            const progress = getJobProgress(jobData);
+
+            this.dispatchEvent(
+                new CustomEvent<JobProgressEvent>("progress", {
+                    detail: { ...progress, state: jobData.state.current },
+                })
+            );
+
+            if (isJobDone(jobData)) {
+                if (jobData.state.current === "error") {
+                    new CustomEvent<components["schemas"]["Job"]>("error", {
+                        detail: jobData,
+                    });
+                    throw jobData;
+                }
+
+                this.dispatchEvent(
+                    new CustomEvent<components["schemas"]["Job"]>("done", {
+                        detail: jobData,
+                    })
+                );
+                return jobData;
+            }
+
+            await this.delay(settings.pollingInterval);
+        }
+    }
+
+    private delay(ms: number = 2000) {
+        return new Promise((res) => setTimeout(res, ms));
+    }
+}
+
+function isJobDone(job: components["schemas"]["Job"]) {
+    const doneState = [
+        "completed",
+        "error",
+        "expired",
+    ] as components["schemas"]["JobState"]["current"][];
+    return doneState.includes(job.state.current);
+}
+
+export const zeroTimeString = "0001-01-01T00:00:00Z";
+/**
+ * Gets a breakdown of a job's progress
+ * @param job A Cycle job
+ * @returns an analysis of job progress
+ */
+export function getJobProgress(job: components["schemas"]["Job"]) {
+    if (!job.tasks || job.tasks.length === 0) {
+        return { total: 0, completed: 0, failed: 0, percent: 100 };
+    }
+
+    const stepAnalysis = job.tasks.reduce(
+        (acc, cur) => {
+            const taskStepCount = cur.steps?.length || 1;
+            acc["total"] += taskStepCount;
+
+            // task hasn't started yet
+            if (cur.state.current === "pending") {
+                return acc;
+            }
+
+            // no steps
+            if (!cur.steps?.length) {
+                switch (cur.state.current) {
+                    case "completed":
+                        acc["completed"] += 1;
+                        break;
+                    case "error":
+                        acc["failed"] += 1;
+                }
+                return acc;
+            }
+
+            cur.steps?.forEach((s) => {
+                if (s.completed !== zeroTimeString) {
+                    acc["completed"] += 1;
+                    return;
+                }
+
+                if (
+                    ["error", "completed"].includes(cur.state.current || "") &&
+                    s.started !== zeroTimeString
+                ) {
+                    // task is done but step didn't complete
+                    acc["failed"] += 1;
+                }
+            });
+
+            return acc;
+        },
+        { total: 0, completed: 0, failed: 0 }
+    );
+
+    return {
+        ...stepAnalysis,
+        percent: (stepAnalysis.completed / stepAnalysis.total) * 100,
+    };
+}
+
+/**
+ * Tracks a job in Cycle API and allows checking its progress.
+ * @param client The Cycle API client instance
+ * @param job A job ID or object containing an id field containing the ID of the job
+ * @param customSettings Settings like polling interval in ms
+ * @returns An object with a Promise and an EventTarget for tracking progress
+ */
+export function trackJob(
+    client: ReturnType<typeof getClient>,
+    job: string | { id: string },
+    customSettings?: TrackJobSettings
+) {
+    return new JobTracker(client, job, customSettings);
+}

package/tsconfig.json

@@ -15,12 +15,14 @@
         "moduleResolution": "node",
         "noUnusedLocals": true,
         "noUnusedParameters": true,
+        "noUncheckedIndexedAccess": true,
         "preserveWatchOutput": true,
         "skipLibCheck": true,
         "strict": true
     },
-    "include": ["./src"],
+    "include": ["src", "tests"],
     "exclude": [
-        "node_modules"
+        "node_modules",
+        "dist"
     ]
 }