@foxtware/mineral 0.1.6 → 0.1.8

package/.creds.yml.sample

@@ -23,4 +23,7 @@ yotpo:
     MERCHANT_ID: _________________________
 
 linear:
-  API_KEY: _______________________________
+  API_KEY: _______________________________
+
+slack:
+  BOT_TOKEN: xoxb________________________________

package/.env.sample

@@ -0,0 +1,2 @@
+# Required by the requireHostedApiKey wrapper — requests must send this as the x-api-key header.
+HOSTED_API_KEY=________________________________

package/README.md

@@ -52,3 +52,8 @@ The [bedrock](https://github.com/GorgonFreeman/bedrock) middleware, refactored f
 Mineral gets pushed to from a larger repo that can also contain private functions. Mineral should be strictly useful stuff for the public, and can be used standalone, but needs to be instantiated for serving, setting stuff like which creds file to use. This allows it to be used as part of another repo in the same HTTP/curl way as by itself. Pass `--workspace` to locate `.creds.yml` and `--api_dirs` to serve additional function directories.
 
 For cloud deploy, workspaces use `hosting/.hosting.yml` and `npm run host` (same `--workspace` / `--api_dirs` flags as dev/serve). See `hosting/.hosting.yml.sample`.
+
+## What the thang do
+- Server makes functions available from the api/ route, where an export matches the filename. Run `npm run serve`, and they're all curlable.
+- .creds.yml is copied into .env when deploying, so creds can be accessed while hosted. Locally, it reads from the file directly.
+- Cloud deploy reads `hosting/.hosting.yml` for per-function config — `before_wrappers` / `after_wrappers` like `requireHostedApiKey`, `max_instances`, schedules — and deploys each function to Google Cloud.

package/api/shopify/shopifyDecodeSessionToken.js

@@ -0,0 +1,206 @@
+// https://shopify.dev/docs/apps/build/authentication-authorization/session-tokens/set-up-session-tokens
+
+const crypto = require('crypto');
+const { credsFromPayload, ArgsWarden } = require('../utils');
+const { credsValidator } = require('../validators');
+
+const sessionTokenValidator = (sessionToken) => {
+  return typeof sessionToken === 'string' && Boolean(sessionToken.trim());
+};
+
+const argsWarden = new ArgsWarden([
+  ['credsPayload', credsValidator],
+  ['sessionToken', sessionTokenValidator],
+]);
+
+const base64UrlDecodeJson = (input) => {
+  const base64 = input.replace(/-/g, '+').replace(/_/g, '/');
+  const padding = '='.repeat((4 - base64.length % 4) % 4);
+
+  return JSON.parse(Buffer.from(`${ base64 }${ padding }`, 'base64').toString('utf8'));
+};
+
+const normalizeSessionToken = (sessionToken) => {
+  const trimmedToken = sessionToken.trim();
+
+  if (trimmedToken.toLowerCase().startsWith('bearer ')) {
+    return trimmedToken.slice(7).trim();
+  }
+
+  return trimmedToken;
+};
+
+const verifySessionTokenSignature = (token, apiSecret) => {
+  const [encodedHeader, encodedPayload, signature] = token.split('.');
+
+  if (!encodedHeader || !encodedPayload || !signature) {
+    return false;
+  }
+
+  const message = `${ encodedHeader }.${ encodedPayload }`;
+  const computedSignature = crypto
+    .createHmac('sha256', apiSecret)
+    .update(message)
+    .digest('base64url');
+
+  return computedSignature === signature;
+};
+
+const validateSessionTokenClaims = (
+  decoded,
+  {
+    checkAudience = true,
+    clientId,
+  } = {},
+) => {
+  const {
+    iss,
+    dest,
+    aud,
+    exp,
+    nbf,
+  } = decoded;
+
+  const currentTime = Math.floor(Date.now() / 1000);
+  const expValid = exp > currentTime;
+  const nbfValid = nbf <= currentTime;
+  const domainsValid = dest?.includes('myshopify.com') && iss?.includes('myshopify.com');
+  const audValid = !checkAudience || aud === clientId;
+
+  return expValid && nbfValid && domainsValid && audValid;
+};
+
+const decodeSessionTokenPayload = (token) => {
+  const encodedPayload = token.split('.')[1];
+
+  if (!encodedPayload) {
+    return null;
+  }
+
+  try {
+    return base64UrlDecodeJson(encodedPayload);
+  } catch (error) {
+    return null;
+  }
+};
+
+const shopifyDecodeSessionToken = async (
+  credsPayload,
+  sessionToken,
+  {
+    checkAudience = true,
+  } = {},
+) => {
+
+  const rejectResponse = await argsWarden.responseIfRejectingArgs({
+    credsPayload,
+    sessionToken,
+  });
+  if (rejectResponse) {
+    return rejectResponse;
+  }
+
+  const creds = await credsFromPayload(credsPayload);
+  const {
+    API_SECRET,
+    CLIENT_ID,
+  } = creds;
+
+  if (!API_SECRET || !CLIENT_ID) {
+    return {
+      ok: false,
+      error: {
+        code: 'INVALID_CREDS',
+        message: 'API_SECRET and CLIENT_ID are required.',
+      },
+    };
+  }
+
+  const token = normalizeSessionToken(sessionToken);
+  const decoded = decodeSessionTokenPayload(token);
+
+  if (!decoded) {
+    return {
+      ok: false,
+      error: {
+        code: 'INVALID_SESSION_TOKEN',
+        message: 'Session token could not be decoded.',
+      },
+    };
+  }
+
+  if (!verifySessionTokenSignature(token, API_SECRET)) {
+    return {
+      ok: false,
+      error: {
+        code: 'INVALID_SESSION_TOKEN',
+        message: 'Session token signature is invalid.',
+      },
+    };
+  }
+
+  if (!validateSessionTokenClaims(decoded, {
+    checkAudience,
+    clientId: CLIENT_ID,
+  })) {
+    return {
+      ok: false,
+      error: {
+        code: 'INVALID_SESSION_TOKEN',
+        message: 'Session token claims are invalid.',
+        details: decoded,
+      },
+    };
+  }
+
+  return {
+    ok: true,
+    data: decoded,
+  };
+};
+
+const funcApiConfig = {
+  argsWarden,
+};
+
+module.exports = {
+  shopifyDecodeSessionToken,
+  funcApiConfig,
+};
+
+/*
+curl -X POST "http://localhost:8000/shopifyDecodeSessionToken" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "credsPayload": { "credsPath": "tender.prod" },
+    "sessionToken": "<jwt>"
+  }'
+*/
+
+/*
+  Legacy usage:
+  const whichApp = req.headers['x-wf-app'];
+
+  const sessionToken = req?.headers?.authorization?.split(' ')?.pop();
+  if (!sessionToken) {
+    return respond(res, 401, {
+      error: 'Unauthorized: No session token',
+    });
+  }
+
+  const sessionTokenData = shopifyDecodeSessionToken(sessionToken, {
+    ...whichApp && { credsPath: whichApp },
+  });
+
+  const {
+    dest,
+    sub: customerGid,
+  } = sessionTokenData;
+
+  const config = domainToConfig(dest);
+  if (!config) {
+    return respond(res, 401, {
+      error: 'No config found for domain',
+    });
+  }
+*/

package/api/slack/slack.constants.js

@@ -0,0 +1,5 @@
+const SLACK_API_BASE_URL = 'https://slack.com/api';
+
+module.exports = {
+  SLACK_API_BASE_URL,
+};

package/api/slack/slack.utils.js

@@ -0,0 +1,46 @@
+const { SLACK_API_BASE_URL } = require('../slack/slack.constants');
+const {
+  FetchClient,
+  Chain,
+  appendUrlToBase,
+  fetchClientCommonSteps,
+} = require('../utils');
+
+const addUrlAndAuthHeaders = async (state) => {
+  const { requestPayload, context } = state;
+  const { creds } = context;
+  const {
+    BOT_TOKEN,
+  } = creds;
+
+  return {
+    requestPayload: {
+      ...requestPayload,
+      method: requestPayload.method || 'post',
+      url: appendUrlToBase(SLACK_API_BASE_URL, requestPayload.url),
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${ BOT_TOKEN }`,
+        ...requestPayload.headers,
+      },
+    },
+  };
+};
+
+
+const slackClientRequestPreparer = new Chain([
+  addUrlAndAuthHeaders,
+]);
+
+const slackClientResponseInterpreter = new Chain([
+  fetchClientCommonSteps.exitEarlyOnNotOk,
+]);
+
+const slackClient = new FetchClient({
+  requestPreparer: slackClientRequestPreparer,
+  responseInterpreter: slackClientResponseInterpreter,
+});
+
+module.exports = {
+  slackClient,
+};

package/api/slack/slackMessagePost.js

@@ -0,0 +1,85 @@
+// https://docs.slack.dev/reference/methods/chat.postmessage
+
+const { credsFromPayload, objHasAny, ArgsWarden } = require('../utils');
+const { credsValidator } = require('../validators');
+const { slackClient } = require('../slack/slack.utils');
+
+const channelIdentifierValidator = (channelIdentifier) => {
+  return objHasAny(channelIdentifier, ['channelName', 'channelId']);
+};
+
+const messagePayloadValidator = (messagePayload) => {
+  return objHasAny(messagePayload, ['text', 'blocks', 'markdownText']);
+};
+
+const argsWarden = new ArgsWarden([
+  ['credsPayload', credsValidator],
+  ['channelIdentifier', channelIdentifierValidator],
+  ['messagePayload', messagePayloadValidator],
+]);
+
+const slackMessagePost = async (
+  credsPayload,
+  channelIdentifier,
+  messagePayload,
+  {
+    inspect = false,
+  } = {},
+) => {
+
+  const rejectResponse = await argsWarden.responseIfRejectingArgs({
+    credsPayload,
+    channelIdentifier,
+    messagePayload,
+  });
+  if (rejectResponse) {
+    return rejectResponse;
+  }
+
+  const creds = await credsFromPayload(credsPayload);
+
+  const {
+    channelName,
+    channelId,
+  } = channelIdentifier;
+
+  const {
+    text,
+    blocks,
+    markdownText,
+  } = messagePayload;
+
+  const response = await slackClient.fetch({
+    url: '/chat.postMessage',
+    method: 'post',
+    body: {
+      channel: channelId || channelName,
+      ...text && { text },
+      ...blocks && { blocks },
+      ...markdownText && { markdown_text: markdownText },
+    },
+    context: { creds },
+    inspect,
+  });
+
+  return response;
+};
+
+const funcApiConfig = {
+  argsWarden,
+};
+
+module.exports = {
+  slackMessagePost,
+  funcApiConfig,
+};
+
+/*
+curl -X POST "http://localhost:8000/slackMessagePost" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "credsPayload": { "credsPath": "slack" },
+    "channelIdentifier": { "channelName": "#hidden_testing" },
+    "messagePayload": { "text": "new number, who dis?" }
+  }'
+*/

package/api/utils.js

@@ -146,14 +146,14 @@ const customFetch = async (url, {
       });
 
       const responseContentType = response.headers.get('content-type');
-      console.log(responseContentType);
+      !HOSTED && console.log('responseContentType', responseContentType);
 
       if (!responseParser) {
         responseParser = getResponseParser(responseContentType);
       }
 
       const parsedResponse = await responseParser(response);
-      logDeep({ parsedResponse });
+      !HOSTED && logDeep({ parsedResponse });
 
       if (response.ok) {
         return {
@@ -278,7 +278,6 @@ const pathAsArray = (path) => {
 
 const objectDigNodeAtPath = (obj, path) => {
   let nodes = pathAsArray(path);
-  console.log(nodes);
 
   let output = obj;
   for (const node of nodes) {
@@ -1135,6 +1134,10 @@ class ArgsWarden {
   }
 }
 
+const gidToId = (gid) => {
+  return gid.split('/').pop();
+};
+
 module.exports = {
   wait,
   timeMs,
@@ -1161,7 +1164,7 @@ module.exports = {
   actionSingleOrMultiple,
   Processor,
   Getter,
-  capitaliseString,
   sentenceCaseString,
   ArgsWarden,
+  gidToId,
 };

package/bin/mineral.js

@@ -11,6 +11,12 @@ if (command === 'host') {
   return;
 }
 
+if (command === 'hosting_preview') {
+  const { startHostingPreview } = require('../hosting/hostingPreview');
+  startHostingPreview();
+  return;
+}
+
 const { startServer } = require('../server');
 
 startServer();

package/hosting/.hosting.yml.sample

@@ -8,14 +8,14 @@ functions:
   exampleFunction:
     max_instances: 1
     timeout: 300s
-    wrappers:
-      - requireHostedApiKey
+    before_wrappers:
       - allowCrossOriginCallsAndHandleOptions
+      - requireHostedApiKey
     # entry_point: otherHandlerName
 
   pokemonPokeballThrow:
     max_instances: 1
-    wrappers:
+    before_wrappers:
       - checkTrainer
 
 groups:

package/hosting/deployFromHostingYml.js

@@ -107,7 +107,8 @@ const deployFunction = async ({
     entry_point,
     schedules,
     groups,
-    wrappers,
+    before_wrappers,
+    after_wrappers,
     source,
     env,
     ...gcloudArgs

package/hosting/generateHosted.js

@@ -1,19 +1,49 @@
 const fs = require('fs');
 const { wrapHostedFunction } = require('./hosting.utils');
 
+const requirePathForHostedJs = (modulePath) => {
+  if (modulePath === './hosting/wrappers.js') {
+    return './wrappers.js';
+  }
+
+  if (modulePath.startsWith('./api/')) {
+    return `../${ modulePath.slice(2) }`;
+  }
+
+  return modulePath;
+};
+
 const formatResolvedWrapperForHostedJs = ({ modulePath, wrapperName }) => (
-  `require('${ modulePath }').${ wrapperName }`
+  `require('${ requirePathForHostedJs(modulePath) }').${ wrapperName }`
 );
 
-const formatWrappersArg = (resolvedWrappers = []) => {
+const formatWrapperList = (resolvedWrappers = []) => {
   if (!resolvedWrappers.length) {
     return '';
   }
 
   const wrapperLines = resolvedWrappers.map((resolvedWrapper) => (
-    `    ${ formatResolvedWrapperForHostedJs(resolvedWrapper) },`
+    `      ${ formatResolvedWrapperForHostedJs(resolvedWrapper) },`
   ));
-  return `, [\n${ wrapperLines.join('\n') }\n  ]`;
+
+  return `\n${ wrapperLines.join('\n') }\n    `;
+};
+
+const formatWrappersArg = ({
+  resolvedBeforeWrappers = [],
+  resolvedAfterWrappers = [],
+} = {}) => {
+  if (!resolvedBeforeWrappers.length && !resolvedAfterWrappers.length) {
+    return '';
+  }
+
+  const beforeWrappersBlock = formatWrapperList(resolvedBeforeWrappers);
+  const afterWrappersBlock = formatWrapperList(resolvedAfterWrappers);
+
+  return `, {
+    beforeWrappers: [${ beforeWrappersBlock }],
+    afterWrappers: [${ afterWrappersBlock }],
+  }`;
 };
 
 const generateHostedJs = ({
@@ -22,11 +52,20 @@ const generateHostedJs = ({
   const exportLines = [];
 
   for (const hostedHandler of hostedHandlers) {
-    const { hostedName, handlerName, resolvedWrappers = [], requirePath } = hostedHandler;
-    const wrappersArg = formatWrappersArg(resolvedWrappers);
+    const {
+      hostedName,
+      handlerName,
+      resolvedBeforeWrappers = [],
+      resolvedAfterWrappers = [],
+      requirePath,
+    } = hostedHandler;
+    const wrappersArg = formatWrappersArg({
+      resolvedBeforeWrappers,
+      resolvedAfterWrappers,
+    });
 
     exportLines.push(
-      `  ${ hostedName }: wrapHostedFunction(() => require('${ requirePath }'), '${ handlerName }'${ wrappersArg }),`,
+      `  ${ hostedName }: wrapHostedFunction(() => require('${ requirePathForHostedJs(requirePath) }'), '${ handlerName }'${ wrappersArg }),`,
     );
   }
 
@@ -50,6 +89,14 @@ const writeHostedJs = ({
   });
 
   fs.mkdirSync(getHostingDir(workspace), { recursive: true });
+
+  if (fs.existsSync(hostedPath)) {
+    const existingContent = fs.readFileSync(hostedPath, 'utf8');
+    if (existingContent === content) {
+      return hostedPath;
+    }
+  }
+
   fs.writeFileSync(hostedPath, content);
   return hostedPath;
 };

package/hosting/hosting.utils.js

@@ -71,13 +71,16 @@ const getHostedEntries = (functions = {}) => (
   Object.entries(functions).map(([hostedName, functionConfig = {}]) => ({
     hostedName,
     handlerName: functionConfig.entry_point || functionConfig.entryPoint || hostedName,
-    wrappers: Array.isArray(functionConfig.wrappers) ? functionConfig.wrappers : [],
+    beforeWrappers: Array.isArray(functionConfig.before_wrappers) ? functionConfig.before_wrappers : [],
+    afterWrappers: Array.isArray(functionConfig.after_wrappers) ? functionConfig.after_wrappers : [],
   }))
 );
 
-const functionUsesWrapper = (functionConfig = {}, wrapperName) => (
-  Array.isArray(functionConfig.wrappers) && functionConfig.wrappers.includes(wrapperName)
-);
+const functionUsesWrapper = (functionConfig = {}, wrapperName) => {
+  const { before_wrappers = [], after_wrappers = [] } = functionConfig;
+
+  return before_wrappers.includes(wrapperName) || after_wrappers.includes(wrapperName);
+};
 
 const getFuncApiConfig = ({
   moduleExports,
@@ -100,7 +103,10 @@ const getFuncApiConfig = ({
   }
 };
 
-const wrapHostedFunction = (loader, exportName, wrappers = []) => {
+const wrapHostedFunction = (loader, exportName, {
+  beforeWrappers = [],
+  afterWrappers = [],
+} = {}) => {
   let handler = null;
   let usesFuncApi = false;
 
@@ -129,7 +135,10 @@ const wrapHostedFunction = (loader, exportName, wrappers = []) => {
       : await handler(...args);
   };
 
-  const wrappedHandler = wrapFunction(coreHandler, wrappers);
+  const wrappedHandler = wrapFunction(coreHandler, {
+    beforeWrappers,
+    afterWrappers,
+  });
 
   return async (req, res) => {
     try {
@@ -180,17 +189,6 @@ const readHostingYml = (workspace) => {
   return hostingConfig;
 };
 
-const getCredsJsonForDeploy = (workspace) => {
-  const credsPath = `${ workspace }/.creds.yml`;
-
-  if (!fs.existsSync(credsPath)) {
-    throw new Error(`Missing .creds.yml in workspace: ${ workspace }`);
-  }
-
-  const credsText = fs.readFileSync(credsPath, 'utf8');
-  return JSON.stringify(yaml.parse(credsText));
-};
-
 const ensureWorkspaceEnvForDeploy = (workspace) => {
   const { copyCredsToEnv } = require('./copyCredsToEnv');
   const envPath = `${ workspace.replace(/\/$/, '') }/.env`;
@@ -211,9 +209,16 @@ const resolveHostedHandlersForDeploy = ({
   const hostedEntries = getHostedEntries(functions);
 
   return hostedEntries.map((hostedEntry) => {
-    const { handlerName, wrappers = [] } = hostedEntry;
+    const {
+      handlerName,
+      beforeWrappers = [],
+      afterWrappers = [],
+    } = hostedEntry;
 
-    const resolvedWrappers = wrappers.map((wrapperName) => (
+    const resolvedBeforeWrappers = beforeWrappers.map((wrapperName) => (
+      resolveWrapperName(wrapperName, workspaceRequire)
+    ));
+    const resolvedAfterWrappers = afterWrappers.map((wrapperName) => (
       resolveWrapperName(wrapperName, workspaceRequire)
     ));
 
@@ -226,7 +231,8 @@ const resolveHostedHandlersForDeploy = ({
 
     return {
       ...hostedEntry,
-      resolvedWrappers,
+      resolvedBeforeWrappers,
+      resolvedAfterWrappers,
       requirePath: getRequirePathForHandler(handler, workspace),
     };
   });
@@ -240,7 +246,6 @@ module.exports = {
   getFuncApiConfig,
   wrapHostedFunction,
   readHostingYml,
-  getCredsJsonForDeploy,
   ensureWorkspaceEnvForDeploy,
   getHostedEntries,
   resolveHostedHandlersForDeploy,

package/hosting/hostingPreview.js

@@ -0,0 +1,160 @@
+const http = require('http');
+const { createRequire } = require('module');
+const { respondJson, errorToReadable } = require('../server.utils');
+const { getWorkspace, setWorkspace, loadWorkspaceEnv, toAbsolutePath } = require('../api/workspace');
+const { getApiDirs, readCliFlag } = require('../cli');
+const { loadHandlers } = require('../server');
+const {
+  readHostingYml,
+  resolveHostedHandlersForDeploy,
+  wrapHostedFunction,
+} = require('./hosting.utils');
+const { copyCredsToEnv } = require('./copyCredsToEnv');
+
+const getConfig = (options = {}) => ({
+  port: Number(options.port ?? process.env.PORT ?? 8000),
+  workspace: toAbsolutePath(
+    options.workspace
+      ?? readCliFlag('--workspace')
+      ?? process.env.MINERAL_WORKSPACE
+      ?? process.cwd(),
+  ),
+  api_dirs: getApiDirs(options),
+});
+
+const handlerByRouteName = (handlers) => {
+  const byName = new Map();
+
+  for (const handler of handlers.values()) {
+    byName.set(handler.routeName, handler);
+  }
+
+  return byName;
+};
+
+const loadHostedRoutes = (config) => {
+  const { functions } = readHostingYml(config.workspace);
+  const handlers = loadHandlers({
+    ...config,
+    host_mode: true,
+  });
+  const handlersByName = handlerByRouteName(handlers);
+  const hostedHandlers = resolveHostedHandlersForDeploy({
+    functions,
+    workspace: config.workspace,
+    handlersByName,
+  });
+
+  const workspaceRequire = createRequire(`${ config.workspace.replace(/\/$/, '') }/package.json`);
+  const routes = new Map();
+
+  for (const hostedHandler of hostedHandlers) {
+    const {
+      hostedName,
+      handlerName,
+      resolvedBeforeWrappers = [],
+      resolvedAfterWrappers = [],
+      requirePath,
+    } = hostedHandler;
+
+    const beforeWrappers = resolvedBeforeWrappers.map(({ modulePath, wrapperName }) => (
+      workspaceRequire(modulePath)[wrapperName]
+    ));
+    const afterWrappers = resolvedAfterWrappers.map(({ modulePath, wrapperName }) => (
+      workspaceRequire(modulePath)[wrapperName]
+    ));
+
+    routes.set(
+      `/${ hostedName }`,
+      wrapHostedFunction(
+        () => workspaceRequire(requirePath),
+        handlerName,
+        {
+          beforeWrappers,
+          afterWrappers,
+        },
+      ),
+    );
+  }
+
+  return routes;
+};
+
+const createHostedPreviewServer = (handlers) => http.createServer(async (req, res) => {
+  if (req.method === 'GET' && req.url === '/') {
+    respondJson(res, 200, {
+      ok: true,
+      data: {
+        mode: 'hosting_preview',
+        routes: [...handlers.keys()].sort(),
+        workspace: getWorkspace(),
+      },
+    });
+    return;
+  }
+
+  const route = (req.url || '/').split('?')[0];
+  const handler = handlers.get(route);
+
+  if (!handler) {
+    respondJson(res, 404, {
+      ok: false,
+      error: {
+        code: 'NOT_FOUND',
+        message: `No hosted handler found for route ${ route }`,
+      },
+    });
+    return;
+  }
+
+  try {
+    await handler(req, res);
+  } catch (error) {
+    if (res.headersSent) {
+      return;
+    }
+
+    respondJson(res, 500, {
+      ok: false,
+      error: {
+        code: 'UNHANDLED_ERROR',
+        message: 'Unhandled server error.',
+        details: errorToReadable(error),
+      },
+    });
+  }
+});
+
+const startHostingPreview = (options = {}) => {
+  process.env.HOSTED = 'true';
+
+  const config = getConfig(options);
+
+  setWorkspace(config.workspace);
+  copyCredsToEnv(config.workspace);
+  loadWorkspaceEnv();
+
+  const handlers = loadHostedRoutes(config);
+  const server = createHostedPreviewServer(handlers);
+
+  server.listen(config.port, () => {
+    console.log(`Hosting preview running on port ${ config.port }`);
+    console.log(`Workspace: ${ config.workspace }`);
+    console.log('Hosted routes:');
+
+    for (const route of [...handlers.keys()].sort()) {
+      console.log(route);
+    }
+  });
+
+  return server;
+};
+
+module.exports = {
+  startHostingPreview,
+  loadHostedRoutes,
+};
+
+if (require.main === module) {
+  startHostingPreview();
+}

package/hosting/wrappers.js

@@ -22,7 +22,7 @@ const allowCrossOriginCallsAndHandleOptions = async (req, res) => {
 
   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');
+  res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization, x-api-key, x-wf-token, x-wf-value, x-wf-app');
 
   if (req.method === 'OPTIONS') {
     res.writeHead(204);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@foxtware/mineral",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "bin": {
     "mineral": "bin/mineral.js"
   },
@@ -10,7 +10,9 @@
   },
   "scripts": {
     "creds_to_env": "node hosting/copyCredsToEnv.js",
-    "dev": "node --watch --watch-path=./api --watch-path=./server.js --watch-path=./server.utils.js --watch-path=./.creds.yml server.js",
+    "dev": "node --watch --watch-path=./api --watch-path=./server.js --watch-path=./server.utils.js --watch-path=./hosting --watch-path=./.creds.yml server.js",
+    "hosting_preview": "node --watch --watch-path=./api --watch-path=./hosting/.hosting.yml --watch-path=./hosting/wrappers.js --watch-path=./.creds.yml hosting/hostingPreview.js",
+    "tunnel": "ngrok http http://localhost:8000",
     "new": "node _build_scripts/createNewFunction.js",
     "serve": "PORT=8100 node server.js",
     "start": "node server.js",
@@ -22,5 +24,8 @@
     "json-2-csv": "^5.5.9",
     "xml2js": "^0.6.2",
     "yaml": "^2.9.0"
+  },
+  "devDependencies": {
+    "ngrok": "^5.0.0-beta.2"
   }
 }

package/server.js

@@ -78,8 +78,6 @@ const directoriesToScan = ({
   return [MINERAL_API_DIR, ...extraDirs];
 };
 
-const getFuncApiConfigFromModule = getFuncApiConfig;
-
 const addHandlerFromFile = (filePath, handlers) => {
   const moduleExports = require(filePath);
   if (!moduleExports || typeof moduleExports !== 'object') {
@@ -92,7 +90,7 @@ const addHandlerFromFile = (filePath, handlers) => {
     return;
   }
 
-  const funcApiConfig = getFuncApiConfigFromModule({
+  const funcApiConfig = getFuncApiConfig({
     moduleExports,
     routeName,
   });

package/server.utils.js

@@ -1,8 +1,9 @@
 const { logDeep } = require('./api/utils');
+const { HOSTED } = require('./api/constants');
 const { StringDecoder } = require('string_decoder');
 
 const respondJson = (res, statusCode, payload) => {
-  logDeep(payload);
+  !HOSTED && logDeep(payload);
   const body = JSON.stringify(payload);
   res.writeHead(statusCode, {
     'Content-Type': 'application/json',
@@ -120,15 +121,48 @@ const runRequestHandler = async (requestHandler, requestContext) => {
   return mergeRequestContext(requestContext, handlerOutput);
 };
 
-const wrapFunction = (func, wrappers = []) => async (req, res, ...rest) => {
-  for (const wrapper of wrappers) {
-    const rejected = await wrapper(req, res);
-    if (rejected) {
-      return rejected;
+const wrapFunction = (func, {
+  beforeWrappers = [],
+  afterWrappers = [],
+} = {}) => async (req, res, ...rest) => {
+  for (const beforeWrapper of beforeWrappers) {
+    const beforeResult = await beforeWrapper(req, res);
+    if (beforeResult?.handled) {
+      return;
+    }
+    if (beforeResult) {
+      return beforeResult;
+    }
+  }
+
+  if (!afterWrappers.length) {
+    return func(req, res, ...rest);
+  }
+
+  let result;
+
+  try {
+    result = await func(req, res, ...rest);
+  } catch (error) {
+    result = {
+      ok: false,
+      error: {
+        code: 'UNHANDLED_ERROR',
+        message: 'Unhandled server error.',
+        details: errorToReadable(error),
+      },
+    };
+  }
+
+  for (const afterWrapper of afterWrappers) {
+    try {
+      await afterWrapper(req, res, result);
+    } catch (error) {
+      console.log('wrapFunction afterWrapper error', error);
     }
   }
 
-  return func(req, res, ...rest);
+  return result;
 };
 
 const statusCodeFromResult = (result) => {