ghost 6.57.1 → 6.58.0

package/core/server/services/recommendations/service/bookshelf-click-event-repository.ts

@@ -1,49 +0,0 @@
-import {BookshelfRepository, ModelClass, ModelInstance} from './bookshelf-repository';
-import logger from '@tryghost/logging';
-import {ClickEvent} from './click-event';
-
-type Sentry = {
-    captureException(err: unknown): void;
-}
-
-export class BookshelfClickEventRepository extends BookshelfRepository<string, ClickEvent> {
-    sentry?: Sentry;
-
-    constructor(Model: ModelClass<string>, deps: {sentry?: Sentry} = {}) {
-        super(Model);
-        this.sentry = deps.sentry;
-    }
-
-    toPrimitive(entity: ClickEvent): object {
-        return {
-            id: entity.id,
-            recommendation_id: entity.recommendationId,
-            member_id: entity.memberId,
-            created_at: entity.createdAt
-        };
-    }
-
-    modelToEntity(model: ModelInstance<string>): ClickEvent | null {
-        try {
-            return ClickEvent.create({
-                id: model.id,
-                recommendationId: model.get('recommendation_id') as string,
-                memberId: model.get('member_id') as string | null,
-                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 ClickEvent, string>;
-    }
-}

package/core/server/services/recommendations/service/bookshelf-recommendation-repository.ts

@@ -1,117 +0,0 @@
-import {AllOptions, BookshelfRepository, ModelClass, ModelInstance} from './bookshelf-repository';
-import logger from '@tryghost/logging';
-import {Knex} from 'knex';
-import {Recommendation} from './recommendation';
-import {RecommendationRepository} from './recommendation-repository';
-
-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/bookshelf-repository.ts

@@ -1,192 +0,0 @@
-
-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>
-
-export type OrderOption<T extends Entity<any> = any> = Order<T>[];
-export type IncludeOption<T extends Entity<any> = any> = OptionalPropertyOf<T>[];
-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/bookshelf-subscribe-event-repository.ts

@@ -1,49 +0,0 @@
-import {BookshelfRepository, ModelClass, ModelInstance} from './bookshelf-repository';
-import logger from '@tryghost/logging';
-import {SubscribeEvent} from './subscribe-event';
-
-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/click-event.ts

@@ -1,32 +0,0 @@
-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/in-memory-recommendation-repository.ts

@@ -1,20 +0,0 @@
-import {Recommendation} from './recommendation';
-import {RecommendationRepository} from './recommendation-repository';
-import {InMemoryRepository} from '../../lib/in-memory-repository';
-
-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/incoming-recommendation-controller.ts

@@ -1,51 +0,0 @@
-import {IncomingRecommendationService} from './incoming-recommendation-service';
-import {IncomingRecommendation} from './incoming-recommendation-service';
-import {UnsafeData} from './unsafe-data';
-
-type Frame = {
-    data: unknown,
-    options: unknown,
-};
-
-type Meta = {
-    pagination: object,
-}
-
-export class IncomingRecommendationController {
-    service: IncomingRecommendationService;
-
-    constructor(deps: {service: IncomingRecommendationService}) {
-        this.service = deps.service;
-    }
-
-    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 {incomingRecommendations, meta} = await this.service.listIncomingRecommendations({page, limit});
-
-        return this.#serialize(
-            incomingRecommendations,
-            meta
-        );
-    }
-
-    #serialize(recommendations: IncomingRecommendation[], meta?: 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
-        };
-    }
-}

package/core/server/services/recommendations/service/incoming-recommendation-email-renderer.ts

@@ -1,37 +0,0 @@
-import {EmailRecipient} from './incoming-recommendation-service';
-import {IncomingRecommendation} from './incoming-recommendation-service';
-
-type StaffService = {
-    api: {
-        emails: {
-            renderHTML(template: string, data: unknown): Promise<string>,
-            renderText(template: string, data: unknown): Promise<string>
-        }
-    }
-}
-
-export class IncomingRecommendationEmailRenderer {
-    #staffService: StaffService;
-
-    constructor({staffService}: {staffService: StaffService}) {
-        this.#staffService = staffService;
-    }
-
-    async renderSubject(recommendation: IncomingRecommendation) {
-        return `👍 New recommendation: ${recommendation.title}`;
-    }
-
-    async renderHTML(recommendation: IncomingRecommendation, recipient: EmailRecipient) {
-        return this.#staffService.api.emails.renderHTML('recommendation-received', {
-            recommendation,
-            recipient
-        });
-    }
-
-    async renderText(recommendation: IncomingRecommendation, recipient: EmailRecipient) {
-        return this.#staffService.api.emails.renderText('recommendation-received', {
-            recommendation,
-            recipient
-        });
-    }
-}