feat(packages/sui-pde): add getDecision function

packages/sui-pde/README.md

@@ -99,6 +99,17 @@ const MyComponent = () => {
 }
 ```
 
+And the function to call elsewhere, like getInitialProps:
+
+```js
+import {getDecision} from '@s-ui/pde'
+
+Page.getInitialProps = async ({context}) => {
+  const {decide} = getDecision(pde)
+  const {enabled} = decide('ff_web_my_flag')
+}
+```
+
 #### Attributes
 
 You can pass additional attributes to refine your decision logic:

packages/sui-pde/src/getDecision.js

@@ -0,0 +1,59 @@
+import {getPlatformStrategy} from './hooks/common/platformStrategies.js'
+
+/**
+ * Function to call decide
+ * @param {object} pde
+ * @return {function}
+ */
+export default function getDecision(pde) {
+  if (!pde) {
+    throw new Error('[sui-pde: useDecision] sui-pde provider is required to work')
+  }
+
+  const decide = (name, {attributes, trackExperimentViewed, isEventDisabled, queryString, adapterId} = {}) => {
+    try {
+      const strategy = getPlatformStrategy({
+        customTrackExperimentViewed: trackExperimentViewed
+      })
+
+      const forced = strategy.getForcedValue({
+        key: name,
+        queryString
+      })
+
+      if (forced) {
+        if (['on', 'off'].includes(forced)) {
+          return {enabled: forced === 'on', flagKey: name}
+        }
+
+        return {enabled: true, flagKey: name, variationKey: forced}
+      }
+
+      const notificationId = pde.addDecideListener({
+        onDecide: ({type, decisionInfo: decision}) => {
+          const {ruleKey, variationKey, decisionEventDispatched} = decision
+
+          if (type === 'flag' && decisionEventDispatched) {
+            strategy.trackExperiment({variationName: variationKey, experimentName: ruleKey})
+          }
+        }
+      })
+
+      const data = strategy.decide({
+        pde,
+        name,
+        attributes,
+        adapterId,
+        isEventDisabled
+      })
+
+      pde.removeNotificationListener({notificationId})
+
+      return data
+    } catch (error) {
+      return {enabled: false, flagKey: name}
+    }
+  }
+
+  return {decide}
+}

packages/sui-pde/src/hooks/useDecisionCallback.js

@@ -1,7 +1,7 @@
 import {useCallback, useContext} from 'react'
 
 import PdeContext from '../contexts/PdeContext.js'
-import {getPlatformStrategy} from './common/platformStrategies.js'
+import getDecision from '../getDecision.js'
 
 /**
  * Hook to call decide
@@ -10,57 +10,7 @@ import {getPlatformStrategy} from './common/platformStrategies.js'
 export default function useDecisionCallback() {
   const {pde} = useContext(PdeContext)
 
-  if (pde === null) {
-    throw new Error('[sui-pde: useDecision] sui-pde provider is required to work')
-  }
+  const getDecisionCallback = useCallback(getDecision, [])
 
-  const decide = useCallback(
-    (name, {attributes, trackExperimentViewed, isEventDisabled, queryString, adapterId} = {}) => {
-      try {
-        const strategy = getPlatformStrategy({
-          customTrackExperimentViewed: trackExperimentViewed
-        })
-
-        const forced = strategy.getForcedValue({
-          key: name,
-          queryString
-        })
-
-        if (forced) {
-          if (['on', 'off'].includes(forced)) {
-            return {enabled: forced === 'on', flagKey: name}
-          }
-
-          return {enabled: true, flagKey: name, variationKey: forced}
-        }
-
-        const notificationId = pde.addDecideListener({
-          onDecide: ({type, decisionInfo: decision}) => {
-            const {ruleKey, variationKey, decisionEventDispatched} = decision
-
-            if (type === 'flag' && decisionEventDispatched) {
-              strategy.trackExperiment({variationName: variationKey, experimentName: ruleKey})
-            }
-          }
-        })
-
-        const data = strategy.decide({
-          pde,
-          name,
-          attributes,
-          adapterId,
-          isEventDisabled
-        })
-
-        pde.removeNotificationListener({notificationId})
-
-        return data
-      } catch (error) {
-        return {enabled: false, flagKey: name}
-      }
-    },
-    []
-  )
-
-  return {decide}
+  return getDecisionCallback(pde)
 }

packages/sui-pde/src/index.js

@@ -1,4 +1,5 @@
 export {default as PDE} from './pde.js'
+export {default as getDecision} from './getDecision.js'
 export {default as useFeature} from './hooks/useFeature.js'
 export {default as PdeContext} from './contexts/PdeContext.js'
 export {default as useExperiment} from './hooks/useExperiment.js'

packages/sui-pde/test/common/getDecisionSpec.js

@@ -0,0 +1,54 @@
+/* eslint-disable no-console */
+import {expect} from 'chai'
+import sinon from 'sinon'
+
+import {descriptorsByEnvironmentPatcher} from '@s-ui/test/lib/descriptor-environment-patcher.js'
+
+import {SESSION_STORAGE_KEY as PDE_CACHE_STORAGE_KEY} from '../../src/hooks/common/trackedEventsLocalCache.js'
+import getDecision from '../../src/getDecision.js'
+
+descriptorsByEnvironmentPatcher()
+
+describe('getDecision function', () => {
+  afterEach(() => {
+    if (typeof window === 'undefined') return
+    window.sessionStorage.removeItem(PDE_CACHE_STORAGE_KEY)
+  })
+
+  describe('when no pde context is set', () => {
+    it('should throw an error', () => {
+      try {
+        getDecision()
+      } catch (error) {
+        expect(error).to.be.instanceOf(Error)
+      }
+    })
+  })
+
+  describe('when pde context is set', () => {
+    let decide, pde
+    const decision = {
+      variationKey: 'variation',
+      enabled: true,
+      variables: {},
+      ruleKey: 'rule',
+      flagKey: 'flag',
+      userContext: {},
+      reasons: []
+    }
+
+    before(() => {
+      const addDecideListener = ({onDecide}) =>
+        onDecide({type: 'flag', decisionInfo: {...decision, decisionEventDispatched: true}})
+      const removeNotificationListener = sinon.stub()
+
+      decide = () => decision
+      pde = {decide, addDecideListener, removeNotificationListener}
+    })
+
+    it('should return a decision', () => {
+      const {decide} = getDecision(pde)
+      expect(decide('flag')).to.deep.equal(decision)
+    })
+  })
+})