Allow web deploy and proxy of domain.

Update docs.

Author: rabbah

README.md

@@ -75,6 +75,7 @@ package = "netlify-plugin-nimbella"
 
 [plugins.inputs]
 path    = "/api"   # The prefix path to access your deployed packages.
+web     = false    # Deploy frontend and proxy domain to Nimbella (allowed values are true or false).
 env     = []       # Environment variables to export to serverless APIs.
 ```
 
@@ -105,6 +106,15 @@ site
 
 The APIs are `auth/login`, `auth/logout`, `todos/create`, and so on. An API may be a single file, or built from a set of files within an enclosing directory. You may mix languages, and deploy functions as source, without even building languages that require compilation. To API end point for any of the actions is constructed in the same way. For example the serverless API implemented by `auth/login/index.js` is invoked with the REST end point `https://your-site.com/api/auth/login`.
 
+Your Nimbella project may also include a `web` folder which can be deployed to the Nimbella cloud as well. The web folder represents the frontend assets for your projects (e.g., HTML, CSS, JavaScript). In a typical deployment of a Nimbella project using Netlify, you will use the Netlify CDN to serve your web assets. There are however some use-cases where you want to deploy the entire project to Nimbella, and proxy to your Nimbella domain from your Netlify site. To do this, you need to enable the deployment of the web portion of your project by setting an option `web = true` in the `plugins.inputs` section of your `netlify.toml` file.
+
+```toml
+[plugins.inputs]
+# Deploy the web folder and proxy your site entirely to your Nimbella deployment.
+web = true
+```
+
+
 ## Exporting Environment Variables to Serverless APIs
 
 If your serverless APIs require environment variables, you have to export the variables explicitly in the `plugins.input` section of the `netlify.toml` file. This is to avoid exporting the entire environment to your APIs, and instead selecting exporting only the variables the actions need access to.

src/index.js

@@ -5,6 +5,7 @@ const {homedir} = require('os')
 
 const nimConfig = join(homedir(), '.nimbella')
 let isProject = false
+let deployWeb = false
 
 // Disable auto updates of nim.
 process.env.NIM_DISABLE_AUTOUPDATE = '1'
@@ -21,35 +22,48 @@ async function getApiHost(run) {
 /**
  * Deploy a Nimbella Project.
  * @param {*} run - function provided under utils by Netlify to build event functions.
+ * @param {bool} includeWeb - flag to include/exclude web assets from project deploy
  */
-async function deployProject(run) {
-  await run.command(`nim project deploy . --exclude=web`)
+async function deployProject(run, includeWeb) {
+  if (includeWeb) {
+    await run.command(`nim project deploy .`) // Do not exclude web folder
+  } else {
+    await run.command(`nim project deploy . --exclude=web`)
+  }
 }
 
 // Creates or updates the _redirects file; this file takes precedence
 // over other redirect declarations, and is processed from top to bottom
 //
 // If there is an API path directive input.path in the plugin settings, add a
 // matching rule to the _redirects file. The target is the Nimbella namespace/:splat.
+//
+// If deploying the web assets as well, then proxy the entire domain instead.
 async function processRedirects(run, inputs) {
   const redirectRules = []
   const {stdout: namespace} = await run.command(`nim auth current`)
   const apihost = await getApiHost(run)
 
-  let {path: redirectPath} = inputs
-  redirectPath = redirectPath.endsWith('/') ? redirectPath : redirectPath + '/'
-  if (redirectPath) {
-    redirectRules.push(
-      `${redirectPath}* https://${apihost}/api/v1/web/${namespace}/:splat 200!`
-    )
+  if (deployWeb) {
+    redirectRules.push(`/* https://${namespace}-${apihost}/:splat 200!`)
+  } else {
+    let {path: redirectPath} = inputs
+    redirectPath = redirectPath.endsWith('/')
+      ? redirectPath
+      : redirectPath + '/'
+    if (redirectPath) {
+      redirectRules.push(
+        `${redirectPath}* https://${apihost}/api/v1/web/${namespace}/:splat 200!`
+      )
+    }
   }
 
   return redirectRules
 }
 
 module.exports = {
   // Execute before build starts.
-  onPreBuild: async ({utils}) => {
+  onPreBuild: async ({utils, inputs}) => {
     if (
       !process.env.NIMBELLA_LOGIN_TOKEN &&
       !(await utils.cache.has(nimConfig))
@@ -100,7 +114,14 @@ module.exports = {
       }
     }
 
-    isProject = existsSync('packages')
+    deployWeb = false
+    if (typeof inputs.web === 'boolean') {
+      deployWeb = inputs.web
+    } else if (typeof inputs.web === 'string') {
+      deployWeb = inputs.web.toLowerCase() === 'true'
+    }
+
+    isProject = existsSync('packages') || (deployWeb && existsSync('web'))
   },
   // Build and deploy the Nimbella project
   onBuild: async ({utils, inputs}) => {
@@ -117,7 +138,7 @@ module.exports = {
         }
 
         try {
-          await deployProject(utils.run)
+          await deployProject(utils.run, deployWeb)
         } catch (error) {
           utils.build.failBuild('Failed to build and deploy the project', {
             error

test/index.js

@@ -230,6 +230,54 @@ describe('onBuild()', () => {
       `nim project deploy . --exclude=web`
     )
   })
+
+  test("should run nim project deploy excluding 'web' if inputs.web is not set", async () => {
+    process.env.NIMBELLA_LOGIN_TOKEN = 'somevalue'
+    process.env.CONTEXT = 'production'
+
+    const pluginInputs = {
+      utils,
+      constants: {CONFIG_PATH: './netlify.toml', PUBLISH_DIR: ''},
+      inputs: {
+        path: ''
+      }
+    }
+
+    mockFs({
+      packages: {},
+      web: {}
+    })
+    await plugin.onPreBuild(pluginInputs)
+    await plugin.onBuild(pluginInputs)
+    mockFs.restore()
+
+    expect(utils.run.command.mock.calls[1][0]).toEqual(
+      `nim project deploy . --exclude=web`
+    )
+  })
+
+  test("should run nim project deploy if 'web' directory exists and inputs.web is set", async () => {
+    process.env.NIMBELLA_LOGIN_TOKEN = 'somevalue'
+    process.env.CONTEXT = 'production'
+
+    const pluginInputs = {
+      utils,
+      constants: {CONFIG_PATH: './netlify.toml', PUBLISH_DIR: ''},
+      inputs: {
+        path: '',
+        web: 'true'
+      }
+    }
+
+    mockFs({
+      web: {}
+    })
+    await plugin.onPreBuild(pluginInputs)
+    await plugin.onBuild(pluginInputs)
+    mockFs.restore()
+
+    expect(utils.run.command.mock.calls[1][0]).toEqual(`nim project deploy .`)
+  })
 })
 
 describe('onPostBuild()', () => {
@@ -334,4 +382,58 @@ describe('onPostBuild()', () => {
     expect(redirects[1]).toEqual('/mypath https://example.com') // Original rewrites come last
     expect(redirects[2]).toEqual('/fn2 /.netlify/functions/fn2 200') // Original rewrites come last
   })
+
+  test('should proxy entire domain if deploying web assets', async () => {
+    process.env.NIMBELLA_LOGIN_TOKEN = 'somevalue'
+    process.env.CONTEXT = 'production'
+
+    utils.run.command = jest.fn((cmd) => {
+      if (cmd === 'nim auth current') return {stdout: 'namespace'}
+      if (cmd === 'nim auth current --apihost') return {stdout: 'somehost'}
+      return {stdout: '???'}
+    })
+
+    const pluginInputs = {
+      utils,
+      constants: {CONFIG_PATH: 'netlify.toml', PUBLISH_DIR: ''},
+      inputs: {
+        path: '/api',
+        web: 'true'
+      }
+    }
+
+    mockFs({
+      packages: {},
+      web: {},
+      'netlify.toml': `
+        [[redirects]]
+        from = "/home"
+        to = "/index.html"
+        status = 200
+
+        [[redirects]]
+        from = "/somefn"
+        to = "/.netlify/functions/fn"
+        status = 200
+      `,
+      'some-dir': {
+        'create.js': '',
+        'update.js': ''
+      },
+      _redirects: [
+        '/mypath https://example.com',
+        '/fn2 /.netlify/functions/fn2 200'
+      ].join('\n')
+    })
+
+    await plugin.onPreBuild(pluginInputs)
+    await plugin.onPostBuild(pluginInputs)
+    const redirects = String(fs.readFileSync('_redirects')).trim().split('\n')
+    mockFs.restore()
+
+    expect(redirects.length).toEqual(3)
+    expect(redirects[0]).toEqual('/* https://namespace-somehost/:splat 200!') // And input directive
+    expect(redirects[1]).toEqual('/mypath https://example.com') // Original rewrites come last
+    expect(redirects[2]).toEqual('/fn2 /.netlify/functions/fn2 200') // Original rewrites come last
+  })
 })