ghost 5.115.1 → 5.116.0

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

@@ -0,0 +1,281 @@
+import errors from '@tryghost/errors';
+import {InMemoryRepository} from '../../lib/InMemoryRepository';
+import logging from '@tryghost/logging';
+import tpl from '@tryghost/tpl';
+
+import {IncludeOption, OrderOption} from './BookshelfRepository';
+import {ClickEvent} from './ClickEvent';
+import {AddRecommendation, Recommendation, RecommendationPlain} from './Recommendation';
+import {RecommendationRepository} from './RecommendationRepository';
+import {SubscribeEvent} from './SubscribeEvent';
+import {WellknownService} from './WellknownService';
+import {RecommendationMetadataService} from './RecommendationMetadataService';
+
+type MentionSendingService = {
+    sendAll(options: {url: URL, links: URL[]}): Promise<void>
+}
+
+type RecommendationEnablerService = {
+    getSetting(): string,
+    setSetting(value: string): Promise<void>
+}
+
+const messages = {
+    notFound: 'Recommendation with id {id} not found'
+};
+
+export class RecommendationService {
+    repository: RecommendationRepository;
+    clickEventRepository: InMemoryRepository<string, ClickEvent>;
+    subscribeEventRepository: InMemoryRepository<string, SubscribeEvent>;
+
+    wellknownService: WellknownService;
+    mentionSendingService: MentionSendingService;
+    recommendationEnablerService: RecommendationEnablerService;
+    recommendationMetadataService: RecommendationMetadataService;
+
+    constructor(deps: {
+        repository: RecommendationRepository,
+        clickEventRepository: InMemoryRepository<string, ClickEvent>,
+        subscribeEventRepository: InMemoryRepository<string, SubscribeEvent>,
+        wellknownService: WellknownService,
+        mentionSendingService: MentionSendingService,
+        recommendationEnablerService: RecommendationEnablerService,
+        recommendationMetadataService: RecommendationMetadataService
+    }) {
+        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.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.info('[Recommendations] Updating recommendations metadata');
+        for (const recommendation of recommendations) {
+            try {
+                await this._updateRecommendationMetadata(recommendation);
+                await this.repository.save(recommendation);
+            } catch (e) {
+                logging.error('[Recommendations] Failed to save updated metadata for recommendation ' + recommendation.url.toString(), e);
+            }
+        }
+    }
+
+    async updateWellknown(recommendations: Recommendation[]) {
+        await this.wellknownService.set(recommendations);
+    }
+
+    async updateRecommendationsEnabledSetting(recommendations: Recommendation[]) {
+        const expectedSetting = (recommendations.length > 0).toString();
+        const currentSetting = this.recommendationEnablerService.getSetting();
+
+        if (currentSetting && currentSetting === expectedSetting) {
+            return;
+        }
+
+        await this.recommendationEnablerService.setSetting(expectedSetting);
+    }
+
+    private sendMentionToRecommendation(recommendation: Recommendation) {
+        this.mentionSendingService.sendAll({
+            url: this.wellknownService.getURL(),
+            links: [
+                recommendation.url
+            ]
+        }).catch((err) => {
+            logging.error('Failed to send mention to recommendation', err);
+        });
+    }
+
+    async readRecommendation(id: string): Promise<RecommendationPlain> {
+        const recommendation = await this.repository.getById(id);
+
+        if (!recommendation) {
+            throw new errors.NotFoundError({
+                message: tpl(messages.notFound, {id})
+            });
+        }
+
+        return recommendation.plain;
+    }
+
+    async addRecommendation(addRecommendation: AddRecommendation): Promise<RecommendationPlain> {
+        const recommendation = 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.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: URL): Promise<Partial<RecommendationPlain>> {
+        // 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.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: 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.error('[Recommendations] Failed to update metadata for recommendation ' + recommendation.url.toString(), e);
+        }
+    }
+
+    async editRecommendation(id: string, recommendationEdit: Partial<Recommendation>): Promise<RecommendationPlain> {
+        // Check if it exists
+        const existing = await this.repository.getById(id);
+        if (!existing) {
+            throw new errors.NotFoundError({
+                message: tpl(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: string) {
+        const existing = await this.repository.getById(id);
+        if (!existing) {
+            throw new errors.NotFoundError({
+                message: tpl(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: { filter?: string; order?: OrderOption<Recommendation>; page?: number; limit?: number|'all', include?: IncludeOption<Recommendation> } = {page: 1, limit: 'all'}): Promise<Recommendation[]> {
+        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: { filter?: string; order?: OrderOption<Recommendation>; page?: number; limit?: number|'all', include?: IncludeOption<Recommendation> } = {page: 1, limit: 'all', include: []}): Promise<RecommendationPlain[]> {
+        const list = await this.#listRecommendations(options);
+        return list.map(e => e.plain);
+    }
+
+    async countRecommendations({filter}: { filter?: string }) {
+        return await this.repository.getCount({filter});
+    }
+
+    async trackClicked({id, memberId}: { id: string, memberId?: string }) {
+        const clickEvent = ClickEvent.create({recommendationId: id, memberId});
+        await this.clickEventRepository.save(clickEvent);
+    }
+
+    async trackSubscribed({id, memberId}: { id: string, memberId: string }) {
+        const subscribeEvent = SubscribeEvent.create({recommendationId: id, memberId});
+        await this.subscribeEventRepository.save(subscribeEvent);
+    }
+
+    async readRecommendationByUrl(url: URL): Promise<RecommendationPlain|null> {
+        const recommendation = await this.repository.getByUrl(url);
+
+        if (!recommendation) {
+            return null;
+        }
+        return recommendation.plain;
+    }
+}

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

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubscribeEvent = void 0;
+const bson_objectid_1 = __importDefault(require("bson-objectid"));
+class SubscribeEvent {
+    id;
+    recommendationId;
+    memberId;
+    createdAt;
+    get deleted() {
+        return false;
+    }
+    constructor(data) {
+        this.id = data.id;
+        this.recommendationId = data.recommendationId;
+        this.memberId = data.memberId;
+        this.createdAt = data.createdAt;
+    }
+    static create(data) {
+        const id = data.id ?? (0, bson_objectid_1.default)().toString();
+        const d = {
+            id,
+            recommendationId: data.recommendationId,
+            memberId: data.memberId,
+            createdAt: data.createdAt ?? new Date()
+        };
+        return new SubscribeEvent(d);
+    }
+}
+exports.SubscribeEvent = SubscribeEvent;

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

@@ -0,0 +1,32 @@
+import ObjectId from 'bson-objectid';
+
+export class SubscribeEvent {
+    id: string;
+    recommendationId: string;
+    memberId: string|null;
+    createdAt: Date;
+
+    get deleted() {
+        return false;
+    }
+
+    private constructor(data: {id: string, recommendationId: string, memberId: string|null, createdAt: Date}) {
+        this.id = data.id;
+        this.recommendationId = data.recommendationId;
+        this.memberId = data.memberId;
+        this.createdAt = data.createdAt;
+    }
+
+    static create(data: {id?: string, recommendationId: string, memberId: string, createdAt?: Date}) {
+        const id = data.id ?? ObjectId().toString();
+
+        const d = {
+            id,
+            recommendationId: data.recommendationId,
+            memberId: data.memberId,
+            createdAt: data.createdAt ?? new Date()
+        };
+
+        return new SubscribeEvent(d);
+    }
+}

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

@@ -0,0 +1,183 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnsafeData = void 0;
+const errors_1 = __importDefault(require("@tryghost/errors"));
+function serializeField(field) {
+    if (field.length === 0) {
+        return 'data';
+    }
+    return field.join('.');
+}
+/**
+ * NOTE: should be moved to a separate package in case this pattern is found to be useful
+ */
+class UnsafeData {
+    data;
+    context;
+    constructor(data, context = {}) {
+        this.data = data;
+        this.context = context;
+    }
+    get field() {
+        return serializeField(this.context.field ?? []);
+    }
+    addKeyToField(key) {
+        return this.context.field ? [...this.context.field, key] : [key];
+    }
+    fieldWithKey(key) {
+        return serializeField(this.addKeyToField(key));
+    }
+    /**
+     * Returns undefined if the key is not present on the object. Note that this doesn't check for null.
+     */
+    optionalKey(key) {
+        if (typeof this.data !== 'object' || this.data === null) {
+            throw new errors_1.default.ValidationError({ message: `${this.field} must be an object` });
+        }
+        if (!Object.prototype.hasOwnProperty.call(this.data, key)) {
+            return undefined;
+        }
+        return new UnsafeData(this.data[key], {
+            field: this.addKeyToField(key)
+        });
+    }
+    key(key) {
+        if (typeof this.data !== 'object' || this.data === null) {
+            throw new errors_1.default.ValidationError({ message: `${this.field} must be an object` });
+        }
+        if (!Object.prototype.hasOwnProperty.call(this.data, key)) {
+            throw new errors_1.default.ValidationError({ message: `${this.fieldWithKey(key)} is required` });
+        }
+        return new UnsafeData(this.data[key], {
+            field: this.addKeyToField(key)
+        });
+    }
+    /**
+     * Use this to get a nullable value:
+     * ```
+     * const url: string|null = data.key('url').nullable.string
+     * ```
+     */
+    get nullable() {
+        if (this.data === null) {
+            const d = {
+                get string() {
+                    return null;
+                },
+                get boolean() {
+                    return null;
+                },
+                get number() {
+                    return null;
+                },
+                get integer() {
+                    return null;
+                },
+                get url() {
+                    return null;
+                },
+                enum() {
+                    return null;
+                },
+                key() {
+                    return d;
+                },
+                optionalKey() {
+                    return d;
+                },
+                get array() {
+                    return null;
+                },
+                index() {
+                    return d;
+                }
+            };
+            return d;
+        }
+        return this;
+    }
+    get string() {
+        if (typeof this.data !== 'string') {
+            throw new errors_1.default.ValidationError({ message: `${this.field} must be a string` });
+        }
+        return this.data;
+    }
+    get boolean() {
+        if (typeof this.data !== 'boolean') {
+            throw new errors_1.default.ValidationError({ message: `${this.field} must be a boolean` });
+        }
+        return this.data;
+    }
+    get number() {
+        if (typeof this.data === 'string') {
+            const parsed = parseFloat(this.data);
+            if (isNaN(parsed) || parsed.toString() !== this.data) {
+                throw new errors_1.default.ValidationError({ message: `${this.field} must be a number, got ${typeof this.data}` });
+            }
+            return new UnsafeData(parsed, this.context).number;
+        }
+        if (typeof this.data !== 'number') {
+            throw new errors_1.default.ValidationError({ message: `${this.field} must be a number, got ${typeof this.data}` });
+        }
+        if (Number.isNaN(this.data) || !Number.isFinite(this.data)) {
+            throw new errors_1.default.ValidationError({ message: `${this.field} must be a finite number` });
+        }
+        return this.data;
+    }
+    get integer() {
+        if (typeof this.data === 'string') {
+            const parsed = parseInt(this.data);
+            if (isNaN(parsed) || parsed.toString() !== this.data) {
+                throw new errors_1.default.ValidationError({ message: `${this.field} must be an integer` });
+            }
+            return new UnsafeData(parseInt(this.data), this.context).integer;
+        }
+        const number = this.number;
+        if (!Number.isSafeInteger(number)) {
+            throw new errors_1.default.ValidationError({ message: `${this.field} must be an integer` });
+        }
+        return number;
+    }
+    get url() {
+        if (this.data instanceof URL) {
+            return this.data;
+        }
+        const string = this.string;
+        try {
+            const url = new URL(string);
+            if (!['http:', 'https:'].includes(url.protocol)) {
+                throw new errors_1.default.ValidationError({ message: `${this.field} must be a valid URL` });
+            }
+            return url;
+        }
+        catch (e) {
+            throw new errors_1.default.ValidationError({ message: `${this.field} must be a valid URL` });
+        }
+    }
+    enum(allowedValues) {
+        if (!allowedValues.includes(this.data)) {
+            throw new errors_1.default.ValidationError({ message: `${this.field} must be one of ${allowedValues.join(', ')}` });
+        }
+        return this.data;
+    }
+    get array() {
+        if (!Array.isArray(this.data)) {
+            throw new errors_1.default.ValidationError({ message: `${this.field} must be an array` });
+        }
+        return this.data.map((d, i) => new UnsafeData(d, { field: this.addKeyToField(`${i}`) }));
+    }
+    index(index) {
+        const arr = this.array;
+        if (index < 0 || !Number.isSafeInteger(index)) {
+            throw new errors_1.default.IncorrectUsageError({ message: `index must be a positive integer` });
+        }
+        if (index >= arr.length) {
+            throw new errors_1.default.ValidationError({ message: `${this.field} must be an array of length ${index + 1}` });
+        }
+        return arr[index];
+    }
+}
+exports.UnsafeData = UnsafeData;