@printhive/api 0.1.0 → 0.3.2

package/dist/index.js

@@ -3,10 +3,55 @@ import {
   PrintHiveNetworkError,
   apiError,
   apiKey,
+  createRequest,
+  jobSnapshot,
   model,
   page,
+  preparation,
+  preparationDownload,
+  preparationInput,
+  printJob,
+  printer,
+  printers,
   source
-} from "./chunk-TGPYH7CV.js";
+} from "./chunk-YZJ5H32X.js";
+
+// 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/transport.ts
 var MAX_RETRY_AFTER_MS = 6e4;
@@ -29,6 +74,14 @@ async function pause(ms, signal) {
     signal?.addEventListener("abort", abort, { once: true });
   });
 }
+function postHeaders(request) {
+  const headers = new Headers({ "idempotency-key": request.idempotencyKey });
+  if (request.contentType !== null)
+    headers.set("content-type", request.contentType ?? "model/3mf");
+  if (request.size !== void 0)
+    headers.set("content-length", String(request.size));
+  return headers;
+}
 var Transport = class {
   options;
   constructor(options) {
@@ -76,9 +129,8 @@ var Transport = class {
           redirect: "error"
         };
         if (request.method === "POST") {
-          headers.set("content-type", "model/3mf");
-          headers.set("content-length", String(request.size));
-          headers.set("idempotency-key", request.idempotencyKey);
+          for (const [name, value] of postHeaders(request))
+            headers.set(name, value);
           init.body = await request.body();
           init.duplex = "half";
         }
@@ -106,7 +158,7 @@ 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;
@@ -114,7 +166,14 @@ function retryDelay(failure, replayable, attempt, maxRetries) {
   return Math.max(backoff, retryAfterMs);
 }
 
-// src/index.ts
+// src/print-jobs.ts
+var PrintJobCreateStoppedError = class extends Error {
+  constructor(request) {
+    super(`Print job creation ${request.status}`);
+    this.request = request;
+    this.name = "PrintJobCreateStoppedError";
+  }
+};
 async function decode(response, validate) {
   const value = await response.json().catch((error) => {
     if (error instanceof SyntaxError)
@@ -124,6 +183,110 @@ async function decode(response, validate) {
   if (!validate(value)) throw new TypeError("Invalid Print Hive API response");
   return value;
 }
+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) => decode(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();
+    if ("file" in bodyInput) {
+      const { file, filename, ...metadata } = bodyInput;
+      const bytes = file instanceof Uint8Array ? new Uint8Array(file) : new Uint8Array(
+        await (await import("fs/promises")).readFile(file)
+      );
+      const response2 = await this.transport.request({
+        method: "POST",
+        path: "/v1/print-jobs/create",
+        idempotencyKey,
+        replayable: true,
+        contentType: null,
+        body: async () => {
+          const form = new FormData();
+          for (const [field, value] of Object.entries({
+            name: metadata.name,
+            printer_id: metadata.printer_id,
+            on_filament_mismatch: metadata.on_filament_mismatch,
+            externalId: metadata.externalId,
+            release: metadata.release
+          })) {
+            if (value !== void 0) form.set(field, value);
+          }
+          form.set("plate", String(metadata.plate));
+          form.set("filaments", JSON.stringify(metadata.filaments));
+          if (metadata.print_options !== void 0)
+            form.set("print_options", JSON.stringify(metadata.print_options));
+          form.set("file", new Blob([bytes]), filename);
+          return form;
+        },
+        decode: (response3) => decode(response3, createRequest)
+      });
+      return { ...response2, idempotencyKey };
+    }
+    const response = await this.transport.request({
+      method: "POST",
+      path: "/v1/print-jobs/create",
+      idempotencyKey,
+      replayable: true,
+      contentType: "application/json",
+      body: async () => JSON.stringify(bodyInput),
+      decode: (response2) => decode(response2, printJob)
+    });
+    return { ...response, idempotencyKey };
+  }
+  getCreateRequest(requestId, signal) {
+    return this.transport.request({
+      method: "GET",
+      path: `/v1/print-jobs/create-requests/${encodeURIComponent(requestId)}`,
+      signal,
+      decode: (response) => decode(response, createRequest)
+    });
+  }
+  async waitUntilCreated(requestId, options = {}) {
+    const interval = positive(options.intervalMs ?? 1e3, "intervalMs");
+    const deadline = AbortSignal.timeout(
+      positive(options.timeoutMs ?? 12e4, "timeoutMs")
+    );
+    const signal = options.signal ? AbortSignal.any([options.signal, deadline]) : deadline;
+    try {
+      for (; ; ) {
+        const request = await this.getCreateRequest(requestId, signal);
+        if (request.status === "created") return request;
+        if (request.status !== "preparing")
+          throw new PrintJobCreateStoppedError(request);
+        await pause(interval, signal);
+      }
+    } catch (error) {
+      if (deadline.aborted && !options.signal?.aborted)
+        throw new PrintHiveNetworkError("timeout");
+      throw error;
+    }
+  }
+};
+
+// 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);
 }
@@ -131,14 +294,93 @@ var prefix = "/v1/partner-production";
 var PrintHive = class {
   partnerSources;
   models;
+  printers;
+  printJobs;
+  filamentCatalog;
+  preparations;
   constructor(options) {
     const transport = new Transport(options);
+    this.printJobs = new PrintJobs(transport);
+    this.filamentCatalog = new FilamentCatalog(transport);
     const get = (sourceId, signal) => transport.request({
-      decode: (response) => decode(response, source),
+      decode: (response) => decode2(response, source),
       method: "GET",
       path: `${prefix}/uploads/${encodeURIComponent(sourceId)}`,
       signal
     });
+    const getPreparation = (id, signal) => transport.request({
+      decode: (response) => decode2(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) => decode2(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-GNC6X3MK.js");
+            throw new PrintHiveNetworkError2("timeout");
+          }
+          throw error;
+        }
+      },
+      downloadInfo: (id, plateId, signal) => transport.request({
+        decode: (response) => decode2(response, preparationDownload),
+        method: "GET",
+        path: `${prefix}/preparations/${encodeURIComponent(id)}/plates/${encodeURIComponent(plateId)}/download`,
+        signal
+      })
+    };
+    this.printers = {
+      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),
+          method: "GET",
+          path: "/v1/printers",
+          query
+        });
+      },
+      get: (id) => transport.request({
+        decode: (response) => decode2(response, printer),
+        method: "GET",
+        path: `/v1/printers/${encodeURIComponent(id)}`
+      })
+    };
     this.partnerSources = {
       get,
       async upload(input) {
@@ -172,7 +414,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) => decode(response, source),
+          decode: (response) => decode2(response, source),
           method: "POST",
           path: `${prefix}/uploads`,
           query,
@@ -198,7 +440,7 @@ var PrintHive = class {
           }
         } catch (error) {
           if (deadline.aborted && !options2.signal?.aborted) {
-            const { PrintHiveNetworkError: PrintHiveNetworkError2 } = await import("./errors-LHFABGGG.js");
+            const { PrintHiveNetworkError: PrintHiveNetworkError2 } = await import("./errors-GNC6X3MK.js");
             throw new PrintHiveNetworkError2("timeout");
           }
           throw error;
@@ -207,7 +449,7 @@ var PrintHive = class {
     };
     this.models = {
       findByExternalId: (externalId) => transport.request({
-        decode: (response) => decode(response, model),
+        decode: (response) => decode2(response, model),
         method: "GET",
         path: `${prefix}/models`,
         query: new URLSearchParams({ externalId })
@@ -218,7 +460,7 @@ var PrintHive = class {
           const query = new URLSearchParams();
           if (cursor !== null) query.set("cursor", cursor);
           const page2 = await transport.request({
-            decode: (response) => decode(response, page),
+            decode: (response) => decode2(response, page),
             method: "GET",
             path: `${prefix}/models/${encodeURIComponent(modelId)}/files`,
             query
@@ -233,5 +475,6 @@ var PrintHive = class {
 export {
   PrintHive,
   PrintHiveApiError,
-  PrintHiveNetworkError
+  PrintHiveNetworkError,
+  PrintJobCreateStoppedError
 };

package/package.json

@@ -1,9 +1,14 @@
 {
   "name": "@printhive/api",
-  "version": "0.1.0",
+  "version": "0.3.2",
   "private": false,
   "type": "module",
-  "description": "Print Hive partner-production REST API client",
+  "description": "Print Hive REST API client",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/PrintHive/hive.git",
+    "directory": "packages/api-client"
+  },
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",