ghost 5.115.1 → 5.116.1

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

@@ -0,0 +1,201 @@
+/* eslint-disable ghost/filenames/match-exported-class */
+
+import ObjectId from 'bson-objectid';
+import errors from '@tryghost/errors';
+import {UnsafeData} from './UnsafeData';
+
+/**
+ * We never expose Entities outside of services. Because we should never expose the bussiness logic methods. The plain objects are used for that
+ */
+export type RecommendationPlain = {
+    id: string,
+    title: string
+    description: string|null
+    excerpt: string|null // Fetched from the site meta data
+    featuredImage: URL|null // Fetched from the site meta data
+    favicon: URL|null // Fetched from the site meta data
+    url: URL
+    oneClickSubscribe: boolean,
+    createdAt: Date,
+    updatedAt: Date|null,
+
+    /**
+     * These are read only, you cannot change them
+     */
+    clickCount?: number
+    subscriberCount?: number
+}
+
+export type RecommendationCreateData = {
+    id?: string
+    title: string
+    description: string|null
+    excerpt: string|null // Fetched from the site meta data
+    featuredImage: URL|string|null // Fetched from the site meta data
+    favicon: URL|string|null // Fetched from the site meta data
+    url: URL|string
+    oneClickSubscribe: boolean
+    createdAt?: Date
+    updatedAt?: Date|null,
+
+    /**
+     * These are read only, you cannot change them
+     */
+    clickCount?: number
+    subscriberCount?: number
+}
+
+export type AddRecommendation = Omit<RecommendationCreateData, 'id'|'createdAt'|'updatedAt'>
+export type EditRecommendation = Partial<AddRecommendation>
+
+export class Recommendation {
+    id: string;
+    title: string;
+    description: string|null;
+    excerpt: string|null; // Fetched from the site meta data
+    featuredImage: URL|null; // Fetched from the site meta data
+    favicon: URL|null; // Fetched from the site meta data
+    url: URL;
+    oneClickSubscribe: boolean;
+    createdAt: Date;
+    updatedAt: Date|null;
+    #clickCount: number|undefined;
+    #subscriberCount: number|undefined;
+
+    #deleted: boolean;
+
+    get deleted() {
+        return this.#deleted;
+    }
+
+    get clickCount() {
+        return this.#clickCount;
+    }
+
+    get subscriberCount() {
+        return this.#subscriberCount;
+    }
+
+    private constructor(data: RecommendationPlain) {
+        this.id = data.id;
+        this.title = data.title;
+        this.description = data.description;
+        this.excerpt = data.excerpt;
+        this.featuredImage = data.featuredImage;
+        this.favicon = data.favicon;
+        this.url = data.url;
+        this.oneClickSubscribe = data.oneClickSubscribe;
+        this.createdAt = data.createdAt;
+        this.updatedAt = data.updatedAt;
+        this.#clickCount = data.clickCount;
+        this.#subscriberCount = data.subscriberCount;
+        this.#deleted = false;
+    }
+
+    static validate(properties: AddRecommendation) {
+        if (properties.title.length === 0) {
+            throw new errors.ValidationError({
+                message: 'Title must not be empty'
+            });
+        }
+
+        if (properties.title.length > 2000) {
+            throw new errors.ValidationError({
+                message: 'Title must be less than 2000 characters'
+            });
+        }
+
+        if (properties.description && properties.description.length > 200) {
+            throw new errors.ValidationError({
+                message: 'Description must be less than 200 characters'
+            });
+        }
+    }
+
+    clean() {
+        if (this.description !== null && this.description.length === 0) {
+            this.description = null;
+        }
+
+        if (this.excerpt !== null && this.excerpt.length === 0) {
+            this.excerpt = null;
+        }
+
+        if (this.excerpt !== null && this.excerpt.length > 2000) {
+            this.excerpt = this.excerpt.slice(0, 1997) + '...';
+        }
+
+        this.createdAt.setMilliseconds(0);
+        this.updatedAt?.setMilliseconds(0);
+    }
+
+    static create(data: RecommendationCreateData) {
+        const id = data.id ?? ObjectId().toString();
+
+        const d = {
+            id,
+            title: data.title,
+            description: data.description,
+            excerpt: data.excerpt,
+            featuredImage: new UnsafeData(data.featuredImage, {field: ['featuredImage']}).nullable.url,
+            favicon: new UnsafeData(data.favicon, {field: ['favicon']}).nullable.url,
+            url: new UnsafeData(data.url, {field: ['url']}).url,
+            oneClickSubscribe: data.oneClickSubscribe,
+            createdAt: data.createdAt ?? new Date(),
+            updatedAt: data.updatedAt ?? null,
+            clickCount: data.clickCount,
+            subscriberCount: data.subscriberCount
+        };
+
+        this.validate(d);
+        const recommendation = new Recommendation(d);
+        recommendation.clean();
+
+        return recommendation;
+    }
+
+    get plain(): RecommendationPlain {
+        return {
+            id: this.id,
+            title: this.title,
+            description: this.description,
+            excerpt: this.excerpt,
+            featuredImage: this.featuredImage,
+            favicon: this.favicon,
+            url: this.url,
+            oneClickSubscribe: this.oneClickSubscribe,
+            createdAt: this.createdAt,
+            updatedAt: this.updatedAt,
+            clickCount: this.clickCount,
+            subscriberCount: this.subscriberCount
+        };
+    }
+
+    /**
+     * Change the specified properties. Properties that are set to undefined will not be changed
+     */
+    edit(properties: EditRecommendation) {
+        // Delete undefined properties
+        const newProperties = this.plain;
+        let didChange = false;
+
+        for (const key of Object.keys(properties) as (keyof EditRecommendation)[]) {
+            if (Object.prototype.hasOwnProperty.call(properties, key) && properties[key] !== undefined && properties[key] !== newProperties[key]) {
+                (newProperties as Record<string, unknown>)[key] = properties[key] as unknown;
+                didChange = true;
+            }
+        }
+
+        if (!didChange) {
+            return;
+        }
+        newProperties.updatedAt = new Date();
+
+        const created = Recommendation.create(newProperties);
+        Object.assign(this, created);
+    }
+
+    delete() {
+        this.#deleted = true;
+    }
+}

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

@@ -0,0 +1,208 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RecommendationController = void 0;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const errors_1 = __importDefault(require("@tryghost/errors"));
+const UnsafeData_1 = require("./UnsafeData");
+const RecommendationIncludesMap = {
+    'count.clicks': 'clickCount',
+    'count.subscribers': 'subscriberCount'
+};
+const RecommendationOrderMap = {
+    title: 'title',
+    description: 'description',
+    excerpt: 'excerpt',
+    one_click_subscribe: 'oneClickSubscribe',
+    created_at: 'createdAt',
+    updated_at: 'updatedAt',
+    'count.clicks': 'clickCount',
+    'count.subscribers': 'subscriberCount'
+};
+class RecommendationController {
+    service;
+    constructor(deps) {
+        this.service = deps.service;
+    }
+    async read(frame) {
+        const options = new UnsafeData_1.UnsafeData(frame.options);
+        const id = options.key('id').string;
+        const recommendation = await this.service.readRecommendation(id);
+        return this.#serialize([recommendation]);
+    }
+    async add(frame) {
+        const data = new UnsafeData_1.UnsafeData(frame.data);
+        const recommendation = data.key('recommendations').index(0);
+        const plain = {
+            title: recommendation.key('title').string,
+            url: recommendation.key('url').url,
+            // Optional fields
+            oneClickSubscribe: recommendation.optionalKey('one_click_subscribe')?.boolean ?? false,
+            description: recommendation.optionalKey('description')?.nullable.string ?? null,
+            excerpt: recommendation.optionalKey('excerpt')?.nullable.string ?? null,
+            featuredImage: recommendation.optionalKey('featured_image')?.nullable.url ?? null,
+            favicon: recommendation.optionalKey('favicon')?.nullable.url ?? null
+        };
+        return this.#serialize([await this.service.addRecommendation(plain)]);
+    }
+    /**
+     * Given a recommendation URL, returns either an existing recommendation with that url and updated metadata,
+     * or the metadata from that URL as if it would create a new one (without creating a new one)
+     *
+     * This can be used in the frontend when creating a new recommendation (duplication checking + showing a preview before saving)
+     */
+    async check(frame) {
+        const data = new UnsafeData_1.UnsafeData(frame.data);
+        const recommendation = data.key('recommendations').index(0);
+        const url = recommendation.key('url').url;
+        return this.#serialize([await this.service.checkRecommendation(url)]);
+    }
+    async edit(frame) {
+        const options = new UnsafeData_1.UnsafeData(frame.options);
+        const data = new UnsafeData_1.UnsafeData(frame.data);
+        const recommendation = data.key('recommendations').index(0);
+        const id = options.key('id').string;
+        const plain = {
+            title: recommendation.optionalKey('title')?.string,
+            url: recommendation.optionalKey('url')?.url,
+            oneClickSubscribe: recommendation.optionalKey('one_click_subscribe')?.boolean,
+            description: recommendation.optionalKey('description')?.nullable.string,
+            excerpt: recommendation.optionalKey('excerpt')?.nullable.string,
+            featuredImage: recommendation.optionalKey('featured_image')?.nullable.url,
+            favicon: recommendation.optionalKey('favicon')?.nullable.url
+        };
+        return this.#serialize([await this.service.editRecommendation(id, plain)]);
+    }
+    async destroy(frame) {
+        const options = new UnsafeData_1.UnsafeData(frame.options);
+        const id = options.key('id').string;
+        await this.service.deleteRecommendation(id);
+    }
+    #stringToOrder(str) {
+        if (!str) {
+            // Default order
+            return [
+                {
+                    field: 'createdAt',
+                    direction: 'desc'
+                }
+            ];
+        }
+        const parts = str.split(',');
+        const order = [];
+        for (const [index, part] of parts.entries()) {
+            const trimmed = part.trim();
+            const fieldData = new UnsafeData_1.UnsafeData(trimmed.split(' ')[0].trim(), { field: ['order', index.toString(), 'field'] });
+            const directionData = new UnsafeData_1.UnsafeData(trimmed.split(' ')[1]?.trim() ?? 'desc', { field: ['order', index.toString(), 'direction'] });
+            const validatedField = fieldData.enum(Object.keys(RecommendationOrderMap));
+            const direction = directionData.enum(['asc', 'desc']);
+            // Convert 'count.' and camelCase to snake_case
+            const field = RecommendationOrderMap[validatedField];
+            order.push({
+                field,
+                direction
+            });
+        }
+        return order;
+    }
+    async browse(frame) {
+        const options = new UnsafeData_1.UnsafeData(frame.options);
+        const page = options.optionalKey('page')?.integer ?? 1;
+        const limit = options.optionalKey('limit')?.integer ?? 5;
+        const include = options.optionalKey('withRelated')?.array.map((item) => {
+            return RecommendationIncludesMap[item.enum(Object.keys(RecommendationIncludesMap))];
+        }) ?? [];
+        const filter = options.optionalKey('filter')?.string;
+        const orderOption = options.optionalKey('order')?.string;
+        const order = this.#stringToOrder(orderOption);
+        const count = await this.service.countRecommendations({});
+        const recommendations = (await this.service.listRecommendations({ page, limit, filter, include, order }));
+        return this.#serialize(recommendations, {
+            pagination: this.#serializePagination({ page, limit, count })
+        });
+    }
+    async trackClicked(frame) {
+        const member = this.#optionalAuthMember(frame);
+        const options = new UnsafeData_1.UnsafeData(frame.options);
+        const id = options.key('id').string;
+        await this.service.trackClicked({
+            id,
+            memberId: member?.id
+        });
+    }
+    async trackSubscribed(frame) {
+        const member = this.#authMember(frame);
+        const options = new UnsafeData_1.UnsafeData(frame.options);
+        const id = options.key('id').string;
+        await this.service.trackSubscribed({
+            id,
+            memberId: member.id
+        });
+    }
+    #authMember(frame) {
+        const options = new UnsafeData_1.UnsafeData(frame.options);
+        const memberId = options.key('context').optionalKey('member')?.nullable.key('id').string;
+        if (!memberId) {
+            // This is an internal server error because authentication should happen outside this service.
+            throw new errors_1.default.UnauthorizedError({
+                message: 'Member not found'
+            });
+        }
+        return {
+            id: memberId
+        };
+    }
+    #optionalAuthMember(frame) {
+        try {
+            const member = this.#authMember(frame);
+            return member;
+        }
+        catch (e) {
+            if (e instanceof errors_1.default.UnauthorizedError) {
+                // This is fine, this is not required
+            }
+            else {
+                throw e;
+            }
+        }
+        return null;
+    }
+    #serialize(recommendations, meta) {
+        return {
+            data: recommendations.map((entity) => {
+                const d = {
+                    id: entity.id ?? null,
+                    title: entity.title ?? null,
+                    description: entity.description ?? null,
+                    excerpt: entity.excerpt ?? null,
+                    featured_image: entity.featuredImage?.toString() ?? null,
+                    favicon: entity.favicon?.toString() ?? null,
+                    url: entity.url?.toString() ?? null,
+                    one_click_subscribe: entity.oneClickSubscribe ?? null,
+                    created_at: entity.createdAt?.toISOString() ?? null,
+                    updated_at: entity.updatedAt?.toISOString() ?? null,
+                    count: entity.clickCount !== undefined || entity.subscriberCount !== undefined ? {
+                        clicks: entity.clickCount,
+                        subscribers: entity.subscriberCount
+                    } : undefined
+                };
+                return d;
+            }),
+            meta
+        };
+    }
+    #serializePagination({ page, limit, count }) {
+        const pages = Math.ceil(count / limit);
+        return {
+            page,
+            limit,
+            total: count,
+            pages,
+            prev: page > 1 ? page - 1 : null,
+            next: page < pages ? page + 1 : null
+        };
+    }
+}
+exports.RecommendationController = RecommendationController;

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

@@ -0,0 +1,258 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import errors from '@tryghost/errors';
+import {AddRecommendation, Recommendation, RecommendationPlain} from './Recommendation';
+import {RecommendationService} from './RecommendationService';
+import {UnsafeData} from './UnsafeData';
+import {OrderOption} from './BookshelfRepository';
+
+type Frame = {
+    data: unknown,
+    options: unknown,
+    user: unknown,
+};
+
+const RecommendationIncludesMap = {
+    'count.clicks': 'clickCount' as const,
+    'count.subscribers': 'subscriberCount' as const
+};
+
+const RecommendationOrderMap = {
+    title: 'title' as const,
+    description: 'description' as const,
+    excerpt: 'excerpt' as const,
+    one_click_subscribe: 'oneClickSubscribe' as const,
+    created_at: 'createdAt' as const,
+    updated_at: 'updatedAt' as const,
+    'count.clicks': 'clickCount' as const,
+    'count.subscribers': 'subscriberCount' as const
+};
+
+export class RecommendationController {
+    service: RecommendationService;
+
+    constructor(deps: {service: RecommendationService}) {
+        this.service = deps.service;
+    }
+
+    async read(frame: Frame) {
+        const options = new UnsafeData(frame.options);
+        const id = options.key('id').string;
+
+        const recommendation = await this.service.readRecommendation(id);
+
+        return this.#serialize(
+            [recommendation]
+        );
+    }
+
+    async add(frame: Frame) {
+        const data = new UnsafeData(frame.data);
+        const recommendation = data.key('recommendations').index(0);
+        const plain: AddRecommendation = {
+            title: recommendation.key('title').string,
+            url: recommendation.key('url').url,
+
+            // Optional fields
+            oneClickSubscribe: recommendation.optionalKey('one_click_subscribe')?.boolean ?? false,
+            description: recommendation.optionalKey('description')?.nullable.string ?? null,
+            excerpt: recommendation.optionalKey('excerpt')?.nullable.string ?? null,
+            featuredImage: recommendation.optionalKey('featured_image')?.nullable.url ?? null,
+            favicon: recommendation.optionalKey('favicon')?.nullable.url ?? null
+        };
+
+        return this.#serialize(
+            [await this.service.addRecommendation(plain)]
+        );
+    }
+
+    /**
+     * Given a recommendation URL, returns either an existing recommendation with that url and updated metadata,
+     * or the metadata from that URL as if it would create a new one (without creating a new one)
+     *
+     * This can be used in the frontend when creating a new recommendation (duplication checking + showing a preview before saving)
+     */
+    async check(frame: Frame) {
+        const data = new UnsafeData(frame.data);
+        const recommendation = data.key('recommendations').index(0);
+        const url = recommendation.key('url').url;
+
+        return this.#serialize(
+            [await this.service.checkRecommendation(url)]
+        );
+    }
+
+    async edit(frame: Frame) {
+        const options = new UnsafeData(frame.options);
+        const data = new UnsafeData(frame.data);
+        const recommendation = data.key('recommendations').index(0);
+
+        const id = options.key('id').string;
+        const plain: Partial<RecommendationPlain> = {
+            title: recommendation.optionalKey('title')?.string,
+            url: recommendation.optionalKey('url')?.url,
+            oneClickSubscribe: recommendation.optionalKey('one_click_subscribe')?.boolean,
+            description: recommendation.optionalKey('description')?.nullable.string,
+            excerpt: recommendation.optionalKey('excerpt')?.nullable.string,
+            featuredImage: recommendation.optionalKey('featured_image')?.nullable.url,
+            favicon: recommendation.optionalKey('favicon')?.nullable.url
+        };
+
+        return this.#serialize(
+            [await this.service.editRecommendation(id, plain)]
+        );
+    }
+
+    async destroy(frame: Frame) {
+        const options = new UnsafeData(frame.options);
+        const id = options.key('id').string;
+        await this.service.deleteRecommendation(id);
+    }
+
+    #stringToOrder(str?: string) {
+        if (!str) {
+            // Default order
+            return [
+                {
+                    field: 'createdAt' as const,
+                    direction: 'desc' as const
+                }
+            ];
+        }
+
+        const parts = str.split(',');
+        const order: OrderOption<Recommendation> = [];
+        for (const [index, part] of parts.entries()) {
+            const trimmed = part.trim();
+            const fieldData = new UnsafeData(trimmed.split(' ')[0].trim(), {field: ['order', index.toString(), 'field']});
+            const directionData = new UnsafeData(trimmed.split(' ')[1]?.trim() ?? 'desc', {field: ['order', index.toString(), 'direction']});
+
+            const validatedField = fieldData.enum(
+                Object.keys(RecommendationOrderMap) as (keyof typeof RecommendationOrderMap)[]
+            );
+            const direction = directionData.enum(['asc' as const, 'desc' as const]);
+
+            // Convert 'count.' and camelCase to snake_case
+            const field = RecommendationOrderMap[validatedField];
+            order.push({
+                field,
+                direction
+            });
+        }
+
+        return order;
+    }
+
+    async browse(frame: Frame) {
+        const options = new UnsafeData(frame.options);
+
+        const page = options.optionalKey('page')?.integer ?? 1;
+        const limit = options.optionalKey('limit')?.integer ?? 5;
+        const include = options.optionalKey('withRelated')?.array.map((item) => {
+            return RecommendationIncludesMap[item.enum(
+                Object.keys(RecommendationIncludesMap) as (keyof typeof RecommendationIncludesMap)[]
+            )];
+        }) ?? [];
+        const filter = options.optionalKey('filter')?.string;
+
+        const orderOption = options.optionalKey('order')?.string;
+        const order = this.#stringToOrder(orderOption);
+
+        const count = await this.service.countRecommendations({});
+        const recommendations = (await this.service.listRecommendations({page, limit, filter, include, order}));
+
+        return this.#serialize(
+            recommendations,
+            {
+                pagination: this.#serializePagination({page, limit, count})
+            }
+        );
+    }
+
+    async trackClicked(frame: Frame) {
+        const member = this.#optionalAuthMember(frame);
+        const options = new UnsafeData(frame.options);
+        const id = options.key('id').string;
+
+        await this.service.trackClicked({
+            id,
+            memberId: member?.id
+        });
+    }
+    async trackSubscribed(frame: Frame) {
+        const member = this.#authMember(frame);
+        const options = new UnsafeData(frame.options);
+        const id = options.key('id').string;
+
+        await this.service.trackSubscribed({
+            id,
+            memberId: member.id
+        });
+    }
+
+    #authMember(frame: Frame): {id: string} {
+        const options = new UnsafeData(frame.options);
+        const memberId = options.key('context').optionalKey('member')?.nullable.key('id').string;
+        if (!memberId) {
+            // This is an internal server error because authentication should happen outside this service.
+            throw new errors.UnauthorizedError({
+                message: 'Member not found'
+            });
+        }
+        return {
+            id: memberId
+        };
+    }
+
+    #optionalAuthMember(frame: Frame): {id: string}|null {
+        try {
+            const member = this.#authMember(frame);
+            return member;
+        } catch (e) {
+            if (e instanceof errors.UnauthorizedError) {
+                // This is fine, this is not required
+            } else {
+                throw e;
+            }
+        }
+        return null;
+    }
+
+    #serialize(recommendations: Partial<RecommendationPlain>[], meta?: any) {
+        return {
+            data: recommendations.map((entity) => {
+                const d = {
+                    id: entity.id ?? null,
+                    title: entity.title ?? null,
+                    description: entity.description ?? null,
+                    excerpt: entity.excerpt ?? null,
+                    featured_image: entity.featuredImage?.toString() ?? null,
+                    favicon: entity.favicon?.toString() ?? null,
+                    url: entity.url?.toString() ?? null,
+                    one_click_subscribe: entity.oneClickSubscribe ?? null,
+                    created_at: entity.createdAt?.toISOString() ?? null,
+                    updated_at: entity.updatedAt?.toISOString() ?? null,
+                    count: entity.clickCount !== undefined || entity.subscriberCount !== undefined ? {
+                        clicks: entity.clickCount,
+                        subscribers: entity.subscriberCount
+                    } : undefined
+                };
+
+                return d;
+            }),
+            meta
+        };
+    }
+
+    #serializePagination({page, limit, count}: {page: number, limit: number, count: number}) {
+        const pages = Math.ceil(count / limit);
+
+        return {
+            page,
+            limit,
+            total: count,
+            pages,
+            prev: page > 1 ? page - 1 : null,
+            next: page < pages ? page + 1 : null
+        };
+    }
+}