ghost 5.115.1 → 5.116.0

package/core/server/services/recommendations/service/RecommendationMetadataService.js

@@ -0,0 +1,86 @@
+"use strict";
+/* eslint-disable ghost/filenames/match-exported-class */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RecommendationMetadataService = void 0;
+class RecommendationMetadataService {
+    #oembedService;
+    #externalRequest;
+    constructor(dependencies) {
+        this.#oembedService = dependencies.oembedService;
+        this.#externalRequest = dependencies.externalRequest;
+    }
+    async #fetchJSON(url, options) {
+        // Even though we have throwHttpErrors: false, we still need to catch DNS errors
+        // that can arise from externalRequest, otherwise we'll return a HTTP 500 to the user
+        try {
+            // default content type is application/x-www-form-encoded which is what we need for the webmentions spec
+            const response = await this.#externalRequest.get(url.toString(), {
+                throwHttpErrors: false,
+                maxRedirects: 10,
+                followRedirect: true,
+                timeout: 15000,
+                retry: {
+                    // Only retry on network issues, or specific HTTP status codes
+                    limit: 3
+                },
+                ...options
+            });
+            if (response.statusCode >= 200 && response.statusCode < 300) {
+                try {
+                    return JSON.parse(response.body);
+                }
+                catch (e) {
+                    return undefined;
+                }
+            }
+        }
+        catch (e) {
+            return undefined;
+        }
+    }
+    #castUrl(url) {
+        if (!url) {
+            return null;
+        }
+        try {
+            return new URL(url);
+        }
+        catch (e) {
+            return null;
+        }
+    }
+    async fetch(url, options = { timeout: 5000 }) {
+        // Make sure url path ends with a slash (urls should be resolved relative to the path)
+        if (!url.pathname.endsWith('/')) {
+            url.pathname += '/';
+        }
+        // 1. Check if it is a Ghost site
+        let ghostSiteData = await this.#fetchJSON(new URL('members/api/site', url), options);
+        if (!ghostSiteData && url.pathname !== '' && url.pathname !== '/') {
+            // Try root relative URL
+            ghostSiteData = await this.#fetchJSON(new URL('members/api/site', url.origin), options);
+        }
+        if (ghostSiteData && typeof ghostSiteData === 'object' && ghostSiteData.site && typeof ghostSiteData.site === 'object') {
+            // Check if the Ghost site returns allow_external_signup, otherwise it is an old Ghost version that returns unreliable data
+            if (typeof ghostSiteData.site.allow_external_signup === 'boolean') {
+                return {
+                    title: ghostSiteData.site.title || null,
+                    excerpt: ghostSiteData.site.description || null,
+                    featuredImage: this.#castUrl(ghostSiteData.site.cover_image),
+                    favicon: this.#castUrl(ghostSiteData.site.icon || ghostSiteData.site.logo),
+                    oneClickSubscribe: !!ghostSiteData.site.allow_external_signup
+                };
+            }
+        }
+        // Use the oembed service to fetch metadata
+        const oembed = await this.#oembedService.fetchOembedDataFromUrl(url.toString(), 'mention');
+        return {
+            title: oembed?.metadata?.title || null,
+            excerpt: oembed?.metadata?.description || null,
+            featuredImage: this.#castUrl(oembed?.metadata?.thumbnail),
+            favicon: this.#castUrl(oembed?.metadata?.icon),
+            oneClickSubscribe: false
+        };
+    }
+}
+exports.RecommendationMetadataService = RecommendationMetadataService;

package/core/server/services/recommendations/service/RecommendationMetadataService.ts

@@ -0,0 +1,128 @@
+/* eslint-disable ghost/filenames/match-exported-class */
+
+type OembedMetadata<Type extends string> = {
+    version: '1.0',
+    type: Type,
+    url: string,
+    metadata: {
+        title: string|null,
+        description: string|null,
+        publisher: string|null,
+        author: string|null,
+        thumbnail: string|null,
+        icon: string|null
+    },
+    body?: Type extends 'mention' ? string : unknown,
+    contentType?: Type extends 'mention' ? string : unknown
+}
+
+type OEmbedService = {
+    fetchOembedDataFromUrl<Type extends string>(url: string, type: Type, options?: {timeout?: number}): Promise<OembedMetadata<Type>>
+}
+
+type ExternalRequest = {
+    get(url: string, options: object): Promise<{statusCode: number, body: string}>
+}
+
+export type RecommendationMetadata = {
+    title: string|null,
+    excerpt: string|null,
+    featuredImage: URL|null,
+    favicon: URL|null,
+    oneClickSubscribe: boolean
+}
+
+export class RecommendationMetadataService {
+    #oembedService: OEmbedService;
+    #externalRequest: ExternalRequest;
+
+    constructor(dependencies: {oembedService: OEmbedService, externalRequest: ExternalRequest}) {
+        this.#oembedService = dependencies.oembedService;
+        this.#externalRequest = dependencies.externalRequest;
+    }
+
+    async #fetchJSON(url: URL, options?: {timeout?: number}) {
+        // Even though we have throwHttpErrors: false, we still need to catch DNS errors
+        // that can arise from externalRequest, otherwise we'll return a HTTP 500 to the user
+        try {
+            // default content type is application/x-www-form-encoded which is what we need for the webmentions spec
+            const response = await this.#externalRequest.get(url.toString(), {
+                throwHttpErrors: false,
+                maxRedirects: 10,
+                followRedirect: true,
+                timeout: 15000,
+                retry: {
+                    // Only retry on network issues, or specific HTTP status codes
+                    limit: 3
+                },
+                ...options
+            });
+
+            if (response.statusCode >= 200 && response.statusCode < 300) {
+                try {
+                    return JSON.parse(response.body);
+                } catch (e) {
+                    return undefined;
+                }
+            }
+        } catch (e) {
+            return undefined;
+        }
+    }
+
+    #castUrl(url: string|null|undefined): URL|null {
+        if (!url) {
+            return null;
+        }
+        try {
+            return new URL(url);
+        } catch (e) {
+            return null;
+        }
+    }
+
+    async fetch(url: URL, options: {timeout: number} = {timeout: 5000}): Promise<RecommendationMetadata> {
+        // Make sure url path ends with a slash (urls should be resolved relative to the path)
+        if (!url.pathname.endsWith('/')) {
+            url.pathname += '/';
+        }
+
+        // 1. Check if it is a Ghost site
+        let ghostSiteData = await this.#fetchJSON(
+            new URL('members/api/site', url),
+            options
+        );
+
+        if (!ghostSiteData && url.pathname !== '' && url.pathname !== '/') {
+            // Try root relative URL
+            ghostSiteData = await this.#fetchJSON(
+                new URL('members/api/site', url.origin),
+                options
+            );
+        }
+
+        if (ghostSiteData && typeof ghostSiteData === 'object' && ghostSiteData.site && typeof ghostSiteData.site === 'object') {
+            // Check if the Ghost site returns allow_external_signup, otherwise it is an old Ghost version that returns unreliable data
+            if (typeof ghostSiteData.site.allow_external_signup === 'boolean') {
+                return {
+                    title: ghostSiteData.site.title || null,
+                    excerpt: ghostSiteData.site.description || null,
+                    featuredImage: this.#castUrl(ghostSiteData.site.cover_image),
+                    favicon: this.#castUrl(ghostSiteData.site.icon || ghostSiteData.site.logo),
+                    oneClickSubscribe: !!ghostSiteData.site.allow_external_signup
+                };
+            }
+        }
+
+        // Use the oembed service to fetch metadata
+        const oembed = await this.#oembedService.fetchOembedDataFromUrl(url.toString(), 'mention');
+
+        return {
+            title: oembed?.metadata?.title || null,
+            excerpt: oembed?.metadata?.description || null,
+            featuredImage: this.#castUrl(oembed?.metadata?.thumbnail),
+            favicon: this.#castUrl(oembed?.metadata?.icon),
+            oneClickSubscribe: false
+        };
+    }
+}

package/core/server/services/recommendations/service/RecommendationRepository.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/core/server/services/recommendations/service/RecommendationRepository.ts

@@ -0,0 +1,13 @@
+import {AllOptions} from './BookshelfRepository';
+import {Recommendation} from './Recommendation';
+
+export interface RecommendationRepository {
+    save(entity: Recommendation): Promise<void>;
+    getById(id: string): Promise<Recommendation | null>;
+    getByUrl(url: URL): Promise<Recommendation|null>;
+    getAll(options: Omit<AllOptions<Recommendation>, 'page'|'limit'>): Promise<Recommendation[]>;
+    getPage(options: AllOptions<Recommendation> & Required<Pick<AllOptions<Recommendation>, 'page'|'limit'>>): Promise<Recommendation[]>;
+    getCount(options: {
+        filter?: string;
+    }): Promise<number>;
+}

package/core/server/services/recommendations/service/RecommendationService.js

@@ -0,0 +1,228 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RecommendationService = void 0;
+const errors_1 = __importDefault(require("@tryghost/errors"));
+const logging_1 = __importDefault(require("@tryghost/logging"));
+const tpl_1 = __importDefault(require("@tryghost/tpl"));
+const ClickEvent_1 = require("./ClickEvent");
+const Recommendation_1 = require("./Recommendation");
+const SubscribeEvent_1 = require("./SubscribeEvent");
+const messages = {
+    notFound: 'Recommendation with id {id} not found'
+};
+class RecommendationService {
+    repository;
+    clickEventRepository;
+    subscribeEventRepository;
+    wellknownService;
+    mentionSendingService;
+    recommendationEnablerService;
+    recommendationMetadataService;
+    constructor(deps) {
+        this.repository = deps.repository;
+        this.wellknownService = deps.wellknownService;
+        this.mentionSendingService = deps.mentionSendingService;
+        this.recommendationEnablerService = deps.recommendationEnablerService;
+        this.clickEventRepository = deps.clickEventRepository;
+        this.subscribeEventRepository = deps.subscribeEventRepository;
+        this.recommendationMetadataService = deps.recommendationMetadataService;
+    }
+    async init() {
+        const recommendations = await this.#listRecommendations();
+        await this.updateWellknown(recommendations);
+        // Do a slow update of all the recommendation metadata (keeping logo up to date, one-click-subscribe, etc.)
+        // We better move this to a job in the future
+        if (!process.env.NODE_ENV?.startsWith('test')) {
+            setTimeout(async () => {
+                try {
+                    await this.updateAllRecommendationsMetadata();
+                }
+                catch (e) {
+                    logging_1.default.error('[Recommendations] Failed to update all recommendations metadata on boot', e);
+                }
+            }, 2 * 60 * 1000 + Math.random() * 5 * 60 * 1000);
+        }
+    }
+    async updateAllRecommendationsMetadata() {
+        const recommendations = await this.#listRecommendations();
+        logging_1.default.info('[Recommendations] Updating recommendations metadata');
+        for (const recommendation of recommendations) {
+            try {
+                await this._updateRecommendationMetadata(recommendation);
+                await this.repository.save(recommendation);
+            }
+            catch (e) {
+                logging_1.default.error('[Recommendations] Failed to save updated metadata for recommendation ' + recommendation.url.toString(), e);
+            }
+        }
+    }
+    async updateWellknown(recommendations) {
+        await this.wellknownService.set(recommendations);
+    }
+    async updateRecommendationsEnabledSetting(recommendations) {
+        const expectedSetting = (recommendations.length > 0).toString();
+        const currentSetting = this.recommendationEnablerService.getSetting();
+        if (currentSetting && currentSetting === expectedSetting) {
+            return;
+        }
+        await this.recommendationEnablerService.setSetting(expectedSetting);
+    }
+    sendMentionToRecommendation(recommendation) {
+        this.mentionSendingService.sendAll({
+            url: this.wellknownService.getURL(),
+            links: [
+                recommendation.url
+            ]
+        }).catch((err) => {
+            logging_1.default.error('Failed to send mention to recommendation', err);
+        });
+    }
+    async readRecommendation(id) {
+        const recommendation = await this.repository.getById(id);
+        if (!recommendation) {
+            throw new errors_1.default.NotFoundError({
+                message: (0, tpl_1.default)(messages.notFound, { id })
+            });
+        }
+        return recommendation.plain;
+    }
+    async addRecommendation(addRecommendation) {
+        const recommendation = Recommendation_1.Recommendation.create(addRecommendation);
+        // If a recommendation with this URL already exists, throw an error
+        const existing = await this.repository.getByUrl(recommendation.url);
+        if (existing) {
+            throw new errors_1.default.ValidationError({
+                message: 'A recommendation with this URL already exists.'
+            });
+        }
+        await this.repository.save(recommendation);
+        const recommendations = await this.#listRecommendations();
+        await this.updateWellknown(recommendations);
+        await this.updateRecommendationsEnabledSetting(recommendations);
+        // Only send an update for the mentioned URL
+        this.sendMentionToRecommendation(recommendation);
+        return recommendation.plain;
+    }
+    async checkRecommendation(url) {
+        // If a recommendation with this URL already exists, return it, but with updated metadata
+        const existing = await this.repository.getByUrl(url);
+        if (existing) {
+            this._updateRecommendationMetadata(existing);
+            await this.repository.save(existing);
+            return existing.plain;
+        }
+        let metadata;
+        try {
+            metadata = await this.recommendationMetadataService.fetch(url);
+        }
+        catch (e) {
+            logging_1.default.error('[Recommendations] Failed to fetch metadata for url ' + url, e);
+            return {
+                url: url,
+                title: undefined,
+                excerpt: undefined,
+                featuredImage: undefined,
+                favicon: undefined,
+                oneClickSubscribe: false
+            };
+        }
+        return {
+            url: url,
+            title: metadata.title ?? undefined,
+            excerpt: metadata.excerpt ?? undefined,
+            featuredImage: metadata.featuredImage ?? undefined,
+            favicon: metadata.favicon ?? undefined,
+            oneClickSubscribe: !!metadata.oneClickSubscribe
+        };
+    }
+    async _updateRecommendationMetadata(recommendation) {
+        // Fetch data
+        try {
+            const metadata = await this.recommendationMetadataService.fetch(recommendation.url);
+            // Set null values to undefined so we don't trigger an update
+            recommendation.edit({
+                // Don't set title if it's already set on the recommendation
+                title: recommendation.title ? undefined : (metadata.title ?? undefined),
+                excerpt: metadata.excerpt ?? undefined,
+                featuredImage: metadata.featuredImage ?? undefined,
+                favicon: metadata.favicon ?? undefined,
+                oneClickSubscribe: !!metadata.oneClickSubscribe
+            });
+        }
+        catch (e) {
+            logging_1.default.error('[Recommendations] Failed to update metadata for recommendation ' + recommendation.url.toString(), e);
+        }
+    }
+    async editRecommendation(id, recommendationEdit) {
+        // Check if it exists
+        const existing = await this.repository.getById(id);
+        if (!existing) {
+            throw new errors_1.default.NotFoundError({
+                message: (0, tpl_1.default)(messages.notFound, { id })
+            });
+        }
+        existing.edit(recommendationEdit);
+        await this._updateRecommendationMetadata(existing);
+        await this.repository.save(existing);
+        const recommendations = await this.#listRecommendations();
+        await this.updateWellknown(recommendations);
+        this.sendMentionToRecommendation(existing);
+        return existing.plain;
+    }
+    async deleteRecommendation(id) {
+        const existing = await this.repository.getById(id);
+        if (!existing) {
+            throw new errors_1.default.NotFoundError({
+                message: (0, tpl_1.default)(messages.notFound, { id })
+            });
+        }
+        existing.delete();
+        await this.repository.save(existing);
+        const recommendations = await this.#listRecommendations();
+        await this.updateWellknown(recommendations);
+        await this.updateRecommendationsEnabledSetting(recommendations);
+        // Send a mention (because it was deleted, according to the webmentions spec)
+        this.sendMentionToRecommendation(existing);
+    }
+    /**
+     * Sames as listRecommendations, but returns Entities instead of plain objects (Entities are only used internally)
+     */
+    async #listRecommendations(options = { page: 1, limit: 'all' }) {
+        if (options.limit === 'all') {
+            return await this.repository.getAll({
+                ...options
+            });
+        }
+        return await this.repository.getPage({
+            ...options,
+            page: options.page || 1,
+            limit: options.limit || 15
+        });
+    }
+    async listRecommendations(options = { page: 1, limit: 'all', include: [] }) {
+        const list = await this.#listRecommendations(options);
+        return list.map(e => e.plain);
+    }
+    async countRecommendations({ filter }) {
+        return await this.repository.getCount({ filter });
+    }
+    async trackClicked({ id, memberId }) {
+        const clickEvent = ClickEvent_1.ClickEvent.create({ recommendationId: id, memberId });
+        await this.clickEventRepository.save(clickEvent);
+    }
+    async trackSubscribed({ id, memberId }) {
+        const subscribeEvent = SubscribeEvent_1.SubscribeEvent.create({ recommendationId: id, memberId });
+        await this.subscribeEventRepository.save(subscribeEvent);
+    }
+    async readRecommendationByUrl(url) {
+        const recommendation = await this.repository.getByUrl(url);
+        if (!recommendation) {
+            return null;
+        }
+        return recommendation.plain;
+    }
+}
+exports.RecommendationService = RecommendationService;