ghost 5.115.0 → 5.116.0

package/core/server/api/endpoints/utils/validators/input/settings.js

@@ -2,7 +2,7 @@ const _ = require('lodash');
 const {ValidationError} = require('@tryghost/errors');
 const validator = require('@tryghost/validator');
 const tpl = require('@tryghost/tpl');
-const AnnouncementBarSettings = require('@tryghost/announcement-bar-settings');
+const AnnouncementBarSettings = require('../../../../../services/announcement-bar-service/AnnouncementBarSettings');
 
 const messages = {
     invalidEmailReceived: 'Please send a valid email',

package/core/server/data/db/connection.js

@@ -6,6 +6,8 @@ const fs = require('fs');
 const logging = require('@tryghost/logging');
 const config = require('../../../shared/config');
 const errors = require('@tryghost/errors');
+
+/** @type {knex.Knex} */
 let knexInstance;
 
 // @TODO:

package/core/server/data/db/index.js

@@ -1,3 +1,4 @@
+/** @type {import('knex').Knex} */
 let connection;
 
 Object.defineProperty(exports, 'knex', {

package/core/server/data/importer/handlers/ImporterContentFileHandler.js

@@ -0,0 +1,90 @@
+const _ = require('lodash');
+const path = require('path');
+
+class ImporterContentFileHandler {
+    /** @property {'media' | 'files' | 'images'} */
+    type;
+
+    /** @property {string[]} */
+    directories;
+
+    /** @property {string[]} */
+    extensions;
+
+    /** @property {string[]} */
+    contentTypes;
+
+    /**
+     * Holds path to the destination content directory
+     * @property {string} */
+    #contentPath;
+
+    /**
+     *
+     * @param {Object} deps dependencies
+     * @param {'media' | 'files' | 'images'} deps.type type of content file
+     * @param {string[]} deps.extensions file extensions to search for
+     * @param {boolean} [deps.ignoreRootFolderFiles] whether to ignore files in the root folder
+     * @param {string[]} deps.contentTypes content types to search for
+     * @param {string[]} deps.directories directories to search for content files
+     * @param {string} deps.contentPath path to the destination content directory
+     * @param {Object} deps.storage storage adapter instance
+     * @param {object} deps.urlUtils urlUtils instance
+     */
+    constructor(deps) {
+        this.type = deps.type;
+        this.directories = deps.directories;
+        this.extensions = deps.extensions;
+        this.contentTypes = deps.contentTypes;
+        this.ignoreRootFolderFiles = deps.ignoreRootFolderFiles;
+        this.storage = deps.storage;
+        this.#contentPath = deps.contentPath;
+        this.urlUtils = deps.urlUtils;
+    }
+
+    async loadFile(files, baseDir) {
+        const baseDirRegex = baseDir ? new RegExp('^' + baseDir + '/') : new RegExp('');
+
+        const contentFilesFolderRegexes = _.map(this.storage.staticFileURLPrefix.split('/'), function (dir) {
+            return new RegExp('^' + dir + '/');
+        });
+
+        if (this.ignoreRootFolderFiles) {
+            files = _.filter(files, function (file) {
+                return file.name.indexOf('/') !== -1;
+            });
+        }
+
+        // normalize the directory structure
+        const filesContentPath = this.#contentPath;
+        files = _.map(files, function (file) {
+            const noBaseDir = file.name.replace(baseDirRegex, '');
+            let noGhostDirs = noBaseDir;
+
+            _.each(contentFilesFolderRegexes, function (regex) {
+                noGhostDirs = noGhostDirs.replace(regex, '');
+            });
+
+            file.originalPath = noBaseDir;
+            file.name = noGhostDirs;
+            file.targetDir = path.join(filesContentPath, path.dirname(noGhostDirs));
+            return file;
+        });
+
+        const self = this;
+        return Promise.all(files.map(function (contentFile) {
+            return self.storage.getUniqueFileName(contentFile, contentFile.targetDir).then(function (targetFilename) {
+                contentFile.newPath = self.urlUtils.urlJoin(
+                    '/',
+                    self.urlUtils.getSubdir(),
+                    self.storage.staticFileURLPrefix,
+                    path.relative(filesContentPath, targetFilename)
+                );
+
+                return contentFile;
+            });
+        }));
+    }
+}
+
+module.exports = ImporterContentFileHandler;

package/core/server/data/importer/import-manager.js

@@ -11,12 +11,12 @@ const debug = require('@tryghost/debug')('import-manager');
 const logging = require('@tryghost/logging');
 const errors = require('@tryghost/errors');
 const ImageHandler = require('./handlers/image');
-const ImporterContentFileHandler = require('@tryghost/importer-handler-content-files');
+const ImporterContentFileHandler = require('./handlers/ImporterContentFileHandler');
 const RevueHandler = require('./handlers/revue');
 const JSONHandler = require('./handlers/json');
 const MarkdownHandler = require('./handlers/markdown');
 const ContentFileImporter = require('./importers/ContentFileImporter');
-const RevueImporter = require('@tryghost/importer-revue');
+const RevueImporter = require('./importers/importer-revue');
 const DataImporter = require('./importers/data');
 const urlUtils = require('../../../shared/url-utils');
 const {GhostMailer} = require('../../services/mail');
@@ -225,7 +225,7 @@ class ImportManager {
 
         try {
             await extract(filePath, tmpDir);
-            
+
             // Set permissions for all extracted files
             const files = glob.sync('**/*', {cwd: tmpDir, nodir: true});
             await Promise.all(files.map(file => fs.chmod(path.join(tmpDir, file), 0o644)));

package/core/server/data/importer/importers/importer-revue.js

@@ -0,0 +1,128 @@
+const debug = require('@tryghost/debug')('importer:revue');
+const {slugify} = require('@tryghost/string');
+const papaparse = require('papaparse');
+const _ = require('lodash');
+
+const JSONToHTML = require('./json-to-html');
+
+/**
+ * Build posts out of the issue and item data
+ *
+ * @param {Object} revueData
+ * @return {Array}
+ */
+const fetchPostsFromData = (revueData) => {
+    const itemData = JSON.parse(revueData.items);
+    const issueData = papaparse.parse(revueData.issues, {
+        header: true,
+        skipEmptyLines: true,
+        transform(value, header) {
+            if (header === 'id') {
+                return parseInt(value);
+            }
+            return value;
+        }
+    });
+
+    const posts = [];
+
+    issueData.data.forEach((postMeta) => {
+        // Convert issues to posts
+        if (!postMeta.subject) {
+            return;
+        }
+
+        const revuePostID = postMeta.id;
+        let postHTML = JSONToHTML.cleanCsvHTML(postMeta.description);
+
+        const postItems = _.filter(itemData, {issue_id: revuePostID});
+        const sortedPostItems = _.sortBy(postItems, o => o.order);
+
+        if (postItems) {
+            const convertedItems = JSONToHTML.itemsToHtml(sortedPostItems);
+            postHTML = `${postHTML}${convertedItems}`;
+        }
+
+        const postDate = JSONToHTML.getPostDate(postMeta);
+        const postSlug = slugify(postMeta.subject).slice(0, 190);
+
+        posts.push({
+            comment_id: revuePostID,
+            title: postMeta.subject,
+            slug: postSlug,
+            status: JSONToHTML.getPostStatus(postMeta),
+            visibility: 'public',
+            created_at: postDate,
+            published_at: postDate,
+            updated_at: postDate,
+            html: postHTML
+        });
+    });
+
+    return posts;
+};
+
+/**
+ *
+ * @param {*} revueData
+ */
+const buildSubscriberList = (revueData) => {
+    const subscribers = [];
+
+    const subscriberData = papaparse.parse(revueData.subscribers, {
+        header: true,
+        skipEmptyLines: true
+    });
+
+    subscriberData.data.forEach((subscriber) => {
+        subscribers.push({
+            email: subscriber.email,
+            name: `${subscriber.first_name} ${subscriber.last_name}`.trim(),
+            created_at: subscriber.created_at,
+            subscribed: true
+        });
+    });
+
+    return subscribers;
+};
+
+const RevueImporter = {
+    type: 'revue',
+    preProcess: function (importData) {
+        debug('preProcess');
+        importData.preProcessedByRevue = true;
+
+        // TODO: this should really be in doImport
+        // No posts to prePprocess, return early
+        if (!importData?.revue?.revue?.issues) {
+            return importData;
+        }
+
+        // This processed data goes to the data importer
+        importData.data = {
+            meta: {version: '5.0.0'},
+            data: {}
+        };
+
+        importData.data.data.posts = this.importPosts(importData.revue.revue);
+
+        // No subscribers to import, we're done
+        if (!importData?.revue?.revue?.subscribers) {
+            return importData;
+        }
+
+        importData.data.data.revue_subscribers = this.importSubscribers(importData.revue.revue);
+
+        return importData;
+    },
+    doImport: function (importData) {
+        debug('doImport');
+
+        return importData;
+    },
+
+    importPosts: fetchPostsFromData,
+    importSubscribers: buildSubscriberList
+};
+
+module.exports = RevueImporter;

package/core/server/data/importer/importers/json-to-html.js

@@ -0,0 +1,107 @@
+const SimpleDom = require('simple-dom');
+const serializer = new SimpleDom.HTMLSerializer(SimpleDom.voidMap);
+const imageCard = require('@tryghost/kg-default-cards/lib/cards/image.js');
+const embedCard = require('@tryghost/kg-default-cards/lib/cards/embed.js');
+
+// Take the array of items for a specific post and return the converted HTML
+const itemsToHtml = (items) => {
+    let itemHTMLChunks = [];
+    items.forEach((item) => {
+        let type = item.item_type;
+
+        if (type === 'header') {
+            itemHTMLChunks.push(`<h3>${item.title}</h3>`);
+        } else if (type === 'text') {
+            itemHTMLChunks.push(item.description); // THis is basic text HTML with <p>, <b>, <a>, etc (no media)
+        } else if (type === 'image') {
+            // We have 2 values to work with here. `image` is smaller and most suitable, and `original_image_url` is the full-res that would need to be resized
+            // - item.image (https://s3.amazonaws.com/revue/items/images/019/005/542/web/anita-austvika-C-JUrfmYqcw-unsplash.jpg?1667924147)
+            // - item.original_image_url (https://s3.amazonaws.com/revue/items/images/019/005/542/original/anita-austvika-C-JUrfmYqcw-unsplash.jpg?1667924147)
+            let cardOpts = {
+                env: {dom: new SimpleDom.Document()},
+                payload: {
+                    src: item.image,
+                    caption: item.description
+                }
+            };
+
+            itemHTMLChunks.push(serializer.serialize(imageCard.render(cardOpts)));
+        } else if (type === 'link') {
+            // This could be a bookmark, or it could be a paragraph of text with a linked header, there's no way to tell
+            // The safest option here is to output an image with text under it
+            let cardOpts = {
+                env: {dom: new SimpleDom.Document()},
+                payload: {
+                    src: item.image,
+                    caption: item.title,
+                    href: item.url
+                }
+            };
+            itemHTMLChunks.push(serializer.serialize(imageCard.render(cardOpts)));
+
+            let linkHTML = `<h4><a href="${item.url}">${item.title}</a></h4>${item.description}`;
+            itemHTMLChunks.push(linkHTML);
+        } else if (type === 'tweet') {
+            // Should this be an oEmbed call? Probably.
+            itemHTMLChunks.push(`<figure class="kg-card kg-embed-card">
+                <blockquote class="twitter-tweet"><a href="${item.url}"></a></blockquote>
+                <script async src="https://platform.twitter.com/widgets.js" charset="utf-8"></script>
+                </figure>`);
+        } else if (type === 'video') {
+            const isLongYouTube = /youtube.com/.test(item.url);
+            const isShortYouTube = /youtu.be/.test(item.url);
+            const isVimeo = /vimeo.com/.test(item.url);
+            let videoHTML = '';
+            if (isLongYouTube) {
+                let videoID = item.url.replace(/https?:\/\/(?:www\.)?youtube\.com\/watch\?v=([a-zA-Z0-9_-]*)/gi, '$1');
+                videoHTML = `<iframe width="200" height="113" src="https://www.youtube.com/embed/${videoID}?feature=oembed" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>`;
+            } else if (isShortYouTube) {
+                let videoID = item.url.replace(/https?:\/\/(?:www\.)?youtu\.be\/([a-zA-Z0-9_-]*)/gi, '$1');
+                videoHTML = `<iframe width="200" height="113" src="https://www.youtube.com/embed/${videoID}?feature=oembed" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>`;
+            } else if (isVimeo) {
+                let videoID = item.url.replace(/https?:\/\/(?:www\.)?vimeo\.com\/([0-9]+)/gi, '$1');
+                videoHTML = `<iframe src="https://player.vimeo.com/video/${videoID}" width="200" height="113" frameborder="0" allow="autoplay; fullscreen; picture-in-picture" allowfullscreen></iframe>`;
+            }
+            let cardOpts = {
+                env: {dom: new SimpleDom.Document()},
+                payload: {
+                    html: videoHTML,
+                    caption: item.description
+                }
+            };
+
+            itemHTMLChunks.push(serializer.serialize(embedCard.render(cardOpts)));
+        }
+    });
+    return itemHTMLChunks.join('\n');
+};
+
+const getPostDate = (data) => {
+    const isPublished = (data.sent_at) ? true : false; // This is how we determine is a post is published or not
+    const postDate = (isPublished) ? new Date(data.sent_at) : new Date();
+
+    return postDate.toISOString();
+};
+
+const getPostStatus = (data) => {
+    const isPublished = (data.sent_at) ? true : false; // This is how we determine is a post is published or not
+    return (isPublished) ? 'published' : 'draft';
+};
+
+const cleanCsvHTML = (data) => {
+    // Blockquotes need to have some sort of wrapping elements around all contents
+    // Wrap all content in <p> tags. The HTML to Mobiledoc parse can handle duplicate <p> tags.
+    data = data.replace(/<blockquote.*?>(.*?)<\/blockquote>/gm, '<blockquote><p>$1</p></blockquote>');
+
+    // These exports have a lot of <p><br></p> that we don't want
+    data = data.replace(/<p><br><\/p>/gm, '');
+
+    return data;
+};
+
+module.exports = {
+    itemsToHtml,
+    getPostDate,
+    getPostStatus,
+    cleanCsvHTML
+};

package/core/server/data/migrations/utils/tables.js

@@ -5,8 +5,7 @@ const {createIrreversibleMigration, createNonTransactionalMigration} = require('
 /**
  * Creates a migrations which will add a new table from schema.js to the database
  * @param {string} name - table name
- * @param {Object} tableSpec - copy of table schema definition as defined in schema.js at the moment of writing the migration,
- * this parameter MUST be present, otherwise @daniellockyer will hunt you down
+ * @param {Object} tableSpec - copy of table schema definition as defined in schema.js at the moment of writing the migration, this parameter MUST be present
  *
  * @returns {Object} migration object returning config/up/down properties
  */
@@ -60,8 +59,7 @@ function dropTables(names) {
 /**
  * Creates a migration which will drop an existing table and then re-add a new table based on provided spec
  * @param {string} name - table name
- * @param {Object} tableSpec - copy of table schema definition as defined in schema.js at the moment of writing the migration,
- * this parameter MUST be present, otherwise @daniellockyer will hunt you down
+ * @param {Object} tableSpec - copy of table schema definition as defined in schema.js at the moment of writing the migration, this parameter MUST be present
  *
  * @returns {Object} migration object returning config/up/down properties
  */

package/core/server/data/seeders/DataGenerator.js

@@ -0,0 +1,288 @@
+const path = require('path');
+const fs = require('fs/promises');
+const JsonImporter = require('./utils/JsonImporter');
+const {getProcessRoot} = require('@tryghost/root-utils');
+const topologicalSort = require('./utils/topological-sort');
+const {faker} = require('@faker-js/faker');
+const {faker: americanFaker} = require('@faker-js/faker/locale/en_US');
+const crypto = require('crypto');
+const {Buffer} = require('node:buffer');
+const DatabaseInfo = require('@tryghost/database-info');
+const errors = require('@tryghost/errors');
+const importers = require('./importers').reduce((acc, val) => {
+    acc[val.table] = val;
+    return acc;
+}, {});
+
+class DataGenerator {
+    /**
+     *
+     * @param {object} options
+     * @param {Record<string,number>} [options.quantities] Pass in custom amounts for specific tables
+     * @param {number} [options.seed] If you pass the same seed, the same data will be generated if you used the same options too and if the data generation code remained the same.
+     */
+    constructor({
+        knex,
+        tables,
+        schemaTables,
+        clearDatabase = false,
+        baseDataPack = '',
+        baseUrl,
+        logger,
+        printDependencies,
+        withDefault,
+        seed,
+        quantities = {},
+        useTransaction = true
+    }) {
+        this.knex = knex;
+        this.tableList = tables || [];
+        this.schemaTables = schemaTables;
+        this.willClearData = clearDatabase;
+        this.useBaseDataPack = baseDataPack !== '';
+        this.baseDataPack = baseDataPack;
+        this.baseUrl = baseUrl;
+        this.logger = logger;
+        this.withDefault = withDefault;
+        this.printDependencies = printDependencies;
+        this.seed = seed;
+        this.quantities = quantities;
+        this.useTransaction = useTransaction;
+    }
+
+    sortTableList() {
+        // Add missing dependencies
+        for (const table of this.tableList) {
+            table.importer = importers[table.name];
+
+            // eslint-disable-next-line no-unused-vars
+            table.dependencies = Object.entries(this.schemaTables[table.name]).reduce((acc, [_col, data]) => {
+                if (data.references) {
+                    const referencedTable = data.references.split('.')[0];
+                    // The ghost_subscriptions_id property has a foreign key to the subscriptions table, but we don't use that table yet atm, so don't add it as a dependency
+                    if (!acc.includes(referencedTable) && referencedTable !== 'subscriptions') {
+                        acc.push(referencedTable);
+                    }
+                }
+                return acc;
+            }, table.importer.dependencies);
+
+            for (const dependency of table.dependencies) {
+                if (!this.tableList.find(t => t.name === dependency)) {
+                    this.tableList.push({
+                        name: dependency,
+                        importer: importers[dependency]
+                    });
+                }
+            }
+        }
+
+        // Order to ensure dependencies are created before dependants
+        this.tableList = topologicalSort(this.tableList);
+    }
+
+    /**
+     * TODO: This needs to reverse through all dependency chains to clear data from all tables
+     * @param {import('knex/types').Knex.Transaction} transaction
+     */
+    async clearData(transaction) {
+        const tables = this.tableList.map(t => t.name).reverse();
+
+        // TODO: Remove this once we import posts_meta
+        tables.unshift('posts_meta');
+
+        // Clear data from any tables that are being imported
+        for (const table of tables) {
+            this.logger.debug(`Clearing table ${table}`);
+
+            if (table === 'roles_users') {
+                await transaction(table).del().whereNot('user_id', '1');
+            } else if (table === 'users') {
+                // Avoid deleting the admin user
+                await transaction(table).del().whereNot('id', '1');
+            } else {
+                await transaction(table).truncate();
+            }
+        }
+    }
+
+    async importBasePack(transaction) {
+        let baseDataPack = this.baseDataPack;
+        if (!path.isAbsolute(this.baseDataPack)) {
+            baseDataPack = path.join(getProcessRoot(), baseDataPack);
+        }
+        let baseData = {};
+        try {
+            baseData = JSON.parse((await fs.readFile(baseDataPack)).toString());
+            this.logger.info('Read base data pack');
+        } catch (error) {
+            this.logger.error('Failed to read data pack: ', error);
+            throw error;
+        }
+
+        this.logger.info('Starting base data import');
+        const jsonImporter = new JsonImporter(transaction);
+
+        // Clear settings table
+        await transaction('settings').del();
+
+        // Hard-coded for order
+        const tablesToImport = [
+            'newsletters',
+            'posts',
+            'tags',
+            'products',
+            'benefits',
+            'products_benefits',
+            'stripe_products',
+            'stripe_prices',
+            'settings',
+            'custom_theme_settings'
+        ];
+        for (const table of tablesToImport) {
+            this.logger.info(`Importing content for table ${table} from base data pack`);
+            await jsonImporter.import({
+                name: table,
+                data: baseData[table]
+            });
+            const tableIndex = this.tableList.findIndex(t => t.name === table);
+            if (tableIndex !== -1) {
+                this.tableList.splice(tableIndex, 1);
+            }
+        }
+
+        this.logger.info('Completed base data import');
+    }
+
+    async importData() {
+        const start = Date.now();
+
+        // Add default tables if none are specified
+        if (this.tableList.length === 0) {
+            this.tableList = Object.keys(importers).map(name => ({name}));
+        } else if (this.withDefault) {
+        // Add default tables to the end of the list
+            const defaultTables = Object.keys(importers).map(name => ({name}));
+            for (const table of defaultTables) {
+                if (!this.tableList.find(t => t.name === table.name)) {
+                    this.tableList.push(table);
+                }
+            }
+        }
+
+        // Error if we have an unknown table
+        for (const table of this.tableList) {
+            if (importers[table.name] === undefined) {
+                throw new errors.IncorrectUsageError({message: `Unknown table: ${table.name}`});
+            }
+        }
+
+        this.sortTableList();
+
+        if (this.printDependencies) {
+            this.logger.info('Table dependencies:');
+            for (const table of this.tableList) {
+                this.logger.info(`\t${table.name}: ${table.dependencies.join(', ')}`);
+            }
+            process.exit(0);
+        }
+
+        if (this.useTransaction) {
+            await this.knex.transaction(async (transaction) => {
+                if (!DatabaseInfo.isSQLite(this.knex)) {
+                    await transaction.raw('SET autocommit=0;');
+                }
+
+                await this.#run(transaction);
+            }, {isolationLevel: 'read committed'});
+        } else {
+            await this.#run(this.knex);
+        }
+
+        this.logger.info(`Completed data import in ${((Date.now() - start) / 1000).toFixed(1)}s`);
+    }
+
+    async #run(transaction) {
+        if (!DatabaseInfo.isSQLite(this.knex)) {
+            if (process.env.DISABLE_FAST_IMPORT) {
+                await transaction.raw('SET FOREIGN_KEY_CHECKS=0;');
+                await transaction.raw('SET unique_checks=0;');
+            } else {
+                await transaction.raw('ALTER INSTANCE DISABLE INNODB REDO_LOG;');
+                await transaction.raw('SET FOREIGN_KEY_CHECKS=0;');
+                await transaction.raw('SET unique_checks=0;');
+                await transaction.raw('SET GLOBAL local_infile=1;');
+            }
+        }
+
+        if (this.willClearData) {
+            await this.clearData(transaction);
+        }
+
+        if (this.useBaseDataPack) {
+            await this.importBasePack(transaction);
+        }
+
+        // Set quantities for tables
+        for (const table of this.tableList) {
+            if (this.quantities[table.name] !== undefined) {
+                table.quantity = this.quantities[table.name];
+            }
+        }
+
+        const cryptoRandomBytes = crypto.randomBytes;
+
+        if (this.seed) {
+            // The probality distributions library uses crypto.randomBytes, which we can't seed, so we need to override it
+            crypto.randomBytes = (size) => {
+                const buffer = Buffer.alloc(size);
+                for (let i = 0; i < size; i++) {
+                    buffer[i] = Math.floor(faker.datatype.number({min: 0, max: 255}));
+                }
+                return buffer;
+            };
+        }
+
+        try {
+            for (const table of this.tableList) {
+                if (this.seed) {
+                    // We reset the seed for every table, so the chosen tables don't affect the data and changes in one importer don't affect the others
+                    faker.seed(this.seed);
+                    americanFaker.seed(this.seed);
+                }
+
+                // Add all common options to every importer, whether they use them or not
+                const tableImporter = new table.importer(this.knex, transaction, {
+                    baseUrl: this.baseUrl
+                });
+
+                const amount = table.quantity ?? tableImporter.defaultQuantity;
+                this.logger.info('Importing content for table', table.name, amount ? `(${amount} records)` : '');
+
+                await tableImporter.import(table.quantity ?? undefined);
+            }
+        } finally {
+            if (this.seed) {
+                // Revert crypto.randomBytes to the original function
+                crypto.randomBytes = cryptoRandomBytes;
+            }
+        }
+
+        // Finalise all tables - uses new table importer objects to avoid keeping all data in memory
+        for (const table of this.tableList) {
+            const tableImporter = new table.importer(this.knex, transaction, {
+                baseUrl: this.baseUrl
+            });
+            await tableImporter.finalise();
+        }
+
+        // Re-enable the redo log because it's a persisted global
+        // Leaving it disabled can break the database in the event of an unexpected shutdown
+        // See https://dev.mysql.com/doc/refman/8.0/en/innodb-redo-log.html#innodb-disable-redo-logging
+        if (!DatabaseInfo.isSQLite(this.knex) && !process.env.DISABLE_FAST_IMPORT) {
+            await transaction.raw('ALTER INSTANCE ENABLE INNODB REDO_LOG;');
+        }
+    }
+}
+
+module.exports = DataGenerator;