@payfit/nx-core 4.10.0-ephemeral.0 → 4.10.0

package/src/scripts/version-action.ts

@@ -1,89 +0,0 @@
-import { ProjectGraph, Tree } from '@nx/devkit'
-import { VersionActions } from 'nx/release'
-import { NxReleaseVersionConfiguration } from 'nx/src/config/nx-json'
-import { inc } from 'semver'
-
-export default class customVersionAction extends VersionActions {
-  validManifestFilenames: string[]
-  async readCurrentVersionFromSourceManifest(
-    tree: Tree,
-  ): Promise<{ currentVersion: string; manifestPath: string } | null> {
-    return {
-      currentVersion: '0.0.0',
-      manifestPath: 'apps/my-nest-app/project.json',
-    }
-  }
-  async readCurrentVersionFromRegistry(
-    tree: Tree,
-    currentVersionResolverMetadata: NxReleaseVersionConfiguration['currentVersionResolverMetadata'],
-  ): Promise<{ currentVersion: string | null; logText: string } | null> {
-    return {
-      currentVersion: '0.0.0',
-      logText: 'Current version from registry',
-    }
-  }
-  async readCurrentVersionOfDependency(
-    tree: Tree,
-    projectGraph: ProjectGraph,
-    dependencyProjectName: string,
-  ): Promise<{
-    currentVersion: string | null
-    dependencyCollection: string | null
-  }> {
-    return {
-      currentVersion: '0.0.0',
-      dependencyCollection: '0.0.0',
-    }
-  }
-  async isLocalDependencyProtocol(versionSpecifier: string): Promise<boolean> {
-    return false
-  }
-  async updateProjectVersion(
-    tree: Tree,
-    newVersion: string,
-  ): Promise<string[]> {
-    // Update the version in the VERSION file
-    const currentProject = this.projectGraphNode.name
-    const versionFilePath = `dist/apps/${currentProject}/VERSION`
-    tree.write(versionFilePath, newVersion)
-    return []
-  }
-  async updateProjectDependencies(
-    tree: Tree,
-    projectGraph: ProjectGraph,
-    dependenciesToUpdate: Record<string, string>,
-  ): Promise<string[]> {
-    return []
-  }
-  async calculateNewVersion(
-    currentVersion: string | null,
-    newVersionInput: string,
-    newVersionInputReason: string,
-    newVersionInputReasonData: Record<string, unknown>,
-    preid: string,
-  ): Promise<{
-    newVersion: string
-    logText: string
-  }> {
-    function formatDate() {
-      const date = new Date()
-      const year = date.getFullYear()
-      const month = String(date.getMonth() + 1).padStart(2, '0') // getMonth() returns 0-11
-      const day = date.getDate()
-
-      return `${year}${month}.${day}.`
-    }
-
-    function getNewVersionFromCurrentVersion(currentVersion: string) {
-      const expectedPattern = formatDate()
-      return !currentVersion.startsWith(expectedPattern)
-        ? `${expectedPattern}0`
-        : inc(currentVersion, 'patch')
-    }
-
-    return {
-      newVersion: getNewVersionFromCurrentVersion(currentVersion),
-      logText: `New version: ${getNewVersionFromCurrentVersion(currentVersion)}`,
-    }
-  }
-}

package/src/utils/aws-auth.ts

@@ -1,100 +0,0 @@
-import { getDockerOrPodman } from './docker'
-import { exec_command } from './exec'
-
-let profileName = 'OIDC-PROFILE'
-
-/**
- * Return the AWS profile name to use in AWS cli commands
- */
-export function getProfileName() {
-  return profileName
-}
-
-/**
- * Retrieves the AWS credentials from environment variables.
- * Ensures that `AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY`, and `AWS_DEFAULT_REGION` are properly set.
- * Throws an error if credentials or region are missing.
- *
- * @return {Object} An object containing AWS credentials.
- * @return {string} return.accessKeyId The AWS Access Key ID.
- * @return {string} return.secretAccessKey The AWS Secret Access Key.
- * @return {string} return.region The AWS Region.
- */
-export function getAwsCredentialsSet(): {
-  accessKeyId: string
-  secretAccessKey: string
-  region: string
-} {
-  const accessKeyId = process.env.AWS_ACCESS_KEY_ID
-  const secretAccessKey = process.env.AWS_SECRET_ACCESS_KEY
-  const region = process.env.AWS_DEFAULT_REGION
-  if (!accessKeyId || !secretAccessKey) {
-    throw new Error(
-      'AWS credentials not found, please set AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY environment variables (or attach GLOBAL_ORG context if you are using CircleCI)',
-    )
-  }
-  if (!region) {
-    throw new Error(
-      'AWS region not found, please set AWS_DEFAULT_REGION environment variable (or attach GLOBAL_ORG context if you are using CircleCI)',
-    )
-  }
-  return { accessKeyId, secretAccessKey, region }
-}
-
-/**
- * Retrieves the authentication information for a given OIDC profile.
- * If the specified profile exists, it fetches the configuration; otherwise, it returns false.
- *
- * @return {Promise<string | boolean>} The authentication details if the profile exists, or false if the profile does not exist.
- */
-export async function getAuthWithOidcProfile(): Promise<string | boolean> {
-  try {
-    const profileExist = await exec_command(
-      `aws configure list-profiles | grep ${profileName}`,
-    )
-    if (profileExist.success) {
-      return profileExist.stdout
-    }
-    return false
-  } catch (e) {
-    console.error(e)
-    return false
-  }
-}
-
-export async function loginToEcr() {
-  return exec_command(
-    `aws ecr get-login-password --profile ${profileName} --region eu-west-3 | ${await getDockerOrPodman()} login --username AWS --password-stdin ${process.env.AWS_ECR_REGISTRY}`,
-  )
-}
-
-/**
- * Check AWS CLI with the OIDC profile otherwise use the default credentials
- * @returns {string} the profile's name
- */
-export async function checkAwsAuth(): Promise<string> {
-  const profileExist = await getAuthWithOidcProfile()
-  if (profileExist) {
-    console.log('OIDC profile found, using it')
-    profileName = 'OIDC-PROFILE'
-  } else if (getAwsCredentialsSet()) {
-    console.log(
-      'OIDC profile not found, using AWS_KEY_ID and AWS_SECRET_ACCESS_KEY',
-    )
-    profileName = 'default'
-  } else {
-    throw new Error(
-      'AWS credentials not found, please attach CORE-PLATFORM_SHARED_ENV context if you are using CircleCI or export AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY environment variables',
-    )
-  }
-  return profileName
-}
-
-export function pushImageToEcr(
-  repositoryName: string,
-  version: string,
-): Promise<{ success: boolean }> {
-  return exec_command(
-    `docker push ${process.env.AWS_ECR_REGISTRY}/${repositoryName}:${version}`,
-  )
-}

package/src/utils/exec.spec.ts

@@ -1,16 +0,0 @@
-import { exec_command } from './exec'
-
-describe('exec', () => {
-  it('can run', async () => {
-    const output = await exec_command('echo "Hello World"')
-    expect(output.success).toBe(true)
-    expect(output.stdout).toBe('Hello World\n')
-  })
-
-  it('can run with stderr', async () => {
-    const output = await exec_command('echo "Hello World" 1>&2')
-    expect(output.success).toBe(false)
-    expect(output.stdout).toBe('')
-    expect(output.stderr).toBe('Hello World\n')
-  })
-})

package/src/utils/exec.ts

@@ -1,31 +0,0 @@
-import { exec } from 'child_process'
-import { promisify } from 'util'
-
-import type { Options, TinyExec } from 'tinyexec'
-
-import { x } from 'tinyexec'
-
-export async function exec_command(command: string) {
-  const { stdout, stderr } = await promisify(exec)(command)
-  console.log(stdout)
-  console.error(stderr)
-
-  const success = !stderr
-  return { success, stdout, stderr }
-}
-
-function createLoggingExecWrapper(execFn: TinyExec): TinyExec {
-  return (
-    command: string,
-    args: string[] = [],
-    options: Partial<Options> = {},
-  ) => {
-    console.log(`Running '${command} ${args.join(' ')}'...`)
-    return execFn(command, args, {
-      throwOnError: true,
-      ...options,
-    })
-  }
-}
-
-export const execTiny = createLoggingExecWrapper(x)

package/src/utils/get-version.ts

@@ -1,11 +0,0 @@
-import * as fs from 'node:fs'
-
-/**
- * Get the version of a project
- * @param projectName
- * @returns {string}
- */
-export function getVersion(projectName: string): string {
-  const versionFilePath = `dist/apps/${projectName}/VERSION`
-  return fs.readFileSync(versionFilePath, 'utf8')
-}

package/src/utils/github.ts

@@ -1,14 +0,0 @@
-import { exec_command } from './exec'
-
-/**
- * Get sanitized current git branch name
- */
-export async function getSanitizedCurrentGitBranch() {
-  const branchName = await exec_command(`git branch --show-current`)
-  return branchName.success
-    ? branchName.stdout
-        .trim()
-        .toLowerCase()
-        .replace(/[^a-z0-9]/g, '')
-    : ''
-}

package/src/utils/helm.ts

@@ -1,125 +0,0 @@
-import * as fs from 'node:fs'
-import * as process from 'node:process'
-
-import { parse, stringify } from 'yaml'
-
-import { getProfileName } from './aws-auth'
-import { exec_command } from './exec'
-
-const tshProxy = 'http://localhost'
-
-/**
- * Read & parse the Helm chart.yaml file
- * @param helmFolderPath
- */
-export async function getHelmChartFile(helmFolderPath: string) {
-  return parse(fs.readFileSync(`${helmFolderPath}/Chart.yaml`, 'utf8'))
-}
-
-/**
- * Prepare the Chart.yaml config file for the Tsh proxy
- * @param helmFolderPath
- * @param tshPort
- */
-export async function setupTeleportProxyHelmChartFile(
-  helmFolderPath: string,
-  tshPort: number,
-) {
-  console.log(
-    `Replacing charts.shared.payfit.tech -> localhost:${tshPort} for the Teleport proxy`,
-  )
-  let chartConfigStr = stringify(await getHelmChartFile(helmFolderPath))
-  chartConfigStr = chartConfigStr.replace(
-    /(https?:\/\/)charts(\.shared)?\.payfit\.tech/gi,
-    `${tshProxy}:${tshPort}`,
-  )
-  return fs.writeFileSync(`${helmFolderPath}/Chart.yaml`, chartConfigStr)
-}
-
-/**
- * Revert the Tsh proxy config in the Chart.yaml config file
- * @param helmFolderPath
- * @param tshPort
- */
-export async function resetTeleportProxyHelmChartFile(
-  helmFolderPath: string,
-  tshPort: number,
-) {
-  let chartConfigStr = stringify(await getHelmChartFile(helmFolderPath))
-  chartConfigStr = chartConfigStr.replace(
-    `${tshProxy}:${tshPort}`,
-    'https://charts.shared.payfit.tech',
-  )
-  return fs.writeFileSync(`${helmFolderPath}/Chart.yaml`, chartConfigStr)
-}
-
-/**
- * Install all the helm repositories defined in the Chart config
- * @param helmFolderPath
- */
-export async function installHelmRepo(helmFolderPath: string) {
-  const chartConfig = await getHelmChartFile(helmFolderPath)
-  if (chartConfig.dependencies) {
-    for (let i = 0; i < chartConfig.dependencies.length; i++) {
-      const dep = chartConfig.dependencies[i]
-      const repoName = `tsh-${dep.name}-${dep.alias}`
-      // check if the repository is our private payfit repo or a public one
-      if (dep.repository.includes(tshProxy)) {
-        // if  it's our repo, we need the username and password to authenticate
-        if (
-          !process.env.CHARTMUSEUM_USERNAME ||
-          !process.env.CHARTMUSEUM_PASSWORD
-        )
-          throw new Error(
-            'Missing CHARTMUSEUM_USERNAME, CHARTMUSEUM_PASSWORD in environment!',
-          )
-        await exec_command(
-          `helm repo add --username '${process.env.CHARTMUSEUM_USERNAME}' --password '${process.env.CHARTMUSEUM_PASSWORD}' '${repoName}' '${dep.repository}' --force-update`,
-        )
-      } else {
-        await exec_command(
-          `helm repo add '${repoName}' '${dep.repository}' --force-update`,
-        )
-      }
-      await exec_command(`helm repo update ${repoName}`)
-    }
-  }
-  return exec_command(`helm dependency update ${helmFolderPath}`)
-}
-
-/**
- * Package the Helm chart
- * @param helmFolderPath
- * @param version
- * @param destinationPath
- */
-export async function packageHelm(
-  helmFolderPath: string,
-  version: string,
-  destinationPath: string,
-) {
-  return exec_command(
-    `helm package ${helmFolderPath} --version ${version} --destination ${destinationPath}`,
-  )
-}
-
-/**
- * Push the packaged Helm chart in the chartmuseum
- * @param packagedHelmChartFilePath
- * @param projectName
- * @param branch
- */
-export async function pushPackagedHelm(
-  packagedHelmChartFilePath: string,
-  projectName: string,
-  branch: string,
-) {
-  if (!process.env.CHARTMUSEUM_BUCKET_NAME)
-    throw new Error('Missing CHARTMUSEUM_BUCKET_NAME in environment!')
-  // aws s3api put-object-tagging --bucket ${process.env.CHARTMUSEUM_BUCKET_NAME} --key ${projectName}/${branch}/${packagedHelmChartFilePath} --tagging '{"TagSet": [{ "Key": "auto-purge", "Value": "false" }]}' // todo
-  const profile =
-    getProfileName() === 'default' ? '' : `--profile ${getProfileName()}`
-  return exec_command(
-    `aws s3 cp ${profile} --sse AES256 ${packagedHelmChartFilePath} s3://${process.env.CHARTMUSEUM_BUCKET_NAME}/${projectName}/${branch}/`,
-  )
-}

package/src/utils/import-esm.ts

@@ -1,10 +0,0 @@
-// Needed since we have to have dynamic import to esm module, since we are stuck with cjs on the nx tool runner
-export function importKy(): Promise<typeof import('ky')> {
-  return Function('return import("ky")')() as Promise<typeof import('ky')>
-}
-
-export function importGetPort(): Promise<typeof import('get-port')> {
-  return Function('return import("get-port")')() as Promise<
-    typeof import('get-port')
-  >
-}

package/src/utils/tsh.ts

@@ -1,127 +0,0 @@
-import { workspaceRoot } from 'nx/src/utils/workspace-root'
-import { z } from 'zod'
-
-import { execTiny } from './exec'
-import { importGetPort, importKy } from './import-esm'
-
-const expectedProfileUrl = 'https://payfit.teleport.sh:443'
-const expectedAppName = 'charts-shared'
-
-const profile = z.object({
-  profile_url: z.string(),
-})
-
-const statusSchema = z.object({
-  active: profile,
-  profiles: z.array(profile).optional(),
-})
-
-const getStatusOfTsh = async () => {
-  const { stdout } = await execTiny('tsh', `status -f json`.split(' '))
-  return statusSchema.parse(JSON.parse(stdout))
-}
-
-export async function isLoggedInToTsh(): Promise<boolean> {
-  try {
-    const status = await getStatusOfTsh()
-    return status.active.profile_url === expectedProfileUrl
-  } catch {
-    return false
-  }
-}
-
-export async function ensureIsLoggedInToTsh(): Promise<boolean> {
-  if (await isLoggedInToTsh()) {
-    return true
-  }
-  await execTiny(
-    'tsh',
-    `login --proxy=${expectedProfileUrl} --auth=okta`.split(' '),
-    {
-      throwOnError: true,
-    },
-  )
-  return await isLoggedInToTsh()
-}
-
-const getAppConfigOfTsh = async () => {
-  const { stdout } = await execTiny(
-    'tsh',
-    `apps config -f json --proxy=${expectedProfileUrl} ${expectedAppName}`.split(
-      ' ',
-    ),
-    {
-      throwOnError: true,
-    },
-  )
-
-  return JSON.parse(stdout)
-}
-
-export async function isConnectedToChartMuseum(): Promise<boolean> {
-  try {
-    const apps = await getAppConfigOfTsh()
-    return apps.name === expectedAppName
-  } catch {
-    return false
-  }
-}
-
-export async function ensureAppIsChartMuseum(): Promise<boolean> {
-  if (await isConnectedToChartMuseum()) {
-    return true
-  }
-  await execTiny(
-    'tsh',
-    `apps login ${expectedAppName} --proxy=${expectedProfileUrl}`.split(' '),
-    {
-      throwOnError: true,
-    },
-  )
-  return await isConnectedToChartMuseum()
-}
-
-export const getLocalPortForChartMuseum = async () => {
-  if (!process.env.CI) {
-    await ensureIsLoggedInToTsh()
-    await ensureAppIsChartMuseum()
-  }
-
-  const { default: getPort } = await importGetPort()
-  const { default: ky } = await importKy()
-  const port = await getPort()
-
-  const command = process.env.CI
-    ? `-i ./certs/identity --proxy payfit.teleport.sh:443 proxy app ${expectedAppName} --port ${port}`
-    : `proxy app ${expectedAppName} -p ${port}`
-  const execHandle = execTiny('tsh', command.split(' '), {
-    nodeOptions: {
-      cwd: workspaceRoot,
-    },
-  })
-
-  const isReady = async (): Promise<boolean> => {
-    for await (const line of execHandle) {
-      console.log(`[TSH] ${line}`)
-      if (line.includes('Proxying connections')) {
-        return true
-      }
-    }
-    // line will be from stderr/stdout in the order you'd see it in a term
-    return false
-  }
-
-  const fetchClient = ky.create({
-    prefixUrl: `http://localhost:${port}`,
-  })
-
-  return {
-    [Symbol.dispose]: async () => {
-      console.log(`Terminating tsh proxy on port ${port}`)
-      execHandle.kill()
-    },
-    fetchClient,
-    isReady,
-    port,
-  }
-}

package/tsconfig.json

@@ -1,19 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "module": "commonjs",
-    "esModuleInterop": true,
-    "target": "es2022",
-    "lib": ["es2022", "esnext.disposable", "dom"]
-  },
-  "files": [],
-  "include": [],
-  "references": [
-    {
-      "path": "./tsconfig.lib.json"
-    },
-    {
-      "path": "./tsconfig.spec.json"
-    }
-  ]
-}

package/tsconfig.lib.json

@@ -1,22 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "outDir": "./dist/out-tsc",
-    "tsBuildInfoFile": "./dist/out-tsc.tsbuildinfo"
-  },
-  "include": ["src/**/*.ts"],
-  "exclude": [
-    "vite.config.ts",
-    "vite.config.mts",
-    "vitest.config.ts",
-    "vitest.config.mts",
-    "src/**/*.test.ts",
-    "src/**/*.spec.ts",
-    "src/**/*.test.tsx",
-    "src/**/*.spec.tsx",
-    "src/**/*.test.js",
-    "src/**/*.spec.js",
-    "src/**/*.test.jsx",
-    "src/**/*.spec.jsx"
-  ]
-}

package/tsconfig.spec.json

@@ -1,28 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "outDir": "dist",
-    "types": [
-      "vitest/globals",
-      "vitest/importMeta",
-      "vite/client",
-      "node",
-      "vitest"
-    ]
-  },
-  "include": [
-    "vite.config.ts",
-    "vite.config.mts",
-    "vitest.config.ts",
-    "vitest.config.mts",
-    "src/**/*.test.ts",
-    "src/**/*.spec.ts",
-    "src/**/*.test.tsx",
-    "src/**/*.spec.tsx",
-    "src/**/*.test.js",
-    "src/**/*.spec.js",
-    "src/**/*.test.jsx",
-    "src/**/*.spec.jsx",
-    "src/**/*.d.ts"
-  ]
-}

package/vite.config.ts

@@ -1,28 +0,0 @@
-import { nxCopyAssetsPlugin } from '@nx/vite/plugins/nx-copy-assets.plugin'
-import { nxViteTsPaths } from '@nx/vite/plugins/nx-tsconfig-paths.plugin'
-import { defineConfig, loadEnv } from 'vite'
-
-export default defineConfig(({ mode }) => ({
-  root: __dirname,
-  cacheDir: '../../node_modules/.vite/tools/publisher',
-  plugins: [nxViteTsPaths(), nxCopyAssetsPlugin(['*.md'])],
-  // Uncomment this if you are using workers.
-  // worker: {
-  //  plugins: [ nxViteTsPaths() ],
-  // },
-  test: {
-    watch: false,
-    globals: true,
-    environment: 'jsdom',
-    include: ['src/**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}'],
-    reporters: ['default', 'junit'],
-    outputFile: {
-      junit: '../../test-results/vitest-results.xml',
-    },
-    coverage: {
-      reportsDirectory: '../../coverage/packages/nx-core',
-      provider: 'v8' as const,
-    },
-    env: loadEnv(mode, process.cwd(), ''),
-  },
-}))