const noDeclaredLanguage = resolvedQueries.noDeclaredLanguage;

const noDeclaredLanguageQueries = Object.keys(noDeclaredLanguage);

if (noDeclaredLanguageQueries.length !== 0) {

throw new Error('The following queries do not declare a language. ' +

'Their qlpack.yml files are either missing or is invalid.\n' +

noDeclaredLanguageQueries.join('\n'));

}

const multipleDeclaredLanguages = resolvedQueries.multipleDeclaredLanguages;

const multipleDeclaredLanguagesQueries = Object.keys(multipleDeclaredLanguages);

if (multipleDeclaredLanguagesQueries.length !== 0) {

throw new Error('The following queries declare multiple languages. ' +

'Their qlpack.yml files are either missing or is invalid.\n' +

multipleDeclaredLanguagesQueries.join('\n'));

}

const codeQl = codeql_1.getCodeQL();

const resolvedQueries = await codeQl.resolveQueries(toResolve, extraSearchPath);

for (const [language, queries] of Object.entries(resolvedQueries.byLanguage)) {

if (resultMap[language] === undefined) {

resultMap[language] = [];

}

resultMap[language].push(...Object.keys(queries).filter(q => !queryIsDisabled(language, q)));

}

if (errorOnInvalidQueries) {

validateQueries(resolvedQueries);

}

const suite = builtinSuites.find((suite) => suite === suiteName);

if (!suite) {

throw new Error(getQueryUsesInvalid(configFile, suiteName));

}

const suites = languages.map(l => l + '-' + suiteName + '.qls');

await runResolveQueries(resultMap, suites, undefined, false);

// Resolve the local path against the workspace so that when this is

// passed to codeql it resolves to exactly the path we expect it to resolve to.

const workspacePath = fs.realpathSync(util.getRequiredEnvParam('GITHUB_WORKSPACE'));

let absoluteQueryPath = path.join(workspacePath, localQueryPath);

// Check the file exists

if (!fs.existsSync(absoluteQueryPath)) {

throw new Error(getLocalPathDoesNotExist(configFile, localQueryPath));

}

// Call this after checking file exists, because it'll fail if file doesn't exist

absoluteQueryPath = fs.realpathSync(absoluteQueryPath);

// Check the local path doesn't jump outside the repo using '..' or symlinks

if (!(absoluteQueryPath + path.sep).startsWith(workspacePath + path.sep)) {

throw new Error(getLocalPathOutsideOfRepository(configFile, localQueryPath));

}

// Get the root of the current repo to use when resolving query dependencies

const rootOfRepo = util.getRequiredEnvParam('GITHUB_WORKSPACE');

await runResolveQueries(resultMap, [absoluteQueryPath], rootOfRepo, true);

let tok = queryUses.split('@');

if (tok.length !== 2) {

throw new Error(getQueryUsesInvalid(configFile, queryUses));

}

const ref = tok[1];

tok = tok[0].split('/');

// The first token is the owner

// The second token is the repo

// The rest is a path, if there is more than one token combine them to form the full path

if (tok.length < 2) {

throw new Error(getQueryUsesInvalid(configFile, queryUses));

}

// Check none of the parts of the repository name are empty

if (tok[0].trim() === '' || tok[1].trim() === '') {

throw new Error(getQueryUsesInvalid(configFile, queryUses));

}

const nwo = tok[0] + '/' + tok[1];

// Checkout the external repository

const rootOfRepo = await externalQueries.checkoutExternalRepository(nwo, ref);

const queryPath = tok.length > 2

? path.join(rootOfRepo, tok.slice(2).join('/'))

: rootOfRepo;

await runResolveQueries(resultMap, [queryPath], rootOfRepo, true);

queryUses = queryUses.trim();

if (queryUses === "") {

throw new Error(getQueryUsesInvalid(configFile));

}

// Check for the local path case before we start trying to parse the repository name

if (queryUses.startsWith("./")) {

await addLocalQueries(configFile, resultMap, queryUses.slice(2));

return;

}

// Check for one of the builtin suites

if (queryUses.indexOf('/') === -1 && queryUses.indexOf('@') === -1) {

await addBuiltinSuiteQueries(configFile, languages, resultMap, queryUses);

return;

}

// Otherwise, must be a reference to another repo

await addRemoteQueries(configFile, resultMap, queryUses);

// Take a copy so we don't modify the original path, so we can still construct error messages

let path = originalPath;

// All paths are relative to the src root, so strip off leading slashes.

while (path.charAt(0) === '/') {

path = path.substring(1);

}

// Trailing ** are redundant, so strip them off

if (path.endsWith('/**')) {

path = path.substring(0, path.length - 2);

}

// An empty path is not allowed as it's meaningless

if (path === '') {

throw new Error(getConfigFilePropertyError(configFile, propertyName, '"' + originalPath + '" is not an invalid path. ' +

'It is not necessary to include it, and it is not allowed to exclude it.'));

}

// Check for illegal uses of **

if (path.match(pathStarsRegex)) {

throw new Error(getConfigFilePropertyError(configFile, propertyName, '"' + originalPath + '" contains an invalid "**" wildcard. ' +

'They must be immediately preceeded and followed by a slash as in "/**/", or come at the start or end.'));

}

// Check for other regex characters that we don't support.

// Output a warning so the user knows, but otherwise continue normally.

if (path.match(filterPatternCharactersRegex)) {

core.warning(getConfigFilePropertyError(configFile, propertyName, '"' + originalPath + '" contains an unsupported character. ' +

'The filter pattern characters ?, +, [, ], ! are not supported and will be matched literally.'));

}

// Ban any uses of backslash for now.

// This may not play nicely with project layouts.

// This restriction can be lifted later if we determine they are ok.

if (path.indexOf('\\') !== -1) {

throw new Error(getConfigFilePropertyError(configFile, propertyName, '"' + originalPath + '" contains an "\\" character. These are not allowed in filters. ' +

'If running on windows we recommend using "/" instead for path filters.'));

}

return path;

return getConfigFilePropertyError(configFile, QUERIES_PROPERTY + '.' + QUERIES_USES_PROPERTY, 'must be a built-in suite (' + builtinSuites.join(' or ') +

'), a relative path, or be of the form "owner/repo[/path]@ref"' +

(queryUses !== undefined ? '\n Found: ' + queryUses : ''));

let error = 'The configuration file "' + configFile + '" is not a supported remote file reference.';

error += ' Expected format <owner>/<repository>/<file-path>@<ref>';

return error;

var _a;

// Translate between GitHub's API names for languages and ours

const codeqlLanguages = {

'C': 'cpp',

'C++': 'cpp',

'C#': 'csharp',

'Go': 'go',

'Java': 'java',

'JavaScript': 'javascript',

'TypeScript': 'javascript',

'Python': 'python',

};

let repo_nwo = (_a = process.env['GITHUB_REPOSITORY']) === null || _a === void 0 ? void 0 : _a.split("/");

if (repo_nwo) {

let owner = repo_nwo[0];

let repo = repo_nwo[1];

core.debug(`GitHub repo ${owner} ${repo}`);

const response = await api.getApiClient().request("GET /repos/:owner/:repo/languages", ({

owner,

repo

}));

core.debug("Languages API response: " + JSON.stringify(response));

// The GitHub API is going to return languages in order of popularity,

// When we pick a language to autobuild we want to pick the most popular traced language

// Since sets in javascript maintain insertion order, using a set here and then splatting it

// into an array gives us an array of languages ordered by popularity

let languages = new Set();

for (let lang in response.data) {

if (lang in codeqlLanguages) {

languages.add(codeqlLanguages[lang]);

}

}

return [...languages];

}

else {

return [];

}

// Obtain from action input 'languages' if set

let languages = core.getInput('languages', { required: false })

.split(',')

.map(x => x.trim())

.filter(x => x.length > 0);

core.info("Languages from configuration: " + JSON.stringify(languages));

if (languages.length === 0) {

// Obtain languages as all languages in the repo that can be analysed

languages = await getLanguagesInRepo();

core.info("Automatically detected languages: " + JSON.stringify(languages));

}

return languages;

const languages = await getLanguages();

const queries = {};

await addDefaultQueries(languages, queries);

return {

languages: languages,

queries: queries,

pathsIgnore: [],

paths: []

};

let parsedYAML;

if (isLocal(configFile)) {

// Treat the config file as relative to the workspace

const workspacePath = util.getRequiredEnvParam('GITHUB_WORKSPACE');

configFile = path.resolve(workspacePath, configFile);

parsedYAML = getLocalConfig(configFile, workspacePath);

}

else {

parsedYAML = await getRemoteConfig(configFile);

}

// Validate that the 'name' property is syntactically correct,

// even though we don't use the value yet.

if (NAME_PROPERTY in parsedYAML) {

if (typeof parsedYAML[NAME_PROPERTY] !== "string") {

throw new Error(getNameInvalid(configFile));

}

if (parsedYAML[NAME_PROPERTY].length === 0) {

throw new Error(getNameInvalid(configFile));

}

}

const languages = await getLanguages();

// If the languages parameter was not given and no languages were

// detected then fail here as this is a workflow configuration error.

if (languages.length === 0) {

throw new Error("Did not detect any languages to analyze. Please update input in workflow.");

}

const queries = {};

const pathsIgnore = [];

const paths = [];

let disableDefaultQueries = false;

if (DISABLE_DEFAULT_QUERIES_PROPERTY in parsedYAML) {

if (typeof parsedYAML[DISABLE_DEFAULT_QUERIES_PROPERTY] !== "boolean") {

throw new Error(getDisableDefaultQueriesInvalid(configFile));

}

disableDefaultQueries = parsedYAML[DISABLE_DEFAULT_QUERIES_PROPERTY];

}

if (!disableDefaultQueries) {

await addDefaultQueries(languages, queries);

}

if (QUERIES_PROPERTY in parsedYAML) {

if (!(parsedYAML[QUERIES_PROPERTY] instanceof Array)) {

throw new Error(getQueriesInvalid(configFile));

}

for (const query of parsedYAML[QUERIES_PROPERTY]) {

if (!(QUERIES_USES_PROPERTY in query) || typeof query[QUERIES_USES_PROPERTY] !== "string") {

throw new Error(getQueryUsesInvalid(configFile));

}

await parseQueryUses(configFile, languages, queries, query[QUERIES_USES_PROPERTY]);

}

}

if (PATHS_IGNORE_PROPERTY in parsedYAML) {

if (!(parsedYAML[PATHS_IGNORE_PROPERTY] instanceof Array)) {

throw new Error(getPathsIgnoreInvalid(configFile));

}

parsedYAML[PATHS_IGNORE_PROPERTY].forEach(path => {

if (typeof path !== "string" || path === '') {

throw new Error(getPathsIgnoreInvalid(configFile));

}

pathsIgnore.push(validateAndSanitisePath(path, PATHS_IGNORE_PROPERTY, configFile));

});

}

if (PATHS_PROPERTY in parsedYAML) {

if (!(parsedYAML[PATHS_PROPERTY] instanceof Array)) {

throw new Error(getPathsInvalid(configFile));

}

parsedYAML[PATHS_PROPERTY].forEach(path => {

if (typeof path !== "string" || path === '') {

throw new Error(getPathsInvalid(configFile));

}

paths.push(validateAndSanitisePath(path, PATHS_PROPERTY, configFile));

});

}

return { languages, queries, pathsIgnore, paths };

const configFile = core.getInput('config-file');

let config;

// If no config file was provided create an empty one

if (configFile === '') {

core.debug('No configuration file was provided');

config = await getDefaultConfig();

}

else {

config = await loadConfig(configFile);

}

// Save the config so we can easily access it again in the future

await saveConfig(config);

return config;

// If the path starts with ./, look locally

if (configPath.indexOf("./") === 0) {

return true;

}

return (configPath.indexOf("@") === -1);

// Error if the config file is now outside of the workspace

if (!(configFile + path.sep).startsWith(workspacePath + path.sep)) {

throw new Error(getConfigFileOutsideWorkspaceErrorMessage(configFile));

}

// Error if the file does not exist

if (!fs.existsSync(configFile)) {

throw new Error(getConfigFileDoesNotExistErrorMessage(configFile));

}

return yaml.safeLoad(fs.readFileSync(configFile, 'utf8'));

// retrieve the various parts of the config location, and ensure they're present

const format = new RegExp('(?<owner>[^/]+)/(?<repo>[^/]+)/(?<path>[^@]+)@(?<ref>.*)');

const pieces = format.exec(configFile);

// 5 = 4 groups + the whole expression

if (pieces === null || pieces.groups === undefined || pieces.length < 5) {

throw new Error(getConfigFileRepoFormatInvalidMessage(configFile));

}

const response = await api.getApiClient().repos.getContents({

owner: pieces.groups.owner,

repo: pieces.groups.repo,

path: pieces.groups.path,

ref: pieces.groups.ref,

});

let fileContents;

if ("content" in response.data && response.data.content !== undefined) {

fileContents = response.data.content;

}

else if (Array.isArray(response.data)) {

throw new Error(getConfigFileDirectoryGivenMessage(configFile));

}

else {

throw new Error(getConfigFileFormatInvalidMessage(configFile));

}

return yaml.safeLoad(Buffer.from(fileContents, 'base64').toString('binary'));

const configString = JSON.stringify(config);

await io.mkdirP(getPathToParsedConfigFolder());

fs.writeFileSync(getPathToParsedConfigFile(), configString, 'utf8');

core.debug('Saved config:');

core.debug(configString);

const configFile = getPathToParsedConfigFile();

if (!fs.existsSync(configFile)) {

throw new Error("Config file could not be found at expected location. Has the 'init' action been called?");

}

const configString = fs.readFileSync(configFile, 'utf8');

core.debug('Loaded config:');

core.debug(configString);

return JSON.parse(configString);