Feat/evault core

.github/workflows/tests-evault-core.yml

@@ -0,0 +1,34 @@
+name: Tests [evault-core]
+
+on:
+  push:
+    branches: [main]
+    paths:
+      - 'infrastructure/evault-core/**'
+  pull_request:
+    branches: [main]
+    paths:
+      - 'infrastructure/w3id/**'
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v3
+
+      - name: Set up Node.js 22
+        uses: actions/setup-node@v4
+        with:
+          node-version: 22
+
+      - name: Install pnpm
+        run: npm install -g pnpm
+
+      - name: Install dependencies
+        run: pnpm install
+
+      - name: Run tests
+        run: pnpm -F=evault-core test
+

infrastructure/evault-core/docker-compose.yml

@@ -0,0 +1,22 @@
+version: '3.8'
+
+services:
+  neo4j:
+    image: neo4j:5.15
+    container_name: neo4j
+    ports:
+      - "7474:7474"
+      - "7687:7687"
+    environment:
+      - NEO4J_AUTH=neo4j/testpass
+    volumes:
+      - neo4j_data:/data
+    networks:
+      - graphnet
+
+volumes:
+  neo4j_data:
+
+networks:
+  graphnet:
+    driver: bridge

infrastructure/evault-core/package.json

@@ -1,12 +1,32 @@
 {
-	"name": "evault-core",
-	"version": "1.0.0",
-	"description": "",
-	"main": "index.js",
-	"scripts": {
-		"test": "echo \"Error: no test specified\" && exit 1"
-	},
-	"keywords": [],
-	"author": "",
-	"license": "ISC"
+  "name": "evault-core",
+  "version": "0.1.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "vitest --config vitest.config.ts"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "@types/json-schema": "^7.0.15",
+    "@types/node": "^22.13.10",
+    "dotenv": "^16.5.0",
+    "testcontainers": "^10.24.2",
+    "tsx": "^4.19.3",
+    "typescript": "^5.8.3",
+    "uuid": "^11.1.0",
+    "vitest": "^3.0.9"
+  },
+  "dependencies": {
+    "@testcontainers/neo4j": "^10.24.2",
+    "graphql": "^16.10.0",
+    "graphql-type-json": "^0.3.2",
+    "graphql-voyager": "^2.1.0",
+    "graphql-yoga": "^5.13.4",
+    "json-schema": "^0.4.0",
+    "neo4j-driver": "^5.28.1",
+    "w3id": "workspace:*"
+  }
 }

infrastructure/evault-core/src/db/db.service.spec.ts

@@ -0,0 +1,270 @@
+import neo4j, { Driver } from "neo4j-driver";
+import { DbService } from "./db.service"; // adjust if needed
+import { it, describe, beforeAll, afterAll, expect } from "vitest";
+import { Neo4jContainer, StartedNeo4jContainer } from "@testcontainers/neo4j";
+
+type Envelope = {
+    id: string;
+    ontology: string;
+    value: any;
+    valueType: string;
+};
+
+describe("DbService (integration)", () => {
+    let container: StartedNeo4jContainer;
+    let service: DbService;
+    let driver: Driver;
+
+    beforeAll(async () => {
+        container = await new Neo4jContainer("neo4j:5.15").start();
+
+        const username = container.getUsername();
+        const password = container.getPassword();
+        const boltPort = container.getMappedPort(7687);
+        const uri = `bolt://localhost:${boltPort}`;
+
+        driver = neo4j.driver(uri, neo4j.auth.basic(username, password));
+        service = new DbService(driver);
+    });
+
+    afterAll(async () => {
+        await service.close();
+        await driver.close();
+        await container.stop();
+    });
+
+    it("should store and retrieve a meta-envelope with various data types", async () => {
+        const input = {
+            ontology: "TestTypes",
+            payload: {
+                string: "hello world",
+                number: 42,
+                boolean: true,
+                date: new Date("2025-04-10T00:00:00Z"),
+                array: [1, 2, 3],
+                object: { nested: { value: "deep" } },
+            },
+            acl: ["@test-user"],
+        };
+
+        const result = await service.storeMetaEnvelope(input, input.acl);
+        const id = result.metaEnvelope.id;
+
+        const fetched = await service.findMetaEnvelopeById(id);
+        expect(fetched).toBeDefined();
+        expect(fetched.id).toBeDefined();
+        expect(fetched.ontology).toBe("TestTypes");
+        expect(fetched.acl).toEqual(["@test-user"]);
+        expect(fetched.envelopes).toHaveLength(6);
+
+        // Verify parsed field matches original payload
+        expect(fetched.parsed).toEqual(input.payload);
+
+        // Verify each data type is properly stored and retrieved
+        const envelopes = fetched.envelopes.reduce(
+            (acc: Record<string, Envelope>, e: Envelope) => {
+                acc[e.ontology] = e;
+                return acc;
+            },
+            {},
+        );
+
+        expect(envelopes.string.value).toBe("hello world");
+        expect(envelopes.string.valueType).toBe("string");
+
+        expect(envelopes.number.value).toBe(42);
+        expect(envelopes.number.valueType).toBe("number");
+
+        expect(envelopes.boolean.value).toBe(true);
+        expect(envelopes.boolean.valueType).toBe("boolean");
+
+        expect(envelopes.date.value).toBeInstanceOf(Date);
+        expect(envelopes.date.value.toISOString()).toBe(
+            "2025-04-10T00:00:00.000Z",
+        );
+        expect(envelopes.date.valueType).toBe("date");
+
+        expect(envelopes.array.value).toEqual([1, 2, 3]);
+        expect(envelopes.array.valueType).toBe("array");
+
+        expect(envelopes.object.value).toEqual({ nested: { value: "deep" } });
+        expect(envelopes.object.valueType).toBe("object");
+    });
+
+    it("should find meta-envelopes containing the search term in any envelope value", async () => {
+        const input = {
+            ontology: "SocialMediaPost",
+            payload: {
+                text: "This is a searchable tweet",
+                image: "https://example.com/image.jpg",
+                likes: ["user1", "user2"],
+            },
+            acl: ["@search-test-user"],
+        };
+
+        const metaEnv = await service.storeMetaEnvelope(input, input.acl);
+
+        const found = await service.findMetaEnvelopesBySearchTerm(
+            "SocialMediaPost",
+            "searchable",
+        );
+
+        expect(Array.isArray(found)).toBe(true);
+        const match = found.find((m) => m.id === metaEnv.metaEnvelope.id);
+        expect(match).toBeDefined();
+        if (!match) throw new Error();
+        expect(match.envelopes.length).toBeGreaterThan(0);
+        expect(
+            match.envelopes.some((e) => e.value.includes("searchable")),
+        ).toBe(true);
+    });
+
+    it("should return empty array if no values contain the search term", async () => {
+        const found = await service.findMetaEnvelopesBySearchTerm(
+            "SocialMediaPost",
+            "notfoundterm",
+        );
+        expect(Array.isArray(found)).toBe(true);
+        expect(found.length).toBe(0);
+    });
+
+    it("should find meta-envelopes by ontology", async () => {
+        const results =
+            await service.findMetaEnvelopesByOntology("SocialMediaPost");
+        expect(Array.isArray(results)).toBe(true);
+        expect(results.length).toBeGreaterThan(0);
+    });
+
+    it("should delete a meta-envelope and its envelopes", async () => {
+        const meta = {
+            ontology: "TempPost",
+            payload: {
+                value: "to be deleted",
+            },
+            acl: ["@delete-user"],
+        };
+
+        const stored = await service.storeMetaEnvelope(meta, meta.acl);
+        await service.deleteMetaEnvelope(stored.metaEnvelope.id);
+
+        const deleted = await service.findMetaEnvelopeById(
+            stored.metaEnvelope.id,
+        );
+        expect(deleted).toBeNull();
+    });
+
+    it("should update envelope value with proper type handling", async () => {
+        const meta = {
+            ontology: "UpdateTest",
+            payload: {
+                value: "original",
+            },
+            acl: ["@updater"],
+        };
+
+        const stored = await service.storeMetaEnvelope(meta, meta.acl);
+
+        const result = await service.findMetaEnvelopeById(
+            stored.metaEnvelope.id,
+        );
+        const targetEnvelope = result.envelopes.find(
+            (e: Envelope) => e.ontology === "value",
+        );
+
+        // Update with a different type
+        const newValue = new Date("2025-04-10T00:00:00Z");
+        await service.updateEnvelopeValue(targetEnvelope.id, newValue);
+
+        const updated = await service.findMetaEnvelopeById(
+            stored.metaEnvelope.id,
+        );
+        const updatedValue = updated.envelopes.find(
+            (e: Envelope) => e.id === targetEnvelope.id,
+        );
+        expect(updatedValue.value).toBeInstanceOf(Date);
+        expect(updatedValue.value.toISOString()).toBe(
+            "2025-04-10T00:00:00.000Z",
+        );
+        expect(updatedValue.valueType).toBe("date");
+    });
+
+    it("should find meta-envelopes containing the search term in any value type", async () => {
+        const input = {
+            ontology: "SearchTest",
+            payload: {
+                string: "This is a searchable string",
+                array: ["searchable", "array", "element"],
+                object: { text: "searchable object" },
+                number: 42,
+                date: new Date("2025-04-10T00:00:00Z"),
+            },
+            acl: ["@search-test-user"],
+        };
+
+        const metaEnv = await service.storeMetaEnvelope(input, input.acl);
+
+        // Test search in string
+        const foundInString = await service.findMetaEnvelopesBySearchTerm(
+            "SearchTest",
+            "searchable string",
+        );
+        expect(foundInString.length).toBeGreaterThan(0);
+        expect(foundInString[0].id).toBe(metaEnv.metaEnvelope.id);
+
+        // Test search in array
+        const foundInArray = await service.findMetaEnvelopesBySearchTerm(
+            "SearchTest",
+            "searchable",
+        );
+        expect(foundInArray.length).toBeGreaterThan(0);
+        expect(foundInArray[0].id).toBe(metaEnv.metaEnvelope.id);
+
+        // Test search in object
+        const foundInObject = await service.findMetaEnvelopesBySearchTerm(
+            "SearchTest",
+            "searchable object",
+        );
+        expect(foundInObject.length).toBeGreaterThan(0);
+        expect(foundInObject[0].id).toBe(metaEnv.metaEnvelope.id);
+    });
+
+    it("should find meta-envelopes containing the search term with parsed payload", async () => {
+        const input = {
+            ontology: "SearchTestHeyyy",
+            payload: {
+                string: "This is a searchable string",
+                array: ["searchable", "array", "element"],
+                object: { text: "searchable object" },
+                number: 42,
+                date: new Date("2025-04-10T00:00:00Z"),
+            },
+            acl: ["@search-test-user"],
+        };
+
+        const metaEnv = await service.storeMetaEnvelope(input, input.acl);
+
+        // Test search in string
+        const foundInString = await service.findMetaEnvelopesBySearchTerm(
+            "SearchTestHeyyy",
+            "searchable string",
+        );
+        expect(foundInString.length).toBeGreaterThan(0);
+        expect(foundInString[0].id).toBe(metaEnv.metaEnvelope.id);
+
+        // Test search in array
+        const foundInArray = await service.findMetaEnvelopesBySearchTerm(
+            "SearchTestHeyyy",
+            "searchable",
+        );
+        expect(foundInArray.length).toBeGreaterThan(0);
+        expect(foundInArray[0].id).toBe(metaEnv.metaEnvelope.id);
+
+        // Test search in object
+        const foundInObject = await service.findMetaEnvelopesBySearchTerm(
+            "SearchTestHeyyy",
+            "searchable object",
+        );
+        expect(foundInObject.length).toBeGreaterThan(0);
+        expect(foundInObject[0].id).toBe(metaEnv.metaEnvelope.id);
+    });
+});