ghost 6.57.1 → 6.58.0

package/core/server/services/url/permalink-matcher.ts

@@ -1,119 +0,0 @@
-const routeMatch = require('path-match')();
-
-import type {ResourceLookupParams} from './lazy-url-service';
-
-export type PermalinkParams = ResourceLookupParams & {
-    year?: string;
-    month?: string;
-    day?: string;
-    primary_tag?: string;
-    primary_author?: string;
-};
-
-const SUPPORTED_TOKENS = new Set([
-    'id',
-    'slug',
-    'year',
-    'month',
-    'day',
-    'primary_tag',
-    'primary_author'
-]);
-
-const FIELD_VALIDATORS: Record<string, RegExp> = {
-    id: /^[0-9a-f]{24}$/i,
-    year: /^\d{4}$/,
-    month: /^\d{2}$/,
-    day: /^\d{2}$/
-};
-
-const TOKEN = /:([A-Za-z_]\w*)/g;
-const PARAM = /:([A-Za-z_]\w*)(?:\([^)]*\))?[+*?]?/g;
-const BARE_PARAM = /:([A-Za-z_]\w*)(?![\w(])/g;
-
-function constrainHyphenatedPermalinkParams(permalink: string): string {
-    return permalink.split('/').map((segment) => {
-        if (!segment.includes('-')) {
-            return segment;
-        }
-
-        const params = [...segment.matchAll(PARAM)];
-
-        if (params.length < 2) {
-            return segment;
-        }
-
-        return segment.replace(BARE_PARAM, (match, ...args) => {
-            const offset = args[args.length - 2];
-            const index = params.findIndex(param => param.index === offset);
-            const isLastParamInSegment = index === params.length - 1;
-
-            return `${match}${isLastParamInSegment ? '([^/]+)' : '([^-/]+)'}`;
-        });
-    }).join('/');
-}
-
-function hasOnlySupportedTokens(template: string): boolean {
-    for (const [, token] of template.matchAll(TOKEN)) {
-        if (!SUPPORTED_TOKENS.has(token)) {
-            return false;
-        }
-    }
-    return true;
-}
-
-function valuesFitTheirFormat(params: Record<string, string>): boolean {
-    for (const [field, value] of Object.entries(params)) {
-        const pattern = FIELD_VALIDATORS[field];
-        if (pattern && !pattern.test(value)) {
-            return false;
-        }
-    }
-    return true;
-}
-
-export function matchPermalink(template: string, urlPath: string): PermalinkParams | null {
-    if (!hasOnlySupportedTokens(template)) {
-        return null;
-    }
-
-    const match = routeMatch(constrainHyphenatedPermalinkParams(template));
-
-    let params: Record<string, string> | false;
-    try {
-        params = match(urlPath);
-    } catch {
-        // path-match throws a 400 on an undecodable %-escape; treat as no match.
-        return null;
-    }
-
-    if (params === false) {
-        return null;
-    }
-
-    if (!valuesFitTheirFormat(params)) {
-        return null;
-    }
-
-    if (params.id === undefined && params.slug === undefined) {
-        return null;
-    }
-
-    return params as PermalinkParams;
-}
-
-/**
- * Narrows a matched permalink down to the single unique column the DB is
- * queried by. matchPermalink guarantees a queryable column is present, so this
- * is total — there is no "no lookup column" case to handle.
- */
-export function toLookupParams(params: PermalinkParams): ResourceLookupParams {
-    if ('id' in params) {
-        return {id: params.id};
-    }
-    return {slug: params.slug};
-}
-
-module.exports = {matchPermalink, toLookupParams};
-module.exports.matchPermalink = matchPermalink;
-module.exports.toLookupParams = toLookupParams;

package/core/server/services/url/router-filter.ts

@@ -1,80 +0,0 @@
-const nql = require('@tryghost/nql');
-const logging = require('@tryghost/logging');
-
-// NQL evaluation for routes.yaml collection filters, kept in one place so the
-// forward lookup, ownership check and reverse lookup all decide membership the
-// same way.
-export const EXPANSIONS = [
-    {key: 'author', replacement: 'authors.slug'},
-    {key: 'tags', replacement: 'tags.slug'},
-    {key: 'tag', replacement: 'tags.slug'},
-    {key: 'authors', replacement: 'authors.slug'},
-    {key: 'primary_tag', replacement: 'primary_tag.slug'},
-    {key: 'primary_author', replacement: 'primary_author.slug'}
-];
-
-const PAGE_TRANSFORMER = nql.utils.mapKeyValues({
-    key: {from: 'page', to: 'type'},
-    values: [
-        {from: false, to: 'post'},
-        {from: true, to: 'page'}
-    ]
-});
-
-// Accepts both singular DB types ('post') and plural router keys ('posts').
-const TYPE_TO_ROUTER_TYPE: Record<string, string> = {
-    post: 'posts',
-    posts: 'posts',
-    page: 'pages',
-    pages: 'pages',
-    tag: 'tags',
-    tags: 'tags',
-    author: 'authors',
-    authors: 'authors'
-};
-
-export interface CompiledFilter {
-    queryJSON(record: Record<string, unknown>): unknown;
-}
-
-export function routerTypeOf(resource: {type?: string} | null | undefined): string | null {
-    if (!resource || !resource.type) {
-        return null;
-    }
-    return TYPE_TO_ROUTER_TYPE[resource.type] || null;
-}
-
-export function buildFilter(filter: string | null | undefined): CompiledFilter | null {
-    if (!filter) {
-        return null;
-    }
-    return nql(filter, {expansions: EXPANSIONS, transformer: PAGE_TRANSFORMER});
-}
-
-// A null filter always matches; anything that throws is a non-match, not an
-// error.
-//
-// That covers malformed filters as well as odd records, because NQL parses
-// lazily: `buildFilter` returns happily for a filter like `((`, and the parse
-// error surfaces here on the first `queryJSON`. So this catch is the only
-// thing standing between a bad routes.yaml filter and a site that cannot
-// route — do not narrow it on the assumption that compilation already
-// failed somewhere upstream. Pinned in router-filter.test.js.
-export function filterMatches(compiledFilter: CompiledFilter | null, record: Record<string, unknown>): boolean {
-    if (!compiledFilter) {
-        return true;
-    }
-    try {
-        return !!compiledFilter.queryJSON(record);
-    } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        logging.warn('NQL match failed', message);
-        return false;
-    }
-}
-
-module.exports = {EXPANSIONS, routerTypeOf, buildFilter, filterMatches};
-module.exports.EXPANSIONS = EXPANSIONS;
-module.exports.routerTypeOf = routerTypeOf;
-module.exports.buildFilter = buildFilter;
-module.exports.filterMatches = filterMatches;

package/core/server/services/verification/verification-webhook-service.ts

@@ -1,137 +0,0 @@
-import crypto from 'crypto';
-const logging = require('@tryghost/logging');
-const request = require('@tryghost/request');
-const ghostVersion = require('@tryghost/version');
-const config = require('../../../shared/config');
-
-type VerificationTriggerMethod = 'admin' | 'api' | 'import';
-
-type VerificationWebhookBody = {
-    type: string;
-    siteId: string | null;
-    amountTriggered: number;
-    threshold: number;
-    method: VerificationTriggerMethod;
-};
-
-type VerificationWebhookServiceDependencies = {
-    config: {
-        get: (key: string) => unknown;
-    };
-    logging: {
-        info: (message: string) => void;
-        warn: (message: string) => void;
-        error: (message: string) => void;
-    };
-    request: (url: string, options: unknown) => Promise<unknown>;
-};
-
-const REQUEST_TIMEOUT_MS = 30_000;
-const MAX_RETRY_LIMIT = 5;
-
-export class VerificationWebhookService {
-    #config: VerificationWebhookServiceDependencies['config'];
-    #logging: VerificationWebhookServiceDependencies['logging'];
-    #request: VerificationWebhookServiceDependencies['request'];
-
-    constructor(dependencies: VerificationWebhookServiceDependencies = {config, logging, request}) {
-        this.#config = dependencies.config;
-        this.#logging = dependencies.logging;
-        this.#request = dependencies.request;
-    }
-
-    #readWebhookConfig() {
-        return {
-            webhookType: this.#config.get('hostSettings:emailVerification:webhookType'),
-            webhookUrl: this.#config.get('hostSettings:emailVerification:webhookUrl'),
-            webhookSecret: this.#config.get('hostSettings:emailVerification:webhookSecret') || '',
-            siteId: this.#config.get('hostSettings:siteId') || null
-        };
-    }
-
-    #computeSignature(timestamp: string, body: string, secret: string): string {
-        const baseString = `${timestamp}:${body}`;
-        return crypto.createHmac('sha256', secret).update(baseString).digest('base64');
-    }
-
-    #sanitizeWebhookUrl(webhookUrl: string): string {
-        try {
-            return new URL(webhookUrl).origin;
-        } catch {
-            return '[invalid webhook url]';
-        }
-    }
-
-    /**
-     * Sends a verification webhook to the configured endpoint.
-     */
-    async sendVerificationWebhook({
-        amountTriggered,
-        threshold,
-        method
-    }: {
-        amountTriggered: number;
-        threshold: number;
-        method: VerificationTriggerMethod;
-    }): Promise<boolean> {
-        const {webhookType, webhookUrl, webhookSecret, siteId} = this.#readWebhookConfig();
-
-        if (typeof webhookUrl !== 'string' || webhookUrl.length === 0) {
-            this.#logging.warn('Verification webhook is not configured because webhookUrl is missing.');
-            return false;
-        }
-
-        if (typeof webhookType !== 'string' || webhookType.length === 0) {
-            this.#logging.warn('Verification webhook is not configured because webhookType is missing.');
-            return false;
-        }
-
-        const payload: VerificationWebhookBody = {
-            type: webhookType,
-            siteId: typeof siteId === 'string' ? siteId : null,
-            amountTriggered,
-            threshold,
-            method
-        };
-
-        const requestBody = JSON.stringify(payload);
-        const timestamp = Date.now().toString();
-
-        const headers: Record<string, string | number> = {
-            'Content-Length': Buffer.byteLength(requestBody),
-            'Content-Type': 'application/json',
-            'Content-Version': `v${ghostVersion.safe}`,
-            'X-Ghost-Request-Timestamp': timestamp
-        };
-
-        if (typeof webhookSecret === 'string' && webhookSecret !== '') {
-            headers['X-Ghost-Signature'] = this.#computeSignature(timestamp, requestBody, webhookSecret);
-        }
-
-        const requestOptions = {
-            method: 'POST',
-            body: requestBody,
-            headers,
-            timeout: {
-                request: REQUEST_TIMEOUT_MS
-            },
-            retry: {
-                limit: process.env.NODE_ENV?.startsWith('test') ? 0 : MAX_RETRY_LIMIT
-            }
-        };
-
-        const sanitizedWebhookUrl = this.#sanitizeWebhookUrl(webhookUrl);
-        this.#logging.info(`Triggering verification webhook to "${sanitizedWebhookUrl}"`);
-
-        try {
-            await this.#request(webhookUrl, requestOptions);
-            return true;
-        } catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            this.#logging.error(`Failed to send verification webhook to "${sanitizedWebhookUrl}": ${message}`);
-            throw error;
-        }
-    }
-}
-
-export const verificationWebhookService = new VerificationWebhookService();

package/core/shared/config/helpers.ts

@@ -1,133 +0,0 @@
-import path from 'node:path';
-import {URL} from 'node:url';
-import type {Provider} from 'nconf';
-import type {BoundHelpers} from '@tryghost/config-url-helpers';
-
-/**
- * The subset of the config instance the helpers read from.
- */
-type ConfigLike = Pick<Provider, 'get'>;
-
-/**
- * The config instance once the url helpers have been bound to it.
- */
-type ConfigWithUrlHelpers = ConfigLike & BoundHelpers;
-
-/**
- * The set of helper methods that `bindAll` attaches to the config instance.
- */
-export interface ConfigHelpers {
-    isPrivacyDisabled(privacyFlag: string): boolean;
-    getContentPath(type: string): string;
-    getBackendMountPath(): string | RegExp;
-    getFrontendMountPath(): string | RegExp;
-    isTestEnv(): boolean;
-    isProductionOrDevelopment(): boolean;
-}
-
-const DEFAULT_HOST_ARG = /.*/;
-
-function escapeRegExp(string: string): string {
-    return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-
-function getHostInfo(config: ConfigWithUrlHelpers) {
-    const frontendHost = new URL(config.getSiteUrl()).hostname;
-
-    const adminUrl = config.getAdminUrl();
-    const backendHost = adminUrl ? new URL(adminUrl).hostname : '';
-    const hasSeparateBackendHost = backendHost && backendHost !== frontendHost;
-
-    return {
-        backendHost,
-        hasSeparateBackendHost
-    };
-}
-
-function getBackendMountPath(this: ConfigWithUrlHelpers): string | RegExp {
-    const {backendHost, hasSeparateBackendHost} = getHostInfo(this);
-
-    // with a separate admin url only serve on that host, otherwise serve on all hosts
-    return (hasSeparateBackendHost) && backendHost ? backendHost : DEFAULT_HOST_ARG;
-}
-
-function getFrontendMountPath(this: ConfigWithUrlHelpers): string | RegExp {
-    const {backendHost, hasSeparateBackendHost} = getHostInfo(this);
-
-    // with a separate admin url we adjust the frontend vhost to exclude requests to that host, otherwise serve on all hosts
-    return (hasSeparateBackendHost && backendHost) ? new RegExp(`^(?!${escapeRegExp(backendHost)}).*`) : DEFAULT_HOST_ARG;
-}
-
-function isPrivacyDisabled(this: ConfigLike, privacyFlag: string): boolean {
-    if (!this.get('privacy')) {
-        return false;
-    }
-
-    // CASE: disable all privacy features
-    if (this.get('privacy').useTinfoil === true) {
-        // CASE: you can still enable single features
-        if (this.get('privacy')[privacyFlag] === true) {
-            return false;
-        }
-
-        return true;
-    }
-
-    return this.get('privacy')[privacyFlag] === false;
-}
-
-function getContentPath(this: ConfigLike, type: string): string {
-    switch (type) {
-    case 'images':
-        return path.join(this.get('paths:contentPath'), 'images/');
-    case 'media':
-        return path.join(this.get('paths:contentPath'), 'media/');
-    case 'files':
-        return path.join(this.get('paths:contentPath'), 'files/');
-    case 'themes':
-        return path.join(this.get('paths:contentPath'), 'themes/');
-    case 'adapters':
-        return path.join(this.get('paths:contentPath'), 'adapters/');
-    case 'logs':
-        return path.join(this.get('paths:contentPath'), 'logs/');
-    case 'data':
-        return path.join(this.get('paths:contentPath'), 'data/');
-    case 'settings':
-        return path.join(this.get('paths:contentPath'), 'settings/');
-    case 'public':
-        return path.join(this.get('paths:contentPath'), 'public/');
-    default:
-        // new Error is allowed here, as we do not want config to depend on @tryghost/error
-        // @TODO: revisit this decision when @tryghost/error is no longer dependent on all of ghost-ignition
-        // eslint-disable-next-line ghost/ghost-custom/no-native-error
-        throw new Error('getContentPath was called with: ' + type);
-    }
-}
-
-function isTestEnv(this: ConfigLike): boolean {
-    return this.get('env').startsWith('test');
-}
-
-/**
- * env defaults to 'development' when NODE_ENV is unset (see getNodeEnv() in
- * ./utils.ts), matching ghost.js's own `process.env.NODE_ENV = process.env.NODE_ENV
- * || 'development'` at the real CLI entry point — so in any Ghost boot via the
- * normal entry point, this and a raw `process.env.NODE_ENV` check agree. They
- * only diverge for programmatic embedders that require core modules directly
- * without going through ghost.js and never set NODE_ENV themselves — those now
- * count as 'development' (e.g. explore-ping/update-check will phone home)
- * rather than being silently skipped.
- */
-function isProductionOrDevelopment(this: ConfigLike): boolean {
-    return ['development', 'production'].includes(this.get('env'));
-}
-
-export function bindAll(nconf: Provider & BoundHelpers): asserts nconf is Provider & BoundHelpers & ConfigHelpers {
-    const target = nconf as Provider & BoundHelpers & ConfigHelpers;
-    target.isPrivacyDisabled = isPrivacyDisabled.bind(nconf);
-    target.getContentPath = getContentPath.bind(nconf);
-    target.getBackendMountPath = getBackendMountPath.bind(nconf);
-    target.getFrontendMountPath = getFrontendMountPath.bind(nconf);
-    target.isTestEnv = isTestEnv.bind(nconf);
-    target.isProductionOrDevelopment = isProductionOrDevelopment.bind(nconf);
-}

package/core/shared/config/index.ts

@@ -1,12 +0,0 @@
-import {loadNconf} from './loader';
-
-// NOTE: this file must contain no export other than the `export =` below.
-// esbuild/tsx (used by the dev + test runners) can't combine `export =` with
-// any additional export statement — even an erasable `export type` — without
-// emitting a broken `<name>_module.exports = ...` reference that throws at
-// runtime. Import ConfigInstance directly from './loader' instead.
-
-// @ts-expect-error ignore erasableSyntaxOnly here because both js and ts
-// files import this, so use export = for now until we can update
-// all the imports to reference the default export.
-export = loadNconf();

package/core/shared/config/loader.ts

@@ -1,87 +0,0 @@
-import Nconf from 'nconf';
-import path from 'node:path';
-import {bindAll as bindUrlHelpers, type BoundHelpers} from '@tryghost/config-url-helpers';
-import * as localUtils from './utils';
-import {bindAll as bindHelpers, type ConfigHelpers} from './helpers';
-
-const _debug = require('@tryghost/debug')._base;
-const debug = _debug('ghost:config');
-
-interface LoadNconfOptions {
-    baseConfigPath?: string;
-    customConfigPath?: string;
-}
-
-export type ConfigInstance = Nconf.Provider & BoundHelpers & ConfigHelpers;
-
-function loadNconf(options?: LoadNconfOptions): ConfigInstance {
-    debug('config start');
-    const env = localUtils.getNodeEnv();
-    options = options || {};
-
-    const baseConfigPath = options.baseConfigPath || __dirname;
-    const customConfigPath = options.customConfigPath || process.cwd();
-    const nconf = new Nconf.Provider();
-
-    // ## Load Config
-
-    // no channel can override the overrides
-    nconf.file('overrides', path.join(baseConfigPath, 'overrides.json'));
-
-    // command line arguments take precedence, then environment variables
-    nconf.argv();
-    nconf.env({separator: '__', parseValues: true});
-
-    // Now load various config json files
-    nconf.file('custom-env', path.join(customConfigPath, 'config.' + env + '.json'));
-    if (!env.startsWith('testing')) {
-        if (process.env.GHOST_DEV_IS_DOCKER === 'true') {
-            nconf.file('docker-env', path.join(baseConfigPath, 'env', 'config.development.docker.json'));
-        }
-        nconf.file('local-env', path.join(customConfigPath, 'config.local.json'));
-        nconf.file('local-env-jsonc', {
-            file: path.join(customConfigPath, 'config.local.jsonc'),
-            format: localUtils.jsoncFormat
-        });
-    }
-    nconf.file('default-env', path.join(baseConfigPath, 'env', 'config.' + env + '.json'));
-
-    // Finally, we load defaults, if nothing else has a value this will
-    nconf.file('defaults', path.join(baseConfigPath, 'defaults.json'));
-
-    // ## Config Methods
-
-    // Expose dynamic utility methods
-    bindUrlHelpers(nconf);
-    bindHelpers(nconf);
-
-    // ## Sanitization
-
-    // transform all relative paths to absolute paths
-    localUtils.makePathsAbsolute(nconf, nconf.get('paths'), 'paths');
-
-    // transform sqlite filename path for Ghost-CLI
-    localUtils.sanitizeDatabaseProperties(nconf);
-
-    // Check if the URL in config has a protocol
-    localUtils.checkUrlProtocol(nconf.get('url'));
-
-    // Ensure that the content path exists
-    localUtils.doesContentPathExist(nconf.get('paths:contentPath'));
-
-    // ## Other Stuff!
-
-    // Manually set values
-    nconf.set('env', env);
-
-    // Wrap this in a check, because else nconf.get() is executed unnecessarily
-    // To output this, use DEBUG=ghost:*,ghost-config
-    if (_debug.enabled('ghost-config')) {
-        debug(nconf.get());
-    }
-
-    debug('config end');
-    return nconf;
-}
-
-export {loadNconf};

package/core/shared/config/utils.ts

@@ -1,104 +0,0 @@
-import path from 'node:path';
-import fs from 'node:fs';
-import * as jsonc from 'jsonc-parser';
-import type {Provider, IFormat} from 'nconf';
-
-/**
- * transform all relative paths to absolute paths
- * @TODO: re-write this function a little bit so we don't have to add the parent path - that is hard to understand
- *
- * Path must be string.
- * Path must match minimum one / or \
- * Path can be a "." to re-present current folder
- */
-function makePathsAbsolute(nconf: Provider, obj: Record<string, unknown>, parent: string): void {
-    Object.entries(obj).forEach(([pathsKey, configValue]) => {
-        if (configValue && typeof configValue === 'object') {
-            makePathsAbsolute(nconf, configValue as Record<string, unknown>, parent + ':' + pathsKey);
-        } else if (
-            typeof configValue === 'string' &&
-            (configValue.match(/\/+|\\+/) || configValue === '.') &&
-            !path.isAbsolute(configValue)
-        ) {
-            nconf.set(parent + ':' + pathsKey, path.normalize(path.join(__dirname, '../../..', configValue)));
-        }
-    });
-}
-
-function doesContentPathExist(contentPath: string): void {
-    if (!fs.existsSync(contentPath)) {
-        // new Error is allowed here, as we do not want config to depend on @tryghost/error
-        // @TODO: revisit this decision when @tryghost/error is no longer dependent on all of ghost-ignition
-        // eslint-disable-next-line ghost/ghost-custom/no-native-error
-        throw new Error('Your content path does not exist! Please double check `paths.contentPath` in your custom config file e.g. config.production.json.');
-    }
-}
-
-/**
-* Check if the URL in config has a protocol and sanitise it if not including a warning that it should be changed
-*/
-function checkUrlProtocol(url: string): void {
-    if (!url.match(/^https?:\/\//i)) {
-        // new Error is allowed here, as we do not want config to depend on @tryghost/error
-        // @TODO: revisit this decision when @tryghost/error is no longer dependent on all of ghost-ignition
-        // eslint-disable-next-line ghost/ghost-custom/no-native-error
-        throw new Error('URL in config must be provided with protocol, eg. "http://my-ghost-blog.com"');
-    }
-}
-
-/**
- * nconf merges all database keys together and this can be confusing
- * e.g. production default database is sqlite, but you override the configuration with mysql
- *
- * this.clear('key') does not work
- * https://github.com/indexzero/nconf/issues/235#issuecomment-257606507
- */
-function sanitizeDatabaseProperties(nconf: Provider): void {
-    if (nconf.get('database:client') === 'mysql') {
-        nconf.set('database:client', 'mysql2');
-    }
-
-    if (nconf.get('database:client') === 'sqlite3') {
-        nconf.set('database:client', 'better-sqlite3');
-    }
-
-    const database = nconf.get('database');
-    const client = nconf.get('database:client');
-
-    if (client === 'mysql2') {
-        delete database.connection.filename;
-    } else {
-        delete database.connection.host;
-        delete database.connection.user;
-        delete database.connection.password;
-        delete database.connection.database;
-    }
-
-    nconf.set('database', database);
-
-    if (client === 'better-sqlite3') {
-        makePathsAbsolute(nconf, nconf.get('database:connection'), 'database:connection');
-    }
-}
-
-function getNodeEnv(): string {
-    return process.env.NODE_ENV || 'development';
-}
-
-const jsoncFormat: IFormat = {
-    parse: function (text: string) {
-        return jsonc.parse(text);
-    },
-    stringify: function (obj: unknown, replacer: unknown, spacing?: unknown) {
-        return JSON.stringify(obj, replacer as Parameters<typeof JSON.stringify>[1], spacing as string | number);
-    }
-};
-
-export {
-    makePathsAbsolute,
-    doesContentPathExist,
-    checkUrlProtocol,
-    sanitizeDatabaseProperties,
-    getNodeEnv,
-    jsoncFormat
-};