ghost 5.115.0 → 5.116.0

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

@@ -0,0 +1,259 @@
+const {faker} = require('@faker-js/faker');
+const TableImporter = require('./TableImporter');
+const dateToDatabaseString = require('../utils/database-date');
+const generateEvents = require('../utils/event-generator');
+const {luck} = require('../utils/random');
+
+class MembersStripeCustomersSubscriptionsImporter extends TableImporter {
+    static table = 'members_stripe_customers_subscriptions';
+    static dependencies = ['members', 'members_products', 'members_stripe_customers', 'products', 'stripe_products', 'stripe_prices'];
+
+    constructor(knex, transaction) {
+        super(MembersStripeCustomersSubscriptionsImporter.table, knex, transaction);
+    }
+
+    async import() {
+        let offset = 0;
+        let limit = 5000;
+        this.products = await this.transaction.select('id', 'name').from('products').whereNot('type', 'free');
+        this.stripeProducts = await this.transaction.select('id', 'product_id', 'stripe_product_id').from('stripe_products');
+        this.stripePrices = await this.transaction.select('id', 'nickname', 'stripe_product_id', 'stripe_price_id', 'amount', 'interval', 'currency').from('stripe_prices');
+
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            const membersStripeCustomers = await this.transaction.select('id', 'member_id', 'customer_id').from('members_stripe_customers').limit(limit).offset(offset);
+
+            if (membersStripeCustomers.length === 0) {
+                break;
+            }
+
+            this.members = await this.transaction.select('id', 'status', 'created_at').from('members').whereIn('id', membersStripeCustomers.map(m => m.member_id));
+
+            if (this.members.length === 0) {
+                continue;
+            }
+
+            const membersProducts = await this.transaction.select('member_id', 'product_id').from('members_products').whereIn('member_id', this.members.map(member => member.id));
+            //const membersStripeCustomers = await this.transaction.select('id', 'member_id', 'customer_id').from('members_stripe_customers').whereIn('member_id', this.members.map(member => member.id));
+
+            this.membersStripeCustomers = new Map();
+            for (const customer of membersStripeCustomers) {
+                this.membersStripeCustomers.set(customer.member_id, customer);
+            }
+
+            this.membersProducts = new Map();
+
+            for (const product of membersProducts) {
+                this.membersProducts.set(product.member_id, product);
+            }
+
+            await this.importForEach(this.members, 1.2);
+
+            offset += limit;
+        }
+    }
+
+    setReferencedModel(model) {
+        this.model = model;
+        this.count = 0;
+        this.lastSubscriptionStart = null;
+    }
+
+    generate() {
+        this.count += 1;
+
+        const member = this.model;
+        const customer = this.membersStripeCustomers.get(this.model.id);
+
+        if (!customer) {
+            // This is a requirement, so skip if we don't have a customer
+            return;
+        }
+
+        if (this.count > 1 && member.status !== 'paid') {
+            return;
+        }
+
+        const memberProduct = this.membersProducts.get(this.model.id);
+        let ghostProduct = memberProduct ? this.products.find(product => product.id === memberProduct.product_id) : null;
+
+        // Whether we should create a valid subscription or not
+        // We'll only create one valid subscription for each member if they are currently paid
+        let createValid = this.count === 1 && member.status === 'paid';
+
+        if (!ghostProduct) {
+            // Generate canceled, incomplete, incomplete_expired or unpaid subscriptions
+            // Choose a random paid product
+            ghostProduct = faker.helpers.arrayElement(this.products);
+            createValid = false;
+        }
+
+        const isMonthly = luck(70);
+        const stripeProduct = this.stripeProducts.find(product => product.product_id === ghostProduct.id);
+        const stripePrice = this.stripePrices.find((price) => {
+            return price.stripe_product_id === stripeProduct.stripe_product_id &&
+                (isMonthly ? price.interval === 'month' : price.interval === 'year');
+        });
+        const mrr = createValid ? (isMonthly ? stripePrice.amount : Math.floor(stripePrice.amount / 12)) : 0;
+
+        const referenceEndDate = this.lastSubscriptionStart ?? new Date();
+
+        if (!createValid) {
+            if (isMonthly) {
+                referenceEndDate.setMonth(referenceEndDate.getMonth() - 1);
+            } else {
+                referenceEndDate.setFullYear(referenceEndDate.getFullYear() - 1);
+            }
+        }
+
+        if (referenceEndDate < member.created_at) {
+            // Not possible to create an invalid subscription here
+            return;
+        }
+
+        const [startDate] = generateEvents({
+            total: 1,
+            trend: 'negative',
+            startTime: new Date(member.created_at),
+            endTime: referenceEndDate,
+            shape: 'ease-out'
+        });
+        this.lastSubscriptionStart = startDate;
+        const endDate = new Date(startDate);
+
+        if (createValid) {
+            // End date should be in the future
+
+            if (isMonthly) {
+                endDate.setFullYear(new Date().getFullYear());
+                endDate.setMonth(new Date().getMonth());
+                if (endDate < new Date()) {
+                    endDate.setMonth(endDate.getMonth() + 1);
+                }
+            } else {
+                endDate.setFullYear(new Date().getFullYear());
+                if (endDate < new Date()) {
+                    endDate.setFullYear(endDate.getFullYear() + 1);
+                }
+            }
+        } else {
+            // End date should be in the past
+            if (isMonthly) {
+                // What is the month difference between startDate and now? Pick a random number in between
+                const monthDiff = (new Date().getFullYear() - startDate.getFullYear()) * 12 + (new Date().getMonth() - startDate.getMonth());
+                if (monthDiff === 0) {
+                    // Not possible to create an invalid subscription here
+                    return;
+                }
+
+                const randomMonthDiff = faker.datatype.number({min: 1, max: monthDiff});
+                endDate.setMonth(startDate.getMonth() + randomMonthDiff);
+            } else {
+                // What is the year difference between startDate and now? Pick a random number in between
+                const yearDiff = new Date().getFullYear() - startDate.getFullYear();
+
+                if (yearDiff === 0) {
+                    // Not possible to create an invalid subscription here
+                    return;
+                }
+                const randomYearDiff = faker.datatype.number({min: 1, max: yearDiff});
+
+                endDate.setFullYear(startDate.getFullYear() + randomYearDiff);
+            }
+        }
+
+        // Simulate some different statusses here:
+        // - active, not ending (cancel_at_period_end  = false)
+        // - active, ending (cancel_at_period_end = true)
+        // - canceled -> current_period_end can be in both past or present, cancel_at_period_end can be both true or false
+        // - incomplete_expired -> user tried to pay but 3D secure expired
+        // - incomplete -> waiting on 3D secure
+        // - trialing -> need to set trial_end_at to a date in the future
+        // - past_due -> last paymet failed, but subscription still active until tried a couple of times
+        // - unpaid -> all payment attempts failed - but keep the subscription active (special setting in Stripe)
+
+        const validStatusses = new Array(10).fill({
+            status: 'active',
+            cancel_at_period_end: false
+        });
+
+        // Trialing only possible when the startDate > 1 month ago
+        const monthAgo = new Date();
+
+        if (!isMonthly) {
+            // Year ago
+            monthAgo.setFullYear(monthAgo.getFullYear() - 1);
+        } else {
+            // Month ago
+            monthAgo.setMonth(monthAgo.getMonth() - 1);
+        }
+
+        if (startDate > monthAgo) {
+            validStatusses.push({
+                status: 'trialing',
+                cancel_at_period_end: false,
+                trial_end_at: dateToDatabaseString(endDate),
+                trial_start_at: dateToDatabaseString(startDate)
+            });
+        }
+
+        // Past due only possible if startDate < 1 month ago
+        if (startDate < monthAgo) {
+            validStatusses.push({
+                status: 'past_due',
+                cancel_at_period_end: false
+            });
+            validStatusses.push({
+                status: 'unpaid',
+                cancel_at_period_end: false
+            });
+        }
+
+        const invalidStatusses = [
+            {
+                status: 'canceled',
+                cancel_at_period_end: true
+            },
+            {
+                status: 'canceled',
+                cancel_at_period_end: false
+            },
+            {
+                status: 'incomplete_expired',
+                cancel_at_period_end: false
+            },
+            {
+                status: 'incomplete',
+                cancel_at_period_end: false
+            }
+        ];
+
+        const status = createValid ? faker.helpers.arrayElement(validStatusses) : faker.helpers.arrayElement(invalidStatusses);
+
+        return {
+            id: this.fastFakeObjectId(),
+            customer_id: customer.customer_id,
+            subscription_id: `sub_${faker.random.alphaNumeric(14)}`,
+            stripe_price_id: stripePrice.stripe_price_id,
+            start_date: dateToDatabaseString(startDate),
+            created_at: dateToDatabaseString(startDate),
+            created_by: 'unused',
+            mrr,
+            plan_id: stripeProduct.stripe_product_id,
+            plan_nickname: `${ghostProduct.name} - ${stripePrice.nickname}`,
+            plan_interval: stripePrice.interval,
+            plan_amount: stripePrice.amount,
+            plan_currency: stripePrice.currency,
+
+            // Defaults
+            status: 'active',
+            cancel_at_period_end: false,
+            current_period_end: dateToDatabaseString(endDate),
+
+            // Override
+            ...status
+        };
+    }
+}
+
+module.exports = MembersStripeCustomersSubscriptionsImporter;

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;