@foxtware/mineral 0.1.0

package/server.js

@@ -0,0 +1,196 @@
+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 apiDirectory = path.join(__dirname, 'api');
+
+const shouldSkipApiFile = (fileName) => {
+  if (!fileName.endsWith('.js')) {
+    return true;
+  }
+
+  if (fileName.startsWith('_')) {
+    return true;
+  }
+
+  if (fileName.endsWith('.utils.js')) {
+    return true;
+  }
+
+  const skippedFiles = new Set([
+    'utils.js',
+    'validators.js',
+  ]);
+
+  return skippedFiles.has(fileName);
+};
+
+const walkFilesRecursive = (directory) => {
+  const entries = fs.readdirSync(directory, { withFileTypes: true });
+  const files = [];
+
+  for (const entry of entries) {
+    const entryPath = path.join(directory, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...walkFilesRecursive(entryPath));
+      continue;
+    }
+
+    if (entry.isFile()) {
+      files.push(entryPath);
+    }
+  }
+
+  return files;
+};
+
+const loadHandlers = () => {
+  const files = walkFilesRecursive(apiDirectory).filter((filePath) => !shouldSkipApiFile(path.basename(filePath)));
+  const routeToHandler = new Map();
+
+  for (const filePath of files) {
+    const moduleExports = require(filePath);
+    if (!moduleExports || typeof moduleExports !== 'object') {
+      continue;
+    }
+
+    const fileBaseName = path.basename(filePath, '.js');
+    const exportedValue = moduleExports[fileBaseName];
+
+    if (typeof exportedValue !== 'function') {
+      continue;
+    }
+
+    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 }`);
+    }
+
+    routeToHandler.set(routePath, {
+      filePath,
+      exportName: fileBaseName,
+      handler,
+      usesFuncApi: Boolean(exportFuncApiConfig),
+    });
+  }
+
+  return routeToHandler;
+};
+
+const handlers = loadHandlers();
+
+const server = 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,
+      },
+    });
+    return;
+  }
+
+  const pathOnly = (req.url || '/').split('?')[0];
+  const matchedHandler = handlers.get(pathOnly);
+  if (!matchedHandler) {
+    respondJson(res, 404, {
+      ok: false,
+      error: {
+        code: 'NOT_FOUND',
+        message: `No handler found for route ${ pathOnly }`,
+      },
+    });
+    return;
+  }
+
+  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);
+
+    if (result === undefined) {
+      respondJson(res, 200, {
+        ok: true,
+      });
+      return;
+    }
+
+    respondJson(res, 200, result);
+  } catch (error) {
+    respondJson(res, 500, {
+      ok: false,
+      error: {
+        code: 'UNHANDLED_ERROR',
+        message: 'Unhandled server error.',
+        details: errorToReadable(error),
+      },
+    });
+  }
+});
+
+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);
+    }
+  });
+
+  return server;
+};
+
+module.exports = {
+  server,
+  handlers,
+  loadHandlers,
+  startServer,
+};
+
+if (require.main === module) {
+  startServer();
+}

package/server.utils.js

@@ -0,0 +1,228 @@
+const { logDeep } = require('./api/utils');
+const { StringDecoder } = require('string_decoder');
+
+const respondJson = (res, statusCode, payload) => {
+  logDeep(payload);
+  const body = JSON.stringify(payload);
+  res.writeHead(statusCode, {
+    'Content-Type': 'application/json',
+    'Content-Length': Buffer.byteLength(body),
+  });
+  res.end(body);
+};
+
+const errorToReadable = (error) => {
+  if (!error) {
+    return {
+      message: 'Unknown error',
+    };
+  }
+
+  if (typeof error === 'string') {
+    return {
+      message: error,
+    };
+  }
+
+  return {
+    name: error.name,
+    message: error.message,
+    stack: error.stack,
+  };
+};
+
+const getRequestBody = async (req) => {
+  if (req.method === 'GET' || req.method === 'HEAD') {
+    return undefined;
+  }
+
+  const decoder = new StringDecoder('utf8');
+
+  return await new Promise((resolve, reject) => {
+    let buffer = '';
+
+    req.on('data', (chunk) => {
+      buffer += decoder.write(chunk);
+    });
+
+    req.on('end', () => {
+      buffer += decoder.end();
+
+      if (!buffer.trim()) {
+        resolve(undefined);
+        return;
+      }
+
+      try {
+        resolve(JSON.parse(buffer));
+      } catch (error) {
+        reject(new Error(`Invalid JSON body: ${ error.message }`));
+      }
+    });
+
+    req.on('error', reject);
+  });
+};
+
+const argsFromBody = (body) => {
+  if (Array.isArray(body)) {
+    return body;
+  }
+
+  if (Array.isArray(body?.args)) {
+    return body.args;
+  }
+
+  if (body === undefined) {
+    return [];
+  }
+
+  return [body];
+};
+
+const mergeRequestContext = (requestContext, update) => {
+  if (!update || typeof update !== 'object') {
+    return requestContext;
+  }
+
+  return {
+    ...requestContext,
+    ...update,
+  };
+};
+
+const runRequestHandler = async (requestHandler, requestContext) => {
+  if (!requestHandler) {
+    return requestContext;
+  }
+
+  if (Array.isArray(requestHandler)) {
+    let updatedRequestContext = requestContext;
+    for (const requestHandlerStep of requestHandler) {
+      if (typeof requestHandlerStep !== 'function') {
+        throw new Error('requestHandler array only supports functions');
+      }
+      const stepOutput = await requestHandlerStep(updatedRequestContext);
+      updatedRequestContext = mergeRequestContext(updatedRequestContext, stepOutput);
+    }
+    return updatedRequestContext;
+  }
+
+  if (typeof requestHandler?.run !== 'function' && typeof requestHandler !== 'function') {
+    throw new Error('requestHandler must be a function, array of functions, or a Chain');
+  }
+
+  const handlerOutput = await requestHandler?.run(requestContext) || await requestHandler(requestContext);
+  return mergeRequestContext(requestContext, handlerOutput);
+};
+
+const funcApi = (func, config = {}) => {
+  const {
+    requestHandler,
+    argsWarden,
+    validators = [],
+    requestVerifiers = [],
+    bodyModifiers = [],
+    passThroughReq = false,
+    passThroughBody = false,
+  } = config;
+
+  const argNames = argsWarden?.argNames();
+
+  return async ({
+    req,
+    res,
+    body,
+    args,
+  }) => {
+    let requestContext = {
+      req,
+      res,
+      body,
+      args,
+    };
+
+    requestContext = await runRequestHandler(requestHandler, requestContext);
+    if (requestContext?.response !== undefined) {
+      return requestContext.response;
+    }
+
+    for (const requestVerifier of requestVerifiers) {
+      const verified = await requestVerifier(
+        requestContext.req,
+        requestContext.res,
+        requestContext.body,
+        requestContext,
+      );
+      if (!verified) {
+        return {
+          ok: false,
+          error: {
+            code: 'REQUEST_NOT_VERIFIED',
+            message: 'Request verification failed.',
+          },
+        };
+      }
+    }
+
+    let modifiedBody = requestContext.body;
+    for (const bodyModifier of bodyModifiers) {
+      modifiedBody = await bodyModifier(modifiedBody, requestContext.req, requestContext.res, requestContext);
+    }
+    requestContext.body = modifiedBody;
+
+    if (argsWarden) {
+      const rejectResponse = await argsWarden.responseIfRejectingArgs(
+        Object.fromEntries(argNames.map((argName) => [argName, modifiedBody?.[argName]])),
+        { ...modifiedBody },
+      );
+      if (rejectResponse) {
+        return rejectResponse;
+      }
+    }
+
+    for (const validator of validators) {
+      const valid = await validator(
+        modifiedBody,
+        requestContext.req,
+        requestContext.res,
+        requestContext,
+      );
+      if (!valid) {
+        return {
+          ok: false,
+          error: {
+            code: 'INVALID_BODY',
+            message: 'Request body failed validation.',
+          },
+        };
+      }
+    }
+
+    let callArgs = requestContext.args;
+    if (passThroughReq) {
+      callArgs = [requestContext.req];
+    } else if (passThroughBody) {
+      callArgs = [modifiedBody];
+    } else if (argNames?.length) {
+      callArgs = argNames.map((argName) => modifiedBody?.[argName]);
+
+      if (
+        !argNames.includes('options')
+        && modifiedBody?.options !== undefined
+      ) {
+        callArgs.push(modifiedBody.options);
+      }
+    }
+
+    return await func(...callArgs);
+  };
+};
+
+module.exports = {
+  respondJson,
+  errorToReadable,
+  getRequestBody,
+  argsFromBody,
+  funcApi,
+};

package/test.js

@@ -0,0 +1,19 @@
+const { shopifyOrdersGet } = require('./api/shopify/shopifyOrdersGet');
+
+const [
+  storeHandle,
+  apiKey,
+] = process.argv.slice(2);
+
+shopifyOrdersGet(
+  {
+    credsObject: {
+      STORE_HANDLE: storeHandle,
+      API_KEY: apiKey,
+    },
+  },
+).then((result) => {
+  console.log('result', result);
+});
+
+// node test.js a-b-c shpat_111111 1111