Staging

.github/workflows/playwright.yml

@@ -0,0 +1,41 @@
+name: Playwright Tests
+on:
+  push:
+    branches: [ main, staging ]
+  pull_request:
+    branches: [ main, staging ]
+jobs:
+  test:
+    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: Set up environment variables and run tests
+      env:
+        FALKORDB_URL: ${{ secrets.FALKORDB_URL }}
+        OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
+        SECRET_TOKEN: ${{ secrets.SECRET_TOKEN }}
+        NEXT_PUBLIC_MODE: UNLIMITED
+        BACKEND_URL: ${{ secrets.BACKEND_URL }}
+      run: |
+        npm install
+        npm run build
+        NEXTAUTH_SECRET=SECRET npm start & npx playwright test --reporter=dot,list
+    - uses: actions/upload-artifact@v4
+      if: ${{ !cancelled() }}
+      with:
+        name: playwright-report
+        path: playwright-report/
+        retention-days: 30

.gitignore

@@ -37,4 +37,9 @@ next-env.d.ts
 
 
 # vscode
-/.vscode/
+/.vscode/
+node_modules/
+/test-results/
+/playwright-report/
+/blob-report/
+/playwright/.cache/

app/api/chat/[graph]/route.ts

@@ -0,0 +1,39 @@
+import { NextRequest, NextResponse } from "next/server"
+import { getEnvVariables } from "../../utils"
+
+
+export async function POST(request: NextRequest, { params }: { params: Promise<{ graph: string }> }) {
+
+    const repo = (await params).graph
+    const msg = request.nextUrl.searchParams.get('msg')
+
+    try {
+
+        if (!msg) {
+            throw new Error("Message parameter is required")
+        }
+
+        const { url, token } = getEnvVariables()
+
+        const result = await fetch(`${url}/chat`, {
+            method: 'POST',
+            body: JSON.stringify({ repo, msg }),
+            headers: {
+                "Authorization": token,
+                "Content-Type": 'application/json'
+            },
+            cache: 'no-store'
+        })
+
+        if (!result.ok) {
+            throw new Error(await result.text())
+        }
+
+        const json = await result.json()
+
+        return NextResponse.json({ result: json }, { status: 200 })
+    } catch (err) {
+        console.error(err)
+        return NextResponse.json((err as Error).message, { status: 400 })
+    }
+}

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

@@ -1,24 +1,45 @@
-import { FalkorDB, Graph } from "falkordb";
+import { getEnvVariables } from "@/app/api/utils";
 import { NextRequest, NextResponse } from "next/server";
 
-export async function GET(request: NextRequest, { params }: { params: { graph: string, node: string } }) {
-
-    const nodeId  = parseInt(params.node);
-    const graphId = params.graph;
+export async function POST(request: NextRequest, { params }: { params: Promise<{ graph: string, node: string }> }) {
 
-    const db = await FalkorDB.connect({url: process.env.FALKORDB_URL || 'falkor://localhost:6379',});
-    const graph = db.selectGraph(graphId);
+    const p = await params;
 
-    // Get node's neighbors    
-    const q_params = {nodeId: nodeId};
-    const query    = `MATCH (src)-[e]-(n)
-                      WHERE ID(src) = $nodeId
-                      RETURN collect(distinct { label:labels(n)[0], id:ID(n), name: n.name } ) as nodes,
-                      collect( { src: ID(startNode(e)), id: ID(e), dest: ID(endNode(e)), type: type(e) } ) as edges`;
+    const repo = p.graph;
+    const src = Number(p.node);
+    const dest = Number(request.nextUrl.searchParams.get('targetId'))
 
-    let res: any = await graph.query(query, { params: q_params });
-    let nodes = res.data[0]['nodes'];
-    let edges = res.data[0]['edges'];
+    try {
 
-    return NextResponse.json({ id: graphId, nodes: nodes, edges: edges }, { status: 200 })
+        if (!dest) {
+            throw new Error("targetId is required");
+        }
+
+        const { url, token } = getEnvVariables()
+
+        const result = await fetch(`${url}/find_paths`, {
+            method: 'POST',
+            headers: {
+                "Authorization": token,
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+                repo,
+                src,
+                dest
+            }),
+            cache: 'no-store'
+        })
+
+        if (!result.ok) {
+            throw new Error(await result.text())
+        }
+
+        const json = await result.json()
+
+        return NextResponse.json({ result: json }, { status: 200 })
+    } catch (err) {
+        console.error(err)
+        return NextResponse.json((err as Error).message, { status: 400 })
+    }
 }

app/api/repo/[graph]/commit/route.ts

@@ -0,0 +1,37 @@
+import { getEnvVariables } from "@/app/api/utils";
+import { NextRequest, NextResponse } from "next/server";
+
+export async function GET(request: NextRequest, { params }: { params: Promise<{ graph: string }> }) {
+
+    const repo = (await params).graph
+
+    try {
+
+        const { url, token } = getEnvVariables()
+
+        const result = await fetch(`${url}/list_commits`, {
+            method: 'POST',
+            body: JSON.stringify({ repo }),
+            headers: {
+                "Authorization": token,
+                "Content-Type": 'application/json'
+            },
+            cache: 'no-store'
+        })
+
+        if (!result.ok) {
+            throw new Error(await result.text())
+        }
+
+        const json = await result.json()
+
+        return NextResponse.json({ result: json }, { status: 200 })
+    } catch (err) {
+        console.error(err)
+        return NextResponse.json((err as Error).message, { status: 400 })
+    }
+}
+
+export async function POST(request: NextRequest, { params }: { params: Promise<{ graph: string }> }) {
+
+}

app/api/repo/[graph]/info/route.ts

@@ -0,0 +1,33 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getEnvVariables } from "@/app/api/utils";
+
+export async function GET(request: NextRequest, { params }: { params: Promise<{ graph: string }> }) {
+
+    const repo = (await params).graph
+
+    try {
+
+        const { url, token } = getEnvVariables();
+
+        const result = await fetch(`${url}/repo_info`, {
+            method: 'POST',
+            body: JSON.stringify({ repo }),
+            headers: {
+                "Authorization": token,
+                "Content-Type": 'application/json'
+            },
+            cache: 'no-store'
+        })
+
+        if (!result.ok) {
+            throw new Error(await result.text())
+        }
+
+        const json = await result.json()
+
+        return NextResponse.json({ result: json }, { status: 200 })
+    } catch (err) {
+        console.error(err)
+        return NextResponse.json((err as Error).message, { status: 400 })
+    }
+}

app/api/repo/[graph]/neighbors/route.ts

@@ -0,0 +1,34 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getEnvVariables } from "@/app/api/utils";
+
+export async function POST(request: NextRequest, { params }: { params: Promise<{ graph: string }> }) {
+
+    const repo = (await params).graph;
+    const node_ids = (await request.json()).nodeIds.map((id: string) => Number(id));
+
+    try {
+
+        const { url, token } = getEnvVariables();
+
+        if (node_ids.length === 0) {
+            throw new Error("nodeIds is required");
+        }
+
+        const result = await fetch(`${url}/get_neighbors`, {
+            method: 'POST',
+            body: JSON.stringify({ node_ids, repo }),
+            headers: {
+                "Content-Type": 'application/json',
+                "Authorization": token,
+            },
+            cache: 'no-store'
+        })
+
+        const json = await result.json()
+
+        return NextResponse.json({ result: json }, { status: 200 })
+    } catch (err) {
+        console.error(err)
+        return NextResponse.json((err as Error).message, { status: 400 })
+    }
+}