feat: registry using local db

Author: coodos

infrastructure/evault-provisioner/src/index.ts

@@ -4,11 +4,15 @@ import { provisionEVault } from "./templates/evault.nomad.js";
 import dotenv from "dotenv";
 import { W3IDBuilder } from "w3id";
 import * as jose from "jose";
+import path from "path";
+import { fileURLToPath } from "url";
 
-dotenv.config();
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+dotenv.config({ path: path.resolve(__dirname, "../../../.env") });
 
 const app = express();
-const port = process.env.PORT || 3000;
+const port = process.env.PORT || 3001;
 
 app.use(express.json());
 
@@ -37,6 +41,8 @@ app.post(
         res: Response<ProvisionResponse>,
     ) => {
         try {
+
+            if (!process.env.REGISTRY_URI) throw new Error("REGISTRY_URI is not set");
             const { registryEntropy, namespace } = req.body;
 
             if (!registryEntropy || !namespace) {
@@ -67,10 +73,22 @@ app.post(
             const uri = await provisionEVault(w3id, evaultId.id);
 
 
+            await axios.post(new URL("/register", process.env.REGISTRY_URI).toString(), {
+                ename: w3id,
+                uri,
+                evault: evaultId.id,
+            }, {
+                headers: {
+                    "Authorization": `Bearer ${process.env.REGISTRY_SHARED_SECRET}`
+                }
+            });
+
             res.json({
                 success: true,
                 uri,
             });
+
+
         } catch (error) {
             const axiosError = error as AxiosError;
             res.status(500).json({

infrastructure/web3-adapter/src/__tests__/evault.test.ts

@@ -5,7 +5,7 @@ const EVaultEndpoint = "http://localhost:4000/graphql";
 
 async function queryGraphQL(
     query: string,
-    variables: Record<string, any> = {},
+    variables: Record<string, unknown> = {},
 ) {
     const response = await fetch(EVaultEndpoint, {
         method: "POST",

infrastructure/web3-adapter/src/adapter.ts

@@ -1,7 +1,7 @@
 export type FieldMapping = {
     sourceField: string;
     targetField: string;
-    transform?: (value: any) => any;
+    transform?: (value: unknown) => unknown;
 };
 
 export class Web3Adapter {
@@ -17,14 +17,14 @@ export class Web3Adapter {
 
     public toUniversal(
         platform: string,
-        data: Record<string, any>,
-    ): Record<string, any> {
+        data: Record<string, unknown>,
+    ): Record<string, unknown> {
         const mappings = this.mappings.get(platform);
         if (!mappings) {
             throw new Error(`No mappings found for platform: ${platform}`);
         }
 
-        const result: Record<string, any> = {};
+        const result: Record<string, unknown> = {};
         for (const mapping of mappings) {
             if (data[mapping.sourceField] !== undefined) {
                 const value = mapping.transform
@@ -38,14 +38,14 @@ export class Web3Adapter {
 
     public fromUniversal(
         platform: string,
-        data: Record<string, any>,
-    ): Record<string, any> {
+        data: Record<string, unknown>,
+    ): Record<string, unknown> {
         const mappings = this.mappings.get(platform);
         if (!mappings) {
             throw new Error(`No mappings found for platform: ${platform}`);
         }
 
-        const result: Record<string, any> = {};
+        const result: Record<string, unknown> = {};
         for (const mapping of mappings) {
             if (data[mapping.targetField] !== undefined) {
                 const value = mapping.transform

platforms/registry/src/config/database.ts

@@ -4,7 +4,7 @@ import * as dotenv from "dotenv"
 import { join } from "path"
 
 // Load environment variables from root .env file
-dotenv.config({ path: join(__dirname, "../../../.env") })
+dotenv.config({ path: join(__dirname, "../../../../.env") })
 
 export const AppDataSource = new DataSource({
     type: "postgres",

platforms/registry/src/index.ts

@@ -23,6 +23,40 @@ const initializeDatabase = async () => {
 // Initialize VaultService
 const vaultService = new VaultService(AppDataSource.getRepository("Vault"));
 
+// Middleware to check shared secret
+const checkSharedSecret = async (request: any, reply: any) => {
+    const authHeader = request.headers.authorization;
+    if (!authHeader || !authHeader.startsWith('Bearer ')) {
+        return reply.status(401).send({ error: 'Missing or invalid authorization header' });
+    }
+
+    const secret = authHeader.split(' ')[1];
+    if (secret !== process.env.REGISTRY_SHARED_SECRET) {
+        return reply.status(401).send({ error: 'Invalid shared secret' });
+    }
+};
+
+// Create a new vault entry
+server.post("/register", {
+    preHandler: checkSharedSecret
+}, async (request, reply) => {
+    try {
+        const { ename, uri, evault } = request.body as { ename: string; uri: string; evault: string };
+
+        if (!ename || !uri || !evault) {
+            return reply.status(400).send({ 
+                error: "Missing required fields. Please provide ename, uri, and evault" 
+            });
+        }
+
+        const vault = await vaultService.create(ename, uri, evault);
+        return reply.status(201).send(vault);
+    } catch (error) {
+        server.log.error(error);
+        reply.status(500).send({ error: "Failed to create vault entry" });
+    }
+});
+
 // Generate and return a signed JWT with entropy
 server.get("/entropy", async (request, reply) => {
   try {
@@ -53,16 +87,15 @@ server.get("/resolve", async (request, reply) => {
       return reply.status(400).send({ error: "w3id parameter is required" });
     }
 
-    const service = await vaultService.findByEname(w3id);
-    
-    if (!service) {
+    const vault = await vaultService.findByEname(w3id);
+    if (!vault) {
       return reply.status(404).send({ error: "Service not found" });
     }
 
     return {
-      ename: service.ename,
-      uri: service.uri,
-      evault: service.evault
+      ename: vault.ename,
+      uri: vault.uri,
+      evault: vault.evault
     };
   } catch (error) {
     server.log.error(error);

platforms/registry/src/migrations/1748865359304-migration.ts

@@ -0,0 +1,14 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class Migration1748865359304 implements MigrationInterface {
+    name = 'Migration1748865359304'
+
+    public async up(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.query(`CREATE TABLE "vault" ("id" SERIAL NOT NULL, "ename" character varying NOT NULL, "uri" character varying NOT NULL, "evault" character varying NOT NULL, CONSTRAINT "PK_dd0898234c77f9d97585171ac59" PRIMARY KEY ("id"))`);
+    }
+
+    public async down(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.query(`DROP TABLE "vault"`);
+    }
+
+}