@ogcio/building-blocks-sdk 0.2.85 → 0.2.87

package/src/client/clients/upload/shared.ts

@@ -0,0 +1,122 @@
+import type createClient from "openapi-fetch";
+import { buildStreamingMultipart } from "../../utils/client-utils.js";
+import type { paths } from "./schema.js";
+
+const DEFAULT_TIMEOUT_MS = 120000; // 120 seconds
+
+export async function uploadFile(params: {
+  file: File;
+  expirationDate?: string;
+  options?: { timeoutMs?: number };
+  client: ReturnType<typeof createClient<paths>>;
+  path: "/api/v1/support/files/" | "/api/v1/files/";
+}): Promise<{
+  error?: {
+    code: string;
+    detail: string;
+    requestId: string;
+    name: string;
+    validation?: unknown;
+    validationContext?: string;
+  };
+  data?: { uploadId?: string };
+}> {
+  const { file, expirationDate, options, client, path } = params;
+  const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  try {
+    const { error, data } = await client.POST(path, {
+      body: {
+        file,
+        expirationDate,
+      },
+      signal: AbortSignal.timeout(timeoutMs),
+      bodySerializer: (body: unknown) => {
+        const parsed = body as { file: File; expirationDate?: string };
+        const formData = new FormData();
+        if (parsed.expirationDate) {
+          formData.set("expirationDate", parsed.expirationDate);
+        }
+        formData.set("file", parsed.file);
+        return formData;
+      },
+    });
+
+    return { error, data: { uploadId: data?.data.id } };
+  } catch (e: unknown) {
+    const err = e as Error & { name?: string };
+    if (
+      err?.name === "AbortError" ||
+      err?.constructor?.name === "DOMException"
+    ) {
+      return {
+        error: {
+          name: "TimeoutError",
+          detail: "Upload aborted after reaching timeout",
+          requestId: "",
+          code: "TIMEOUT_ERROR",
+        },
+      };
+    }
+    throw err;
+  }
+}
+
+export async function uploadStreamFile(params: {
+  file: ReadableStream<Uint8Array> | Blob;
+  filename: string;
+  mimeType: string;
+  expirationDate?: string;
+  options?: { timeoutMs?: number };
+  client: ReturnType<typeof createClient<paths>>;
+  path: "/api/v1/support/files/" | "/api/v1/files/";
+}): Promise<{
+  error?: {
+    code: string;
+    detail: string;
+    requestId: string;
+    name: string;
+    validation?: unknown;
+    validationContext?: string;
+  };
+  data?: { uploadId?: string };
+}> {
+  const { file, filename, mimeType, expirationDate, options, client, path } =
+    params;
+
+  const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  try {
+    const stream = file instanceof Blob ? file.stream() : file;
+    const { body, contentType } = buildStreamingMultipart(
+      stream,
+      filename,
+      mimeType,
+      expirationDate,
+    );
+
+    const { error, data } = await client.POST(path, {
+      body: {} as never,
+      signal: AbortSignal.timeout(timeoutMs),
+      headers: { "content-type": contentType },
+      bodySerializer: () => body,
+      duplex: "half",
+    } as unknown as Parameters<typeof client.POST>[1]);
+
+    return { error, data: { uploadId: data?.data.id } };
+  } catch (e: unknown) {
+    const err = e as Error & { name?: string };
+    if (
+      err?.name === "AbortError" ||
+      err?.constructor?.name === "DOMException"
+    ) {
+      return {
+        error: {
+          name: "TimeoutError",
+          detail: "Upload aborted after reaching timeout",
+          requestId: "",
+          code: "TIMEOUT_ERROR",
+        },
+      };
+    }
+    throw err;
+  }
+}

package/src/client/clients/upload/support.ts

@@ -6,6 +6,7 @@ import {
   throwIfEmpty,
 } from "../../utils/client-utils.js";
 import type { paths } from "./schema.js";
+import { uploadFile, uploadStreamFile } from "./shared.js";
 
 export class UploadSupport {
   constructor(
@@ -74,43 +75,41 @@ export class UploadSupport {
     };
     data?: { uploadId?: string };
   }> {
-    const timeoutMs = options?.timeoutMs ?? 120000; // default 120s
-    try {
-      const { error, data } = await this.client.POST("/api/v1/support/files/", {
-        body: {
-          file,
-          expirationDate,
-        },
-        signal: AbortSignal.timeout(timeoutMs),
-        bodySerializer: (body: unknown) => {
-          const parsed = body as { file: File; expirationDate?: string };
-          const formData = new FormData();
-          if (parsed.expirationDate) {
-            formData.set("expirationDate", parsed.expirationDate);
-          }
-          formData.set("file", parsed.file);
-          return formData;
-        },
-      });
+    return uploadFile({
+      file,
+      expirationDate,
+      options,
+      client: this.client,
+      path: "/api/v1/support/files/",
+    });
+  }
 
-      return { error, data: { uploadId: data?.data.id } };
-    } catch (e: unknown) {
-      const err = e as Error & { name?: string };
-      if (
-        err?.name === "AbortError" ||
-        err?.constructor?.name === "DOMException"
-      ) {
-        return {
-          error: {
-            name: "TimeoutError",
-            detail: "Upload aborted after reaching timeout",
-            requestId: "",
-            code: "TIMEOUT_ERROR",
-          },
-        };
-      }
-      throw err;
-    }
+  async uploadStreamFile(
+    file: ReadableStream<Uint8Array> | Blob,
+    filename: string,
+    mimeType: string,
+    expirationDate?: string,
+    options?: { timeoutMs?: number },
+  ): Promise<{
+    error?: {
+      code: string;
+      detail: string;
+      requestId: string;
+      name: string;
+      validation?: unknown;
+      validationContext?: string;
+    };
+    data?: { uploadId?: string };
+  }> {
+    return uploadStreamFile({
+      file,
+      filename,
+      mimeType,
+      expirationDate,
+      options,
+      client: this.client,
+      path: "/api/v1/support/files/",
+    });
   }
 
   shareFile(fileId: string, ...userIds: string[]) {

package/src/client/utils/client-utils.ts

@@ -163,3 +163,62 @@ export function throwIfEmpty(input: string | string[]): void {
     throw Error("Parameter cannot be an empty string or array!");
   }
 }
+
+/**
+ * Builds a streaming multipart/form-data body from a ReadableStream without
+ * buffering the file content in memory. The returned ReadableStream pipes the
+ * file chunks directly into the multipart envelope as they are read.
+ */
+export function buildStreamingMultipart(
+  stream: ReadableStream<Uint8Array>,
+  filename: string,
+  mimeType: string,
+  expirationDate?: string,
+): { body: ReadableStream<Uint8Array>; contentType: string } {
+  const boundary = `----FormBoundary${crypto.randomUUID().replace(/-/g, "")}`;
+  const encoder = new TextEncoder();
+  // Sanitize filename to prevent Content-Disposition header injection
+  const safeFilename = filename.replace(/["\\\r\n]/g, "_");
+
+  const parts: (Uint8Array | ReadableStream<Uint8Array>)[] = [];
+
+  if (expirationDate) {
+    parts.push(
+      encoder.encode(
+        `--${boundary}\r\nContent-Disposition: form-data; name="expirationDate"\r\n\r\n${expirationDate}\r\n`,
+      ),
+    );
+  }
+
+  parts.push(
+    encoder.encode(
+      `--${boundary}\r\nContent-Disposition: form-data; name="file"; filename="${safeFilename}"\r\nContent-Type: ${mimeType}\r\n\r\n`,
+    ),
+  );
+  parts.push(stream);
+  parts.push(encoder.encode(`\r\n--${boundary}--\r\n`));
+
+  const body = new ReadableStream<Uint8Array>({
+    async start(controller) {
+      for (const part of parts) {
+        if (part instanceof Uint8Array) {
+          controller.enqueue(part);
+        } else {
+          const reader = part.getReader();
+          try {
+            while (true) {
+              const { done, value } = await reader.read();
+              if (done) break;
+              controller.enqueue(value);
+            }
+          } finally {
+            reader.releaseLock();
+          }
+        }
+      }
+      controller.close();
+    },
+  });
+
+  return { body, contentType: `multipart/form-data; boundary=${boundary}` };
+}