@foxtware/mineral 0.1.7 → 0.1.8

package/api/utils.js

@@ -1134,6 +1134,10 @@ class ArgsWarden {
   }
 }
 
+const gidToId = (gid) => {
+  return gid.split('/').pop();
+};
+
 module.exports = {
   wait,
   timeMs,
@@ -1162,4 +1166,5 @@ module.exports = {
   Getter,
   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/generateHosted.js

@@ -1,8 +1,20 @@
 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 formatWrapperList = (resolvedWrappers = []) => {
@@ -53,7 +65,7 @@ const generateHostedJs = ({
     });
 
     exportLines.push(
-      `  ${ hostedName }: wrapHostedFunction(() => require('${ requirePath }'), '${ handlerName }'${ wrappersArg }),`,
+      `  ${ hostedName }: wrapHostedFunction(() => require('${ requirePathForHostedJs(requirePath) }'), '${ handlerName }'${ wrappersArg }),`,
     );
   }
 
@@ -77,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/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, Authorization, 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.7",
+  "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"
   }
 }