@automattic/vip 2.10.0 → 2.12.0

package/package/dist/lib/validations/is-multi-site-sql-dump.js

@@ -0,0 +1,59 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.sqlDumpLineIsMultiSite = sqlDumpLineIsMultiSite;
+exports.isMultiSiteDumpFile = isMultiSiteDumpFile;
+
+var _lineByLine = require("./line-by-line");
+
+var exit = _interopRequireWildcard(require("../cli/exit"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+/**
+ * 
+ * @format
+ */
+
+/**
+ * External dependencies
+ */
+
+/**
+ * Internal dependencies
+ */
+const SQL_CREATE_TABLE_IS_MULTISITE_REGEX = /^CREATE TABLE `?(wp_\d+_[a-z0-9_]*|wp_blogs)/i;
+const SQL_CONTAINS_MULTISITE_WP_USERS_REGEX = /\`spam\` tinyint\(2\)|\`deleted\` tinyint\(2\)/i;
+
+function sqlDumpLineIsMultiSite(line) {
+  // determine if we're on a CREATE TABLE statement line what has eg. wp_\d_options OR wp_blogs
+  // also check if we're on a line that defines the additional two columns found on the wp_users table for multisites
+  if (SQL_CREATE_TABLE_IS_MULTISITE_REGEX.test(line) || SQL_CONTAINS_MULTISITE_WP_USERS_REGEX.test(line)) {
+    return true;
+  }
+
+  return false;
+}
+
+function isMultiSiteDumpFile(fileName) {
+  return new Promise(async resolve => {
+    const readInterface = await (0, _lineByLine.getReadInterface)(fileName);
+    readInterface.on('line', line => {
+      const result = sqlDumpLineIsMultiSite(line);
+
+      if (true === result) {
+        resolve(true);
+      }
+    });
+    readInterface.on('error', () => {
+      exit.withError('An error was encountered while reading your SQL dump file.  Please verify the file contents.');
+    }); // Block until the processing completes
+
+    await new Promise(resolveBlock => readInterface.on('close', resolveBlock));
+    resolve(false);
+  });
+}

package/package/dist/lib/validations/is-multi-site.js

@@ -0,0 +1,99 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isMultiSiteInSiteMeta = isMultiSiteInSiteMeta;
+
+var _graphqlTag = _interopRequireDefault(require("graphql-tag"));
+
+var _api = _interopRequireDefault(require("../api"));
+
+var _tracker = require("../tracker");
+
+var exit = _interopRequireWildcard(require("../cli/exit"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * 
+ * @format
+ */
+
+/**
+ * External dependencies
+ */
+
+/**
+ * Internal dependencies
+ */
+const isMultiSite = new WeakMap();
+
+async function isMultiSiteInSiteMeta(appId, envId) {
+  var _res, _res$data, _res$data$app;
+
+  const track = _tracker.trackEventWithEnv.bind(null, appId, envId); // if we've already been through this, avoid doing it again within the same process
+
+
+  if (isMultiSite.has(arguments) && 'boolean' === typeof isMultiSite.get(arguments)) {
+    return Boolean(isMultiSite.get(arguments));
+  }
+
+  const api = await (0, _api.default)();
+  let res;
+
+  try {
+    res = await api.query({
+      query: (0, _graphqlTag.default)`
+				query AppMultiSiteCheck($appId: Int, $envId: Int) {
+					app(id: $appId) {
+						id
+						name
+						repo
+						environments(id: $envId) {
+							id
+							appId
+							name
+							type
+							isMultisite
+							isSubdirectoryMultisite
+						}
+					}
+				}
+			`,
+      variables: {
+        appId,
+        envId
+      }
+    });
+  } catch (GraphQlError) {
+    await track('import_sql_command_error', {
+      error_type: 'GraphQL-MultiSite-Check-failed',
+      gql_err: GraphQlError
+    });
+    exit.withError(`StartImport call failed: ${GraphQlError}`);
+  }
+
+  if (Array.isArray((_res = res) === null || _res === void 0 ? void 0 : (_res$data = _res.data) === null || _res$data === void 0 ? void 0 : (_res$data$app = _res$data.app) === null || _res$data$app === void 0 ? void 0 : _res$data$app.environments)) {
+    const environments = res.data.app.environments;
+
+    if (!environments.length) {
+      isMultiSite.set(arguments, false);
+      return false;
+    } // we asked for one result with one appId and one envId, so...
+
+
+    const thisEnv = environments[0];
+
+    if (thisEnv.isMultiSite || thisEnv.isSubdirectoryMultisite) {
+      isMultiSite.set(arguments, true);
+      return true;
+    }
+  }
+
+  return false;
+}

package/package/dist/lib/validations/line-by-line.js

@@ -0,0 +1,92 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getReadInterface = getReadInterface;
+exports.fileLineValidations = fileLineValidations;
+
+var _readline = _interopRequireDefault(require("readline"));
+
+var _fs = _interopRequireDefault(require("fs"));
+
+var _debug = _interopRequireDefault(require("debug"));
+
+var exit = _interopRequireWildcard(require("../cli/exit"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * 
+ * @format
+ */
+
+/**
+ * External dependencies
+ */
+
+/**
+ * Internal dependencies
+ */
+const debug = (0, _debug.default)('vip:validations:line-by-line');
+
+function openFile(filename, flags = 'r', mode = 666) {
+  return new Promise((resolve, reject) => {
+    _fs.default.open(filename, flags, mode, (err, fd) => {
+      if (err) {
+        return reject(err);
+      }
+
+      resolve(fd);
+    });
+  });
+}
+
+async function getReadInterface(filename) {
+  let fd;
+
+  try {
+    fd = await openFile(filename);
+  } catch (err) {
+    exit.withError('The file at the provided path is either missing or not readable. Please check the input and try again.');
+  }
+
+  return _readline.default.createInterface({
+    input: _fs.default.createReadStream('', {
+      fd
+    }),
+    output: null,
+    console: false
+  });
+}
+
+async function fileLineValidations(appId, envId, fileName, validations) {
+  const isImport = true;
+  const readInterface = await getReadInterface(fileName);
+  debug('Validations: ', validations);
+  readInterface.on('line', line => {
+    validations.map(validation => {
+      validation.execute(line);
+    });
+  });
+  readInterface.on('error', err => {
+    throw new Error(` Error validating input file: ${err.toString()}`);
+  }); // Block until the processing completes
+
+  await new Promise(resolve => readInterface.on('close', resolve));
+  readInterface.close();
+  return Promise.all(validations.map(async validation => {
+    if (validation.hasOwnProperty('postLineExecutionProcessing') && typeof validation.postLineExecutionProcessing === 'function') {
+      return validation.postLineExecutionProcessing({
+        fileName,
+        isImport,
+        appId,
+        envId
+      });
+    }
+  }));
+}

package/package/dist/lib/validations/site-type.js

@@ -0,0 +1,66 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.siteTypeValidations = void 0;
+
+var _debug = _interopRequireDefault(require("debug"));
+
+var _tracker = require("../tracker");
+
+var _isMultiSiteSqlDump = require("./is-multi-site-sql-dump");
+
+var _isMultiSite = require("./is-multi-site");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * 
+ * @format
+ */
+
+/**
+ * External dependencies
+ */
+
+/**
+ * Internal dependencies
+ */
+const debug = (0, _debug.default)('vip:vip-import-sql');
+let isMultiSiteSqlDump = false;
+const siteTypeValidations = {
+  execute: line => {
+    const lineIsMultiSite = (0, _isMultiSiteSqlDump.sqlDumpLineIsMultiSite)(line);
+
+    if (lineIsMultiSite) {
+      isMultiSiteSqlDump = true;
+    }
+  },
+  postLineExecutionProcessing: async ({
+    appId,
+    envId
+  }) => {
+    const isMultiSite = await (0, _isMultiSite.isMultiSiteInSiteMeta)(appId, envId);
+
+    const track = _tracker.trackEventWithEnv.bind(null, appId, envId);
+
+    debug(`\nAppId: ${appId} is ${isMultiSite ? 'a multisite.' : 'not a multisite'}`);
+    debug(`The SQL dump provided is ${isMultiSiteSqlDump ? 'from a multisite.' : 'not from a multisite'}\n`);
+
+    if (!isMultiSite && isMultiSiteSqlDump) {
+      await track('import_sql_command_error', {
+        error_type: 'not-multisite-with-multisite-sql-dump'
+      });
+      throw new Error('You have provided a multisite SQL dump file for import into a single site (non-multisite).');
+    }
+
+    if (isMultiSite && !isMultiSiteSqlDump) {
+      await track('import_sql_command_error', {
+        error_type: 'subsite-import-without-subsite-sql-dump'
+      });
+      throw new Error('You have requested a subsite SQL import but have not provided a subsite compatiable SQL dump.');
+    }
+  }
+};
+exports.siteTypeValidations = siteTypeValidations;

package/package/dist/lib/validations/sql.js

@@ -0,0 +1,371 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.validate = exports.staticSqlValidations = exports.getTableNames = exports.postValidation = void 0;
+
+var _chalk = _interopRequireDefault(require("chalk"));
+
+var _singleLineLog = require("single-line-log");
+
+var exit = _interopRequireWildcard(require("../cli/exit"));
+
+var _tracker = require("../tracker");
+
+var _lineByLine = require("./line-by-line");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * 
+ * @format
+ */
+
+/**
+ * External dependencies
+ */
+
+/**
+ * Internal dependencies
+ */
+let problemsFound = 0;
+let lineNum = 1;
+const tableNames = [];
+
+function formatError(message) {
+  return `${_chalk.default.red('SQL Error:')} ${message}`;
+}
+
+function formatRecommendation(message) {
+  return `${_chalk.default.yellow('Recommendation:')} ${message}`;
+}
+
+const errorCheckFormatter = check => {
+  const errors = [];
+  const infos = [];
+
+  if (check.results.length > 0) {
+    problemsFound += 1;
+    errors.push({
+      error: formatError(`${check.message} on line(s) ${check.results.join(', ')}.`),
+      recommendation: formatRecommendation(check.recommendation)
+    });
+  } else {
+    infos.push(`✅ ${check.message} was found ${check.results.length} times.`);
+  }
+
+  return {
+    errors,
+    infos
+  };
+};
+
+const requiredCheckFormatter = (check, type, isImport) => {
+  const errors = [];
+  const infos = [];
+
+  if (check.results.length > 0) {
+    infos.push(`✅ ${check.message} was found ${check.results.length} times.`);
+
+    if (type === 'createTable') {
+      if (!isImport) {
+        checkTablePrefixes(check.results, errors, infos);
+      }
+    }
+  } else {
+    problemsFound += 1;
+    errors.push({
+      error: formatError(`${check.message} was not found.`),
+      recommendation: formatRecommendation(check.recommendation)
+    });
+  }
+
+  return {
+    errors,
+    infos
+  };
+};
+
+const infoCheckFormatter = check => {
+  const infos = [];
+  check.results.forEach(item => {
+    infos.push(item);
+  });
+  return {
+    errors: [],
+    infos
+  };
+};
+
+function checkTablePrefixes(tables, errors, infos) {
+  const wpTables = [],
+        notWPTables = [],
+        wpMultisiteTables = [];
+  tables.forEach(tableName => {
+    if (tableName.match(/^wp_(\d+_)/)) {
+      wpMultisiteTables.push(tableName);
+    } else if (tableName.match(/^wp_/)) {
+      wpTables.push(tableName);
+    } else if (!tableName.match(/^wp_/)) {
+      notWPTables.push(tableName);
+    }
+  });
+
+  if (wpTables.length > 0) {
+    infos.push(` - wp_ prefix tables found: ${wpTables.length} `);
+  }
+
+  if (notWPTables.length > 0) {
+    problemsFound += 1;
+    errors.push({
+      error: formatError(`tables without wp_ prefix found: ${notWPTables.join(',')}`),
+      recommendation: formatRecommendation('Please make sure all table names are prefixed with `wp_`')
+    });
+  }
+
+  if (wpMultisiteTables.length > 0) {
+    infos.push(` - wp_n_ prefix tables found: ${wpMultisiteTables.length} `);
+  }
+}
+
+const checks = {
+  binaryLogging: {
+    matcher: /SET @@SESSION.sql_log_bin/i,
+    matchHandler: lineNumber => lineNumber,
+    outputFormatter: errorCheckFormatter,
+    results: [],
+    message: 'SET @@SESSION.sql_log_bin statement',
+    excerpt: "'SET @@SESSION.sql_log_bin' statement should not be present (case-insensitive)",
+    recommendation: 'Remove these lines'
+  },
+  trigger: {
+    // Match `CREATE (DEFINER=`root`@`host`) TRIGGER`
+    matcher: /^CREATE (\(?DEFINER=`?(\w*)(`@`)?(\w*\.*%?)*`?\)?)?(| )TRIGGER/i,
+    matchHandler: lineNumber => lineNumber,
+    outputFormatter: errorCheckFormatter,
+    results: [],
+    message: 'TRIGGER statement',
+    excerpt: "'TRIGGER' statement should not be present (case-sensitive)",
+    recommendation: 'Remove these lines'
+  },
+  dropDB: {
+    matcher: /^DROP DATABASE/i,
+    matchHandler: lineNumber => lineNumber,
+    outputFormatter: errorCheckFormatter,
+    results: [],
+    message: 'DROP DATABASE statement',
+    excerpt: "'DROP DATABASE' should not be present (case-insensitive)",
+    recommendation: 'Remove these lines'
+  },
+  useStatement: {
+    matcher: /^USE /i,
+    matchHandler: lineNumber => lineNumber,
+    outputFormatter: errorCheckFormatter,
+    results: [],
+    message: 'USE <DATABASE_NAME> statement',
+    excerpt: "'USE <DATABASE_NAME>' should not be present (case-insensitive)",
+    recommendation: 'Remove these lines'
+  },
+  alterUser: {
+    matcher: /^(ALTER USER|SET PASSWORD)/i,
+    matchHandler: lineNumber => lineNumber,
+    outputFormatter: errorCheckFormatter,
+    results: [],
+    message: 'ALTER USER statement',
+    excerpt: "'ALTER USER' should not be present (case-insensitive)",
+    recommendation: 'Remove these lines'
+  },
+  dropTable: {
+    matcher: /^DROP TABLE IF EXISTS `?([a-z0-9_]*)/i,
+    matchHandler: (lineNumber, results) => results[1],
+    outputFormatter: requiredCheckFormatter,
+    results: [],
+    message: 'DROP TABLE',
+    excerpt: "'DROP TABLE IF EXISTS' should be present (case-insensitive)",
+    recommendation: 'Check import settings to include DROP TABLE statements'
+  },
+  createTable: {
+    matcher: /^CREATE TABLE (?:IF NOT EXISTS )?`?([a-z0-9_]*)/i,
+    matchHandler: (lineNumber, results) => results[1],
+    outputFormatter: requiredCheckFormatter,
+    results: [],
+    message: 'CREATE TABLE',
+    excerpt: "'CREATE TABLE' should be present (case-insensitive)",
+    recommendation: 'Check import settings to include CREATE TABLE statements'
+  },
+  siteHomeUrl: {
+    matcher: "'(siteurl|home)',\\s?'(.*?)'",
+    matchHandler: (lineNumber, results) => results[0],
+    outputFormatter: infoCheckFormatter,
+    results: [],
+    message: 'Siteurl/home matches',
+    excerpt: 'Siteurl/home options',
+    recommendation: ''
+  },
+  engineInnoDB: {
+    matcher: / ENGINE=(?!(InnoDB))/i,
+    matchHandler: lineNumber => lineNumber,
+    outputFormatter: errorCheckFormatter,
+    results: [],
+    message: 'ENGINE != InnoDB',
+    excerpt: "'ENGINE=InnoDB' should be present (case-insensitive) for all tables",
+    recommendation: "Ensure your application works with InnoDB and update your SQL dump to include only 'ENGINE=InnoDB' engine definitions in 'CREATE TABLE' statements. " + "We suggest you search for all 'ENGINE=X' entries and replace them with 'ENGINE=InnoDB'!"
+  }
+};
+
+const postValidation = async (filename, isImport = false) => {
+  await (0, _tracker.trackEvent)('import_validate_sql_command_execute', {
+    is_import: isImport
+  });
+
+  if (!isImport) {
+    (0, _singleLineLog.stdout)(`Finished processing ${lineNum} lines.`);
+    console.log('\n');
+  }
+
+  const errorSummary = {};
+  const checkEntries = Object.entries(checks);
+  let formattedErrors = [];
+  let formattedInfos = [];
+
+  for (const [type, check] of checkEntries) {
+    const formattedOutput = check.outputFormatter(check, type, isImport);
+    formattedErrors = formattedErrors.concat(formattedOutput.errors);
+    formattedInfos = formattedInfos.concat(formattedOutput.infos);
+    errorSummary[type] = check.results.length;
+  } // eslint-disable-next-line camelcase
+
+
+  errorSummary.problems_found = problemsFound;
+  const tableNamesSet = new Set(tableNames);
+
+  if (tableNames.length > tableNamesSet.size) {
+    // there was a duplciate table
+    problemsFound++;
+
+    function findDuplicates(arr) {
+      const filtered = arr.filter(item => {
+        if (tableNamesSet.has(item)) {
+          tableNamesSet.delete(item);
+        } else {
+          return item;
+        }
+      });
+      return [...new Set(filtered)];
+    }
+
+    const duplicates = findDuplicates(tableNames);
+    const errorObject = {
+      error: formatError('Duplicate table names were found: ' + duplicates.join(',')),
+      recommendation: formatRecommendation('Ensure that there are no duplicate tables in your SQL dump')
+    };
+    formattedErrors = formattedErrors.concat(errorObject);
+  }
+
+  if (problemsFound > 0) {
+    await (0, _tracker.trackEvent)('import_validate_sql_command_failure', {
+      is_import: isImport,
+      error: errorSummary
+    });
+    const errorOutput = [`SQL validation failed due to ${_chalk.default.red(problemsFound)} error(s)`, ''];
+    formattedErrors.forEach(error => {
+      errorOutput.push(error.error);
+
+      if (error.recommendation) {
+        errorOutput.push(error.recommendation);
+      }
+
+      errorOutput.push('');
+    });
+
+    if (isImport) {
+      throw new Error(errorOutput.join('\n'));
+    }
+
+    exit.withError(errorOutput.join('\n'));
+  }
+
+  if (!isImport) {
+    console.log(formattedInfos.join('\n'));
+    console.log('');
+  }
+
+  await (0, _tracker.trackEvent)('import_validate_sql_command_success', {
+    is_import: isImport
+  });
+};
+
+exports.postValidation = postValidation;
+
+const getTableNames = () => {
+  return tableNames;
+};
+
+exports.getTableNames = getTableNames;
+
+const checkForTableName = line => {
+  const matches = line.match(/(?<=^CREATE\sTABLE\s)`?(?:(wp_[\d+_]?\w+))`?/);
+
+  if (matches) {
+    const tableName = matches[1]; // we should only have one match if we have any since we're looking at the start of the string
+
+    tableNames.push(tableName);
+  }
+};
+
+const perLineValidations = (line, runAsImport, skipChecks) => {
+  if (lineNum % 500 === 0) {
+    runAsImport ? '' : (0, _singleLineLog.stdout)(`Reading line ${lineNum} `);
+  }
+
+  checkForTableName(line);
+  const checkKeys = Object.keys(checks).filter(checkItem => !skipChecks.includes(checkItem));
+  const checkValues = checkKeys.map(checkKey => checks[checkKey]);
+  checkValues.forEach(check => {
+    const results = line.match(check.matcher);
+
+    if (results) {
+      check.results.push(check.matchHandler(lineNum, results));
+    }
+  });
+  lineNum += 1;
+};
+
+const execute = (line, isImport = true, skipChecks = ['useStatement']) => {
+  perLineValidations(line, isImport, skipChecks);
+};
+
+const postLineExecutionProcessing = async ({
+  fileName,
+  isImport
+}) => {
+  await postValidation(fileName, isImport);
+};
+
+const staticSqlValidations = {
+  execute,
+  postLineExecutionProcessing
+}; // For standalone SQL validations
+
+exports.staticSqlValidations = staticSqlValidations;
+
+const validate = async (filename, skipChecks = ['useStatement']) => {
+  const readInterface = await (0, _lineByLine.getReadInterface)(filename);
+  readInterface.on('line', line => {
+    execute(line, false, skipChecks);
+  }); // Block until the processing completes
+
+  await new Promise(resolve => readInterface.on('close', resolve));
+  readInterface.close();
+  await postLineExecutionProcessing({
+    filename,
+    isImport: false
+  });
+};
+
+exports.validate = validate;