ghost 6.57.1 → 6.58.0

package/core/server/services/activitypub/activity-pub-service.ts

@@ -1,216 +0,0 @@
-import ObjectID from 'bson-objectid';
-import {Knex} from 'knex';
-import {IdentityTokenService} from '../identity-tokens/identity-token-service';
-import fetch from 'node-fetch';
-
-type ExpectedWebhook = {
-    event: string;
-    target_url: URL;
-    api_version: string;
-    secret: string;
-};
-
-interface Logger {
-    info(message: string): void
-    warn(message: string): void
-    error(message: string): void
-}
-
-export class ActivityPubService {
-    private knex: Knex;
-    private siteUrl: URL;
-    private logging: Logger;
-    private identityTokenService: IdentityTokenService;
-
-    constructor(
-        knex: Knex,
-        siteUrl: URL,
-        logging: Logger,
-        identityTokenService: IdentityTokenService
-    ) {
-        this.knex = knex;
-        this.siteUrl = siteUrl;
-        this.logging = logging;
-        this.identityTokenService = identityTokenService;
-    }
-
-    getExpectedWebhooks(secret: string): ExpectedWebhook[] {
-        return [
-            {
-                event: 'post.published',
-                target_url: new URL('.ghost/activitypub/v1/webhooks/post/published', this.siteUrl),
-                api_version: 'v5.100.0',
-                secret
-            },
-            {
-                event: 'post.deleted',
-                target_url: new URL('.ghost/activitypub/v1/webhooks/post/deleted', this.siteUrl),
-                api_version: 'v5.100.0',
-                secret
-            },
-            {
-                event: 'post.unpublished',
-                target_url: new URL('.ghost/activitypub/v1/webhooks/post/unpublished', this.siteUrl),
-                api_version: 'v5.100.0',
-                secret
-            },
-            {
-                event: 'post.published.edited',
-                target_url: new URL('.ghost/activitypub/v1/webhooks/post/updated', this.siteUrl),
-                api_version: 'v5.100.0',
-                secret
-            }
-        ];
-    }
-
-    async checkWebhookState(expectedWebhooks: ExpectedWebhook[], integration: {id: string}) {
-        this.logging.info(`Checking ActivityPub Webhook state`);
-
-        const webhooks = await this.knex
-            .select('*')
-            .from('webhooks')
-            .where('integration_id', '=', integration.id);
-
-        if (webhooks.length !== expectedWebhooks.length) {
-            this.logging.warn(`Expected ${expectedWebhooks.length} webhooks for ActivityPub`);
-            return false;
-        }
-
-        for (const expectedWebhook of expectedWebhooks) {
-            const foundWebhook = webhooks.find((webhook) => {
-                return webhook.event === expectedWebhook.event && webhook.target_url === expectedWebhook.target_url.href && webhook.secret === expectedWebhook.secret;
-            });
-            if (!foundWebhook) {
-                this.logging.error(`Could not find webhook for ${expectedWebhook.event} ${expectedWebhook.target_url}`);
-                return false;
-            }
-        }
-
-        return true;
-    }
-
-    async getWebhookSecret(): Promise<string | null> {
-        try {
-            const token = await this.getOwnerUserToken();
-
-            const res = await fetch(new URL('.ghost/activitypub/v1/site/', this.siteUrl), {
-                headers: {
-                    Authorization: `Bearer ${token}`
-                }
-            });
-
-            const body = await res.json();
-
-            return body.webhook_secret;
-        } catch (err: unknown) {
-            this.logging.error(`Could not get webhook secret for ActivityPub ${err}`);
-            return null;
-        }
-    }
-
-    async disable() {
-        await this.removeWebhooks();
-        await this.disableSite();
-    }
-
-    async enable() {
-        await this.initialiseWebhooks();
-    }
-
-    async removeWebhooks() {
-        const integration = await this.knex
-            .select('*')
-            .from('integrations')
-            .where('slug', '=', 'ghost-activitypub')
-            .andWhere('type', '=', 'internal')
-            .first();
-
-        if (!integration) {
-            this.logging.error('No ActivityPub integration found - cannot remove webhooks');
-            return;
-        }
-
-        await this.knex
-            .del()
-            .from('webhooks')
-            .where('integration_id', '=', integration.id);
-    }
-
-    async initialiseWebhooks() {
-        const integration = await this.knex
-            .select('*')
-            .from('integrations')
-            .where('slug', '=', 'ghost-activitypub')
-            .andWhere('type', '=', 'internal')
-            .first();
-
-        if (!integration) {
-            this.logging.error('No ActivityPub integration found - cannot initialise');
-            return;
-        }
-
-        const secret = await this.getWebhookSecret();
-
-        if (!secret) {
-            this.logging.error('No webhook secret found - cannot initialise');
-            return;
-        }
-
-        const expectedWebhooks = this.getExpectedWebhooks(secret);
-        const isInCorrectState = await this.checkWebhookState(expectedWebhooks, integration);
-
-        if (isInCorrectState) {
-            this.logging.info(`ActivityPub webhooks in correct state`);
-            return;
-        }
-
-        this.logging.info(`ActivityPub webhooks in incorrect state, deleting all of them and starting fresh`);
-        await this.knex
-            .del()
-            .from('webhooks')
-            .where('integration_id', '=', integration.id);
-
-        const webhooksToInsert = expectedWebhooks.map((expectedWebhook) => {
-            return {
-                id: (new ObjectID).toHexString(),
-                event: expectedWebhook.event,
-                target_url: expectedWebhook.target_url.href,
-                api_version: expectedWebhook.api_version,
-                name: `ActivityPub ${expectedWebhook.event} Webhook`,
-                secret: secret,
-                integration_id: integration.id,
-                created_at: this.knex.raw('current_timestamp')
-            };
-        });
-
-        await this.knex
-            .insert(webhooksToInsert)
-            .into('webhooks');
-    }
-
-    async disableSite() {
-        try {
-            const token = await this.getOwnerUserToken();
-
-            await fetch(new URL('.ghost/activitypub/v1/site/', this.siteUrl), {
-                method: 'DELETE',
-                headers: {
-                    Authorization: `Bearer ${token}`
-                }
-            });
-        } catch (err: unknown) {
-            this.logging.error(`Could not disable ActivityPub for site: ${this.siteUrl} due to: ${err}`);
-        }
-    }
-
-    private async getOwnerUserToken() {
-        const ownerUser = await this.knex('users')
-            .select('users.*')
-            .join('roles_users', 'users.id', 'roles_users.user_id')
-            .join('roles', 'roles.id', 'roles_users.role_id')
-            .where('roles.name', 'Owner')
-            .first();
-
-        return await this.identityTokenService.getTokenForUser(ownerUser.email, 'Owner');
-    }
-}

package/core/server/services/adapter-manager/adapter-manager.ts

@@ -1,253 +0,0 @@
-import errors from '@tryghost/errors';
-import {loadAdapterClass, resolveAdapterOptions, normalizeAdapterConfig, getConfiguredFeatures} from './utils';
-import type {ConfigInstance} from '../../../shared/config/loader';
-import type {
-    Adapter,
-    AdapterConstructor,
-    AdapterName,
-    ResolvedAdapter
-} from './types';
-
-/**
- * A map from an adapter type name (e.g. "storage") to the base class every
- * adapter of that type must extend.
- */
-export type BaseClassMap = Record<string, AdapterConstructor>;
-
-/**
- * The type-only registry derived from a `BaseClassMap`: each adapter type name
- * mapped to the instance type of its base class. Read back by `getAdapter` to
- * return a precisely-typed instance.
- */
-export type RegistryOf<BaseClasses extends BaseClassMap> = {
-    [Type in keyof BaseClasses]: InstanceType<BaseClasses[Type]>;
-};
-
-export interface AdapterManagerOptions<BaseClasses extends BaseClassMap = BaseClassMap> {
-    /** The paths to check, e.g. ['content/adapters', 'core/server/adapters'] */
-    pathsToAdapters: string[];
-    /** A function to load adapters, e.g. global.require */
-    loadAdapterFromPath: (path: string) => unknown;
-    /** The base classes keyed by adapter type name, e.g. {storage: GhostStorageBase} */
-    baseClasses: BaseClasses;
-    /** The config instance used to resolve which adapter and options to load */
-    config: ConfigInstance;
-}
-
-/**
- * AdapterManager loads, validates and caches adapter instances by type.
- *
- * The set of known adapter types (and the base class each must extend) is fixed
- * at construction time via the `baseClasses` map. The `BaseClasses` type
- * parameter is inferred from that map, so `getAdapter` can return a
- * precisely-typed instance:
- *
- * ```ts
- * const mgr = new AdapterManager({
- *     pathsToAdapters,
- *     loadAdapterFromPath,
- *     config,
- *     baseClasses: {sso: SSOBase, storage: StorageBase}
- * });
- *
- * mgr.getAdapter('sso');            // => SSOBase instance
- * mgr.getAdapter('storage:images'); // => StorageBase instance
- * ```
- */
-export class AdapterManager<BaseClasses extends BaseClassMap = BaseClassMap> {
-    private baseClasses: BaseClassMap;
-    private instanceCache: Record<string, Record<string, Adapter>>;
-    private pathsToAdapters: string[];
-    private loadAdapterFromPath: (path: string) => unknown;
-    private config: ConfigInstance;
-
-    constructor({pathsToAdapters, loadAdapterFromPath, baseClasses, config}: AdapterManagerOptions<BaseClasses>) {
-        this.baseClasses = {};
-        this.instanceCache = {};
-        this.pathsToAdapters = pathsToAdapters;
-        this.loadAdapterFromPath = loadAdapterFromPath;
-        this.config = config;
-
-        for (const [type, BaseClass] of Object.entries(baseClasses)) {
-            if (type.includes(':')) {
-                throw new errors.IncorrectUsageError({
-                    message: `Adapter type "${type}" cannot contain a colon.`
-                });
-            }
-
-            this.instanceCache[type] = {};
-            this.baseClasses[type] = BaseClass;
-        }
-    }
-
-    /**
-     * Force recreation of all instances instead of reusing cached instances.
-     * Use when editing config file during tests.
-     */
-    clearCache(): void {
-        for (const key of Object.keys(this.instanceCache)) {
-            this.instanceCache[key] = {};
-        }
-    }
-
-    /**
-     * getAdapter
-     *
-     * Resolves the active adapter class name and options for the given name from
-     * config, then loads, validates and caches the adapter instance.
-     *
-     * @param name The name of the type of adapter, e.g. "storage" or
-     *   "scheduling", optionally including the feature, e.g. "storage:images"
-     *
-     * @returns The resolved and instantiated adapter
-     */
-    getAdapter<Name extends AdapterName<RegistryOf<BaseClasses>>>(
-        name: Name
-    ): ResolvedAdapter<RegistryOf<BaseClasses>, Name>;
-    getAdapter(name: string): Adapter {
-        if (!name) {
-            throw new errors.IncorrectUsageError({
-                message: 'getAdapter must be called with an adapter name.'
-            });
-        }
-
-        const {Adapter, adapterConfig, adapterType, adapterClassName} = this.loadAdapter(name);
-        const adapterCache = this.instanceCache[adapterType];
-
-        // @NOTE: example cache key value 'email:newsletters:custom-newsletter-adapter'
-        const adapterCacheKey = `${name}:${adapterClassName}`;
-        if (adapterCache[adapterCacheKey]) {
-            return adapterCache[adapterCacheKey];
-        }
-
-        // `Adapter` is an abstract-compatible constructor type; the runtime value
-        // is always a concrete class here, so instantiation is safe.
-        const AdapterClass = Adapter as new (config?: object) => Adapter;
-        const adapter = new AdapterClass(adapterConfig);
-
-        const BaseClass = this.baseClasses[adapterType];
-        if (!(adapter instanceof BaseClass)) {
-            if (Object.getPrototypeOf(Adapter).name !== BaseClass.name) {
-                throw new errors.IncorrectUsageError({
-                    message: `${adapterType} adapter ${adapterClassName} does not inherit from the base class.`
-                });
-            }
-        }
-
-        if (!Array.isArray(adapter.requiredFns)) {
-            throw new errors.IncorrectUsageError({
-                message: `${adapterType} adapter ${adapterClassName} does not have the requiredFns array.`
-            });
-        }
-
-        for (const requiredFn of adapter.requiredFns) {
-            if (typeof (adapter as any)[requiredFn] !== 'function') {
-                throw new errors.IncorrectUsageError({
-                    message: `${adapterType} adapter ${adapterClassName} is missing the ${requiredFn} method.`
-                });
-            }
-        }
-
-        adapterCache[adapterCacheKey] = adapter;
-
-        return adapter;
-    }
-
-    /**
-     * Resolve the active adapter class name and options for `name` from config,
-     * then locate and load the adapter constructor from `pathsToAdapters`.
-     *
-     * Does not instantiate the adapter or touch the instance cache — shared by
-     * `getAdapter` (which instantiates + caches) and `init` (which validates).
-     */
-    private loadAdapter(name: string): {
-        Adapter: AdapterConstructor;
-        adapterConfig: object;
-        adapterType: string;
-        adapterClassName: string;
-    } {
-        // Re-read config on every call so runtime config changes (and test config
-        // overrides) are reflected, matching the original JS implementation.
-        const adapterServiceConfig = normalizeAdapterConfig(this.config);
-        const {adapterClassName, adapterConfig} = resolveAdapterOptions(name, adapterServiceConfig);
-
-        const [adapterType] = name.split(':');
-
-        if (!this.baseClasses[adapterType]) {
-            throw new errors.NotFoundError({
-                message: `Unknown adapter type ${adapterType}. Please register adapter.`
-            });
-        }
-
-        if (!adapterClassName) {
-            throw new errors.IncorrectUsageError({
-                message: `Unable to find ${adapterType} adapter in ${this.pathsToAdapters}.`
-            });
-        }
-
-        const Adapter = loadAdapterClass(adapterType, adapterClassName, this.pathsToAdapters, this.loadAdapterFromPath);
-
-        return {Adapter, adapterConfig: adapterConfig ?? {}, adapterType, adapterClassName};
-    }
-
-    /**
-     * Validate the config of every configured adapter up-front, so
-     * misconfiguration fails at boot rather than on first lazy `getAdapter`.
-     *
-     * Enumerates the active adapter for each registered type plus every
-     * configured feature variant (e.g. `storage:media`), resolves each to a
-     * distinct class + config, and calls the adapter's optional static
-     * `validate` when present. All failures — bad config or a failure to load a
-     * configured adapter — are aggregated into a single error so an operator
-     * sees every problem at once. Types with no configured adapter are skipped;
-     * presence is still enforced on use by `getAdapter`.
-     */
-    init(): void {
-        const adapterServiceConfig = normalizeAdapterConfig(this.config);
-
-        // 1. Enumerate every configured adapter name (active + feature variants).
-        const names: string[] = [];
-        for (const adapterType of Object.keys(this.baseClasses)) {
-            names.push(adapterType);
-            for (const feature of getConfiguredFeatures(adapterServiceConfig[adapterType])) {
-                names.push(`${adapterType}:${feature}`);
-            }
-        }
-
-        // 2. Resolve to distinct class + config pairs, skipping unconfigured
-        //    types/features and deduping identical class+config combinations.
-        const distinct = new Map<string, string>();
-        for (const name of names) {
-            const {adapterClassName, adapterConfig} = resolveAdapterOptions(name, adapterServiceConfig);
-            if (!adapterClassName) {
-                continue;
-            }
-            const [adapterType] = name.split(':');
-            const key = `${adapterType}:${adapterClassName}:${JSON.stringify(adapterConfig ?? {})}`;
-            if (!distinct.has(key)) {
-                distinct.set(key, name);
-            }
-        }
-
-        // 3. Load + validate each distinct adapter, aggregating all failures.
-        const failures: {name: string; err: Error}[] = [];
-        for (const name of distinct.values()) {
-            try {
-                const {Adapter, adapterConfig} = this.loadAdapter(name);
-                if (typeof Adapter.validate === 'function') {
-                    Adapter.validate(adapterConfig);
-                }
-            } catch (err) {
-                failures.push({name, err: err as Error});
-            }
-        }
-
-        if (failures.length > 0) {
-            const details = failures.map(({name, err}) => `- ${name}: ${err.message}`).join('\n');
-            throw new errors.IncorrectUsageError({
-                message: `Invalid adapter configuration:\n${details}`,
-                errorDetails: failures.map(({name, err}) => ({adapter: name, message: err.message}))
-            });
-        }
-    }
-}

package/core/server/services/adapter-manager/adapter-paths.ts

@@ -1,26 +0,0 @@
-import config from '../../../shared/config';
-import type {ConfigInstance} from '../../../shared/config/loader';
-
-/**
- * Where adapters are looked up, in order. Also read by bin/validate-adapters.ts,
- * which checks adapter implementations at build time - keep this the only place
- * the lookup order is declared, so a name resolves there exactly as it does here.
- */
-export function buildAdapterPaths(configInstance: ConfigInstance): string[] {
-    return Array.from(new Set<string>([
-        '', // A blank path will cause us to check node_modules for the adapter
-        configInstance.get('paths').internalAdaptersPath,
-
-        // custom docker builds may install adapters in a separate path from content,
-        // since the content dir is often bind-mounted into the container. Offering
-        // an escape hatch here to allow for this
-        configInstance.get('paths').installedAdaptersPath ?? '',
-
-        // load adapters from content last, so that they don't override any other
-        // internal or platform-installed adapters
-        // TODO: potentially deprecate/remove as part of Ghost 7.0
-        configInstance.getContentPath('adapters')
-    ]));
-}
-
-export const adapterPaths: string[] = buildAdapterPaths(config);

package/core/server/services/adapter-manager/base-classes.ts

@@ -1,22 +0,0 @@
-import {StorageBase} from 'ghost-storage-base';
-import {SchedulingBase} from '@tryghost/adapter-base-scheduling';
-import {SSOBase} from '@tryghost/adapter-base-sso';
-import {CacheBase} from '@tryghost/adapter-base-cache';
-import {RedirectsStoreBase} from '@tryghost/adapter-base-redirects';
-import {RouteSettingsStoreBase} from '@tryghost/adapter-base-route-settings';
-
-import type {BaseClassMap} from './adapter-manager';
-
-/**
- * The base class every adapter of a given type must extend. Also read by
- * bin/validate-adapters.js, which checks adapter implementations at build time -
- * keep this the only place the mapping is declared.
- */
-export const baseClasses = {
-    storage: StorageBase,
-    scheduling: SchedulingBase,
-    sso: SSOBase,
-    cache: CacheBase,
-    redirects: RedirectsStoreBase,
-    'route-settings': RouteSettingsStoreBase
-} satisfies BaseClassMap;

package/core/server/services/adapter-manager/index.ts

@@ -1,16 +0,0 @@
-import {AdapterManager} from './adapter-manager';
-import {adapterPaths} from './adapter-paths';
-import {baseClasses} from './base-classes';
-import config from '../../../shared/config';
-
-// A singleton adapter manager, preconfigured with the base classes for every
-// known adapter type. `getAdapter` resolves the active adapter and its options
-// from config on each call, so runtime config changes are always reflected.
-const adapterManager = new AdapterManager({
-    loadAdapterFromPath: require,
-    config,
-    pathsToAdapters: adapterPaths,
-    baseClasses
-});
-
-export default adapterManager;

package/core/server/services/adapter-manager/types.ts

@@ -1,45 +0,0 @@
-export interface Adapter {
-    requiredFns: readonly string[];
-}
-
-/**
- * Constructor type that matches abstract as well as concrete base classes.
- *
- * The optional static `validate` lets an adapter check the options it would be
- * constructed with — without being instantiated — so misconfiguration can be
- * surfaced at boot rather than on first lazy use. It is synchronous and throws
- * (e.g. `IncorrectUsageError`) when the config is invalid. This is the loose,
- * manager-facing signature; a concrete adapter is free to declare a narrower
- * assertion signature (`asserts config is XOptions`) on its own static.
- */
-export type AdapterConstructor<T extends Adapter = Adapter> = (abstract new (...args: any[]) => T) & {
-    validate?(config?: object): void;
-};
-
-/**
- * A type-only registry mapping an adapter type name (e.g. "storage") to the
- * instance type of the base class registered for it. Derived from the
- * `baseClasses` map passed to `AdapterManager` — see `RegistryOf`.
- */
-export type AdapterRegistry = Record<string, Adapter>;
-
-/**
- * Strip an optional ":feature" suffix from an adapter name.
- * e.g. "storage:images" -> "storage", "storage" -> "storage"
- */
-export type AdapterType<Name extends string> = Name extends `${infer Type}:${string}` ? Type : Name;
-
-/**
- * All valid names accepted by `getAdapter` for a given registry: each registered
- * type on its own, plus any "type:feature" extension of it.
- */
-export type AdapterName<Registry extends AdapterRegistry> = keyof Registry extends string
-    ? keyof Registry | `${keyof Registry}:${string}`
-    : never;
-
-/**
- * Resolve the registered adapter instance type for a (possibly feature-suffixed)
- * name, e.g. ResolvedAdapter<R, "storage:images"> === R["storage"].
- */
-export type ResolvedAdapter<Registry extends AdapterRegistry, Name extends string> =
-    AdapterType<Name> extends keyof Registry ? Registry[AdapterType<Name>] : never;