ghost 5.115.1 → 5.116.1

package/core/server/data/seeders/importers/MembersSubscribeEventsImporter.js

@@ -0,0 +1,69 @@
+const TableImporter = require('./TableImporter');
+const {faker} = require('@faker-js/faker');
+const {luck} = require('../utils/random');
+const dateToDatabaseString = require('../utils/database-date');
+
+class MembersSubscribeEventsImporter extends TableImporter {
+    static table = 'members_subscribe_events';
+    static dependencies = ['members', 'newsletters'];
+
+    constructor(knex, transaction) {
+        super(MembersSubscribeEventsImporter.table, knex, transaction);
+    }
+
+    async import(quantity) {
+        if (quantity === 0) {
+            return;
+        }
+
+        let offset = 0;
+        let limit = 100000;
+        this.newsletters = await this.transaction.select('id').from('newsletters').orderBy('sort_order');
+
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            const members = await this.transaction.select('id', 'created_at', 'status').from('members').limit(limit).offset(offset);
+
+            if (members.length === 0) {
+                break;
+            }
+
+            await this.importForEach(members, quantity ? quantity / members.length : this.newsletters.length);
+            offset += limit;
+        }
+    }
+
+    setReferencedModel(model) {
+        this.model = model;
+        this.count = 0;
+    }
+
+    generate() {
+        const count = this.count;
+        this.count = this.count + 1;
+
+        if (count === 1 && this.model.status === 'free') {
+            return null;
+        }
+
+        let subscribed = luck(80);
+
+        if (!subscribed) {
+            return null;
+        }
+
+        const createdAt = dateToDatabaseString(faker.date.between(new Date(this.model.created_at), new Date()));
+        const newsletterId = this.newsletters[count % this.newsletters.length].id;
+
+        return {
+            id: this.fastFakeObjectId(),
+            member_id: this.model.id,
+            newsletter_id: newsletterId,
+            subscribed: 1,
+            created_at: createdAt,
+            source: 'member'
+        };
+    }
+}
+
+module.exports = MembersSubscribeEventsImporter;

package/core/server/data/seeders/importers/MembersSubscriptionCreatedEventsImporter.js

@@ -0,0 +1,95 @@
+const TableImporter = require('./TableImporter');
+const {faker} = require('@faker-js/faker');
+const {luck} = require('../utils/random');
+
+class MembersSubscriptionCreatedEventsImporter extends TableImporter {
+    static table = 'members_subscription_created_events';
+    static dependencies = ['members_stripe_customers', 'members_stripe_customers_subscriptions', 'posts', 'mentions'];
+
+    constructor(knex, transaction) {
+        super(MembersSubscriptionCreatedEventsImporter.table, knex, transaction);
+    }
+
+    async import(quantity) {
+        let offset = 0;
+        let limit = 1000;
+        this.posts = await this.transaction.select('id', 'published_at', 'visibility', 'type', 'slug').from('posts').whereNotNull('published_at').where('visibility', 'public').orderBy('published_at', 'desc');
+        this.incomingRecommendations = await this.transaction.select('id', 'source', 'created_at').from('mentions');
+
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            const membersStripeCustomersSubscriptions = await this.transaction.select('id', 'created_at', 'customer_id').from('members_stripe_customers_subscriptions').limit(limit).offset(offset);
+
+            if (membersStripeCustomersSubscriptions.length === 0) {
+                break;
+            }
+            const membersStripeCustomers = await this.transaction.select('id', 'member_id', 'customer_id').from('members_stripe_customers').whereIn('customer_id', membersStripeCustomersSubscriptions.map(subscription => subscription.customer_id));
+
+            this.membersStripeCustomers = new Map();
+            for (const memberStripeCustomer of membersStripeCustomers) {
+                this.membersStripeCustomers.set(memberStripeCustomer.customer_id, memberStripeCustomer);
+            }
+            await this.importForEach(membersStripeCustomersSubscriptions, quantity ? quantity / membersStripeCustomersSubscriptions.length : 1);
+            offset += limit;
+        }
+    }
+
+    generate() {
+        // We need to add all properties here already otherwise CSV imports won't know all the columns
+        let attribution = {
+            attribution_id: null,
+            attribution_type: null,
+            attribution_url: null
+        };
+        let referrer = {
+            referrer_source: null,
+            referrer_url: null,
+            referrer_medium: null
+        };
+
+        if (luck(30)) {
+            const post = this.posts.find(p => p.visibility === 'public' && new Date(p.published_at) < new Date(this.model.created_at));
+            if (post) {
+                attribution = {
+                    attribution_id: post.id,
+                    attribution_type: post.type,
+                    attribution_url: post.slug
+                };
+            }
+        }
+
+        if (luck(40)) {
+            if (luck(20)) {
+                // Ghost network
+                referrer = {
+                    referrer_source: luck(20) ? 'Ghost.org' : 'Ghost Explore',
+                    referrer_url: 'ghost.org',
+                    referrer_medium: 'Ghost Network'
+                };
+            } else {
+                // Incoming recommendation
+                const incomingRecommendation = faker.helpers.arrayElement(this.incomingRecommendations);
+
+                const hostname = new URL(incomingRecommendation.source).hostname;
+                referrer = {
+                    referrer_source: hostname,
+                    referrer_url: hostname,
+                    referrer_medium: faker.helpers.arrayElement([null, 'Email'])
+                };
+            }
+        }
+
+        const memberCustomer = this.membersStripeCustomers.get(this.model.customer_id);
+
+        return {
+            id: this.fastFakeObjectId(),
+            created_at: this.model.created_at,
+            member_id: memberCustomer.member_id,
+            subscription_id: this.model.id,
+            ...attribution,
+            ...referrer
+        };
+    }
+}
+
+module.exports = MembersSubscriptionCreatedEventsImporter;

package/core/server/data/seeders/importers/NewslettersImporter.js

@@ -0,0 +1,40 @@
+const TableImporter = require('./TableImporter');
+const {blogStartDate} = require('../utils/blog-info');
+const {faker} = require('@faker-js/faker');
+const {slugify} = require('@tryghost/string');
+
+class NewslettersImporter extends TableImporter {
+    static table = 'newsletters';
+    static dependencies = [];
+
+    defaultQuantity = 2;
+
+    sortOrder = 0;
+
+    constructor(knex, transaction) {
+        super(NewslettersImporter.table, knex, transaction);
+    }
+
+    generate() {
+        const name = `${faker.commerce.productAdjective()} ${faker.word.noun()}`;
+        const sortOrder = this.sortOrder;
+        this.sortOrder = this.sortOrder + 1;
+
+        const weekAfter = new Date(blogStartDate);
+        weekAfter.setDate(weekAfter.getDate() + 7);
+
+        return {
+            id: this.fastFakeObjectId(),
+            uuid: faker.datatype.uuid(),
+            name: name,
+            slug: `${slugify(name)}-${faker.random.numeric(3)}`,
+            sender_reply_to: 'newsletter',
+            status: 'active',
+            subscribe_on_signup: faker.datatype.boolean(),
+            sort_order: sortOrder,
+            created_at: faker.date.between(blogStartDate, weekAfter)
+        };
+    }
+}
+
+module.exports = NewslettersImporter;

package/core/server/data/seeders/importers/OffersImporter.js

@@ -0,0 +1,70 @@
+const TableImporter = require('./TableImporter');
+const {faker} = require('@faker-js/faker');
+const {slugify} = require('@tryghost/string');
+const {blogStartDate} = require('../utils/blog-info');
+const dateToDatabaseString = require('../utils/database-date');
+
+class OffersImporter extends TableImporter {
+    static table = 'offers';
+    static dependencies = ['products'];
+    defaultQuantity = 2;
+
+    constructor(knex, transaction) {
+        super(OffersImporter.table, knex, transaction);
+    }
+
+    async import(quantity = this.defaultQuantity) {
+        this.products = await this.transaction.select('id', 'currency').from('products').where('type', 'paid');
+        this.names = ['Black Friday', 'Free Trial'];
+        this.count = 0;
+
+        await super.import(quantity);
+    }
+
+    generate() {
+        const name = this.names.pop();
+
+        const product = this.products[faker.datatype.number({
+            min: 0,
+            max: this.products.length - 1
+        })];
+
+        // id: {type: 'string', maxlength: 24, nullable: false, primary: true},
+        // // @deprecated: use a status enum with isIn validation, not an `active` boolean
+        // active: {type: 'boolean', nullable: false, defaultTo: true},
+        // name: {type: 'string', maxlength: 191, nullable: false, unique: true},
+        // code: {type: 'string', maxlength: 191, nullable: false, unique: true},
+        // product_id: {type: 'string', maxlength: 24, nullable: false, references: 'products.id'},
+        // stripe_coupon_id: {type: 'string', maxlength: 255, nullable: true, unique: true},
+        // interval: {type: 'string', maxlength: 50, nullable: false, validations: {isIn: [['month', 'year']]}},
+        // currency: {type: 'string', maxlength: 50, nullable: true},
+        // discount_type: {type: 'string', maxlength: 50, nullable: false, validations: {isIn: [['percent', 'amount', 'trial']]}},
+        // discount_amount: {type: 'integer', nullable: false},
+        // duration: {type: 'string', maxlength: 50, nullable: false, validations: {isIn: [['trial', 'once', 'repeating', 'forever']]}},
+        // duration_in_months: {type: 'integer', nullable: true},
+        // portal_title: {type: 'string', maxlength: 191, nullable: true},
+        // portal_description: {type: 'string', maxlength: 2000, nullable: true},
+        // created_at: {type: 'dateTime', nullable: false},
+        // updated_at: {type: 'dateTime', nullable: true}
+        return {
+            id: this.fastFakeObjectId(),
+            active: true,
+            name,
+            code: slugify(name),
+            product_id: product.id,
+            stripe_coupon_id: faker.random.alphaNumeric(8),
+            interval: 'month',
+            currency: product.currency,
+            discount_type: name === 'Free Trial' ? 'trial' : 'percent',
+            discount_amount: name === 'Free Trial' ? 7 : 20,
+            duration: name === 'Free Trial' ? 'trial' : 'once',
+            duration_in_months: name === 'Free Trial' ? 1 : 12,
+            portal_title: name,
+            portal_description: name === 'Free Trial' ? 'Get a 1 week free trial' : 'Get 20% off for Black Friday',
+            created_at: dateToDatabaseString(blogStartDate),
+            updated_at: dateToDatabaseString(blogStartDate)
+        };
+    }
+}
+
+module.exports = OffersImporter;

package/core/server/data/seeders/importers/PostsAuthorsImporter.js

@@ -0,0 +1,32 @@
+const {faker} = require('@faker-js/faker');
+const TableImporter = require('./TableImporter');
+
+class PostsAuthorsImporter extends TableImporter {
+    static table = 'posts_authors';
+    static dependencies = ['posts', 'users'];
+
+    constructor(knex, transaction) {
+        super(PostsAuthorsImporter.table, knex, transaction);
+        this.sortOrder = 0;
+    }
+
+    async import(quantity) {
+        const posts = await this.transaction.select('id').from('posts');
+        this.users = await this.transaction.select('id').from('users');
+
+        await this.importForEach(posts, quantity ? quantity / posts.length : 1);
+    }
+
+    generate() {
+        const sortOrder = this.sortOrder;
+        this.sortOrder = this.sortOrder + 1;
+        return {
+            id: this.fastFakeObjectId(),
+            post_id: this.model.id,
+            author_id: this.users[faker.datatype.number(this.users.length - 1)].id,
+            sort_order: sortOrder
+        };
+    }
+}
+
+module.exports = PostsAuthorsImporter;

package/core/server/data/seeders/importers/PostsImporter.js

@@ -0,0 +1,102 @@
+const {faker} = require('@faker-js/faker');
+const {slugify} = require('@tryghost/string');
+const {luck} = require('../utils/random');
+const TableImporter = require('./TableImporter');
+const dateToDatabaseString = require('../utils/database-date');
+
+class PostsImporter extends TableImporter {
+    static table = 'posts';
+    static dependencies = ['newsletters'];
+    defaultQuantity = faker.datatype.number({
+        min: 80,
+        max: 120
+    });
+
+    type = 'post';
+
+    constructor(knex, transaction) {
+        super(PostsImporter.table, knex, transaction);
+    }
+
+    async import(quantity = this.defaultQuantity) {
+        this.newsletters = await this.transaction.select('id').from('newsletters').orderBy('sort_order');
+
+        await super.import(quantity);
+    }
+
+    generate() {
+        const title = faker.lorem.sentence();
+        const content = faker.lorem.paragraphs(faker.datatype.number({
+            min: 3,
+            max: 10
+        })).split('\n');
+        const twoYearsAgo = new Date();
+        twoYearsAgo.setFullYear(twoYearsAgo.getFullYear() - 2);
+        const twoWeeksFromNow = new Date();
+        twoWeeksFromNow.setDate(twoWeeksFromNow.getDate() + 14);
+        const timestamp = faker.date.between(twoYearsAgo, twoWeeksFromNow);
+        const currentTime = new Date();
+
+        let status = 'published';
+        if (timestamp > currentTime) {
+            status = 'scheduled';
+        }
+        if (luck(5)) {
+            status = 'draft';
+        }
+        if (this.type === 'page') {
+            status = 'published';
+        }
+
+        const visibility = luck(85) ? 'paid' : luck(10) ? 'members' : 'public';
+
+        return {
+            id: this.fastFakeObjectId(),
+            created_at: dateToDatabaseString(timestamp),
+            created_by: '1',
+            updated_at: dateToDatabaseString(timestamp),
+            published_at: status === 'published' ? dateToDatabaseString(timestamp) : status === 'scheduled' ? dateToDatabaseString(faker.date.soon(5, timestamp)) : null,
+            uuid: faker.datatype.uuid(),
+            title: title,
+            type: this.type,
+            slug: `${slugify(title)}-${faker.random.numeric(3)}`,
+            status,
+            visibility,
+            lexical: JSON.stringify({
+                root: {
+                    children: content.map(paragraph => (
+                        {
+                            children: [
+                                {
+                                    detail: 0,
+                                    format: 0,
+                                    mode: 'normal',
+                                    style: '',
+                                    text: paragraph,
+                                    type: 'extended-text',
+                                    version: 1
+                                }
+                            ],
+                            direction: 'ltr',
+                            format: '',
+                            indent: 0,
+                            type: 'paragraph',
+                            version: 1
+                        }
+                    )),
+                    direction: 'ltr',
+                    format: '',
+                    indent: 0,
+                    type: 'root',
+                    version: 1
+                }
+            }),
+            html: content.map(paragraph => `<p>${paragraph}</p>`).join(''),
+            plaintext: content.join('\n\n'),
+            email_recipient_filter: 'all',
+            newsletter_id: this.type === 'post' && status === 'published' && luck(90) ? (visibility === 'paid' ? this.newsletters[0].id : this.newsletters[1].id) : null
+        };
+    }
+}
+
+module.exports = PostsImporter;

package/core/server/data/seeders/importers/PostsProductsImporter.js

@@ -0,0 +1,35 @@
+const TableImporter = require('./TableImporter');
+
+class PostsProductsImporter extends TableImporter {
+    static table = 'posts_products';
+    static dependencies = ['posts', 'products'];
+
+    constructor(knex, transaction) {
+        super(PostsProductsImporter.table, knex, transaction);
+    }
+
+    async import(quantity) {
+        const posts = await this.transaction.select('id').from('posts').where('type', 'post');
+        this.products = await this.transaction.select('id').from('products');
+
+        await this.importForEach(posts, quantity ? quantity / posts.length : 1);
+    }
+
+    setReferencedModel(model) {
+        this.model = model;
+        this.sortOrder = 0;
+    }
+
+    generate() {
+        const sortOrder = this.sortOrder;
+        this.sortOrder = this.sortOrder + 1;
+        return {
+            id: this.fastFakeObjectId(),
+            post_id: this.model.id,
+            product_id: this.products[sortOrder].id,
+            sort_order: this.sortOrder
+        };
+    }
+}
+
+module.exports = PostsProductsImporter;

package/core/server/data/seeders/importers/PostsTagsImporter.js

@@ -0,0 +1,46 @@
+const {faker} = require('@faker-js/faker');
+const TableImporter = require('./TableImporter');
+
+class PostsTagsImporter extends TableImporter {
+    static table = 'posts_tags';
+    static dependencies = ['posts', 'tags'];
+
+    constructor(knex, transaction) {
+        super(PostsTagsImporter.table, knex, transaction);
+        this.sortOrder = 0;
+    }
+
+    async import(quantity) {
+        const posts = await this.transaction.select('id').from('posts').where('type', 'post');
+        this.tags = await this.transaction.select('id').from('tags');
+
+        await this.importForEach(posts, quantity ? quantity / posts.length : () => faker.datatype.number({
+            min: 0,
+            max: 3
+        }));
+    }
+
+    setReferencedModel(model) {
+        this.model = model;
+        this.notIndex = [];
+    }
+
+    generate() {
+        const sortOrder = this.sortOrder;
+        this.sortOrder = this.sortOrder + 1;
+        let tagIndex = 0;
+        do {
+            tagIndex = faker.datatype.number(this.tags.length - 1);
+        } while (this.notIndex.includes(tagIndex));
+        this.notIndex.push(tagIndex);
+
+        return {
+            id: this.fastFakeObjectId(),
+            post_id: this.model.id,
+            tag_id: this.tags[tagIndex].id,
+            sort_order: sortOrder
+        };
+    }
+}
+
+module.exports = PostsTagsImporter;

package/core/server/data/seeders/importers/ProductsBenefitsImporter.js

@@ -0,0 +1,54 @@
+const TableImporter = require('./TableImporter');
+
+class ProductsBenefitsImporter extends TableImporter {
+    static table = 'products_benefits';
+    static dependencies = ['benefits', 'products'];
+
+    constructor(knex, transaction) {
+        super(ProductsBenefitsImporter.table, knex, transaction);
+    }
+
+    async import(quantity) {
+        const products = await this.transaction.select('id', 'name').from('products');
+        this.benefits = await this.transaction.select('id').from('benefits');
+
+        await this.importForEach(products, quantity ? quantity / products.length : 5);
+    }
+
+    setReferencedModel(model) {
+        this.model = model;
+
+        this.sortOrder = 0;
+        switch (this.model.name) {
+        case 'Bronze':
+            this.benefitCount = 1;
+            break;
+        case 'Silver':
+            this.benefitCount = 3;
+            break;
+        case 'Gold':
+            this.benefitCount = 5;
+            break;
+        case 'Free Preview':
+            this.benefitCount = 0;
+            break;
+        }
+    }
+
+    generate() {
+        if (this.sortOrder >= this.benefitCount) {
+            // No more benefits than benefitCount
+            return null;
+        }
+        const sortOrder = this.sortOrder;
+        this.sortOrder = this.sortOrder + 1;
+        return {
+            id: this.fastFakeObjectId(),
+            product_id: this.model.id,
+            benefit_id: this.benefits[sortOrder].id,
+            sort_order: sortOrder
+        };
+    }
+}
+
+module.exports = ProductsBenefitsImporter;

package/core/server/data/seeders/importers/ProductsImporter.js

@@ -0,0 +1,90 @@
+const TableImporter = require('./TableImporter');
+const {faker} = require('@faker-js/faker');
+const {slugify} = require('@tryghost/string');
+const {blogStartDate} = require('../utils/blog-info');
+
+class ProductsImporter extends TableImporter {
+    static table = 'products';
+    static dependencies = [];
+    defaultQuantity = 4;
+
+    constructor(knex, transaction) {
+        super(ProductsImporter.table, knex, transaction);
+    }
+
+    async import(quantity = this.defaultQuantity) {
+        // TODO: Add random products if quantity != 4
+        this.names = ['Free', 'Bronze', 'Silver', 'Gold'].reverse();
+        this.count = 0;
+
+        await super.import(quantity);
+    }
+
+    /**
+     * Add the stripe products / prices
+     */
+    async finalise() {
+        const stripeProducts = await this.transaction.select('id', 'product_id', 'stripe_product_id').from('stripe_products');
+        const stripePrices = await this.transaction.select('id', 'stripe_product_id', 'interval').from('stripe_prices');
+
+        const products = await this.transaction.select('id').from('products');
+
+        for (const {id} of products) {
+            const stripeProduct = stripeProducts.find(p => id === p.product_id);
+            if (!stripeProduct) {
+                // Free product
+                continue;
+            }
+            const monthlyPrice = stripePrices.find((p) => {
+                return p.stripe_product_id === stripeProduct.stripe_product_id &&
+                    p.interval === 'monthly';
+            });
+            const yearlyPrice = stripePrices.find((p) => {
+                return p.stripe_product_id === stripeProduct.stripe_product_id &&
+                    p.interval === 'yearly';
+            });
+
+            const update = {};
+            if (monthlyPrice) {
+                update.monthly_price_id = monthlyPrice.id;
+            }
+            if (yearlyPrice) {
+                update.yearly_price_id = yearlyPrice.id;
+            }
+
+            if (Object.keys(update).length > 0) {
+                await this.transaction('products').update(update).where({
+                    id
+                });
+            }
+        }
+    }
+
+    generate() {
+        const name = this.names.pop();
+        const count = this.count;
+        this.count = this.count + 1;
+        const sixMonthsLater = new Date(blogStartDate);
+        sixMonthsLater.setMonth(sixMonthsLater.getMonth() + 6);
+        const tierInfo = {
+            type: 'free',
+            description: 'A free sample of content'
+        };
+        if (count !== 0) {
+            tierInfo.type = 'paid';
+            tierInfo.description = `${name} tier member`;
+            tierInfo.currency = 'USD';
+            tierInfo.monthly_price = count * 500;
+            tierInfo.yearly_price = count * 5000;
+        }
+        return Object.assign({}, {
+            id: this.fastFakeObjectId(),
+            name: name,
+            slug: `${slugify(name)}-${faker.random.numeric(3)}`,
+            visibility: 'public',
+            created_at: faker.date.between(blogStartDate, sixMonthsLater)
+        }, tierInfo);
+    }
+}
+
+module.exports = ProductsImporter;

package/core/server/data/seeders/importers/RecommendationClickEventsImporter.js

@@ -0,0 +1,32 @@
+const TableImporter = require('./TableImporter');
+const {faker} = require('@faker-js/faker');
+const {luck} = require('../utils/random');
+
+class RecommendationClickEventsImporter extends TableImporter {
+    static table = 'recommendation_click_events';
+    static dependencies = ['recommendations', 'members'];
+
+    constructor(knex, transaction) {
+        super(RecommendationClickEventsImporter.table, knex, transaction);
+    }
+
+    async import(quantity) {
+        const recommendations = await this.transaction.select('id', 'created_at').from('recommendations');
+        this.members = await this.transaction.select('id').from('members').limit(500);
+
+        await this.importForEach(recommendations, quantity ? quantity / recommendations.length : () => faker.datatype.number({min: 0, max: 30}));
+    }
+
+    generate() {
+        // Not unique
+        const member = luck(30) ? null : faker.helpers.arrayElement(this.members);
+        return {
+            id: this.fastFakeObjectId(),
+            recommendation_id: this.model.id,
+            member_id: member?.id ?? null,
+            created_at: faker.date.past()
+        };
+    }
+}
+
+module.exports = RecommendationClickEventsImporter;