@automattic/vip 4.1.6 → 4.1.8

package/dist/lib/validations/sql-insert-parser.js

@@ -0,0 +1,415 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOptionUrlMatchResults = exports.unquoteSqlValue = exports.parseSqlTupleRows = exports.stripSqlCommentsOutsideQuotedStrings = exports.isEscapedByBackslash = exports.parseInsertColumnListSegment = exports.parseInsertColumnList = exports.findValuesKeywordIndex = exports.findValuesKeyword = exports.normalizeSqlIdentifier = exports.checkRequiresOptionsInsertContext = exports.isWordPressOptionsTable = exports.getInsertStatementInfo = exports.readSqlIdentifier = exports.skipSqlWhitespace = exports.DEFAULT_OPTIONS_INSERT_COLUMNS = exports.INSERT_STATEMENT_MODIFIERS = void 0;
+exports.INSERT_STATEMENT_MODIFIERS = new Set([
+    'IGNORE',
+    'LOW_PRIORITY',
+    'DELAYED',
+    'HIGH_PRIORITY',
+]);
+const SQL_IDENTIFIER_REGEX = /^[a-z0-9_$]+/i;
+const SQL_IDENTIFIER_CHAR_REGEX = /^[a-z0-9_$]$/i;
+const VALUES_KEYWORD_REGEX = /^VALUES?/i;
+exports.DEFAULT_OPTIONS_INSERT_COLUMNS = [
+    'option_id',
+    'option_name',
+    'option_value',
+    'autoload',
+];
+const skipSqlWhitespace = (line, startIndex) => {
+    let index = startIndex;
+    while (index < line.length && /\s/.test(line[index])) {
+        index += 1;
+    }
+    return index;
+};
+exports.skipSqlWhitespace = skipSqlWhitespace;
+const readSqlIdentifier = (line, startIndex) => {
+    const index = (0, exports.skipSqlWhitespace)(line, startIndex);
+    if (index >= line.length) {
+        return undefined;
+    }
+    if ('`' === line[index]) {
+        let endIndex = index + 1;
+        while (endIndex < line.length) {
+            endIndex = line.indexOf('`', endIndex);
+            if (-1 === endIndex) {
+                return undefined;
+            }
+            if ('`' !== line[endIndex + 1]) {
+                return {
+                    name: line.slice(index + 1, endIndex).replaceAll('``', '`'),
+                    endIndex: endIndex + 1,
+                };
+            }
+            endIndex += 2;
+        }
+        return undefined;
+    }
+    const matches = SQL_IDENTIFIER_REGEX.exec(line.slice(index));
+    if (!matches) {
+        return undefined;
+    }
+    return { name: matches[0], endIndex: index + matches[0].length };
+};
+exports.readSqlIdentifier = readSqlIdentifier;
+const getInsertStatementInfo = (line) => {
+    const statementMatches = /^\s*(?:INSERT|REPLACE)\b/i.exec(line);
+    if (!statementMatches) {
+        return undefined;
+    }
+    let index = statementMatches[0].length;
+    let tableName;
+    while (true) {
+        const identifier = (0, exports.readSqlIdentifier)(line, index);
+        if (!identifier) {
+            return undefined;
+        }
+        const keyword = identifier.name.toUpperCase();
+        index = identifier.endIndex;
+        if (exports.INSERT_STATEMENT_MODIFIERS.has(keyword) || 'INTO' === keyword) {
+            continue;
+        }
+        tableName = identifier;
+        break;
+    }
+    const dotIndex = (0, exports.skipSqlWhitespace)(line, tableName.endIndex);
+    if ('.' !== line[dotIndex]) {
+        return { tableName: tableName.name, tableEndIndex: tableName.endIndex };
+    }
+    const qualifiedTableName = (0, exports.readSqlIdentifier)(line, dotIndex + 1);
+    return {
+        tableName: qualifiedTableName?.name ?? tableName.name,
+        tableEndIndex: qualifiedTableName?.endIndex ?? tableName.endIndex,
+    };
+};
+exports.getInsertStatementInfo = getInsertStatementInfo;
+const isWordPressOptionsTable = (tableName) => tableName
+    ? /^wp_\d+_options$/i.test(tableName) || 'wp_options' === tableName.toLowerCase()
+    : false;
+exports.isWordPressOptionsTable = isWordPressOptionsTable;
+const checkRequiresOptionsInsertContext = (checkKey) => {
+    return 'siteHomeUrl' === checkKey || 'siteHomeUrlLando' === checkKey;
+};
+exports.checkRequiresOptionsInsertContext = checkRequiresOptionsInsertContext;
+const normalizeSqlIdentifier = (identifier) => {
+    return identifier.replace(/^`|`$/g, '').toLowerCase();
+};
+exports.normalizeSqlIdentifier = normalizeSqlIdentifier;
+const isSqlIdentifierChar = (char) => {
+    return undefined !== char && SQL_IDENTIFIER_CHAR_REGEX.test(char);
+};
+const skipSqlDelimitedSegment = (line, startIndex) => {
+    const delimiter = line[startIndex];
+    if ('`' !== delimiter && "'" !== delimiter && '"' !== delimiter) {
+        return undefined;
+    }
+    for (let index = startIndex + 1; index < line.length; index += 1) {
+        const char = line[index];
+        const nextChar = line[index + 1];
+        if (char !== delimiter) {
+            continue;
+        }
+        if ('`' !== delimiter && (0, exports.isEscapedByBackslash)(line, index)) {
+            continue;
+        }
+        if (nextChar === delimiter) {
+            index += 1;
+            continue;
+        }
+        return index;
+    }
+    return line.length - 1;
+};
+const getValuesKeywordMatchAt = (line, index) => {
+    const valuesMatches = VALUES_KEYWORD_REGEX.exec(line.slice(index));
+    if (!valuesMatches) {
+        return undefined;
+    }
+    const endIndex = index + valuesMatches[0].length;
+    if (isSqlIdentifierChar(line[index - 1]) || isSqlIdentifierChar(line[endIndex])) {
+        return undefined;
+    }
+    return {
+        index,
+        endIndex,
+    };
+};
+const findValuesKeyword = (line) => {
+    for (let index = 0; index < line.length; index += 1) {
+        const segmentEndIndex = skipSqlDelimitedSegment(line, index);
+        if (undefined !== segmentEndIndex) {
+            index = segmentEndIndex; // NOSONAR
+            continue;
+        }
+        const valuesKeyword = getValuesKeywordMatchAt(line, index);
+        if (valuesKeyword) {
+            return valuesKeyword;
+        }
+    }
+    return undefined;
+};
+exports.findValuesKeyword = findValuesKeyword;
+const findValuesKeywordIndex = (line) => {
+    return (0, exports.findValuesKeyword)(line)?.index ?? -1;
+};
+exports.findValuesKeywordIndex = findValuesKeywordIndex;
+const parseInsertColumnList = (line, startIndex) => {
+    const valuesIndex = (0, exports.findValuesKeywordIndex)(line);
+    const openingParenthesisIndex = line.indexOf('(', startIndex);
+    if (-1 === openingParenthesisIndex ||
+        (-1 !== valuesIndex && openingParenthesisIndex > valuesIndex)) {
+        return undefined;
+    }
+    const closingParenthesisIndex = line.indexOf(')', openingParenthesisIndex + 1);
+    if (-1 === closingParenthesisIndex) {
+        return undefined;
+    }
+    const columns = line
+        .slice(openingParenthesisIndex + 1, closingParenthesisIndex)
+        .split(',')
+        .map(column => (0, exports.normalizeSqlIdentifier)(column.trim()))
+        .filter(Boolean);
+    return columns.length > 0 ? columns : undefined;
+};
+exports.parseInsertColumnList = parseInsertColumnList;
+const parseInsertColumnListSegment = (columnList) => {
+    const columns = columnList
+        .split(',')
+        .map(column => (0, exports.normalizeSqlIdentifier)(column.trim()))
+        .filter(Boolean);
+    return columns.length > 0 ? columns : undefined;
+};
+exports.parseInsertColumnListSegment = parseInsertColumnListSegment;
+const isEscapedByBackslash = (line, index) => {
+    let backslashCount = 0;
+    let currentIndex = index - 1;
+    while (currentIndex >= 0 && '\\' === line[currentIndex]) {
+        backslashCount += 1;
+        currentIndex -= 1;
+    }
+    return 1 === backslashCount % 2;
+};
+exports.isEscapedByBackslash = isEscapedByBackslash;
+const isSqlQuoteStart = (char) => "'" === char || '"' === char || '`' === char;
+const isSqlBlockCommentStart = (line, index) => '/' === line[index] && '*' === line[index + 1];
+const isSqlBlockCommentEnd = (line, index) => '*' === line[index] && '/' === line[index + 1];
+const isSqlDashCommentStart = (line, index) => {
+    if ('-' !== line[index] || '-' !== line[index + 1]) {
+        return false;
+    }
+    const afterCommentMarker = line[index + 2];
+    return undefined === afterCommentMarker || /\s/.test(afterCommentMarker);
+};
+const isSqlLineCommentStart = (line, index) => '#' === line[index] || isSqlDashCommentStart(line, index);
+const setSqlCommentStripState = (state, inBlockComment) => {
+    if (state) {
+        state.inBlockComment = inBlockComment;
+    }
+};
+const readSqlQuotedSegment = (line, startIndex) => {
+    if (!isSqlQuoteStart(line[startIndex])) {
+        return undefined;
+    }
+    const endIndex = skipSqlDelimitedSegment(line, startIndex);
+    if (undefined === endIndex) {
+        return undefined;
+    }
+    return {
+        text: line.slice(startIndex, endIndex + 1),
+        nextIndex: endIndex + 1,
+    };
+};
+const skipSqlBlockComment = (line, startIndex, uncommentedLine, state) => {
+    for (let index = startIndex; index < line.length; index += 1) {
+        if (!isSqlBlockCommentEnd(line, index)) {
+            continue;
+        }
+        setSqlCommentStripState(state, false);
+        const nextIndex = index + 2;
+        return {
+            inBlockComment: false,
+            nextIndex: '' === uncommentedLine ? (0, exports.skipSqlWhitespace)(line, nextIndex) : nextIndex,
+        };
+    }
+    setSqlCommentStripState(state, true);
+    return {
+        inBlockComment: true,
+        nextIndex: line.length,
+    };
+};
+const blockCommentNeedsSeparator = (output, line, nextIndex) => Boolean(output) &&
+    !/\s$/.test(output) &&
+    nextIndex < line.length &&
+    !/\s/.test(line[nextIndex]);
+const isUnescapedDelimiter = (quote, line, index) => '`' === quote || !(0, exports.isEscapedByBackslash)(line, index);
+const stripSqlCommentsOutsideQuotedStrings = (line, state) => {
+    let uncommentedLine = '';
+    let inBlockComment = state?.inBlockComment ?? false;
+    let index = 0;
+    while (index < line.length) {
+        if (inBlockComment) {
+            const blockComment = skipSqlBlockComment(line, index, uncommentedLine, state);
+            inBlockComment = blockComment.inBlockComment;
+            index = blockComment.nextIndex;
+            continue;
+        }
+        if (state?.quote) {
+            const quote = state.quote;
+            const start = index;
+            while (index < line.length) {
+                const nextQuote = line.indexOf(quote, index);
+                if (-1 === nextQuote) {
+                    index = line.length;
+                    break;
+                }
+                index = nextQuote;
+                if (isUnescapedDelimiter(quote, line, index)) {
+                    if (line[index + 1] === quote) {
+                        index += 2;
+                        continue;
+                    }
+                    state.quote = undefined;
+                    index += 1;
+                    break;
+                }
+                index += 1;
+            }
+            uncommentedLine += line.slice(start, index);
+            continue;
+        }
+        if (state && isSqlQuoteStart(line[index])) {
+            state.quote = line[index];
+            uncommentedLine += line[index];
+            index += 1;
+            continue;
+        }
+        const quotedSegment = readSqlQuotedSegment(line, index);
+        if (quotedSegment) {
+            uncommentedLine += quotedSegment.text;
+            index = quotedSegment.nextIndex;
+            continue;
+        }
+        if (isSqlLineCommentStart(line, index)) {
+            return uncommentedLine.trimEnd();
+        }
+        if (isSqlBlockCommentStart(line, index)) {
+            const blockComment = skipSqlBlockComment(line, index + 2, uncommentedLine, state);
+            if (blockCommentNeedsSeparator(uncommentedLine, line, blockComment.nextIndex)) {
+                uncommentedLine += ' ';
+            }
+            inBlockComment = blockComment.inBlockComment;
+            index = blockComment.nextIndex;
+            continue;
+        }
+        const nextSpecial = /['"`#/-]/g;
+        nextSpecial.lastIndex = index + 1;
+        const match = nextSpecial.exec(line);
+        const end = match?.index ?? line.length;
+        uncommentedLine += line.slice(index, end);
+        index = end;
+    }
+    if (inBlockComment) {
+        return uncommentedLine.trimEnd();
+    }
+    return uncommentedLine;
+};
+exports.stripSqlCommentsOutsideQuotedStrings = stripSqlCommentsOutsideQuotedStrings;
+const isNonTupleContent = (char, depth, quote) => 0 === depth && !quote && !/[\s,(]/.test(char);
+const parseSqlTupleRows = (line, startIndex) => {
+    const rows = [];
+    let currentRow;
+    let currentValue = '';
+    let parenthesisDepth = 0;
+    let quote;
+    let rowStartIndex;
+    for (let index = startIndex; index < line.length; index += 1) {
+        const char = line[index];
+        if (isNonTupleContent(char, parenthesisDepth, quote)) {
+            return { rows, finished: true };
+        }
+        if (quote) {
+            currentValue += char;
+            if (char === quote && !(0, exports.isEscapedByBackslash)(line, index)) {
+                if (line[index + 1] === quote) {
+                    currentValue += line[index + 1];
+                    index += 1;
+                    continue;
+                }
+                quote = undefined;
+            }
+            continue;
+        }
+        if ("'" === char || '"' === char) {
+            quote = char;
+            currentValue += char;
+            continue;
+        }
+        if ('(' === char) {
+            if (0 === parenthesisDepth) {
+                currentRow = [];
+                currentValue = '';
+                rowStartIndex = index;
+            }
+            else {
+                currentValue += char;
+            }
+            parenthesisDepth += 1;
+            continue;
+        }
+        if (')' === char && currentRow) {
+            parenthesisDepth -= 1;
+            if (0 === parenthesisDepth) {
+                currentRow.push(currentValue.trim());
+                rows.push(currentRow);
+                currentRow = undefined;
+                currentValue = '';
+                rowStartIndex = undefined;
+                continue;
+            }
+        }
+        if (',' === char && 1 === parenthesisDepth && currentRow) {
+            currentRow.push(currentValue.trim());
+            currentValue = '';
+            continue;
+        }
+        if (currentRow) {
+            currentValue += char;
+        }
+    }
+    return {
+        rows,
+        remainder: undefined === rowStartIndex ? undefined : line.slice(rowStartIndex),
+    };
+};
+exports.parseSqlTupleRows = parseSqlTupleRows;
+const unquoteSqlValue = (value) => {
+    const trimmedValue = value?.trim() ?? '';
+    const quote = trimmedValue[0];
+    if (!quote || ("'" !== quote && '"' !== quote) || trimmedValue.at(-1) !== quote) {
+        return trimmedValue;
+    }
+    return trimmedValue
+        .slice(1, -1)
+        .replaceAll(quote + quote, quote)
+        .replaceAll('\\' + quote, quote);
+};
+exports.unquoteSqlValue = unquoteSqlValue;
+const getOptionUrlMatchResults = (row, columns) => {
+    const optionColumns = columns ?? exports.DEFAULT_OPTIONS_INSERT_COLUMNS;
+    const optionNameIndex = optionColumns.indexOf('option_name');
+    const optionValueIndex = optionColumns.indexOf('option_value');
+    if (-1 === optionNameIndex || -1 === optionValueIndex) {
+        return undefined;
+    }
+    const optionName = (0, exports.unquoteSqlValue)(row[optionNameIndex]).toLowerCase();
+    const optionValue = (0, exports.unquoteSqlValue)(row[optionValueIndex]);
+    if ('siteurl' !== optionName && 'home' !== optionName) {
+        return undefined;
+    }
+    if (!/^https?:\/\//i.test(optionValue)) {
+        return undefined;
+    }
+    return ['', optionName, optionValue];
+};
+exports.getOptionUrlMatchResults = getOptionUrlMatchResults;