ghost 5.115.1 → 5.116.0

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

@@ -0,0 +1,212 @@
+const TableImporter = require('./TableImporter');
+const {faker} = require('@faker-js/faker');
+const generateEvents = require('../utils/event-generator');
+const dateToDatabaseString = require('../utils/database-date');
+const debug = require('@tryghost/debug')('EmailRecipientsImporter');
+
+const emailStatus = {
+    delivered: Symbol(),
+    opened: Symbol(),
+    failed: Symbol(),
+    none: Symbol()
+};
+
+function findFirstHigherIndex(arr, target) {
+    let start = 0;
+    let end = arr.length - 1;
+    let result = -1;
+
+    while (start <= end) {
+        let mid = Math.floor((start + end) / 2);
+
+        if (arr[mid] >= target) {
+            result = mid;
+            end = mid - 1; // Continue searching in the left half
+        } else {
+            start = mid + 1; // Continue searching in the right half
+        }
+    }
+
+    return result; // Return -1 if no element is higher than target
+}
+
+class EmailRecipientsImporter extends TableImporter {
+    static table = 'email_recipients';
+    static dependencies = ['emails', 'email_batches', 'members', 'members_subscribe_events'];
+
+    constructor(knex, transaction) {
+        super(EmailRecipientsImporter.table, knex, transaction);
+    }
+
+    async import(quantity) {
+        if (quantity === 0) {
+            return;
+        }
+
+        const now = Date.now();
+        const emails = await this.transaction
+            .select(
+                'id',
+                'newsletter_id',
+                'email_count',
+                'delivered_count',
+                'opened_count',
+                'failed_count')
+            .from('emails');
+        this.emails = new Map();
+
+        for (const email of emails) {
+            this.emails.set(email.id, email);
+        }
+
+        this.emailBatches = await this.transaction.select('id', 'email_id', 'updated_at').from('email_batches').orderBy('email_id');
+        const members = await this.transaction.select('id', 'uuid', 'email', 'name').from('members');
+        this.membersSubscribeEvents = await this.transaction.select('id', 'newsletter_id', 'created_at', 'member_id').from('members_subscribe_events').orderBy('created_at', 'asc'); // Order required for better performance in setReferencedModel
+
+        // Create a map for fast lookups
+        this.members = new Map();
+        for (const member of members) {
+            this.members.set(member.id, member);
+        }
+
+        // Save indexes of each batch for performance (remarkable faster than doing findIndex on each generate call)
+        let lastEmailId = null;
+        let lastIndex = 0;
+        for (const batch of this.emailBatches) {
+            if (batch.email_id !== lastEmailId) {
+                lastIndex = 0;
+                lastEmailId = batch.email_id;
+            }
+            batch.index = lastIndex;
+            lastIndex += 1;
+        }
+
+        // Now reorder by email id
+
+        debug (`Prepared data for ${this.name} in ${Date.now() - now}ms`);
+
+        // We use the same event curve for all emails to speed up the generation
+        // Spread over 14 days
+        this.eventStartTimeUsed = new Date();
+        const endTime = new Date(this.eventStartTimeUsed.getTime() + 1000 * 60 * 60 * 24 * 14);
+        this.eventCurve = generateEvents({
+            shape: 'ease-out',
+            trend: 'negative',
+            total: 1000,
+            startTime: this.eventStartTimeUsed,
+            endTime
+        });
+
+        this.membersSubscribeEventsByNewsletterId = new Map();
+        this.membersSubscribeEventsCreatedAtsByNewsletterId = new Map();
+        for (const memberSubscribeEvent of this.membersSubscribeEvents) {
+            if (!this.membersSubscribeEventsByNewsletterId.has(memberSubscribeEvent.newsletter_id)) {
+                this.membersSubscribeEventsByNewsletterId.set(memberSubscribeEvent.newsletter_id, []);
+            }
+            this.membersSubscribeEventsByNewsletterId.get(memberSubscribeEvent.newsletter_id).push(memberSubscribeEvent);
+
+            if (!this.membersSubscribeEventsCreatedAtsByNewsletterId.has(memberSubscribeEvent.newsletter_id)) {
+                this.membersSubscribeEventsCreatedAtsByNewsletterId.set(memberSubscribeEvent.newsletter_id, []);
+            }
+
+            if (!(memberSubscribeEvent.created_at instanceof Date)) {
+                // SQLite fix
+                memberSubscribeEvent.created_at = new Date(memberSubscribeEvent.created_at);
+            }
+            this.membersSubscribeEventsCreatedAtsByNewsletterId.get(memberSubscribeEvent.newsletter_id).push(memberSubscribeEvent.created_at.getTime());
+        }
+
+        await this.importForEach(this.emailBatches, quantity ? quantity / emails.length : 1000);
+    }
+
+    setReferencedModel(model) {
+        this.batch = model;
+        this.model = this.emails.get(this.batch.email_id);
+        this.batchIndex = this.batch.index;
+
+        // Shallow clone members list so we can shuffle and modify it
+        const earliestOpenTime = new Date(this.batch.updated_at);
+        const latestOpenTime = new Date(this.batch.updated_at);
+        latestOpenTime.setDate(latestOpenTime.getDate() + 14);
+
+        // Get all members that were subscribed to this newsletter BEFORE the batch was sent
+        // We use binary search to speed up it up
+        const lastIndex = findFirstHigherIndex(this.membersSubscribeEventsCreatedAtsByNewsletterId.get(this.model.newsletter_id), earliestOpenTime);
+
+        this.membersList = this.membersSubscribeEventsByNewsletterId.get(this.model.newsletter_id).slice(0, Math.max(0, lastIndex - 1))
+            .slice(this.batchIndex * 1000, (this.batchIndex + 1) * 1000)
+            .map(memberSubscribeEvent => memberSubscribeEvent.member_id);
+
+        this.events = faker.helpers.shuffle(this.eventCurve.slice(0, this.membersList.length));
+        this.eventIndex = 0;
+
+        this.emailMeta = {
+            // delievered and not opened
+            deliveredCount: this.model.delivered_count - this.model.opened_count,
+            openedCount: this.model.opened_count,
+            failedCount: this.model.failed_count
+        };
+
+        let offset = this.batchIndex * 1000;
+
+        // We always first create the failures, then the opened, then the delivered, so we need to remove those from the meta so we don't generate them multiple times
+        this.emailMeta = {
+            failedCount: Math.max(0, this.emailMeta.failedCount - offset),
+            openedCount: Math.max(0, this.emailMeta.openedCount - Math.max(0, offset - this.emailMeta.failedCount)),
+            deliveredCount: Math.max(0, this.emailMeta.deliveredCount - Math.max(0, offset - this.emailMeta.failedCount - this.emailMeta.openedCount))
+        };
+    }
+
+    generate() {
+        let timestamp = this.events.pop();
+        if (!timestamp) {
+            return;
+        }
+
+        // The events are generated for a different time, so we need to move them to the batch time
+        timestamp = new Date(timestamp.getTime() - this.eventStartTimeUsed.getTime() + new Date(this.batch.updated_at).getTime());
+
+        if (timestamp > new Date()) {
+            timestamp = new Date();
+        }
+
+        const memberId = this.membersList[this.events.length];
+        const member = this.members.get(memberId);
+
+        let status = emailStatus.none;
+        if (this.emailMeta.failedCount > 0) {
+            status = emailStatus.failed;
+            this.emailMeta.failedCount -= 1;
+        } else if (this.emailMeta.openedCount > 0) {
+            status = emailStatus.opened;
+            this.emailMeta.openedCount -= 1;
+        } else if (this.emailMeta.deliveredCount > 0) {
+            status = emailStatus.delivered;
+            this.emailMeta.deliveredCount -= 1;
+        }
+
+        let deliveredTime;
+        if (status === emailStatus.opened) {
+            const startDate = this.batch.updated_at;
+            const endDate = timestamp;
+            deliveredTime = faker.date.between(startDate, endDate);
+        }
+
+        return {
+            // Using sorted ids are much much faster (35% as far as my testing goes) for huge imports
+            id: this.fastFakeObjectId(),
+            email_id: this.model.id,
+            batch_id: this.batch.id,
+            member_id: member.id,
+            processed_at: dateToDatabaseString(this.batch.updated_at),
+            delivered_at: status === emailStatus.opened ? dateToDatabaseString(deliveredTime) : status === emailStatus.delivered ? dateToDatabaseString(timestamp) : null,
+            opened_at: status === emailStatus.opened ? dateToDatabaseString(timestamp) : null,
+            failed_at: status === emailStatus.failed ? dateToDatabaseString(timestamp) : null,
+            member_uuid: member.uuid,
+            member_email: member.email,
+            member_name: member.name
+        };
+    }
+}
+
+module.exports = EmailRecipientsImporter;

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

@@ -0,0 +1,99 @@
+const TableImporter = require('./TableImporter');
+const {faker} = require('@faker-js/faker');
+const generateEvents = require('../utils/event-generator');
+const {luck} = require('../utils/random');
+const dateToDatabaseString = require('../utils/database-date');
+
+class EmailsImporter extends TableImporter {
+    static table = 'emails';
+    static dependencies = ['posts', 'newsletters', 'members_subscribe_events'];
+
+    constructor(knex, transaction) {
+        super(EmailsImporter.table, knex, transaction);
+    }
+
+    async import(quantity) {
+        if (quantity === 0) {
+            return;
+        }
+
+        const posts = await this.transaction.select('id', 'title', 'published_at').from('posts').where('type', 'post').where('status', 'published').orderBy('published_at', 'desc');
+        this.newsletters = await this.transaction.select('id').from('newsletters').orderBy('sort_order');
+        this.membersSubscribeEvents = await this.transaction.select('id', 'newsletter_id', 'created_at').from('members_subscribe_events');
+
+        // Only generate emails for last 25% of posts, and only generate emails for 50% of those
+        await this.importForEach(posts.slice(0, Math.ceil(posts.length / 4)), quantity ? quantity / posts.length : 0.5);
+    }
+
+    generate() {
+        const id = this.fastFakeObjectId();
+
+        let newsletter;
+        if (this.newsletters.length === 0) {
+            return null;
+        } else if (this.newsletters.length === 1) {
+            newsletter = this.newsletters[0];
+        } else {
+            // Choose between first two newsletters
+            newsletter = luck(90)
+                // Regular premium
+                ? this.newsletters[0]
+                // Occasional freebie
+                : this.newsletters[1];
+        }
+
+        const timestamp = luck(60)
+            ? new Date(this.model.published_at)
+            : generateEvents({
+                shape: 'ease-out',
+                trend: 'negative',
+                total: 1,
+                startTime: new Date(this.model.published_at),
+                endTime: new Date()
+            })[0];
+
+        const recipientCount = this.membersSubscribeEvents
+            .filter(entry => entry.newsletter_id === newsletter.id)
+            .filter(entry => new Date(entry.created_at) < timestamp).length;
+        const deliveredCount = Math.ceil(recipientCount * faker.datatype.float({
+            max: 1,
+            min: 0.9,
+            precision: 0.001
+        }));
+        const openedCount = Math.ceil(deliveredCount * faker.datatype.float({
+            max: 0.95,
+            min: 0.6,
+            precision: 0.001
+        }));
+        const failedCount = Math.floor((recipientCount - deliveredCount) * faker.datatype.float({
+            max: 0.05,
+            min: 0,
+            precision: 0.001
+        }));
+
+        return {
+            id,
+            uuid: faker.datatype.uuid(),
+            post_id: this.model.id,
+            status: 'submitted',
+            recipient_filter: '', // TODO: Add recipient filter?
+            email_count: recipientCount,
+            delivered_count: deliveredCount,
+            opened_count: openedCount,
+            failed_count: failedCount,
+            subject: this.model.title,
+            source_type: 'html',
+            track_opens: true,
+            track_clicks: true,
+            feedback_enabled: true,
+            submitted_at: dateToDatabaseString(timestamp),
+            newsletter_id: newsletter.id,
+            created_at: dateToDatabaseString(timestamp),
+            created_by: 'unused',
+            updated_at: dateToDatabaseString(timestamp),
+            updated_by: 'unused'
+        };
+    }
+}
+
+module.exports = EmailsImporter;

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

@@ -0,0 +1,41 @@
+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 LabelsImporter extends TableImporter {
+    static table = 'labels';
+    static dependencies = [];
+    defaultQuantity = 10;
+
+    constructor(knex, transaction) {
+        super(LabelsImporter.table, knex, transaction);
+        this.generatedNames = new Set();
+    }
+
+    generateName() {
+        let name;
+        do {
+            name = `${faker.color.human()} ${faker.name.jobType()}`;
+            name = `${name[0].toUpperCase()}${name.slice(1)}`;
+        } while (this.generatedNames.has(name));
+        this.generatedNames.add(name);
+        return name;
+    }
+
+    generate() {
+        const name = this.generateName();
+        return {
+            id: this.fastFakeObjectId(),
+            name: name,
+            slug: `${slugify(name)}`,
+            created_at: dateToDatabaseString(blogStartDate),
+            created_by: '1',
+            updated_at: dateToDatabaseString(blogStartDate),
+            updated_by: '1'
+        };
+    }
+}
+
+module.exports = LabelsImporter;

package/core/server/data/seeders/importers/MembersClickEventsImporter.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 MembersClickEventsImporter extends TableImporter {
+    static table = 'members_click_events';
+    static dependencies = ['email_recipients', 'redirects', 'emails'];
+
+    constructor(knex, transaction) {
+        super(MembersClickEventsImporter.table, knex, transaction);
+    }
+
+    async import(quantity) {
+        const emailRecipients = await this.transaction.select('id', 'opened_at', 'email_id', 'member_id').from('email_recipients').whereNotNull('opened_at');
+        const redirects = await this.transaction.select('id', 'post_id').from('redirects');
+        const emails = await this.transaction.select('id', 'post_id').from('emails');
+        this.quantity = quantity ? quantity / emailRecipients.length : 2;
+
+        // Create maps for faster lookups (this does make a difference for large data generation)
+        this.emails = new Map();
+        for (const email of emails) {
+            this.emails.set(email.id, email);
+        }
+
+        this.redirects = new Map();
+        for (const redirect of redirects) {
+            if (!this.redirects.has(redirect.post_id)) {
+                this.redirects.set(redirect.post_id, []);
+            }
+            this.redirects.get(redirect.post_id).push(redirect);
+        }
+
+        await this.importForEach(emailRecipients, this.quantity);
+    }
+
+    setReferencedModel(model) {
+        this.model = model;
+        this.amount = model.opened_at === null ? 0 : luck(40) ? faker.datatype.number({
+            min: 0,
+            max: this.quantity
+        }) : 0;
+        const email = this.emails.get(model.email_id);
+        this.redirectList = this.redirects.get(email.post_id) ?? [];
+    }
+
+    generate() {
+        if (this.amount <= 0 || this.redirectList.length === 0 || !this.model.opened_at) {
+            return;
+        }
+        this.amount -= 1;
+
+        const openedAt = new Date(this.model.opened_at);
+        const laterOn = new Date(openedAt.getTime() + 1000 * 60 * 15);
+        const clickTime = faker.date.between(openedAt.getTime(), laterOn.getTime()); //added getTime here because it threw random errors
+
+        return {
+            id: this.fastFakeObjectId(),
+            member_id: this.model.member_id,
+            redirect_id: this.redirectList[this.redirectList.length === 1 ? 0 : (faker.datatype.number({
+                min: 0,
+                max: this.redirectList.length - 1
+            }))].id,
+            created_at: dateToDatabaseString(clickTime)
+        };
+    }
+}
+
+module.exports = MembersClickEventsImporter;

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

@@ -0,0 +1,103 @@
+const TableImporter = require('./TableImporter');
+const {faker} = require('@faker-js/faker');
+const {luck} = require('../utils/random');
+const dateToDatabaseString = require('../utils/database-date');
+
+class MembersCreatedEventsImporter extends TableImporter {
+    static table = 'members_created_events';
+    static dependencies = ['members', 'posts', 'mentions'];
+
+    constructor(knex, transaction) {
+        super(MembersCreatedEventsImporter.table, knex, transaction);
+    }
+
+    async import(quantity) {
+        const members = await this.transaction.select('id', 'created_at').from('members');
+        this.posts = await this.transaction.select('id', 'published_at', 'visibility', 'type', 'slug').from('posts').orderBy('published_at', 'desc');
+        this.incomingRecommendations = await this.transaction.select('id', 'source', 'created_at').from('mentions');
+
+        await this.importForEach(members, quantity ? quantity / members.length : 1);
+    }
+
+    generateSource() {
+        let source = 'member';
+        if (luck(10)) {
+            source = 'admin';
+        } else if (luck(5)) {
+            source = 'api';
+        } else if (luck(5)) { // eslint-disable-line no-dupe-else-if
+            source = 'import';
+        }
+        return source;
+    }
+
+    generate() {
+        const source = this.generateSource();
+
+        // 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 (source === 'member' && 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 (source === 'member' && 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'])
+                };
+            }
+        }
+
+        if (source === 'import') {
+            referrer.referrer_source = 'Imported';
+            referrer.referrer_medium = 'Member Importer';
+        } else if (source === 'admin') {
+            referrer.referrer_source = 'Created manually';
+            referrer.referrer_medium = 'Ghost Admin';
+        } else if (source === 'api') {
+            referrer.referrer_source = 'Created via API';
+            referrer.referrer_medium = 'Admin API';
+        }
+
+        return {
+            id: this.fastFakeObjectId(),
+            created_at: dateToDatabaseString(this.model.created_at),
+            member_id: this.model.id,
+            source,
+            ...attribution,
+            ...referrer
+        };
+    }
+}
+
+module.exports = MembersCreatedEventsImporter;

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

@@ -0,0 +1,45 @@
+const TableImporter = require('./TableImporter');
+const {faker} = require('@faker-js/faker');
+const {luck} = require('../utils/random');
+const dateToDatabaseString = require('../utils/database-date');
+
+class MembersFeedbackImporter extends TableImporter {
+    static table = 'members_feedback';
+    static dependencies = ['emails', 'email_recipients'];
+
+    constructor(knex, transaction, {emails}) {
+        super(MembersFeedbackImporter.table, knex, transaction);
+        this.emails = emails;
+    }
+
+    async import(quantity) {
+        const emailRecipients = await this.transaction.select('id', 'opened_at', 'email_id', 'member_id').from('email_recipients');
+        this.emails = await this.transaction.select('id', 'post_id').from('emails');
+
+        await this.importForEach(emailRecipients, quantity ? quantity / emailRecipients.length : 1);
+    }
+
+    generate() {
+        // ~10% of people who opened the email will leave feedback
+        if (!this.model.opened_at || luck(90)) {
+            return null;
+        }
+
+        const openedAt = new Date(this.model.opened_at);
+        const laterOn = new Date(this.model.opened_at);
+        laterOn.setMinutes(laterOn.getMinutes() + 60);
+        const feedbackTime = faker.date.between(openedAt, laterOn);
+
+        const postId = this.emails.find(email => email.id === this.model.email_id).post_id;
+        return {
+            id: this.fastFakeObjectId(),
+            score: luck(70) ? 1 : 0,
+            member_id: this.model.member_id,
+            post_id: postId,
+            created_at: dateToDatabaseString(feedbackTime),
+            updated_at: dateToDatabaseString(feedbackTime)
+        };
+    }
+}
+
+module.exports = MembersFeedbackImporter;

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

@@ -0,0 +1,111 @@
+const TableImporter = require('./TableImporter');
+const {faker} = require('@faker-js/faker');
+const {faker: americanFaker} = require('@faker-js/faker/locale/en_US');
+const {blogStartDate: startTime} = require('../utils/blog-info');
+const generateEvents = require('../utils/event-generator');
+const {luck} = require('../utils/random');
+const dateToDatabaseString = require('../utils/database-date');
+const debug = require('@tryghost/debug')('MembersImporter');
+
+class MembersImporter extends TableImporter {
+    static table = 'members';
+    static dependencies = [];
+    defaultQuantity = faker.datatype.number({
+        min: 7000,
+        max: 8000
+    });
+
+    constructor(knex, transaction) {
+        super(MembersImporter.table, knex, transaction);
+    }
+
+    async import(quantity = this.defaultQuantity) {
+        const generateNow = Date.now();
+
+        this.timestamps = generateEvents({
+            shape: 'ease-in',
+            trend: 'positive',
+            total: quantity,
+            startTime,
+            endTime: new Date()
+        }).sort();
+        debug(`${this.name} generated ${this.timestamps.length} timestamps in ${Date.now() - generateNow}ms`);
+
+        await super.import(quantity);
+    }
+
+    /**
+     * Add open rate data to members table
+     */
+    async finalise() {
+        const emailRecipients = await this.transaction.select('id', 'member_id', 'opened_at').from('email_recipients');
+
+        const memberData = {};
+        for (const emailRecipient of emailRecipients) {
+            if (!(emailRecipient.member_id in memberData)) {
+                memberData[emailRecipient.member_id] = {
+                    emailCount: 1,
+                    openedCount: emailRecipient.opened_at ? 1 : 0
+                };
+            } else {
+                memberData[emailRecipient.member_id].emailCount += 1;
+                if (emailRecipient.opened_at) {
+                    memberData[emailRecipient.member_id].openedCount += 1;
+                }
+            }
+        }
+
+        for (const [memberId, emailInfo] of Object.entries(memberData)) {
+            const openRate = Math.round(100 * (emailInfo.openedCount / emailInfo.emailCount));
+            await this.transaction('members').update({
+                email_count: emailInfo.emailCount,
+                email_opened_count: emailInfo.openedCount,
+                email_open_rate: emailInfo.emailCount >= 5 ? openRate : null
+            }).where({id: memberId});
+        }
+    }
+
+    generate() {
+        const id = this.fastFakeObjectId();
+        // Use name from American locale to reflect an English-speaking audience
+        const name = `${americanFaker.name.firstName()} ${americanFaker.name.lastName()}`;
+        const timestamp = this.timestamps.pop();
+
+        return {
+            id,
+            uuid: faker.datatype.uuid(),
+            transient_id: faker.datatype.uuid(),
+            email: `${name.replace(' ', '.').replace(/[^a-zA-Z0-9]/g, '').toLowerCase()}${faker.datatype.number({min: 0, max: 999999})}@example.com`,
+            status: luck(5) ? 'comped' : luck(15) ? 'paid' : 'free',
+            name: name,
+            expertise: luck(30) ? faker.name.jobTitle() : undefined,
+            geolocation: JSON.stringify({
+                organization_name: faker.company.name(),
+                region: faker.address.state(),
+                accuracy: 50,
+                asn: parseInt(faker.random.numeric(4)),
+                organization: `${faker.random.alpha({count: 2, casing: 'upper'})}${faker.random.numeric(4)} ${faker.company.name()}`,
+                timezone: faker.address.timeZone(),
+                longitude: faker.address.longitude(),
+                country_code3: faker.address.countryCode('alpha-3'),
+                area_code: '0',
+                ip: faker.internet.ipv4(),
+                city: faker.address.cityName(),
+                country: faker.address.country(),
+                continent_code: 'EU',
+                country_code: faker.address.countryCode('alpha-2'),
+                latitude: faker.address.latitude()
+            }),
+            email_count: 0, // Depends on number of emails sent since created_at, the newsletter they're a part of and subscription status
+            email_opened_count: 0,
+            email_open_rate: null,
+            // 40% of users logged in within a week, 60% sometime since registering
+            last_seen_at: luck(40) ? dateToDatabaseString(faker.date.recent(7)) : dateToDatabaseString(faker.date.between(timestamp, new Date())),
+            created_at: dateToDatabaseString(timestamp),
+            created_by: id,
+            updated_at: dateToDatabaseString(timestamp)
+        };
+    }
+}
+
+module.exports = MembersImporter;