@metaplay/metaplay-auth 1.4.2 → 1.6.0

package/src/utils.ts

@@ -1,8 +1,8 @@
 import { spawn } from 'child_process'
-
-export function stackApiBaseFromOptions (arg: string, options: Record<string, any>): string {
-  return ''
-}
+import { logger } from './logging.js'
+import path from 'path'
+import yaml from 'js-yaml'
+import * as semver from 'semver'
 
 /**
  * Checks if the given string is a fully qualified domain name (FQDN).
@@ -10,7 +10,7 @@ export function stackApiBaseFromOptions (arg: string, options: Record<string, an
  * @param domain The domain name to check.
  * @returns true if the domain is a valid FQDN, false otherwise.
  */
-export function isValidFQDN (domain: string): boolean {
+export function isValidFQDN(domain: string): boolean {
   const fqdnRegex = /^(?=.{1,253}$)(([a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,})$/
 
   return fqdnRegex.test(domain)
@@ -22,7 +22,12 @@ export function isValidFQDN (domain: string): boolean {
  * @param urlString The HTTP URL string to be split.
  * @returns An object containing the scheme, hostname, port, and subpaths.
  */
-export function splitUrlComponents (urlString: string): { scheme: string, hostname: string, port: string | null, subpaths: string | null } {
+export function splitUrlComponents(urlString: string): {
+  scheme: string
+  hostname: string
+  port: string | null
+  subpaths: string | null
+} {
   try {
     const url = new URL(urlString)
 
@@ -35,51 +40,177 @@ export function splitUrlComponents (urlString: string): { scheme: string, hostna
     const subpaths = url.pathname.slice(1) ?? null
 
     return { scheme, hostname, port, subpaths }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
   } catch (error) {
     throw new Error('Invalid URL')
   }
 }
 
-export function getGameserverAdminUrl (uri: string): string {
-  const parts = uri.split('.')
-
-  const hostname = parts[0]
-  const domain = uri.substring(hostname.length + 1)
-
-  return `${hostname}-admin.${domain}`
-}
-
-interface CommandResult {
-  code: number | null
+export interface ExecuteCommandResult {
+  exitCode: number | null
   stdout: any[]
   stderr: any[]
 }
 
-export async function executeCommand (command: string, args: string[]): Promise<CommandResult> {
+export interface ExecuteCommandOptions {
+  /**
+   * Should the stdin/stdout/stderr be inherited from the parent process? If false, the outputs are buffered for reading later.
+   */
+  inheritStdio?: boolean
+  /**
+   * Environment variables to pass in. Does not inherit parent process env. Use current process env if not specified.
+   */
+  env?: NodeJS.ProcessEnv
+}
+
+/**
+ * Run a child process and return an awaitable Promise.
+ *
+ * @param command Name of the command/binary to execute.
+ * @param args List of arguments to pass to the child process.
+ * @returns Awaitable promise with the result of the execution.
+ */
+export async function executeCommand(
+  command: string,
+  args: string[],
+  options?: { inheritStdio?: boolean; env?: NodeJS.ProcessEnv }
+): Promise<ExecuteCommandResult> {
   return await new Promise((resolve, reject) => {
-    const childProcess = spawn(command, args) //, { stdio: 'inherit' }) -- this pipes stdout & stderr to our output
-    let stdout: any[] = []
-    let stderr: any[] = []
+    const childProcess = spawn(command, args, {
+      stdio: options?.inheritStdio ? 'inherit' : undefined,
+      env: options?.env,
+    })
+    const stdout: string[] = []
+    const stderr: string[] = []
 
-    childProcess.stdout?.on('data', (data) => {
-      stdout += data
+    childProcess.stdout?.on('data', (data: string) => {
+      stdout.push(data)
     })
 
-    childProcess.stderr?.on('data', (data) => {
-      stderr += data
+    childProcess.stderr?.on('data', (data: string) => {
+      stderr.push(data)
     })
 
     // If program runs to completion, resolve promise with success
     childProcess.on('close', (code) => {
-      resolve({ code, stdout, stderr })
+      resolve({ exitCode: code, stdout, stderr })
     })
 
     childProcess.on('error', (err) => {
-      reject(
-        new Error(
-          `Failed to execute command '${command} ${args.join(' ')}': ${err.message}`
-        )
-      )
+      reject(new Error(`Failed to execute command '${command} ${args.join(' ')}': ${err.message}`))
     })
   })
 }
+
+export function isRunningUnderNpx(): boolean {
+  // console.log('process.argv:', process.argv)
+  const matchBinary = (binaryPath: string, binaryName: string): boolean => {
+    const binary = path.basename(binaryPath, path.extname(binaryPath)) // drop path and extension
+    return binary === binaryName
+  }
+
+  // Check if 'npx' is the invoked binary (this check is not sufficient as it can also be 'node')
+  if (matchBinary(process.argv[0], 'npx')) {
+    return true
+  }
+
+  // Check if the script path contains a known npx temporary directory pattern
+  const scriptPath = process.argv[1]
+  if (scriptPath?.includes(`${path.sep}_npx${path.sep}`)) {
+    return true
+  }
+
+  // Check if the environment variable 'npm_execpath' is exactly 'npx'
+  if (process.env.npm_execpath && matchBinary(process.env.npm_execpath, 'npx')) {
+    return true
+  }
+
+  // Check if the environment variable '_' ends with 'npx' (specific to npx usage)
+  if (process.env._ && matchBinary(process.env._, 'npx')) {
+    return true
+  }
+
+  return false
+}
+
+/**
+ * Join a set of path segments and return result with Unix path separators ('/').
+ * @param paths Individual path segments to join
+ * @returns Joined path
+ */
+export function pathJoin(...paths: string[]): string {
+  return path.join(...paths).replaceAll('\\', '/')
+}
+
+/**
+ * Remove a trailing slash from a URL.
+ * @param url URL to remove the trailing slash from.
+ * @returns URL without a trailing slash.
+ */
+export function removeTrailingSlash(url: string): string {
+  return url.replace(/\/+$/, '')
+}
+
+/**
+ * Entry in the Helm chart repository index.
+ */
+interface HelmChartEntry {
+  name: string
+  version: string
+  description?: string
+  apiVersion?: string
+  appVersion?: string
+  urls: string[]
+}
+
+/**
+ * The index of the Helm chart repository. Contains an entry for each of published chart version.
+ */
+interface HelmChartRepoIndex {
+  apiVersion: string
+  entries: Record<string, HelmChartEntry[]>
+  generated: string
+}
+
+/**
+ * Fetch the available versions of a specific Helm chart from a repository.
+ * @param repository URL of the Helm chart repository. No trailing slash allowed.
+ * @param chartName Name of the Helm chart.
+ * @returns List of available Helm chart versions.
+ */
+export async function fetchHelmChartVersions(repository: string, chartName: string): Promise<string[]> {
+  // Fetch the index.yaml file from the repository
+  logger.debug(`Fetching Helm chart versions from '${repository}'...`)
+  const response: Response = await fetch(`${repository}/index.yaml`)
+  const indexYaml: string = await response.text()
+
+  // Parse the YAML index file
+  const repoIndex: HelmChartRepoIndex = yaml.load(indexYaml) as HelmChartRepoIndex
+
+  // Grab all versions >= 0.5.0 -- older are considered legacy
+  const chartVersions = repoIndex.entries[chartName]
+    .map((entry) => entry.version)
+    .filter((version) => semver.gte(version, '0.5.0'))
+  return chartVersions
+}
+
+/**
+ * Resolve the best matching version from a list of versions that satisfy a semver range.
+ * @param versions List of versions to resolve from.
+ * @param range Semver range to satisfy.
+ * @returns The best (latest) matching version or null if no versions satisfy the range.
+ */
+export function resolveBestMatchingVersion(versions: string[], range: semver.Range | null): string | null {
+  // Filter versions that satisfy the range -- range==null means 'latest' == include all versions
+  const satisfyingVersions = range ? versions.filter((version) => semver.satisfies(version, range)) : versions
+  logger.debug(`Satisfying versions: ${satisfyingVersions.join(', ')}`)
+
+  // If no versions satisfy the range, return null
+  if (satisfyingVersions.length === 0) {
+    return null
+  }
+
+  // Sort the versions to get the highest one that matches the range
+  const sortedVersions = satisfyingVersions.sort(semver.rcompare)
+  return sortedVersions[0]
+}

package/src/version.ts

@@ -0,0 +1 @@
+export const PACKAGE_VERSION = "1.6.0"