ghost 5.115.1 → 5.116.1

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

@@ -0,0 +1,117 @@
+import {AllOptions, BookshelfRepository, ModelClass, ModelInstance} from './BookshelfRepository';
+import logger from '@tryghost/logging';
+import {Knex} from 'knex';
+import {Recommendation} from './Recommendation';
+import {RecommendationRepository} from './RecommendationRepository';
+
+type Sentry = {
+    captureException(err: unknown): void;
+}
+
+type RecommendationFindOneData<T> = {
+    id?: T;
+    url?: string;
+};
+
+type RecommendationModelClass<T> = ModelClass<T> & {
+    findOne: (data: RecommendationFindOneData<T>, options?: { require?: boolean }) => Promise<ModelInstance<T> | null>;
+};
+
+export class BookshelfRecommendationRepository extends BookshelfRepository<string, Recommendation> implements RecommendationRepository {
+    sentry?: Sentry;
+
+    constructor(Model: RecommendationModelClass<string>, deps: {sentry?: Sentry} = {}) {
+        super(Model);
+        this.sentry = deps.sentry;
+    }
+
+    applyCustomQuery(query: Knex.QueryBuilder, options: AllOptions<Recommendation>) {
+        query.select('recommendations.*');
+
+        if (options.include?.includes('clickCount') || options.order?.find(o => o.field === 'clickCount')) {
+            query.select((knex: Knex.QueryBuilder) => {
+                knex.count('*').from('recommendation_click_events').where('recommendation_click_events.recommendation_id', knex.client.raw('recommendations.id')).as('count__clicks');
+            });
+        }
+
+        if (options.include?.includes('subscriberCount') || options.order?.find(o => o.field === 'subscriberCount')) {
+            query.select((knex: Knex.QueryBuilder) => {
+                knex.count('*').from('recommendation_subscribe_events').where('recommendation_subscribe_events.recommendation_id', knex.client.raw('recommendations.id')).as('count__subscribers');
+            });
+        }
+    }
+
+    toPrimitive(entity: Recommendation): object {
+        return {
+            id: entity.id,
+            title: entity.title,
+            description: entity.description,
+            excerpt: entity.excerpt,
+            featured_image: entity.featuredImage?.toString(),
+            favicon: entity.favicon?.toString(),
+            url: entity.url.toString(),
+            one_click_subscribe: entity.oneClickSubscribe,
+            created_at: entity.createdAt,
+            updated_at: entity.updatedAt
+            // Count relations are not saveable: so don't set them here
+        };
+    }
+
+    modelToEntity(model: ModelInstance<string>): Recommendation | null {
+        try {
+            return Recommendation.create({
+                id: model.id,
+                title: model.get('title') as string,
+                description: model.get('description') as string | null,
+                excerpt: model.get('excerpt') as string | null,
+                featuredImage: model.get('featured_image') as string | null,
+                favicon: model.get('favicon') as string | null,
+                url: model.get('url') as string,
+                oneClickSubscribe: model.get('one_click_subscribe') as boolean,
+                createdAt: model.get('created_at') as Date,
+                updatedAt: model.get('updated_at') as Date | null,
+                clickCount: (model.get('count__clicks') ?? undefined) as number | undefined,
+                subscriberCount: (model.get('count__subscribers') ?? undefined) as number | undefined
+            });
+        } catch (err) {
+            logger.error(err);
+            this.sentry?.captureException(err);
+            return null;
+        }
+    }
+
+    getFieldToColumnMap() {
+        return {
+            id: 'id',
+            title: 'title',
+            description: 'description',
+            excerpt: 'excerpt',
+            featuredImage: 'featured_image',
+            favicon: 'favicon',
+            url: 'url',
+            oneClickSubscribe: 'one_click_subscribe',
+            createdAt: 'created_at',
+            updatedAt: 'updated_at',
+            clickCount: 'count__clicks',
+            subscriberCount: 'count__subscribers'
+        } as Record<keyof Recommendation, string>;
+    }
+
+    async getByUrl(url: URL): Promise<Recommendation | null> {
+        const urlFilter = `url:~'${url.host.replace('www.', '')}${url.pathname.replace(/\/$/, '')}'`;
+        const recommendations = await this.getAll({filter: urlFilter});
+
+        if (!recommendations || recommendations.length === 0) {
+            return null;
+        }
+
+        //  Find URL based on the hostname and pathname.
+        //  Query params, hash fragements, protocol and www are ignored.
+        const existing = recommendations.find((r) => {
+            return r.url.hostname.replace('www.', '') === url.hostname.replace('www.', '') &&
+                   r.url.pathname.replace(/\/$/, '') === url.pathname.replace(/\/$/, '');
+        }) || null;
+
+        return existing;
+    }
+}

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

@@ -0,0 +1,134 @@
+"use strict";
+/* eslint-disable ghost/filenames/match-exported-class */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BookshelfRepository = void 0;
+const mongo_utils_1 = require("@tryghost/mongo-utils");
+const errors_1 = __importDefault(require("@tryghost/errors"));
+class BookshelfRepository {
+    Model;
+    constructor(Model) {
+        this.Model = Model;
+    }
+    /**
+     * override this method to add custom query logic to knex queries
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    applyCustomQuery(query, options) {
+        return;
+    }
+    #entityFieldToColumn(field) {
+        const mapping = this.getFieldToColumnMap();
+        return mapping[field];
+    }
+    #orderToString(order) {
+        if (!order || order.length === 0) {
+            return;
+        }
+        return order.map(({ field, direction }) => `${this.#entityFieldToColumn(field)} ${direction}`).join(',');
+    }
+    /**
+     * Map all the fields in an NQL filter to the names of the model
+     */
+    #getNQLKeyTransformer() {
+        return (0, mongo_utils_1.chainTransformers)(...(0, mongo_utils_1.mapKeys)(this.getFieldToColumnMap()));
+    }
+    async save(entity) {
+        if (entity.deleted) {
+            await this.Model.destroy({ id: entity.id });
+            return;
+        }
+        const existing = await this.Model.findOne({ id: entity.id }, { require: false });
+        if (existing) {
+            existing.set(this.toPrimitive(entity));
+            await existing.save({}, { autoRefresh: false, method: 'update' });
+        }
+        else {
+            await this.Model.add(this.toPrimitive(entity));
+        }
+    }
+    async getById(id) {
+        const models = await this.#fetchAll({
+            filter: `id:'${id}'`,
+            limit: 1
+        });
+        if (models.length === 1) {
+            return models[0];
+        }
+        return null;
+    }
+    async #fetchAll(options = {}) {
+        const { filter, order, page, limit } = options;
+        if (page !== undefined) {
+            if (page < 1) {
+                throw new errors_1.default.BadRequestError({ message: 'page must be greater or equal to 1' });
+            }
+            if (limit !== undefined && limit < 1) {
+                throw new errors_1.default.BadRequestError({ message: 'limit must be greater or equal to 1' });
+            }
+        }
+        const collection = this.Model.getFilteredCollection({
+            filter,
+            mongoTransformer: this.#getNQLKeyTransformer()
+        });
+        const orderString = this.#orderToString(order);
+        collection
+            .query((q) => {
+            this.applyCustomQuery(q, options);
+            if (limit) {
+                q.limit(limit);
+            }
+            if (limit && page) {
+                q.limit(limit);
+                q.offset(limit * (page - 1));
+            }
+            if (orderString) {
+                q.orderByRaw(orderString);
+            }
+        });
+        const models = await collection.fetchAll();
+        return (await Promise.all(models.map(model => this.modelToEntity(model)))).filter(entity => !!entity);
+    }
+    async getAll({ filter, order, include } = {}) {
+        return this.#fetchAll({
+            filter,
+            order,
+            include
+        });
+    }
+    async getPage({ filter, order, page, limit, include }) {
+        return this.#fetchAll({
+            filter,
+            order,
+            page,
+            limit,
+            include
+        });
+    }
+    async getCount({ filter } = {}) {
+        const collection = this.Model.getFilteredCollection({
+            filter,
+            mongoTransformer: this.#getNQLKeyTransformer()
+        });
+        return await collection.count();
+    }
+    async getGroupedCount({ filter, groupBy }) {
+        const columnName = this.#entityFieldToColumn(groupBy);
+        const data = (await this.Model.getFilteredCollection({
+            filter,
+            mongoTransformer: this.#getNQLKeyTransformer()
+        }).query()
+            .select(columnName)
+            .count('* as count')
+            .groupBy(columnName));
+        return data.map((row) => {
+            return {
+                count: row.count,
+                [groupBy]: row[columnName]
+            };
+        });
+    }
+}
+exports.BookshelfRepository = BookshelfRepository;

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

@@ -0,0 +1,196 @@
+/* eslint-disable ghost/filenames/match-exported-class */
+
+import {Knex} from 'knex';
+import {mapKeys, chainTransformers} from '@tryghost/mongo-utils';
+import errors from '@tryghost/errors';
+
+type Entity<T> = {
+    id: T;
+    deleted: boolean
+}
+
+type Order<T> = {
+    field: keyof T;
+    direction: 'asc' | 'desc';
+}
+
+export type ModelClass<T> = {
+    destroy: (data: {id: T}) => Promise<void>;
+    findOne: (data: {id: T}, options?: {require?: boolean}) => Promise<ModelInstance<T> | null>;
+    add: (data: object) => Promise<ModelInstance<T>>;
+    getFilteredCollection: (options: {filter?: string, mongoTransformer?: unknown}) => {
+        count(): Promise<number>,
+        query: (f?: (q: Knex.QueryBuilder) => void) => Knex.QueryBuilder,
+        fetchAll: () => Promise<ModelInstance<T>[]>
+    };
+}
+
+export type ModelInstance<T> = {
+    id: T;
+    get(field: string): unknown;
+    set(data: object|string, value?: unknown): void;
+    save(properties: object, options?: {autoRefresh?: boolean; method?: 'update' | 'insert'}): Promise<ModelInstance<T>>;
+}
+
+type OptionalPropertyOf<T extends object> = Exclude<{
+[K in keyof T]: T extends Record<K, Exclude<T[K], undefined>>
+    ? never
+    : K
+}[keyof T], undefined>
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type OrderOption<T extends Entity<any> = any> = Order<T>[];
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type IncludeOption<T extends Entity<any> = any> = OptionalPropertyOf<T>[];
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type AllOptions<T extends Entity<any> = any> = { filter?: string; order?: OrderOption<T>; page?: number; limit?: number, include?: IncludeOption<T> }
+
+export abstract class BookshelfRepository<IDType, T extends Entity<IDType>> {
+    protected Model: ModelClass<IDType>;
+
+    constructor(Model: ModelClass<IDType>) {
+        this.Model = Model;
+    }
+
+    protected abstract toPrimitive(entity: T): object;
+    protected abstract modelToEntity (model: ModelInstance<IDType>): Promise<T|null> | T | null
+    protected abstract getFieldToColumnMap(): Record<keyof T, string>;
+
+    /**
+     * override this method to add custom query logic to knex queries
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    applyCustomQuery(query: Knex.QueryBuilder, options: AllOptions<T>) {
+        return;
+    }
+
+    #entityFieldToColumn(field: keyof T): string {
+        const mapping = this.getFieldToColumnMap();
+        return mapping[field];
+    }
+
+    #orderToString(order?: OrderOption<T>) {
+        if (!order || order.length === 0) {
+            return;
+        }
+        return order.map(({field, direction}) => `${this.#entityFieldToColumn(field)} ${direction}`).join(',');
+    }
+
+    /**
+     * Map all the fields in an NQL filter to the names of the model
+     */
+    #getNQLKeyTransformer() {
+        return chainTransformers(...mapKeys(this.getFieldToColumnMap()));
+    }
+
+    async save(entity: T): Promise<void> {
+        if (entity.deleted) {
+            await this.Model.destroy({id: entity.id});
+            return;
+        }
+
+        const existing = await this.Model.findOne({id: entity.id}, {require: false});
+        if (existing) {
+            existing.set(this.toPrimitive(entity));
+            await existing.save({}, {autoRefresh: false, method: 'update'});
+        } else {
+            await this.Model.add(this.toPrimitive(entity));
+        }
+    }
+
+    async getById(id: IDType): Promise<T | null> {
+        const models = await this.#fetchAll({
+            filter: `id:'${id}'`,
+            limit: 1
+        });
+        if (models.length === 1) {
+            return models[0];
+        }
+        return null;
+    }
+
+    async #fetchAll(options: AllOptions<T> = {}): Promise<T[]> {
+        const {filter, order, page, limit} = options;
+        if (page !== undefined) {
+            if (page < 1) {
+                throw new errors.BadRequestError({message: 'page must be greater or equal to 1'});
+            }
+            if (limit !== undefined && limit < 1) {
+                throw new errors.BadRequestError({message: 'limit must be greater or equal to 1'});
+            }
+        }
+
+        const collection = this.Model.getFilteredCollection({
+            filter,
+            mongoTransformer: this.#getNQLKeyTransformer()
+        });
+        const orderString = this.#orderToString(order);
+
+        collection
+            .query((q) => {
+                this.applyCustomQuery(q, options);
+
+                if (limit) {
+                    q.limit(limit);
+                }
+                if (limit && page) {
+                    q.limit(limit);
+                    q.offset(limit * (page - 1));
+                }
+
+                if (orderString) {
+                    q.orderByRaw(
+                        orderString
+                    );
+                }
+            });
+
+        const models = await collection.fetchAll();
+        return (await Promise.all(models.map(model => this.modelToEntity(model)))).filter(entity => !!entity) as T[];
+    }
+
+    async getAll({filter, order, include}: Omit<AllOptions<T>, 'page'|'limit'> = {}): Promise<T[]> {
+        return this.#fetchAll({
+            filter,
+            order,
+            include
+        });
+    }
+
+    async getPage({filter, order, page, limit, include}: AllOptions<T> & Required<Pick<AllOptions<T>, 'page'|'limit'>>): Promise<T[]> {
+        return this.#fetchAll({
+            filter,
+            order,
+            page,
+            limit,
+            include
+        });
+    }
+
+    async getCount({filter}: { filter?: string } = {}): Promise<number> {
+        const collection = this.Model.getFilteredCollection({
+            filter,
+            mongoTransformer: this.#getNQLKeyTransformer()
+        });
+        return await collection.count();
+    }
+
+    async getGroupedCount<K extends keyof T>({filter, groupBy}: { filter?: string, groupBy: K }): Promise<({count: number} & Record<K, T[K]>)[]> {
+        const columnName = this.#entityFieldToColumn(groupBy);
+
+        const data = (await this.Model.getFilteredCollection({
+            filter,
+            mongoTransformer: this.#getNQLKeyTransformer()
+        }).query()
+            .select(columnName)
+            .count('* as count')
+            .groupBy(columnName)) as ({count: number} & Record<string, T[K]>)[];
+
+        return data.map((row) => {
+            return {
+                count: row.count,
+                [groupBy]: row[columnName]
+            };
+        }) as ({count: number} & Record<K, T[K]>)[];
+    }
+}

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

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BookshelfSubscribeEventRepository = void 0;
+const BookshelfRepository_1 = require("./BookshelfRepository");
+const logging_1 = __importDefault(require("@tryghost/logging"));
+const SubscribeEvent_1 = require("./SubscribeEvent");
+class BookshelfSubscribeEventRepository extends BookshelfRepository_1.BookshelfRepository {
+    sentry;
+    constructor(Model, deps = {}) {
+        super(Model);
+        this.sentry = deps.sentry;
+    }
+    toPrimitive(entity) {
+        return {
+            id: entity.id,
+            recommendation_id: entity.recommendationId,
+            member_id: entity.memberId,
+            created_at: entity.createdAt
+        };
+    }
+    modelToEntity(model) {
+        try {
+            return SubscribeEvent_1.SubscribeEvent.create({
+                id: model.id,
+                recommendationId: model.get('recommendation_id'),
+                memberId: model.get('member_id'),
+                createdAt: model.get('created_at')
+            });
+        }
+        catch (err) {
+            logging_1.default.error(err);
+            this.sentry?.captureException(err);
+            return null;
+        }
+    }
+    getFieldToColumnMap() {
+        return {
+            id: 'id',
+            recommendationId: 'recommendation_id',
+            memberId: 'member_id',
+            createdAt: 'created_at'
+        };
+    }
+}
+exports.BookshelfSubscribeEventRepository = BookshelfSubscribeEventRepository;

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

@@ -0,0 +1,49 @@
+import {BookshelfRepository, ModelClass, ModelInstance} from './BookshelfRepository';
+import logger from '@tryghost/logging';
+import {SubscribeEvent} from './SubscribeEvent';
+
+type Sentry = {
+    captureException(err: unknown): void;
+}
+
+export class BookshelfSubscribeEventRepository extends BookshelfRepository<string, SubscribeEvent> {
+    sentry?: Sentry;
+
+    constructor(Model: ModelClass<string>, deps: {sentry?: Sentry} = {}) {
+        super(Model);
+        this.sentry = deps.sentry;
+    }
+
+    toPrimitive(entity: SubscribeEvent): object {
+        return {
+            id: entity.id,
+            recommendation_id: entity.recommendationId,
+            member_id: entity.memberId,
+            created_at: entity.createdAt
+        };
+    }
+
+    modelToEntity(model: ModelInstance<string>): SubscribeEvent | null {
+        try {
+            return SubscribeEvent.create({
+                id: model.id,
+                recommendationId: model.get('recommendation_id') as string,
+                memberId: model.get('member_id') as string,
+                createdAt: model.get('created_at') as Date
+            });
+        } catch (err) {
+            logger.error(err);
+            this.sentry?.captureException(err);
+            return null;
+        }
+    }
+
+    getFieldToColumnMap() {
+        return {
+            id: 'id',
+            recommendationId: 'recommendation_id',
+            memberId: 'member_id',
+            createdAt: 'created_at'
+        } as Record<keyof SubscribeEvent, string>;
+    }
+}

package/core/server/services/recommendations/service/ClickEvent.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.ClickEvent = void 0;
+const bson_objectid_1 = __importDefault(require("bson-objectid"));
+class ClickEvent {
+    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 ?? null,
+            createdAt: data.createdAt ?? new Date()
+        };
+        return new ClickEvent(d);
+    }
+}
+exports.ClickEvent = ClickEvent;

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

@@ -0,0 +1,32 @@
+import ObjectId from 'bson-objectid';
+
+export class ClickEvent {
+    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|null, createdAt?: Date}) {
+        const id = data.id ?? ObjectId().toString();
+
+        const d = {
+            id,
+            recommendationId: data.recommendationId,
+            memberId: data.memberId ?? null,
+            createdAt: data.createdAt ?? new Date()
+        };
+
+        return new ClickEvent(d);
+    }
+}

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemoryRecommendationRepository = void 0;
+const InMemoryRepository_1 = require("../../lib/InMemoryRepository");
+class InMemoryRecommendationRepository extends InMemoryRepository_1.InMemoryRepository {
+    toPrimitive(entity) {
+        return entity;
+    }
+    async getByUrl(url) {
+        //  Find URL based on the hostname and pathname.
+        //  Query params, hash fragements, protocol and www are ignored.
+        const existing = this.store.find((r) => {
+            return r.url.hostname.replace('www.', '') === url.hostname.replace('www.', '') &&
+                r.url.pathname.replace(/\/$/, '') === url.pathname.replace(/\/$/, '');
+        }) || null;
+        return existing;
+    }
+}
+exports.InMemoryRecommendationRepository = InMemoryRecommendationRepository;

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

@@ -0,0 +1,20 @@
+import {Recommendation} from './Recommendation';
+import {RecommendationRepository} from './RecommendationRepository';
+import {InMemoryRepository} from '../../lib/InMemoryRepository';
+
+export class InMemoryRecommendationRepository extends InMemoryRepository<string, Recommendation> implements RecommendationRepository {
+    toPrimitive(entity: Recommendation): object {
+        return entity;
+    }
+
+    async getByUrl(url: URL): Promise<Recommendation | null > {
+        //  Find URL based on the hostname and pathname.
+        //  Query params, hash fragements, protocol and www are ignored.
+        const existing = this.store.find((r) => {
+            return r.url.hostname.replace('www.', '') === url.hostname.replace('www.', '') &&
+                   r.url.pathname.replace(/\/$/, '') === url.pathname.replace(/\/$/, '');
+        }) || null;
+
+        return existing;
+    }
+}

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IncomingRecommendationController = void 0;
+const UnsafeData_1 = require("./UnsafeData");
+class IncomingRecommendationController {
+    service;
+    constructor(deps) {
+        this.service = deps.service;
+    }
+    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 { incomingRecommendations, meta } = await this.service.listIncomingRecommendations({ page, limit });
+        return this.#serialize(incomingRecommendations, meta);
+    }
+    #serialize(recommendations, meta) {
+        return {
+            data: recommendations.map((entity) => {
+                return {
+                    id: entity.id,
+                    title: entity.title,
+                    excerpt: entity.excerpt,
+                    featured_image: entity.featuredImage?.toString() ?? null,
+                    favicon: entity.favicon?.toString() ?? null,
+                    url: entity.url.toString(),
+                    recommending_back: !!entity.recommendingBack
+                };
+            }),
+            meta
+        };
+    }
+}
+exports.IncomingRecommendationController = IncomingRecommendationController;