GitFOSS

// 1st-party
import { InMemoryCacheAdapter } from "@ethicdevs/fastify-stream-react-views";
import type { ServiceMethodFactory } from "@ethicdevs/react-monolith";
import { PipelineStatus } from "@prisma/client";
// app
import { RepositoryCountersDTO } from "../../types";
// service
import type { RepositoryServiceDeps } from "./types";

const CACHE = new InMemoryCacheAdapter();
const CACHE_TTL = 30 * 1000; // 30s before cache expires

const makeGetRepositoryCounters: ServiceMethodFactory<
  RepositoryServiceDeps,
  [string, string, string | null],
  Promise<RepositoryCountersDTO | null>
> = ({ request }) => {
  return async (orgSlug, repoSlug, username) => {
    const cacheKey = `${orgSlug}/${repoSlug}/counters`;
    const lastRefresh = await CACHE.get(
      `${orgSlug}/${repoSlug}/counters/lastRefresh`,
    );

    let isFreshCache = (request.params as any)["refetch"] != null || false;

    // when last refresh is more than 30s ago, bypass the cache.
    if (
      lastRefresh != null &&
      new Date(lastRefresh).getTime() > Date.now() - CACHE_TTL
    ) {
      isFreshCache = true;
    }

    // when cache is fresh, return it.
    if (isFreshCache === false && (await CACHE.has(cacheKey))) {
      const value = await CACHE.get(cacheKey);
      if (value) return JSON.parse(value);
      return DEFAULT_COUNTERS;
    }

    // retrieve open pulls count in repository (PRs targeting this repo)
    const openPulls =
      orgSlug != null && repoSlug != null
        ? await request.prisma.pullRequest.count({
            where: {
              targetRepository: {
                organization: { slug: orgSlug },
                slug: repoSlug,
              },
              state: "OPEN",
              closedAt: null,
            },
          })
        : 0;

    // retrieve merged pulls count in repository (PRs targeting this repo)
    const mergedPulls =
      orgSlug != null && repoSlug != null
        ? await request.prisma.pullRequest.count({
            where: {
              targetRepository: {
                organization: { slug: orgSlug },
                slug: repoSlug,
              },
              state: "CLOSE_MERGED",
            },
          })
        : 0;

    // retrieve closed pulls count in repository (PRs targeting this repo)
    const closedPulls =
      orgSlug != null && repoSlug != null
        ? await request.prisma.pullRequest.count({
            where: {
              targetRepository: {
                organization: { slug: orgSlug },
                slug: repoSlug,
              },
              state: "CLOSE_DENIED",
            },
          })
        : 0;

    const pendingPipelines =
      orgSlug != null && repoSlug != null
        ? await request.prisma.pipeline.count({
            where: {
              repo: {
                organization: { slug: orgSlug },
                slug: repoSlug,
              },
              status: PipelineStatus.PENDING,
            },
          })
        : 0;

    const runningPipelines =
      orgSlug != null && repoSlug != null
        ? await request.prisma.pipeline.count({
            where: {
              repo: {
                organization: { slug: orgSlug },
                slug: repoSlug,
              },
              status: PipelineStatus.RUNNING,
            },
          })
        : 0;

    const passedPipelines =
      orgSlug != null && repoSlug != null
        ? await request.prisma.pipeline.count({
            where: {
              repo: {
                organization: { slug: orgSlug },
                slug: repoSlug,
              },
              status: PipelineStatus.PASSED,
            },
          })
        : 0;

    const failedPipelines =
      orgSlug != null && repoSlug != null
        ? await request.prisma.pipeline.count({
            where: {
              repo: {
                organization: { slug: orgSlug },
                slug: repoSlug,
              },
              status: PipelineStatus.FAILED,
            },
          })
        : 0;

    const canceledPipelines =
      orgSlug != null && repoSlug != null
        ? await request.prisma.pipeline.count({
            where: {
              repo: {
                organization: { slug: orgSlug },
                slug: repoSlug,
              },
              status: PipelineStatus.CANCELED,
            },
          })
        : 0;

    console.log("username:", username);

    // retrieve current user ssh keyrs count
    const sshKeys =
      username != null
        ? await request.prisma.userSSHKey.count({
            where: {
              user: {
                username: username!,
              },
            },
          })
        : 0;
    const sshKeysActive =
      username != null
        ? await request.prisma.userSSHKey.count({
            where: {
              user: {
                id: request.session.data.curr_user_uid!,
              },
              revoked: false,
            },
          })
        : 0;
    const sshKeysRevoked =
      username != null
        ? await request.prisma.userSSHKey.count({
            where: {
              user: {
                id: request.session.data.curr_user_uid!,
              },
              revoked: true,
            },
          })
        : 0;

    const forks =
      orgSlug != null && repoSlug != null
        ? await request.prisma.repository.count({
            where: {
              isFork: true,
              forkedFromRepo: {
                organization: {
                  slug: orgSlug,
                },
                slug: repoSlug,
              },
            },
          })
        : 0;

    // for now provide pulls and zeros
    const counters: RepositoryCountersDTO = {
      files: 0,
      forks: forks,
      likes: 0,
      watchers: 0,
      branches: 0,
      tags: 0,
      commits: 0,
      pulls: openPulls, // we only show open pulls, not total here
      pullsOpen: openPulls,
      pullsMerged: mergedPulls,
      pullsClosed: closedPulls,
      pullsTotal: openPulls + mergedPulls + closedPulls,
      pipelines:
        pendingPipelines +
        runningPipelines +
        passedPipelines +
        failedPipelines +
        canceledPipelines,
      pipelinesPending: pendingPipelines,
      pipelinesRunning: runningPipelines,
      pipelinesPassed: passedPipelines,
      pipelinesFailed: failedPipelines,
      pipelinesCanceled: canceledPipelines,
      pipelinesTotal:
        pendingPipelines +
        runningPipelines +
        passedPipelines +
        failedPipelines +
        canceledPipelines,
      tests: 0,
      builds: 0,
      issues: 0,
      apiRefSymbols: 0,
      helpCenterNotifs: 0,
      sshKeys: sshKeys,
      sshKeysActive: sshKeysActive,
      sshKeysRevoked: sshKeysRevoked,
      sshKeysTotal: sshKeysActive + sshKeysRevoked,
    };

    console.log("COUNTERS=", counters);

    await CACHE.set(cacheKey, JSON.stringify(counters));
    return counters;
  };
};

const DEFAULT_COUNTERS: RepositoryCountersDTO = {
  files: 0,
  watchers: 0,
  likes: 0,
  forks: 0,
  branches: 0,
  tags: 0,
  commits: 0,
  pulls: 0,
  pullsOpen: 0,
  pullsMerged: 0,
  pullsClosed: 0,
  pullsTotal: 0,
  pipelines: 0,
  pipelinesPending: 0,
  pipelinesRunning: 0,
  pipelinesPassed: 0,
  pipelinesFailed: 0,
  pipelinesCanceled: 0,
  pipelinesTotal: 0,
  tests: 0,
  builds: 0,
  issues: 0,
  apiRefSymbols: 0,
  helpCenterNotifs: 0,
  sshKeys: 0,
  sshKeysActive: 0,
  sshKeysRevoked: 0,
  sshKeysTotal: 0,
};

export default makeGetRepositoryCounters;