@foxtware/mineral 0.1.4 → 0.1.5

package/.hosting.yml.sample

@@ -12,15 +12,14 @@ functions:
     max_instances: 1
     timeout: 300s
     wrappers:
-      - '@foxtware/mineral/server.utils#requireHostedApiKey'
-      - '@foxtware/mineral/server.utils#allowCrossOriginCallsAndHandleOptions'
     # entry_point: otherExportName
+      - requireHostedApiKey
+      - allowCrossOriginCallsAndHandleOptions
 
-  packagedFunction:
-    source: '@foxtware/mineral/api/pokemon/pokemonPokeballThrow.js'
+  pokemonPokeballThrow:
     max_instances: 1
     wrappers:
-      - '@foxtware/mineral/server.utils#checkTrainer'
+      - checkTrainer
 
 groups:
   example_group:

package/_deploy_scripts/generateHosted.js

@@ -1,17 +1,18 @@
 const fs = require('fs');
-const { wrapHostedFunction, parseWrapperRef } = require('../hosting.utils');
+const { wrapHostedFunction } = require('../hosting.utils');
 
-const formatWrapperRefForHostedJs = (wrapperRef) => {
-  const { modulePath, exportName } = parseWrapperRef(wrapperRef);
-  return `require('${ modulePath }').${ exportName }`;
-};
+const formatResolvedWrapperForHostedJs = ({ modulePath, wrapperName }) => (
+  `require('${ modulePath }').${ wrapperName }`
+);
 
-const formatWrappersArg = (wrappers = []) => {
-  if (!wrappers.length) {
+const formatWrappersArg = (resolvedWrappers = []) => {
+  if (!resolvedWrappers.length) {
     return '';
   }
 
-  const wrapperLines = wrappers.map((wrapperRef) => `    ${ formatWrapperRefForHostedJs(wrapperRef) },`);
+  const wrapperLines = resolvedWrappers.map((resolvedWrapper) => (
+    `    ${ formatResolvedWrapperForHostedJs(resolvedWrapper) },`
+  ));
   return `, [\n${ wrapperLines.join('\n') }\n  ]`;
 };
 
@@ -21,11 +22,11 @@ const generateHostedJs = ({
   const exportLines = [];
 
   for (const hostedHandler of hostedHandlers) {
-    const { entryPoint, wrappers = [], requirePath } = hostedHandler;
-    const wrappersArg = formatWrappersArg(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 }),`,
     );
   }
 

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,
@@ -11,61 +12,63 @@ const {
   statusCodeFromResult,
 } = require('./server.utils');
 
-const parseWrapperRef = (wrapperRef) => {
-  const hashIndex = wrapperRef.lastIndexOf('#');
+const MINERAL_WRAPPERS_MODULE = '@foxtware/mineral/wrappers.js';
+const WORKSPACE_WRAPPERS_MODULE = './wrappers.js';
 
-  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 validateWrapperRef = (wrapperRef, workspaceRequire) => {
-  const { modulePath, exportName } = parseWrapperRef(wrapperRef);
-  workspaceRequire.resolve(modulePath);
-  const moduleExports = workspaceRequire(modulePath);
+const getMineralWrappers = (workspaceRequire) => {
+  try {
+    return workspaceRequire(MINERAL_WRAPPERS_MODULE);
+  } catch (error) {
+    if (error.code !== 'MODULE_NOT_FOUND') {
+      throw error;
+    }
 
-  if (typeof moduleExports[exportName] !== 'function') {
-    throw new Error(`Wrapper export not found: ${ exportName } in ${ modulePath }`);
+    return require('./wrappers.js');
   }
 };
 
-const wrapperExportName = (wrapperRef) => (
-  parseWrapperRef(wrapperRef).exportName
-);
-
-const getHostedEntries = (functions = {}) => {
-  const byEntryPoint = new Map();
+const resolveWrapperName = (wrapperName, workspaceRequire) => {
+  if (typeof wrapperName !== 'string' || !wrapperName.trim()) {
+    throw new Error(`Invalid wrapper name: ${ wrapperName }`);
+  }
 
-  for (const [functionName, functionConfig] of Object.entries(functions)) {
-    const entryPoint = functionConfig.entry_point || functionConfig.entryPoint || functionName;
-    const existing = byEntryPoint.get(entryPoint) || {
-      entryPoint,
-      wrappers: [],
+  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 functionUsesWrapper = (functionConfig = {}, exportName) => (
-  Array.isArray(functionConfig.wrappers)
-  && functionConfig.wrappers.some((wrapperRef) => wrapperExportName(wrapperRef) === exportName)
+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)
 );
 
 const getFuncApiConfig = ({
@@ -218,35 +221,23 @@ const resolveHostedHandlersForDeploy = ({
   const hostedEntries = getHostedEntries(functions);
 
   return hostedEntries.map((hostedEntry) => {
-    const { entryPoint, source, wrappers = [] } = hostedEntry;
-
-    for (const wrapperRef of wrappers) {
-      validateWrapperRef(wrapperRef, workspaceRequire);
-    }
-
-    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),
     };
   });
 };
@@ -254,7 +245,7 @@ const resolveHostedHandlersForDeploy = ({
 // TODO: support credsPayload in google_cloud_info instead of full workspace .creds.yml
 
 module.exports = {
-  parseWrapperRef,
+  resolveWrapperName,
   getFuncApiConfig,
   wrapHostedFunction,
   readHostingYml,
@@ -264,5 +255,6 @@ module.exports = {
   getHostedEntries,
   resolveHostedHandlersForDeploy,
   functionUsesWrapper,
-  wrapperExportName,
+  MINERAL_WRAPPERS_MODULE,
+  WORKSPACE_WRAPPERS_MODULE,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@foxtware/mineral",
-  "version": "0.1.4",
+  "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,37 +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 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;
@@ -280,8 +248,6 @@ module.exports = {
   getRequestBody,
   argsFromBody,
   wrapFunction,
-  requireHostedApiKey,
-  allowCrossOriginCallsAndHandleOptions,
   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,
+};