@foxtware/mineral 0.1.2 → 0.1.4

package/.hosting.yml.sample

@@ -4,19 +4,23 @@ google_cloud_info:
 
 # TODO: consider credsPayload in google_cloud_info instead of workspace .creds.yml
 
+env:
+  - HOSTED_API_KEY
+
 functions:
   exampleFunction:
     max_instances: 1
     timeout: 300s
     wrappers:
-      - requireHostedApiKey
+      - '@foxtware/mineral/server.utils#requireHostedApiKey'
+      - '@foxtware/mineral/server.utils#allowCrossOriginCallsAndHandleOptions'
     # entry_point: otherExportName
 
   packagedFunction:
     source: '@foxtware/mineral/api/pokemon/pokemonPokeballThrow.js'
     max_instances: 1
     wrappers:
-      - checkTrainer
+      - '@foxtware/mineral/server.utils#checkTrainer'
 
 groups:
   example_group:

package/_deploy_scripts/deployFromHostingYml.js

@@ -2,7 +2,13 @@ const readline = require('readline');
 const { toAbsolutePath, setWorkspace } = require('../api/workspace');
 const { getApiDirs, readCliFlag } = require('../cli');
 const { loadHandlers } = require('../server');
-const { readHostingYml, getCredsJsonForDeploy, getHostedApiKeyForDeploy, resolveHostedHandlersForDeploy, functionUsesWrapper } = require('../hosting.utils');
+const {
+  readHostingYml,
+  getCredsJsonForDeploy,
+  validateEnvVarsForDeploy,
+  resolveHostedHandlersForDeploy,
+  functionUsesWrapper,
+} = require('../hosting.utils');
 const { writeHostedJs } = require('./generateHosted');
 const { execCommand } = require('./execCommand');
 const { formatSetEnvVarsForGcloud, shellQuoteSingle } = require('./setEnvVarsGcloud');
@@ -44,10 +50,6 @@ const chooseOption = async (prompt, options) => new Promise((resolve) => {
   });
 });
 
-const anyHostedEntryUsesWrapper = (hostedEntries, wrapperName) => (
-  hostedEntries.some((hostedEntry) => hostedEntry.wrappers?.includes(wrapperName))
-);
-
 const getDeployArgs = () => {
   const args = process.argv.slice(2);
   const deployArgs = [];
@@ -55,6 +57,10 @@ const getDeployArgs = () => {
   for (let index = 0; index < args.length; index++) {
     const arg = args[index];
 
+    if (arg === 'host') {
+      continue;
+    }
+
     if (arg === '--workspace' || arg === '--api_dirs') {
       index++;
       continue;
@@ -86,7 +92,7 @@ const deployFunction = async ({
   googleCloudInfo,
   workspace,
   credsJson,
-  hostedApiKey,
+  deployEnvVars = {},
 }) => {
   const config = {
     ...googleCloudInfo,
@@ -113,12 +119,9 @@ const deployFunction = async ({
   const envParts = [
     'HOSTED=true',
     `CREDS=${ credsJson }`,
+    ...Object.entries(deployEnvVars).map(([envName, envValue]) => `${ envName }=${ envValue }`),
   ];
 
-  if (hostedApiKey) {
-    envParts.push(`HOSTED_API_KEY=${ hostedApiKey }`);
-  }
-
   if (extraSetEnvVars) {
     envParts.push(extraSetEnvVars);
   }
@@ -154,6 +157,7 @@ const deployFunction = async ({
   }
 
   const requiresHostedApiKey = functionUsesWrapper(functionConfig, 'requireHostedApiKey');
+  const hostedApiKey = deployEnvVars.HOSTED_API_KEY;
 
   for (const schedule of schedules) {
     const {
@@ -203,6 +207,7 @@ const deployFromHostingYml = async (options = {}) => {
   const hostingConfig = readHostingYml(config.workspace);
   const {
     google_cloud_info: googleCloudInfo,
+    env: envNames = [],
     functions = {},
     groups = {},
   } = hostingConfig;
@@ -222,12 +227,7 @@ const deployFromHostingYml = async (options = {}) => {
     handlersByName,
   });
 
-  if (anyHostedEntryUsesWrapper(hostedHandlers, 'requireHostedApiKey')) {
-    const hostedApiKey = getHostedApiKeyForDeploy(config.workspace);
-    if (!hostedApiKey) {
-      throw new Error('HOSTED_API_KEY is required in workspace .env when using requireHostedApiKey wrapper');
-    }
-  }
+  const deployEnvVars = validateEnvVarsForDeploy(config.workspace, envNames);
 
   writeHostedJs({
     workspace: config.workspace,
@@ -235,7 +235,6 @@ const deployFromHostingYml = async (options = {}) => {
   });
 
   const credsJson = getCredsJsonForDeploy(config.workspace);
-  const hostedApiKey = getHostedApiKeyForDeploy(config.workspace);
   const deployArgs = getDeployArgs();
 
   const deployOne = async (functionName) => {
@@ -250,7 +249,7 @@ const deployFromHostingYml = async (options = {}) => {
       googleCloudInfo,
       workspace: config.workspace,
       credsJson,
-      hostedApiKey,
+      deployEnvVars,
     });
   };
 
@@ -289,9 +288,9 @@ const deployFromHostingYml = async (options = {}) => {
 
   console.log(`
 Usage (from workspace repo):
-  npm run host --workspace . --api_dirs api all
-  npm run host --workspace . --api_dirs api function
-  npm run host --workspace . --api_dirs api group
+  mineral host --workspace . --api_dirs api all
+  mineral host --workspace . --api_dirs api function
+  mineral host --workspace . --api_dirs api group
 `);
 };
 
@@ -309,11 +308,11 @@ module.exports = {
 
 /*
   Deploy everything:
-  npm run host all
+  mineral host all
 
   Deploy a single function:
-  npm run host function
+  mineral host function
 
   Deploy a group of functions:
-  npm run host group
+  mineral host group
 */

package/_deploy_scripts/generateHosted.js

@@ -1,15 +1,28 @@
 const fs = require('fs');
-const { wrapHostedFunction } = require('../hosting.utils');
+const { wrapHostedFunction, parseWrapperRef } = require('../hosting.utils');
+
+const formatWrapperRefForHostedJs = (wrapperRef) => {
+  const { modulePath, exportName } = parseWrapperRef(wrapperRef);
+  return `require('${ modulePath }').${ exportName }`;
+};
+
+const formatWrappersArg = (wrappers = []) => {
+  if (!wrappers.length) {
+    return '';
+  }
+
+  const wrapperLines = wrappers.map((wrapperRef) => `    ${ formatWrapperRefForHostedJs(wrapperRef) },`);
+  return `, [\n${ wrapperLines.join('\n') }\n  ]`;
+};
 
 const generateHostedJs = ({
   hostedHandlers,
 }) => {
   const exportLines = [];
-  const hostingUtilsRequire = '@foxtware/mineral/hosting.utils';
 
   for (const hostedHandler of hostedHandlers) {
     const { entryPoint, wrappers = [], requirePath } = hostedHandler;
-    const wrappersArg = wrappers.length ? `, ${ JSON.stringify(wrappers) }` : '';
+    const wrappersArg = formatWrappersArg(wrappers);
 
     exportLines.push(
       `  ${ entryPoint }: wrapHostedFunction(() => require('${ requirePath }'), '${ entryPoint }'${ wrappersArg }),`,
@@ -17,7 +30,7 @@ const generateHostedJs = ({
   }
 
   return `// Generated by mineral — do not edit
-const { wrapHostedFunction } = require('${ hostingUtilsRequire }');
+const { wrapHostedFunction } = require('@foxtware/mineral/hosting.utils');
 
 module.exports = {
 ${ exportLines.join('\n') }

package/bin/mineral.js

@@ -1,5 +1,16 @@
 #!/usr/bin/env node
 
+const command = process.argv[2];
+
+if (command === 'host') {
+  const { deployFromHostingYml } = require('../_deploy_scripts/deployFromHostingYml');
+  deployFromHostingYml().catch((error) => {
+    console.error(error);
+    process.exit(1);
+  });
+  return;
+}
+
 const { startServer } = require('../server');
 
 startServer();

package/hosting.utils.js

@@ -8,22 +8,34 @@ const {
   argsFromBody,
   funcApi,
   wrapFunction,
-  requireHostedApiKey,
   statusCodeFromResult,
 } = require('./server.utils');
 
-const wrappersByName = {
-  requireHostedApiKey,
+const parseWrapperRef = (wrapperRef) => {
+  const hashIndex = wrapperRef.lastIndexOf('#');
+
+  if (hashIndex === -1) {
+    throw new Error(`Invalid wrapper ref (expected path#export): ${ wrapperRef }`);
+  }
+
+  return {
+    modulePath: wrapperRef.slice(0, hashIndex),
+    exportName: wrapperRef.slice(hashIndex + 1),
+  };
 };
 
-const resolveWrappers = (wrapperNames = []) => (
-  wrapperNames.map((wrapperName) => {
-    const wrapper = wrappersByName[wrapperName];
-    if (!wrapper) {
-      throw new Error(`Unknown wrapper: ${ wrapperName }`);
-    }
-    return wrapper;
-  })
+const validateWrapperRef = (wrapperRef, workspaceRequire) => {
+  const { modulePath, exportName } = parseWrapperRef(wrapperRef);
+  workspaceRequire.resolve(modulePath);
+  const moduleExports = workspaceRequire(modulePath);
+
+  if (typeof moduleExports[exportName] !== 'function') {
+    throw new Error(`Wrapper export not found: ${ exportName } in ${ modulePath }`);
+  }
+};
+
+const wrapperExportName = (wrapperRef) => (
+  parseWrapperRef(wrapperRef).exportName
 );
 
 const getHostedEntries = (functions = {}) => {
@@ -51,8 +63,9 @@ const getHostedEntries = (functions = {}) => {
   return [...byEntryPoint.values()];
 };
 
-const functionUsesWrapper = (functionConfig = {}, wrapperName) => (
-  Array.isArray(functionConfig.wrappers) && functionConfig.wrappers.includes(wrapperName)
+const functionUsesWrapper = (functionConfig = {}, exportName) => (
+  Array.isArray(functionConfig.wrappers)
+  && functionConfig.wrappers.some((wrapperRef) => wrapperExportName(wrapperRef) === exportName)
 );
 
 const getFuncApiConfig = ({
@@ -76,10 +89,9 @@ const getFuncApiConfig = ({
   }
 };
 
-const wrapHostedFunction = (loader, exportName, wrapperNames = []) => {
+const wrapHostedFunction = (loader, exportName, wrappers = []) => {
   let handler = null;
   let usesFuncApi = false;
-  const wrappers = resolveWrappers(wrapperNames);
 
   const coreHandler = async (req, res) => {
     if (!handler) {
@@ -168,7 +180,7 @@ const getCredsJsonForDeploy = (workspace) => {
   return JSON.stringify(yaml.parse(credsText));
 };
 
-const getHostedApiKeyForDeploy = (workspace) => {
+const getEnvValueForDeploy = (workspace, envName) => {
   const envPath = `${ workspace }/.env`;
 
   if (!fs.existsSync(envPath)) {
@@ -176,10 +188,27 @@ const getHostedApiKeyForDeploy = (workspace) => {
   }
 
   const envText = fs.readFileSync(envPath, 'utf8');
-  const match = envText.match(/^HOSTED_API_KEY=(.*)$/m);
+  const match = envText.match(new RegExp(`^${ envName }=(.*)$`, 'm'));
   return match ? match[1].trim() : '';
 };
 
+const getEnvVarsForDeploy = (workspace, envNames = []) => (
+  Object.fromEntries(
+    envNames.map((envName) => [envName, getEnvValueForDeploy(workspace, envName)]),
+  )
+);
+
+const validateEnvVarsForDeploy = (workspace, envNames = []) => {
+  const envVars = getEnvVarsForDeploy(workspace, envNames);
+  const missing = envNames.filter((envName) => !envVars[envName]);
+
+  if (missing.length) {
+    throw new Error(`Missing required .env values: ${ missing.join(', ') }`);
+  }
+
+  return envVars;
+};
+
 const resolveHostedHandlersForDeploy = ({
   functions = {},
   workspace,
@@ -189,7 +218,11 @@ const resolveHostedHandlersForDeploy = ({
   const hostedEntries = getHostedEntries(functions);
 
   return hostedEntries.map((hostedEntry) => {
-    const { entryPoint, source } = hostedEntry;
+    const { entryPoint, source, wrappers = [] } = hostedEntry;
+
+    for (const wrapperRef of wrappers) {
+      validateWrapperRef(wrapperRef, workspaceRequire);
+    }
 
     if (source) {
       workspaceRequire.resolve(source);
@@ -221,12 +254,15 @@ const resolveHostedHandlersForDeploy = ({
 // TODO: support credsPayload in google_cloud_info instead of full workspace .creds.yml
 
 module.exports = {
+  parseWrapperRef,
   getFuncApiConfig,
   wrapHostedFunction,
   readHostingYml,
   getCredsJsonForDeploy,
-  getHostedApiKeyForDeploy,
+  getEnvVarsForDeploy,
+  validateEnvVarsForDeploy,
   getHostedEntries,
   resolveHostedHandlersForDeploy,
   functionUsesWrapper,
+  wrapperExportName,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@foxtware/mineral",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "bin": {
     "mineral": "bin/mineral.js"
   },

package/server.utils.js

@@ -37,6 +37,10 @@ const getRequestBody = async (req) => {
     return undefined;
   }
 
+  if (req.body !== undefined) {
+    return req.body;
+  }
+
   const decoder = new StringDecoder('utf8');
 
   return await new Promise((resolve, reject) => {
@@ -145,6 +149,20 @@ const requireHostedApiKey = async (req) => {
   }
 };
 
+const allowCrossOriginCallsAndHandleOptions = async (req, res) => {
+  const { origin } = req.headers;
+
+  res.setHeader('Access-Control-Allow-Origin', origin || '*');
+  res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+  res.setHeader('Access-Control-Allow-Headers', 'Content-Type, x-api-key, x-wf-token, x-wf-value');
+
+  if (req.method === 'OPTIONS') {
+    res.writeHead(204);
+    res.end();
+    return { handled: true };
+  }
+};
+
 const statusCodeFromResult = (result) => {
   if (result?.ok === false) {
     return result?.error?.statusCode ?? 400;
@@ -263,6 +281,7 @@ module.exports = {
   argsFromBody,
   wrapFunction,
   requireHostedApiKey,
+  allowCrossOriginCallsAndHandleOptions,
   statusCodeFromResult,
   funcApi,
 };