@printhive/api 0.0.0-stage → 0.2.0

package/dist/index.js

@@ -0,0 +1,368 @@
+import {
+  PrintHiveApiError,
+  PrintHiveNetworkError,
+  apiError,
+  apiKey,
+  createRequest,
+  model,
+  page,
+  printJob,
+  printer,
+  printers,
+  source
+} from "./chunk-7UULMDS5.js";
+
+// src/transport.ts
+var MAX_RETRY_AFTER_MS = 6e4;
+function positive(value, name) {
+  if (!Number.isFinite(value) || value <= 0)
+    throw new RangeError(`${name} must be positive`);
+  return value;
+}
+async function pause(ms, signal) {
+  if (signal?.aborted) throw new PrintHiveNetworkError("aborted");
+  await new Promise((resolve, reject) => {
+    const abort = () => {
+      clearTimeout(timer);
+      reject(new PrintHiveNetworkError("aborted"));
+    };
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", abort);
+      resolve();
+    }, ms);
+    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) {
+    if (!apiKey(options.apiKey))
+      throw new TypeError("apiKey must be a non-empty valid HTTP header value");
+    const baseUrl = new URL(options.baseUrl ?? "https://api.printhiv3d.com");
+    if (!["http:", "https:"].includes(baseUrl.protocol) || baseUrl.username || baseUrl.password) {
+      throw new TypeError("baseUrl must be an HTTP URL without credentials");
+    }
+    const maxRetries = options.maxRetries ?? 2;
+    if (!Number.isInteger(maxRetries) || maxRetries < 0)
+      throw new RangeError("maxRetries must be a nonnegative integer");
+    this.options = {
+      ...options,
+      baseUrl: baseUrl.href.replace(/\/$/, ""),
+      fetch: options.fetch ?? globalThis.fetch,
+      timeoutMs: positive(options.timeoutMs ?? 3e4, "timeoutMs"),
+      maxRetries
+    };
+  }
+  async request(request) {
+    const url = new URL(this.options.baseUrl + request.path);
+    url.search = request.query?.toString() ?? "";
+    const replayable = request.method === "GET" || request.replayable;
+    for (let attempt = 0; ; attempt += 1) {
+      if (request.signal?.aborted) throw new PrintHiveNetworkError("aborted");
+      const controller = new AbortController();
+      let timedOut = false;
+      const timer = setTimeout(() => {
+        timedOut = true;
+        controller.abort();
+      }, this.options.timeoutMs);
+      const abort = () => controller.abort();
+      request.signal?.addEventListener("abort", abort, { once: true });
+      let failure;
+      try {
+        const headers = new Headers({
+          "x-api-key": this.options.apiKey,
+          accept: "application/json"
+        });
+        const init = {
+          method: request.method,
+          headers,
+          signal: controller.signal,
+          redirect: "error"
+        };
+        if (request.method === "POST") {
+          for (const [name, value] of postHeaders(request))
+            headers.set(name, value);
+          init.body = await request.body();
+          init.duplex = "half";
+        }
+        const response = await this.options.fetch(url, init);
+        if (!response.ok) throw await apiError(response);
+        return await request.decode(response);
+      } catch (error) {
+        if (error instanceof TypeError && error.message === "Invalid Print Hive API response")
+          throw error;
+        if (request.signal?.aborted) throw new PrintHiveNetworkError("aborted");
+        if (timedOut) throw new PrintHiveNetworkError("timeout");
+        failure = error instanceof PrintHiveApiError ? error : new PrintHiveNetworkError("network");
+      } finally {
+        clearTimeout(timer);
+        request.signal?.removeEventListener("abort", abort);
+      }
+      const delay = retryDelay(
+        failure,
+        replayable,
+        attempt,
+        this.options.maxRetries
+      );
+      await pause(delay, request.signal);
+    }
+  }
+};
+function retryDelay(failure, replayable, attempt, maxRetries) {
+  const retryable = failure instanceof PrintHiveApiError ? 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);
+}
+
+// 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)
+      throw new TypeError("Invalid Print Hive API response");
+    throw error;
+  });
+  if (!validate(value)) throw new TypeError("Invalid Print Hive API response");
+  return value;
+}
+var PrintJobs = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  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);
+}
+var prefix = "/v1/partner-production";
+var PrintHive = class {
+  partnerSources;
+  models;
+  printers;
+  printJobs;
+  constructor(options) {
+    const transport = new Transport(options);
+    this.printJobs = new PrintJobs(transport);
+    const get = (sourceId, signal) => transport.request({
+      decode: (response) => decode2(response, source),
+      method: "GET",
+      path: `${prefix}/uploads/${encodeURIComponent(sourceId)}`,
+      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) {
+        const idempotencyKey = input.idempotencyKey ?? crypto.randomUUID();
+        const query = new URLSearchParams({ filename: input.filename });
+        if (input.externalId !== void 0)
+          query.set("externalId", input.externalId);
+        if (input.modelId !== void 0) query.set("modelId", input.modelId);
+        const file = input.file;
+        let body;
+        let size;
+        let replayable;
+        if (isPath(file)) {
+          const { readFile } = await import("fs/promises");
+          const bytes = new Uint8Array(await readFile(file));
+          size = bytes.byteLength;
+          body = async () => new Blob([bytes]);
+          replayable = true;
+        } else if (file instanceof Uint8Array) {
+          const bytes = new Uint8Array(file);
+          size = bytes.byteLength;
+          body = async () => new Blob([bytes]);
+          replayable = true;
+        } else {
+          if (input.size === void 0)
+            throw new TypeError("Stream uploads require size");
+          size = input.size;
+          body = async () => file;
+          replayable = false;
+        }
+        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),
+          method: "POST",
+          path: `${prefix}/uploads`,
+          query,
+          body,
+          size,
+          idempotencyKey,
+          replayable
+        });
+        return { ...source2, idempotencyKey };
+      },
+      async waitUntilSettled(sourceId, 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 source2 = await get(sourceId, signal);
+            if (source2.status === "ready" || source2.status === "failed")
+              return source2;
+            await pause(interval, signal);
+          }
+        } catch (error) {
+          if (deadline.aborted && !options2.signal?.aborted) {
+            const { PrintHiveNetworkError: PrintHiveNetworkError2 } = await import("./errors-TJFN2M7S.js");
+            throw new PrintHiveNetworkError2("timeout");
+          }
+          throw error;
+        }
+      }
+    };
+    this.models = {
+      findByExternalId: (externalId) => transport.request({
+        decode: (response) => decode2(response, model),
+        method: "GET",
+        path: `${prefix}/models`,
+        query: new URLSearchParams({ externalId })
+      }),
+      async *listSourceFiles(modelId) {
+        let cursor = null;
+        do {
+          const query = new URLSearchParams();
+          if (cursor !== null) query.set("cursor", cursor);
+          const page2 = await transport.request({
+            decode: (response) => decode2(response, page),
+            method: "GET",
+            path: `${prefix}/models/${encodeURIComponent(modelId)}/files`,
+            query
+          });
+          yield* page2.sources;
+          cursor = page2.nextCursor;
+        } while (cursor !== null);
+      }
+    };
+  }
+};
+export {
+  PrintHive,
+  PrintHiveApiError,
+  PrintHiveNetworkError,
+  PrintJobCreateStoppedError
+};

package/package.json

@@ -1,6 +1,59 @@
 {
   "name": "@printhive/api",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.2.0",
+  "private": false,
+  "type": "module",
+  "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",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "bun run check:drift && tsup src/index.ts --format cjs,esm --dts --clean",
+    "check-types": "bun run build && tsc --noEmit",
+    "lint": "eslint src test --ext .ts",
+    "generate": "node scripts/contracts.mjs --write",
+    "check:drift": "node scripts/contracts.mjs",
+    "test": "bun run build && vitest run"
+  },
+  "devDependencies": {
+    "@types/node": "^24.10.1",
+    "openapi-typescript": "^7.13.0",
+    "tsup": "^8.5.0",
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.0",
+    "@hiv3d/eslint-config": "*",
+    "eslint": "^9.39.1",
+    "ajv": "^8.17.1",
+    "prettier": "^3.8.5"
+  },
+  "license": "MIT"
+}