Merge pull request #817 from FalkorDB/staging

Staging

Author: Anchel123

.env.local.template

@@ -2,3 +2,4 @@
 NEXTAUTH_URL=http://localhost:3000/
 NEXTAUTH_SECRET=SECRET
 NEXT_PUBLIC_GOOGLE_ANALYTICS=ANALYTICS
+INITIAL=3000

.github/workflows/playwright.yml

@@ -17,7 +17,8 @@ concurrency:
   cancel-in-progress: true
 
 jobs:
-  test:
+  test-part-1:
+    name: Run tests part 1 (except settings)
     timeout-minutes: 60
     runs-on: ubuntu-latest
 
@@ -28,33 +29,89 @@ jobs:
           - 6379:6379
 
     steps:
-    - uses: actions/checkout@v4
-    - uses: actions/setup-node@v4
-      with:
-        node-version: lts/*
-    - name: Install dependencies
-      run: npm ci
-    - name: Install Playwright Browsers
-      run: npx playwright install --with-deps
-    - name: Run Playwright tests with detailed reporting
-      run: |
-        npm install
-        npm run build
-        NEXTAUTH_SECRET=SECRET npm start & npx playwright test --reporter=dot,list
-    - name: Ensure required directories exist
-      run: |
-        mkdir -p playwright-report
-        mkdir -p playwright-report/artifacts
-    - uses: actions/upload-artifact@v4
-      if: always()
-      with:
-        name: playwright-report
-        path: playwright-report/
-        retention-days: 30
-    - name: Upload failed test screenshots
-      if: always()
-      uses: actions/upload-artifact@v4
-      with:
-        name: failed-test-screenshots
-        path: playwright-report/artifacts/
-        retention-days: 30
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: lts/*
+      - name: Install dependencies
+        run: npm ci
+      - name: Install Playwright Browsers
+        run: npx playwright install --with-deps
+      - name: Run Playwright tests (shard 1 of 2)
+        run: |
+          npm run build
+          NEXTAUTH_SECRET=SECRET npm start & npx playwright test --grep-invert @config --shard=1/2 --reporter=dot,list
+      - name: Upload artifacts
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: playwright-report-part-1
+          path: playwright-report/
+          retention-days: 30
+
+  test-part-2:
+    name: Run tests part 2 (except settings)
+    timeout-minutes: 60
+    runs-on: ubuntu-latest
+
+    services:
+      falkordb:
+        image: falkordb/falkordb:latest
+        ports:
+          - 6379:6379
+
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: lts/*
+      - name: Install dependencies
+        run: npm ci
+      - name: Install Playwright Browsers
+        run: npx playwright install --with-deps
+      - name: Run Playwright tests (shard 2 of 2)
+        run: |
+          npm run build
+          NEXTAUTH_SECRET=SECRET npm start & npx playwright test --grep-invert @config --shard=2/2 --reporter=dot,list
+      - name: Upload artifacts
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: playwright-report-part-2
+          path: playwright-report/
+          retention-days: 30
+
+  run-settings-tests:
+    name: Run settings tests
+    runs-on: ubuntu-latest
+
+    services:
+      falkordb:
+        image: falkordb/falkordb:latest
+        ports:
+          - 6379:6379
+
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: lts/*
+      - name: Install dependencies
+        run: npm ci
+      - name: Install Playwright Browsers
+        run: npx playwright install --with-deps
+      - name: Run only config test
+        run: |
+          npm run build
+          NEXTAUTH_SECRET=SECRET npm start & npx playwright test --grep @config --reporter=dot,list
+      - name: Ensure required directories exist
+        run: |
+          mkdir -p playwright-report
+          mkdir -p playwright-report/artifacts
+      - uses: actions/upload-artifact@v4
+        if: always()
+        with:
+          name: playwright-report-settings
+          path: playwright-report/
+          retention-days: 30
+

app/api/auth/[...nextauth]/options.ts

@@ -5,11 +5,16 @@ import { NextResponse } from "next/server";
 import { FalkorDBOptions } from "falkordb/dist/src/falkordb";
 import { ErrorReply } from "redis";
 import { v4 as uuidv4 } from 'uuid'
+import { GraphReply } from "falkordb/dist/src/graph";
 
-const connections = new Map<string, FalkorDB>();
+export type CACHE = {
+    callback: (() => void) | undefined,
+    result: GraphReply<unknown> | Error | undefined
+}
 
-async function newClient(credentials: { host: string, port: string, password: string, username: string, tls: string, ca: string }, id: string): Promise<{ role: Role, client: FalkorDB }> {
+const connections = new Map<string, { client: FalkorDB, cache: Map<number, CACHE> }>();
 
+async function newClient(credentials: { host: string, port: string, password: string, username: string, tls: string, ca: string }, id: string): Promise<{ role: Role, client: FalkorDB, cache: Map<number, CACHE> }> {
     const connectionOptions: FalkorDBOptions = credentials.tls === "true" ?
         {
             socket: {
@@ -34,15 +39,15 @@ async function newClient(credentials: { host: string, port: string, password: st
     const client = await FalkorDB.connect(connectionOptions)
 
     // Save connection in connections map for later use
-    connections.set(id, client)
+    connections.set(id, { client, cache: new Map<number, CACHE>() })
 
     client.on('error', err => {
         // Close coonection on error and remove from connections map
         console.error('FalkorDB Client Error', err)
         const connection = connections.get(id)
         if (connection) {
             connections.delete(id)
-            connection.close()
+            connection.client.close()
                 .catch((e) => {
                     console.warn('FalkorDB Client Disconnect Error', e)
                 })
@@ -51,10 +56,11 @@ async function newClient(credentials: { host: string, port: string, password: st
 
     // Verify connection and Role
     const connection = await client.connection
+    const cache = new Map<number, CACHE>()
 
     try {
         await connection.aclGetUser(credentials.username || "default")
-        return { role: "Admin", client }
+        return { role: "Admin", client, cache }
     } catch (err) {
         if (err instanceof ErrorReply && (err as ErrorReply).message.startsWith("NOPERM")) {
             console.debug(err);
@@ -66,13 +72,13 @@ async function newClient(credentials: { host: string, port: string, password: st
     } catch (err) {
         if ((err as Error).message.includes("permissions")) {
             console.debug(err);
-            return { role: "Read-Only", client }
+            return { role: "Read-Only", client, cache }
         }
         console.debug(err);
-        return { role: "Read-Write", client }
+        return { role: "Read-Write", client, cache }
     }
 
-    return { role: "Admin", client }
+    return { role: "Admin", client, cache }
 }
 
 function generateTimeUUID() {
@@ -170,25 +176,27 @@ export async function getClient() {
     }
 
     const { user } = session;
-    let client = connections.get(user.id)
+    let connection = connections.get(user.id)
 
     // If client is not found, create a new one
-    if (!client) {
-        client = (await newClient({
+    if (!connection) {
+        connection = (await newClient({
             host: user.host,
             port: user.port.toString() ?? "6379",
             username: user.username,
             password: user.password,
             tls: String(user.tls),
             ca: user.ca
-        }, user.id)).client
+        }, user.id))
     }
 
+    const { client, cache } = connection
+
     if (!client) {
         return NextResponse.json({ message: "Not authenticated" }, { status: 401 })
     }
 
-    return { client, user }
+    return { client, user, cache }
 }
 
 export default authOptions

app/api/graph/[graph]/[node]/[key]/route.ts

@@ -0,0 +1,69 @@
+import { NextResponse, NextRequest } from "next/server"
+import { getClient } from "@/app/api/auth/[...nextauth]/options"
+
+export async function POST(request: NextRequest, { params }: { params: Promise<{ graph: string, node: string, key: string }> }) {
+    const session = await getClient()
+
+    if (session instanceof NextResponse) {
+        return session
+    }
+
+    const { client } = session
+
+    const { graph: graphId, node, key } = await params
+    const nodeId = Number(node)
+    const { value, type } = await request.json()
+
+    try {
+        if (type === undefined) throw new Error("Type is required")
+
+        const graph = client.selectGraph(graphId);
+
+        if (!value) throw new Error("Value is required")
+
+        const query = type
+            ? `MATCH (n) WHERE ID(n) = $nodeId SET n.${key} = $value`
+            : `MATCH (n)-[e]-(m) WHERE ID(e) = $nodeId SET e.${key} = $value`;
+
+        const result = await graph.query(query, { params: { nodeId, value } });
+
+        if (!result) throw new Error("Something went wrong")
+
+        return NextResponse.json({ result }, { status: 200 })
+    } catch (err: unknown) {
+        console.error(err)
+        return NextResponse.json({ message: (err as Error).message }, { status: 400 })
+    }
+}
+
+export async function DELETE(request: NextRequest, { params }: { params: Promise<{ graph: string, node: string, key: string }> }) {
+    const session = await getClient()
+    if (session instanceof NextResponse) {
+        return session
+    }
+
+    const { client } = session
+
+    const { graph: graphId, node, key } = await params
+    const nodeId = Number(node)
+    const { type } = await request.json()
+
+    try {
+        if (type === undefined) throw new Error("Type is required")
+
+        const graph = client.selectGraph(graphId);
+
+        const query = type
+            ? `MATCH (n) WHERE ID(n) = $nodeId SET n.${key} = NULL`
+            : `MATCH (n)-[e]-(m) WHERE ID(e) = $nodeId SET e.${key} = NULL`;
+
+        const result = await graph.query(query, { params: { nodeId } });
+
+        if (!result) throw new Error("Something went wrong")
+
+        return NextResponse.json({ result }, { status: 200 })
+    } catch (err: unknown) {
+        console.error(err)
+        return NextResponse.json({ message: (err as Error).message }, { status: 400 })
+    }
+}

app/api/graph/[graph]/[node]/label/route.ts

@@ -0,0 +1,62 @@
+import { getClient } from "@/app/api/auth/[...nextauth]/options";
+import { NextRequest, NextResponse } from "next/server";
+
+export async function DELETE(request: NextRequest, { params }: { params: Promise<{ graph: string, node: string }> }) {
+
+    const session = await getClient()
+
+    if (session instanceof NextResponse) {
+        return session
+    }
+
+    const { client } = session
+
+    const { graph: graphId, node } = await params
+    const nodeId = Number(node)
+    const { label } = await request.json()
+
+    try {
+        if (!label) throw new Error("Label is required")
+
+        const query = `MATCH (n) WHERE ID(n) = $nodeId REMOVE n:${label}`
+        const graph = client.selectGraph(graphId);
+        const result = await graph.query(query, { params: { nodeId } })
+
+        if (!result) throw new Error("Something went wrong")
+
+        return NextResponse.json({ message: "Label removed successfully" }, { status: 200 });
+    } catch (err: unknown) {
+        console.error(err)
+        return NextResponse.json({ message: (err as Error).message }, { status: 400 })
+    }
+}
+
+export async function POST(request: NextRequest, { params }: { params: Promise<{ graph: string, node: string }> }) {
+
+    const session = await getClient()
+
+    if (session instanceof NextResponse) {
+        return session
+    }
+
+    const { client } = session
+
+    const { graph: graphId, node } = await params
+    const nodeId = Number(node)
+    const { label } = await request.json()
+
+    try {
+        if (!label) throw new Error("Label is required")
+
+        const query = `MATCH (n) WHERE ID(n) = $nodeId SET n:${label}`
+        const graph = client.selectGraph(graphId);
+        const result = await graph.query(query, { params: { nodeId } })
+
+        if (!result) throw new Error("Something went wrong")
+
+        return NextResponse.json({ message: "Label added successfully" }, { status: 200 });
+    } catch (err: unknown) {
+        console.error(err)
+        return NextResponse.json({ message: (err as Error).message }, { status: 400 })
+    }
+}