@tothalex/nulljs 0.0.53 → 0.0.54

package/src/lib/deploy.ts

@@ -1,103 +0,0 @@
-import { basename } from 'path'
-import { build, type Rollup } from 'vite'
-import { createFunctionDeployment, createReactDeployment } from '@nulljs/api'
-
-import { functionConfig, spaClientConfig, spaConfigConfig } from './bundle'
-
-// Cache of file path -> hash of last deployed bundle
-const deployedHashes = new Map<string, string>()
-
-export const clearDeployCache = () => {
-  deployedHashes.clear()
-}
-
-const hashCode = (code: string): string => {
-  return Bun.hash(code).toString(16)
-}
-
-export type DeployResult = {
-  deployed: boolean
-  skipped: boolean
-}
-
-export const deployFunction = async (
-  filePath: string,
-  privateKey: CryptoKey,
-  apiUrl: string
-): Promise<DeployResult> => {
-  const fileName = basename(filePath)
-
-  const result = (await build(functionConfig(filePath))) as Rollup.RollupOutput
-
-  const handler = result.output.find(
-    (output): output is Rollup.OutputChunk =>
-      output.type === 'chunk' && output.fileName === 'handler.js'
-  )
-
-  if (!handler) {
-    throw new Error('Bundle failed: handler.js not found in output')
-  }
-
-  const hash = hashCode(handler.code)
-  const lastHash = deployedHashes.get(filePath)
-
-  if (lastHash === hash) {
-    return { deployed: false, skipped: true }
-  }
-
-  await createFunctionDeployment(
-    { name: fileName, assets: [{ fileName: 'handler.js', code: handler.code }] },
-    { privateKey, url: apiUrl }
-  )
-
-  deployedHashes.set(filePath, hash)
-  return { deployed: true, skipped: false }
-}
-
-export const deployReact = async (
-  filePath: string,
-  privateKey: CryptoKey,
-  apiUrl: string
-): Promise<DeployResult> => {
-  const fileName = basename(filePath)
-
-  // Build config.js file first
-  const configResult = (await build(spaConfigConfig(filePath))) as Rollup.RollupOutput
-  const configOutput = configResult.output.find(
-    (output): output is Rollup.OutputChunk =>
-      output.type === 'chunk' && output.fileName === 'index.js'
-  )
-
-  if (!configOutput) {
-    throw new Error('Config build failed: config file not found in output')
-  }
-
-  // Build client assets
-  const result = (await build(spaClientConfig(filePath))) as Rollup.RollupOutput
-  const assets: Array<{ fileName: string; code: string }> = []
-
-  // Add config.js first (required by backend)
-  assets.push({ fileName: 'config.js', code: configOutput.code })
-
-  for (const output of result.output) {
-    if (output.type === 'chunk') {
-      assets.push({ fileName: output.fileName, code: output.code })
-    } else if (output.type === 'asset' && typeof output.source === 'string') {
-      assets.push({ fileName: output.fileName, code: output.source })
-    }
-  }
-
-  // Hash all assets combined
-  const combinedCode = assets.map((a) => a.code).join('')
-  const hash = hashCode(combinedCode)
-  const lastHash = deployedHashes.get(filePath)
-
-  if (lastHash === hash) {
-    return { deployed: false, skipped: true }
-  }
-
-  await createReactDeployment({ name: fileName, assets }, { privateKey, url: apiUrl })
-
-  deployedHashes.set(filePath, hash)
-  return { deployed: true, skipped: false }
-}

package/src/lib/server.ts

@@ -1,160 +0,0 @@
-import { existsSync, mkdirSync, realpathSync } from 'fs'
-import { join, dirname } from 'path'
-import chalk from 'chalk'
-import { getOrCreateLocalDevConfig } from '../config'
-
-const CLI_DIR = dirname(realpathSync(import.meta.dir))
-
-type PlatformKey = 'linux-x64' | 'linux-arm64' | 'darwin-arm64'
-
-export type BinarySource = 'local-debug' | 'local-release' | 'local-env' | 'npm'
-
-export type ServerInfo = {
-  process: ReturnType<typeof Bun.spawn>
-  binarySource: BinarySource
-  binaryPath: string
-}
-
-const PLATFORMS: Record<PlatformKey, string> = {
-  'linux-x64': '@tothalex/nulljs-linux-x64',
-  'linux-arm64': '@tothalex/nulljs-linux-arm64',
-  'darwin-arm64': '@tothalex/nulljs-darwin-arm64'
-}
-
-const getPlatformKey = (): string => {
-  return `${process.platform}-${process.arch}`
-}
-
-const findProjectRoot = (startPath: string = process.cwd()): string => {
-  let currentPath = startPath
-  while (currentPath !== dirname(currentPath)) {
-    if (existsSync(join(currentPath, 'package.json'))) {
-      return currentPath
-    }
-    currentPath = dirname(currentPath)
-  }
-  return startPath
-}
-
-const findMonorepoRoot = (startPath: string = process.cwd()): string | null => {
-  let currentPath = startPath
-  while (currentPath !== dirname(currentPath)) {
-    if (
-      existsSync(join(currentPath, 'Cargo.toml')) &&
-      existsSync(join(currentPath, 'package.json'))
-    ) {
-      return currentPath
-    }
-    currentPath = dirname(currentPath)
-  }
-  return null
-}
-
-const getLocalBinaryPath = (): { path: string; source: BinarySource } | null => {
-  const envBinary = process.env.NULLJS_SERVER_BINARY
-  if (envBinary && existsSync(envBinary)) {
-    return { path: envBinary, source: 'local-env' }
-  }
-
-  // Check from cwd first, then from CLI package location (for bun link)
-  const monorepoRoot = findMonorepoRoot() || findMonorepoRoot(CLI_DIR)
-  if (monorepoRoot) {
-    const debugBinary = join(monorepoRoot, 'target', 'debug', 'server')
-    if (existsSync(debugBinary)) {
-      return { path: debugBinary, source: 'local-debug' }
-    }
-    const releaseBinary = join(monorepoRoot, 'target', 'release', 'server')
-    if (existsSync(releaseBinary)) {
-      return { path: releaseBinary, source: 'local-release' }
-    }
-  }
-
-  return null
-}
-
-// Removed getCloudPath as we now use unique paths per project
-
-const waitForServer = async (port: number, maxRetries = 30, delayMs = 1000): Promise<void> => {
-  for (let i = 0; i < maxRetries; i++) {
-    try {
-      const response = await fetch(`http://localhost:${port}/api/health`)
-      if (response.ok) {
-        return
-      }
-    } catch {}
-    await new Promise((resolve) => setTimeout(resolve, delayMs))
-  }
-  throw new Error(`Server did not start within ${(maxRetries * delayMs) / 1000}s`)
-}
-
-const buildDevArgs = async (): Promise<string[]> => {
-  // Use project-local config (creates one if it doesn't exist)
-  const devConfig = await getOrCreateLocalDevConfig()
-
-  const args = ['--dev']
-  args.push('--api-port', '3000')
-  args.push('--gateway-port', '3001')
-
-  // Use the project's .nulljs directory for cloud storage
-  const projectRoot = findProjectRoot()
-  const cloudPath = join(projectRoot, '.nulljs')
-  args.push('--cloud-path', cloudPath)
-
-  if (!existsSync(cloudPath)) {
-    mkdirSync(cloudPath, { recursive: true })
-  }
-
-  args.push('--public-key', devConfig.key.public)
-
-  return args
-}
-
-export const startServer = async (): Promise<ServerInfo> => {
-  const localBinary = getLocalBinaryPath()
-  let binaryPath: string
-  let binarySource: BinarySource
-
-  if (localBinary) {
-    console.log(chalk.cyan(`Using local binary: ${localBinary.path}`))
-    binaryPath = localBinary.path
-    binarySource = localBinary.source
-  } else {
-    const platformKey = getPlatformKey()
-    const pkgName = PLATFORMS[platformKey as PlatformKey]
-
-    if (!pkgName) {
-      console.error(chalk.red(`✗ Unsupported platform: ${platformKey}`))
-      throw new Error(`Unsupported platform: ${platformKey}`)
-    }
-
-    binaryPath = require.resolve(`${pkgName}/bin/server`)
-    binarySource = 'npm'
-    console.log(chalk.cyan(`Using npm binary: ${pkgName}`))
-  }
-
-  try {
-    const args = await buildDevArgs()
-
-    console.log(chalk.yellow(`Starting server with args: ${args.join(' ')}`))
-
-    const proc = Bun.spawn([binaryPath, ...args], {
-      stdout: 'ignore',
-      stderr: 'ignore'
-    })
-
-    console.log(chalk.green('✓ Server process started, waiting for server to be ready...'))
-
-    await waitForServer(3000)
-
-    console.log(chalk.green('✓ Server is ready'))
-
-    return { process: proc, binarySource, binaryPath }
-  } catch (error) {
-    console.error(
-      chalk.red(
-        `✗ Failed to start server: ${error instanceof Error ? error.message : String(error)}`
-      )
-    )
-    throw error
-  }
-}

package/src/lib/vite.ts

@@ -1,120 +0,0 @@
-import { createServer, type ViteDevServer, type Logger } from 'vite'
-import { dirname, resolve, basename } from 'path'
-import react from '@vitejs/plugin-react'
-import tailwindcss from '@tailwindcss/vite'
-import { writeFile, unlink } from 'node:fs/promises'
-import { existsSync } from 'node:fs'
-
-const VITE_PORT = 5173
-const GATEWAY_PORT = 3001
-
-type ViteServerInfo = {
-  server: ViteDevServer
-  indexHtmlPath: string
-}
-
-const createViteLogger = (onLog?: (msg: string, level: string) => void): Logger => {
-  return {
-    info: (msg) => onLog?.(msg, 'info'),
-    warn: (msg) => onLog?.(msg, 'warn'),
-    warnOnce: (msg) => onLog?.(msg, 'warn'),
-    error: (msg) => onLog?.(msg, 'error'),
-    clearScreen: () => {},
-    hasErrorLogged: () => false,
-    hasWarned: false
-  }
-}
-
-const createTempIndexHtml = (componentPath: string, projectRoot: string): string => {
-  const relativePath = resolve(componentPath).replace(projectRoot + '/', '')
-  const componentName = basename(componentPath, '.tsx')
-
-  return `<!DOCTYPE html>
-<html lang="en">
-  <head>
-    <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>${componentName} - Dev Mode</title>
-    <style>
-      * { box-sizing: border-box; }
-      body { margin: 0; padding: 0; font-family: system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif; }
-      #root { min-height: 100vh; }
-    </style>
-  </head>
-  <body>
-    <div id="root"></div>
-    <script type="module">
-      import React from 'react'
-      import ReactDOM from 'react-dom/client'
-      import { Page } from '/${relativePath}'
-
-      const root = ReactDOM.createRoot(document.getElementById('root'))
-      root.render(
-        React.createElement(React.StrictMode, null,
-          React.createElement(Page)
-        )
-      )
-    </script>
-  </body>
-</html>`
-}
-
-export const startViteServer = async (options: {
-  srcDir: string
-  onLog?: (msg: string, level: string) => void
-}): Promise<ViteServerInfo | null> => {
-  const indexTsxPath = resolve(options.srcDir, 'index.tsx')
-
-  if (!existsSync(indexTsxPath)) {
-    return null
-  }
-
-  const projectDir = dirname(options.srcDir)
-  const tempIndexPath = resolve(projectDir, 'index.html')
-
-  try {
-    const indexHtml = createTempIndexHtml(indexTsxPath, projectDir)
-    await writeFile(tempIndexPath, indexHtml)
-
-    const server = await createServer({
-      root: projectDir,
-      plugins: [react(), tailwindcss()],
-      customLogger: createViteLogger(options.onLog),
-      server: {
-        port: VITE_PORT,
-        host: true,
-        proxy: {
-          '/api': {
-            target: `http://localhost:${GATEWAY_PORT}`,
-            changeOrigin: true,
-            secure: false
-          },
-          '/assets': {
-            target: `http://localhost:${GATEWAY_PORT}`,
-            changeOrigin: true,
-            secure: false
-          }
-        }
-      }
-    })
-
-    await server.listen()
-    options.onLog?.(`Vite server started on http://localhost:${VITE_PORT}`, 'info')
-
-    return { server, indexHtmlPath: tempIndexPath }
-  } catch (error) {
-    options.onLog?.(`Failed to start Vite: ${error}`, 'error')
-    return null
-  }
-}
-
-export const stopViteServer = async (info: ViteServerInfo): Promise<void> => {
-  await info.server.close()
-
-  // Clean up temp index.html
-  try {
-    await unlink(info.indexHtmlPath)
-  } catch {
-    // Ignore if file doesn't exist
-  }
-}

package/src/lib/watcher.ts

@@ -1,274 +0,0 @@
-import { watch, existsSync } from 'fs'
-import { readdir } from 'fs/promises'
-import { join } from 'path'
-import { build, type Rollup } from 'vite'
-
-import { readLocalConfig, loadPrivateKey } from '../config'
-import { functionWatchConfig, type FunctionEntry, type BuildResult } from './bundle'
-import { createFunctionDeployment } from '@nulljs/api'
-
-export type DeployResult = {
-  name: string
-  success: boolean
-  skipped: boolean
-  error?: string
-}
-
-export type WatcherOptions = {
-  silent?: boolean
-  onDeploy?: (filePath: string, success: boolean, skipped: boolean, error?: string) => void
-  onDeployBatch?: (results: DeployResult[]) => void
-  onReady?: (functionCount: number) => void
-}
-
-const FUNCTION_DIRS = ['api', 'cron', 'event'] as const
-
-// Cache of entry name -> hash of last deployed bundle
-const deployedHashes = new Map<string, string>()
-
-const hashCode = (code: string): string => {
-  return Bun.hash(code).toString(16)
-}
-
-const findFunctionEntries = async (functionsPath: string): Promise<FunctionEntry[]> => {
-  const entries: FunctionEntry[] = []
-
-  for (const dir of FUNCTION_DIRS) {
-    const dirPath = join(functionsPath, dir)
-
-    try {
-      const items = await readdir(dirPath, { withFileTypes: true })
-
-      for (const item of items) {
-        if (item.isFile() && (item.name.endsWith('.ts') || item.name.endsWith('.tsx'))) {
-          const fullPath = join(dirPath, item.name)
-          const name = `${dir}/${item.name.replace(/\.tsx?$/, '')}`
-
-          entries.push({
-            name,
-            path: fullPath,
-            type: dir
-          })
-        }
-      }
-    } catch {
-      // Directory doesn't exist, skip
-    }
-  }
-
-  return entries
-}
-
-export const startWatcher = async (
-  srcPath: string,
-  options: WatcherOptions = {}
-): Promise<() => void> => {
-  const { silent = false, onDeploy, onDeployBatch, onReady } = options
-  const config = readLocalConfig()
-
-  if (!config) {
-    if (!silent) console.error('No local configuration found. Run "nulljs dev" first.')
-    return () => {}
-  }
-
-  const functionsPath = join(srcPath, 'function')
-  let entries = await findFunctionEntries(functionsPath)
-  let viteWatcher: Rollup.RollupWatcher | null = null
-  let isRestarting = false
-
-  onReady?.(entries.length)
-
-  const privateKey = await loadPrivateKey(config)
-
-  const deployBatch = async (builds: BuildResult[]): Promise<DeployResult[]> => {
-    const results: DeployResult[] = []
-
-    for (const { entry, code } of builds) {
-      const hash = hashCode(code)
-      const lastHash = deployedHashes.get(entry.name)
-
-      if (lastHash === hash) {
-        // Skip unchanged - don't include in results
-        continue
-      }
-
-      try {
-        await createFunctionDeployment(
-          {
-            name: `${entry.name}.ts`,
-            assets: [{ fileName: 'handler.js', code }]
-          },
-          { privateKey, url: config.api }
-        )
-        deployedHashes.set(entry.name, hash)
-        results.push({ name: entry.name, success: true, skipped: false })
-      } catch (error) {
-        results.push({
-          name: entry.name,
-          success: false,
-          skipped: false,
-          error: error instanceof Error ? error.message : String(error)
-        })
-      }
-    }
-
-    return results
-  }
-
-  const startViteWatcher = async () => {
-    if (entries.length === 0) {
-      return null
-    }
-
-    const result = await build(
-      functionWatchConfig(entries, {
-        onBuildComplete: async (builds) => {
-          const results = await deployBatch(builds)
-
-          // Only notify if there were actual deploys
-          if (results.length > 0) {
-            onDeployBatch?.(results)
-
-            // Also call individual onDeploy for backwards compatibility
-            for (const r of results) {
-              onDeploy?.(r.name, r.success, r.skipped, r.error)
-            }
-          }
-        }
-      })
-    )
-
-    // In watch mode, build() returns a RollupWatcher
-    if ('on' in result) {
-      return result as Rollup.RollupWatcher
-    }
-
-    return null
-  }
-
-  const restartViteWatcher = async () => {
-    if (isRestarting) return
-    isRestarting = true
-
-    try {
-      if (viteWatcher) {
-        await viteWatcher.close()
-        viteWatcher = null
-      }
-
-      entries = await findFunctionEntries(functionsPath)
-      onReady?.(entries.length)
-
-      viteWatcher = await startViteWatcher()
-    } finally {
-      isRestarting = false
-    }
-  }
-
-  // Start initial Vite watcher
-  viteWatcher = await startViteWatcher()
-
-  // Watch function directories for new files (additions/deletions)
-  const dirWatchers: ReturnType<typeof watch>[] = []
-
-  for (const dir of FUNCTION_DIRS) {
-    const dirPath = join(functionsPath, dir)
-
-    if (!existsSync(dirPath)) continue
-
-    try {
-      const watcher = watch(dirPath, async (eventType, filename) => {
-        if (!filename) return
-        if (!filename.endsWith('.ts') && !filename.endsWith('.tsx')) return
-
-        // Check if this is a new or deleted file
-        const fullPath = join(dirPath, filename)
-        const entryName = `${dir}/${filename.replace(/\.tsx?$/, '')}`
-        const existingEntry = entries.find((e) => e.name === entryName)
-        const fileExists = existsSync(fullPath)
-
-        if ((!existingEntry && fileExists) || (existingEntry && !fileExists)) {
-          // New file added or file deleted - restart Vite watcher
-          await restartViteWatcher()
-        }
-      })
-
-      dirWatchers.push(watcher)
-    } catch {
-      // Directory can't be watched
-    }
-  }
-
-  // Return cleanup function
-  return () => {
-    for (const watcher of dirWatchers) {
-      watcher.close()
-    }
-    if (viteWatcher) {
-      viteWatcher.close()
-    }
-  }
-}
-
-export type ForceDeployOptions = {
-  onDeploy?: (filePath: string, success: boolean, error?: string) => void
-  onComplete?: (total: number, successful: number, failed: number) => void
-}
-
-export const forceDeployAll = async (
-  srcPath: string,
-  options: ForceDeployOptions = {}
-): Promise<void> => {
-  const { onDeploy, onComplete } = options
-  const config = readLocalConfig()
-
-  if (!config) {
-    throw new Error('No local configuration found. Run "nulljs dev" first.')
-  }
-
-  const privateKey = await loadPrivateKey(config)
-
-  // Clear the deploy cache to force re-deploy
-  deployedHashes.clear()
-
-  const functionsPath = join(srcPath, 'function')
-  const entries = await findFunctionEntries(functionsPath)
-
-  // React entrypoint is always src/index.tsx
-  const reactEntry = join(srcPath, 'index.tsx')
-  const hasReact = existsSync(reactEntry)
-
-  let total = entries.length + (hasReact ? 1 : 0)
-  let successful = 0
-  let failed = 0
-
-  // Deploy all functions using the existing single-file deploy
-  const { deployFunction, deployReact, clearDeployCache } = await import('./deploy')
-  clearDeployCache()
-
-  for (const entry of entries) {
-    try {
-      await deployFunction(entry.path, privateKey, config.api)
-      successful++
-      onDeploy?.(entry.name, true)
-    } catch (error) {
-      failed++
-      onDeploy?.(entry.name, false, error instanceof Error ? error.message : String(error))
-    }
-  }
-
-  // Deploy React app (src/index.tsx)
-  if (hasReact) {
-    const fileName = 'index.tsx'
-    try {
-      await deployReact(reactEntry, privateKey, config.api)
-      successful++
-      onDeploy?.(fileName, true)
-    } catch (error) {
-      failed++
-      onDeploy?.(fileName, false, error instanceof Error ? error.message : String(error))
-    }
-  }
-
-  onComplete?.(total, successful, failed)
-}