feature/duckdb: POC duck db node api

webapp/app/api/db-example/route.ts

@@ -0,0 +1,18 @@
+import { fetchExample } from "@/app/lib/data";
+
+// an api route fetching data
+export async function GET() {
+  try {
+    const reader = await fetchExample();
+    return Response.json({
+      status: "OK",
+      rows: reader.getRowObjectsJson(),
+      columnNames: reader.columnNames(),
+      columnTypes: reader.columnTypes(),
+      count: reader.columnCount,
+    });
+  } catch (error) {
+    console.error("Error while retrieving data:", error);
+    return Response.json({ error }, { status: 500 });
+  }
+}

webapp/app/duckdb-example/loading.tsx

@@ -0,0 +1,3 @@
+export default function Loading() {
+  return "Loading...";
+}

webapp/app/duckdb-example/page.tsx

@@ -0,0 +1,57 @@
+import { fetchExample } from "../lib/data";
+
+export default async function Page() {
+  //using api route
+  // try {
+
+  //   const response = await fetch("http://localhost:3001/api/db-example", { cache: "no-store" })
+  //   const results = response.json();
+  // } catch (err) {
+  //    console.error("Error fetching DB status:", err)
+  // }
+
+  // using directly the data layer
+  const reader = await fetchExample();
+
+  return (
+    <div className="flex items-center justify-center min-h-screen bg-gray-100 p-4">
+      <div className="w-full max-w-5xl overflow-x-auto bg-white shadow-lg rounded-2xl p-6">
+        <table className="w-full border-collapse border border-gray-300">
+          <thead>
+            <tr className="bg-gray-200 text-gray-700">
+              <th className="border border-gray-300 px-4 py-2">Row</th>
+              {Array.from({ length: reader.columnCount }, (_, i) => (
+                <th key={i} className="border border-gray-300 px-4 py-2">
+                  {reader.columnName(i)}
+                </th>
+              ))}
+            </tr>
+          </thead>
+          <tbody>
+            {Object.entries(reader.getRows()).map(([key, value]) => (
+              <tr key={key} className="hover:bg-gray-100">
+                <td className="border border-gray-300 px-4 py-2 font-semibold">
+                  {key}
+                </td>
+                {Array.from({ length: reader.columnCount }, (_, i) => (
+                  <td key={i} className="border border-gray-300 px-4 py-2">
+                    {/* Affichage par type - exemple avec des méthodes propre à certains types => pas d'erreur, le typage semble bon */}
+                    {/* {value[i] != null &&
+                      ((reader.columnType(i).typeId === DuckDBTypeId.VARCHAR &&
+                        String(value[i]).slice(0, 3)) ||
+                        (reader.columnType(i).typeId === DuckDBTypeId.BIGINT &&
+                          (value[i] as bigint) * BigInt(100000)) ||
+                        (reader.columnType(i).typeId === DuckDBTypeId.DOUBLE &&
+                          (value[i] as number)?.toExponential()))} */}
+                    {/* Affichage simple */}
+                    {String(value[i])}
+                  </td>
+                ))}
+              </tr>
+            ))}
+          </tbody>
+        </table>
+      </div>
+    </div>
+  );
+}

webapp/app/lib/data.ts

@@ -0,0 +1,34 @@
+import db from "./duckdb";
+
+/**
+ * Rows are still read in chunks of 2048 elements.
+ */
+const ROW_TARGET_COUNT = 1000;
+
+export async function fetchExample() {
+  try {
+    const connection = await db.connect();
+
+    const result = await connection.runAndReadUntil(
+      "SELECT * from edc_resultats",
+      ROW_TARGET_COUNT
+    );
+
+    // Example of query with a group by :
+    // const result = await connection.runAndReadUntil(
+    //   "SELECT qualitparam, count(*) from edc_resultats group by qualitparam",
+    //   ROW_TARGET_COUNT //(Rows are read in chunks of 2048.)
+    // );
+
+    // Example of a prepared statement :
+    // const prepared = await connection.prepare(
+    //   "SELECT qualitparam, count(*) from edc_resultats where qualitparam = $1 group by qualitparam"
+    // );
+    // prepared.bindVarchar(1, "O");
+    // const result = await prepared.runAndReadUntil(ROW_TARGET_COUNT);
+    return result;
+  } catch (error) {
+    console.error("Database Error:", error);
+    throw new Error("Failed to fetch example rows.");
+  }
+}

webapp/app/lib/duckdb.ts

@@ -0,0 +1,21 @@
+import { DuckDBInstance } from "@duckdb/node-api";
+
+import fs from "fs";
+import path from "path";
+
+// Access the database file one level above the current project directory
+const dbFilePath = path.join(process.cwd(), "../database", "data.duckdb");
+// Check if the file exists
+if (!fs.existsSync(dbFilePath)) {
+  throw new Error("Database file not found");
+}
+
+//TODO: need to handle hot reload in dev mode
+console.log("Create DB instance...");
+// next build needs access to the file and can't if not using read_only because the file gets locked - @see https://duckdb.org/docs/connect/concurrency
+// it may be possible without it if we use the database differently or configure next (maybe ?), but as we are only reading in the db it should be better like this
+const db = await DuckDBInstance.create(dbFilePath, {
+  access_mode: "READ_ONLY",
+});
+
+export default db;

webapp/next.config.ts

@@ -1,7 +1,7 @@
 import type { NextConfig } from "next";
 
 const nextConfig: NextConfig = {
-  /* config options here */
+  /* config options here */ serverExternalPackages: ["@duckdb/node-api"],
 };
 
 export default nextConfig;

webapp/package.json

@@ -9,6 +9,7 @@
     "lint": "next lint"
   },
   "dependencies": {
+    "@duckdb/node-api": "^1.1.3-alpha.12",
     "maplibre-gl": "^5.0.1",
     "next": "15.1.6",
     "react": "^19.0.0",