@tothalex/nulljs 0.0.48 → 0.0.54

package/src/commands/dev/function/index.ts

@@ -1,221 +0,0 @@
-import { existsSync } from 'fs'
-import { resolve } from 'path'
-import chokidar from 'chokidar'
-import chalk from 'chalk'
-import ts from 'typescript'
-
-import { deployFunctionAndLog } from './utils'
-
-// Track dependencies between files
-const dependencyGraph = new Map<string, Set<string>>()
-const reverseDependencyGraph = new Map<string, Set<string>>()
-
-function analyzeDependencies(filePath: string): Set<string> {
-  const dependencies = new Set<string>()
-
-  try {
-    const fs = require('fs')
-    const path = require('path')
-
-    const sourceCode = fs.readFileSync(filePath, 'utf-8')
-    const sourceFile = ts.createSourceFile(filePath, sourceCode, ts.ScriptTarget.Latest, true)
-
-    function visit(node: ts.Node) {
-      if (
-        ts.isImportDeclaration(node) &&
-        node.moduleSpecifier &&
-        ts.isStringLiteral(node.moduleSpecifier)
-      ) {
-        const importPath = node.moduleSpecifier.text
-
-        // Resolve relative imports
-        if (importPath.startsWith('./') || importPath.startsWith('../')) {
-          const resolvedPath = path.resolve(path.dirname(filePath), importPath)
-
-          // Try different extensions
-          const extensions = ['.ts', '.js', '.tsx', '.jsx']
-          for (const ext of extensions) {
-            const fullPath = resolvedPath + ext
-            if (fs.existsSync(fullPath)) {
-              dependencies.add(fullPath)
-              break
-            }
-          }
-
-          // Also try index files
-          const indexPath = path.join(resolvedPath, 'index.ts')
-          if (fs.existsSync(indexPath)) {
-            dependencies.add(indexPath)
-          }
-        }
-      }
-
-      ts.forEachChild(node, visit)
-    }
-
-    visit(sourceFile)
-  } catch {
-    // Silent fallback - dependency tracking is nice-to-have
-  }
-
-  return dependencies
-}
-
-function updateDependencyGraph(filePath: string) {
-  // Remove old dependencies
-  const oldDeps = dependencyGraph.get(filePath) || new Set()
-  oldDeps.forEach((dep) => {
-    const reverseDeps = reverseDependencyGraph.get(dep) || new Set()
-    reverseDeps.delete(filePath)
-    if (reverseDeps.size === 0) {
-      reverseDependencyGraph.delete(dep)
-    } else {
-      reverseDependencyGraph.set(dep, reverseDeps)
-    }
-  })
-
-  // Add new dependencies
-  const newDeps = analyzeDependencies(filePath)
-  dependencyGraph.set(filePath, newDeps)
-
-  newDeps.forEach((dep) => {
-    const reverseDeps = reverseDependencyGraph.get(dep) || new Set()
-    reverseDeps.add(filePath)
-    reverseDependencyGraph.set(dep, reverseDeps)
-  })
-}
-
-function getAffectedFunctions(changedFile: string, functionDir: string): Set<string> {
-  const affected = new Set<string>()
-
-  // If the changed file is already in function dir, include it
-  if (changedFile.startsWith(functionDir) && changedFile.endsWith('.ts')) {
-    affected.add(changedFile)
-  }
-
-  // Find all functions that depend on this changed file
-  function findDependents(filePath: string, visited = new Set<string>()) {
-    if (visited.has(filePath)) return
-    visited.add(filePath)
-
-    const dependents = reverseDependencyGraph.get(filePath) || new Set()
-    dependents.forEach((dependent) => {
-      if (dependent.startsWith(functionDir) && dependent.endsWith('.ts')) {
-        affected.add(dependent)
-      }
-      findDependents(dependent, visited)
-    })
-  }
-
-  findDependents(changedFile)
-  return affected
-}
-
-export const createFunctionWatcher = (props: { srcDir: string; log: (data: string) => void }) => {
-  const functionDir = resolve(props.srcDir, 'function')
-
-  if (!existsSync(functionDir)) {
-    props.log(
-      chalk.yellow(
-        `⚠️  Functions directory not found at ${functionDir}, skipping function watcher.`
-      )
-    )
-    return null
-  }
-
-  props.log(chalk.cyan(`👀 Watching functions and dependencies in ${props.srcDir}`))
-
-  // Build initial dependency graph for all TypeScript files
-  const buildInitialDependencyGraph = () => {
-    const glob = require('glob')
-    const tsFiles = glob.sync(`${props.srcDir}/**/*.ts`, {
-      ignore: ['**/node_modules/**', '**/dist/**', '**/build/**']
-    })
-
-    props.log(chalk.gray(`🔍 Analyzing ${tsFiles.length} files for dependencies...`))
-
-    tsFiles.forEach((filePath: string) => {
-      const absolutePath = resolve(filePath)
-      updateDependencyGraph(absolutePath)
-    })
-
-    props.log(chalk.gray(`✓ Ready for smart rebuilds`))
-  }
-
-  // Build initial graph
-  buildInitialDependencyGraph()
-
-  return chokidar
-    .watch(props.srcDir, {
-      ignored: (path) => {
-        // Exclude common web/React directories and file types
-        const excludePatterns = [
-          'node_modules',
-          '.git',
-          'pages',
-          'components',
-          'styles',
-          'public',
-          'assets',
-          'dist',
-          'build'
-        ]
-
-        // Exclude file extensions that aren't relevant to functions
-        const excludeExtensions = [
-          '.css',
-          '.scss',
-          '.sass',
-          '.less',
-          '.jsx',
-          '.tsx',
-          '.html',
-          '.md'
-        ]
-
-        return (
-          excludePatterns.some((pattern) => path.includes(pattern)) ||
-          excludeExtensions.some((ext) => path.endsWith(ext))
-        )
-      },
-      persistent: true,
-      ignoreInitial: true,
-      cwd: process.cwd()
-    })
-    .on('add', (filePath) => {
-      if (filePath.endsWith('.ts')) {
-        const absolutePath = resolve(filePath)
-        updateDependencyGraph(absolutePath)
-
-        // Only deploy if it's a function file
-        if (absolutePath.startsWith(functionDir)) {
-          deployFunctionAndLog(absolutePath, props.log)
-        }
-      }
-    })
-    .on('change', (filePath) => {
-      if (filePath.endsWith('.ts')) {
-        const absolutePath = resolve(filePath)
-        updateDependencyGraph(absolutePath)
-
-        // Find all affected functions and deploy them
-        const affectedFunctions = getAffectedFunctions(absolutePath, functionDir)
-
-        if (affectedFunctions.size > 0) {
-          const fileName = require('path').basename(filePath)
-          const functionNames = Array.from(affectedFunctions).map((f) =>
-            require('path').basename(f, '.ts')
-          )
-
-          props.log(chalk.blue(`${fileName} changed → checking ${functionNames.join(', ')}`))
-
-          affectedFunctions.forEach((functionPath) => {
-            deployFunctionAndLog(functionPath, props.log)
-          })
-        }
-      }
-    })
-    .on('error', (error) => {
-      props.log(chalk.red('❌ Function watcher error:' + error))
-    })
-}

package/src/commands/dev/function/utils.ts

@@ -1,99 +0,0 @@
-import { existsSync, readdirSync } from 'fs'
-import { resolve, basename } from 'path'
-import chalk from 'chalk'
-import { deployFunction, isTypescript, type DeploymentResult } from '../../../lib/deployment'
-import { createSecretsFromFile } from '../../secret'
-
-export const deployFunctionAndLog = async (
-  filePath: string,
-  log: (data: string) => void,
-  force: boolean = false
-): Promise<void> => {
-  if (!isTypescript(filePath)) {
-    log(chalk.gray(`Skipping non-TypeScript file: ${basename(filePath)}`))
-    return
-  }
-
-  try {
-    // Silent logger for watch mode
-    const logger = {
-      log: () => {},
-      error: (error: any) => log(chalk.red(`Error: ${error}`))
-    }
-
-    const result: DeploymentResult = await deployFunction(filePath, logger, force)
-
-    // Show appropriate status based on actual result
-    if (result.error) {
-      log(chalk.red(`  ${basename(filePath, '.ts')} deployment failed`))
-      if (result.error.message.includes('Unable to connect')) {
-        log(chalk.yellow('    Is your server running?'))
-      } else {
-        log(chalk.gray(`    ${result.error.message}`))
-      }
-    } else if (result.cached) {
-      log(chalk.gray(`  ${basename(filePath, '.ts')} skipped (no changes)`))
-    } else if (result.deployed) {
-      log(chalk.green(`  ${basename(filePath, '.ts')} deployed successfully`))
-    }
-  } catch (error: any) {
-    log(chalk.red(`  ✗ ${basename(filePath, '.ts')} failed`))
-    log(chalk.gray(`    ${error.message || error}`))
-  }
-}
-
-export const deployAllFunctions = async (
-  srcDir: string,
-  log: (data: string) => void
-): Promise<void> => {
-  const functionDir = resolve(srcDir, 'function')
-
-  if (!existsSync(functionDir)) {
-    log(chalk.yellow('⚠️ No function directory found'))
-    return
-  }
-
-  try {
-    const files = readdirSync(functionDir, { recursive: true })
-    const tsFiles = files
-      .filter((file): file is string => typeof file === 'string')
-      .filter((file) => file.endsWith('.ts'))
-
-    if (tsFiles.length === 0) {
-      log(chalk.yellow('⚠️ No TypeScript functions found to deploy'))
-      return
-    }
-
-    log(chalk.blue(`🚀 Manually deploying ${tsFiles.length} functions...`))
-
-    for (const file of tsFiles) {
-      const absolutePath = resolve(functionDir, file)
-      await deployFunctionAndLog(absolutePath, log, true)
-    }
-
-    log(chalk.green('✅ Manual function deployment complete'))
-  } catch (error) {
-    log(chalk.red('❌ Error during manual function deployment: ' + error))
-  }
-}
-
-export const deploySecrets = async (srcDir: string, log: (data: string) => void): Promise<void> => {
-  const secretsPath = resolve(srcDir, '../.secrets')
-
-  log(chalk.cyan(`🔍 Checking for .secrets file at ${secretsPath}`))
-
-  if (!existsSync(secretsPath)) {
-    log(chalk.yellow('⚠️ No .secrets file found'))
-    return
-  }
-
-  try {
-    log(chalk.blue('🔐 Deploying secrets from .secrets file...' + ' ' + chalk.gray(secretsPath)))
-
-    await createSecretsFromFile({ filePath: secretsPath, log })
-
-    log(chalk.green('✅ Secret deployment complete'))
-  } catch (error) {
-    log(chalk.red('❌ Error during secret deployment: ' + error))
-  }
-}

package/src/commands/dev/index.tsx

@@ -1,126 +0,0 @@
-import { resolve } from 'path'
-import { exists } from 'node:fs/promises'
-
-import { createServer } from './server'
-import { createVite } from './vite'
-import { UI } from './ui/'
-import { render } from 'ink'
-import { LoggingManager } from './logging-manager'
-import type { Tab } from './ui/components/tab-bar'
-import { createFunctionWatcher } from './function'
-
-const analyzeProject = async (srcDir: string) => {
-  const indexTsxPath = resolve(srcDir, 'index.tsx')
-  const functionDirPath = resolve(srcDir, 'function')
-
-  const hasReactApp = await exists(indexTsxPath)
-  const hasFunctions = await exists(functionDirPath)
-
-  return {
-    hasReactApp,
-    hasFunctions,
-    indexTsxPath: hasReactApp ? indexTsxPath : null
-  }
-}
-
-export const dev = async (srcPath: string) => {
-  const srcDir = resolve(srcPath)
-  const loggingManager = new LoggingManager()
-
-  const { hasFunctions, indexTsxPath } = await analyzeProject(srcDir)
-
-  const tabs: Tab[] = [
-    { name: 'Server', status: 'loading' },
-    { name: 'Functions', status: 'loading' },
-    { name: 'Vite', status: 'loading' }
-  ]
-
-  let viteServer: any = null
-  let serverProcess: any = null
-  let functionWatcher: any = null
-
-  if (indexTsxPath) {
-    viteServer = await createVite({
-      indexTsxPath,
-      srcDir,
-      log: loggingManager.getLogFunction('vite')
-    })
-
-    tabs.find((tab) => tab.name === 'Vite')!.status = 'running'
-  }
-
-  serverProcess = createServer({
-    log: loggingManager.getLogFunction('server')
-  })
-  tabs.find((tab) => tab.name === 'Server')!.status = 'running'
-
-  if (hasFunctions) {
-    functionWatcher = createFunctionWatcher({
-      srcDir,
-      log: loggingManager.getLogFunction('functions')
-    })
-
-    tabs.find((tab) => tab.name === 'Functions')!.status = 'running'
-  }
-
-  const shutdown = async () => {
-    loggingManager.addLog('server', 'info', 'Shutting down services...')
-
-    const shutdownTasks = []
-
-    if (viteServer) {
-      shutdownTasks.push(
-        viteServer
-          .close()
-          .then(() => {
-            loggingManager.addLog('vite', 'info', 'Vite server stopped')
-            tabs.find((tab) => tab.name === 'Vite')!.status = 'stopped'
-          })
-          .catch((error: any) =>
-            loggingManager.addLog('vite', 'error', `Error stopping Vite: ${error}`)
-          )
-      )
-    }
-
-    if (serverProcess) {
-      shutdownTasks.push(
-        Promise.resolve()
-          .then(() => {
-            serverProcess.kill()
-            loggingManager.addLog('server', 'info', 'Server process stopped')
-            tabs.find((tab) => tab.name === 'Server')!.status = 'stopped'
-          })
-          .catch((error: any) =>
-            loggingManager.addLog('server', 'error', `Error stopping server: ${error}`)
-          )
-      )
-    }
-
-    if (functionWatcher) {
-      shutdownTasks.push(
-        functionWatcher
-          .close()
-          .then(() => {
-            loggingManager.addLog('functions', 'info', 'Function watcher stopped')
-            tabs.find((tab) => tab.name === 'Functions')!.status = 'stopped'
-          })
-          .catch((error: any) =>
-            loggingManager.addLog('functions', 'error', `Error stopping function watcher: ${error}`)
-          )
-      )
-    }
-
-    try {
-      await Promise.race([
-        Promise.all(shutdownTasks),
-        new Promise((_, reject) => setTimeout(() => reject(new Error('Shutdown timeout')), 3000))
-      ])
-    } catch (error) {
-      loggingManager.addLog('server', 'warn', `Shutdown timeout or error: ${error}`)
-    }
-
-    process.exit(0)
-  }
-
-  render(<UI tabs={tabs} loggingManager={loggingManager} onShutdown={shutdown} srcDir={srcDir} />)
-}

package/src/commands/dev/logging-manager.ts

@@ -1,87 +0,0 @@
-export type LogEntry = {
-  id: string
-  timestamp: Date
-  service: 'server' | 'functions' | 'vite'
-  level: 'info' | 'warn' | 'error'
-  message: string
-}
-
-export class LoggingManager {
-  private logs: Record<string, LogEntry[]> = {
-    server: [],
-    functions: [],
-    vite: []
-  }
-
-  private listeners: Set<() => void> = new Set()
-
-  addLog(service: LogEntry['service'], level: LogEntry['level'], message: string) {
-    const newLog: LogEntry = {
-      id: `${service}-${Date.now()}-${Math.random()}`,
-      timestamp: new Date(),
-      service,
-      level,
-      message
-    }
-
-    this.logs[service].push(newLog)
-    this.notifyListeners()
-  }
-
-  getLogs(service?: LogEntry['service']): LogEntry[] {
-    if (service) {
-      return [...this.logs[service]]
-    }
-    return Object.values(this.logs).flat()
-  }
-
-  getAllLogs(): Record<string, LogEntry[]> {
-    return {
-      server: [...this.logs.server],
-      functions: [...this.logs.functions],
-      vite: [...this.logs.vite]
-    }
-  }
-
-  clearLogs(service?: LogEntry['service']) {
-    if (service) {
-      this.logs[service] = []
-    } else {
-      this.logs = {
-        server: [],
-        functions: [],
-        vite: []
-      }
-    }
-    this.notifyListeners()
-  }
-
-  subscribe(listener: () => void) {
-    this.listeners.add(listener)
-
-    return () => this.listeners.delete(listener)
-  }
-
-  private notifyListeners() {
-    this.listeners.forEach((listener) => listener())
-  }
-
-  getLogFunction(service: LogEntry['service']) {
-    return (data: any) => {
-      let message: string
-      let level: LogEntry['level'] = 'info'
-
-      if (typeof data === 'string') {
-        message = data
-      } else if (data && typeof data === 'object') {
-        message = data.message || JSON.stringify(data)
-        level = data.level || level
-      } else {
-        message = String(data)
-      }
-
-      this.addLog(service, level, message)
-    }
-  }
-}
-

package/src/commands/dev/server/index.ts

@@ -1,48 +0,0 @@
-import chalk from 'chalk'
-import { spawn } from 'bun'
-import { existsSync } from 'fs'
-
-import { buildServerArgs, getServerBinPath } from './utils'
-import { getDevConfig } from '../../../lib/config'
-
-export const createServer = (props: { log?: (data: string) => void }) => {
-  const serverBinPath = getServerBinPath()
-
-  if (!existsSync(serverBinPath)) {
-    console.log(chalk.yellow('⚠️  Server binary not found ' + serverBinPath))
-    console.log(chalk.gray('   Run: bun run postinstall to install the server'))
-    return null
-  }
-
-  const devConfig = getDevConfig()
-
-  const args = buildServerArgs(devConfig)
-
-  const process = spawn([serverBinPath, ...args], {
-    stdout: props.log ? 'pipe' : 'inherit',
-    stderr: props.log ? 'pipe' : 'inherit'
-  })
-
-  if (props.log && process.stdout && process.stderr) {
-    const decoder = new TextDecoder()
-
-    const readStream = async (stream: ReadableStream<Uint8Array>) => {
-      const reader = stream.getReader()
-      while (true) {
-        const { done, value } = await reader.read()
-        if (done) {
-          break
-        }
-
-        if (props.log) {
-          props.log(decoder.decode(value))
-        }
-      }
-    }
-
-    readStream(process.stdout)
-    readStream(process.stderr)
-  }
-
-  return process
-}

package/src/commands/dev/server/utils.ts

@@ -1,37 +0,0 @@
-import { resolve, dirname, join } from 'path'
-import { existsSync } from 'fs'
-import { fileURLToPath } from 'url'
-
-import { getCloudPath, type DevConfig } from '../../../lib/config'
-
-export const getServerBinPath = (): string => {
-  // Try to find the server binary relative to this module
-  // This works both in development and when installed globally
-  const currentFile = fileURLToPath(import.meta.url)
-  const moduleRoot = resolve(dirname(currentFile), '../../..')
-  const path = join(moduleRoot, 'bin', 'server')
-
-  if (!existsSync(path)) {
-    const currentFile = fileURLToPath(import.meta.url)
-    const moduleRoot = resolve(dirname(currentFile), '../../../..')
-    return join(moduleRoot, 'bin', 'server')
-  }
-
-  return path
-}
-
-export const buildServerArgs = (config: DevConfig): string[] => {
-  const args = ['--dev']
-
-  args.push('--api-port', config.apiPort.toString())
-  args.push('--gateway-port', config.gatewayPort.toString())
-
-  const cloudPath = getCloudPath()
-  args.push('--cloud-path', cloudPath)
-
-  if (config.publicKey) {
-    args.push('--public-key', config.publicKey)
-  }
-
-  return args
-}