@codeque/core/dist/searchInFs.js

Multiline code search for every language. Structural code search for JavaScript, TypeScript, HTML and CSS

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.searchInFileSystem = void 0;

var _fs = _interopRequireDefault(require("fs"));

var _utils = require("./utils");

var _logger = require("./logger");

var _parseQuery = require("./parseQuery");

var _searchFileContent = require("./searchStages/searchFileContent");

var _textSearch = require("./textSearch");

var _index = require("./parserSettings/index");

var _testOnlyConfig = require("./testOnlyConfig");

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

const searchInFileSystem = ({
  mode,
  filePaths,
  queryCodes,
  caseInsensitive = false,
  debug = false,
  onPartialResult,
  maxResultsLimit,
  hardStopFlag,
  parser = 'babel'
}) => {
  if (mode === 'text') {
    const getFileContent = filePath => {
      // sync file getting works faster :man-shrug; in text mode
      return _fs.default.readFileSync(filePath).toString();
    };

    return (0, _textSearch.textSearch)({
      getFileContent,
      filePaths,
      mode,
      queryCodes: queryCodes ?? [],
      caseInsensitive,
      onPartialResult,
      maxResultsLimit
    });
  }

  const parserSettings = _index.parserSettingsMap[_testOnlyConfig.testParserTypeOverride ?? parser]();

  const settings = {
    mode,
    caseInsensitive,
    logger: (0, _logger.createLogger)(debug),
    parserSettings
  };
  const {
    log
  } = settings.logger;
  const allMatches = [];
  const [queries, parseOk] = (0, _parseQuery.parseQueries)(queryCodes, caseInsensitive, parserSettings);

  if (!parseOk) {
    const errors = queries.filter(queryResult => queryResult.error);
    return {
      matches: [],
      hints: queries.map(({
        hints
      }) => hints),
      errors
    };
  }

  const searchErrors = [];

  for (const filePath of filePaths) {
    if (maxResultsLimit !== undefined && allMatches.length > maxResultsLimit || hardStopFlag?.stopSearch) {
      break;
    }

    try {
      const fileContent = _fs.default.readFileSync(filePath).toString();

      const fileMatches = (0, _searchFileContent.searchFileContent)({
        queries: queries,
        filePath,
        fileContent,
        ...settings
      });
      const dedupedFileMatches = (0, _utils.dedupMatches)(fileMatches);

      if (onPartialResult && dedupedFileMatches.length > 0) {
        onPartialResult(dedupedFileMatches);
      }

      allMatches.push(...dedupedFileMatches);

      if (dedupedFileMatches.length > 0) {
        if (debug) {
          break;
        }
      }
    } catch (e) {
      searchErrors.push({
        filePath,
        error: e?.message,
        stack: e?.stack
      });

      if (debug) {
        console.error(filePath, e);
        break;
      }
    }
  }

  if (debug) {
    (0, _utils.logMetrics)();
  }

  return {
    matches: allMatches,
    errors: searchErrors,
    hints: queries.map(({
      hints
    }) => hints)
  };
};

exports.searchInFileSystem = searchInFileSystem;