@tothalex/nulljs 0.0.48 → 0.0.53

package/src/lib/config.ts

@@ -1,347 +0,0 @@
-import {
-  readFileSync,
-  writeFileSync,
-  existsSync,
-  mkdirSync,
-  readdirSync,
-  unlinkSync
-} from 'node:fs'
-import { join, dirname } from 'node:path'
-import chalk from 'chalk'
-
-type NulljsConfig = {
-  key?: {
-    private: string
-    public: string
-  }
-  api?: string
-  dev?: {
-    apiPort?: number
-    gatewayPort?: number
-  }
-}
-
-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
-}
-
-export const configPath = join(findProjectRoot(), '.nulljs', 'config.json')
-export const profilesDir = join(findProjectRoot(), '.nulljs', 'profiles')
-export const activeProfilePath = join(findProjectRoot(), '.nulljs', 'active-profile')
-
-export const loadConfig = (): NulljsConfig => {
-  if (!existsSync(configPath)) {
-    return {}
-  }
-
-  try {
-    const configContent = readFileSync(configPath, 'utf8')
-    return JSON.parse(configContent) as NulljsConfig
-  } catch (error) {
-    console.error('Failed to parse config file:', error)
-    return {}
-  }
-}
-
-export const saveConfig = (config: NulljsConfig): void => {
-  try {
-    // Ensure the directory exists
-    const configDir = dirname(configPath)
-    if (!existsSync(configDir)) {
-      mkdirSync(configDir, { recursive: true })
-    }
-
-    const configContent = JSON.stringify(config, null, 2)
-    writeFileSync(configPath, configContent, 'utf8')
-  } catch (error) {
-    console.error('Failed to save config file:', error)
-    throw error
-  }
-}
-
-export const updateConfig = (partialConfig: Partial<NulljsConfig>): void => {
-  const currentConfig = loadConfig()
-  const updatedConfig = { ...currentConfig, ...partialConfig }
-
-  saveConfig(updatedConfig)
-}
-
-// Profile-related functions (must be defined before other functions use them)
-export const getActiveProfile = (): string | null => {
-  if (!existsSync(activeProfilePath)) {
-    return null
-  }
-  try {
-    return readFileSync(activeProfilePath, 'utf8').trim()
-  } catch {
-    return null
-  }
-}
-
-export const setActiveProfile = (profileName: string): void => {
-  const configDir = dirname(activeProfilePath)
-  if (!existsSync(configDir)) {
-    mkdirSync(configDir, { recursive: true })
-  }
-  writeFileSync(activeProfilePath, profileName, 'utf8')
-}
-
-export const getProfilePath = (profileName: string): string => {
-  return join(profilesDir, `${profileName}.json`)
-}
-
-export const loadProfile = (profileName: string): NulljsConfig => {
-  const profilePath = getProfilePath(profileName)
-  if (!existsSync(profilePath)) {
-    return {}
-  }
-
-  try {
-    const profileContent = readFileSync(profilePath, 'utf8')
-    return JSON.parse(profileContent) as NulljsConfig
-  } catch (error) {
-    console.error(`Failed to parse profile '${profileName}':`, error)
-    return {}
-  }
-}
-
-export const saveProfile = (profileName: string, config: NulljsConfig): void => {
-  try {
-    if (!existsSync(profilesDir)) {
-      mkdirSync(profilesDir, { recursive: true })
-    }
-
-    const profilePath = getProfilePath(profileName)
-    const configContent = JSON.stringify(config, null, 2)
-    writeFileSync(profilePath, configContent, 'utf8')
-  } catch (error) {
-    console.error(`Failed to save profile '${profileName}':`, error)
-    throw error
-  }
-}
-
-export const profileExists = (profileName: string): boolean => {
-  return existsSync(getProfilePath(profileName))
-}
-
-export const loadConfigWithProfile = (): NulljsConfig => {
-  const activeProfile = getActiveProfile()
-
-  if (activeProfile && profileExists(activeProfile)) {
-    return loadProfile(activeProfile)
-  }
-
-  return loadConfig()
-}
-
-export const saveConfigWithProfile = (config: NulljsConfig, profileName?: string): void => {
-  if (profileName) {
-    saveProfile(profileName, config)
-    setActiveProfile(profileName)
-  } else {
-    const activeProfile = getActiveProfile()
-    if (activeProfile && profileExists(activeProfile)) {
-      saveProfile(activeProfile, config)
-    } else {
-      saveConfig(config)
-    }
-  }
-}
-
-export const updateConfigWithProfile = (
-  partialConfig: Partial<NulljsConfig>,
-  profileName?: string
-): void => {
-  if (profileName) {
-    const currentConfig = loadProfile(profileName)
-    const updatedConfig = { ...currentConfig, ...partialConfig }
-    saveProfile(profileName, updatedConfig)
-    setActiveProfile(profileName)
-  } else {
-    const activeProfile = getActiveProfile()
-    if (activeProfile && profileExists(activeProfile)) {
-      const currentConfig = loadProfile(activeProfile)
-      const updatedConfig = { ...currentConfig, ...partialConfig }
-      saveProfile(activeProfile, updatedConfig)
-    } else {
-      updateConfig(partialConfig)
-    }
-  }
-}
-
-// Functions that use profile-related functions
-export const saveKeys = (privateKey: string, publicKey: string, profileName?: string): void => {
-  updateConfigWithProfile(
-    {
-      key: {
-        private: privateKey,
-        public: publicKey
-      }
-    },
-    profileName
-  )
-}
-
-export const saveApiUrl = (apiUrl: string, profileName?: string): void => {
-  updateConfigWithProfile({ api: apiUrl }, profileName)
-}
-
-export const loadPrivateKey = async () => {
-  let base64Key = process.env.NULLJS_PRIVATE_KEY
-
-  if (!base64Key) {
-    const config = loadConfigWithProfile()
-    if (!config.key?.private) {
-      throw new Error('Private key not found in config file or environment variable')
-    }
-    base64Key = config.key.private
-  }
-
-  const keyBuffer = Uint8Array.from(atob(base64Key), (c) => c.charCodeAt(0))
-
-  return await crypto.subtle.importKey(
-    'pkcs8',
-    keyBuffer,
-    {
-      name: 'Ed25519',
-      namedCurve: 'Ed25519'
-    },
-    false,
-    ['sign']
-  )
-}
-
-export const getApiUrl = (): string => {
-  const config = loadConfigWithProfile()
-  return config.api || 'http://localhost:3000/api'
-}
-
-export const API = getApiUrl()
-
-export type DevConfig = {
-  apiPort: number
-  gatewayPort: number
-  publicKey: string | undefined
-}
-
-export const getDevConfig = () => {
-  const config = loadConfigWithProfile()
-  return {
-    apiPort: config.dev?.apiPort || 3000,
-    gatewayPort: config.dev?.gatewayPort || 3001,
-    publicKey: config.key?.public
-  }
-}
-
-export const getProjectRoot = () => findProjectRoot()
-
-export const getCloudPath = () => join(findProjectRoot(), '.nulljs')
-
-export const listProfiles = (): string[] => {
-  if (!existsSync(profilesDir)) {
-    return []
-  }
-
-  try {
-    return readdirSync(profilesDir)
-      .filter((file) => file.endsWith('.json'))
-      .map((file) => file.replace('.json', ''))
-  } catch {
-    return []
-  }
-}
-
-export const deleteProfile = (profileName: string): boolean => {
-  const profilePath = getProfilePath(profileName)
-  if (!existsSync(profilePath)) {
-    return false
-  }
-
-  try {
-    unlinkSync(profilePath)
-
-    const activeProfile = getActiveProfile()
-    if (activeProfile === profileName) {
-      if (existsSync(activeProfilePath)) {
-        unlinkSync(activeProfilePath)
-      }
-    }
-
-    return true
-  } catch {
-    return false
-  }
-}
-
-export const requireActiveProfile = (): { profileName: string; config: NulljsConfig } => {
-  const activeProfile = getActiveProfile()
-
-  if (!activeProfile) {
-    console.error(chalk.red('❌ No active profile selected.'))
-    console.error(chalk.gray('   Create a profile: nulljs profile create <name>'))
-    console.error(chalk.gray('   Or switch to existing: nulljs profile use <name>'))
-    process.exit(1)
-  }
-
-  if (!profileExists(activeProfile)) {
-    console.error(chalk.red(`❌ Active profile '${activeProfile}' does not exist.`))
-    console.error(chalk.gray('   Available profiles:'))
-    const profiles = listProfiles()
-    if (profiles.length > 0) {
-      profiles.forEach((profile) => console.error(chalk.gray(`     - ${profile}`)))
-      console.error(chalk.gray('   Switch to an existing profile: nulljs profile use <name>'))
-    } else {
-      console.error(chalk.gray('   Create your first profile: nulljs profile create <name>'))
-    }
-    process.exit(1)
-  }
-
-  const config = loadProfile(activeProfile)
-  return { profileName: activeProfile, config }
-}
-
-export const requireProfileConfiguration = (
-  requiredFields: Array<'api' | 'key' | 'dev'> = ['api', 'key']
-): { profileName: string; config: NulljsConfig } => {
-  const { profileName, config } = requireActiveProfile()
-
-  const missing: string[] = []
-
-  if (requiredFields.includes('api') && !config.api) {
-    missing.push('API URL')
-  }
-
-  if (requiredFields.includes('key') && (!config.key?.private || !config.key?.public)) {
-    missing.push('authentication keys')
-  }
-
-  if (requiredFields.includes('dev') && !config.dev) {
-    missing.push('dev configuration')
-  }
-
-  if (missing.length > 0) {
-    console.error(chalk.red(`❌ Profile '${profileName}' is missing required configuration:`))
-    missing.forEach((field) => console.error(chalk.yellow(`     - ${field}`)))
-    console.error('')
-    console.error(chalk.gray('   Configure your profile:'))
-    if (missing.includes('API URL')) {
-      console.error(chalk.gray('     nulljs api <url>'))
-    }
-    if (missing.includes('authentication keys')) {
-      console.error(chalk.gray('     nulljs auth'))
-    }
-    if (missing.includes('dev configuration')) {
-      console.error(chalk.gray('     Check your .nulljs/profiles/<profile>.json file'))
-    }
-    process.exit(1)
-  }
-
-  return { profileName, config }
-}

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
-  }
-}