ghost 5.115.0 → 5.116.0

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;

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

@@ -0,0 +1,32 @@
+const TableImporter = require('./TableImporter');
+const {faker} = require('@faker-js/faker');
+const {luck} = require('../utils/random');
+
+class RecommendationSubscribeEventsImporter extends TableImporter {
+    static table = 'recommendation_subscribe_events';
+    static dependencies = ['recommendations', 'members'];
+
+    constructor(knex, transaction) {
+        super(RecommendationSubscribeEventsImporter.table, knex, transaction);
+    }
+
+    async import(quantity) {
+        const recommendations = await this.transaction.select('id', 'created_at').from('recommendations').where('one_click_subscribe', true);
+        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: 50}));
+    }
+
+    generate() {
+        // Not unique
+        const member = luck(1) ? 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 = RecommendationSubscribeEventsImporter;

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

@@ -0,0 +1,34 @@
+const TableImporter = require('./TableImporter');
+const {faker} = require('@faker-js/faker');
+
+function capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+class RecommendationsImporter extends TableImporter {
+    static table = 'recommendations';
+    static dependencies = [];
+    defaultQuantity = 15;
+
+    constructor(knex, transaction) {
+        super(RecommendationsImporter.table, knex, transaction);
+    }
+
+    generate() {
+        const id = this.fastFakeObjectId();
+        return {
+            id,
+            url: faker.internet.url(),
+            title: capitalize(`${faker.word.adjective()} ${faker.word.noun()}`),
+            excerpt: faker.lorem.sentence(),
+            featured_image: `https://api.dicebear.com/5.x/shapes/png?size=256&seed=${id}`,
+            favicon: `https://api.dicebear.com/5.x/shapes/png?size=32&seed=${id}`,
+            description: faker.lorem.sentence(),
+            one_click_subscribe: faker.datatype.boolean(),
+            created_at: faker.date.past(),
+            updated_at: faker.date.past()
+        };
+    }
+}
+
+module.exports = RecommendationsImporter;

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

@@ -0,0 +1,49 @@
+const TableImporter = require('./TableImporter');
+const {faker} = require('@faker-js/faker');
+
+class RedirectsImporter extends TableImporter {
+    static table = 'redirects';
+    static dependencies = ['posts'];
+
+    constructor(knex, transaction) {
+        super(RedirectsImporter.table, knex, transaction);
+    }
+
+    async import(quantity) {
+        const posts = await this.transaction
+            .select('id', 'published_at')
+            .from('posts')
+            .where('type', 'post')
+            .andWhere('status', 'published');
+
+        this.quantity = quantity ? quantity / posts.length : 10;
+        await this.importForEach(posts, this.quantity);
+    }
+
+    setReferencedModel(model) {
+        this.model = model;
+
+        // Reset the amount for each model
+        this.amount = faker.datatype.number({
+            min: 0,
+            max: this.quantity
+        });
+    }
+
+    generate() {
+        if (this.amount <= 0) {
+            return;
+        }
+        this.amount -= 1;
+        return {
+            id: this.fastFakeObjectId(),
+            from: `/r/${faker.datatype.hexadecimal({length: 8, prefix: '', case: 'lower'})}`,
+            to: `${faker.internet.url()}/${faker.helpers.slugify(`${faker.word.adjective()} ${faker.word.noun()}`).toLowerCase()}`,
+            post_id: this.model.id,
+            created_at: this.model.published_at,
+            updated_at: this.model.published_at
+        };
+    }
+}
+
+module.exports = RedirectsImporter;

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

@@ -0,0 +1,42 @@
+const {faker} = require('@faker-js/faker');
+const TableImporter = require('./TableImporter');
+
+class RolesUsersImporter extends TableImporter {
+    static table = 'roles_users';
+    // No roles imorter, since roles are statically defined in database
+    static dependencies = ['users'];
+
+    constructor(knex, transaction) {
+        super(RolesUsersImporter.table, knex, transaction);
+    }
+
+    /**
+     * Ignore overriden quantity for 1:1 relationship
+     */
+    async import() {
+        const users = await this.transaction.select('id').from('users').whereNot('id', 1);
+        this.roles = await this.transaction.select('id', 'name').from('roles');
+
+        await this.importForEach(users, 1);
+    }
+
+    generate() {
+        const userRoles = ['Editor', 'Contributor', 'Author'];
+        const userRole = userRoles[faker.datatype.number({
+            min: 0,
+            max: userRoles.length - 1
+        })];
+        const actualRole = this.roles.find(role => role.name === userRole);
+        if (!actualRole) {
+            // No roles defined in database, don't bother creating user role
+            return;
+        }
+        return {
+            id: this.fastFakeObjectId(),
+            role_id: actualRole.id,
+            user_id: this.model.id
+        };
+    }
+}
+
+module.exports = RolesUsersImporter;

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

@@ -0,0 +1,69 @@
+const {faker} = require('@faker-js/faker');
+const TableImporter = require('./TableImporter');
+const {blogStartDate} = require('../utils/blog-info');
+
+const sixWeeksLater = new Date(blogStartDate);
+sixWeeksLater.setDate(sixWeeksLater.getDate() + (7 * 6));
+
+class StripePricesImporter extends TableImporter {
+    static table = 'stripe_prices';
+    static dependencies = ['products', 'stripe_products'];
+
+    constructor(knex, transaction) {
+        super(StripePricesImporter.table, knex, transaction);
+    }
+
+    async import() {
+        const stripeProducts = await this.transaction.select('id', 'stripe_product_id', 'product_id').from('stripe_products');
+        this.products = await this.transaction.select('id', 'monthly_price', 'yearly_price').from('products');
+
+        await this.importForEach(stripeProducts, 2);
+    }
+
+    setReferencedModel(model) {
+        this.model = model;
+        this.count = 0;
+    }
+
+    generate() {
+        const count = this.count;
+        this.count = this.count + 1;
+
+        const relatedProduct = this.products.find(product => product.id === this.model.product_id);
+
+        if (count === 1 && relatedProduct.monthly_price === null) {
+            // Only single complimentary price (yearly)
+            return null;
+        }
+
+        const billingCycle = {
+            nickname: 'Monthly',
+            interval: 'month',
+            type: 'recurring',
+            currency: 'usd',
+            amount: relatedProduct.monthly_price
+        };
+        if (count === 1) {
+            billingCycle.nickname = 'Yearly';
+            billingCycle.interval = 'year';
+            billingCycle.amount = relatedProduct.yearly_price;
+        } else if (relatedProduct.monthly_price === null) {
+            billingCycle.nickname = 'Complimentary';
+            billingCycle.interval = 'year';
+            billingCycle.amount = 0;
+        }
+
+        return Object.assign({}, {
+            id: this.fastFakeObjectId(),
+            stripe_price_id: faker.datatype.hexadecimal({
+                length: 64,
+                prefix: ''
+            }),
+            stripe_product_id: this.model.stripe_product_id,
+            active: true,
+            created_at: faker.date.between(blogStartDate, sixWeeksLater)
+        }, billingCycle);
+    }
+}
+
+module.exports = StripePricesImporter;

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

@@ -0,0 +1,34 @@
+const {faker} = require('@faker-js/faker');
+const TableImporter = require('./TableImporter');
+const {blogStartDate} = require('../utils/blog-info');
+
+const sixWeeksLater = new Date(blogStartDate);
+sixWeeksLater.setDate(sixWeeksLater.getDate() + (7 * 6));
+
+class StripeProductsImporter extends TableImporter {
+    static table = 'stripe_products';
+    static dependencies = ['products'];
+
+    constructor(knex, transaction) {
+        super(StripeProductsImporter.table, knex, transaction);
+    }
+
+    async import() {
+        const products = await this.transaction.select('id').from('products');
+        await this.importForEach(products, 1);
+    }
+
+    generate() {
+        return {
+            id: this.fastFakeObjectId(),
+            product_id: this.model.id,
+            stripe_product_id: faker.datatype.hexadecimal({
+                length: 64,
+                prefix: ''
+            }),
+            created_at: faker.date.between(blogStartDate, sixWeeksLater)
+        };
+    }
+}
+
+module.exports = StripeProductsImporter;