Node.js based forum software built for the modern web
'use strict';
const nconf = require('nconf');
const winston = require('winston');
const querystring = require('querystring');
const _ = require('lodash');
const chalk = require('chalk').default;
const translator = require('../translator');
const user = require('../user');
const privileges = require('../privileges');
const categories = require('../categories');
const plugins = require('../plugins');
const meta = require('../meta');
const middlewareHelpers = require('../middleware/helpers');
const utils = require('../utils');
const helpers = module.exports;
const relative_path = nconf.get('relative_path');
const url = nconf.get('url');
helpers.noScriptErrors = async function (req, res, error, httpStatus) {
if (req.body.noscript !== 'true') {
if (typeof error === 'string') {
winston.error(`${new Error(error).stack}`);
return res.status(httpStatus).send(error);
}
winston.error(`${new Error(JSON.stringify(error)).stack}`);
return res.status(httpStatus).json(error);
}
const middleware = require('../middleware');
const httpStatusString = httpStatus.toString();
await middleware.buildHeaderAsync(req, res);
res.status(httpStatus).render(httpStatusString, {
path: req.path,
loggedIn: req.loggedIn,
error: error,
returnLink: true,
title: `[[global:${httpStatusString}.title]]`,
});
};
helpers.terms = {
alltime: 'alltime',
daily: 'day',
weekly: 'week',
monthly: 'month',
};
helpers.buildQueryString = function (query, key, value) {
const queryObj = { ...query };
if (value) {
queryObj[key] = value;
} else {
delete queryObj[key];
}
delete queryObj._;
return Object.keys(queryObj).length ? `?${querystring.stringify(queryObj)}` : '';
};
helpers.addLinkTags = function (params) {
params.res.locals.linkTags = params.res.locals.linkTags || [];
const page = params.page > 1 ? `?page=${params.page}` : '';
params.res.locals.linkTags.push({
rel: 'canonical',
href: `${url}/${params.url}${page}`,
});
params.tags.forEach((rel) => {
rel.href = `${url}/${params.url}${rel.href}`;
params.res.locals.linkTags.push(rel);
});
};
helpers.buildFilters = function (url, filter, query) {
return [{
name: '[[unread:all-topics]]',
url: url + helpers.buildQueryString(query, 'filter', ''),
selected: filter === '',
filter: '',
icon: 'fa-book',
}, {
name: '[[unread:new-topics]]',
url: url + helpers.buildQueryString(query, 'filter', 'new'),
selected: filter === 'new',
filter: 'new',
icon: 'fa-clock-o',
}, {
name: '[[unread:watched-topics]]',
url: url + helpers.buildQueryString(query, 'filter', 'watched'),
selected: filter === 'watched',
filter: 'watched',
icon: 'fa-bell-o',
}, {
name: '[[unread:unreplied-topics]]',
url: url + helpers.buildQueryString(query, 'filter', 'unreplied'),
selected: filter === 'unreplied',
filter: 'unreplied',
icon: 'fa-reply',
}];
};
helpers.buildTerms = function (url, term, query) {
return [{
name: '[[recent:alltime]]',
url: url + helpers.buildQueryString(query, 'term', 'alltime'),
selected: term === 'alltime',
term: 'alltime',
}, {
name: '[[recent:day]]',
url: url + helpers.buildQueryString(query, 'term', 'daily'),
selected: term === 'day',
term: 'day',
}, {
name: '[[recent:week]]',
url: url + helpers.buildQueryString(query, 'term', 'weekly'),
selected: term === 'week',
term: 'week',
}, {
name: '[[recent:month]]',
url: url + helpers.buildQueryString(query, 'term', 'monthly'),
selected: term === 'month',
term: 'month',
}];
};
helpers.notAllowed = async function (req, res, error) {
({ error } = await plugins.hooks.fire('filter:helpers.notAllowed', { req, res, error }));
await plugins.hooks.fire('response:helpers.notAllowed', { req, res, error });
if (res.headersSent) {
return;
}
if (req.loggedIn || req.uid === -1) {
if (res.locals.isAPI) {
if (req.originalUrl.startsWith(`${relative_path}/api/v3`)) {
await helpers.formatApiResponse(403, res, error);
} else {
res.status(403).json({
path: req.path.replace(/^\/api/, ''),
loggedIn: req.loggedIn,
error: error,
title: '[[global:403.title]]',
bodyClass: middlewareHelpers.buildBodyClass(req, res),
});
}
} else {
const middleware = require('../middleware');
await middleware.buildHeaderAsync(req, res);
res.status(403).render('403', {
path: req.path,
loggedIn: req.loggedIn,
error,
title: '[[global:403.title]]',
});
}
} else if (res.locals.isAPI) {
req.session.returnTo = req.url.replace(/^\/api/, '');
await helpers.formatApiResponse(401, res, error);
} else {
req.session.returnTo = req.url;
res.redirect(`${relative_path}/login${req.path.startsWith('/admin') ? '?local=1' : ''}`);
}
};
helpers.redirect = function (res, url, permanent) {
// this is used by sso plugins to redirect to the auth route
// { external: '/auth/sso' } or { external: 'https://domain/auth/sso' }
if (url.hasOwnProperty('external')) {
if (!utils.isSafeHref(url.external)) {
winston.warn(`[security] Unsafe external redirect attempted: ${url.external}`);
url.external = '/';
}
const redirectUrl = prependRelativePath(url.external);
if (res.locals.isAPI) {
res.set('X-Redirect', encodeURIComponent(redirectUrl)).status(200).json({ external: redirectUrl });
} else {
res.redirect(permanent ? 308 : 307, redirectUrl);
}
return;
}
if (res.locals.isAPI) {
res.set('X-Redirect', encodeURIComponent(url)).status(200).json(url);
} else {
// Reject unsafe redirect URLs — fall back to home page
if (!helpers.normalizeReturnToPath(url)) {
winston.warn(`[security] Unsafe redirect attempted: ${url}`);
url = '/';
}
res.redirect(permanent ? 308 : 307, prependRelativePath(url));
}
};
helpers.normalizeReturnToPath = function (pathCandidate, { allowApi = true } = {}) {
if (typeof pathCandidate !== 'string') {
return '';
}
const raw = pathCandidate.trim();
let decoded;
let configuredUrl;
try {
decoded = decodeURIComponent(raw);
configuredUrl = new URL(nconf.get('url'));
} catch {
return '';
}
const rawIsAbsolute = /^[a-z][a-z\d+.-]*:/i.test(raw);
const decodedIsAbsolute = /^[a-z][a-z\d+.-]*:/i.test(decoded);
const rawPathCandidate = raw.split(/[?#]/, 1)[0];
const decodedPathCandidate = decoded.split(/[?#]/, 1)[0];
const hasControlCharacter = Array.from(decoded).some((character) => {
const codePoint = character.codePointAt(0);
return codePoint < 32 || codePoint === 127;
});
if (
!raw || raw.startsWith('//') || decoded.startsWith('//') ||
hasControlCharacter ||
rawPathCandidate.includes('\\') || decodedPathCandidate.includes('\\') ||
(!raw.startsWith('/') && !rawIsAbsolute) ||
(!decoded.startsWith('/') && !decodedIsAbsolute)
) {
return '';
}
let parsed;
let decodedParsed;
try {
parsed = new URL(raw, configuredUrl.origin);
decodedParsed = new URL(decoded, configuredUrl.origin);
} catch {
return '';
}
if (
parsed.origin !== configuredUrl.origin || decodedParsed.origin !== configuredUrl.origin ||
parsed.username || parsed.password || decodedParsed.username || decodedParsed.password
) {
return '';
}
const relativePath = nconf.get('relative_path') || '';
const isWithinRelativePath = pathname => !relativePath ||
pathname === relativePath || pathname.startsWith(`${relativePath}/`);
if (rawIsAbsolute && !isWithinRelativePath(parsed.pathname)) {
return '';
}
if (decodedIsAbsolute && !isWithinRelativePath(decodedParsed.pathname)) {
return '';
}
const stripRelativePath = pathname => relativePath && isWithinRelativePath(pathname) ?
(pathname.slice(relativePath.length) || '/') : pathname;
const pathname = stripRelativePath(parsed.pathname);
const decodedPathname = stripRelativePath(decodedParsed.pathname);
if (pathname.startsWith('//') || decodedPathname.startsWith('//')) {
return '';
}
if (!allowApi && (/^\/api(?:\/|$)/i.test(pathname) || /^\/api(?:\/|$)/i.test(decodedPathname))) {
return '';
}
return `${pathname}${parsed.search}${parsed.hash}`;
};
function prependRelativePath(url) {
return url.startsWith('http://') || url.startsWith('https://') ?
url : relative_path + url;
}
helpers.buildCategoryBreadcrumbs = async function (cid) {
const breadcrumbs = [];
while (parseInt(cid, 10)) {
/* eslint-disable no-await-in-loop */
const data = await categories.getCategoryFields(cid, ['name', 'slug', 'parentCid', 'disabled', 'isSection']);
if (!data.disabled && !data.isSection) {
breadcrumbs.unshift({
text: data.name,
url: `${url}/category/${data.slug}`,
cid: cid,
});
}
cid = data.parentCid;
}
if (meta.config.homePageRoute && meta.config.homePageRoute !== 'categories') {
breadcrumbs.unshift({
text: '[[global:header.categories]]',
url: `${url}/categories`,
});
}
breadcrumbs.unshift({
text: meta.config.homePageTitle || '[[global:home]]',
url: url,
});
return breadcrumbs;
};
helpers.buildBreadcrumbs = function (crumbs) {
const breadcrumbs = [
{
text: meta.config.homePageTitle || '[[global:home]]',
url: url,
},
];
crumbs.forEach((crumb) => {
if (crumb) {
if (crumb.url) {
crumb.url = `${utils.isRelativeUrl(crumb.url) ? `${url}/` : ''}${crumb.url}`;
}
breadcrumbs.push(crumb);
}
});
return breadcrumbs;
};
helpers.buildTitle = async function (pageTitle, userLang, template) {
pageTitle = String(pageTitle || '');
const translateTitle = template !== 'topic';
const browserTitle = String(meta.config.browserTitle || meta.config.title || 'NodeBB');
const [titleTranslated, browserTitleTranslated] = await Promise.all([
translateTitle ? translator.translateKey(pageTitle, [], userLang) : pageTitle,
translator.translateKey(browserTitle, [], userLang),
], userLang);
const titleLayout = meta.config.titleLayout || `${pageTitle ? '{pageTitle} | ' : ''}{browserTitle}`;
let title = titleLayout
.replace('{pageTitle}', () => titleTranslated)
.replace('{browserTitle}', () => browserTitleTranslated);
// The browser tab has no dir attribute, so it picks the title's direction from
// its first strongly-directional character. An RTL user viewing a page whose
// title starts with a Latin string (e.g. a username) would otherwise get an
// LTR title. Prefix a right-to-left mark to keep the direction stable.
if (translator.languageDirection(userLang) === 'rtl' && !title.startsWith('\u200F')) {
title = `\u200F${title}`;
}
return utils.decodeHTMLEntities(title);
};
helpers.getCategories = async function (set, uid, privilege, selectedCid) {
const cids = await categories.getCidsByPrivilege(set, uid, privilege);
return await getCategoryData(cids, uid, selectedCid, Object.values(categories.watchStates), privilege);
};
helpers.getCategoriesByStates = async function (uid, selectedCid, states, privilege = 'topics:read') {
const cids = await categories.getAllCidsFromSet('categories:cid');
return await getCategoryData(cids, uid, selectedCid, states, privilege);
};
async function getCategoryData(cids, uid, selectedCid, states, privilege) {
const [visibleCategories, selectData] = await Promise.all([
helpers.getVisibleCategories({
cids, uid, states, privilege, showLinks: false,
}),
helpers.getSelectedCategory(selectedCid, uid),
]);
const categoriesData = categories.buildForSelectCategories(visibleCategories, ['disabledClass']);
categoriesData.forEach((category) => {
category.selected = selectData.selectedCids.includes(category.cid);
});
selectData.selectedCids.sort((a, b) => a - b);
return {
categories: categoriesData,
selectedCategory: selectData.selectedCategory,
selectedCids: selectData.selectedCids,
};
}
helpers.getVisibleCategories = async function (params) {
const { cids, uid, privilege } = params;
const states = params.states || [categories.watchStates.watching, categories.watchStates.notwatching];
const showLinks = !!params.showLinks;
let [allowed, watchState, categoriesData, isAdmin, isModerator] = await Promise.all([
privileges.categories.isUserAllowedTo(privilege, cids, uid),
categories.getWatchState(cids, uid),
categories.getCategoriesData(cids),
user.isAdministrator(uid),
user.isModerator(uid, cids),
]);
const filtered = await plugins.hooks.fire('filter:helpers.getVisibleCategories', {
uid: uid,
allowed: allowed,
watchState: watchState,
categoriesData: categoriesData,
isModerator: isModerator,
isAdmin: isAdmin,
});
({ allowed, watchState, categoriesData, isModerator, isAdmin } = filtered);
categories.getTree(categoriesData, params.parentCid);
const cidToAllowed = _.zipObject(cids, allowed.map((allowed, i) => isAdmin || isModerator[i] || allowed));
const cidToCategory = _.zipObject(cids, categoriesData);
const cidToWatchState = _.zipObject(cids, watchState);
return categoriesData.filter((c) => {
if (!c) {
return false;
}
const hasVisibleChildren = checkVisibleChildren(c, cidToAllowed, cidToWatchState, states);
const isCategoryVisible = (
cidToAllowed[c.cid] &&
(showLinks || !c.link) &&
!c.disabled &&
states.includes(cidToWatchState[c.cid])
);
const shouldBeRemoved = !hasVisibleChildren && !isCategoryVisible;
const shouldBeDisaplayedAsDisabled = hasVisibleChildren && !isCategoryVisible;
if (shouldBeDisaplayedAsDisabled) {
c.disabledClass = true;
}
if (shouldBeRemoved && c.parent && c.parent.cid && cidToCategory[c.parent.cid]) {
cidToCategory[c.parent.cid].children = cidToCategory[c.parent.cid].children.filter(child => child.cid !== c.cid);
}
return !shouldBeRemoved;
});
};
helpers.getSelectedCategory = async function (cids, uid) {
if (cids && !Array.isArray(cids)) {
cids = [cids];
}
if (uid === undefined) {
const als = require('../als');
const store = als.getStore();
const e = new Error('').stack.split('\n')[3].trim();
if (store) {
winston.warn(`helpers.getSelectedCategory called without uid, getting it from async local storage. This is not recommended and may break in future versions. Pass in a uid explicitly. Called ${e}`);
} else {
winston.warn(`helpers.getSelectedCategory called without uid and no async local storage found, falling back to uid:0. Pass in a uid explicitly. Called ${e}`);
}
uid = store && store.uid ? store.uid : 0;
}
cids = cids && cids.map(cid => parseInt(cid, 10));
if (cids && cids.length) {
cids = await privileges.categories.filterCids('find', cids, uid);
}
const selectedCategories = await categories.getCategoriesData(cids);
let selectedCategory = null;
const selectedCids = selectedCategories.map(c => c && c.cid).filter(Boolean);
if (selectedCategories.length > 1) {
selectedCategory = {
icon: 'fa-plus',
name: '[[unread:multiple-categories-selected]]',
bgColor: '#ddd',
};
} else if (selectedCategories.length === 1 && selectedCategories[0]) {
selectedCategory = selectedCategories[0];
}
return { selectedCids, selectedCategory };
};
helpers.getSelectedTag = function (tags) {
if (tags && !Array.isArray(tags)) {
tags = [tags];
}
tags = tags || [];
const tagData = tags.map(t => String(t));
let selectedTag = null;
if (tagData.length) {
selectedTag = {
label: tagData.join(', '),
};
}
return {
selectedTags: tagData,
selectedTag: selectedTag,
};
};
helpers.trimChildren = function (category) {
if (category && Array.isArray(category.children)) {
category.children = category.children.slice(0, category.subCategoriesPerPage);
category.children.forEach((child) => {
if (category.isSection) {
helpers.trimChildren(child);
} else {
child.children = undefined;
}
});
}
};
helpers.setCategoryTeaser = function (category) {
if (Array.isArray(category.posts) && category.posts.length && category.posts[0]) {
const post = category.posts[0];
category.teaser = {
url: `${nconf.get('relative_path')}/post/${encodeURIComponent(post.pid)}`,
timestampISO: post.timestampISO,
pid: post.pid,
tid: post.tid,
index: post.index,
topic: post.topic,
user: post.user,
};
}
};
function checkVisibleChildren(c, cidToAllowed, cidToWatchState, states) {
if (!c || !Array.isArray(c.children)) {
return false;
}
return c.children.some(c => !c.disabled && (
(cidToAllowed[c.cid] && states.includes(cidToWatchState[c.cid])) ||
checkVisibleChildren(c, cidToAllowed, cidToWatchState, states)
));
}
helpers.getHomePageRoutes = async function (uid) {
const routes = [
{
route: 'categories',
name: 'Categories',
},
{
route: 'world',
name: 'World',
},
{
route: 'unread',
name: 'Unread',
},
{
route: 'recent',
name: 'Recent',
},
{
route: 'top',
name: 'Top',
},
{
route: 'popular',
name: 'Popular',
},
{
route: 'custom',
name: 'Custom',
},
];
const data = await plugins.hooks.fire('filter:homepage.get', {
uid: uid,
routes: routes,
});
return data.routes;
};
helpers.formatApiResponse = async (statusCode, res, payload) => {
if (res.req.method === 'HEAD') {
return res.sendStatus(statusCode);
}
if (String(statusCode).startsWith('2')) {
if (res.req.loggedIn) {
res.set('cache-control', 'private');
}
let code = 'ok';
let message = 'OK';
switch (statusCode) {
case 202:
code = 'accepted';
message = 'Accepted';
break;
case 204:
code = 'no-content';
message = 'No Content';
break;
}
res.status(statusCode).json({
status: { code, message },
response: payload || {},
});
} else if (payload instanceof Error || typeof payload === 'string') {
const message = payload instanceof Error ? payload.message : payload;
const response = {};
// Update status code based on some common error codes
switch (message) {
case '[[error:user-banned]]':
Object.assign(response, await generateBannedResponse(res));
// intentional fall through
case '[[error:no-privileges]]':
statusCode = 403;
break;
case '[[error:invalid-uid]]':
statusCode = 401;
break;
case '[[error:no-topic]]':
statusCode = 404;
break;
}
if (message.startsWith('[[error:required-parameters-missing, ')) {
const params = message.slice('[[error:required-parameters-missing, '.length, -2).split(' ');
Object.assign(response, { params });
}
const returnPayload = await helpers.generateError(statusCode, message, res);
returnPayload.response = response;
if (process.env.NODE_ENV === 'development') {
const stack = payload instanceof Error ? payload.stack : new Error(String(payload)).stack;
returnPayload.stack = stack;
process.stdout.write(`[${chalk.yellow('api')}] Exception caught, error with stack trace follows:\n`);
process.stdout.write(stack);
}
res.status(statusCode).json(returnPayload);
} else {
// Non-2xx statusCode, generate predefined error
const message = payload ? String(payload) : null;
const returnPayload = await helpers.generateError(statusCode, message, res);
res.status(statusCode).json(returnPayload);
}
};
async function generateBannedResponse(res) {
const response = {};
const [reason, expiry] = await Promise.all([
user.bans.getReason(res.req.uid),
user.getUserField(res.req.uid, 'banned:expire'),
]);
response.reason = reason;
if (expiry) {
Object.assign(response, {
expiry,
expiryISO: new Date(expiry).toISOString(),
expiryLocaleString: new Date(expiry).toLocaleString(),
});
}
return response;
}
helpers.generateError = async (statusCode, message, res) => {
async function translateMessage(message) {
const { req } = res;
const settings = req?.query?.lang ? null : await user.getSettings(req.uid);
const language = String(req?.query?.lang || settings.userLang || meta.config.defaultLang);
return await translator.translate(message, language);
}
if (message && message.startsWith('[[')) {
message = await translateMessage(message);
}
const payload = {
status: {
code: 'internal-server-error',
message: message || await translateMessage(`[[error:api.${statusCode}]]`),
},
response: {},
};
switch (statusCode) {
case 400:
payload.status.code = 'bad-request';
break;
case 401:
payload.status.code = 'not-authorised';
break;
case 403:
payload.status.code = 'forbidden';
break;
case 404:
payload.status.code = 'not-found';
break;
case 426:
payload.status.code = 'upgrade-required';
break;
case 429:
payload.status.code = 'too-many-requests';
break;
case 500:
payload.status.code = 'internal-server-error';
break;
case 501:
payload.status.code = 'not-implemented';
break;
case 503:
payload.status.code = 'service-unavailable';
break;
}
return payload;
};
helpers.validateParameters = function (query, fields, validation) {
// Parse query string params for filters, eliminate non-valid filters
const valid = fields.reduce((memo, field) => {
if (query.hasOwnProperty(field) && Object.hasOwn(validation, field)) {
const val = query[field];
const validationRule = validation[field];
if (Array.isArray(validationRule) && validationRule.includes(val)) {
memo[field] = val;
} else if (validationRule === 'number') {
if (Array.isArray(val)) {
memo[field] = val.filter(utils.isNumber);
} else if (utils.isNumber(val)) {
memo[field] = val;
}
}
}
return memo;
}, {});
return valid;
};
require('../promisify')(helpers);