Start removing ow validation

Author: lnbc1QWFyb24

package.json

@@ -29,7 +29,6 @@
     "bignumber.js": "^9.0.0",
     "bnc-sdk": "0.1.1",
     "bowser": "^2.5.2",
-    "ow": "^0.13.2",
     "promise-cancelable": "^2.1.1",
     "regenerator-runtime": "^0.13.3",
     "svelte": "^3.0.0",

rollup.config.js

@@ -39,7 +39,6 @@ export default [
     external: [
       "bowser",
       "bnc-sdk",
-      "ow",
       "bignumber.js",
       "svelte-i18n",
       "svelte",

src/index.js

@@ -15,14 +15,13 @@ import {
   walletInterface
 } from "./stores"
 
-import { validateInit, validateConfig } from "./validation"
 import { isMobileDevice } from "./utilities"
 import { initializeBlocknative } from "./services"
 
 import { version } from "../package.json"
 
 function init(initialization) {
-  validateInit(initialization)
+  // validateInit(initialization)
 
   const { subscriptions, dappId, networkId, modules } = initialization
 
@@ -107,7 +106,7 @@ function init(initialization) {
   }
 
   function config(options) {
-    validateConfig(options)
+    // validateConfig(options)
     app.update(store => ({ ...store, ...options }))
   }
 

src/stores.js

@@ -1,6 +1,5 @@
 import { writable, derived } from "svelte/store"
 import Cancelable from "promise-cancelable"
-import { validateWalletInterface } from "./validation"
 import { getBlocknative } from "./services"
 import { wait, makeQuerablePromise } from "./utilities"
 
@@ -75,7 +74,7 @@ function createWalletInterfaceStore(initialState) {
     subscribe,
     update,
     set: walletInterface => {
-      validateWalletInterface(walletInterface)
+      // validateWalletInterface(walletInterface)
       set(walletInterface)
     }
   }

src/validation.js

@@ -1,53 +1,204 @@
-import ow from "ow"
-
 export function validateInit(init) {
-  ow(
-    init,
-    "Initialization Options",
-    ow.object.exactShape({
-      networkId: ow.number,
-      dappId: ow.string,
-      subscriptions: ow.optional.object.exactShape({
-        address: ow.optional.function,
-        network: ow.optional.function,
-        balance: ow.optional.function,
-        wallet: ow.optional.function
-      }),
-      modules: ow.object.exactShape({
-        walletSelect: ow.object.exactShape({
-          heading: ow.string,
-          description: ow.string,
-          wallets: ow.object.exactShape({
-            mobile: ow.optional.array.nonEmpty.ofType(
-              ow.object.exactShape({
-                name: ow.string,
-                iconSrc: ow.optional.string,
-                iconSrcSet: ow.optional.string,
-                svg: ow.optional.string,
-                wallet: ow.function,
-                link: ow.optional.string,
-                installMessage: ow.optional.function,
-                preferred: ow.optional.boolean
-              })
-            ),
-            desktop: ow.optional.array.nonEmpty.ofType(
-              ow.object.exactShape({
-                name: ow.string,
-                iconSrc: ow.optional.string,
-                iconSrcSet: ow.optional.string,
-                svg: ow.optional.string,
-                wallet: ow.function,
-                link: ow.optional.string,
-                installMessage: ow.optional.function,
-                preferred: ow.optional.boolean
-              })
-            )
-          })
-        }),
-        walletReady: ow.array.nonEmpty.ofType(ow.function)
-      })
+  if (!init || typeof init !== "object") {
+    throw new Error(
+      `"onboard" must be called with an initialization object, received: ${init}`
+    )
+  }
+
+  const { networkId, dappId, subscriptions, modules } = init
+
+  if (!dappId || typeof dappId !== "string") {
+    throw new Error(`"dappId" must be of type string, received: ${dappId}`)
+  }
+
+  if (!networkId || typeof networkId !== "number") {
+    throw new Error(
+      `"networkId" must be of type number, received: ${networkId}`
+    )
+  }
+
+  validateSubscriptions(subscriptions)
+  validateModules(modules)
+}
+
+function validateSubscriptions(subscriptions) {
+  if (subscriptions) {
+    if (typeof subscriptions !== "object") {
+      throw new Error(
+        `"subscriptions" must be of type object, received: ${subscriptions}`
+      )
+    }
+
+    Object.keys(subscriptions).forEach(key => {
+      if (!validSubscriptionKey(subscriptions[key])) {
+        throw new Error(
+          `${key} is not a valid subscription listener, received: ${key}`
+        )
+      }
+
+      if (subscriptions[key] !== "function") {
+        throw new Error(
+          `subscription listener must be a function, received: ${subscriptions[key]}`
+        )
+      }
     })
-  )
+  }
+}
+
+function validateModules(modules) {
+  if (!modules || typeof modules !== "object") {
+    throw new Error(
+      `"onboard" must be called with a modules object, received: ${modules}`
+    )
+  }
+
+  const { walletSelect, walletReady } = modules
+
+  validateWalletSelect(walletSelect)
+  validateWalletReady(walletReady)
+}
+
+function validateWalletSelect(walletSelect) {
+  if (!walletSelect || typeof walletSelect !== "object") {
+    throw new Error(
+      `"modules" must have a "walletSelect" object, received: ${walletSelect}`
+    )
+  }
+
+  const { heading, description, wallets } = walletSelect
+
+  if (!heading || typeof heading !== "string") {
+    throw new Error(
+      `"walletSelect" requires a "heading" parameter of type string, received: ${heading}`
+    )
+  }
+
+  if (!description || typeof description !== "string") {
+    throw new Error(
+      `"walletSelect" requires a "description" parameter of type string, received: ${description}`
+    )
+  }
+
+  if (!wallets || typeof wallets !== "object") {
+    throw new Error(
+      `"walletSelect" must have a "wallets" object, received: ${wallets}`
+    )
+  }
+
+  const { mobile, desktop } = wallets
+
+  if (mobile) {
+    if (!Array.isArray(mobile) || mobile.length < 1) {
+      throw new Error(
+        `"mobile" must be an array of at least one wallet object, received: ${mobile}`
+      )
+    }
+
+    mobile.forEach(module => {
+      validateWalletModule(module)
+    })
+  }
+
+  if (desktop) {
+    if (!Array.isArray(desktop) || desktop.length < 1) {
+      throw new Error(
+        `"desktop" must be an array of at least one wallet object, received: ${desktop}`
+      )
+    }
+
+    desktop.forEach(module => {
+      validateWalletModule(module)
+    })
+  }
+}
+
+function validateWalletModule(module) {
+  const {
+    name,
+    iconSrc,
+    iconSrcSet,
+    svg,
+    wallet,
+    link,
+    installMessage,
+    preferred
+  } = module
+
+  if (!name || typeof name !== "string") {
+    throw new Error(
+      `wallet module must have a name property of type string, received: ${name}`
+    )
+  }
+
+  if (!wallet || typeof wallet !== "string") {
+    throw new Error(
+      `wallet module must have a "wallet" property of type string, received: ${wallet}`
+    )
+  }
+
+  if (iconSrc && typeof iconSrc !== "string") {
+    throw new Error(`"iconSrc" must be of type string, received: ${iconSrc}`)
+  }
+
+  if (iconSrcSet && typeof iconSrcSet !== "string") {
+    throw new Error(
+      `"iconSrcSet" must be of type string, received: ${iconSrcSet}`
+    )
+  }
+
+  if (svg && typeof svg !== "string") {
+    throw new Error(`"svg" must be of type string, received: ${svg}`)
+  }
+
+  if (link && typeof link !== "string") {
+    throw new Error(`"link" must be of type string, received: ${link}`)
+  }
+
+  if (installMessage && typeof installMessage !== "function") {
+    throw new Error(
+      `"installMessage" must be of type function, received: ${installMessage}`
+    )
+  }
+
+  if (preferred && typeof preferred !== "boolean") {
+    throw new Error(
+      `"preferred" must be of type boolean, received: ${preferred}`
+    )
+  }
+}
+
+function validateWalletReady(walletReady) {
+  if (!walletReady || typeof walletReady !== "object") {
+    throw new Error(
+      `"modules" must have a "walletReady" object, received: ${walletReady}`
+    )
+  }
+
+  if (!Array.isArray(walletReady) || walletReady.length < 1) {
+    throw new Error(
+      `"walletReady" must be an array of at least one readiness object, received: ${walletReady}`
+    )
+  }
+
+  walletReady.forEach(module => {
+    if (typeof module !== "function") {
+      throw new Error(
+        `"walletReady" module must be of type function, received: ${module}`
+      )
+    }
+  })
+}
+
+function validSubscriptionKey(key) {
+  switch (key) {
+    case "address":
+    case "network":
+    case "balance":
+    case "wallet":
+      return true
+    default:
+      return false
+  }
 }
 
 export function validateConfig(configuration) {