chore: envelope logic works

Author: coodos

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

@@ -4,6 +4,12 @@ import { it, describe, beforeAll, afterAll, expect } from "vitest";
 import { v4 as uuidv4 } from "uuid";
 import { Neo4jContainer, StartedNeo4jContainer } from "@testcontainers/neo4j";
 
+type Envelope = {
+    id: string;
+    ontology: string;
+    value: any;
+};
+
 describe("DbService (integration)", () => {
     let container: StartedNeo4jContainer;
     let service: DbService;
@@ -28,42 +34,48 @@ describe("DbService (integration)", () => {
     });
 
     it("should store and retrieve a meta-envelope", async () => {
-        const testId = uuidv4();
         const input = {
-            id: testId,
             ontology: "SocialMediaPost",
             payload: {
                 text: "hello world",
                 dateCreated: "2025-04-10",
                 likes: ["user1", "user2"],
             },
+            acl: ["@test-user"],
         };
 
-        const result = await service.storeMetaEnvelope(input, ["@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("SocialMediaPost");
+        expect(fetched.acl).toEqual(["@test-user"]);
         expect(fetched.envelopes).toHaveLength(3);
+        expect(fetched.envelopes[0]).toEqual(
+            expect.objectContaining({
+                id: expect.any(String),
+                ontology: expect.any(String),
+                value: expect.any(String),
+            }),
+        );
+
+        console.log(fetched);
     });
 
     it("should find meta-envelopes containing the search term in any envelope value", async () => {
-        const metaId = uuidv4();
         const input = {
-            id: metaId,
             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, [
-            "@search-test-user",
-        ]);
+        const metaEnv = await service.storeMetaEnvelope(input, input.acl);
 
         const found = await service.findMetaEnvelopesBySearchTerm(
             "SocialMediaPost",
@@ -97,52 +109,49 @@ describe("DbService (integration)", () => {
     });
 
     it("should delete a meta-envelope and its envelopes", async () => {
-        const tempId = uuidv4();
         const meta = {
-            id: tempId,
             ontology: "TempPost",
             payload: {
                 value: "to be deleted",
             },
+            acl: ["@delete-user"],
         };
 
-        await service.storeMetaEnvelope(meta, ["@delete-user"]);
-        await service.deleteMetaEnvelope(tempId);
+        const stored = await service.storeMetaEnvelope(meta, meta.acl);
+        await service.deleteMetaEnvelope(stored.metaEnvelope.id);
 
-        const deleted = await service.findMetaEnvelopeById(tempId);
+        const deleted = await service.findMetaEnvelopeById(
+            stored.metaEnvelope.id,
+        );
         expect(deleted).toBeNull();
     });
 
     it("should update envelope value", async () => {
-        const testId = uuidv4();
         const meta = {
-            id: testId,
             ontology: "UpdateTest",
             payload: {
                 value: "original",
             },
+            acl: ["@updater"],
         };
 
-        const stored = await service.storeMetaEnvelope(meta, ["@updater"]);
+        const stored = await service.storeMetaEnvelope(meta, meta.acl);
 
         const result = await service.findMetaEnvelopeById(
             stored.metaEnvelope.id,
         );
         const targetEnvelope = result.envelopes.find(
-            (e: any) => e.properties.ontology === "value",
+            (e: Envelope) => e.ontology === "value",
         );
 
-        await service.updateEnvelopeValue(
-            targetEnvelope.properties.id,
-            "updated",
-        );
+        await service.updateEnvelopeValue(targetEnvelope.id, "updated");
 
         const updated = await service.findMetaEnvelopeById(
             stored.metaEnvelope.id,
         );
         const updatedValue = updated.envelopes.find(
-            (e: any) => e.properties.id === targetEnvelope.properties.id,
+            (e: Envelope) => e.id === targetEnvelope.id,
         );
-        expect(updatedValue.properties.value).toBe("updated");
+        expect(updatedValue.value).toBe("updated");
     });
 });

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

@@ -2,16 +2,15 @@ import neo4j, { Driver, Session } from "neo4j-driver";
 import { W3IDBuilder } from "w3id";
 
 type MetaEnvelope = {
-    id: string;
     ontology: string;
     payload: Record<string, any>;
+    acl: string[];
 };
 
 type Envelope = {
     id: string;
     value: any;
     ontology: string;
-    acl: string[];
 };
 
 export class DbService {
@@ -30,17 +29,17 @@ export class DbService {
         }
     }
 
-    async storeMetaEnvelope(meta: MetaEnvelope, acl: string[]) {
+    async storeMetaEnvelope(meta: Omit<MetaEnvelope, "id">, acl: string[]) {
         const w3id = await new W3IDBuilder().build();
 
         const cypher: string[] = [
-            `CREATE (m:MetaEnvelope { id: $metaId, ontology: $ontology })`,
+            `CREATE (m:MetaEnvelope { id: $metaId, ontology: $ontology, acl: $acl })`,
         ];
 
         const envelopeParams: Record<string, any> = {
             metaId: w3id.id,
             ontology: meta.ontology,
-            acl,
+            acl: acl,
         };
 
         const createdEnvelopes: Envelope[] = [];
@@ -58,8 +57,7 @@ export class DbService {
       CREATE (${alias}:Envelope {
         id: $${alias}_id,
         ontology: $${alias}_ontology,
-        value: $${alias}_value,
-        acl: $acl
+        value: $${alias}_value
       })
       WITH m, ${alias}
       MERGE (m)-[:LINKS_TO]->(${alias})
@@ -73,7 +71,6 @@ export class DbService {
                 id: envelopeId,
                 ontology: key,
                 value: value,
-                acl,
             });
 
             counter++;
@@ -85,6 +82,7 @@ export class DbService {
             metaEnvelope: {
                 id: w3id.id,
                 ontology: meta.ontology,
+                acl: acl,
             },
             envelopes: createdEnvelopes,
         };
@@ -105,20 +103,36 @@ export class DbService {
 
         return result.records.map((record) => ({
             id: record.get("id"),
-            envelopes: record.get("envelopes").map((e: any) => e.properties),
+            envelopes: record.get("envelopes").map((node: any) => ({
+                id: node.properties.id,
+                ontology: node.properties.ontology,
+                value: node.properties.value,
+            })),
         }));
     }
 
     async findMetaEnvelopeById(id: string): Promise<any> {
         const result = await this.runQuery(
             `
       MATCH (m:MetaEnvelope { id: $id })-[:LINKS_TO]->(e:Envelope)
-      RETURN m.id AS id, m.ontology AS ontology, collect(e) AS envelopes
+      RETURN m.id AS id, m.ontology AS ontology, m.acl AS acl, collect(e) AS envelopes
       `,
             { id },
         );
 
-        return result.records[0]?.toObject() ?? null;
+        if (!result.records[0]) return null;
+
+        const record = result.records[0];
+        return {
+            id: record.get("id"),
+            ontology: record.get("ontology"),
+            acl: record.get("acl"),
+            envelopes: record.get("envelopes").map((node: any) => ({
+                id: node.properties.id,
+                ontology: node.properties.ontology,
+                value: node.properties.value,
+            })),
+        };
     }
 
     async findMetaEnvelopesByOntology(ontology: string): Promise<string[]> {
@@ -158,7 +172,14 @@ export class DbService {
 
     async getAllEnvelopes(): Promise<Envelope[]> {
         const result = await this.runQuery(`MATCH (e:Envelope) RETURN e`, {});
-        return result.records.map((r) => r.get("e").properties as Envelope);
+        return result.records.map((r) => {
+            const node = r.get("e");
+            return {
+                id: node.properties.id,
+                ontology: node.properties.ontology,
+                value: node.properties.value,
+            };
+        });
     }
 
     async close(): Promise<void> {