(fix): pdf generation works

Author: fern-support

src/Client.ts

@@ -45,12 +45,7 @@ export class FileForgeClient {
             allowUnrecognizedEnumValues: false,
             breadcrumbsPrefix: [""],
         });
-        console.log(options);
-        await _request.append(
-            "options",
-            JSON.stringify(options),
-            { contentType: "application/json" }
-        );
+        await _request.append("options", new Blob([JSON.stringify(options)], { type: "application/json" }));
         for (const _file of files) {
             await _request.append("files", _file);
         }
@@ -74,9 +69,7 @@ export class FileForgeClient {
             timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1000 : 60000,
             maxRetries: requestOptions?.maxRetries,
         });
-        console.log("_response", JSON.stringify(_response))
         if (_response.ok) {
-            console.log("_response.body", _response.body);
             return _response.body;
         }
 

src/core/fetcher/Fetcher.ts

@@ -66,39 +66,25 @@ async function fetcherImpl<R = unknown>(args: Fetcher.Args): Promise<APIResponse
             : args.url;
 
     let body: BodyInit | undefined = undefined;
-    const maybeStringifyBody = (body: any) => {
+    const maybeStringifyBody = async (body: any) => {
         if (body instanceof Uint8Array) {
             return body;
+        } else if (body instanceof FormData 
+            || body instanceof (await import("formdata-node")).FormData 
+            || body instanceof (await import("form-data")).default)  { 
+            return body as any;
         } else {
             return JSON.stringify(body);
         }
     };
 
-    if (RUNTIME.type === "node") {
-        if (args.body instanceof (await import("formdata-node")).FormData) {
-            // @ts-expect-error
-            body = args.body;
-        } else {
-            body = maybeStringifyBody(args.body);
-        }
-    } else {
-        if (args.body instanceof (await import("form-data")).default) {
-            // @ts-expect-error
-            body = args.body;
-        } else {
-            body = maybeStringifyBody(args.body);
-        }
-    }
+    body = await maybeStringifyBody(args.body);
 
     // In Node.js environments, the SDK always uses`node-fetch`.
     // If not in Node.js the SDK uses global fetch if available,
     // and falls back to node-fetch.
     const fetchFn =
-        RUNTIME.type === "node"
-            ? // `.default` is required due to this issue:
-              // https://github.com/node-fetch/node-fetch/issues/450#issuecomment-387045223
-              ((await import("node-fetch")).default as any)
-            : typeof fetch == "function"
+        typeof fetch == "function"
             ? fetch
             : ((await import("node-fetch")).default as any);
 
@@ -139,6 +125,8 @@ async function fetcherImpl<R = unknown>(args: Fetcher.Args): Promise<APIResponse
             }
         }
 
+        console.log(response.body);
+
         let body: unknown;
         if (response.body != null && args.responseType === "blob") {
             body = await response.blob();
@@ -208,4 +196,4 @@ async function fetcherImpl<R = unknown>(args: Fetcher.Args): Promise<APIResponse
     }
 }
 
-export const fetcher: FetchFunction = fetcherImpl;
+export const fetcher: FetchFunction = fetcherImpl;

src/core/form-data-utils/FormData.ts

@@ -1,20 +1,20 @@
 import { RUNTIME } from "../runtime";
 
-export function newFormData(): FormData {
+export function newFormData(): CrossRuntimeFormData {
     if (RUNTIME.type === "node") {
         return new NodeFormData();
     } else {
         return new WebFormData();
     }
 }
 
-export declare namespace FormData {
+export declare namespace CrossRuntimeFormData {
     interface AppendOptions {
         contentType?: string;
     }
 }
 
-export abstract class FormData {
+export abstract class CrossRuntimeFormData {
     public abstract append(key: string, value: any, options?: { contentType?: string }): Promise<void>;
 
     /**
@@ -28,48 +28,35 @@ export abstract class FormData {
     public abstract getHeaders(): Promise<Record<string, string>>;
 }
 
-class NodeFormData implements FormData {
-    private encoder: any | undefined;
+class NodeFormData implements CrossRuntimeFormData {
     private fd: any | undefined;
 
-    public async initialize(): Promise<void> {
-        this.fd = new (await import("formdata-node")).FormData();
-        this.encoder = new (await import("form-data-encoder")).FormDataEncoder(this.fd);
+    public constructor() {
+        this.fd = new FormData();
     }
 
     public async append(
         key: string,
         value: any,
         options?: { contentType?: string | undefined } | undefined
     ): Promise<void> {
-        if (this.fd == null) {
-            await this.initialize();
-        }
-        if (options?.contentType == null) {
-            this.fd.append(key, value);
+        if (options?.contentType != null) {
+            this.fd.append(key, new Blob([value], { type: options?.contentType }));
         } else {
-            this.fd.append(key, new Blob([value], { type: options.contentType }));
+            this.fd.append(key, value);
         }
     }
-    
+
     public async getBody(): Promise<any> {
-        if (this.encoder == null) {
-            await this.initialize();
-        }
-        return (await import("node:stream")).Readable.from(this.encoder);
+        return this.fd;
     }
 
     public async getHeaders(): Promise<Record<string, string>> {
-        if (this.encoder == null) {
-            await this.initialize();
-        }
-        return {
-            "Content-Length": this.encoder.length,
-        };
+        return {};
     }
 }
 
-class WebFormData implements FormData {
+class WebFormData implements CrossRuntimeFormData {
     private fd: any;
 
     public async initialize(): Promise<void> {

tests/custom.test.ts

@@ -1,6 +1,19 @@
 import stream from "stream";
+import * as core from "../src/core";
 import { FileForgeClient } from "../src";
 import fs from "fs";
+import { writeFile } from "fs/promises";
+
+const HTML = `<!DOCTYPE html>
+<html>
+  <head>
+    <title>My First Web Page</title>
+  </head>
+  <body>
+    <h1>Hello World!</h1>
+  </body>
+</html>
+`;
 
 /**
  * This is a custom test file, if you wish to add more tests
@@ -12,44 +25,25 @@ import fs from "fs";
  */
 describe("test", () => {
     it("should generate a PDF", async () => {
-        const apiKeySupplier = async () => "ebec0c4c-214f-4796-afd2-b5c9b12281b6"; // Replace with your actual API key supplier
-        const environmentSupplier = async () => "https://api.fileforge.com"; // Replace with your actual environment endpoint
-
-        const client = new FileForgeClient({
-            apiKey: apiKeySupplier,
-            environment: environmentSupplier,
+        const blob = new Blob([HTML], {
+            type: "text/html",
         });
+        const htmlFile = new File([blob], "index.html", { type: "text/html" });
 
-        // Write HTML content to a file
-        const htmlContent = "<h1>Hello World!</h1>";
-        const blob = new Blob([htmlContent], { type: "text/html" });
-        const file = new File([blob], "index.html", { type: "text/html" });
-
-        const request = {
-            options: {
-                fileName: "test.pdf",
-                test: false,
-                host: false,
-            },
-        };
-
-        const pdfStream: stream.Readable = await client.generate([file], request);
-        console.log(pdfStream);
-        const pdfFilePath = "output.pdf";
-        const writeStream = fs.createWriteStream(pdfFilePath);
-
-        pdfStream.pipe(writeStream);
-
-        return new Promise((resolve, reject) => {
-            writeStream.on("finish", () => {
-                console.log("PDF generated and saved to", pdfFilePath);
-                resolve(true);
-            });
-
-            writeStream.on("error", (error) => {
-                console.error("Error generating PDF:", error);
-                reject(error);
-            });
+        const ff = new FileForgeClient({
+            apiKey: "480039ed-ccf0-48be-9103-6875d0559012"
         });
-    });
+        const pdf = await ff.generate(
+            [htmlFile], 
+            {
+                options: {}
+            }
+        );
+
+        const chunks: any[] = []
+        for await (let chunk of pdf) {
+            chunks.push(chunk)
+        }
+        await writeFile("output.pdf", Buffer.concat(chunks));
+    }, 10_000_000);
 });