@forgecart/sdk 1.2.5 → 1.2.6

package/src/upload.ts

@@ -0,0 +1,211 @@
+/**
+ * Standalone fetch-based multipart upload function for ForgeCart SDK.
+ * Zero Apollo dependency — works in both Node.js (18+) and browser.
+ * Implements the GraphQL multipart request spec.
+ */
+
+interface ExtractableFile {
+  name?: string;
+  type?: string;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  stream?: () => any;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  arrayBuffer?: () => Promise<any>;
+}
+
+/**
+ * Check if a value is an extractable file (File, Blob, Buffer, or similar)
+ */
+function isExtractableFile(value: unknown): value is ExtractableFile {
+  if (typeof value !== 'object' || value === null) {
+    return false;
+  }
+
+  // Check for File
+  if (typeof File !== 'undefined' && value instanceof File) {
+    return true;
+  }
+
+  // Check for Blob
+  if (typeof Blob !== 'undefined' && value instanceof Blob) {
+    return true;
+  }
+
+  // Check for Buffer (Node.js — not available in browser)
+  if (typeof Buffer !== 'undefined' && Buffer.isBuffer(value)) {
+    return true;
+  }
+
+  return false;
+}
+
+/**
+ * Get file name from extractable file
+ */
+function getFileName(file: ExtractableFile): string {
+  if (file.name) {
+    return file.name;
+  }
+  return 'file';
+}
+
+/**
+ * Convert file to Blob for FormData
+ */
+async function fileToBlob(file: ExtractableFile): Promise<Blob> {
+  // If it's already a Blob/File, return it
+  if (file instanceof Blob) {
+    return file;
+  }
+
+  // If it's a Buffer (Node.js — not available in browser), convert to Blob
+  if (typeof Buffer !== 'undefined' && Buffer.isBuffer(file)) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return new Blob([file as any]);
+  }
+
+  // For other objects, try to get arrayBuffer
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const val = file as any;
+  if (val.arrayBuffer) {
+    const arrayBuffer = await val.arrayBuffer();
+    return new Blob([arrayBuffer]);
+  }
+
+  if (val.data && typeof Buffer !== 'undefined' && Buffer.isBuffer(val.data)) {
+    return new Blob([val.data]);
+  }
+
+  // Last resort - stringify
+  return new Blob([JSON.stringify(file)]);
+}
+
+/**
+ * Recursively extracts files from variables and returns paths to them
+ */
+function extractFiles(
+  value: unknown,
+  path = '',
+  files: Map<ExtractableFile, string[]> = new Map(),
+): { clone: unknown; files: Map<ExtractableFile, string[]> } {
+  if (isExtractableFile(value)) {
+    const existingPaths = files.get(value) || [];
+    files.set(value, [...existingPaths, path]);
+    return { clone: null, files };
+  }
+
+  if (Array.isArray(value)) {
+    const clone: unknown[] = [];
+    value.forEach((item, index) => {
+      const result = extractFiles(item, `${path}.${index}`, files);
+      clone[index] = result.clone;
+      files = result.files;
+    });
+    return { clone, files };
+  }
+
+  if (typeof value === 'object' && value !== null) {
+    const clone: Record<string, unknown> = {};
+    Object.entries(value).forEach(([key, val]) => {
+      const result = extractFiles(val, path ? `${path}.${key}` : key, files);
+      clone[key] = result.clone;
+      files = result.files;
+    });
+    return { clone, files };
+  }
+
+  return { clone: value, files };
+}
+
+export interface UploadResult<T> {
+  data: T;
+  extensions?: Record<string, unknown>;
+}
+
+/**
+ * Performs a GraphQL mutation with file upload support via the multipart request spec.
+ * Falls back to standard JSON POST when no files are detected in variables.
+ */
+export async function uploadViaFetch<T>(
+  endpoint: string,
+  document: string,
+  variables: Record<string, unknown>,
+  headers: Record<string, string>,
+): Promise<UploadResult<T>> {
+  const { clone, files } = extractFiles(variables);
+
+  const hasFiles = files.size > 0;
+  let body: FormData | string;
+  const fetchHeaders = { ...headers };
+
+  if (hasFiles) {
+    const formData = new FormData();
+    formData.append('operations', JSON.stringify({
+      query: document,
+      variables: clone,
+    }));
+
+    const map: Record<string, string[]> = {};
+    const fileList: { key: string; file: ExtractableFile }[] = [];
+    let fileIndex = 0;
+    files.forEach((paths, file) => {
+      const key = fileIndex.toString();
+      map[key] = paths.map((p) => `variables.${p}`);
+      fileList.push({ key, file });
+      fileIndex++;
+    });
+
+    formData.append('map', JSON.stringify(map));
+
+    for (const { key, file } of fileList) {
+      const filename = getFileName(file);
+      if (file instanceof File) {
+        formData.append(key, file, filename);
+      } else if (file instanceof Blob) {
+        formData.append(key, file, filename);
+      } else {
+        const blob = await fileToBlob(file);
+        formData.append(key, blob, filename);
+      }
+    }
+
+    body = formData;
+    // Let FormData set its own Content-Type with boundary
+    delete fetchHeaders['content-type'];
+    // Required by Apollo Server to accept multipart requests
+    fetchHeaders['apollo-require-preflight'] = 'true';
+  } else {
+    fetchHeaders['content-type'] = 'application/json';
+    body = JSON.stringify({
+      query: document,
+      variables,
+    });
+  }
+
+  const response = await fetch(endpoint, {
+    method: 'POST',
+    headers: fetchHeaders,
+    body: body as never,
+  });
+
+  const result = await response.json() as {
+    data?: T;
+    errors?: Array<{ message: string; extensions?: Record<string, unknown> }>;
+    extensions?: Record<string, unknown>;
+  };
+
+  if (result.errors && result.errors.length > 0) {
+    const error = new Error(result.errors[0].message) as Error & { response: { errors: typeof result.errors } };
+    error.response = { errors: result.errors };
+    throw error;
+  }
+
+  if (!response.ok) {
+    throw new Error(`HTTP error: ${response.status}`);
+  }
+
+  return {
+    data: result.data as T,
+    extensions: result.extensions,
+  };
+}

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2022 Vendure
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.