@foxtware/mineral 0.1.0 → 0.1.1

package/server.js

@@ -1,45 +1,100 @@
-require('dotenv').config();
-
 const fs = require('fs');
-const path = require('path');
 const http = require('http');
 const { respondJson, errorToReadable, getRequestBody, argsFromBody, funcApi } = require('./server.utils');
+const { getWorkspace, setWorkspace, loadWorkspaceEnv, toAbsolutePath } = require('./api/workspace');
+
+const MINERAL_API_DIR = `${ __dirname }/api`;
+
+// --- Config ---
+
+const splitCommaList = (value = '') => value
+  .split(',')
+  .map((item) => item.trim())
+  .filter(Boolean);
+
+const readCliFlag = (flag) => {
+  const args = process.argv.slice(2);
+  const equalsPrefix = `${ flag }=`;
+
+  for (let index = 0; index < args.length; index++) {
+    if (args[index].startsWith(equalsPrefix)) {
+      return args[index].slice(equalsPrefix.length);
+    }
+
+    if (args[index] === flag) {
+      return args[index + 1];
+    }
+  }
+};
+
+const getApiDirs = (options = {}) => {
+  if (options.api_dirs) {
+    return options.api_dirs;
+  }
+
+  const fromCli = readCliFlag('--api_dirs');
+  if (fromCli) {
+    return splitCommaList(fromCli);
+  }
+
+  if (process.env.MINERAL_API_DIRS) {
+    return splitCommaList(process.env.MINERAL_API_DIRS);
+  }
+
+  return [];
+};
+
+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 apiDirectory = path.join(__dirname, 'api');
+// --- Handler discovery ---
 
-const shouldSkipApiFile = (fileName) => {
+const isHandlerFile = (fileName) => {
   if (!fileName.endsWith('.js')) {
-    return true;
+    return false;
   }
 
   if (fileName.startsWith('_')) {
-    return true;
+    return false;
   }
 
   if (fileName.endsWith('.utils.js')) {
-    return true;
+    return false;
   }
 
-  const skippedFiles = new Set([
-    'utils.js',
-    'validators.js',
-  ]);
+  return true;
+};
 
-  return skippedFiles.has(fileName);
+const routeNameFromFile = (filePath) => {
+  const fileName = filePath.split('/').pop();
+  return fileName.slice(0, -3);
 };
 
-const walkFilesRecursive = (directory) => {
-  const entries = fs.readdirSync(directory, { withFileTypes: true });
+const listJsFiles = (directory) => {
+  if (!fs.existsSync(directory)) {
+    return [];
+  }
+
   const files = [];
+  const entries = fs.readdirSync(directory, { withFileTypes: true });
 
   for (const entry of entries) {
-    const entryPath = path.join(directory, entry.name);
+    const entryPath = `${ directory }/${ entry.name }`;
+
     if (entry.isDirectory()) {
-      files.push(...walkFilesRecursive(entryPath));
+      files.push(...listJsFiles(entryPath));
       continue;
     }
 
-    if (entry.isFile()) {
+    if (entry.isFile() && isHandlerFile(entry.name)) {
       files.push(entryPath);
     }
   }
@@ -47,92 +102,105 @@ const walkFilesRecursive = (directory) => {
   return files;
 };
 
-const loadHandlers = () => {
-  const files = walkFilesRecursive(apiDirectory).filter((filePath) => !shouldSkipApiFile(path.basename(filePath)));
-  const routeToHandler = new Map();
+const directoriesToScan = ({
+  workspace,
+  api_dirs,
+}) => {
+  const extraDirs = api_dirs.map((dir) => (
+    dir.startsWith('/')
+      ? dir
+      : `${ workspace }/${ dir }`
+  ));
+
+  return [MINERAL_API_DIR, ...extraDirs];
+};
 
-  for (const filePath of files) {
-    const moduleExports = require(filePath);
-    if (!moduleExports || typeof moduleExports !== 'object') {
-      continue;
-    }
+const getFuncApiConfig = ({
+  moduleExports,
+  routeName,
+}) => {
+  const { funcApiConfig } = moduleExports;
+  if (!funcApiConfig || typeof funcApiConfig !== 'object') {
+    return undefined;
+  }
 
-    const fileBaseName = path.basename(filePath, '.js');
-    const exportedValue = moduleExports[fileBaseName];
+  if (funcApiConfig[routeName]) {
+    return funcApiConfig[routeName];
+  }
 
-    if (typeof exportedValue !== 'function') {
-      continue;
-    }
+  const exportNames = Object.keys(moduleExports).filter((key) => key !== 'funcApiConfig');
+  const configIsShared = !exportNames.some((name) => funcApiConfig[name]);
 
-    const {
-      funcApiConfig,
-    } = moduleExports;
-    const functionExportNames = Object.entries(moduleExports)
-      .filter(([exportName, exportValue]) => exportName !== 'funcApiConfig' && typeof exportValue === 'function')
-      .map(([exportName]) => exportName);
-
-    const getFuncApiConfigForExport = (exportName) => {
-      if (!funcApiConfig || typeof funcApiConfig !== 'object') {
-        return undefined;
-      }
-
-      const configByExportName = funcApiConfig[exportName];
-      if (configByExportName && typeof configByExportName === 'object' && !Array.isArray(configByExportName)) {
-        return configByExportName;
-      }
-
-      // If config isn't keyed by function names and this export matches the filename,
-      // treat funcApiConfig as the config for that function.
-      const configIsKeyedByFunctionName = functionExportNames.some((functionExportName) => funcApiConfig[functionExportName] !== undefined);
-      if (!configIsKeyedByFunctionName && exportName === fileBaseName) {
-        return funcApiConfig;
-      }
-    };
-
-    const exportFuncApiConfig = getFuncApiConfigForExport(fileBaseName);
-    const handler = exportFuncApiConfig
-      ? funcApi(exportedValue, exportFuncApiConfig)
-      : exportedValue;
-
-    const routePath = `/${ fileBaseName }`;
-    if (routeToHandler.has(routePath)) {
-      const existing = routeToHandler.get(routePath);
-      throw new Error(`Duplicate handler route '${ routePath }' from ${ filePath } and ${ existing.filePath }`);
-    }
+  if (configIsShared) {
+    return funcApiConfig;
+  }
+};
 
-    routeToHandler.set(routePath, {
-      filePath,
-      exportName: fileBaseName,
-      handler,
-      usesFuncApi: Boolean(exportFuncApiConfig),
-    });
+const addHandlerFromFile = (filePath, handlers) => {
+  const moduleExports = require(filePath);
+  if (!moduleExports || typeof moduleExports !== 'object') {
+    return;
+  }
+
+  const routeName = routeNameFromFile(filePath);
+  const handlerFn = moduleExports[routeName];
+  if (typeof handlerFn !== 'function') {
+    return;
+  }
+
+  const funcApiConfig = getFuncApiConfig({
+    moduleExports,
+    routeName,
+  });
+
+  const route = `/${ routeName }`;
+  if (handlers.has(route)) {
+    const existing = handlers.get(route);
+    throw new Error(`Duplicate route '${ route }' from ${ filePath } and ${ existing.filePath }`);
   }
 
-  return routeToHandler;
+  handlers.set(route, {
+    filePath,
+    routeName,
+    handler: funcApiConfig ? funcApi(handlerFn, funcApiConfig) : handlerFn,
+    usesFuncApi: Boolean(funcApiConfig),
+  });
 };
 
-const handlers = loadHandlers();
+const loadHandlers = (config) => {
+  const handlers = new Map();
+
+  for (const directory of directoriesToScan(config)) {
+    for (const filePath of listJsFiles(directory)) {
+      addHandlerFromFile(filePath, handlers);
+    }
+  }
 
-const server = http.createServer(async (req, res) => {
+  return handlers;
+};
+
+// --- HTTP ---
+
+const createServer = (handlers) => http.createServer(async (req, res) => {
   if (req.method === 'GET' && req.url === '/') {
-    const routes = Array.from(handlers.keys()).sort();
     respondJson(res, 200, {
       ok: true,
       data: {
-        routes,
+        routes: [...handlers.keys()].sort(),
+        workspace: getWorkspace(),
       },
     });
     return;
   }
 
-  const pathOnly = (req.url || '/').split('?')[0];
-  const matchedHandler = handlers.get(pathOnly);
-  if (!matchedHandler) {
+  const route = (req.url || '/').split('?')[0];
+  const handler = handlers.get(route);
+  if (!handler) {
     respondJson(res, 404, {
       ok: false,
       error: {
         code: 'NOT_FOUND',
-        message: `No handler found for route ${ pathOnly }`,
+        message: `No handler found for route ${ route }`,
       },
     });
     return;
@@ -141,19 +209,12 @@ const server = http.createServer(async (req, res) => {
   try {
     const body = await getRequestBody(req);
     const args = argsFromBody(body);
-    const result = matchedHandler.usesFuncApi
-      ? await matchedHandler.handler({
-        req,
-        res,
-        body,
-        args,
-      })
-      : await matchedHandler.handler(...args);
+    const result = handler.usesFuncApi
+      ? await handler.handler({ req, res, body, args })
+      : await handler.handler(...args);
 
     if (result === undefined) {
-      respondJson(res, 200, {
-        ok: true,
-      });
+      respondJson(res, 200, { ok: true });
       return;
     }
 
@@ -170,25 +231,64 @@ const server = http.createServer(async (req, res) => {
   }
 });
 
-const startServer = ({
-  port = process.env.PORT || 8000,
-} = {}) => {
-  server.listen(port, () => {
-    console.log(`Mineral server running on port ${ port }`);
-    console.log('Registered routes:');
-    for (const route of Array.from(handlers.keys()).sort()) {
-      console.log(route);
-    }
-  });
+// --- Start ---
+
+let server = null;
+let handlers = null;
+
+const logStartup = ({
+  port,
+  workspace,
+  api_dirs,
+  handlers: routeHandlers,
+}) => {
+  console.log(`Mineral server running on port ${ port }`);
+  console.log(`Workspace: ${ workspace }`);
+
+  if (api_dirs.length) {
+    console.log('Extra API dirs:', api_dirs.join(', '));
+  }
+
+  console.log('Registered routes:');
+  for (const route of [...routeHandlers.keys()].sort()) {
+    console.log(route);
+  }
+};
+
+const startServer = (options = {}) => {
+  const config = getConfig(options);
+
+  setWorkspace(config.workspace);
+  loadWorkspaceEnv();
+
+  handlers = loadHandlers(config);
+  server = createServer(handlers);
+
+  server.listen(config.port, () => logStartup({
+    ...config,
+    handlers,
+  }));
 
   return server;
 };
 
 module.exports = {
-  server,
-  handlers,
-  loadHandlers,
   startServer,
+  loadHandlers,
+  get server() {
+    if (!server) {
+      startServer();
+    }
+
+    return server;
+  },
+  get handlers() {
+    if (!handlers) {
+      startServer();
+    }
+
+    return handlers;
+  },
 };
 
 if (require.main === module) {