@foxtware/mineral 0.1.3 → 0.1.5

package/.hosting.yml.sample

@@ -4,16 +4,19 @@ 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
     # entry_point: otherExportName
+      - requireHostedApiKey
+      - allowCrossOriginCallsAndHandleOptions
 
-  packagedFunction:
-    source: '@foxtware/mineral/api/pokemon/pokemonPokeballThrow.js'
+  pokemonPokeballThrow:
     max_instances: 1
     wrappers:
       - checkTrainer

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,23 +1,37 @@
 const fs = require('fs');
 const { wrapHostedFunction } = require('../hosting.utils');
 
+const formatResolvedWrapperForHostedJs = ({ modulePath, wrapperName }) => (
+  `require('${ modulePath }').${ wrapperName }`
+);
+
+const formatWrappersArg = (resolvedWrappers = []) => {
+  if (!resolvedWrappers.length) {
+    return '';
+  }
+
+  const wrapperLines = resolvedWrappers.map((resolvedWrapper) => (
+    `    ${ formatResolvedWrapperForHostedJs(resolvedWrapper) },`
+  ));
+  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 { hostedName, handlerName, resolvedWrappers = [], requirePath } = hostedHandler;
+    const wrappersArg = formatWrappersArg(resolvedWrappers);
 
     exportLines.push(
-      `  ${ entryPoint }: wrapHostedFunction(() => require('${ requirePath }'), '${ entryPoint }'${ wrappersArg }),`,
+      `  ${ hostedName }: wrapHostedFunction(() => require('${ requirePath }'), '${ handlerName }'${ wrappersArg }),`,
     );
   }
 
   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/handlerPaths.js

@@ -0,0 +1,23 @@
+const MINERAL_ROOT = __dirname;
+const MINERAL_API_DIR = `${ MINERAL_ROOT }/api`;
+
+const getRequirePathForHandler = (handler, workspace) => {
+  const normalizedWorkspace = workspace.replace(/\/$/, '');
+  const { filePath } = handler;
+
+  if (filePath.startsWith(`${ normalizedWorkspace }/`)) {
+    return `./${ filePath.slice(normalizedWorkspace.length + 1) }`;
+  }
+
+  if (filePath.startsWith(`${ MINERAL_API_DIR }/`)) {
+    const relativePath = filePath.slice(MINERAL_API_DIR.length + 1);
+    return `@foxtware/mineral/api/${ relativePath }`;
+  }
+
+  throw new Error(`Handler "${ handler.routeName }" is not in workspace or mineral api dirs`);
+};
+
+module.exports = {
+  MINERAL_API_DIR,
+  getRequirePathForHandler,
+};

package/hosting.utils.js

@@ -1,6 +1,7 @@
 const fs = require('fs');
 const { createRequire } = require('module');
 const yaml = require('yaml');
+const { getRequirePathForHandler } = require('./handlerPaths');
 const {
   respondJson,
   errorToReadable,
@@ -8,49 +9,64 @@ const {
   argsFromBody,
   funcApi,
   wrapFunction,
-  requireHostedApiKey,
   statusCodeFromResult,
 } = require('./server.utils');
 
-const wrappersByName = {
-  requireHostedApiKey,
-};
+const MINERAL_WRAPPERS_MODULE = '@foxtware/mineral/wrappers.js';
+const WORKSPACE_WRAPPERS_MODULE = './wrappers.js';
 
-const resolveWrappers = (wrapperNames = []) => (
-  wrapperNames.map((wrapperName) => {
-    const wrapper = wrappersByName[wrapperName];
-    if (!wrapper) {
-      throw new Error(`Unknown wrapper: ${ wrapperName }`);
+const getMineralWrappers = (workspaceRequire) => {
+  try {
+    return workspaceRequire(MINERAL_WRAPPERS_MODULE);
+  } catch (error) {
+    if (error.code !== 'MODULE_NOT_FOUND') {
+      throw error;
     }
-    return wrapper;
-  })
-);
 
-const getHostedEntries = (functions = {}) => {
-  const byEntryPoint = new Map();
+    return require('./wrappers.js');
+  }
+};
 
-  for (const [functionName, functionConfig] of Object.entries(functions)) {
-    const entryPoint = functionConfig.entry_point || functionConfig.entryPoint || functionName;
-    const existing = byEntryPoint.get(entryPoint) || {
-      entryPoint,
-      wrappers: [],
+const resolveWrapperName = (wrapperName, workspaceRequire) => {
+  if (typeof wrapperName !== 'string' || !wrapperName.trim()) {
+    throw new Error(`Invalid wrapper name: ${ wrapperName }`);
+  }
+
+  const mineralWrappers = getMineralWrappers(workspaceRequire);
+  if (typeof mineralWrappers[wrapperName] === 'function') {
+    return {
+      wrapperName,
+      modulePath: MINERAL_WRAPPERS_MODULE,
     };
+  }
 
-    if (Array.isArray(functionConfig.wrappers)) {
-      existing.wrappers.push(...functionConfig.wrappers);
-      existing.wrappers = [...new Set(existing.wrappers)];
+  try {
+    const workspaceWrappers = workspaceRequire(WORKSPACE_WRAPPERS_MODULE);
+    if (typeof workspaceWrappers[wrapperName] === 'function') {
+      return {
+        wrapperName,
+        modulePath: WORKSPACE_WRAPPERS_MODULE,
+      };
     }
-
-    if (functionConfig.source) {
-      existing.source = functionConfig.source;
+  } catch (error) {
+    if (error.code !== 'MODULE_NOT_FOUND') {
+      throw error;
     }
-
-    byEntryPoint.set(entryPoint, existing);
   }
 
-  return [...byEntryPoint.values()];
+  throw new Error(
+    `Wrapper "${ wrapperName }" not found in ${ MINERAL_WRAPPERS_MODULE } or ${ WORKSPACE_WRAPPERS_MODULE }`,
+  );
 };
 
+const getHostedEntries = (functions = {}) => (
+  Object.entries(functions).map(([hostedName, functionConfig = {}]) => ({
+    hostedName,
+    handlerName: functionConfig.entry_point || functionConfig.entryPoint || hostedName,
+    wrappers: Array.isArray(functionConfig.wrappers) ? functionConfig.wrappers : [],
+  }))
+);
+
 const functionUsesWrapper = (functionConfig = {}, wrapperName) => (
   Array.isArray(functionConfig.wrappers) && functionConfig.wrappers.includes(wrapperName)
 );
@@ -76,10 +92,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 +183,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 +191,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,31 +221,23 @@ const resolveHostedHandlersForDeploy = ({
   const hostedEntries = getHostedEntries(functions);
 
   return hostedEntries.map((hostedEntry) => {
-    const { entryPoint, source } = hostedEntry;
-
-    if (source) {
-      workspaceRequire.resolve(source);
-      const moduleExports = workspaceRequire(source);
-      if (typeof moduleExports[entryPoint] !== 'function') {
-        throw new Error(`Hosted export not found: ${ entryPoint } in ${ source }`);
-      }
+    const { handlerName, wrappers = [] } = hostedEntry;
 
-      return {
-        ...hostedEntry,
-        requirePath: source,
-      };
-    }
+    const resolvedWrappers = wrappers.map((wrapperName) => (
+      resolveWrapperName(wrapperName, workspaceRequire)
+    ));
 
-    const handler = handlersByName.get(entryPoint);
+    const handler = handlersByName.get(handlerName);
     if (!handler) {
       throw new Error(
-        `entry_point "${ entryPoint }" not found in workspace handlers — add api/ handler or source in .hosting.yml`,
+        `Function "${ handlerName }" not found — add a handler in workspace api dirs or mineral api`,
       );
     }
 
     return {
       ...hostedEntry,
-      requirePath: `./${ handler.filePath.slice(workspace.length + 1) }`,
+      resolvedWrappers,
+      requirePath: getRequirePathForHandler(handler, workspace),
     };
   });
 };
@@ -221,12 +245,16 @@ const resolveHostedHandlersForDeploy = ({
 // TODO: support credsPayload in google_cloud_info instead of full workspace .creds.yml
 
 module.exports = {
+  resolveWrapperName,
   getFuncApiConfig,
   wrapHostedFunction,
   readHostingYml,
   getCredsJsonForDeploy,
-  getHostedApiKeyForDeploy,
+  getEnvVarsForDeploy,
+  validateEnvVarsForDeploy,
   getHostedEntries,
   resolveHostedHandlersForDeploy,
   functionUsesWrapper,
+  MINERAL_WRAPPERS_MODULE,
+  WORKSPACE_WRAPPERS_MODULE,
 };

package/package.json

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

package/server.js

@@ -4,8 +4,7 @@ const { respondJson, errorToReadable, getRequestBody, argsFromBody, funcApi, sta
 const { getWorkspace, setWorkspace, loadWorkspaceEnv, toAbsolutePath } = require('./api/workspace');
 const { getApiDirs, readCliFlag } = require('./cli');
 const { getFuncApiConfig } = require('./hosting.utils');
-
-const MINERAL_API_DIR = `${ __dirname }/api`;
+const { MINERAL_API_DIR, getRequirePathForHandler } = require('./handlerPaths');
 
 const getConfig = (options = {}) => ({
   port: Number(options.port ?? process.env.PORT ?? 8000),
@@ -69,7 +68,6 @@ const listJsFiles = (directory) => {
 const directoriesToScan = ({
   workspace,
   api_dirs,
-  host_mode = false,
 }) => {
   const extraDirs = api_dirs.map((dir) => (
     dir.startsWith('/')
@@ -77,10 +75,6 @@ const directoriesToScan = ({
       : `${ workspace }/${ dir }`
   ));
 
-  if (host_mode && api_dirs.length) {
-    return extraDirs;
-  }
-
   return [MINERAL_API_DIR, ...extraDirs];
 };
 
@@ -225,6 +219,8 @@ const startServer = (options = {}) => {
 module.exports = {
   startServer,
   loadHandlers,
+  getRequirePathForHandler,
+  MINERAL_API_DIR,
   get server() {
     if (!server) {
       startServer();

package/server.utils.js

@@ -1,6 +1,5 @@
 const { logDeep } = require('./api/utils');
 const { StringDecoder } = require('string_decoder');
-const { HOSTED } = require('./api/constants');
 
 const respondJson = (res, statusCode, payload) => {
   logDeep(payload);
@@ -132,23 +131,6 @@ const wrapFunction = (func, wrappers = []) => async (req, res, ...rest) => {
   return func(req, res, ...rest);
 };
 
-const requireHostedApiKey = async (req) => {
-  if (!HOSTED) {
-    return;
-  }
-
-  if (req.headers['x-api-key'] !== process.env.HOSTED_API_KEY) {
-    return {
-      ok: false,
-      error: {
-        code: 'UNAUTHORIZED',
-        message: 'Unauthorized',
-        statusCode: 401,
-      },
-    };
-  }
-};
-
 const statusCodeFromResult = (result) => {
   if (result?.ok === false) {
     return result?.error?.statusCode ?? 400;
@@ -266,7 +248,6 @@ module.exports = {
   getRequestBody,
   argsFromBody,
   wrapFunction,
-  requireHostedApiKey,
   statusCodeFromResult,
   funcApi,
 };

package/wrappers.js

@@ -0,0 +1,37 @@
+const { HOSTED } = require('./api/constants');
+
+const requireHostedApiKey = async (req) => {
+  if (!HOSTED) {
+    return;
+  }
+
+  if (req.headers['x-api-key'] !== process.env.HOSTED_API_KEY) {
+    return {
+      ok: false,
+      error: {
+        code: 'UNAUTHORIZED',
+        message: 'Unauthorized',
+        statusCode: 401,
+      },
+    };
+  }
+};
+
+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 };
+  }
+};
+
+module.exports = {
+  requireHostedApiKey,
+  allowCrossOriginCallsAndHandleOptions,
+};