@printhive/api 0.2.0 → 0.4.0

package/dist/index.js

@@ -4,13 +4,20 @@ import {
   apiError,
   apiKey,
   createRequest,
+  filamentSearch,
+  jobSnapshot,
   model,
   page,
+  preparation,
+  preparationDownload,
+  preparationInput,
   printJob,
   printer,
+  printerSearch,
   printers,
+  reviewApproval,
   source
-} from "./chunk-7UULMDS5.js";
+} from "./chunk-GOUMDFJR.js";
 
 // src/transport.ts
 var MAX_RETRY_AFTER_MS = 6e4;
@@ -117,13 +124,93 @@ var Transport = class {
   }
 };
 function retryDelay(failure, replayable, attempt, maxRetries) {
-  const retryable = failure instanceof PrintHiveApiError ? failure.status === 429 || failure.status === 503 : failure.reason === "network";
+  const retryable = failure instanceof PrintHiveApiError ? failure.code !== "preparation_disabled" && (failure.status === 429 || failure.status === 503) : failure.reason === "network";
   if (!retryable || !replayable || attempt >= maxRetries) throw failure;
   const retryAfterMs = failure instanceof PrintHiveApiError ? failure.retryAfterMs ?? 0 : 0;
   if (retryAfterMs > MAX_RETRY_AFTER_MS) throw failure;
   const backoff = Math.min(3e4, 250 * 2 ** attempt) * (0.5 + Math.random());
   return Math.max(backoff, retryAfterMs);
 }
+async function decode(response, validate) {
+  const value = await response.json().catch((error) => {
+    if (error instanceof SyntaxError)
+      throw new TypeError("Invalid Print Hive API response");
+    throw error;
+  });
+  if (!validate(value)) throw new TypeError("Invalid Print Hive API response");
+  return value;
+}
+
+// src/search.ts
+function searchQuery(input) {
+  const query = new URLSearchParams({ q: input.query });
+  if (input.limit !== void 0) query.set("limit", String(input.limit));
+  if (input.offset !== void 0) query.set("offset", String(input.offset));
+  return query;
+}
+var ResourceSearch = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  async printers(input) {
+    const query = searchQuery(input);
+    const page2 = await this.transport.request({
+      method: "GET",
+      path: "/v1/printers/search",
+      query,
+      signal: input.signal,
+      decode: (response) => decode(response, printerSearch)
+    });
+    return page2;
+  }
+  async filaments(input) {
+    const page2 = await this.transport.request({
+      method: "GET",
+      path: "/v1/filaments/search",
+      query: searchQuery(input),
+      signal: input.signal,
+      decode: (response) => decode(response, filamentSearch)
+    });
+    return page2;
+  }
+};
+
+// src/filament-catalog.ts
+var FilamentCatalog = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  upsert(input) {
+    const snapshot = JSON.stringify(input);
+    return this.transport.request({
+      method: "POST",
+      path: "/v1/filament-catalog",
+      contentType: "application/json",
+      body: async () => snapshot,
+      idempotencyKey: encodeURIComponent(input.externalId),
+      replayable: true,
+      decode: async (response) => response.json()
+    });
+  }
+  list(input = {}) {
+    const query = new URLSearchParams();
+    for (const [key, value] of Object.entries(input))
+      if (value !== void 0) query.set(key, String(value));
+    return this.transport.request({
+      method: "GET",
+      path: "/v1/filament-catalog",
+      query,
+      decode: async (response) => response.json()
+    });
+  }
+  get(id) {
+    return this.transport.request({
+      method: "GET",
+      path: `/v1/filament-catalog/${encodeURIComponent(id)}`,
+      decode: async (response) => response.json()
+    });
+  }
+};
 
 // src/print-jobs.ts
 var PrintJobCreateStoppedError = class extends Error {
@@ -133,7 +220,7 @@ var PrintJobCreateStoppedError = class extends Error {
     this.name = "PrintJobCreateStoppedError";
   }
 };
-async function decode(response, validate) {
+async function decode2(response, validate) {
   const value = await response.json().catch((error) => {
     if (error instanceof SyntaxError)
       throw new TypeError("Invalid Print Hive API response");
@@ -146,6 +233,19 @@ var PrintJobs = class {
   constructor(transport) {
     this.transport = transport;
   }
+  async get(id, signal) {
+    if (!Number.isSafeInteger(id) || id < 1)
+      throw new RangeError("Print job id must be a positive safe integer");
+    const response = await this.transport.request({
+      method: "GET",
+      path: `/v1/print-jobs/${id}`,
+      signal,
+      decode: (response2) => decode2(response2, jobSnapshot)
+    });
+    if (response.job.id !== id)
+      throw new TypeError("Invalid Print Hive API response");
+    return response.job;
+  }
   async create(input) {
     const { idempotencyKey: suppliedKey, ...bodyInput } = input;
     const idempotencyKey = suppliedKey ?? crypto.randomUUID();
@@ -171,6 +271,11 @@ var PrintJobs = class {
           })) {
             if (value !== void 0) form.set(field, value);
           }
+          if (metadata.acceptEngineSettingUpdates !== void 0)
+            form.set(
+              "acceptEngineSettingUpdates",
+              JSON.stringify(metadata.acceptEngineSettingUpdates)
+            );
           form.set("plate", String(metadata.plate));
           form.set("filaments", JSON.stringify(metadata.filaments));
           if (metadata.print_options !== void 0)
@@ -178,7 +283,7 @@ var PrintJobs = class {
           form.set("file", new Blob([bytes]), filename);
           return form;
         },
-        decode: (response3) => decode(response3, createRequest)
+        decode: (response3) => decode2(response3, createRequest)
       });
       return { ...response2, idempotencyKey };
     }
@@ -189,7 +294,7 @@ var PrintJobs = class {
       replayable: true,
       contentType: "application/json",
       body: async () => JSON.stringify(bodyInput),
-      decode: (response2) => decode(response2, printJob)
+      decode: (response2) => decode2(response2, printJob)
     });
     return { ...response, idempotencyKey };
   }
@@ -198,7 +303,19 @@ var PrintJobs = class {
       method: "GET",
       path: `/v1/print-jobs/create-requests/${encodeURIComponent(requestId)}`,
       signal,
-      decode: (response) => decode(response, createRequest)
+      decode: (response) => decode2(response, createRequest)
+    });
+  }
+  approveReview(requestId, review, signal) {
+    return this.transport.request({
+      method: "POST",
+      path: `/v1/print-jobs/create-requests/${encodeURIComponent(requestId)}/approve-review`,
+      signal,
+      idempotencyKey: crypto.randomUUID(),
+      replayable: false,
+      contentType: "application/json",
+      body: async () => JSON.stringify(review),
+      decode: (response) => decode2(response, reviewApproval)
     });
   }
   async waitUntilCreated(requestId, options = {}) {
@@ -224,15 +341,6 @@ var PrintJobs = class {
 };
 
 // src/index.ts
-async function decode2(response, validate) {
-  const value = await response.json().catch((error) => {
-    if (error instanceof SyntaxError)
-      throw new TypeError("Invalid Print Hive API response");
-    throw error;
-  });
-  if (!validate(value)) throw new TypeError("Invalid Print Hive API response");
-  return value;
-}
 function isPath(file) {
   return !(file instanceof Uint8Array) && !(file instanceof ReadableStream);
 }
@@ -242,29 +350,93 @@ var PrintHive = class {
   models;
   printers;
   printJobs;
+  filamentCatalog;
+  filaments;
+  preparations;
   constructor(options) {
     const transport = new Transport(options);
+    const search = new ResourceSearch(transport);
+    this.filaments = {
+      search: (input) => search.filaments(input)
+    };
     this.printJobs = new PrintJobs(transport);
+    this.filamentCatalog = new FilamentCatalog(transport);
     const get = (sourceId, signal) => transport.request({
-      decode: (response) => decode2(response, source),
+      decode: (response) => decode(response, source),
       method: "GET",
       path: `${prefix}/uploads/${encodeURIComponent(sourceId)}`,
       signal
     });
+    const getPreparation = (id, signal) => transport.request({
+      decode: (response) => decode(response, preparation),
+      method: "GET",
+      path: `${prefix}/preparations/${encodeURIComponent(id)}`,
+      signal
+    });
+    this.preparations = {
+      get: getPreparation,
+      async create(input) {
+        const idempotencyKey = input.idempotencyKey ?? crypto.randomUUID();
+        const snapshot = JSON.stringify({ items: input.items });
+        if (!preparationInput(JSON.parse(snapshot)))
+          throw new TypeError("Invalid preparation input");
+        const preparation2 = await transport.request({
+          decode: (response) => decode(response, preparation),
+          method: "POST",
+          path: `${prefix}/preparations`,
+          contentType: "application/json",
+          body: async () => snapshot,
+          size: new TextEncoder().encode(snapshot).byteLength,
+          idempotencyKey,
+          replayable: true,
+          signal: input.signal
+        });
+        return { ...preparation2, idempotencyKey };
+      },
+      async waitUntilSettled(id, options2 = {}) {
+        const interval = positive(options2.intervalMs ?? 1e3, "intervalMs");
+        const deadline = AbortSignal.timeout(
+          positive(options2.timeoutMs ?? 12e4, "timeoutMs")
+        );
+        const signal = options2.signal ? AbortSignal.any([options2.signal, deadline]) : deadline;
+        try {
+          for (; ; ) {
+            const preparation2 = await getPreparation(id, signal);
+            const status = preparation2.status;
+            if (status === "ready" || status === "held" || status === "failed")
+              return { ...preparation2, status };
+            await pause(interval, signal);
+          }
+        } catch (error) {
+          if (deadline.aborted && !options2.signal?.aborted) {
+            const { PrintHiveNetworkError: PrintHiveNetworkError2 } = await import("./errors-4M56UUFV.js");
+            throw new PrintHiveNetworkError2("timeout");
+          }
+          throw error;
+        }
+      },
+      downloadInfo: (id, plateId, signal) => transport.request({
+        decode: (response) => decode(response, preparationDownload),
+        method: "GET",
+        path: `${prefix}/preparations/${encodeURIComponent(id)}/plates/${encodeURIComponent(plateId)}/download`,
+        signal
+      })
+    };
     this.printers = {
+      search: (input) => search.printers(input),
       list: (input = {}) => {
         const query = new URLSearchParams();
         if (input.limit !== void 0) query.set("limit", String(input.limit));
         if (input.cursor !== void 0) query.set("cursor", input.cursor);
         return transport.request({
-          decode: (response) => decode2(response, printers),
+          decode: (response) => decode(response, printers),
           method: "GET",
           path: "/v1/printers",
           query
         });
       },
       get: (id) => transport.request({
-        decode: (response) => decode2(response, printer),
+        decode: (response) => decode(response, printer),
         method: "GET",
         path: `/v1/printers/${encodeURIComponent(id)}`
       })
@@ -302,7 +474,7 @@ var PrintHive = class {
         if (!Number.isSafeInteger(size) || size < 0)
           throw new RangeError("size must be a nonnegative safe integer");
         const source2 = await transport.request({
-          decode: (response) => decode2(response, source),
+          decode: (response) => decode(response, source),
           method: "POST",
           path: `${prefix}/uploads`,
           query,
@@ -328,7 +500,7 @@ var PrintHive = class {
           }
         } catch (error) {
           if (deadline.aborted && !options2.signal?.aborted) {
-            const { PrintHiveNetworkError: PrintHiveNetworkError2 } = await import("./errors-TJFN2M7S.js");
+            const { PrintHiveNetworkError: PrintHiveNetworkError2 } = await import("./errors-4M56UUFV.js");
             throw new PrintHiveNetworkError2("timeout");
           }
           throw error;
@@ -337,7 +509,7 @@ var PrintHive = class {
     };
     this.models = {
       findByExternalId: (externalId) => transport.request({
-        decode: (response) => decode2(response, model),
+        decode: (response) => decode(response, model),
         method: "GET",
         path: `${prefix}/models`,
         query: new URLSearchParams({ externalId })
@@ -348,7 +520,7 @@ var PrintHive = class {
           const query = new URLSearchParams();
           if (cursor !== null) query.set("cursor", cursor);
           const page2 = await transport.request({
-            decode: (response) => decode2(response, page),
+            decode: (response) => decode(response, page),
             method: "GET",
             path: `${prefix}/models/${encodeURIComponent(modelId)}/files`,
             query

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@printhive/api",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "private": false,
   "type": "module",
   "description": "Print Hive REST API client",