@rharkor/caching-for-turbo 2.0.0 → 2.1.1

package/script/release

@@ -1,59 +0,0 @@
-#!/bin/bash
-
-# About:
-#
-# This is a helper script to tag and push a new release. GitHub Actions use
-# release tags to allow users to select a specific version of the action to use.
-#
-# See: https://github.com/actions/typescript-action#publishing-a-new-release
-#
-# This script will do the following:
-#
-# 1. Get the latest release tag
-# 2. Prompt the user for a new release tag
-# 3. Tag the new release
-# 4. Push the new tag to the remote
-#
-# Usage:
-#
-# script/release
-
-# Terminal colors
-OFF='\033[0m'
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-BLUE='\033[0;34m'
-
-# Get the latest release tag
-latest_tag=$(git describe --tags "$(git rev-list --tags --max-count=1)")
-
-if [[ -z "$latest_tag" ]]; then
-	# There are no existing release tags
-	echo -e "No tags found (yet) - Continue to create and push your first tag"
-	latest_tag="[unknown]"
-fi
-
-# Display the latest release tag
-echo -e "The latest release tag is: ${BLUE}${latest_tag}${OFF}"
-
-# Prompt the user for the new release tag
-read -r -p 'Enter a new release tag (vX.X.X format): ' new_tag
-
-# Validate the new release tag
-tag_regex='v[0-9]+\.[0-9]+\.[0-9]+$'
-if echo "$new_tag" | grep -q -E "$tag_regex"; then
-	echo -e "Tag: ${BLUE}$new_tag${OFF} is valid"
-else
-	# Release tag is not `vX.X.X` format
-	echo -e "Tag: ${BLUE}$new_tag${OFF} is ${RED}not valid${OFF} (must be in vX.X.X format)"
-	exit 1
-fi
-
-# Tag the new release
-git tag -a "$new_tag" -m "$new_tag Release"
-echo -e "${GREEN}Tagged: $new_tag${OFF}"
-
-# Push the new tag to the remote
-git push --tags
-echo -e "${GREEN}Release tag pushed to remote${OFF}"
-echo -e "${GREEN}Done!${OFF}"

package/src/cli.ts

@@ -1,94 +0,0 @@
-#!/usr/bin/env node
-
-import { config } from 'dotenv'
-import { server } from './lib/server'
-import { killServer, launchServer } from './lib/server/utils'
-import { logger } from '@rharkor/logger'
-import { ping } from './lib/ping'
-import { serverLogFile } from './lib/constants'
-import { writeFile } from 'fs/promises'
-import { version } from '../package.json'
-
-// Load environment variables from .env file if it exists
-config()
-
-const main = async (): Promise<void> => {
-  await logger.init()
-
-  const args = process.argv.slice(2)
-
-  if (args.includes('--help') || args.includes('-h')) {
-    console.log(`
-Turborepo GitHub Actions Cache Server
-
-Usage:
-  turbogha [options]
-
-Options:
-  --server          Run the server in foreground mode
-  --help, -h        Show this help message
-  --version, -v     Show version
-  --ping            Ping the server
-  --kill            Kill the server
-
-Environment Variables:
-  The following environment variables are supported for S3 configuration:
-  - S3_ACCESS_KEY_ID: AWS S3 access key ID
-  - S3_SECRET_ACCESS_KEY: AWS S3 secret access key  
-  - S3_BUCKET: AWS S3 bucket name
-  - S3_REGION: AWS S3 region
-  - S3_ENDPOINT: S3 endpoint (default: https://s3.amazonaws.com)
-  - S3_PREFIX: Prefix for S3 objects (default: turbogha/)
-  - PROVIDER: Cache provider (github or s3)
-
-Examples:
-  # Run server in background and export environment variables
-  turbogha
-
-  # Run server in foreground mode
-  turbogha --server
-
-  # Ping the server
-  turbogha --ping
-
-  # With S3 configuration
-  S3_ACCESS_KEY_ID=your-key S3_SECRET_ACCESS_KEY=your-secret S3_BUCKET=your-bucket S3_REGION=us-east-1 turbogha
-`)
-    process.exit(0)
-  }
-
-  if (args.includes('--version') || args.includes('-v')) {
-    console.log(version)
-    process.exit(0)
-  }
-
-  try {
-    if (args.includes('--ping')) {
-      await ping()
-    } else if (args.includes('--kill')) {
-      await killServer()
-    } else if (args.includes('--server')) {
-      // Empty log file
-      await writeFile(serverLogFile, '', { flag: 'w' })
-      // Run server in foreground mode
-      console.log('Starting Turborepo cache server in foreground mode...')
-      await server()
-    } else {
-      // Run server in background mode and export environment variables
-      console.log('Starting Turborepo cache server...')
-      // Empty log file
-      await writeFile(serverLogFile, '', { flag: 'w' })
-      await launchServer()
-      console.log(
-        '\nServer is running! You can now use Turbo with remote caching.'
-      )
-      console.log('\nTo stop the server, run:')
-      console.log('curl -X DELETE http://localhost:41230/shutdown')
-    }
-  } catch (error) {
-    console.error('Error:', error)
-    process.exit(1)
-  }
-}
-
-main()

package/src/dev/cleanup.ts

@@ -1,14 +0,0 @@
-import { config } from 'dotenv'
-config()
-
-import { cleanup } from 'src/lib/server/cleanup'
-
-const main = async () => {
-  await cleanup({
-    log: {
-      info: console.log
-    }
-  })
-}
-
-main()

package/src/dev-run.ts

@@ -1,16 +0,0 @@
-// Run the server in foreground and kill it after the test
-
-import { config } from 'dotenv'
-config()
-
-import { server } from './lib/server'
-import { launchServer } from './lib/server/utils'
-
-const main = async (): Promise<void> => {
-  //* Run server
-  server()
-  //* Run launch server
-  await launchServer(true)
-}
-
-main()

package/src/index.ts

@@ -1,6 +0,0 @@
-/**
- * The entrypoint for the action.
- */
-import { run } from './main'
-
-run()

package/src/lib/constants.ts

@@ -1,29 +0,0 @@
-import { join } from 'path'
-import { env } from './env'
-import { core } from './core'
-
-// Helper function to get input value, prioritizing environment variables for local development
-const getInput = (name: string, envName?: string): string | undefined => {
-  // In GitHub Actions context, try core.getInput first
-  if (process.env.CI === 'true') {
-    const coreInput = core.getInput(name)
-    if (coreInput) return coreInput
-  }
-
-  // Fall back to environment variable
-  const envVar = envName || name.toUpperCase().replace(/-/g, '_')
-  return process.env[envVar]
-}
-
-export const serverPort = 41230
-export const cachePath = 'turbogha_'
-export const cachePrefix = getInput('cache-prefix', 'CACHE_PREFIX') || cachePath
-export const getCacheKey = (hash: string, tag?: string): string =>
-  `${cachePrefix}${hash}${tag ? `#${tag}` : ''}`
-export const serverLogFile = env.RUNNER_TEMP
-  ? join(env.RUNNER_TEMP, 'turbogha.log')
-  : '/tmp/turbogha.log'
-export const getFsCachePath = (hash: string): string =>
-  join(env.RUNNER_TEMP || '/tmp', `${hash}.tg.bin`)
-export const getTempCachePath = (key: string): string =>
-  join(env.RUNNER_TEMP || '/tmp', `cache-${key}.tg.bin`)

package/src/lib/core.ts

@@ -1,62 +0,0 @@
-import * as coreLib from '@actions/core'
-import { logger as loggerLib } from '@rharkor/logger'
-
-const isCI = process.env.CI === 'true'
-
-export const core = {
-  isCI,
-  setFailed: (message: string) => {
-    if (isCI) {
-      coreLib.setFailed(message)
-    } else {
-      loggerLib.error(message)
-    }
-  },
-  getInput: (name: string) => {
-    if (isCI) {
-      return coreLib.getInput(name)
-    }
-    return undefined
-  },
-  exportVariable: (name: string, value: string) => {
-    if (isCI) {
-      coreLib.exportVariable(name, value)
-    }
-  },
-  //* Logger
-  info: (message: string) => {
-    if (isCI) {
-      coreLib.info(message)
-    } else {
-      loggerLib.info(message)
-    }
-  },
-  error: (message: string) => {
-    if (isCI) {
-      coreLib.error(message)
-    } else {
-      loggerLib.error(message)
-    }
-  },
-  debug: (message: string) => {
-    if (isCI) {
-      coreLib.debug(message)
-    } else {
-      loggerLib.debug(message)
-    }
-  },
-  log: (message: string) => {
-    if (isCI) {
-      coreLib.info(message)
-    } else {
-      loggerLib.log(message)
-    }
-  },
-  success: (message: string) => {
-    if (isCI) {
-      coreLib.info(message)
-    } else {
-      loggerLib.success(message)
-    }
-  }
-}

package/src/lib/env/index.ts

@@ -1,22 +0,0 @@
-const envObject = {
-  ACTIONS_RUNTIME_TOKEN: process.env.ACTIONS_RUNTIME_TOKEN,
-  ACTIONS_CACHE_URL: process.env.ACTIONS_CACHE_URL,
-  RUNNER_TEMP: process.env.RUNNER_TEMP
-}
-
-type TInvalidEnv = {
-  valid: false
-} & typeof envObject
-
-type TValidEnv = {
-  valid: true
-} & {
-  [K in keyof typeof envObject]: NonNullable<(typeof envObject)[K]>
-}
-
-type TEnv = TInvalidEnv | TValidEnv
-
-export const env = {
-  valid: Object.values(envObject).every(value => value !== undefined),
-  ...envObject
-} as TEnv

package/src/lib/ping.ts

@@ -1,7 +0,0 @@
-import { core } from './core'
-import { waitForServer } from './server/utils'
-
-export const ping = async () => {
-  await waitForServer()
-  core.success('Server is up and running')
-}

package/src/lib/providers/cache/index.ts

@@ -1,87 +0,0 @@
-import { Readable } from 'node:stream'
-import { env } from '../../env'
-import { pipeline } from 'node:stream/promises'
-import {
-  createReadStream,
-  createWriteStream,
-  existsSync,
-  statSync
-} from 'node:fs'
-import { getCacheKey, getFsCachePath, getTempCachePath } from '../../constants'
-import { RequestContext } from '../../server'
-import { TListFile } from '../../server/cleanup'
-import { getCacheClient } from './utils'
-import { TProvider } from '../../providers'
-import { core } from 'src/lib/core'
-
-//* Cache API
-export async function saveCache(
-  ctx: RequestContext,
-  hash: string,
-  tag: string,
-  stream: Readable
-): Promise<void> {
-  if (!env.valid) {
-    ctx.log.info(
-      `Using filesystem cache because cache API env vars are not set`
-    )
-    await pipeline(stream, createWriteStream(getFsCachePath(hash)))
-    return
-  }
-  const client = getCacheClient()
-  const key = getCacheKey(hash, tag)
-  await client.save(key, stream)
-  ctx.log.info(`Saved cache ${key} for ${hash}`)
-}
-
-export async function getCache(
-  ctx: RequestContext,
-  hash: string
-): Promise<
-  [number | undefined, Readable | ReadableStream, string | undefined] | null
-> {
-  //* Get cache from filesystem if cache API env vars are not set
-  if (!env.valid) {
-    const path = getFsCachePath(hash)
-    if (!existsSync(path)) return null
-    const size = statSync(path).size
-    return [size, createReadStream(path), undefined]
-  }
-  //* Get cache from cache API
-  const client = getCacheClient()
-  const cacheKey = getCacheKey(hash)
-  const fileRestorationPath = getTempCachePath(cacheKey)
-  const foundKey = await client.restore(fileRestorationPath, cacheKey)
-  ctx.log.info(`Cache lookup for ${cacheKey}`)
-  if (!foundKey) {
-    ctx.log.info(`Cache lookup did not return data`)
-    return null
-  }
-  const [foundCacheKey, artifactTag] = String(foundKey).split('#')
-  if (foundCacheKey !== cacheKey) {
-    ctx.log.info(`Cache key mismatch: ${foundCacheKey} !== ${cacheKey}`)
-    return null
-  }
-  const size = statSync(fileRestorationPath).size
-  const readableStream = createReadStream(fileRestorationPath)
-  return [size, readableStream, artifactTag]
-}
-
-export async function deleteCache(): Promise<void> {
-  core.error(`Cannot delete github cache automatically.`)
-  throw new Error(`Cannot delete github cache automatically.`)
-}
-
-export async function listCache(): Promise<TListFile[]> {
-  core.error(`Cannot list github cache automatically.`)
-  throw new Error(`Cannot list github cache automatically.`)
-}
-
-export const getGithubProvider = (): TProvider => {
-  return {
-    save: saveCache,
-    get: getCache,
-    delete: deleteCache,
-    list: listCache
-  }
-}

package/src/lib/providers/cache/utils.ts

@@ -1,70 +0,0 @@
-import { Readable } from 'node:stream'
-import { env } from '../../env'
-import streamToPromise from 'stream-to-promise'
-import { createWriteStream } from 'node:fs'
-import { unlink } from 'node:fs/promises'
-import { getTempCachePath } from '../../constants'
-import { restoreCache, saveCache } from '@actions/cache'
-import { core } from 'src/lib/core'
-class HandledError extends Error {
-  status: number
-  statusText: string
-  data: unknown
-  constructor(status: number, statusText: string, data: unknown) {
-    super(`${status}: ${statusText}`)
-    this.status = status
-    this.statusText = statusText
-    this.data = data
-  }
-}
-
-function handleFetchError(message: string) {
-  return (error: unknown) => {
-    if (error instanceof HandledError) {
-      core.error(`${message}: ${error.status} ${error.statusText}`)
-      core.error(JSON.stringify(error.data))
-      throw error
-    }
-    core.error(`${message}: ${error}`)
-    throw error
-  }
-}
-
-export function getCacheClient() {
-  if (!env.valid) {
-    throw new Error('Cache API env vars are not set')
-  }
-
-  const save = async (key: string, stream: Readable): Promise<void> => {
-    try {
-      //* Create a temporary file to store the cache
-      const tempFile = getTempCachePath(key)
-      const writeStream = createWriteStream(tempFile)
-      await streamToPromise(stream.pipe(writeStream))
-      core.info(`Saved cache to ${tempFile}`)
-
-      core.info(`Saving cache for key: ${key}, path: ${tempFile}`)
-      await saveCache([tempFile], key)
-      core.info(`Saved cache ${key}`)
-
-      //* Remove the temporary file
-      await unlink(tempFile)
-    } catch (error) {
-      handleFetchError('Unable to upload cache')(error)
-    }
-  }
-
-  const restore = async (
-    path: string,
-    key: string
-  ): Promise<string | undefined> => {
-    core.info(`Querying cache for key: ${key}, path: ${path}`)
-
-    return restoreCache([path], key, [])
-  }
-
-  return {
-    save,
-    restore
-  }
-}