@tothalex/nulljs 0.0.48 → 0.0.54

package/src/lib/deployment.ts

@@ -1,244 +0,0 @@
-import { basename } from 'path'
-import { existsSync, readFileSync, writeFileSync } from 'fs'
-import { join } from 'path'
-import { build } from 'vite'
-import { createHash } from 'crypto'
-import type { OutputAsset, OutputChunk, RollupOutput } from 'rollup'
-import chalk from 'chalk'
-
-import { functionConfig, spaClientConfig, ssrConfigConfig } from './bundle'
-import { createDeployment } from './api'
-import { getCloudPath } from './config'
-
-export const isReact = (file: string) => file.endsWith('.tsx')
-export const isAsset = (file: string) => file.endsWith('.css')
-export const isTypescript = (file: string) => file.endsWith('.ts')
-export const isJavaScript = (file: string) => file.endsWith('.js')
-export const getFileName = (path: string) => basename(path)
-
-export const isOutputAsset = (output: OutputAsset | OutputChunk): output is OutputAsset => {
-  return output.type === 'asset'
-}
-
-export const isOutputChunk = (output: OutputAsset | OutputChunk): output is OutputChunk => {
-  return output.type === 'chunk'
-}
-
-export type DeploymentType = 'react' | 'function'
-
-export type Deployment = {
-  name: string
-  type: DeploymentType
-  assets: Array<{
-    fileName: string
-    code: string
-  }>
-}
-
-// Persistent cache utilities
-const getCachePath = (): string => {
-  const nulljsPath = getCloudPath()
-  return join(nulljsPath, 'deployment-cache.json')
-}
-
-const loadDeploymentCache = (): Map<string, string> => {
-  const cachePath = getCachePath()
-
-  if (!existsSync(cachePath)) {
-    return new Map()
-  }
-
-  try {
-    const cacheContent = readFileSync(cachePath, 'utf-8')
-    const cacheObject = JSON.parse(cacheContent)
-    return new Map(Object.entries(cacheObject))
-  } catch {
-    // If cache is corrupted, start fresh
-    return new Map()
-  }
-}
-
-const saveDeploymentCache = (cache: Map<string, string>): void => {
-  const cachePath = getCachePath()
-  const nulljsPath = getCloudPath()
-
-  // Ensure .nulljs directory exists
-  if (!existsSync(nulljsPath)) {
-    require('fs').mkdirSync(nulljsPath, { recursive: true })
-  }
-
-  const cacheObject = Object.fromEntries(cache)
-  writeFileSync(cachePath, JSON.stringify(cacheObject, null, 2), 'utf-8')
-}
-
-// Load cache on startup
-let deploymentHashCache = loadDeploymentCache()
-
-const generateDeploymentHash = (deployment: Deployment): string => {
-  const assetsString = deployment.assets
-    .map((asset) => `${asset.fileName}:${asset.code}`)
-    .sort()
-    .join('|')
-
-  return createHash('sha256').update(assetsString).digest('hex')
-}
-
-const getCachedHash = (deploymentName: string, type: DeploymentType): string | null => {
-  const cacheKey = `${type}-${deploymentName}`
-  return deploymentHashCache.get(cacheKey) || null
-}
-
-const saveCachedHash = (deploymentName: string, type: DeploymentType, hash: string): void => {
-  const cacheKey = `${type}-${deploymentName}`
-  deploymentHashCache.set(cacheKey, hash)
-  saveDeploymentCache(deploymentHashCache)
-}
-
-const hasDeploymentChanged = (
-  deployment: Deployment,
-  force: boolean = false,
-  logger: any = console
-): boolean => {
-  if (force) {
-    logger.log(`Force flag set for ${deployment.name}, deploying...`)
-    return true
-  }
-
-  const currentHash = generateDeploymentHash(deployment)
-  const cachedHash = getCachedHash(deployment.name, deployment.type)
-
-  if (!cachedHash) {
-    logger.log(`No cached build found for ${deployment.name}, deploying...`)
-    return true
-  }
-
-  const hasChanged = currentHash !== cachedHash
-
-  if (hasChanged) {
-    logger.log(`Build changed for ${deployment.name}, deploying...`)
-  } else {
-    logger.log(`No changes detected for ${deployment.name}, skipping deployment`)
-  }
-
-  return hasChanged
-}
-
-export type DeploymentResult = {
-  deployed: boolean
-  cached: boolean
-  error?: Error
-}
-
-export const deployFunction = async (
-  path: string,
-  logger: any = console,
-  force: boolean = false
-): Promise<DeploymentResult> => {
-  const file = basename(path)
-
-  const deployment: Deployment = {
-    name: file,
-    type: 'function',
-    assets: []
-  }
-
-  try {
-    const functionBuild = (await build(functionConfig(path))) as RollupOutput
-
-    const handler = functionBuild.output.find(
-      (output) => output.fileName === 'handler.js'
-    ) as OutputChunk
-
-    if (!handler) {
-      logger.log(chalk.yellow(`Handler not found for ${deployment.name}`))
-      return { deployed: false, cached: false, error: new Error('Handler not found') }
-    }
-
-    deployment.assets.push({
-      fileName: handler.fileName,
-      code: handler.code
-    })
-
-    if (!hasDeploymentChanged(deployment, force, logger)) {
-      return { deployed: false, cached: true }
-    }
-
-    await createDeployment(deployment, logger)
-
-    const hash = generateDeploymentHash(deployment)
-    saveCachedHash(deployment.name, deployment.type, hash)
-
-    return { deployed: true, cached: false }
-  } catch (error) {
-    logger.error ? logger.error(error) : logger.log(`Error: ${error}`)
-    return { deployed: false, cached: false, error: error as Error }
-  }
-}
-
-export const deployPage = async (path: string) => {
-  const file = basename(path)
-
-  const deployment: Deployment = {
-    name: file,
-    type: 'react',
-    assets: []
-  }
-
-  // const serverBuild = (await build(ssrServerConfig(path))) as RollupOutput
-  // const server = serverBuild.output.pop() as OutputChunk
-  //
-  // deployment.assets.push({
-  //   fileName: 'server.js',
-  //   code: server.code
-  // })
-
-  const configBuild = (await build(ssrConfigConfig(path))) as RollupOutput
-  const config = configBuild.output.pop() as OutputChunk
-
-  deployment.assets.push({
-    fileName: 'config.js',
-    code: config.code
-  })
-
-  // const propsBuild = (await build(ssrPropsConfig(path))) as RollupOutput
-  // const props = propsBuild.output.pop() as OutputChunk
-  //
-  // deployment.assets.push({
-  //   fileName: 'props.js',
-  //   code: props.code
-  // })
-
-  const clientConfig = spaClientConfig(path)
-  const clientBuild = (await build(clientConfig)) as RollupOutput
-
-  for (const clientAsset of clientBuild.output) {
-    const fileName = getFileName(clientAsset.fileName)
-
-    if (isOutputChunk(clientAsset)) {
-      deployment.assets.push({
-        fileName,
-        code: clientAsset.code
-      })
-    }
-
-    if (isOutputAsset(clientAsset)) {
-      deployment.assets.push({
-        fileName,
-        code: clientAsset.source as string
-      })
-    }
-  }
-
-  if (!hasDeploymentChanged(deployment)) {
-    return // Skip deployment if no changes
-  }
-
-  try {
-    await createDeployment(deployment)
-    const hash = generateDeploymentHash(deployment)
-    saveCachedHash(deployment.name, deployment.type, hash)
-  } catch (error) {
-    console.error(error)
-    throw error // Re-throw the error so it propagates to the caller
-  }
-}

package/src/lib/update-server.ts

@@ -1,262 +0,0 @@
-import { existsSync, createWriteStream, chmodSync, unlinkSync, mkdirSync } from 'node:fs'
-import { join, dirname } from 'node:path'
-import { fileURLToPath } from 'node:url'
-import https from 'node:https'
-import * as tar from 'tar'
-import chalk from 'chalk'
-
-// --- Configuration ---
-const S3_BASE_URL = 'https://nulljs.s3.eu-north-1.amazonaws.com'
-const S3_PREFIX = 'releases/'
-const DOWNLOAD_BASE_URL = `${S3_BASE_URL}/${S3_PREFIX}`
-// ---------------------
-
-interface PlatformInfo {
-  target: string
-  extension: string
-  binaryName: string
-}
-
-interface S3DownloadInfo {
-  downloadUrl: string
-  version: string
-}
-
-// --- Core Helper Functions (Unchanged) ---
-
-function getPlatformInfo(): PlatformInfo {
-  const platform = process.platform
-  const arch = process.arch
-
-  const platformMap: Record<string, Record<string, string>> = {
-    linux: {
-      x64: 'x86_64-unknown-linux-gnu',
-      arm64: 'aarch64-unknown-linux-gnu'
-    },
-    darwin: {
-      x64: 'x86_64-apple-darwin',
-      arm64: 'aarch64-apple-darwin'
-    }
-  }
-
-  const target = platformMap[platform]?.[arch]
-  if (!target) {
-    throw new Error(`Unsupported platform: ${platform}-${arch}`)
-  }
-
-  const extension = '.tar.gz'
-  const binaryName = 'server'
-
-  return { target, extension, binaryName }
-}
-
-async function downloadFile(url: string, destination: string): Promise<void> {
-  return new Promise((resolve, reject) => {
-    const file = createWriteStream(destination)
-
-    https
-      .get(url, (response) => {
-        if (response.statusCode === 302 || response.statusCode === 301) {
-          // Handle redirect
-          return downloadFile(response.headers.location!, destination).then(resolve).catch(reject)
-        }
-
-        if (response.statusCode !== 200) {
-          reject(new Error(`Failed to download: ${response.statusCode}`))
-          return
-        }
-
-        response.pipe(file)
-
-        file.on('finish', () => {
-          file.close()
-          resolve()
-        })
-
-        file.on('error', reject)
-      })
-      .on('error', reject)
-  })
-}
-
-async function extractArchive(
-  archivePath: string,
-  extractPath: string,
-  binaryName: string
-): Promise<void> {
-  // Extract tar.gz
-  await tar.x({
-    file: archivePath,
-    cwd: extractPath
-  })
-
-  // Make binary executable
-  const binaryPath = join(extractPath, binaryName)
-  chmodSync(binaryPath, '755')
-}
-
-function getServerBinPath(): string {
-  // Try to find the server binary relative to this module
-  const currentFile = fileURLToPath(import.meta.url)
-  const moduleRoot = join(dirname(currentFile), '../..')
-  return join(moduleRoot, 'bin', 'server')
-}
-
-// --- S3 LISTING Functions (New) ---
-
-/**
- * Fetches the raw XML listing from S3.
- */
-async function fetchXml(url: string): Promise<string> {
-  return new Promise((resolve, reject) => {
-    https
-      .get(url, (res) => {
-        if (res.statusCode !== 200) {
-          // This likely indicates a 403 Access Denied error
-          reject(
-            new Error(`S3 Request Failed (${res.statusCode}): Check public 's3:ListBucket' policy.`)
-          )
-          return
-        }
-        let data = ''
-        res.on('data', (chunk) => (data += chunk))
-        res.on('end', () => resolve(data))
-      })
-      .on('error', reject)
-  })
-}
-
-/**
- * Lists the S3 prefix, parses the XML, and determines the latest version tag.
- */
-async function getLatestVersionFromS3(target: string, extension: string): Promise<S3DownloadInfo> {
-  // Query S3 for folders using delimiter and prefix
-  const listUrl = `${S3_BASE_URL}/?delimiter=/&prefix=${S3_PREFIX}`
-  const xmlData = await fetchXml(listUrl)
-
-  // Regex to find all CommonPrefixes entries (the version folders)
-  // Example: <Prefix>releases/v1.0.0/</Prefix>
-  const prefixRegex = /<Prefix>(releases\/v[^<]+)\/<\/Prefix>/g
-  const versionFolders: string[] = []
-  let match: RegExpExecArray | null
-
-  while ((match = prefixRegex.exec(xmlData)) !== null) {
-    // Extract version part: "releases/v1.0.0/" -> "v1.0.0"
-    const fullPrefix = match[1]
-    const version = fullPrefix.substring(S3_PREFIX.length)
-    versionFolders.push(version)
-  }
-
-  if (versionFolders.length === 0) {
-    throw new Error('No version folders found in S3 bucket. Has the CI/CD run?')
-  }
-
-  // Sort versions to find the latest (using semantic versioning logic)
-  const sortedVersions = versionFolders.sort((a, b) => {
-    // Strips 'v', splits by '.', and converts to number arrays for comparison
-    const aParts = a.replace('v', '').split('.').map(Number)
-    const bParts = b.replace('v', '').split('.').map(Number)
-
-    // Compare major, minor, and patch numbers (assuming vX.Y.Z)
-    for (let i = 0; i < 3; i++) {
-      if (aParts[i] > bParts[i]) return 1
-      if (aParts[i] < bParts[i]) return -1
-    }
-    return 0
-  })
-
-  // The latest version is the last one after sorting
-  const latestVersion = sortedVersions[sortedVersions.length - 1]
-
-  // Construct the full download URL
-  const downloadUrl = `${DOWNLOAD_BASE_URL}${latestVersion}/nulljs-server-${target}${extension}`
-
-  return { downloadUrl, version: latestVersion }
-}
-
-// --- Main Update Function (Modified) ---
-
-export async function updateServer(): Promise<void> {
-  try {
-    console.log(chalk.blue('🔄 Updating nulljs server binary...'))
-
-    const { target, extension, binaryName } = getPlatformInfo()
-
-    const serverBinPath = getServerBinPath()
-    const binDir = dirname(serverBinPath)
-    const archivePath = join(binDir, `server${extension}`)
-    const backupPath = join(binDir, 'server.backup')
-
-    // Create bin directory if it doesn't exist
-    if (!existsSync(binDir)) {
-      mkdirSync(binDir, { recursive: true })
-    }
-
-    // Backup existing binary if it exists
-    if (existsSync(serverBinPath)) {
-      console.log(chalk.blue('💾 Backing up existing binary...'))
-
-      if (existsSync(backupPath)) {
-        unlinkSync(backupPath)
-      }
-
-      const fs = await import('node:fs/promises')
-      await fs.copyFile(serverBinPath, backupPath)
-      console.log(chalk.green('✅ Backup created'))
-    }
-
-    console.log(chalk.blue(`🔍 Searching for latest server version...`))
-
-    // 1. Get download URL and version from S3 listing (NEW LOGIC)
-    const { downloadUrl, version } = await getLatestVersionFromS3(target, extension)
-    console.log(chalk.blue(`   Found latest version: ${version} for ${target}`))
-    console.log(chalk.blue(`   Downloading from: ${downloadUrl}`))
-
-    try {
-      // Download the archive
-      await downloadFile(downloadUrl, archivePath)
-      console.log(chalk.green('✅ Download completed'))
-
-      // Remove existing binary before extracting new one
-      if (existsSync(serverBinPath)) {
-        unlinkSync(serverBinPath)
-      }
-
-      // Extract the binary
-      console.log(chalk.blue('📂 Extracting binary...'))
-      await extractArchive(archivePath, binDir, binaryName)
-
-      // Clean up archive
-      unlinkSync(archivePath)
-
-      // Remove backup since update was successful
-      if (existsSync(backupPath)) {
-        unlinkSync(backupPath)
-      }
-
-      console.log(chalk.green('✅ nulljs server updated successfully'))
-    } catch (error) {
-      // If update failed and we have a backup, restore it
-      if (existsSync(backupPath)) {
-        console.log(chalk.yellow('⚠️ Update failed, restoring backup...'))
-
-        if (existsSync(serverBinPath)) {
-          unlinkSync(serverBinPath)
-        }
-
-        const fs = await import('node:fs/promises')
-        await fs.copyFile(backupPath, serverBinPath)
-        unlinkSync(backupPath)
-
-        console.log(chalk.green('✅ Backup restored'))
-      }
-
-      throw error
-    }
-  } catch (error) {
-    // Ensure the error message is available if it's not a standard Error object
-    const errorMessage = error instanceof Error ? error.message : String(error)
-    console.error(chalk.red('❌ Failed to update server binary:'), errorMessage)
-    throw error
-  }
-}