feat: protocol

Author: coodos

infrastructure/evault-core/package.json

@@ -14,12 +14,17 @@
     "@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.ts

@@ -1,4 +1,4 @@
-import neo4j, { Driver } from "neo4j-driver";
+import { Driver } from "neo4j-driver";
 import { W3IDBuilder } from "w3id";
 import { serializeValue, deserializeValue } from "./schema";
 import {

infrastructure/evault-core/src/evault.ts

@@ -0,0 +1,12 @@
+import neo4j from "neo4j-driver";
+import { DbService } from "./db/db.service";
+import { GraphQLServer } from "./protocol/graphql-server";
+
+async function startEVault() {
+    const uri = `bolt://localhost:7687`;
+    const driver = neo4j.driver(uri, neo4j.auth.basic("neo4j", "testpass"));
+    const dbService = new DbService(driver);
+    new GraphQLServer(dbService);
+}
+
+startEVault();

infrastructure/evault-core/src/protocol/graphql-server.ts

@@ -0,0 +1,92 @@
+import { createSchema, createYoga } from "graphql-yoga";
+import { createServer } from "http";
+import { typeDefs } from "./typedefs";
+import { DbService } from "../db/db.service";
+import { renderVoyagerPage } from "graphql-voyager/middleware";
+
+export class GraphQLServer {
+    private db: DbService;
+
+    constructor(db: DbService) {
+        this.db = db;
+        this.instantiateServer();
+    }
+
+    private instantiateServer() {
+        const resolvers = {
+            JSON: require("graphql-type-json"),
+
+            Query: {
+                getMetaEnvelopeById: (_: any, { id }: { id: string }) =>
+                    this.db.findMetaEnvelopeById(id),
+                findMetaEnvelopesByOntology: (
+                    _: any,
+                    { ontology }: { ontology: string },
+                ) => this.db.findMetaEnvelopesByOntology(ontology),
+                searchMetaEnvelopes: (
+                    _: any,
+                    { ontology, term }: { ontology: string; term: string },
+                ) => this.db.findMetaEnvelopesBySearchTerm(ontology, term),
+                getAllEnvelopes: () => this.db.getAllEnvelopes(),
+            },
+
+            Mutation: {
+                storeMetaEnvelope: async (
+                    _: any,
+                    {
+                        input,
+                    }: {
+                        input: {
+                            ontology: string;
+                            payload: any;
+                            acl: string[];
+                        };
+                    },
+                ) => {
+                    return await this.db.storeMetaEnvelope(
+                        {
+                            ontology: input.ontology,
+                            payload: input.payload,
+                            acl: input.acl,
+                        },
+                        input.acl,
+                    );
+                },
+                deleteMetaEnvelope: async (_: any, { id }: { id: string }) => {
+                    await this.db.deleteMetaEnvelope(id);
+                    return true;
+                },
+                updateEnvelopeValue: async (
+                    _: any,
+                    {
+                        envelopeId,
+                        newValue,
+                    }: { envelopeId: string; newValue: any },
+                ) => {
+                    await this.db.updateEnvelopeValue(envelopeId, newValue);
+                    return true;
+                },
+            },
+        };
+
+        const schema = createSchema({ typeDefs, resolvers });
+        const yoga = createYoga({ schema });
+        const server = createServer((req, res) => {
+            if (req.url === "/voyager") {
+                res.writeHead(200, { "Content-Type": "text/html" });
+                res.end(
+                    renderVoyagerPage({
+                        endpointUrl: "/graphql",
+                    }),
+                );
+            } else {
+                yoga(req, res);
+            }
+        });
+
+        server.listen(4000, () => {
+            console.log("🚀 GraphQL at http://localhost:4000/graphql");
+            console.log("🛰️ Voyager at http://localhost:4000/voyager");
+        });
+    }
+}

infrastructure/evault-core/src/protocol/typedefs.ts

@@ -0,0 +1,43 @@
+// GraphQL Schema Definition
+export const typeDefs = /* GraphQL */ `
+    scalar JSON
+
+    type Envelope {
+        id: String!
+        ontology: String!
+        value: JSON
+        valueType: String
+    }
+
+    type MetaEnvelope {
+        id: String!
+        ontology: String!
+        acl: [String!]!
+        envelopes: [Envelope!]!
+        parsed: JSON
+    }
+
+    type StoreMetaEnvelopeResult {
+        metaEnvelope: MetaEnvelope!
+        envelopes: [Envelope!]!
+    }
+
+    type Query {
+        getMetaEnvelopeById(id: String!): MetaEnvelope
+        findMetaEnvelopesByOntology(ontology: String!): [String!]!
+        searchMetaEnvelopes(ontology: String!, term: String!): [MetaEnvelope!]!
+        getAllEnvelopes: [Envelope!]!
+    }
+
+    input MetaEnvelopeInput {
+        ontology: String!
+        payload: JSON!
+        acl: [String!]!
+    }
+
+    type Mutation {
+        storeMetaEnvelope(input: MetaEnvelopeInput!): StoreMetaEnvelopeResult!
+        deleteMetaEnvelope(id: String!): Boolean!
+        updateEnvelopeValue(envelopeId: String!, newValue: JSON!): Boolean!
+    }
+`;