@ogcio/building-blocks-sdk 0.2.84 → 0.2.86

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

@@ -143,6 +143,155 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/v1/support/files/": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: {
+                content: {
+                    "multipart/form-data": unknown | unknown;
+                };
+            };
+            responses: {
+                /** @description Default Response */
+                201: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            data: {
+                                id: string;
+                            };
+                        };
+                    };
+                };
+                /** @description Default Response */
+                "4XX": {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            code: string;
+                            detail: string;
+                            requestId: string;
+                            name: string;
+                            validation?: unknown;
+                            validationContext?: string;
+                        };
+                    };
+                };
+                /** @description Default Response */
+                "5XX": {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            code: string;
+                            detail: string;
+                            requestId: string;
+                            name: string;
+                            validation?: unknown;
+                            validationContext?: string;
+                        };
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/support/files/download-batch": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody: {
+                content: {
+                    "application/json": {
+                        fileIds: string[];
+                        userId: string;
+                    };
+                };
+            };
+            responses: {
+                /** @description Multipart mixed response containing requested files */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "multipart/mixed": string;
+                    };
+                };
+                /** @description Default Response */
+                "4XX": {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            code: string;
+                            detail: string;
+                            requestId: string;
+                            name: string;
+                            validation?: unknown;
+                            validationContext?: string;
+                        };
+                    };
+                };
+                /** @description Default Response */
+                "5XX": {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            code: string;
+                            detail: string;
+                            requestId: string;
+                            name: string;
+                            validation?: unknown;
+                            validationContext?: string;
+                        };
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/v1/metadata/": {
         parameters: {
             query?: never;
@@ -377,6 +526,93 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/v1/support/metadata/": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: {
+            parameters: {
+                query?: {
+                    userId?: string;
+                    organizationId?: string;
+                };
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Default Response */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            data: {
+                                fileName: string;
+                                id?: string;
+                                key: string;
+                                ownerId: string;
+                                fileSize: number;
+                                mimeType: string;
+                                createdAt: string;
+                                lastScan: string;
+                                /** @default false */
+                                deleted: boolean;
+                                infected: boolean;
+                                infectionDescription?: string;
+                                antivirusDbVersion?: string;
+                                expiresAt?: string;
+                            }[];
+                        };
+                    };
+                };
+                /** @description Default Response */
+                "4XX": {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            code: string;
+                            detail: string;
+                            requestId: string;
+                            name: string;
+                            validation?: unknown;
+                            validationContext?: string;
+                        };
+                    };
+                };
+                /** @description Default Response */
+                "5XX": {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            code: string;
+                            detail: string;
+                            requestId: string;
+                            name: string;
+                            validation?: unknown;
+                            validationContext?: string;
+                        };
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/v1/permissions/": {
         parameters: {
             query?: never;
@@ -569,6 +805,91 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/v1/support/permissions/": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: {
+                content: {
+                    "application/json": {
+                        fileId: string;
+                        userId: string;
+                    } | {
+                        fileId: string;
+                        userIds: string[];
+                    };
+                };
+            };
+            responses: {
+                /** @description Default Response */
+                201: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            data: {
+                                fileId: string;
+                                userId: string;
+                            } | {
+                                fileId: string;
+                                userIds: string[];
+                            };
+                        };
+                    };
+                };
+                /** @description Default Response */
+                "4XX": {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            code: string;
+                            detail: string;
+                            requestId: string;
+                            name: string;
+                            validation?: unknown;
+                            validationContext?: string;
+                        };
+                    };
+                };
+                /** @description Default Response */
+                "5XX": {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            code: string;
+                            detail: string;
+                            requestId: string;
+                            name: string;
+                            validation?: unknown;
+                            validationContext?: string;
+                        };
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
 }
 export type webhooks = Record<string, never>;
 export interface components {

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

@@ -0,0 +1,127 @@
+import type createClient from "openapi-fetch";
+import type { Logger } from "../../../types/index.js";
+import {
+  formatError,
+  formatResponse,
+  throwIfEmpty,
+} from "../../utils/client-utils.js";
+import type { paths } from "./schema.js";
+import { uploadFile, uploadStreamFile } from "./shared.js";
+
+export class UploadSupport {
+  constructor(
+    private readonly client: ReturnType<typeof createClient<paths>>,
+    private readonly serviceName: string,
+    private readonly logger: Logger | undefined,
+  ) {}
+
+  async getSharedFilesForUser(
+    query: paths["/api/v1/support/metadata/"]["get"]["parameters"]["query"],
+  ) {
+    const { userId, organizationId } = query || {};
+
+    return this.client
+      .GET("/api/v1/support/metadata/", {
+        params: { query: { userId, organizationId } },
+      })
+      .then(
+        (response) => formatResponse(response, this.serviceName, this.logger),
+        (reason) => formatError(reason, this.serviceName, this.logger),
+      );
+  }
+
+  async getFiles(
+    params: paths["/api/v1/support/files/download-batch"]["post"]["requestBody"]["content"]["application/json"],
+  ) {
+    throwIfEmpty(params.userId);
+    try {
+      const {
+        error,
+        data,
+        response: { headers, status },
+      } = await this.client.POST("/api/v1/support/files/download-batch", {
+        body: params,
+        parseAs: "stream",
+      });
+
+      return {
+        error,
+        data,
+        headers: Object.fromEntries(headers.entries()),
+        status,
+      };
+    } catch (e) {
+      return {
+        error: e,
+        data: null,
+        headers: null,
+        status: 500,
+      };
+    }
+  }
+
+  async uploadFile(
+    file: File,
+    expirationDate?: string,
+    options?: { timeoutMs?: number },
+  ): Promise<{
+    error?: {
+      code: string;
+      detail: string;
+      requestId: string;
+      name: string;
+      validation?: unknown;
+      validationContext?: string;
+    };
+    data?: { uploadId?: string };
+  }> {
+    return uploadFile({
+      file,
+      expirationDate,
+      options,
+      client: this.client,
+      path: "/api/v1/support/files/",
+    });
+  }
+
+  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[]) {
+    throwIfEmpty(fileId);
+    throwIfEmpty(userIds);
+    return this.client
+      .POST("/api/v1/support/permissions/", {
+        body: { fileId, userIds },
+      })
+      .then(
+        (response) => formatResponse(response, this.serviceName, this.logger),
+        (reason) => formatError(reason, this.serviceName, this.logger),
+      );
+  }
+}

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}` };
+}