ghost 5.115.1 → 5.116.1

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

@@ -0,0 +1,217 @@
+import errors from '@tryghost/errors';
+
+type UnsafeDataContext = {
+    field?: string[]
+}
+
+function serializeField(field: string[]) {
+    if (field.length === 0) {
+        return 'data';
+    }
+    return field.join('.');
+}
+
+type NullData = {
+    readonly string: null,
+    readonly boolean: null,
+    readonly number: null,
+    readonly integer: null,
+    readonly url: null
+    enum(allowedValues: unknown[]): null
+    key(key: string): NullData
+    optionalKey(key: string): NullData
+    readonly array: null
+    index(index: number): NullData
+}
+
+/**
+ * NOTE: should be moved to a separate package in case this pattern is found to be useful
+ */
+export class UnsafeData {
+    protected data: unknown;
+    protected context: UnsafeDataContext;
+
+    constructor(data: unknown, context: UnsafeDataContext = {}) {
+        this.data = data;
+        this.context = context;
+    }
+
+    protected get field() {
+        return serializeField(this.context.field ?? []);
+    }
+
+    protected addKeyToField(key: string) {
+        return this.context.field ? [...this.context.field, key] : [key];
+    }
+
+    protected fieldWithKey(key: string) {
+        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: string): UnsafeData|undefined {
+        if (typeof this.data !== 'object' || this.data === null) {
+            throw new errors.ValidationError({message: `${this.field} must be an object`});
+        }
+
+        if (!Object.prototype.hasOwnProperty.call(this.data, key)) {
+            return undefined;
+        }
+
+        return new UnsafeData((this.data as Record<string, unknown>)[key], {
+            field: this.addKeyToField(key)
+        });
+    }
+
+    key(key: string): UnsafeData {
+        if (typeof this.data !== 'object' || this.data === null) {
+            throw new errors.ValidationError({message: `${this.field} must be an object`});
+        }
+
+        if (!Object.prototype.hasOwnProperty.call(this.data, key)) {
+            throw new errors.ValidationError({message: `${this.fieldWithKey(key)} is required`});
+        }
+
+        return new UnsafeData((this.data as Record<string, unknown>)[key], {
+            field: this.addKeyToField(key)
+        });
+    }
+
+    /**
+     * Use this to get a nullable value:
+     * ```
+     * const url: string|null = data.key('url').nullable.string
+     * ```
+     */
+    get nullable(): UnsafeData|NullData {
+        if (this.data === null) {
+            const d: NullData = {
+                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(): string {
+        if (typeof this.data !== 'string') {
+            throw new errors.ValidationError({message: `${this.field} must be a string`});
+        }
+        return this.data;
+    }
+
+    get boolean(): boolean {
+        if (typeof this.data !== 'boolean') {
+            throw new errors.ValidationError({message: `${this.field} must be a boolean`});
+        }
+        return this.data;
+    }
+
+    get number(): number {
+        if (typeof this.data === 'string') {
+            const parsed = parseFloat(this.data);
+            if (isNaN(parsed) || parsed.toString() !== this.data) {
+                throw new errors.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.ValidationError({message: `${this.field} must be a number, got ${typeof this.data}`});
+        }
+        if (Number.isNaN(this.data) || !Number.isFinite(this.data)) {
+            throw new errors.ValidationError({message: `${this.field} must be a finite number`});
+        }
+        return this.data;
+    }
+
+    get integer(): number {
+        if (typeof this.data === 'string') {
+            const parsed = parseInt(this.data);
+            if (isNaN(parsed) || parsed.toString() !== this.data) {
+                throw new errors.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.ValidationError({message: `${this.field} must be an integer`});
+        }
+        return number;
+    }
+
+    get url(): 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.ValidationError({message: `${this.field} must be a valid URL`});
+            }
+            return url;
+        } catch (e) {
+            throw new errors.ValidationError({message: `${this.field} must be a valid URL`});
+        }
+    }
+
+    enum<T>(allowedValues: T[]): T {
+        if (!allowedValues.includes(this.data as T)) {
+            throw new errors.ValidationError({message: `${this.field} must be one of ${allowedValues.join(', ')}`});
+        }
+        return this.data as T;
+    }
+
+    get array(): UnsafeData[] {
+        if (!Array.isArray(this.data)) {
+            throw new errors.ValidationError({message: `${this.field} must be an array`});
+        }
+        return this.data.map((d, i) => new UnsafeData(d, {field: this.addKeyToField(`${i}`)}));
+    }
+
+    index(index: number) {
+        const arr = this.array;
+        if (index < 0 || !Number.isSafeInteger(index)) {
+            throw new errors.IncorrectUsageError({message: `index must be a positive integer`});
+        }
+        if (index >= arr.length) {
+            throw new errors.ValidationError({message: `${this.field} must be an array of length ${index + 1}`});
+        }
+        return arr[index];
+    }
+}

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

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WellknownService = void 0;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+class WellknownService {
+    dir;
+    urlUtils;
+    constructor({ dir, urlUtils }) {
+        this.dir = dir;
+        this.urlUtils = urlUtils;
+    }
+    #formatRecommendation(recommendation) {
+        return {
+            url: recommendation.url,
+            updated_at: (recommendation.updatedAt ?? recommendation.createdAt).toISOString(),
+            created_at: (recommendation.createdAt).toISOString()
+        };
+    }
+    getPath() {
+        return path_1.default.join(this.dir, '/.well-known/recommendations.json');
+    }
+    getURL() {
+        return new URL(this.urlUtils.relativeToAbsolute('/.well-known/recommendations.json'));
+    }
+    async set(recommendations) {
+        const content = JSON.stringify(recommendations.map(r => this.#formatRecommendation(r)));
+        const path = this.getPath();
+        await promises_1.default.mkdir(path_1.default.dirname(path), { recursive: true });
+        await promises_1.default.writeFile(path, content);
+    }
+}
+exports.WellknownService = WellknownService;

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

@@ -0,0 +1,47 @@
+import {Recommendation} from './Recommendation';
+import fs from 'fs/promises';
+import _path from 'path';
+
+type UrlUtils = {
+    relativeToAbsolute(url: string): string
+}
+type Options = {
+    /**
+     * Where to publish the wellknown file
+     */
+    dir: string,
+    urlUtils: UrlUtils
+}
+
+export class WellknownService {
+    dir: string;
+    urlUtils: UrlUtils;
+
+    constructor({dir, urlUtils}: Options) {
+        this.dir = dir;
+        this.urlUtils = urlUtils;
+    }
+
+    #formatRecommendation(recommendation: Recommendation) {
+        return {
+            url: recommendation.url,
+            updated_at: (recommendation.updatedAt ?? recommendation.createdAt).toISOString(),
+            created_at: (recommendation.createdAt).toISOString()
+        };
+    }
+
+    getPath() {
+        return _path.join(this.dir, '/.well-known/recommendations.json');
+    }
+
+    getURL(): URL {
+        return new URL(this.urlUtils.relativeToAbsolute('/.well-known/recommendations.json'));
+    }
+
+    async set(recommendations: Recommendation[]) {
+        const content = JSON.stringify(recommendations.map(r => this.#formatRecommendation(r)));
+        const path = this.getPath();
+        await fs.mkdir(_path.dirname(path), {recursive: true});
+        await fs.writeFile(path, content);
+    }
+}

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

@@ -0,0 +1,31 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./RecommendationController"), exports);
+__exportStar(require("./RecommendationService"), exports);
+__exportStar(require("./RecommendationRepository"), exports);
+__exportStar(require("./InMemoryRecommendationRepository"), exports);
+__exportStar(require("./Recommendation"), exports);
+__exportStar(require("./WellknownService"), exports);
+__exportStar(require("./BookshelfRecommendationRepository"), exports);
+__exportStar(require("./ClickEvent"), exports);
+__exportStar(require("./BookshelfClickEventRepository"), exports);
+__exportStar(require("./SubscribeEvent"), exports);
+__exportStar(require("./BookshelfSubscribeEventRepository"), exports);
+__exportStar(require("./IncomingRecommendationController"), exports);
+__exportStar(require("./IncomingRecommendationService"), exports);
+__exportStar(require("./IncomingRecommendationEmailRenderer"), exports);
+__exportStar(require("./RecommendationMetadataService"), exports);

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

@@ -0,0 +1,15 @@
+export * from './RecommendationController';
+export * from './RecommendationService';
+export * from './RecommendationRepository';
+export * from './InMemoryRecommendationRepository';
+export * from './Recommendation';
+export * from './WellknownService';
+export * from './BookshelfRecommendationRepository';
+export * from './ClickEvent';
+export * from './BookshelfClickEventRepository';
+export * from './SubscribeEvent';
+export * from './BookshelfSubscribeEventRepository';
+export * from './IncomingRecommendationController';
+export * from './IncomingRecommendationService';
+export * from './IncomingRecommendationEmailRenderer';
+export * from './RecommendationMetadataService';

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

@@ -0,0 +1,5 @@
+declare module '@tryghost/errors';
+declare module '@tryghost/tpl';
+declare module '@tryghost/logging';
+declare module '@tryghost/mongo-utils';
+declare module '@tryghost/nql';

package/core/server/services/slack-notifications/SlackNotifications.js

@@ -0,0 +1,211 @@
+const got = require('got');
+const validator = require('@tryghost/validator');
+const errors = require('@tryghost/errors');
+const ghostVersion = require('@tryghost/version');
+const moment = require('moment');
+
+/**
+ * @typedef {URL} webhookUrl
+ */
+
+/**
+ * @typedef {string} siteUrl
+ */
+
+/**
+ * @typedef {import('@tryghost/logging')} logging
+ */
+
+/**
+ * @typedef {import('./SlackNotificationsService').ISlackNotifications} ISlackNotifications
+ */
+
+/**
+ * @implements {ISlackNotifications}
+ */
+class SlackNotifications {
+    /** @type {URL} */
+    #webhookUrl;
+
+    /** @type {siteUrl} */
+    #siteUrl;
+
+    /** @type {logging} */
+    #logging;
+
+    /**
+     * @param {object} deps
+     * @param {URL} deps.webhookUrl
+     * @param {siteUrl} deps.siteUrl
+     * @param {logging} deps.logging
+     */
+    constructor(deps) {
+        this.#siteUrl = deps.siteUrl;
+        this.#webhookUrl = deps.webhookUrl;
+        this.#logging = deps.logging;
+    }
+
+    /**
+     * @param {object} eventData
+     * @param {import('@tryghost/milestones/lib/InMemoryMilestoneRepository').Milestone} eventData.milestone
+     * @param {object} [eventData.meta]
+     * @param {'import'|'email'|'skipped'|'initial'} [eventData.meta.reason]
+     * @param {number} [eventData.meta.currentValue]
+     *
+     * @returns {Promise<void>}
+     */
+    async notifyMilestoneReceived({milestone, meta}) {
+        if (meta?.reason === 'skipped' || meta?.reason === 'initial') {
+            return;
+        }
+        const hasImportedMembers = meta?.reason === 'import' ? 'has imported members' : null;
+        const lastEmailTooSoon = meta?.reason === 'email' ? 'last email too recent' : null;
+        const emailNotSentReason = hasImportedMembers || lastEmailTooSoon;
+        const milestoneTypePretty = milestone.type === 'arr' ? 'ARR' : 'Members';
+        const valueFormatted = this.#getFormattedAmount({amount: milestone.value, currency: milestone?.currency});
+        const emailSentText = milestone?.emailSentAt ? this.#getFormattedDate(milestone?.emailSentAt) : `no / ${emailNotSentReason}`;
+        const title = `:tada: ${milestoneTypePretty} Milestone ${valueFormatted} reached!`;
+
+        let valueSection;
+
+        if (milestone.type === 'arr') {
+            valueSection = {
+                type: 'section',
+                fields: [
+                    {
+                        type: 'mrkdwn',
+                        text: `*Milestone:*\n${valueFormatted}`
+                    }
+
+                ]
+            };
+
+            if (meta?.currentValue) {
+                valueSection.fields.push({
+                    type: 'mrkdwn',
+                    text: `*Current ARR:*\n${this.#getFormattedAmount({amount: meta.currentValue, currency: milestone?.currency})}`
+                });
+            }
+        } else {
+            valueSection = {
+                type: 'section',
+                fields: [
+                    {
+                        type: 'mrkdwn',
+                        text: `*Milestone:*\n${valueFormatted}`
+                    }
+                ]
+            };
+            if (meta?.currentValue) {
+                valueSection.fields.push({
+                    type: 'mrkdwn',
+                    text: `*Current Members:*\n${this.#getFormattedAmount({amount: meta.currentValue})}`
+                });
+            }
+        }
+
+        const blocks = [
+            {
+                type: 'header',
+                text: {
+                    type: 'plain_text',
+                    text: title,
+                    emoji: true
+                }
+            },
+            {
+                type: 'section',
+                text: {
+                    type: 'mrkdwn',
+                    text: `New *${milestoneTypePretty} Milestone* achieved for <${this.#siteUrl}|${this.#siteUrl}>`
+                }
+            },
+            {
+                type: 'divider'
+            },
+            valueSection,
+            {
+                type: 'section',
+                text: {
+                    type: 'mrkdwn',
+                    text: `*Email sent:*\n${emailSentText}`
+                }
+            }
+        ];
+
+        const slackData = {
+            unfurl_links: false,
+            username: 'Ghost Milestone Service',
+            attachments: [
+                {
+                    color: '#36a64f',
+                    blocks
+                }
+            ]
+        };
+
+        await this.send(slackData, this.#webhookUrl);
+    }
+
+    /**
+     *
+     * @param {object} slackData
+     * @param {URL} url
+     *
+     * @returns {Promise<any>}
+     */
+    async send(slackData, url) {
+        if ((!url || typeof url !== 'string') || !validator.isURL(url)) {
+            const err = new errors.InternalServerError({
+                message: 'URL empty or invalid.',
+                code: 'URL_MISSING_INVALID',
+                context: url
+            });
+
+            return this.#logging.error(err);
+        }
+
+        const requestOptions = {
+            body: JSON.stringify(slackData),
+            headers: {
+                'user-agent': 'Ghost/' + ghostVersion.original + ' (https://github.com/TryGhost/Ghost)'
+            }
+        };
+
+        if (process.env.NODE_ENV?.startsWith('test')) {
+            requestOptions.retry = 0;
+        }
+
+        return await got.post(url, requestOptions);
+    }
+
+    /**
+     * @param {object} options
+     * @param {number} options.amount
+     * @param {string} [options.currency]
+     *
+     * @returns {string}
+     */
+    #getFormattedAmount({amount = 0, currency}) {
+        if (!currency) {
+            return Intl.NumberFormat().format(amount);
+        }
+
+        return Intl.NumberFormat('en', {
+            style: 'currency',
+            currency,
+            currencyDisplay: 'symbol'
+        }).format(amount);
+    }
+
+    /**
+     * @param {string|Date} date
+     *
+     * @returns {string}
+     */
+    #getFormattedDate(date) {
+        return moment(date).format('D MMM YYYY');
+    }
+}
+
+module.exports = SlackNotifications;

package/core/server/services/slack-notifications/SlackNotificationsService.js

@@ -0,0 +1,90 @@
+const {MilestoneCreatedEvent} = require('@tryghost/milestones');
+
+/**
+ * @typedef {import('@tryghost/milestones/lib/InMemoryMilestoneRepository').Milestone} Milestone
+ */
+
+/**
+ * @typedef {object} meta
+ * @prop {'import'|'email'} [reason]
+ * @prop {number} [currentValue]
+ */
+
+/**
+ * @typedef {import('@tryghost/logging')} logging
+ */
+
+/**
+ * @typedef {object} ISlackNotifications
+ * @param {logging} logging
+ * @param {URL} siteUrl
+ * @param {URL} webhookUrl
+ * @prop {Object.<Milestone, ?meta>} notifyMilestoneReceived
+ * @prop {(slackData: object, url: URL) => Promise<void>} send
+ */
+
+/**
+ * @typedef {object} config
+ * @prop {boolean} isEnabled
+ * @prop {URL} webhookUrl
+ * @prop {number} minThreshold
+ */
+
+module.exports = class SlackNotificationsService {
+    /** @type {import('@tryghost/domain-events')} */
+    #DomainEvents;
+
+    /** @type {import('@tryghost/logging')} */
+    #logging;
+
+    /** @type {config} */
+    #config;
+
+    /** @type {ISlackNotifications} */
+    #slackNotifications;
+
+    /**
+     *
+     * @param {object} deps
+     * @param {import('@tryghost/domain-events')} deps.DomainEvents
+     * @param {config} deps.config
+     * @param {import('@tryghost/logging')} deps.logging
+     * @param {ISlackNotifications} deps.slackNotifications
+     */
+    constructor(deps) {
+        this.#DomainEvents = deps.DomainEvents;
+        this.#logging = deps.logging;
+        this.#config = deps.config;
+        this.#slackNotifications = deps.slackNotifications;
+    }
+
+    /**
+     *
+     * @param {MilestoneCreatedEvent} type
+     * @param {object} event
+     * @param {object} event.data
+     *
+     * @returns {Promise<void>}
+     */
+    async #handleEvent(type, event) {
+        if (
+            type === MilestoneCreatedEvent
+            && event.data.milestone
+            && this.#config.isEnabled
+            && this.#config.webhookUrl
+            && this.#config.minThreshold < event.data.milestone.value
+        ) {
+            try {
+                await this.#slackNotifications.notifyMilestoneReceived(event.data);
+            } catch (error) {
+                this.#logging.error(error);
+            }
+        }
+    }
+
+    subscribeEvents() {
+        this.#DomainEvents.subscribe(MilestoneCreatedEvent, async (event) => {
+            await this.#handleEvent(MilestoneCreatedEvent, event);
+        });
+    }
+};

package/core/server/services/slack-notifications/service.js

@@ -3,7 +3,7 @@ const config = require('../../../shared/config');
 const logging = require('@tryghost/logging');
 
 class SlackNotificationsServiceWrapper {
-    /** @type {import('@tryghost/slack-notifications/lib/SlackNotificationsService')} */
+    /** @type {import('./SlackNotificationsService')} */
     #api;
 
     /**
@@ -14,13 +14,11 @@ class SlackNotificationsServiceWrapper {
      * @param {URL} deps.webhookUrl
      * @param {number} deps.minThreshold
      *
-     * @returns {import('@tryghost/slack-notifications/lib/SlackNotificationsService')}
+     * @returns {import('./SlackNotificationsService')}
      */
     static create({siteUrl, isEnabled, webhookUrl, minThreshold}) {
-        const {
-            SlackNotificationsService,
-            SlackNotifications
-        } = require('@tryghost/slack-notifications');
+        const SlackNotificationsService = require('./SlackNotificationsService');
+        const SlackNotifications = require('./SlackNotifications');
 
         const slackNotifications = new SlackNotifications({
             webhookUrl,