chore: Support applicatives in createOmniGraphHardhatTransformer

LayerZero-Labs · Dec 13, 2023 · 64dd4e0 · 64dd4e0
1 parent 39c9673
commit 64dd4e0
Show file tree

Hide file tree

Showing 2 changed files with 46 additions and 16 deletions.
diff --git a/packages/utils-evm-hardhat/src/omnigraph/transformations.ts b/packages/utils-evm-hardhat/src/omnigraph/transformations.ts
@@ -9,6 +9,7 @@ import type {
     OmniNodeHardhat,
     OmniPointHardhatTransformer,
 } from './types'
+import { parallel } from '@layerzerolabs/utils'
 
 /**
  * Create a function capable of transforming `OmniPointHardhat` to a regular `OmniPoint`
@@ -56,9 +57,10 @@ export const createOmniEdgeHardhatTransformer =
 export const createOmniGraphHardhatTransformer =
     <TNodeConfig, TEdgeConfig>(
         nodeTransformer = createOmniNodeHardhatTransformer(),
-        edgeTransformer = createOmniEdgeHardhatTransformer()
+        edgeTransformer = createOmniEdgeHardhatTransformer(),
+        applicative = parallel
     ): OmniGraphHardhatTransformer<TNodeConfig, TEdgeConfig> =>
-    async (graph) => ({
-        contracts: await Promise.all(graph.contracts.map(nodeTransformer)),
-        connections: await Promise.all(graph.connections.map(edgeTransformer)),
+    async ({ contracts, connections }) => ({
+        contracts: await applicative(contracts.map((contract) => () => nodeTransformer(contract))),
+        connections: await applicative(connections.map((connection) => () => edgeTransformer(connection))),
     })
diff --git a/packages/utils-evm-hardhat/test/omnigraph/transformations.test.ts b/packages/utils-evm-hardhat/test/omnigraph/transformations.test.ts
@@ -8,7 +8,7 @@ import {
 } from '@/omnigraph/transformations'
 import { Contract } from '@ethersproject/contracts'
 import { endpointArbitrary, evmAddressArbitrary, nullableArbitrary, pointArbitrary } from '@layerzerolabs/test-utils'
-import { isOmniPoint } from '@layerzerolabs/utils'
+import { isOmniPoint, parallel, sequence } from '@layerzerolabs/utils'
 
 describe('omnigraph/transformations', () => {
     const pointHardhatArbitrary = fc.record({
@@ -17,6 +17,17 @@ describe('omnigraph/transformations', () => {
         address: nullableArbitrary(evmAddressArbitrary),
     })
 
+    const nodeHardhatArbitrary = fc.record({
+        contract: pointHardhatArbitrary,
+        config: fc.anything(),
+    })
+
+    const edgeHardhatArbitrary = fc.record({
+        from: pointHardhatArbitrary,
+        to: pointHardhatArbitrary,
+        config: fc.anything(),
+    })
+
     describe('createOmniPointHardhatTransformer', () => {
         it('should pass the original value if contract is already an OmniPoint', async () => {
             await fc.assert(
@@ -128,17 +139,6 @@ describe('omnigraph/transformations', () => {
         })
 
         it('should call the nodeTransformer and edgeTransformer for every node and edge and return the result', async () => {
-            const nodeHardhatArbitrary = fc.record({
-                contract: pointHardhatArbitrary,
-                config: fc.anything(),
-            })
-
-            const edgeHardhatArbitrary = fc.record({
-                from: pointHardhatArbitrary,
-                to: pointHardhatArbitrary,
-                config: fc.anything(),
-            })
-
             await fc.assert(
                 fc.asyncProperty(
                     fc.array(nodeHardhatArbitrary),
@@ -156,5 +156,33 @@ describe('omnigraph/transformations', () => {
                 )
             )
         })
+
+        it('should support sequential applicative', async () => {
+            await fc.assert(
+                fc.asyncProperty(
+                    fc.array(nodeHardhatArbitrary),
+                    fc.array(edgeHardhatArbitrary),
+                    async (contracts, connections) => {
+                        const nodeTransformer = jest.fn().mockImplementation(async (node) => ({ node }))
+                        const edgeTransformer = jest.fn().mockImplementation(async (edge) => ({ edge }))
+                        const transformerSequential = createOmniGraphHardhatTransformer(
+                            nodeTransformer,
+                            edgeTransformer,
+                            sequence
+                        )
+                        const transformerParallel = createOmniGraphHardhatTransformer(
+                            nodeTransformer,
+                            edgeTransformer,
+                            parallel
+                        )
+
+                        const graphSequential = await transformerSequential({ contracts, connections })
+                        const graphParallel = await transformerParallel({ contracts, connections })
+
+                        expect(graphSequential).toEqual(graphParallel)
+                    }
+                )
+            )
+        })
     })
 })