ghost 6.53.0 → 6.54.0

package/core/server/services/route-settings/validation-errors.ts

@@ -0,0 +1,196 @@
+import type {z} from 'zod';
+import errors from '@tryghost/errors';
+import tpl from '@tryghost/tpl';
+
+const messages = {
+    validationError: 'The following definition "{at}" is invalid: {reason}'
+};
+
+const DOCS_URL = 'https://ghost.org/docs/themes/routing/';
+const MAX_SHOWN_LENGTH = 40;
+
+export type PathSegment = string | number;
+
+/**
+ * Renders the path to the offending value the way an author would find it in
+ * their file, e.g. `routes['/about/'].template[1]`.
+ */
+export function formatLocation(path: readonly PathSegment[]): string {
+    if (path.length === 0) {
+        return 'routes.yaml';
+    }
+
+    return path.reduce<string>((out, segment) => {
+        if (typeof segment === 'number') {
+            return `${out}[${segment}]`;
+        }
+        if (/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(segment)) {
+            return out ? `${out}.${segment}` : segment;
+        }
+        return `${out}['${segment.replace(/\\/g, '\\\\').replace(/'/g, '\\\'')}']`;
+    }, '');
+}
+
+/**
+ * Names what the author actually wrote, so the error can contrast it with what
+ * was expected. Reads as the "but <this> was provided" half of a message.
+ */
+export function describeValue(value: unknown): string {
+    if (value === null || value === undefined) {
+        return 'nothing';
+    }
+    if (Array.isArray(value)) {
+        return 'a list';
+    }
+    if (value instanceof Date) {
+        return 'a date';
+    }
+    if (typeof value === 'object') {
+        return 'a map';
+    }
+    if (typeof value === 'string') {
+        const shown = value.length > MAX_SHOWN_LENGTH ? `${value.slice(0, MAX_SHOWN_LENGTH)}…` : value;
+        return `the text "${shown}"`;
+    }
+    if (typeof value === 'number' || typeof value === 'boolean') {
+        return String(value);
+    }
+    return 'an unsupported value';
+}
+
+/**
+ * Lists options the way a sentence would, e.g. "posts, pages or tags".
+ */
+export function humanList(items: readonly string[]): string {
+    if (items.length < 2) {
+        return items.join('');
+    }
+    return `${items.slice(0, -1).join(', ')} or ${items[items.length - 1]}`;
+}
+
+/**
+ * What each key in routes.yaml accepts, phrased so the message reads
+ * "<key> must be <expectation>".
+ */
+const FIELD_EXPECTATIONS: Record<string, string> = {
+    routes: 'a map of route paths (e.g. /about/: about)',
+    collections: 'a map of collection paths (e.g. /blog/: {permalink: /{slug}/})',
+    taxonomies: 'a map of tag and/or author permalinks (e.g. tag: /tag/{slug}/)',
+    controller: 'channel, the only supported controller',
+    template: 'a template name, or a list of template names (e.g. template: index)',
+    permalink: 'a route with a leading and trailing slash (e.g. permalink: /{slug}/)',
+    content_type: 'a content type (e.g. content_type: text/xml)',
+    filter: 'a filter string (e.g. filter: featured:true)',
+    order: 'an order string (e.g. order: published_at desc)',
+    limit: 'a number or "all" (e.g. limit: 5)',
+    include: 'a comma-separated string (e.g. include: authors,tags)',
+    fields: 'a comma-separated string (e.g. fields: title,slug)',
+    visibility: 'a string (e.g. visibility: public)',
+    status: 'a string (e.g. status: published)',
+    slug: 'a slug (e.g. slug: welcome)',
+    page: 'a number (e.g. page: 2)',
+    rss: 'true or false',
+    redirect: 'true or false'
+};
+
+const CONTAINER_EXPECTATIONS: Record<string, {subject: string, expectation: string}> = {
+    routes: {subject: 'a route', expectation: 'a template name, or a map of route options (e.g. template, controller, data)'},
+    collections: {subject: 'a collection', expectation: 'a map of collection options (e.g. permalink, template, filter)'}
+};
+
+/**
+ * Keys that accept a list: saying "a list was provided" would contradict the
+ * expectation, so the entries are blamed instead.
+ */
+const LIST_ENTRY_PROBLEMS: Record<string, string> = {
+    template: 'one or more of the entries is not a template name'
+};
+
+function lookup(table: Record<string, string>, key: PathSegment | undefined): string | undefined {
+    return typeof key === 'string' && Object.prototype.hasOwnProperty.call(table, key) ? table[key] : undefined;
+}
+
+/**
+ * The key a failure belongs to — for a list entry that is the key holding the
+ * list, not the index.
+ */
+function fieldKey(path: readonly PathSegment[]): PathSegment | undefined {
+    const last = path[path.length - 1];
+
+    return typeof last === 'number' ? path[path.length - 2] : last;
+}
+
+/**
+ * Resolves the "<subject> must be <expectation>" half of a message for the
+ * value at `path`. Returns null when the key is unknown, in which case the
+ * caller falls back to the underlying schema message.
+ */
+function describeExpectation(path: readonly PathSegment[]): {subject: string, expectation: string} | null {
+    if (path.length === 0) {
+        return {subject: 'the file', expectation: 'a map of routes, collections or taxonomies'};
+    }
+
+    const [section] = path;
+
+    // A whole section, e.g. `routes: hello`
+    if (path.length === 1) {
+        const expectation = lookup(FIELD_EXPECTATIONS, section);
+        return expectation ? {subject: String(section), expectation} : null;
+    }
+
+    // A single route or collection, e.g. `routes: {/about/: [a, b]}`
+    if (path.length === 2 && typeof section === 'string' && Object.prototype.hasOwnProperty.call(CONTAINER_EXPECTATIONS, section)) {
+        return CONTAINER_EXPECTATIONS[section];
+    }
+
+    // A taxonomy permalink, e.g. `taxonomies: {tag: 5}`
+    if (path.length === 2 && section === 'taxonomies') {
+        return {subject: `the ${String(path[1])} taxonomy`, expectation: `a permalink route (e.g. ${String(path[1])}: /${String(path[1])}/{slug}/)`};
+    }
+
+    const expectation = lookup(FIELD_EXPECTATIONS, fieldKey(path));
+
+    return expectation ? {subject: String(fieldKey(path)), expectation} : null;
+}
+
+function valueAtPath(value: unknown, path: readonly PathSegment[]): unknown {
+    return path.reduce<unknown>((current, segment) => {
+        if (current === null || typeof current !== 'object') {
+            return undefined;
+        }
+        return (current as Record<PathSegment, unknown>)[segment];
+    }, value);
+}
+
+export function validationError(at: string, reason: string, help?: string): errors.ValidationError {
+    return new errors.ValidationError({
+        message: tpl(messages.validationError, {at, reason}),
+        ...(help ? {help} : {})
+    });
+}
+
+/**
+ * Turns a schema failure into an error that names the exact key in routes.yaml
+ * and says what that key accepts — schema messages on their own only say
+ * things like "Invalid input: expected string, received number".
+ *
+ * @param error  the schema failure
+ * @param basePath path of the value that was handed to the schema
+ * @param value  that same value, used to describe what the author wrote
+ */
+export function toValidationError(error: z.ZodError, basePath: readonly PathSegment[] = [], value?: unknown): errors.ValidationError {
+    const issue = error.issues[0];
+    const issuePath = issue.path as PathSegment[];
+    const path = [...basePath, ...issuePath];
+
+    const expectation = describeExpectation(path);
+    if (!expectation) {
+        return validationError(formatLocation(path), issue.message, DOCS_URL);
+    }
+
+    const provided = valueAtPath(value, issuePath);
+    const listProblem = Array.isArray(provided) ? lookup(LIST_ENTRY_PROBLEMS, fieldKey(path)) : undefined;
+    const found = listProblem ?? `${describeValue(provided)} was provided`;
+
+    return validationError(formatLocation(path), `${expectation.subject} must be ${expectation.expectation}, but ${found}.`, DOCS_URL);
+}

package/core/server/services/settings/settings-service.js

@@ -7,14 +7,14 @@ const models = require('../../models');
 const labs = require('../../../shared/labs');
 const limits = require('../limits');
 const config = require('../../../shared/config');
-const adapterManager = require('../adapter-manager');
+const adapterManager = require('../adapter-manager').default;
 const SettingsCache = require('../../../shared/settings-cache');
 const SettingsBREADService = require('./settings-bread-service');
 const {generatePrivateSiteAccessCode} = require('./private-site-access-code');
 const {obfuscatedSetting, isSecretSetting, hideValueIfSecret} = require('./settings-utils');
 const mail = require('../mail');
 const SingleUseTokenProvider = require('../members/single-use-token-provider');
-const urlUtils = require('../../../shared/url-utils');
+const urlUtils = require('../../../shared/url-utils').default;
 
 const ObjectId = require('bson-objectid').default;
 const settingsHelpers = require('../settings-helpers');

package/core/server/services/settings-helpers/index.js

@@ -1,5 +1,5 @@
 const settingsCache = require('../../../shared/settings-cache');
-const urlUtils = require('../../../shared/url-utils');
+const urlUtils = require('../../../shared/url-utils').default;
 const config = require('../../../shared/config');
 const SettingsHelpers = require('./settings-helpers');
 const labs = require('../../../shared/labs');

package/core/server/services/slack-notifications/service.js

@@ -45,7 +45,7 @@ class SlackNotificationsServiceWrapper {
         }
 
         const hostSettings = config.get('hostSettings');
-        const urlUtils = require('../../../shared/url-utils');
+        const urlUtils = require('../../../shared/url-utils').default;
         const siteUrl = urlUtils.getSiteUrl();
         const isEnabled = !!(hostSettings?.milestones?.enabled && hostSettings?.milestones?.url);
         const webhookUrl = hostSettings?.milestones?.url;

package/core/server/services/slack-ping/constants.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultPostSlugs = exports.messages = void 0;
+exports.messages = {
+    requestFailedError: 'The {service} service was unable to send a ping request, your site will continue to function.',
+    requestFailedHelp: 'If you get this error repeatedly, please seek help on {url}.'
+};
+exports.defaultPostSlugs = [
+    'welcome',
+    'the-editor',
+    'using-tags',
+    'managing-users',
+    'private-sites',
+    'advanced-markdown',
+    'themes'
+];

package/core/server/services/slack-ping/constants.ts

@@ -0,0 +1,15 @@
+export const messages = {
+    requestFailedError: 'The {service} service was unable to send a ping request, your site will continue to function.',
+    requestFailedHelp: 'If you get this error repeatedly, please seek help on {url}.'
+};
+
+export const defaultPostSlugs = [
+    'welcome',
+    'the-editor',
+    'using-tags',
+    'managing-users',
+    'private-sites',
+    'advanced-markdown',
+    'themes'
+];
+

package/core/server/services/slack-ping/index.js

@@ -1,209 +1,31 @@
-const errors = require('@tryghost/errors');
-const tpl = require('@tryghost/tpl');
-const logging = require('@tryghost/logging');
-const request = require('@tryghost/request');
-const {blogIcon} = require('../../lib/image');
-const urlUtils = require('../../../shared/url-utils');
-const urlService = require('../url');
-const settingsCache = require('../../../shared/settings-cache');
-const moment = require('moment');
-
-// Used to receive post.published model event, but also the slack.test event from the API which iirc this was done to avoid circular deps a long time ago
-const events = require('../../lib/common/events');
-
-const messages = {
-    requestFailedError: 'The {service} service was unable to send a ping request, your site will continue to function.',
-    requestFailedHelp: 'If you get this error repeatedly, please seek help on {url}.'
-};
-
-const defaultPostSlugs = [
-    'welcome',
-    'the-editor',
-    'using-tags',
-    'managing-users',
-    'private-sites',
-    'advanced-markdown',
-    'themes'
-];
-
-function getSlackSettings() {
-    const username = settingsCache.get('slack_username');
-    const url = settingsCache.get('slack_url');
-
-    return {
-        username,
-        url
-    };
-}
-
-/**
- * @TODO: change this function to check for the properties we depend on
- * @param {Object} data
- * @returns {boolean}
- */
-function hasPostProperties(data) {
-    return Object.prototype.hasOwnProperty.call(data, 'html') && Object.prototype.hasOwnProperty.call(data, 'title') && Object.prototype.hasOwnProperty.call(data, 'slug');
-}
-
-function ping(post) {
-    let message;
-    let title;
-    let author;
-    let description;
-    let slackData = {};
-    let slackSettings = getSlackSettings();
-    let blogTitle = settingsCache.get('title');
-
-    // If this is a post, we want to send the link of the post
-    if (hasPostProperties(post)) {
-        message = urlService.facade.getUrlForResource({...post, type: 'posts'}, {absolute: true});
-        title = post.title ? post.title : null;
-        author = post.authors ? post.authors[0] : null;
-
-        if (post.custom_excerpt) {
-            description = post.custom_excerpt;
-        } else if (post.html) {
-            const membersContentIdx = post.html.indexOf('<!--members-only-->');
-            const substringEnd = membersContentIdx > -1 ? membersContentIdx : post.html.length;
-
-            description = `${
-                post.html
-                    // Remove members-only content
-                    .substring(0, substringEnd)
-                    // Strip out HTML
-                    .replace(/<[^>]+>/g, '')
-                    // Split into sentences
-                    .split('.')
-                    // Remove empty strings
-                    .filter(sentence => sentence.trim() !== '')
-                    // Get the first three sentences
-                    .slice(0, 3)
-                    // Join 'em back together
-                    .join('.')
-            }.`;
-        } else {
-            description = null;
-        }
-    } else {
-        message = post.message;
-    }
-
-    // Quit here if slack integration is not activated
-    if (slackSettings && slackSettings.url && slackSettings.url !== '') {
-        slackSettings.username = slackSettings.username ? slackSettings.username : 'Ghost';
-        // Only ping when not a page
-        if (post.type === 'page') {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const slack_ping_service_1 = require("./slack-ping-service");
+class SlackPingServiceWrapper {
+    service;
+    init() {
+        if (this.service) {
+            // Already done
             return;
         }
-
-        // Don't ping for the default posts.
-        // This also handles the case where during Ghost's first run
-        // model loading inserts this post but permissions.init() hasn't
-        // (can't) run yet.
-        if (defaultPostSlugs.indexOf(post.slug) > -1) {
-            return;
-        }
-
-        if (hasPostProperties(post)) {
-            slackData = {
-                // We are handling the case of test notification here by checking
-                // if it is a post or a test message to check webhook working.
-                text: `Notification from *${blogTitle}* :ghost:`,
-                unfurl_links: true,
-                icon_url: blogIcon.getIconUrl({absolute: true}),
-                username: slackSettings.username,
-                // We don't want to send attachment if it is a test notification.
-                attachments: [
-                    {
-                        fallback: 'Sorry, content cannot be shown.',
-                        title: title,
-                        title_link: message,
-                        author_name: blogTitle,
-                        image_url: post ? urlUtils.urlFor('image', {image: post.feature_image}, true) : null,
-                        color: '#008952',
-                        fields: [
-                            {
-                                title: 'Description',
-                                value: description,
-                                short: false
-                            }
-                        ]
-                    },
-                    {
-                        fallback: 'Sorry, content cannot be shown.',
-                        color: '#008952',
-                        thumb_url: author ? urlUtils.urlFor('image', {image: author.profile_image}, true) : null,
-                        fields: [
-                            {
-                                title: 'Author',
-                                value: author ? `<${urlService.facade.getUrlForResource({...author, type: 'authors'}, {absolute: true})} | ${author.name}>` : null,
-                                short: true
-                            }
-                        ],
-                        footer: blogTitle,
-                        footer_icon: blogIcon.getIconUrl({absolute: true}),
-                        ts: moment().unix()
-                    }
-                ]
-            };
-        } else {
-            slackData = {
-                text: message,
-                unfurl_links: true,
-                icon_url: blogIcon.getIconUrl({absolute: true}),
-                username: slackSettings.username
-            };
-        }
-
-        return request(slackSettings.url, {
-            body: JSON.stringify(slackData),
-            headers: {
-                'Content-type': 'application/json'
-            }
-        }).catch(function (err) {
-            logging.error(new errors.InternalServerError({
-                err: err,
-                context: tpl(messages.requestFailedError, {service: 'slack'}),
-                help: tpl(messages.requestFailedHelp, {url: 'https://ghost.org/docs/'})
-            }));
+        // Wire up all the dependencies
+        const { blogIcon } = require('../../lib/image');
+        const events = require('../../lib/common/events');
+        const logging = require('@tryghost/logging');
+        const request = require('@tryghost/request');
+        const settingsCache = require('../../../shared/settings-cache');
+        const urlService = require('../url');
+        const urlUtils = require('../../../shared/url-utils').default;
+        this.service = new slack_ping_service_1.SlackPingService({
+            blogIcon,
+            events,
+            logging,
+            request,
+            settingsCache,
+            urlService,
+            urlUtils
         });
+        this.service.subscribeEvents();
     }
 }
-
-function slackListener(model, options) {
-    // CASE: do not ping slack if we import a database
-    // TODO: refactor post.published events to never fire on importing
-    if (options && options.importing) {
-        return;
-    }
-
-    ping({
-        ...model.toJSON(),
-        authors: model.related('authors').toJSON(),
-        // tags are needed so the lazy URL service can evaluate collection
-        // filters (e.g. `tag:foo`) when resolving the post URL; without them
-        // a tag-filtered post resolves to /404/
-        tags: model.related('tags').toJSON()
-    });
-}
-
-function slackTestPing() {
-    ping({
-        message: 'Heya! This is a test notification from your Ghost blog :smile:. Seems to work fine!'
-    });
-}
-
-function init() {
-    if (!events.hasRegisteredListener('post.published', 'slackListener')) {
-        events.on('post.published', slackListener);
-    }
-
-    if (!events.hasRegisteredListener('slack.test', 'slackTestPing')) {
-        events.on('slack.test', slackTestPing);
-    }
-}
-
-// Public API
-module.exports = {
-    init: init
-};
+exports.default = new SlackPingServiceWrapper();

package/core/server/services/slack-ping/index.ts

@@ -0,0 +1,35 @@
+import {SlackPingService} from './slack-ping-service';
+
+class SlackPingServiceWrapper {
+    service?: SlackPingService;
+
+    init(): void {
+        if (this.service) {
+            // Already done
+            return;
+        }
+
+        // Wire up all the dependencies
+        const {blogIcon} = require('../../lib/image');
+        const events = require('../../lib/common/events');
+        const logging = require('@tryghost/logging');
+        const request = require('@tryghost/request');
+        const settingsCache = require('../../../shared/settings-cache');
+        const urlService = require('../url');
+        const urlUtils = require('../../../shared/url-utils').default;
+
+        this.service = new SlackPingService({
+            blogIcon,
+            events,
+            logging,
+            request,
+            settingsCache,
+            urlService,
+            urlUtils
+        });
+
+        this.service.subscribeEvents();
+    }
+}
+
+export default new SlackPingServiceWrapper();