ghost 6.53.0 → 6.54.0

package/core/server/services/post-scheduling/post-scheduling.ts

@@ -6,7 +6,7 @@ import type {InternalApiKey, InternalKeys} from '../internal-keys';
 // CJS-only modules — typed loosely below. models is the Bookshelf registry
 // without TS declarations; the rest are JS modules without types.
 const models = require('../../models');
-const urlUtils = require('../../../shared/url-utils');
+const urlUtils = require('../../../shared/url-utils').default;
 const {getSignedAdminToken} = require('../../adapters/scheduling/utils');
 const events = require('../../lib/common/events');
 

package/core/server/services/posts/post-email-handler.js

@@ -22,13 +22,13 @@ class PostEmailHandler {
      * Validates email can be sent before saving the post (if an email will be sent)
      *
      * @param {import('@tryghost/api-framework').Frame} frame
-     * @returns {Promise<void>}
+     * @returns {Promise<{newsletter: Object, emailRecipientFilter: string, emailCount: number}|null>}
      */
     async validateBeforeSave(frame) {
         const newStatus = frame.data.posts[0].status;
 
         if (!EMAIL_SENDING_STATUSES.includes(newStatus)) {
-            return;
+            return null;
         }
 
         const existingPost = await this.models.Post.findOne(
@@ -41,7 +41,7 @@ class PostEmailHandler {
         const sendingEmail = hasNewsletter && this.shouldSendEmail(newStatus, previousStatus);
 
         if (!sendingEmail) {
-            return;
+            return null;
         }
 
         const emailRecipientFilter = frame.options.email_segment || existingPost?.get('email_recipient_filter') || 'all';
@@ -50,7 +50,9 @@ class PostEmailHandler {
 
         const newsletter = await this.getNewsletter(frame, existingPost);
 
-        await this.emailService.checkCanSendEmail(newsletter, emailRecipientFilter);
+        const {emailCount} = await this.emailService.checkCanSendEmail(newsletter, emailRecipientFilter);
+
+        return {newsletter, emailRecipientFilter, emailCount};
     }
 
     /**
@@ -97,9 +99,14 @@ class PostEmailHandler {
      * Handles creating or retrying the newsletter email after post is saved
      *
      * @param {Object} model - The post model
+     * @param {Object} [options]
+     * @param {Object} [options.preflight] - Validation result from validateBeforeSave, passed through to createEmail
+     * @param {Object} [options.preflight.newsletter]
+     * @param {string} [options.preflight.emailRecipientFilter]
+     * @param {number} [options.preflight.emailCount]
      * @returns {Promise<void>}
      */
-    async createOrRetryEmail(model) {
+    async createOrRetryEmail(model, {preflight} = {}) {
         if (!model.get('newsletter_id')) {
             return;
         }
@@ -114,7 +121,7 @@ class PostEmailHandler {
         let email;
 
         if (!postEmail) {
-            email = await this.emailService.createEmail(model);
+            email = await this.emailService.createEmail(model, {preflight});
         } else if (postEmail.get('status') === 'failed') {
             email = await this.emailService.retryEmail(postEmail);
         }

package/core/server/services/posts/post-scheduling.js

@@ -2,7 +2,7 @@ const _ = require('lodash');
 const errors = require('@tryghost/errors');
 const moment = require('moment');
 const config = require('../../../shared/config');
-const urlUtils = require('../../../shared/url-utils');
+const urlUtils = require('../../../shared/url-utils').default;
 const api = require('../../api').endpoints;
 
 const messages = {

package/core/server/services/posts/posts-service-instance.js

@@ -6,7 +6,7 @@ const url = require('../../../server/api/endpoints/utils/serializers/output/util
  * @returns {InstanceType<PostsService>} instance of the PostsService
  */
 const getPostServiceInstance = () => {
-    const urlUtils = require('../../../shared/url-utils');
+    const urlUtils = require('../../../shared/url-utils').default;
     const labs = require('../../../shared/labs');
     const models = require('../../models');
     const PostStats = require('./stats/post-stats');

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

@@ -61,11 +61,11 @@ class PostsService {
      * @returns
      */
     async editPost(frame, options) {
-        await this.postEmailHandler.validateBeforeSave(frame);
+        const preflight = await this.postEmailHandler.validateBeforeSave(frame);
 
         const model = await this.models.Post.edit(frame.data.posts[0], frame.options);
 
-        await this.postEmailHandler.createOrRetryEmail(model);
+        await this.postEmailHandler.createOrRetryEmail(model, {preflight});
 
         const dto = model.toJSON(frame.options);
 

package/core/server/services/posts-public/service.js

@@ -6,7 +6,7 @@ class PostsPublicServiceWrapper {
         }
 
         // Wire up all the dependencies
-        const adapterManager = require('../adapter-manager');
+        const adapterManager = require('../adapter-manager').default;
         const config = require('../../../shared/config');
         const EventRegistry = require('../../lib/common/events');
 

package/core/server/services/public-config/site.js

@@ -1,7 +1,7 @@
 const ghostVersion = require('@tryghost/version');
 const settingsCache = require('../../../shared/settings-cache');
 const config = require('../../../shared/config');
-const urlUtils = require('../../../shared/url-utils');
+const urlUtils = require('../../../shared/url-utils').default;
 
 module.exports = function getSiteProperties() {
     const siteProperties = {

package/core/server/services/recommendations/recommendation-service-wrapper.js

@@ -49,7 +49,7 @@ class RecommendationServiceWrapper {
             return;
         }
 
-        const urlUtils = require('../../../shared/url-utils');
+        const urlUtils = require('../../../shared/url-utils').default;
         const models = require('../../models');
         const sentry = require('../../../shared/sentry');
         const settings = require('../settings');

package/core/server/services/recommendations/service/libraries.d.ts

@@ -1,4 +1,2 @@
-declare module '@tryghost/tpl';
-declare module '@tryghost/logging';
 declare module '@tryghost/mongo-utils';
 declare module '@tryghost/nql';

package/core/server/services/route-settings/dynamic-routing-service.js

@@ -112,7 +112,7 @@ class DynamicRoutingService {
         }
     }
 
-    async upload(filePath) {
+    async upload(yamlContent) {
         const parseYaml = require('./yaml-parser');
         const {parseRouteSettings} = require('./route-settings-parser');
         const urlService = require('../url');
@@ -120,8 +120,7 @@ class DynamicRoutingService {
 
         // Parse and validate before anything is persisted — an invalid
         // upload is rejected here and never reaches the store.
-        const content = await fs.readFile(filePath, 'utf8');
-        const next = parseRouteSettings(parseYaml(content), content);
+        const next = parseRouteSettings(parseYaml(yamlContent), yamlContent);
         let previous = null;
         try {
             previous = await this.store.get();

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

@@ -6,7 +6,7 @@ const service = new DynamicRoutingService();
 
 module.exports = {
     init: async () => {
-        const adapterManager = require('../adapter-manager');
+        const adapterManager = require('../adapter-manager').default;
         const SettingsLoader = require('./settings-loader');
         const SettingsPathManager = require('./settings-path-manager');
 

package/core/server/services/route-settings/route-settings-parser.js

@@ -7,37 +7,46 @@ exports.parseRouteSettings = parseRouteSettings;
 exports.serializeRouteSettings = serializeRouteSettings;
 const js_yaml_1 = __importDefault(require("js-yaml"));
 const zod_1 = require("zod");
-const errors_1 = __importDefault(require("@tryghost/errors"));
 const tpl_1 = __importDefault(require("@tryghost/tpl"));
+const validation_errors_1 = require("./validation-errors");
 const messages = {
-    validationError: 'The following definition "{at}" is invalid: {reason}',
-    badDataError: 'Please wrap the data definition into a custom name.',
+    badDataError: '"{key}" is a reserved key. Please wrap the data definition into a custom name.',
     badDataHelp: 'Example:\n data:\n  my-tag:\n    resource: tags\n    ...\n',
-    authorDeprecatedError: 'Please choose a different name. We recommend not using author.'
+    authorDeprecatedError: '"author" is reserved. Please choose a different name. We recommend not using author.'
 };
-function validationError(at, reason, help) {
-    return new errors_1.default.ValidationError({
-        message: (0, tpl_1.default)(messages.validationError, { at, reason }),
-        ...(help ? { help } : {})
-    });
-}
 const VALID_SHORTFORM_RESOURCES = ['tag', 'page', 'post', 'author'];
 const VALID_LONGFORM_RESOURCES = ['tags', 'posts', 'pages', 'authors'];
 const RESERVED_DATA_KEYS = ['resource', 'type', 'limit', 'order', 'include', 'filter', 'status', 'visibility', 'slug', 'redirect'];
-const DataShortFormSchema = zod_1.z.string().superRefine((v, ctx) => {
-    if (!/^[a-zA-Z0-9_]+\.[a-zA-Z0-9_-]+$/.test(v)) {
-        ctx.addIssue({ code: 'custom', message: (0, tpl_1.default)(messages.validationError, { at: v, reason: 'Incorrect Format. Please use e.g. tag.recipes' }) });
-        return;
+// YAML parses a bare `filter:` as null and authors commonly quote numeric scalars
+// (`limit: "100"`); the legacy validator accepted both, so treat an explicitly empty
+// value as unset and coerce digit-only limit strings to numbers.
+const OptionalStringField = zod_1.z.string().nullish().transform(v => v ?? undefined);
+const OptionalBooleanField = zod_1.z.boolean().nullish().transform(v => v ?? undefined);
+const LimitField = zod_1.z.union([zod_1.z.number(), zod_1.z.literal('all'), zod_1.z.string().regex(/^\d+$/).transform(Number)])
+    .nullish().transform(v => v ?? undefined);
+const SHORTFORM_HELP = 'e.g. data: tag.recipes';
+/**
+ * Shorthand data definitions look like `tag.recipes` — resource, dot, slug.
+ *
+ * `%s` stands in for the slug: on channel routes and collections, fetch-data
+ * substitutes it with the request's `slug` param at query time, which is how a
+ * wildcard route such as `/author/:slug/` serves a different author per request.
+ * There is no static slug that could replace it, so rejecting it would break
+ * those routes.
+ */
+function validateDataShortForm(value, path) {
+    if (!/^[a-zA-Z0-9_]+\.(?:%s|[a-zA-Z0-9_-]+)$/.test(value)) {
+        throw (0, validation_errors_1.validationError)((0, validation_errors_1.formatLocation)(path), `"${value}" is not a valid data shorthand. Please use resource.slug, e.g. tag.recipes.`, SHORTFORM_HELP);
     }
-    const resource = v.split('.')[0];
+    const resource = value.split('.')[0];
     if (!VALID_SHORTFORM_RESOURCES.includes(resource)) {
-        ctx.addIssue({ code: 'custom', message: (0, tpl_1.default)(messages.validationError, { at: v, reason: `${resource} not supported. Please use ${VALID_SHORTFORM_RESOURCES.join(', ')}.` }) });
+        throw (0, validation_errors_1.validationError)((0, validation_errors_1.formatLocation)(path), `resource "${resource}" is not supported. Please use ${(0, validation_errors_1.humanList)(VALID_SHORTFORM_RESOURCES)}.`, SHORTFORM_HELP);
     }
-});
+}
 const DataReadEntrySchema = zod_1.z.object({
     type: zod_1.z.literal('read'),
     resource: zod_1.z.enum(VALID_LONGFORM_RESOURCES),
-    slug: zod_1.z.string({ message: 'slug is required for read data entries.' }).min(1, { message: 'slug is required for read data entries.' }),
+    slug: zod_1.z.string().min(1),
     redirect: zod_1.z.boolean().optional(),
     include: zod_1.z.string().optional(),
     visibility: zod_1.z.string().optional(),
@@ -46,98 +55,104 @@ const DataReadEntrySchema = zod_1.z.object({
 const DataBrowseEntrySchema = zod_1.z.object({
     type: zod_1.z.literal('browse'),
     resource: zod_1.z.enum(VALID_LONGFORM_RESOURCES),
-    filter: zod_1.z.string().optional(),
-    limit: zod_1.z.union([zod_1.z.number(), zod_1.z.literal('all')]).optional(),
-    order: zod_1.z.string().optional(),
-    include: zod_1.z.string().optional(),
-    fields: zod_1.z.string().optional(),
-    visibility: zod_1.z.string().optional(),
-    status: zod_1.z.string().optional(),
+    filter: OptionalStringField,
+    limit: LimitField,
+    order: OptionalStringField,
+    include: OptionalStringField,
+    fields: OptionalStringField,
+    visibility: OptionalStringField,
+    status: OptionalStringField,
     page: zod_1.z.number().optional()
 });
 const DataLongFormEntrySchema = zod_1.z.discriminatedUnion('type', [DataReadEntrySchema, DataBrowseEntrySchema]);
-function parseDataEntry(key, value) {
+const DATA_ENTRY_HELP = 'e.g.\n data:\n  my-tag:\n    resource: tags\n    type: read\n    slug: recipes\n';
+function parseDataEntry(value, path) {
     if (typeof value === 'string') {
-        const result = DataShortFormSchema.safeParse(value);
-        if (!result.success) {
-            throw toValidationError(result.error);
-        }
+        validateDataShortForm(value, path);
         return value;
     }
-    if (typeof value === 'object' && value !== null) {
+    if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
         const result = DataLongFormEntrySchema.safeParse(value);
         if (!result.success) {
             const issue = result.error.issues[0];
-            if (issue.message.includes('discriminator')) {
-                const typeVal = value.type;
-                if (typeVal === undefined) {
-                    throw validationError(JSON.stringify(value), 'type is required.');
+            const at = (0, validation_errors_1.formatLocation)(path);
+            const record = value;
+            // A failed `type` discriminator surfaces as a union issue on that
+            // key — matched on the code rather than the wording, which zod
+            // is free to change.
+            if (issue.code === 'invalid_union' && issue.path[0] === 'type') {
+                if (record.type === undefined) {
+                    throw (0, validation_errors_1.validationError)(at, 'type is required. Please use read or browse.', DATA_ENTRY_HELP);
                 }
-                throw validationError(JSON.stringify(value), `${typeVal} not supported. Please use read, browse.`);
+                throw (0, validation_errors_1.validationError)(at, `type "${record.type}" is not supported. Please use read or browse.`, DATA_ENTRY_HELP);
             }
-            if (issue.path?.includes('resource')) {
-                const resVal = value.resource;
-                if (resVal === undefined) {
-                    throw validationError(JSON.stringify(value), 'resource is required.');
+            if (issue.path.includes('resource')) {
+                if (record.resource === undefined) {
+                    throw (0, validation_errors_1.validationError)(at, `resource is required. Please use ${(0, validation_errors_1.humanList)(VALID_LONGFORM_RESOURCES)}.`, DATA_ENTRY_HELP);
                 }
-                throw validationError(JSON.stringify(value), `${resVal} not supported. Please use ${VALID_LONGFORM_RESOURCES.join(', ')}.`);
+                throw (0, validation_errors_1.validationError)(at, `resource "${record.resource}" is not supported. Please use ${(0, validation_errors_1.humanList)(VALID_LONGFORM_RESOURCES)}.`, DATA_ENTRY_HELP);
+            }
+            if (issue.path.includes('slug') && !record.slug) {
+                throw (0, validation_errors_1.validationError)(at, 'slug is required for read data entries.', DATA_ENTRY_HELP);
+            }
+            throw (0, validation_errors_1.toValidationError)(result.error, path, value);
+        }
+        // Fields set to an explicitly empty value parse to undefined — drop the
+        // keys so "unset" means absent in the domain model and serialized output.
+        const entry = result.data;
+        for (const entryKey of Object.keys(entry)) {
+            if (entry[entryKey] === undefined) {
+                delete entry[entryKey];
             }
-            throw toValidationError(result.error);
         }
         return result.data;
     }
-    throw validationError(key, 'Incorrect Format. Please use e.g. tag.recipes');
+    throw (0, validation_errors_1.validationError)((0, validation_errors_1.formatLocation)(path), `a data entry must be a shorthand like tag.recipes, or a map with type and resource, but ${(0, validation_errors_1.describeValue)(value)} was provided.`, DATA_ENTRY_HELP);
 }
-function parseRouteData(data) {
+function parseRouteData(data, path) {
     if (typeof data === 'string') {
-        const result = DataShortFormSchema.safeParse(data);
-        if (!result.success) {
-            throw toValidationError(result.error);
-        }
+        validateDataShortForm(data, path);
         return data;
     }
-    if (typeof data !== 'object' || data === null) {
-        throw validationError(String(data), 'Incorrect Format. Please use e.g. tag.recipes');
+    if (typeof data !== 'object' || data === null || Array.isArray(data)) {
+        throw (0, validation_errors_1.validationError)((0, validation_errors_1.formatLocation)(path), `data must be a shorthand like tag.recipes, or a map of named data entries, but ${(0, validation_errors_1.describeValue)(data)} was provided.`, DATA_ENTRY_HELP);
     }
     const record = data;
     for (const key of Object.keys(record)) {
         if (RESERVED_DATA_KEYS.includes(key)) {
-            throw new errors_1.default.ValidationError({
-                message: (0, tpl_1.default)(messages.badDataError),
-                help: messages.badDataHelp
-            });
+            throw (0, validation_errors_1.validationError)((0, validation_errors_1.formatLocation)([...path, key]), (0, tpl_1.default)(messages.badDataError, { key }), messages.badDataHelp);
         }
         if (key === 'author') {
-            throw new errors_1.default.ValidationError({
-                message: (0, tpl_1.default)(messages.authorDeprecatedError)
-            });
+            throw (0, validation_errors_1.validationError)((0, validation_errors_1.formatLocation)([...path, key]), messages.authorDeprecatedError);
         }
     }
     const parsed = {};
     for (const [key, value] of Object.entries(record)) {
-        parsed[key] = parseDataEntry(key, value);
+        parsed[key] = parseDataEntry(value, [...path, key]);
     }
     return parsed;
 }
-const TemplateField = zod_1.z.union([zod_1.z.string(), zod_1.z.array(zod_1.z.string())]).optional().default([])
+const TemplateField = zod_1.z.union([zod_1.z.string(), zod_1.z.array(zod_1.z.string())]).nullish().default([])
     .transform(v => {
     if (!v || (Array.isArray(v) && v.length === 0)) {
         return [];
     }
     return Array.isArray(v) ? v : [v];
 });
-const RouteObjectSchema = zod_1.z.object({
+// The schemas are built per route/collection so that errors raised while
+// parsing nested `data` can name the exact path they came from.
+const routeObjectSchema = (path) => zod_1.z.object({
     controller: zod_1.z.literal('channel').optional(),
     template: TemplateField,
     data: zod_1.z.unknown().optional(),
-    content_type: zod_1.z.string().optional(),
-    filter: zod_1.z.string().optional(),
-    order: zod_1.z.string().optional(),
-    limit: zod_1.z.union([zod_1.z.number(), zod_1.z.literal('all')]).optional(),
-    rss: zod_1.z.boolean().optional()
+    content_type: OptionalStringField,
+    filter: OptionalStringField,
+    order: OptionalStringField,
+    limit: LimitField,
+    rss: OptionalBooleanField
 }).transform((val) => {
     const templates = val.template;
-    const data = val.data !== undefined ? parseRouteData(val.data) : undefined;
+    const data = val.data !== undefined ? parseRouteData(val.data, [...path, 'data']) : undefined;
     if (val.controller === 'channel') {
         const route = {
             type: 'channel',
@@ -175,16 +190,16 @@ const RouteObjectSchema = zod_1.z.object({
     }
     return route;
 });
-const RawCollectionValueSchema = zod_1.z.object({
-    permalink: zod_1.z.string({ message: 'Please define a permalink route.' }).optional(),
+const collectionValueSchema = (path) => zod_1.z.object({
+    permalink: zod_1.z.string().optional(),
     template: TemplateField,
     data: zod_1.z.unknown().optional(),
-    filter: zod_1.z.string().optional(),
-    order: zod_1.z.string().optional(),
-    limit: zod_1.z.union([zod_1.z.number(), zod_1.z.literal('all')]).optional(),
-    rss: zod_1.z.boolean().optional()
+    filter: OptionalStringField,
+    order: OptionalStringField,
+    limit: LimitField,
+    rss: OptionalBooleanField
 }).transform((val) => {
-    const data = val.data !== undefined ? parseRouteData(val.data) : undefined;
+    const data = val.data !== undefined ? parseRouteData(val.data, [...path, 'data']) : undefined;
     const collection = {
         permalink: val.permalink ?? '',
         templates: val.template
@@ -208,48 +223,60 @@ const RawCollectionValueSchema = zod_1.z.object({
 });
 const RouteSettingsSchema = zod_1.z.object({
     routes: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()).nullable().optional().default({}),
-    collections: zod_1.z.record(zod_1.z.string(), RawCollectionValueSchema).nullable().optional().default({}),
+    collections: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()).nullable().optional().default({}),
     taxonomies: zod_1.z.record(zod_1.z.string(), zod_1.z.string()).nullable().optional().default({})
 });
-function toValidationError(error) {
-    const issue = error.issues[0];
-    return new errors_1.default.ValidationError({
-        message: issue.message
-    });
+/**
+ * Every path in routes.yaml — route paths, collection paths, permalinks and
+ * taxonomy permalinks — follows the same rules, so they share one message set.
+ *
+ * `allowParamNotation` is set for route and collection keys, which are mounted on
+ * Express verbatim: nothing rewrites `{param}` to `:param` for them the way it
+ * does for permalinks and taxonomies. So `/author/:slug/` is a working wildcard
+ * route on live sites and `/author/{slug}/` would be a dead literal path —
+ * rejecting :param there would break the former, and the suggested rewrite would
+ * silently produce the latter.
+ */
+function validatePath(value, path, example, { allowParamNotation = false } = {}) {
+    const at = (0, validation_errors_1.formatLocation)(path);
+    if (!value.startsWith('/')) {
+        throw (0, validation_errors_1.validationError)(at, `"${value}" is missing a leading slash. Please use e.g. ${example}.`);
+    }
+    if (!value.endsWith('/')) {
+        throw (0, validation_errors_1.validationError)(at, `"${value}" is missing a trailing slash. Please use e.g. ${example}.`);
+    }
+    if (!allowParamNotation && /\/:\w+/.test(value)) {
+        // Suggest the same path in the notation Ghost expects, rather than a
+        // generic example the author then has to translate.
+        throw (0, validation_errors_1.validationError)(at, `"${value}" uses the :param notation. Please use "${value.replace(/\/:(\w+)/g, '/{$1}')}".`);
+    }
 }
 function parseRouteSettings(raw, yamlSource) {
     const obj = raw ?? {};
     const parsed = RouteSettingsSchema.safeParse(obj);
     if (!parsed.success) {
-        throw toValidationError(parsed.error);
+        throw (0, validation_errors_1.toValidationError)(parsed.error, [], obj);
     }
     const { routes: rawRoutes, collections: rawCollections, taxonomies: rawTaxonomies } = parsed.data;
     const routes = [];
     if (rawRoutes) {
         for (const [path, value] of Object.entries(rawRoutes)) {
-            if (!path.startsWith('/')) {
-                throw validationError(path, 'A leading slash is required.');
-            }
-            if (!path.endsWith('/')) {
-                throw validationError(path, 'A trailing slash is required.');
-            }
-            if (/\/:\w+/.test(path)) {
-                throw validationError(path, 'Please use the following notation e.g. /{slug}/.');
-            }
+            const routeLocation = ['routes', path];
+            validatePath(path, routeLocation, '/about/', { allowParamNotation: true });
             if (value === null || value === undefined) {
-                throw validationError(path, 'Please define a template.', 'e.g. /about/: about');
+                throw (0, validation_errors_1.validationError)((0, validation_errors_1.formatLocation)(routeLocation), 'Please define a template, e.g. /about/: about.');
             }
             if (typeof value === 'string') {
                 routes.push({ type: 'template', path, templates: [value] });
                 continue;
             }
-            const routeResult = RouteObjectSchema.safeParse(value);
+            const routeResult = routeObjectSchema(routeLocation).safeParse(value);
             if (!routeResult.success) {
-                throw toValidationError(routeResult.error);
+                throw (0, validation_errors_1.toValidationError)(routeResult.error, routeLocation, value);
             }
             const route = routeResult.data;
             if (route.type === 'template' && (!route.templates || route.templates.length === 0) && !route.data && !route.contentType) {
-                throw validationError(path, 'Please define a template.', 'e.g. /about/: about');
+                throw (0, validation_errors_1.validationError)((0, validation_errors_1.formatLocation)(routeLocation), 'Please define a template, e.g. /about/: about.');
             }
             routes.push({ ...route, path });
         }
@@ -257,48 +284,31 @@ function parseRouteSettings(raw, yamlSource) {
     const collections = [];
     if (rawCollections) {
         for (const [path, value] of Object.entries(rawCollections)) {
-            if (!path.startsWith('/')) {
-                throw validationError(path, 'A leading slash is required.');
-            }
-            if (!path.endsWith('/')) {
-                throw validationError(path, 'A trailing slash is required.');
-            }
-            if (/\/:\w+/.test(path)) {
-                throw validationError(path, 'Please use the following notation e.g. /{slug}/.');
+            const collectionLocation = ['collections', path];
+            validatePath(path, collectionLocation, '/blog/', { allowParamNotation: true });
+            const collectionResult = collectionValueSchema(collectionLocation).safeParse(value);
+            if (!collectionResult.success) {
+                throw (0, validation_errors_1.toValidationError)(collectionResult.error, collectionLocation, value);
             }
-            if (!value.permalink) {
-                throw validationError(path, 'Please define a permalink route.', 'e.g. permalink: /{slug}/');
+            const collection = collectionResult.data;
+            if (!collection.permalink) {
+                throw (0, validation_errors_1.validationError)((0, validation_errors_1.formatLocation)(collectionLocation), 'Please define a permalink route, e.g. permalink: /{slug}/.');
             }
-            if (!value.permalink.startsWith('/')) {
-                throw validationError(value.permalink, 'A leading slash is required.');
-            }
-            if (!value.permalink.endsWith('/')) {
-                throw validationError(value.permalink, 'A trailing slash is required.');
-            }
-            if (/\/:\w+/.test(value.permalink)) {
-                throw validationError(value.permalink, 'Please use the following notation e.g. /{slug}/.');
-            }
-            collections.push({ ...value, path });
+            validatePath(collection.permalink, [...collectionLocation, 'permalink'], '/{slug}/');
+            collections.push({ ...collection, path });
         }
     }
     const taxonomies = {};
     if (rawTaxonomies) {
         for (const [key, value] of Object.entries(rawTaxonomies)) {
+            const taxonomyLocation = ['taxonomies', key];
             if (!['tag', 'author'].includes(key)) {
-                throw validationError(key, 'Unknown taxonomy.');
+                throw (0, validation_errors_1.validationError)((0, validation_errors_1.formatLocation)(taxonomyLocation), 'Unknown taxonomy. Please use tag or author.');
             }
             if (!value) {
-                throw validationError(key, 'Please define a taxonomy permalink route.', 'e.g. tag: /tag/{slug}/');
-            }
-            if (!value.startsWith('/')) {
-                throw validationError(value, 'A leading slash is required.');
-            }
-            if (!value.endsWith('/')) {
-                throw validationError(value, 'A trailing slash is required.');
-            }
-            if (/\/:\w+/.test(value)) {
-                throw validationError(value, 'Please use the following notation e.g. /{slug}/.');
+                throw (0, validation_errors_1.validationError)((0, validation_errors_1.formatLocation)(taxonomyLocation), `Please define a taxonomy permalink route, e.g. ${key}: /${key}/{slug}/.`);
             }
+            validatePath(value, taxonomyLocation, `/${key}/{slug}/`);
             if (key === 'tag') {
                 taxonomies.tag = value;
             }