qualiteer/libold/server/database/queries/catalog.js

import pg from "../postgres.js";
// Imports
import {
  insertQuery,
  selectWhereAnyQuery,
  onConflictUpdate,
} from "../pg-query.js";
import { WARN } from "../../util/logging.js";

import getFilteredTags from "../tags.js";
import getDelay from "../delays.js";
// Constants
const table = "catalog";
const PG_DISABLED = process.env.POSTGRES_DISABLED;
import { testsMock, mappingsMock } from "../mocks/catalog-mock.js";
// Queries

export const removeDroppedTests = async (testNames) => {
  // BUG: After dropping a test, the id jumps ridiculously high
  const pgNames = testNames.map((tn) => `'${tn}'`).join(",");
  const query = `DELETE FROM catalog as x where x.name not in (${pgNames});`;
  return pg.query(query);
};

export const getTest = async (name) => {
  const query = selectWhereAnyQuery(table, { name });
  const results = await pg.query(query);
  if (results.length > 1)
    WARN("CATALOG", `More than 1 test found for '${name}'`);
  return results[0];
};

export const getTests = async () => {
  if (PG_DISABLED) return testsMock();
  const query = `SELECT * from ${table}`;
  return pg.query(query);
};

export const getPipelineMappings = async () => {
  if (PG_DISABLED) return mappingsMock();
  const query = `SELECT * from ${table} WHERE pipeline`;
  const tests = await pg.query(query);
  const mappings = [];
  var newTrigger;
  for (var test of tests) {
    if (test.triggers) continue;
    const { name, delay: delayStr } = test;
    var triggerStack = [{ name, delay: getDelay(delayStr), delayStr }];
    newTrigger = { name, delayStr };
    while (
      (newTrigger = tests.find(
        (te) => te.triggers && te.triggers.includes(newTrigger.name)
      )) !== null
    ) {
      if (!newTrigger) break;
      triggerStack.push({
        name: newTrigger.name,
        delay: getDelay(newTrigger.delay),
        delayStr: newTrigger.delay,
      });
    }
    mappings.push(triggerStack.reverse());
  }
  return mappings;
};

export const getProjects = async () => {
  if (PG_DISABLED) {
    const tests = testsMock();
  }
};

export const truncateTests = async () => {
  if (PG_DISABLED) return console.log(`Would truncate table ${table}`);
  const query = `TRUNCATE ${table} RESTART IDENTITY CASCADE;`;
  return await pg.query(query);
};

export const upsertTest = async (test) => {
  if (PG_DISABLED) return console.log("Would insert test", test);
  const {
    name,
    class: className,
    image,
    path,
    description,
    type,
    created,
    mergeRequest,
    tags,
  } = test;

  const filteredTags = getFilteredTags(tags);

  const env =
    filteredTags.ignore && filteredTags.env
      ? filteredTags.env.filter((e) => !filteredTags.ignore.includes(e))
      : filteredTags.env;
  const catalogEntry = {
    name,
    class: className,
    image,
    path,
    description: description ? description : null,
    type,
    created,
    mr: mergeRequest,
    tags,
    crons: filteredTags.crons,
    env,
    regions: filteredTags.regions,
    triggers: filteredTags.triggers,
    pipeline: filteredTags.pipeline ? true : false,
    coverage: filteredTags.coverage,
    projects: filteredTags.projects,
    delay: filteredTags.delay ? filteredTags.delay[0] : null,
  };
  const query =
    insertQuery(table, catalogEntry) + onConflictUpdate(["name"], catalogEntry);
  return await pg.query(query);
};