feat: synchronization works perfectly

Author: coodos

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

@@ -170,11 +170,22 @@ export class GraphQLServer {
                             schemaId: input.ontology,
                         };
 
-                        // Fire and forget webhook delivery
-                        this.deliverWebhooks(
-                            requestingPlatform,
-                            webhookPayload
-                        );
+                        /**
+                         * To whoever who reads this in the future please don't
+                         * remove this delay as this prevents a VERY horrible
+                         * disgusting edge case, where if a platform's URL is
+                         * not determinable the webhook to the same platform as
+                         * the one who sent off the request gets sent and that
+                         * is not an ideal case trust me I've suffered, it
+                         * causes an absolutely beautiful error where you get
+                         * stuck in what I like to call webhook ping-pong
+                         */
+                        setTimeout(() => {
+                            this.deliverWebhooks(
+                                requestingPlatform,
+                                webhookPayload
+                            );
+                        }, 3_000);
 
                         return result;
                     }

infrastructure/evault-core/src/protocol/vault-access-guard.ts

@@ -60,7 +60,9 @@ export class VaultAccessGuard {
         context: VaultContext
     ): Promise<boolean> {
         // Validate token if present
-        const authHeader = context.request?.headers?.get("authorization");
+        const authHeader =
+            context.request?.headers?.get("authorization") ??
+            context.request?.headers?.get("Authorization");
         const tokenPayload = await this.validateToken(authHeader);
 
         if (tokenPayload) {

infrastructure/web3-adapter/src/db/mapping.db.ts

@@ -27,89 +27,76 @@ export class MappingDatabase {
             CREATE TABLE IF NOT EXISTS id_mappings (
                 local_id TEXT NOT NULL,
                 global_id TEXT NOT NULL,
-                table_name TEXT NOT NULL,
                 created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                PRIMARY KEY (local_id, table_name),
-                UNIQUE (global_id, table_name)
+                PRIMARY KEY (global_id)
             )
         `);
 
         await this.runAsync(`
-            CREATE INDEX IF NOT EXISTS idx_global_id ON id_mappings(global_id)
-        `);
-
-        await this.runAsync(`
-            CREATE INDEX IF NOT EXISTS idx_table_name ON id_mappings(table_name)
+            CREATE INDEX IF NOT EXISTS idx_local_id ON id_mappings(local_id)
         `);
     }
 
     /**
-     * Store a mapping between local and global IDs (UPSERT)
+     * Store a mapping between local and global IDs
      */
     public async storeMapping(params: {
         localId: string;
         globalId: string;
-        tableName: string;
     }): Promise<void> {
         // Validate inputs
-        if (!params.localId || !params.globalId || !params.tableName) {
+        if (!params.localId || !params.globalId) {
             throw new Error(
-                "Invalid mapping parameters: all fields are required",
+                "Invalid mapping parameters: all fields are required"
             );
         }
 
+        console.log("storing mapping g:l", params.globalId, params.localId);
+
+        // Check if mapping already exists
+        const existingMapping = await this.getGlobalId(params.localId);
+
+        if (existingMapping) {
+            return;
+        }
+
         try {
-            // Use UPSERT to handle both insert and update cases
             await this.runAsync(
-                `INSERT OR REPLACE INTO id_mappings (local_id, global_id, table_name, updated_at)
-                VALUES (?, ?, ?, CURRENT_TIMESTAMP)`,
-                [params.localId, params.globalId, params.tableName],
+                `INSERT INTO id_mappings (local_id, global_id)
+                VALUES (?, ?)`,
+                [params.localId, params.globalId]
             );
 
-            // Verify the mapping was stored correctly
-            const storedMapping = await this.getGlobalId({
-                localId: params.localId,
-                tableName: params.tableName,
-            });
+            const storedMapping = await this.getGlobalId(params.localId);
 
             if (storedMapping !== params.globalId) {
-                console.error("Mapping verification failed:", {
-                    expected: params.globalId,
-                    actual: storedMapping,
-                    params
-                });
-                throw new Error("Failed to store mapping - verification failed");
+                console.log(
+                    "storedMappingError",
+                    storedMapping,
+                    params.globalId
+                );
+                console.error("Failed to store mapping");
+                return;
             }
-
-            console.log("Successfully stored mapping:", {
-                localId: params.localId,
-                globalId: params.globalId,
-                tableName: params.tableName
-            });
         } catch (error) {
-            console.error("Error storing mapping:", error, params);
             throw error;
         }
     }
 
     /**
      * Get the global ID for a local ID
      */
-    public async getGlobalId(params: {
-        localId: string;
-        tableName: string;
-    }): Promise<string | null> {
-        if (!params.localId || !params.tableName) {
+    public async getGlobalId(localId: string): Promise<string | null> {
+        if (!localId) {
             return null;
         }
 
         try {
             const result = await this.getAsync(
                 `SELECT global_id
                 FROM id_mappings
-                WHERE local_id = ? AND table_name = ?`,
-                [params.localId, params.tableName],
+                WHERE local_id = ?`,
+                [localId]
             );
             return result?.global_id ?? null;
         } catch (error) {
@@ -121,20 +108,17 @@ export class MappingDatabase {
     /**
      * Get the local ID for a global ID
      */
-    public async getLocalId(params: {
-        globalId: string;
-        tableName: string;
-    }): Promise<string | null> {
-        if (!params.globalId || !params.tableName) {
+    public async getLocalId(globalId: string): Promise<string | null> {
+        if (!globalId) {
             return null;
         }
 
         try {
             const result = await this.getAsync(
                 `SELECT local_id
                 FROM id_mappings
-                WHERE global_id = ? AND table_name = ?`,
-                [params.globalId, params.tableName],
+                WHERE global_id = ?`,
+                [globalId]
             );
             return result?.local_id ?? null;
         } catch (error) {
@@ -145,44 +129,35 @@ export class MappingDatabase {
     /**
      * Delete a mapping
      */
-    public async deleteMapping(params: {
-        localId: string;
-        tableName: string;
-    }): Promise<void> {
-        if (!params.localId || !params.tableName) {
+    public async deleteMapping(localId: string): Promise<void> {
+        if (!localId) {
             return;
         }
 
         try {
             await this.runAsync(
                 `DELETE FROM id_mappings
-                WHERE local_id = ? AND table_name = ?`,
-                [params.localId, params.tableName],
+                WHERE local_id = ?`,
+                [localId]
             );
         } catch (error) {
             throw error;
         }
     }
 
     /**
-     * Get all mappings for a table
+     * Get all mappings
      */
-    public async getTableMappings(tableName: string): Promise<
+    public async getAllMappings(): Promise<
         Array<{
             localId: string;
             globalId: string;
         }>
     > {
-        if (!tableName) {
-            return [];
-        }
-
         try {
             const results = await this.allAsync(
                 `SELECT local_id, global_id
-                FROM id_mappings
-                WHERE table_name = ?`,
-                [tableName],
+                FROM id_mappings`
             );
 
             return results.map(({ local_id, global_id }) => ({
@@ -194,83 +169,6 @@ export class MappingDatabase {
         }
     }
 
-    /**
-     * Debug method to get all mappings
-     */
-    public async getAllMappings(): Promise<Array<{
-        localId: string;
-        globalId: string;
-        tableName: string;
-        createdAt: string;
-        updatedAt: string;
-    }>> {
-        try {
-            const results = await this.allAsync(
-                `SELECT local_id, global_id, table_name, created_at, updated_at
-                FROM id_mappings
-                ORDER BY table_name, local_id`
-            );
-
-            return results.map(({ local_id, global_id, table_name, created_at, updated_at }) => ({
-                localId: local_id,
-                globalId: global_id,
-                tableName: table_name,
-                createdAt: created_at,
-                updatedAt: updated_at,
-            }));
-        } catch (error) {
-            console.error("Error getting all mappings:", error);
-            return [];
-        }
-    }
-
-    /**
-     * Debug method to check if a mapping exists
-     */
-    public async debugMapping(params: {
-        localId?: string;
-        globalId?: string;
-        tableName: string;
-    }): Promise<{
-        exists: boolean;
-        mapping?: any;
-        allMappingsForTable: Array<{ localId: string; globalId: string }>;
-    }> {
-        const { localId, globalId, tableName } = params;
-        
-        try {
-            let mapping = null;
-            
-            if (localId) {
-                const globalIdResult = await this.getGlobalId({ localId, tableName });
-                if (globalIdResult) {
-                    mapping = { localId, globalId: globalIdResult, tableName };
-                }
-            }
-            
-            if (globalId && !mapping) {
-                const localIdResult = await this.getLocalId({ globalId, tableName });
-                if (localIdResult) {
-                    mapping = { localId: localIdResult, globalId, tableName };
-                }
-            }
-            
-            const allMappingsForTable = await this.getTableMappings(tableName);
-            
-            return {
-                exists: !!mapping,
-                mapping,
-                allMappingsForTable,
-            };
-        } catch (error) {
-            console.error("Error debugging mapping:", error);
-            return {
-                exists: false,
-                allMappingsForTable: [],
-            };
-        }
-    }
-
     /**
      * Close the database connection
      */

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

@@ -112,7 +112,10 @@ export class EVaultClient {
     private async requestPlatformToken(): Promise<string> {
         try {
             const response = await axios.post<PlatformTokenResponse>(
-                new URL("/platforms/certification", this.registryUrl).toString(),
+                new URL(
+                    "/platforms/certification",
+                    this.registryUrl
+                ).toString(),
                 { platform: this.platform },
                 {
                     headers: {
@@ -141,7 +144,7 @@ export class EVaultClient {
     private async resolveEndpoint(w3id: string): Promise<string> {
         try {
             const response = await axios.get(
-                new URL(`/resolve?w3id=${w3id}`, this.registryUrl).toString(),
+                new URL(`/resolve?w3id=${w3id}`, this.registryUrl).toString()
             );
             return new URL("/graphql", response.data.uri).toString();
         } catch (error) {
@@ -154,7 +157,7 @@ export class EVaultClient {
         if (!this.endpoint || !this.client) {
             this.endpoint = await this.resolveEndpoint(w3id).catch(() => null);
             if (!this.endpoint) throw new Error();
-            
+
             // Get platform token and create client with authorization header
             const token = await this.ensurePlatformToken();
             this.client = new GraphQLClient(this.endpoint, {
@@ -171,7 +174,8 @@ export class EVaultClient {
             return null;
         });
         if (!client) return v4();
-        
+        console.log("sending payload", envelope);
+
         const response = await client
             .request<StoreMetaEnvelopeResponse>(STORE_META_ENVELOPE, {
                 input: {
@@ -211,7 +215,7 @@ export class EVaultClient {
                 {
                     id,
                     w3id,
-                },
+                }
             );
             return response.metaEnvelope;
         } catch (error) {
@@ -222,11 +226,12 @@ export class EVaultClient {
 
     async updateMetaEnvelopeById(
         id: string,
-        envelope: MetaEnvelope,
+        envelope: MetaEnvelope
     ): Promise<void> {
+        console.log("sending to eVault", envelope.w3id);
         const client = await this.ensureClient(envelope.w3id).catch(() => null);
         if (!client) throw new Error();
-        
+
         try {
             const variables = {
                 id,
@@ -236,10 +241,10 @@ export class EVaultClient {
                     acl: ["*"],
                 },
             };
-        
+
             const response = await client.request<StoreMetaEnvelopeResponse>(
                 UPDATE_META_ENVELOPE,
-                variables,
+                variables
             );
         } catch (error) {
             console.error("Error updating meta envelope:", error);