odac 0.9.0 → 1.0.0

package/test/server/Client.test.js

@@ -1,338 +0,0 @@
-// Create mock log function first
-const mockLog = jest.fn()
-
-// Mock global Candy first
-const {mockCandy} = require('./__mocks__/globalCandy')
-
-// Set up the Log mock before setting global.Candy
-mockCandy.setMock('core', 'Log', {
-  init: jest.fn().mockReturnValue({
-    log: mockLog,
-    error: jest.fn()
-  })
-})
-
-global.Candy = mockCandy
-
-// Mock axios
-jest.mock('axios')
-const axios = require('axios')
-
-const Client = require('../../server/src/Client')
-
-describe('Client', () => {
-  beforeEach(() => {
-    jest.clearAllMocks()
-
-    // Reset config
-    mockCandy.setMock('core', 'Config', {
-      config: {}
-    })
-  })
-
-  describe('authentication', () => {
-    it('should authenticate successfully with valid code', async () => {
-      // Arrange
-      const mockCode = 'valid-auth-code'
-      const mockResponse = {
-        data: {
-          result: {success: true},
-          data: {
-            token: 'test-token-123',
-            secret: 'test-secret-456'
-          }
-        }
-      }
-
-      const mockConfig = {config: {}}
-      mockCandy.setMock('core', 'Config', mockConfig)
-      axios.post.mockResolvedValue(mockResponse)
-
-      // Act
-      Client.auth(mockCode)
-
-      // Wait for promise to resolve
-      await new Promise(resolve => setTimeout(resolve, 0))
-
-      // Assert
-      expect(mockLog).toHaveBeenCalledWith('CandyPack authenticating...')
-      expect(axios.post).toHaveBeenCalledWith('https://api.candypack.dev/auth', {code: mockCode})
-      expect(mockConfig.config.auth).toEqual({
-        token: 'test-token-123',
-        secret: 'test-secret-456'
-      })
-      expect(mockLog).toHaveBeenCalledWith('CandyPack authenticated!')
-    })
-
-    it('should handle authentication failure with error message', async () => {
-      // Arrange
-      const mockCode = 'invalid-code'
-      const mockError = 'Invalid authentication code'
-
-      axios.post.mockRejectedValue({
-        response: {data: mockError}
-      })
-
-      // Act
-      Client.auth(mockCode)
-
-      // Wait for promise to reject
-      await new Promise(resolve => setTimeout(resolve, 0))
-
-      // Assert
-      expect(mockLog).toHaveBeenCalledWith('CandyPack authenticating...')
-      expect(axios.post).toHaveBeenCalledWith('https://api.candypack.dev/auth', {code: mockCode})
-      expect(mockLog).toHaveBeenCalledWith(mockError)
-    })
-
-    it('should handle authentication failure without error message', async () => {
-      // Arrange
-      const mockCode = 'invalid-code'
-
-      axios.post.mockRejectedValue({
-        response: {data: null}
-      })
-
-      // Act
-      Client.auth(mockCode)
-
-      // Wait for promise to reject
-      await new Promise(resolve => setTimeout(resolve, 0))
-
-      // Assert
-      expect(mockLog).toHaveBeenCalledWith('CandyPack authenticating...')
-      expect(mockLog).toHaveBeenCalledWith('CandyPack authentication failed!')
-    })
-
-    it('should handle API response with success false', async () => {
-      // Arrange
-      const mockCode = 'valid-code'
-      const mockResponse = {
-        data: {
-          result: {
-            success: false,
-            message: 'Authentication failed on server'
-          }
-        }
-      }
-
-      axios.post.mockResolvedValue(mockResponse)
-
-      // Act
-      Client.auth(mockCode)
-
-      // Wait for promise to reject
-      await new Promise(resolve => setTimeout(resolve, 0))
-
-      // Assert
-      expect(mockLog).toHaveBeenCalledWith('CandyPack authenticating...')
-      expect(mockLog).toHaveBeenCalledWith('Authentication failed on server')
-    })
-
-    it('should store authentication credentials in config', async () => {
-      // Arrange
-      const mockCode = 'test-code'
-      const mockToken = 'stored-token'
-      const mockSecret = 'stored-secret'
-      const mockResponse = {
-        data: {
-          result: {success: true},
-          data: {
-            token: mockToken,
-            secret: mockSecret
-          }
-        }
-      }
-
-      const mockConfig = {config: {existingProp: 'value'}}
-      mockCandy.setMock('core', 'Config', mockConfig)
-      axios.post.mockResolvedValue(mockResponse)
-
-      // Act
-      Client.auth(mockCode)
-
-      // Wait for promise to resolve
-      await new Promise(resolve => setTimeout(resolve, 0))
-
-      // Assert
-      expect(mockConfig.config.auth).toEqual({
-        token: mockToken,
-        secret: mockSecret
-      })
-      // Verify existing config is preserved
-      expect(mockConfig.config.existingProp).toBe('value')
-    })
-  })
-
-  describe('API communication', () => {
-    it('should make successful API call and return data', async () => {
-      // Arrange
-      const mockAction = 'test-action'
-      const mockData = {param1: 'value1', param2: 'value2'}
-      const mockResponseData = {result: 'success', info: 'test data'}
-      const mockResponse = {
-        data: {
-          result: {success: true},
-          data: mockResponseData
-        }
-      }
-
-      axios.post.mockResolvedValue(mockResponse)
-
-      // Act
-      const result = await Client.call(mockAction, mockData)
-
-      // Assert
-      expect(axios.post).toHaveBeenCalledWith('https://api.candypack.dev/test-action', mockData)
-      expect(result).toEqual(mockResponseData)
-    })
-
-    it('should handle API call with different endpoints', async () => {
-      // Arrange
-      const testCases = [
-        {action: 'users', data: {id: 1}},
-        {action: 'domains', data: {domain: 'example.com'}},
-        {action: 'ssl/renew', data: {cert: 'test.crt'}}
-      ]
-
-      const mockResponseData = {status: 'ok'}
-      const mockResponse = {
-        data: {
-          result: {success: true},
-          data: mockResponseData
-        }
-      }
-
-      axios.post.mockResolvedValue(mockResponse)
-
-      // Act & Assert
-      for (const testCase of testCases) {
-        const result = await Client.call(testCase.action, testCase.data)
-        expect(axios.post).toHaveBeenCalledWith(`https://api.candypack.dev/${testCase.action}`, testCase.data)
-        expect(result).toEqual(mockResponseData)
-      }
-    })
-
-    it('should reject when API response indicates failure', async () => {
-      // Arrange
-      const mockAction = 'failing-action'
-      const mockData = {test: 'data'}
-      const mockErrorMessage = 'API operation failed'
-      const mockResponse = {
-        data: {
-          result: {
-            success: false,
-            message: mockErrorMessage
-          }
-        }
-      }
-
-      axios.post.mockResolvedValue(mockResponse)
-
-      // Act & Assert
-      await expect(Client.call(mockAction, mockData)).rejects.toBe(mockErrorMessage)
-      expect(axios.post).toHaveBeenCalledWith('https://api.candypack.dev/failing-action', mockData)
-    })
-
-    it('should handle network errors and log response data', async () => {
-      // Arrange
-      const mockAction = 'network-error'
-      const mockData = {test: 'data'}
-      const mockErrorData = {error: 'Network timeout', code: 500}
-      const mockError = {
-        response: {data: mockErrorData}
-      }
-
-      axios.post.mockRejectedValue(mockError)
-
-      // Act & Assert
-      await expect(Client.call(mockAction, mockData)).rejects.toBe(mockErrorData)
-      expect(mockLog).toHaveBeenCalledWith(mockErrorData)
-      expect(axios.post).toHaveBeenCalledWith('https://api.candypack.dev/network-error', mockData)
-    })
-
-    it('should handle axios errors without response data', async () => {
-      // Arrange
-      const mockAction = 'connection-error'
-      const mockData = {test: 'data'}
-      const mockError = {
-        response: {
-          data: 'Connection refused'
-        }
-      }
-
-      axios.post.mockRejectedValue(mockError)
-
-      // Act & Assert
-      await expect(Client.call(mockAction, mockData)).rejects.toBe('Connection refused')
-      expect(mockLog).toHaveBeenCalledWith('Connection refused')
-    })
-
-    it('should format API requests correctly', async () => {
-      // Arrange
-      const mockAction = 'format-test'
-      const mockData = {
-        string: 'test',
-        number: 123,
-        boolean: true,
-        object: {nested: 'value'},
-        array: [1, 2, 3]
-      }
-      const mockResponse = {
-        data: {
-          result: {success: true},
-          data: {received: 'ok'}
-        }
-      }
-
-      axios.post.mockResolvedValue(mockResponse)
-
-      // Act
-      await Client.call(mockAction, mockData)
-
-      // Assert
-      expect(axios.post).toHaveBeenCalledWith('https://api.candypack.dev/format-test', mockData)
-      expect(axios.post).toHaveBeenCalledTimes(1)
-    })
-
-    it('should handle empty response data', async () => {
-      // Arrange
-      const mockAction = 'empty-response'
-      const mockData = {test: 'data'}
-      const mockResponse = {
-        data: {
-          result: {success: true},
-          data: null
-        }
-      }
-
-      axios.post.mockResolvedValue(mockResponse)
-
-      // Act
-      const result = await Client.call(mockAction, mockData)
-
-      // Assert
-      expect(result).toBeNull()
-    })
-
-    it('should handle API calls with no data parameter', async () => {
-      // Arrange
-      const mockAction = 'no-data'
-      const mockResponse = {
-        data: {
-          result: {success: true},
-          data: {message: 'success'}
-        }
-      }
-
-      axios.post.mockResolvedValue(mockResponse)
-
-      // Act
-      const result = await Client.call(mockAction)
-
-      // Assert
-      expect(axios.post).toHaveBeenCalledWith('https://api.candypack.dev/no-data', undefined)
-      expect(result).toEqual({message: 'success'})
-    })
-  })
-})

package/test/server/__mocks__/http-proxy.js

@@ -1,105 +0,0 @@
-/**
- * Mock implementation of http-proxy module for server tests
- */
-
-const {createMockEventEmitter} = require('./testHelpers')
-
-const createMockProxyServer = (options = {}) => {
-  const proxy = Object.assign(createMockEventEmitter(), {
-    options: options,
-
-    // Main proxy methods
-    web: jest.fn((req, res, options, callback) => {
-      // Simulate successful proxying
-      setTimeout(() => {
-        if (callback) callback()
-      }, 0)
-    }),
-
-    ws: jest.fn((req, socket, head, options, callback) => {
-      // Simulate WebSocket proxying
-      setTimeout(() => {
-        if (callback) callback()
-      }, 0)
-    }),
-
-    listen: jest.fn((port, hostname, callback) => {
-      if (typeof hostname === 'function') {
-        callback = hostname
-        hostname = undefined
-      }
-
-      setTimeout(() => {
-        if (callback) callback()
-      }, 0)
-
-      return proxy
-    }),
-
-    close: jest.fn(callback => {
-      setTimeout(() => {
-        if (callback) callback()
-      }, 0)
-    }),
-
-    // Test helper methods
-    simulateProxyReq: (proxyReq, req, res, options) => {
-      proxy.emit('proxyReq', proxyReq, req, res, options)
-    },
-
-    simulateProxyRes: (proxyRes, req, res) => {
-      proxy.emit('proxyRes', proxyRes, req, res)
-    },
-
-    simulateError: (error, req, res, target) => {
-      proxy.emit('error', error, req, res, target)
-    },
-
-    simulateOpen: proxySocket => {
-      proxy.emit('open', proxySocket)
-    },
-
-    simulateClose: (res, socket, head) => {
-      proxy.emit('close', res, socket, head)
-    }
-  })
-
-  return proxy
-}
-
-const httpProxy = {
-  createProxyServer: jest.fn((options = {}) => {
-    return createMockProxyServer(options)
-  }),
-
-  createServer: jest.fn((options = {}, requestListener) => {
-    if (typeof options === 'function') {
-      requestListener = options
-      options = {}
-    }
-
-    const proxy = createMockProxyServer(options)
-
-    // Add server-like methods
-    proxy.listen = jest.fn((port, hostname, callback) => {
-      if (typeof hostname === 'function') {
-        callback = hostname
-        hostname = undefined
-      }
-
-      setTimeout(() => {
-        proxy.emit('listening')
-        if (callback) callback()
-      }, 0)
-
-      return proxy
-    })
-
-    return proxy
-  }),
-
-  // Test helpers
-  __createMockProxyServer: createMockProxyServer
-}
-
-module.exports = httpProxy

package/watchdog/index.js

@@ -1,3 +0,0 @@
-require('../core/Candy.js')
-
-Candy.watchdog('Watchdog')

package/watchdog/src/Watchdog.js

@@ -1,156 +0,0 @@
-const {spawn} = require('child_process')
-const fs = require('fs').promises
-const os = require('os')
-const path = require('path')
-
-// --- Constants ---
-const CANDYPACK_HOME = path.join(os.homedir(), '.candypack')
-const LOG_DIR = path.join(CANDYPACK_HOME, 'logs')
-const SERVER_SCRIPT_PATH = path.join(__dirname, '..', '..', 'server', 'index.js')
-
-const MAX_RESTARTS_IN_WINDOW = 100
-const RESTART_WINDOW_MS = 1000 * 60 * 5 // 5 minutes
-const SAVE_INTERVAL_MS = 1000 // 1 second
-
-class Watchdog {
-  #logBuffer = ''
-  #errorBuffer = ''
-  #restartCount = 0
-  #lastRestartTimestamp = 0
-  #isSaving = false
-
-  init() {
-    // Set up periodic log saving. This is done only once.
-    setInterval(() => this.#saveLogs(), SAVE_INTERVAL_MS)
-
-    // Start the server for the first time.
-    this.#startServer()
-  }
-
-  /**
-   * Saves the buffered logs to their respective files.
-   * This function is designed to be called periodically.
-   * Keeps only the last 1000 lines in each log file.
-   */
-  async #saveLogs() {
-    if (this.#isSaving) return
-    this.#isSaving = true
-
-    try {
-      // Ensure log directory exists before attempting to write files
-      await fs.mkdir(LOG_DIR, {recursive: true})
-      const logFile = path.join(LOG_DIR, '.candypack.log')
-      const errFile = path.join(LOG_DIR, '.candypack_err.log')
-
-      // Limit log buffer to last 1000 lines
-      const logLines = this.#logBuffer.split('\n')
-      if (logLines.length > 1000) {
-        this.#logBuffer = logLines.slice(-1000).join('\n')
-      }
-
-      // Limit error buffer to last 1000 lines
-      const errLines = this.#errorBuffer.split('\n')
-      if (errLines.length > 1000) {
-        this.#errorBuffer = errLines.slice(-1000).join('\n')
-      }
-
-      await fs.writeFile(logFile, this.#logBuffer, 'utf8')
-      await fs.writeFile(errFile, this.#errorBuffer, 'utf8')
-    } catch (error) {
-      console.error('Failed to save logs:', error)
-    } finally {
-      this.#isSaving = false
-    }
-  }
-
-  /**
-   * Performs startup checks to ensure a clean environment.
-   * It kills any old watchdog or server processes that might still be running.
-   * It also creates the necessary configuration files and directories if they don't exist.
-   * @returns {Promise<boolean>} A promise that resolves to true if the checks pass.
-   */
-  async #performStartupChecks() {
-    try {
-      // Kill previous watchdog process if it exists and is different from the current one
-      if (Candy.core('Config').config.server.watchdog && Candy.core('Config').config.server.watchdog !== process.pid)
-        await Candy.core('Process').stop(Candy.core('Config').config.server.watchdog)
-
-      // Kill previous server process if it exists
-      if (Candy.core('Config').config.server.pid) await Candy.core('Process').stop(Candy.core('Config').config.server.pid)
-
-      for (const domain of Object.keys(Candy.core('Config').config?.websites ?? []))
-        if (Candy.core('Config').config.websites[domain].pid)
-          await Candy.core('Process').stop(Candy.core('Config').config.websites[domain].pid)
-
-      for (const service of Candy.core('Config').config.services ?? []) if (service.pid) await Candy.core('Process').stop(service.pid)
-
-      // Update config with current watchdog's info
-      Candy.core('Config').config.server.watchdog = process.pid
-      Candy.core('Config').config.server.started = Date.now()
-      Candy.core('Config').force()
-
-      return new Promise(resolve => setTimeout(() => resolve(true), 1000))
-    } catch (error) {
-      console.error('Error during startup checks:', error)
-      return false
-    }
-  }
-
-  /**
-   * Starts the server process and sets up monitoring.
-   */
-  async #startServer() {
-    const checksPassed = await this.#performStartupChecks()
-    if (!checksPassed) {
-      console.error('Startup checks failed. Aborting.')
-      process.exit(1)
-    }
-
-    // Ensure log directory exists before starting
-    await fs.mkdir(LOG_DIR, {recursive: true})
-
-    const child = spawn('node', [SERVER_SCRIPT_PATH])
-
-    process.on('exit', () => child.kill())
-
-    Candy.core('Config').config.server.pid = child.pid
-
-    console.log(`Watchdog process started with PID: ${process.pid}`)
-    console.log(`Server process started with PID: ${child.pid}`)
-
-    child.stdout.on('data', data => {
-      this.#logBuffer += `[LOG][${new Date().toISOString()}] ${data.toString()}`
-    })
-
-    child.stderr.on('data', data => {
-      this.#logBuffer += `[ERR][${new Date().toISOString()}] ${data.toString()}`
-      this.#errorBuffer += `[ERR][${new Date().toISOString()}] ${data.toString()}`
-    })
-
-    child.on('close', code => {
-      Candy.core('Config').reload()
-      this.#errorBuffer += `[ERR][${new Date().toISOString()}] Process closed with code ${code}\n`
-
-      // Reset restart count if the last restart was a while ago
-      if (Date.now() - this.#lastRestartTimestamp > RESTART_WINDOW_MS) {
-        this.#restartCount = 0
-      }
-
-      this.#restartCount++
-      this.#lastRestartTimestamp = Date.now()
-
-      // If restart limit is not exceeded, restart the server
-      if (this.#restartCount < MAX_RESTARTS_IN_WINDOW) {
-        console.log('Server process closed. Restarting...')
-        // Relaunch the server process without setting up new intervals
-        this.#startServer()
-      } else {
-        console.error('Server has crashed too many times. Not restarting.')
-        // Final attempt to save logs before exiting
-        this.#saveLogs().then(() => process.exit(1))
-      }
-    })
-  }
-}
-
-module.exports = new Watchdog()

package/web/config.json

@@ -1,5 +0,0 @@
-{
-  "route": {
-    "/assets/js/candy.js": "${candy}/framework/web/candy.js"
-  }
-}

package/web/view/footer/main.html

@@ -1,11 +0,0 @@
-<!-- Footer -->
-<div class="footer">
-    <div class="container">
-        <p>Powered by <strong>CandyPack</strong> - A next-generation server and framework toolkit</p>
-        <p class="footer-links">
-            <a href="https://github.com/candypack" target="_blank" data-navigate="false">GitHub</a> •
-            <a href="https://docs.candypack.dev" target="_blank" data-navigate="false">Documentation</a> •
-            <a href="https://candypack.dev" target="_blank" data-navigate="false">Official Site</a>
-        </p>
-    </div>
-</div>