Node.js or Deno?

[taishikato]

I'm writing an API for Supavec that stores PDFs in Supabase Storage and saves embeddings in the DB.

Currently, I'm planning to use Supabase Edge Functions, which means creating an API that runs on Deno.

Then I got curious, do you prefer Node.js or Deno?

For example, for APIs that:

• handle short-to-medium processes (up to a few mins)
• need to handle high traffic

Which would you prefer:

• Node.js: Render/Railway
  or
• Deno: Supabase Edge Functions?

Join the discussion below! 🙏

[riderx]

Both will perform similar, in deno it’s possible that some dependencies are missing.
Maybe with esm you can get them but not sure they will work so for pdf I would say better to test than to imagine

[taishikato]

ty @riderx !

it’s possible that some dependencies are missing.

this is so true!

yes i'll test it :) I'm just curious since i don't see many ppl who actually use Deno.
are you using supabase edge functions (deno) with capgo?

[riderx]

Yes i use them for internal process.
for user facing endpoint, i use cloudflare because prices scale better. But they work 100% on cloudflare, deno and nodejs.
Thanks to hono

[taishikato]

btw, i couldn't solve the problem below on Edge Functions (Deno).

Error processing PDF: Error: Failed to load pdf-parse. Please install it with eg. `npm install pdf-parse`

when i added import * as parse from "npm:[email protected]"; then the error message became

worker boot error: failed to read path: No such file or directory (os error 2)

i think pdf-parse is required by PDFLoaderfrom npm:@langchain/[email protected]/document_loaders/fs/pdf";

import process from "node:process";
import * as parse from "npm:[email protected]";
import { createClient } from "jsr:@supabase/supabase-js@^2.47.10";
import { OpenAIEmbeddings } from "npm:@langchain/[email protected]";
import { RecursiveCharacterTextSplitter } from "npm:[email protected]/text_splitter";
import { PDFLoader } from "npm:@langchain/[email protected]/document_loaders/fs/pdf";
import { SupabaseVectorStore } from "npm:@langchain/[email protected]/vectorstores/supabase";

console.log("Hello from PDF Functions!");

const corsHeaders = {
  "Access-Control-Allow-Origin": "*",
  "Access-Control-Allow-Headers":
    "authorization, x-client-info, apikey, content-type",
  "Access-Control-Allow-Methods": "POST, OPTIONS",
};

const supabase = createClient(
  process.env.SUPABASE_URL!,
  process.env.SUPABASE_SERVICE_ROLE_KEY!,
);

Deno.serve(async (req) => {
  // Handle CORS preflight requests
  if (req.method === "OPTIONS") {
    return new Response(null, {
      status: 204,
      headers: corsHeaders,
    });
  }

  try {
    const buffer = new Uint8Array(await req.arrayBuffer());

    if (buffer.length === 0) {
      return new Response(JSON.stringify({ error: "No PDF data provided" }), {
        status: 400,
        headers: { ...corsHeaders, "Content-Type": "application/json" },
      });
    }

    // Create a temporary file path
    const tempFileName = `${crypto.randomUUID()}.pdf`;
    const tempFilePath = `/tmp/${tempFileName}`;
    await Deno.writeFile(tempFilePath, buffer);

    // Upload to Supabase Storage
    const uploadId = crypto.randomUUID();
    const { error } = await supabase.storage.createBucket(uploadId, {
      public: false,
    });

    if (error) {
      console.error("Error creating bucket:", error);
      await Deno.remove(tempFilePath);
      throw new Error(error.message);
    }

    const fileName = `${uploadId}.pdf`;
    const { data: uploadData, error: uploadError } = await supabase
      .storage.from(uploadId).upload(fileName, buffer);

    if (uploadError) {
      await Deno.remove(tempFilePath);
      return new Response(JSON.stringify({ error: uploadError.message }), {
        status: 500,
        headers: { ...corsHeaders, "Content-Type": "application/json" },
      });
    }

    // Load and process PDF with LangChain
    const loader = new PDFLoader(tempFilePath);
    const pages = await loader.load();

    // Clean up temp file
    await Deno.remove(tempFilePath);

    // Split text into chunks
    const splitter = new RecursiveCharacterTextSplitter({
      chunkSize: 1000,
      chunkOverlap: 200,
    });
    const chunks = await splitter.splitDocuments(pages);

    // Create embeddings
    const embeddings = new OpenAIEmbeddings({
      openAIApiKey: process.env.OPENAI_API_KEY,
    });

    try {
      await SupabaseVectorStore.fromDocuments(
        chunks,
        embeddings,
        {
          client: supabase,
          tableName: "vectors",
          queryName: "match_vectors",
        },
      );
    } catch (vectorError) {
      throw new Error(vectorError.message);
    }

    return new Response(
      JSON.stringify({
        message: "PDF processed successfully",
        fileName: uploadData.path,
        chunks: chunks.length,
      }),
      {
        status: 200,
        headers: { ...corsHeaders, "Content-Type": "application/json" },
      },
    );
  } catch (error) {
    console.error("Error processing PDF:", error);
    return new Response(
      JSON.stringify({
        error: `Failed to process PDF${
          error.message ? `: ${error.message}` : ""
        }`,
      }),
      {
        status: 500,
        headers: { ...corsHeaders, "Content-Type": "application/json" },
      },
    );
  }
});

[riderx]

Try with https://esm.sh/ with ?deno=true

[taishikato]

thx @riderx i tried

import { PDFLoader } from "https://esm.sh/@langchain/[email protected]/document_loaders/fs/pdf?deno=true";

but didn't work unfortunately.
i got an error below:

Error processing PDF: Error: Failed to load fs/promises. TextLoader available only on environment 'node'. It appears you are running environment 'deno'. See https://<link to docs> for alternatives.