@budibase/server 2.1.32-alpha.1 → 2.1.32-alpha.10

package/dist/utilities/rowProcessor/index.js

@@ -1,4 +1,18 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -8,111 +22,22 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-const linkRows = require("../../db/linkedRows");
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanupAttachments = exports.outputProcessing = exports.inputProcessing = exports.coerce = exports.processAutoColumn = void 0;
+const linkedRows_1 = __importDefault(require("../../db/linkedRows"));
+const constants_1 = require("../../constants");
+const index_1 = require("../index");
+const utils_1 = require("./utils");
+const constants_2 = require("../../constants");
+const backend_core_1 = require("@budibase/backend-core");
+const utils_2 = require("../../db/utils");
+const map_1 = require("./map");
 const { cloneDeep } = require("lodash/fp");
-const { FieldTypes, AutoFieldSubTypes } = require("../../constants");
-const { attachmentsRelativeURL } = require("../index");
-const { processFormulas, fixAutoColumnSubType } = require("./utils");
-const { deleteFiles } = require("../../utilities/fileSystem/utilities");
-const { ObjectStoreBuckets } = require("../../constants");
-const { isProdAppID, getProdAppID, dbExists, } = require("@budibase/backend-core/db");
-const { getAppId } = require("@budibase/backend-core/context");
-const { InternalTables } = require("../../db/utils");
+__exportStar(require("./utils"), exports);
 const BASE_AUTO_ID = 1;
-/**
- * A map of how we convert various properties in rows to each other based on the row type.
- */
-const TYPE_TRANSFORM_MAP = {
-    [FieldTypes.LINK]: {
-        "": [],
-        [null]: [],
-        [undefined]: undefined,
-        parse: link => {
-            if (Array.isArray(link) && typeof link[0] === "object") {
-                return link.map(el => (el && el._id ? el._id : el));
-            }
-            if (typeof link === "string") {
-                return [link];
-            }
-            return link;
-        },
-    },
-    [FieldTypes.OPTIONS]: {
-        "": null,
-        [null]: null,
-        [undefined]: undefined,
-    },
-    [FieldTypes.ARRAY]: {
-        "": [],
-        [null]: [],
-        [undefined]: undefined,
-    },
-    [FieldTypes.STRING]: {
-        "": "",
-        [null]: "",
-        [undefined]: undefined,
-    },
-    [FieldTypes.BARCODEQR]: {
-        "": "",
-        [null]: "",
-        [undefined]: undefined,
-    },
-    [FieldTypes.FORMULA]: {
-        "": "",
-        [null]: "",
-        [undefined]: undefined,
-    },
-    [FieldTypes.LONGFORM]: {
-        "": "",
-        [null]: "",
-        [undefined]: undefined,
-    },
-    [FieldTypes.NUMBER]: {
-        "": null,
-        [null]: null,
-        [undefined]: undefined,
-        parse: n => parseFloat(n),
-    },
-    [FieldTypes.DATETIME]: {
-        "": null,
-        [undefined]: undefined,
-        [null]: null,
-        parse: date => {
-            if (date instanceof Date) {
-                return date.toISOString();
-            }
-            return date;
-        },
-    },
-    [FieldTypes.ATTACHMENT]: {
-        "": [],
-        [null]: [],
-        [undefined]: undefined,
-    },
-    [FieldTypes.BOOLEAN]: {
-        "": null,
-        [null]: null,
-        [undefined]: undefined,
-        true: true,
-        false: false,
-    },
-    [FieldTypes.AUTO]: {
-        parse: () => undefined,
-    },
-    [FieldTypes.JSON]: {
-        parse: input => {
-            try {
-                if (input === "") {
-                    return undefined;
-                }
-                return JSON.parse(input);
-            }
-            catch (err) {
-                return input;
-            }
-        },
-    },
-};
 /**
  * Given the old state of the row and the new one after an update, this will
  * find the keys that have been removed in the updated row.
@@ -121,13 +46,13 @@ function getRemovedAttachmentKeys(oldRow, row, attachmentKey) {
     if (!oldRow[attachmentKey]) {
         return [];
     }
-    const oldKeys = oldRow[attachmentKey].map(attachment => attachment.key);
+    const oldKeys = oldRow[attachmentKey].map((attachment) => attachment.key);
     // no attachments in new row, all removed
     if (!row[attachmentKey]) {
         return oldKeys;
     }
-    const newKeys = row[attachmentKey].map(attachment => attachment.key);
-    return oldKeys.filter(key => newKeys.indexOf(key) === -1);
+    const newKeys = row[attachmentKey].map((attachment) => attachment.key);
+    return oldKeys.filter((key) => newKeys.indexOf(key) === -1);
 }
 /**
  * This will update any auto columns that are found on the row/table with the correct information based on
@@ -139,41 +64,41 @@ function getRemovedAttachmentKeys(oldRow, row, attachmentKey) {
  * @returns {{row: Object, table: Object}} The updated row and table, the table may need to be updated
  * for automatic ID purposes.
  */
-function processAutoColumn(user, table, row, opts = { reprocessing: false, noAutoRelationships: false }) {
+function processAutoColumn(user, table, row, opts) {
     let noUser = !user || !user.userId;
-    let isUserTable = table._id === InternalTables.USER_METADATA;
+    let isUserTable = table._id === utils_2.InternalTables.USER_METADATA;
     let now = new Date().toISOString();
     // if a row doesn't have a revision then it doesn't exist yet
     const creating = !row._rev;
     // check its not user table, or whether any of the processing options have been disabled
-    const shouldUpdateUserFields = !isUserTable && !opts.reprocessing && !opts.noAutoRelationships && !noUser;
+    const shouldUpdateUserFields = !isUserTable && !(opts === null || opts === void 0 ? void 0 : opts.reprocessing) && !(opts === null || opts === void 0 ? void 0 : opts.noAutoRelationships) && !noUser;
     for (let [key, schema] of Object.entries(table.schema)) {
         if (!schema.autocolumn) {
             continue;
         }
         if (!schema.subtype) {
-            schema = fixAutoColumnSubType(schema);
+            schema = (0, utils_1.fixAutoColumnSubType)(schema);
         }
         switch (schema.subtype) {
-            case AutoFieldSubTypes.CREATED_BY:
-                if (creating && shouldUpdateUserFields) {
+            case constants_1.AutoFieldSubTypes.CREATED_BY:
+                if (creating && shouldUpdateUserFields && user) {
                     row[key] = [user.userId];
                 }
                 break;
-            case AutoFieldSubTypes.CREATED_AT:
+            case constants_1.AutoFieldSubTypes.CREATED_AT:
                 if (creating) {
                     row[key] = now;
                 }
                 break;
-            case AutoFieldSubTypes.UPDATED_BY:
-                if (shouldUpdateUserFields) {
+            case constants_1.AutoFieldSubTypes.UPDATED_BY:
+                if (shouldUpdateUserFields && user) {
                     row[key] = [user.userId];
                 }
                 break;
-            case AutoFieldSubTypes.UPDATED_AT:
+            case constants_1.AutoFieldSubTypes.UPDATED_AT:
                 row[key] = now;
                 break;
-            case AutoFieldSubTypes.AUTO_ID:
+            case constants_1.AutoFieldSubTypes.AUTO_ID:
                 if (creating) {
                     schema.lastID = !schema.lastID ? BASE_AUTO_ID : schema.lastID + 1;
                     row[key] = schema.lastID;
@@ -184,28 +109,29 @@ function processAutoColumn(user, table, row, opts = { reprocessing: false, noAut
     return { table, row };
 }
 exports.processAutoColumn = processAutoColumn;
-exports.fixAutoColumnSubType = fixAutoColumnSubType;
-exports.processFormulas = processFormulas;
 /**
  * This will coerce a value to the correct types based on the type transform map
  * @param {object} row The value to coerce
  * @param {object} type The type fo coerce to
  * @returns {object} The coerced value
  */
-exports.coerce = (row, type) => {
+function coerce(row, type) {
     // no coercion specified for type, skip it
-    if (!TYPE_TRANSFORM_MAP[type]) {
+    if (!map_1.TYPE_TRANSFORM_MAP[type]) {
         return row;
     }
     // eslint-disable-next-line no-prototype-builtins
-    if (TYPE_TRANSFORM_MAP[type].hasOwnProperty(row)) {
-        return TYPE_TRANSFORM_MAP[type][row];
+    if (map_1.TYPE_TRANSFORM_MAP[type].hasOwnProperty(row)) {
+        // @ts-ignore
+        return map_1.TYPE_TRANSFORM_MAP[type][row];
     }
-    else if (TYPE_TRANSFORM_MAP[type].parse) {
-        return TYPE_TRANSFORM_MAP[type].parse(row);
+    else if (map_1.TYPE_TRANSFORM_MAP[type].parse) {
+        // @ts-ignore
+        return map_1.TYPE_TRANSFORM_MAP[type].parse(row);
     }
     return row;
-};
+}
+exports.coerce = coerce;
 /**
  * Given an input route this function will apply all the necessary pre-processing to it, such as coercion
  * of column values or adding auto-column values.
@@ -215,7 +141,7 @@ exports.coerce = (row, type) => {
  * @param {object} opts some input processing options (like disabling auto-column relationships).
  * @returns {object} the row which has been prepared to be written to the DB.
  */
-exports.inputProcessing = (user = {}, table, row, opts = { noAutoRelationships: false }) => {
+function inputProcessing(user, table, row, opts) {
     let clonedRow = cloneDeep(row);
     // need to copy the table so it can be differenced on way out
     const copiedTable = cloneDeep(table);
@@ -230,12 +156,12 @@ exports.inputProcessing = (user = {}, table, row, opts = { noAutoRelationships:
             continue;
         }
         // remove any formula values, they are to be generated
-        if (field.type === FieldTypes.FORMULA) {
+        if (field.type === constants_1.FieldTypes.FORMULA) {
             delete clonedRow[key];
         }
         // otherwise coerce what is there to correct types
         else {
-            clonedRow[key] = exports.coerce(value, field.type);
+            clonedRow[key] = coerce(value, field.type);
         }
     }
     if (!clonedRow._id || !clonedRow._rev) {
@@ -244,7 +170,8 @@ exports.inputProcessing = (user = {}, table, row, opts = { noAutoRelationships:
     }
     // handle auto columns - this returns an object like {table, row}
     return processAutoColumn(user, copiedTable, clonedRow, opts);
-};
+}
+exports.inputProcessing = inputProcessing;
 /**
  * This function enriches the input rows with anything they are supposed to contain, for example
  * link records or attachment links.
@@ -254,34 +181,37 @@ exports.inputProcessing = (user = {}, table, row, opts = { noAutoRelationships:
  * @param {object} opts used to set some options for the output, such as disabling relationship squashing.
  * @returns {object[]|object} the enriched rows will be returned.
  */
-exports.outputProcessing = (table, rows, opts = { squash: true }) => __awaiter(void 0, void 0, void 0, function* () {
-    let wasArray = true;
-    if (!(rows instanceof Array)) {
-        rows = [rows];
-        wasArray = false;
-    }
-    // attach any linked row information
-    let enriched = yield linkRows.attachFullLinkedDocs(table, rows);
-    // process formulas
-    enriched = processFormulas(table, enriched, { dynamic: true });
-    // update the attachments URL depending on hosting
-    for (let [property, column] of Object.entries(table.schema)) {
-        if (column.type === FieldTypes.ATTACHMENT) {
-            for (let row of enriched) {
-                if (row[property] == null || !Array.isArray(row[property])) {
-                    continue;
+function outputProcessing(table, rows, opts = { squash: true }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let wasArray = true;
+        if (!(rows instanceof Array)) {
+            rows = [rows];
+            wasArray = false;
+        }
+        // attach any linked row information
+        let enriched = yield linkedRows_1.default.attachFullLinkedDocs(table, rows);
+        // process formulas
+        enriched = (0, utils_1.processFormulas)(table, enriched, { dynamic: true });
+        // update the attachments URL depending on hosting
+        for (let [property, column] of Object.entries(table.schema)) {
+            if (column.type === constants_1.FieldTypes.ATTACHMENT) {
+                for (let row of enriched) {
+                    if (row[property] == null || !Array.isArray(row[property])) {
+                        continue;
+                    }
+                    row[property].forEach((attachment) => {
+                        attachment.url = (0, index_1.attachmentsRelativeURL)(attachment.key);
+                    });
                 }
-                row[property].forEach(attachment => {
-                    attachment.url = attachmentsRelativeURL(attachment.key);
-                });
             }
         }
-    }
-    if (opts.squash) {
-        enriched = yield linkRows.squashLinksToPrimaryDisplay(table, enriched);
-    }
-    return wasArray ? enriched : enriched[0];
-});
+        if (opts.squash) {
+            enriched = yield linkedRows_1.default.squashLinksToPrimaryDisplay(table, enriched);
+        }
+        return wasArray ? enriched : enriched[0];
+    });
+}
+exports.outputProcessing = outputProcessing;
 /**
  * Clean up any attachments that were attached to a row.
  * @param {object} table The table from which a row is being removed.
@@ -292,43 +222,46 @@ exports.outputProcessing = (table, rows, opts = { squash: true }) => __awaiter(v
  * deleted attachment columns.
  * @return {Promise<void>} When all attachments have been removed this will return.
  */
-exports.cleanupAttachments = (table, { row, rows, oldRow, oldTable }) => __awaiter(void 0, void 0, void 0, function* () {
-    const appId = getAppId();
-    if (!isProdAppID(appId)) {
-        const prodAppId = getProdAppID(appId);
-        // if prod exists, then don't allow deleting
-        const exists = yield dbExists(prodAppId);
-        if (exists) {
-            return;
-        }
-    }
-    let files = [];
-    function addFiles(row, key) {
-        if (row[key]) {
-            files = files.concat(row[key].map(attachment => attachment.key));
-        }
-    }
-    const schemaToUse = oldTable ? oldTable.schema : table.schema;
-    for (let [key, schema] of Object.entries(schemaToUse)) {
-        if (schema.type !== FieldTypes.ATTACHMENT) {
-            continue;
-        }
-        // old table had this column, new table doesn't - delete it
-        if (oldTable && !table.schema[key]) {
-            rows.forEach(row => addFiles(row, key));
+function cleanupAttachments(table, { row, rows, oldRow, oldTable, }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const appId = backend_core_1.context.getAppId();
+        if (!backend_core_1.db.isProdAppID(appId)) {
+            const prodAppId = backend_core_1.db.getProdAppID(appId);
+            // if prod exists, then don't allow deleting
+            const exists = yield backend_core_1.db.dbExists(prodAppId);
+            if (exists) {
+                return;
+            }
         }
-        else if (oldRow && row) {
-            // if updating, need to manage the differences
-            files = files.concat(getRemovedAttachmentKeys(oldRow, row, key));
+        let files = [];
+        function addFiles(row, key) {
+            if (row[key]) {
+                files = files.concat(row[key].map((attachment) => attachment.key));
+            }
         }
-        else if (row) {
-            addFiles(row, key);
+        const schemaToUse = oldTable ? oldTable.schema : table.schema;
+        for (let [key, schema] of Object.entries(schemaToUse)) {
+            if (schema.type !== constants_1.FieldTypes.ATTACHMENT) {
+                continue;
+            }
+            // old table had this column, new table doesn't - delete it
+            if (rows && oldTable && !table.schema[key]) {
+                rows.forEach(row => addFiles(row, key));
+            }
+            else if (oldRow && row) {
+                // if updating, need to manage the differences
+                files = files.concat(getRemovedAttachmentKeys(oldRow, row, key));
+            }
+            else if (row) {
+                addFiles(row, key);
+            }
+            else if (rows) {
+                rows.forEach(row => addFiles(row, key));
+            }
         }
-        else if (rows) {
-            rows.forEach(row => addFiles(row, key));
+        if (files.length > 0) {
+            return backend_core_1.objectStore.deleteFiles(constants_2.ObjectStoreBuckets.APPS, files);
         }
-    }
-    if (files.length > 0) {
-        return deleteFiles(ObjectStoreBuckets.APPS, files);
-    }
-});
+    });
+}
+exports.cleanupAttachments = cleanupAttachments;

package/dist/utilities/rowProcessor/map.js

@@ -0,0 +1,96 @@
+"use strict";
+const { FieldTypes } = require("../../constants");
+/**
+ * A map of how we convert various properties in rows to each other based on the row type.
+ */
+exports.TYPE_TRANSFORM_MAP = {
+    [FieldTypes.LINK]: {
+        "": [],
+        [null]: [],
+        [undefined]: undefined,
+        parse: link => {
+            if (Array.isArray(link) && typeof link[0] === "object") {
+                return link.map(el => (el && el._id ? el._id : el));
+            }
+            if (typeof link === "string") {
+                return [link];
+            }
+            return link;
+        },
+    },
+    [FieldTypes.OPTIONS]: {
+        "": null,
+        [null]: null,
+        [undefined]: undefined,
+    },
+    [FieldTypes.ARRAY]: {
+        "": [],
+        [null]: [],
+        [undefined]: undefined,
+    },
+    [FieldTypes.STRING]: {
+        "": "",
+        [null]: "",
+        [undefined]: undefined,
+    },
+    [FieldTypes.BARCODEQR]: {
+        "": "",
+        [null]: "",
+        [undefined]: undefined,
+    },
+    [FieldTypes.FORMULA]: {
+        "": "",
+        [null]: "",
+        [undefined]: undefined,
+    },
+    [FieldTypes.LONGFORM]: {
+        "": "",
+        [null]: "",
+        [undefined]: undefined,
+    },
+    [FieldTypes.NUMBER]: {
+        "": null,
+        [null]: null,
+        [undefined]: undefined,
+        parse: n => parseFloat(n),
+    },
+    [FieldTypes.DATETIME]: {
+        "": null,
+        [undefined]: undefined,
+        [null]: null,
+        parse: date => {
+            if (date instanceof Date) {
+                return date.toISOString();
+            }
+            return date;
+        },
+    },
+    [FieldTypes.ATTACHMENT]: {
+        "": [],
+        [null]: [],
+        [undefined]: undefined,
+    },
+    [FieldTypes.BOOLEAN]: {
+        "": null,
+        [null]: null,
+        [undefined]: undefined,
+        true: true,
+        false: false,
+    },
+    [FieldTypes.AUTO]: {
+        parse: () => undefined,
+    },
+    [FieldTypes.JSON]: {
+        parse: input => {
+            try {
+                if (input === "") {
+                    return undefined;
+                }
+                return JSON.parse(input);
+            }
+            catch (err) {
+                return input;
+            }
+        },
+    },
+};

package/dist/utilities/rowProcessor/utils.js

@@ -1,67 +1,75 @@
 "use strict";
-const { FieldTypes, FormulaTypes, AutoFieldDefaultNames, AutoFieldSubTypes, } = require("../../constants");
-const { processStringSync } = require("@budibase/string-templates");
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processDates = exports.processFormulas = exports.fixAutoColumnSubType = void 0;
+const constants_1 = require("../../constants");
+const string_templates_1 = require("@budibase/string-templates");
 /**
  * If the subtype has been lost for any reason this works out what
  * subtype the auto column should be.
  */
-exports.fixAutoColumnSubType = column => {
+function fixAutoColumnSubType(column) {
     if (!column.autocolumn || !column.name || column.subtype) {
         return column;
     }
     // the columns which get auto generated
-    if (column.name.endsWith(AutoFieldDefaultNames.CREATED_BY)) {
-        column.subtype = AutoFieldSubTypes.CREATED_BY;
+    if (column.name.endsWith(constants_1.AutoFieldDefaultNames.CREATED_BY)) {
+        column.subtype = constants_1.AutoFieldSubTypes.CREATED_BY;
     }
-    else if (column.name.endsWith(AutoFieldDefaultNames.UPDATED_BY)) {
-        column.subtype = AutoFieldSubTypes.UPDATED_BY;
+    else if (column.name.endsWith(constants_1.AutoFieldDefaultNames.UPDATED_BY)) {
+        column.subtype = constants_1.AutoFieldSubTypes.UPDATED_BY;
     }
-    else if (column.name.endsWith(AutoFieldDefaultNames.CREATED_AT)) {
-        column.subtype = AutoFieldSubTypes.CREATED_AT;
+    else if (column.name.endsWith(constants_1.AutoFieldDefaultNames.CREATED_AT)) {
+        column.subtype = constants_1.AutoFieldSubTypes.CREATED_AT;
     }
-    else if (column.name.endsWith(AutoFieldDefaultNames.UPDATED_AT)) {
-        column.subtype = AutoFieldSubTypes.UPDATED_AT;
+    else if (column.name.endsWith(constants_1.AutoFieldDefaultNames.UPDATED_AT)) {
+        column.subtype = constants_1.AutoFieldSubTypes.UPDATED_AT;
     }
-    else if (column.name.endsWith(AutoFieldDefaultNames.AUTO_ID)) {
-        column.subtype = AutoFieldSubTypes.AUTO_ID;
+    else if (column.name.endsWith(constants_1.AutoFieldDefaultNames.AUTO_ID)) {
+        column.subtype = constants_1.AutoFieldSubTypes.AUTO_ID;
     }
     return column;
-};
+}
+exports.fixAutoColumnSubType = fixAutoColumnSubType;
 /**
  * Looks through the rows provided and finds formulas - which it then processes.
  */
-exports.processFormulas = (table, rows, { dynamic, contextRows } = { dynamic: true }) => {
+function processFormulas(table, rows, { dynamic, contextRows } = { dynamic: true }) {
     const single = !Array.isArray(rows);
+    let rowArray;
     if (single) {
-        rows = [rows];
+        rowArray = [rows];
         contextRows = contextRows ? [contextRows] : contextRows;
     }
+    else {
+        rowArray = rows;
+    }
     for (let [column, schema] of Object.entries(table.schema)) {
-        const isStatic = schema.formulaType === FormulaTypes.STATIC;
-        if (schema.type !== FieldTypes.FORMULA ||
+        const isStatic = schema.formulaType === constants_1.FormulaTypes.STATIC;
+        if (schema.type !== constants_1.FieldTypes.FORMULA ||
             (dynamic && isStatic) ||
             (!dynamic && !isStatic)) {
             continue;
         }
         // iterate through rows and process formula
-        for (let i = 0; i < rows.length; i++) {
+        for (let i = 0; i < rowArray.length; i++) {
             if (schema.formula) {
-                let row = rows[i];
+                let row = rowArray[i];
                 let context = contextRows ? contextRows[i] : row;
-                rows[i] = Object.assign(Object.assign({}, row), { [column]: processStringSync(schema.formula, context) });
+                rowArray[i] = Object.assign(Object.assign({}, row), { [column]: (0, string_templates_1.processStringSync)(schema.formula, context) });
             }
         }
     }
-    return single ? rows[0] : rows;
-};
+    return single ? rowArray[0] : rowArray;
+}
+exports.processFormulas = processFormulas;
 /**
  * Processes any date columns and ensures that those without the ignoreTimezones
  * flag set are parsed as UTC rather than local time.
  */
-exports.processDates = (table, rows) => {
+function processDates(table, rows) {
     let datesWithTZ = [];
     for (let [column, schema] of Object.entries(table.schema)) {
-        if (schema.type !== FieldTypes.DATETIME) {
+        if (schema.type !== constants_1.FieldTypes.DATETIME) {
             continue;
         }
         if (!schema.timeOnly && !schema.ignoreTimezones) {
@@ -76,4 +84,5 @@ exports.processDates = (table, rows) => {
         }
     }
     return rows;
-};
+}
+exports.processDates = processDates;