From d25b4e8bf54dd8bef5bee0a8691110988fe0eeec Mon Sep 17 00:00:00 2001 From: hlegay Date: Tue, 30 Dec 2025 21:13:47 +0100 Subject: [PATCH] chore: remove ramda --- src/app.js | 33 ++++---- src/configuration.js | 11 --- src/logger.js | 75 ++++++++----------- src/manager/http-server/index.js | 21 +++--- src/manager/http-server/middlewares/error.js | 1 - .../http-server/middlewares/notFound.js | 1 - .../http-server/middlewares/notSupported.js | 1 - src/manager/http-server/middlewares/render.js | 38 +++++----- src/manager/initManager.js | 27 ++++--- src/manager/queue/jobCompletedHandler.js | 21 ++---- src/manager/queue/jobFailedHandler.js | 36 ++++----- src/manager/queue/utils.js | 1 - src/manager/requestRegistry.js | 10 --- src/processHandlers.js | 28 +++---- src/queue.js | 5 -- src/worker/initWorker.js | 23 +++--- src/worker/queue/processHandler.js | 2 - .../renderers/chrome/browserProvider.js | 10 --- .../renderers/chrome/browserRequestHandler.js | 9 --- src/worker/renderers/chrome/renderer.js | 5 +- src/worker/scriptProvider.js | 47 ++++-------- 21 files changed, 143 insertions(+), 262 deletions(-) diff --git a/src/app.js b/src/app.js index aeb6e492..ad328e18 100644 --- a/src/app.js +++ b/src/app.js @@ -1,25 +1,20 @@ -import { call, ifElse, juxt, pipe } from 'ramda' import initManager from './manager' import initWorker from './worker' import setupProcessHandlers from './processHandlers' -// initApp :: (Configuration, Logger, Queue) => _ -export default (configuration, logger, queue) => call(pipe( - juxt([ - ifElse( - () => configuration.manager.enabled, - () => initManager(configuration, logger, queue), - () => () => {}, // Empty graceful shutdown function - ), - ifElse( - () => configuration.worker.enabled, - () => initWorker(configuration, logger, queue), - () => () => {}, // Empty graceful shutdown function - ), - ]), - ([ shutdownManager, shutdownWorker ]) => async () => { +export default (configuration, logger, queue) => { + const shutdownManager = configuration.manager.enabled + ? initManager(configuration, logger, queue) + : async () => {} + + const shutdownWorker = configuration.worker.enabled + ? initWorker(configuration, logger, queue) + : async () => {} + + const shutdownFunction = async () => { await shutdownWorker() await shutdownManager() - }, - shutdownFunction => setupProcessHandlers(logger, shutdownFunction), -)) + } + + return setupProcessHandlers(logger, shutdownFunction) +} diff --git a/src/configuration.js b/src/configuration.js index e9a278c3..c096108a 100644 --- a/src/configuration.js +++ b/src/configuration.js @@ -33,19 +33,14 @@ const DEFAULT_WORKER_RENDERER_CHROME_OPTIONS = [ '--use-gl=disabled', ] -// isDefined :: Mixed -> Boolean const isDefined = both(complement(isNil), complement(isEmpty)) -// isLogConfigurationValid :: Configuration -> Boolean const isLogConfigurationValid = compose(includes(__, validLogLevels), path(['log', 'level'])) -// isQueueConfigurationValid :: Configuration -> Boolean const isQueueConfigurationValid = compose(isDefined, path(['queue', 'redis_dsn'])) -// isManagerConfigurationValid :: Configuration -> Boolean const isManagerConfigurationValid = T -// isWorkerConfigurationValid :: Configuration -> Boolean const isWorkerConfigurationValid = pipe( path(['worker', 'renderer', 'redirections']), reduce( @@ -60,7 +55,6 @@ const isWorkerConfigurationValid = pipe( ), ) -// validate :: Configuration -> Boolean const validate = allPass([ isLogConfigurationValid, isQueueConfigurationValid, @@ -68,20 +62,16 @@ const validate = allPass([ isWorkerConfigurationValid, ]) -// stringToArray :: String -> String -> [String] const stringToArray = separator => pipe( split(separator), map(trim), filter(complement(anyPass([isNil, isEmpty]))), ) -// commaSeparatedStringToArray :: String -> [String] const commaSeparatedStringToArray = stringToArray(',') -// pipeSeparatedStringToArray :: String -> [String] const pipeSeparatedStringToArray = stringToArray('|') -// generate :: _ -> Configuration const generate = () => ({ log: { level: process.env.LOG_LEVEL ?? LEVEL_INFO, @@ -125,7 +115,6 @@ const generate = () => ({ }, }) -// createConfiguration :: _ -> Configuration export default pipe( generate, unless(validate, () => { throw new Error('Invalid configuration.') }), diff --git a/src/logger.js b/src/logger.js index 6da80a8b..b34e46ef 100644 --- a/src/logger.js +++ b/src/logger.js @@ -1,14 +1,3 @@ -import { F, always, equals, findIndex, gte, ifElse, pickAll } from 'ramda' - -/** - * @type Logger = { - * error :: String -> _, - * info :: String -> _, - * debug :: String -> _, - * warn :: String -> _, - * } - */ - export const LEVEL_ERROR = 'ERROR' export const LEVEL_WARN = 'WARN' export const LEVEL_INFO = 'INFO' @@ -21,50 +10,46 @@ export const levels = [ LEVEL_DEBUG, ] -// resolveLogLevelIndex :: String -> Number -const resolveLogLevelIndex = level => findIndex(equals(level), levels) +const resolveLogLevelIndex = level => levels.indexOf(level) -// loggerHead :: (String, String) -> Boolean -const shouldPrintLog = (loggerLevel, logLevel) => gte( - resolveLogLevelIndex(loggerLevel), - resolveLogLevelIndex(logLevel), +const shouldPrintLog = (loggerLevel, logLevel) => ( + resolveLogLevelIndex(loggerLevel) >= resolveLogLevelIndex(logLevel) ) -// loggerHead :: String-> String const loggerHead = type => `[${(new Date()).toISOString()}] ${type.toUpperCase()}:` -// error :: (String, Output) -> Function -const error = (level, output) => ifElse( - level => shouldPrintLog(level, LEVEL_ERROR), - () => (...args) => output.error(loggerHead(LEVEL_ERROR), ...args), - always(F), -)(level) +const noop = () => false + +const error = (level, output) => ( + shouldPrintLog(level, LEVEL_ERROR) + ? (...args) => output.error(loggerHead(LEVEL_ERROR), ...args) + : noop +) -// warn :: (String, Output) -> Function -const warn = (level, output) => ifElse( - level => shouldPrintLog(level, LEVEL_WARN), - () => (...args) => output.warn(loggerHead(LEVEL_WARN), ...args), - always(F), -)(level) +const warn = (level, output) => ( + shouldPrintLog(level, LEVEL_WARN) + ? (...args) => output.warn(loggerHead(LEVEL_WARN), ...args) + : noop +) -// info :: (String, Output) -> Function -const info = (level, output) => ifElse( - level => shouldPrintLog(level, LEVEL_INFO), - () => (...args) => output.info(loggerHead(LEVEL_INFO), ...args), - always(F), -)(level) +const info = (level, output) => ( + shouldPrintLog(level, LEVEL_INFO) + ? (...args) => output.info(loggerHead(LEVEL_INFO), ...args) + : noop +) -// debug :: (String, Output) -> Function -const debug = (level, output) => ifElse( - level => shouldPrintLog(level, LEVEL_DEBUG), - () => (...args) => output.log(loggerHead(LEVEL_DEBUG), ...args), - always(F), -)(level) +const debug = (level, output) => ( + shouldPrintLog(level, LEVEL_DEBUG) + ? (...args) => output.log(loggerHead(LEVEL_DEBUG), ...args) + : noop +) -// formatException :: Error -> String -export const formatException = e => JSON.stringify(pickAll(['code', 'message', 'stack'], e)) +export const formatException = e => JSON.stringify({ + code: e?.code, + message: e?.message, + stack: e?.stack, +}) -// createLogger :: (String, Output) -> Logger export default (level, output) => ({ error: error(level, output), info: info(level, output), diff --git a/src/manager/http-server/index.js b/src/manager/http-server/index.js index 43f005e0..7a6e3b7c 100644 --- a/src/manager/http-server/index.js +++ b/src/manager/http-server/index.js @@ -3,17 +3,18 @@ import attachNotFoundMiddleware from './middlewares/notFound' import attachNotSupportedMiddleware from './middlewares/notSupported' import attachRenderMiddleware from './middlewares/render' import express from 'express' -import { pipe } from 'ramda' -// createHttpServer => (Configuration, Logger, Queue, RequestRegistry) -> HttpServer -export default (configuration, logger, queue, requestRegistry) => pipe( - attachRenderMiddleware(configuration, logger, queue, requestRegistry), - attachNotFoundMiddleware, - attachNotSupportedMiddleware, - attachErrorMiddleware(logger), - app => app.listen( +export default (configuration, logger, queue, requestRegistry) => { + const app = express() + + attachRenderMiddleware(configuration, logger, queue, requestRegistry)(app) + attachNotFoundMiddleware(app) + attachNotSupportedMiddleware(app) + attachErrorMiddleware(logger)(app) + + return app.listen( configuration.manager.http_server.port, configuration.manager.http_server.host, () => logger.debug('Manager http server started.'), - ), -)(express()) + ) +} diff --git a/src/manager/http-server/middlewares/error.js b/src/manager/http-server/middlewares/error.js index 5ea40b37..982eded0 100644 --- a/src/manager/http-server/middlewares/error.js +++ b/src/manager/http-server/middlewares/error.js @@ -1,6 +1,5 @@ import { formatException } from '../../../logger' -// errorMiddleware :: Logger -> Express.Application -> Void export default logger => app => app.use((error, req, res, next) => { logger.error(formatException(error)) diff --git a/src/manager/http-server/middlewares/notFound.js b/src/manager/http-server/middlewares/notFound.js index 1df521c4..6f88064d 100644 --- a/src/manager/http-server/middlewares/notFound.js +++ b/src/manager/http-server/middlewares/notFound.js @@ -1,2 +1 @@ -// default :: Express.app -> Express.app export default app => app.get(/.*/, (req, res) => res.status(404).send()) diff --git a/src/manager/http-server/middlewares/notSupported.js b/src/manager/http-server/middlewares/notSupported.js index bdc4ca11..eac26d46 100644 --- a/src/manager/http-server/middlewares/notSupported.js +++ b/src/manager/http-server/middlewares/notSupported.js @@ -1,2 +1 @@ -// default :: Express.app -> Express.app export default app => app.use((req, res) => res.status(405).send()) diff --git a/src/manager/http-server/middlewares/render.js b/src/manager/http-server/middlewares/render.js index 0bb7a3d0..1c0a88b5 100644 --- a/src/manager/http-server/middlewares/render.js +++ b/src/manager/http-server/middlewares/render.js @@ -1,23 +1,21 @@ -import { call, complement, compose, ifElse, isNil, path, pipe } from 'ramda' import { DEFAULT_JOB_OPTIONS } from '../../../queue' -// default :: (Configuration, Logger, Queue, RequestRegistry) -> Express.app -> Express.app export default (configuration, logger, queue, requestRegistry) => app => - app.get('/render', (req, res, next) => call(pipe( - () => logger.debug(`Render request for url "${req.query.url}" started.`), - ifElse( - () => compose(complement(isNil), path(['query', 'url']))(req), - pipe( - () => requestRegistry.add(req, res, next), - jobId => queue.add({ - url: req.query.url, - queuedAt: Date.now(), - }, { - ...DEFAULT_JOB_OPTIONS, - timeout: configuration.queue.job.timeout, - jobId, - }), - ), - () => res.status(400).end('Missing url query parameter.'), - ), - ))) + app.get('/render', (req, res, next) => { + logger.debug(`Render request for url "${req.query.url}" started.`) + + if (req.query?.url == null) { + return res.status(400).end('Missing url query parameter.') + } + + const jobId = requestRegistry.add(req, res, next) + + return queue.add({ + url: req.query.url, + queuedAt: Date.now(), + }, { + ...DEFAULT_JOB_OPTIONS, + timeout: configuration.queue.job.timeout, + jobId, + }) + }) diff --git a/src/manager/initManager.js b/src/manager/initManager.js index 637d06c2..c812ea6f 100644 --- a/src/manager/initManager.js +++ b/src/manager/initManager.js @@ -1,22 +1,21 @@ -import { call, pipe, tap } from 'ramda' import createRequestRegistry from './requestRegistry' import initHttpServer from './http-server' import queueJobCompletedHandler from './queue/jobCompletedHandler' import queueJobFailedHandler from './queue/jobFailedHandler' -// initManager :: (Configuration, Logger, Queue) -> Function -export default (configuration, logger, queue) => call(pipe( - tap(() => logger.debug('Initializing manager.')), - () => createRequestRegistry(), - tap(requestRegistry => queue.on('global:completed', queueJobCompletedHandler(logger, queue, requestRegistry))), - tap(requestRegistry => queue.on('global:failed', queueJobFailedHandler(logger, queue, requestRegistry))), - requestRegistry => initHttpServer(configuration, logger, queue, requestRegistry), - tap(() => logger.debug('Manager initialized.')), - // Returns a function to be used to gracefully shutdown the manager - httpServer => async () => { - logger.debug('Gracefully shutting down manager') +export default (configuration, logger, queue) => { + logger.debug('Initializing manager.') + const requestRegistry = createRequestRegistry() + + queue.on('global:completed', queueJobCompletedHandler(logger, queue, requestRegistry)) + queue.on('global:failed', queueJobFailedHandler(logger, queue, requestRegistry)) + const httpServer = initHttpServer(configuration, logger, queue, requestRegistry) + logger.debug('Manager initialized.') + + return async () => { + logger.debug('Gracefully shutting down manager') await queue.close() await httpServer.close() - }, -)) + } +} diff --git a/src/manager/queue/jobCompletedHandler.js b/src/manager/queue/jobCompletedHandler.js index c54fb75f..68b3b68e 100644 --- a/src/manager/queue/jobCompletedHandler.js +++ b/src/manager/queue/jobCompletedHandler.js @@ -1,17 +1,12 @@ -import { juxt, when } from 'ramda' import { resolveJobDuration } from './utils' -// jobCompletedHandler :: (Logger, Queue, RequestRegistry) -> Function -export default (logger, queue, requestRegistry) => (jobId, result) => when( - jobId => requestRegistry.has(jobId), - juxt([ - jobId => requestRegistry.complete(jobId, JSON.parse(result)), - async jobId => { - const job = await queue.getJob(jobId) +export default (logger, queue, requestRegistry) => async (jobId, result) => { + if (!requestRegistry.has(jobId)) return + requestRegistry.complete(jobId, JSON.parse(result)) - logger.info(`${jobId} ${job.data.url} 200 ${resolveJobDuration(job)}`) + const job = await queue.getJob(jobId) + if (!job) return - job.remove() - }, - ]), -)(jobId) + logger.info(`${jobId} ${job.data.url} 200 ${resolveJobDuration(job)}`) + await job.remove() +} diff --git a/src/manager/queue/jobFailedHandler.js b/src/manager/queue/jobFailedHandler.js index 16337c7a..76f60f02 100644 --- a/src/manager/queue/jobFailedHandler.js +++ b/src/manager/queue/jobFailedHandler.js @@ -1,27 +1,19 @@ -import { T, always, cond, juxt, test, when } from 'ramda' import { resolveJobDuration } from './utils' -// resolveStatusCodeFromError :: String -> Integer -const resolveStatusCodeFromError = cond([ - [error => test(/timeout/i, error), always(504)], - [error => test(/timed out/i, error), always(504)], - [T, always(500)], -]) +const resolveStatusCodeFromError = error => { + if (/timeout/i.test(error) || /timed out/i.test(error)) return 504 + return 500 +} -// jobFailedHandler :: (Logger, Queue, RequestRegistry) -> Function -export default (logger, queue, requestRegistry) => (jobId, error) => when( - jobId => requestRegistry.has(jobId), - juxt([ - jobId => requestRegistry.fail( - jobId, - resolveStatusCodeFromError(error), - ), - async jobId => { - const job = await queue.getJob(jobId) +export default (logger, queue, requestRegistry) => async (jobId, error) => { + if (!requestRegistry.has(jobId)) return - logger.error(`${jobId} ${job.data.url} ${resolveStatusCodeFromError(error)} ${resolveJobDuration(job)} ${error}`) + const statusCode = resolveStatusCodeFromError(error) + requestRegistry.fail(jobId, statusCode) - job.remove() - }, - ]), -)(jobId) + const job = await queue.getJob(jobId) + if (!job) return + + logger.error(`${jobId} ${job.data.url} ${statusCode} ${resolveJobDuration(job)} ${error}`) + await job.remove() +} diff --git a/src/manager/queue/utils.js b/src/manager/queue/utils.js index c87876d4..ccde408b 100644 --- a/src/manager/queue/utils.js +++ b/src/manager/queue/utils.js @@ -1,2 +1 @@ -// resolveJobDuration :: Job -> Integer export const resolveJobDuration = job => (Date.now() - job.data.queuedAt) / 1000 diff --git a/src/manager/requestRegistry.js b/src/manager/requestRegistry.js index 29adbbfc..0c5f9366 100644 --- a/src/manager/requestRegistry.js +++ b/src/manager/requestRegistry.js @@ -1,15 +1,5 @@ import { v4 as uuidv4 } from 'uuid' -/** - * @type RequestRegistry = { - * has :: String -> Boolean, - * add :: (Request, Response, Next) -> String, - * complete :: (String, String) -> _, - * fail :: (String, String) -> _, - * } - */ - -// createRequestRegistry :: () -> RequestRegistry export default () => ({ _requests: {}, diff --git a/src/processHandlers.js b/src/processHandlers.js index 84544819..806d1089 100644 --- a/src/processHandlers.js +++ b/src/processHandlers.js @@ -1,31 +1,25 @@ import { formatException } from './logger' -import { pipe } from 'ramda' -// onUncaughtException :: Logger -> Error -> void -const onUncaughtException = logger => pipe( - error => logger.error( +const onUncaughtException = logger => error => { + logger.error( 'An exception has been thrown but not properly caught. Exiting...', formatException(error), - ), - () => process.exit(1), -) + ) + process.exit(1) +} -// setUpUncaughtExceptionHandler :: Logger -> void const setUpUncaughtExceptionHandler = logger => process.on('uncaughtException', onUncaughtException(logger)) -// onUnhandledRejection :: Logger -> Error -> void const onUnhandledRejection = logger => error => logger.error( 'A promise has been rejected without being properly handled.', formatException(error), ) -// setUpUnhandledRejectionHandler :: Logger -> void const setUpUnhandledRejectionHandler = logger => process.on('unhandledRejection', onUnhandledRejection(logger)) -// performGracefulShutdown :: (Logger, Function) -> void const performGracefulShutdown = async (logger, shutdownFunction) => { logger.info(`Graceful shutdown started.`) @@ -33,26 +27,22 @@ const performGracefulShutdown = async (logger, shutdownFunction) => { process.exit(0) } -// onTerminationSignal :: (Logger, Function, String) -> void -export const onTerminationSignal = (logger, shutdownFunction, signal) => pipe( - () => logger.info(`${signal} received.`), - () => performGracefulShutdown(logger, shutdownFunction), -) +export const onTerminationSignal = (logger, shutdownFunction, signal) => () => { + logger.info(`${signal} received.`) + performGracefulShutdown(logger, shutdownFunction) +} -// setUpOnSIGINTHandler :: (Logger, Function) -> void // SIGINT signal is sent if you run the application from your terminal and you // hit ctrl+c const setUpOnSIGINTHandler = (logger, shutdownFunction) => process.on('SIGINT', onTerminationSignal(logger, shutdownFunction, 'SIGINT')) -// setUpOnSIGTERMHandler :: (Logger, Function) -> void // SIGTERM signal is sent by Docker when the container has been requested to // stop (stop, upgrade, etc...). If after x seconds the container doesn't stop // a SIGKILL signal is sent and the container immediately stop. const setUpOnSIGTERMHandler = (logger, shutdownFunction) => process.on('SIGTERM', onTerminationSignal(logger, shutdownFunction, 'SIGTERM')) -// setupProcessHandlers :: (Logger, Function) -> void export default (logger, shutdownFunction) => { setUpUncaughtExceptionHandler(logger) setUpUnhandledRejectionHandler(logger) diff --git a/src/queue.js b/src/queue.js index 697d4d6f..eb8091a2 100644 --- a/src/queue.js +++ b/src/queue.js @@ -1,9 +1,5 @@ import Bull from 'bull' -/** - * @type Queue = Bull.Queue - */ - export const DEFAULT_QUEUE_OPTIONS = { maxRetriesPerRequest: null, enableReadyCheck: false, @@ -13,5 +9,4 @@ export const DEFAULT_JOB_OPTIONS = { attempts: 1, } -// createQueue :: (String, Object) -> Queue export default (redisDsn, options = {}) => new Bull('request-queue', redisDsn, { ...DEFAULT_QUEUE_OPTIONS, ...options }) diff --git a/src/worker/initWorker.js b/src/worker/initWorker.js index 8f0c9d09..41ee401c 100644 --- a/src/worker/initWorker.js +++ b/src/worker/initWorker.js @@ -1,19 +1,14 @@ -import { call, pipe, tap } from 'ramda' import createScriptProvider from './scriptProvider' import queueProcessHandler from './queue/processHandler' -// initWorker :: (Configuration, Logger, Queue) -> Function -export default (configuration, logger, queue) => call(pipe( - tap(() => logger.debug('Initializing worker.')), - tap(pipe( - () => createScriptProvider(), - scriptProvider => queue.process(1, queueProcessHandler(configuration, logger, scriptProvider)), - )), - tap(() => logger.debug('Worker initialized.')), - // Returns a function to be used to gracefully shutdown the worker - () => async () => { - logger.debug('Gracefully shutting down worker') +export default (configuration, logger, queue) => { + logger.debug('Initializing worker.') + const scriptProvider = createScriptProvider() + queue.process(1, queueProcessHandler(configuration, logger, scriptProvider)) + logger.debug('Worker initialized.') + return async () => { + logger.debug('Gracefully shutting down worker') await queue.close() - }, -)) + } +} diff --git a/src/worker/queue/processHandler.js b/src/worker/queue/processHandler.js index d88af8ab..260fcb27 100644 --- a/src/worker/queue/processHandler.js +++ b/src/worker/queue/processHandler.js @@ -1,10 +1,8 @@ import render from '../renderers/chrome' -// isJobExpired :: (Configuration, Job) -> Boolean const isJobExpired = (configuration, job) => Date.now() - job.data.queuedAt > configuration.queue.job.stale_timeout -// queueProcessHandler :: (Configuration, Logger, ScriptProvider) -> Function export default (configuration, logger, scriptProvider) => async job => { if (isJobExpired(configuration, job)) { throw new Error(`Job "${job.id}" with url "${job.data.url}" timed out."`) diff --git a/src/worker/renderers/chrome/browserProvider.js b/src/worker/renderers/chrome/browserProvider.js index 3c270c64..9efdc485 100644 --- a/src/worker/renderers/chrome/browserProvider.js +++ b/src/worker/renderers/chrome/browserProvider.js @@ -1,16 +1,6 @@ import puppeteer from 'puppeteer-core' import treekill from 'tree-kill' -/** - * @type BrowserProvider = { - * getInstance() :: () -> Puppeteer.Browser, - * cleanupInstance :: () -> _, - * } - * - * @type BrowserInstance = Puppeteer.Browser - */ - -// getBrowserProvider :: (Configuration, Logger) -> BrowserProvider export default (configuration, logger) => ({ _logger: logger, _instance: null, diff --git a/src/worker/renderers/chrome/browserRequestHandler.js b/src/worker/renderers/chrome/browserRequestHandler.js index 61fa9689..8af716e6 100644 --- a/src/worker/renderers/chrome/browserRequestHandler.js +++ b/src/worker/renderers/chrome/browserRequestHandler.js @@ -1,39 +1,32 @@ import { T, anyPass, complement, cond, equals, find, ifElse, isNil, pipe, replace, tap, test } from 'ramda' -// resolveRequestDomain :: Request -> String const resolveRequestDomain = req => req.url().match(/^(https?:\/\/)?(?[^/]+)/).groups.host -// isMatchingDomain :: String -> String -> Boolean const isMatchingDomain = input => value => test(new RegExp(`^${replace('*', '.*', value)}$`, 'i'), input) -// isRequestDomainAuthorized :: [String] -> Request -> Boolean const isRequestDomainAuthorized = authorizedRequestDomains => pipe( resolveRequestDomain, domain => find(isMatchingDomain(domain), authorizedRequestDomains), complement(isNil), ) -// isMatchingResourceType :: String -> String -> Boolean const isMatchingResourceType = input => anyPass([ equals('*'), equals(input), ]) -// isRequestResourceAuthorized :: [String] -> Request -> Boolean const isRequestResourceAuthorized = authorizedRequestResources => pipe( req => req.resourceType(), resourceType => find(isMatchingResourceType(resourceType), authorizedRequestResources), complement(isNil), ) -// getRedirection :: [Object] -> Request -> Object|Null const getRedirection = redirections => req => find( ({ from }) => test(new RegExp(`^${from}`, 'i'), req.url()), redirections, ) -// allowRequest :: (logger, [Object]) -> Request -> _ const allowRequest = (logger, redirections) => req => pipe( getRedirection(redirections), ifElse( @@ -47,10 +40,8 @@ const allowRequest = (logger, redirections) => req => pipe( ), )(req) -// blockRequest :: (Logger, String) -> Request -> _ const blockRequest = (logger, reason) => req => logger.debug(`Abort request ${req.url()} because of non authorized ${reason}.`) || req.abort() -// browserRequestHandler :: (Configuration, Logger) => Puppeteer.Request => _ export default (configuration, logger) => cond([ [ complement(isRequestDomainAuthorized(configuration.worker.renderer.authorized_request_domains)), diff --git a/src/worker/renderers/chrome/renderer.js b/src/worker/renderers/chrome/renderer.js index dc546164..68d8701a 100644 --- a/src/worker/renderers/chrome/renderer.js +++ b/src/worker/renderers/chrome/renderer.js @@ -2,9 +2,7 @@ import { POST_RENDER_SCRIPT_KEY } from '../../scriptProvider' import browserRequestHandler from './browserRequestHandler' import { formatException } from './../../../logger' import getBrowserProvider from './browserProvider' -import { reduce } from 'ramda' -// renderPageContent :: (Configuration, Logger, ScriptProvier, BrowserInstance, String) -> RenderedPage const renderPageContent = async (configuration, logger, scriptProvider, browserInstance, url) => { const page = await browserInstance.newPage() @@ -25,7 +23,7 @@ const renderPageContent = async (configuration, logger, scriptProvider, browserI return arg }), )) - const text = reduce((acc, cur) => acc += acc !== '' ? `, ${cur}` : cur, '', args) + const text = args.map(arg => String(arg)).join(', ') logger.debug(`CONSOLE.${msg.type()}: ${msg.text()}\n${text}`) }) @@ -40,7 +38,6 @@ const renderPageContent = async (configuration, logger, scriptProvider, browserI return await page.content() } -// render :: (Configuration, Logger, ScriptProvider) -> String export default (configuration, logger, scriptProvider) => async url => { const browserProvider = getBrowserProvider(configuration, logger) const browserInstance = await browserProvider.getInstance() diff --git a/src/worker/scriptProvider.js b/src/worker/scriptProvider.js index 4c9e5f2b..63cee242 100644 --- a/src/worker/scriptProvider.js +++ b/src/worker/scriptProvider.js @@ -1,49 +1,34 @@ -import { __, includes, pipe } from 'ramda' import fs from 'fs' import path from 'path' import vm from 'vm' -/** - * @type ScriptProvider = { - * get :: String -> Function, - * } - */ - export const POST_RENDER_SCRIPT_KEY = 'postRender' const VALID_SCRIPT_KEYS = [POST_RENDER_SCRIPT_KEY] -// isScriptKeyValid :: String -> Boolean -const isScriptKeyValid = includes(__, VALID_SCRIPT_KEYS) +const isScriptKeyValid = key => VALID_SCRIPT_KEYS.includes(key) -// resolveScriptPath :: String -> String const resolveScriptPath = key => path.join(process.cwd(), `scripts/${key}.js`) -// resolveScriptContent :: String -> String -const resolveScriptContent = pipe( - resolveScriptPath, - scriptPath => fs.readFileSync(scriptPath, { encoding: 'utf8', flag: 'r' }), -) - -// resolveScript :: String -> Function -const resolveScript = pipe( - resolveScriptContent, - scriptContent => { - const script = new vm.Script(scriptContent) +const resolveScriptContent = key => { + const scriptPath = resolveScriptPath(key) + return fs.readFileSync(scriptPath, { encoding: 'utf8', flag: 'r' }) +} - const context = { script: null } - vm.createContext(context) +const resolveScript = key => { + const scriptContent = resolveScriptContent(key) + const script = new vm.Script(scriptContent) + const context = { script: null } - script.runInContext(context) + vm.createContext(context) + script.runInContext(context) - if (typeof context.script !== 'function') { - throw new Error(`The script provided doesn't set the script variable as a valid function.`) - } + if (typeof context.script !== 'function') { + throw new Error(`The script provided doesn't set the script variable as a valid function.`) + } - return context.script - }, -) + return context.script +} -// createScriptProvider :: () -> ScriptProvider export default () => ({ _scripts: {},