odac 0.9.0 → 1.0.0

package/test/framework/Route.test.js

@@ -5,7 +5,7 @@ describe('Route', () => {
 
   beforeEach(() => {
     route = new Route()
-    global.Candy = {
+    global.Odac = {
       Route: {},
       Config: {}
     }
@@ -13,13 +13,13 @@ describe('Route', () => {
   })
 
   afterEach(() => {
-    delete global.Candy
+    delete global.Odac
     delete global.__dir
   })
 
   describe('check - token request', () => {
     it('should handle token request with undefined route gracefully', async () => {
-      const mockCandy = {
+      const mockOdac = {
         Request: {
           url: '/',
           method: 'get',
@@ -28,33 +28,34 @@ describe('Route', () => {
           host: 'example.com',
           header: jest.fn(key => {
             const headers = {
-              'X-Candy': 'token',
+              'X-Odac': 'token',
               Referer: 'http://example.com/',
-              'X-Candy-Client': 'test-client'
+              'X-Odac-Client': 'test-client'
             }
             return headers[key]
           }),
           cookie: jest.fn(key => {
-            if (key === 'candy_client') return 'test-client'
+            if (key === 'odac_client') return 'test-client'
             return null
-          })
+          }),
+          abort: jest.fn()
         },
         token: jest.fn(() => 'test-token')
       }
 
       route.routes = {}
 
-      const result = await route.check(mockCandy)
+      const result = await route.check(mockOdac)
 
       expect(result).toBeDefined()
       expect(result.token).toBe('test-token')
       expect(result.page).toBeUndefined()
-      expect(mockCandy.Request.header).toHaveBeenCalledWith('Access-Control-Allow-Origin', 'http://example.com')
-      expect(mockCandy.Request.header).toHaveBeenCalledWith('Cache-Control', 'no-store, no-cache, must-revalidate, max-age=0')
+      expect(mockOdac.Request.header).toHaveBeenCalledWith('Access-Control-Allow-Origin', 'http://example.com')
+      expect(mockOdac.Request.header).toHaveBeenCalledWith('Cache-Control', 'no-store, no-cache, must-revalidate, max-age=0')
     })
 
     it('should handle token request with route but no page defined', async () => {
-      const mockCandy = {
+      const mockOdac = {
         Request: {
           url: '/',
           method: 'get',
@@ -63,16 +64,17 @@ describe('Route', () => {
           host: 'example.com',
           header: jest.fn(key => {
             const headers = {
-              'X-Candy': 'token',
+              'X-Odac': 'token',
               Referer: 'https://example.com/',
-              'X-Candy-Client': 'test-client'
+              'X-Odac-Client': 'test-client'
             }
             return headers[key]
           }),
           cookie: jest.fn(key => {
-            if (key === 'candy_client') return 'test-client'
+            if (key === 'odac_client') return 'test-client'
             return null
-          })
+          }),
+          abort: jest.fn()
         },
         token: jest.fn(() => 'test-token-2')
       }
@@ -81,7 +83,7 @@ describe('Route', () => {
         test_route: {}
       }
 
-      const result = await route.check(mockCandy)
+      const result = await route.check(mockOdac)
 
       expect(result).toBeDefined()
       expect(result.token).toBe('test-token-2')
@@ -89,7 +91,7 @@ describe('Route', () => {
     })
 
     it('should handle token request with route and page but no url match', async () => {
-      const mockCandy = {
+      const mockOdac = {
         Request: {
           url: '/',
           method: 'get',
@@ -98,16 +100,17 @@ describe('Route', () => {
           host: 'example.com',
           header: jest.fn(key => {
             const headers = {
-              'X-Candy': 'token',
+              'X-Odac': 'token',
               Referer: 'http://example.com/',
-              'X-Candy-Client': 'test-client'
+              'X-Odac-Client': 'test-client'
             }
             return headers[key]
           }),
           cookie: jest.fn(key => {
-            if (key === 'candy_client') return 'test-client'
+            if (key === 'odac_client') return 'test-client'
             return null
-          })
+          }),
+          abort: jest.fn()
         },
         token: jest.fn(() => 'test-token-3')
       }
@@ -120,7 +123,7 @@ describe('Route', () => {
         }
       }
 
-      const result = await route.check(mockCandy)
+      const result = await route.check(mockOdac)
 
       expect(result).toBeDefined()
       expect(result.token).toBe('test-token-3')
@@ -128,7 +131,7 @@ describe('Route', () => {
     })
 
     it('should not return token when referer does not match', async () => {
-      const mockCandy = {
+      const mockOdac = {
         Request: {
           url: '/',
           method: 'get',
@@ -137,14 +140,14 @@ describe('Route', () => {
           host: 'example.com',
           header: jest.fn(key => {
             const headers = {
-              'X-Candy': 'token',
+              'X-Odac': 'token',
               Referer: 'http://malicious.com/',
-              'X-Candy-Client': 'test-client'
+              'X-Odac-Client': 'test-client'
             }
             return headers[key]
           }),
           cookie: jest.fn(key => {
-            if (key === 'candy_client') return 'test-client'
+            if (key === 'odac_client') return 'test-client'
             return null
           }),
           abort: jest.fn()
@@ -159,13 +162,13 @@ describe('Route', () => {
         }
       }
 
-      await route.check(mockCandy)
+      await route.check(mockOdac)
 
-      expect(mockCandy.Request.header).not.toHaveBeenCalledWith('Access-Control-Allow-Origin', expect.any(String))
+      expect(mockOdac.Request.header).not.toHaveBeenCalledWith('Access-Control-Allow-Origin', expect.any(String))
     })
 
     it('should not return token when client cookie does not match', async () => {
-      const mockCandy = {
+      const mockOdac = {
         Request: {
           url: '/',
           method: 'get',
@@ -174,14 +177,14 @@ describe('Route', () => {
           host: 'example.com',
           header: jest.fn(key => {
             const headers = {
-              'X-Candy': 'token',
+              'X-Odac': 'token',
               Referer: 'http://example.com/',
-              'X-Candy-Client': 'test-client'
+              'X-Odac-Client': 'test-client'
             }
             return headers[key]
           }),
           cookie: jest.fn(key => {
-            if (key === 'candy_client') return 'different-client'
+            if (key === 'odac_client') return 'different-client'
             return null
           }),
           abort: jest.fn()
@@ -196,15 +199,15 @@ describe('Route', () => {
         }
       }
 
-      await route.check(mockCandy)
+      await route.check(mockOdac)
 
-      expect(mockCandy.Request.header).not.toHaveBeenCalledWith('Access-Control-Allow-Origin', expect.any(String))
+      expect(mockOdac.Request.header).not.toHaveBeenCalledWith('Access-Control-Allow-Origin', expect.any(String))
     })
   })
 
   describe('set', () => {
     it('should register a route with function handler', () => {
-      global.Candy.Route.buff = 'test_route'
+      global.Odac.Route.buff = 'test_route'
       const handler = jest.fn()
 
       route.set('get', '/test', handler)
@@ -217,7 +220,7 @@ describe('Route', () => {
     })
 
     it('should handle array of methods', () => {
-      global.Candy.Route.buff = 'test_route'
+      global.Odac.Route.buff = 'test_route'
       const handler = jest.fn()
 
       route.set(['get', 'post'], '/test', handler)
@@ -227,7 +230,7 @@ describe('Route', () => {
     })
 
     it('should strip trailing slash from url', () => {
-      global.Candy.Route.buff = 'test_route'
+      global.Odac.Route.buff = 'test_route'
       const handler = jest.fn()
 
       route.set('get', '/test/', handler)
@@ -236,4 +239,20 @@ describe('Route', () => {
       expect(route.routes.test_route.get['/test/']).toBeUndefined()
     })
   })
+
+  describe('WebSocket cleanup', () => {
+    it('should call ws() method successfully', () => {
+      const handler = jest.fn()
+      expect(() => {
+        route.ws('/test', handler, {token: false})
+      }).not.toThrow()
+    })
+
+    it('should call auth.ws() method successfully', () => {
+      const handler = jest.fn()
+      expect(() => {
+        route.auth.ws('/test', handler)
+      }).not.toThrow()
+    })
+  })
 })

package/test/framework/View/EarlyHints.test.js

@@ -245,7 +245,7 @@ describe('EarlyHints', () => {
 
       const result = earlyHints.send(mockRes, resources)
       expect(result).toBe(true)
-      expect(mockRes.setHeader).toHaveBeenCalledWith('X-Candy-Early-Hints', JSON.stringify(['</css/main.css>; rel=preload; as=style']))
+      expect(mockRes.setHeader).toHaveBeenCalledWith('X-Odac-Early-Hints', JSON.stringify(['</css/main.css>; rel=preload; as=style']))
     })
 
     it('should send early hints successfully', () => {
@@ -262,7 +262,7 @@ describe('EarlyHints', () => {
       expect(mockRes.writeEarlyHints).toHaveBeenCalledWith({
         link: ['</css/main.css>; rel=preload; as=style']
       })
-      expect(mockRes.setHeader).toHaveBeenCalledWith('X-Candy-Early-Hints', JSON.stringify(['</css/main.css>; rel=preload; as=style']))
+      expect(mockRes.setHeader).toHaveBeenCalledWith('X-Odac-Early-Hints', JSON.stringify(['</css/main.css>; rel=preload; as=style']))
     })
 
     it('should handle writeEarlyHints errors gracefully', () => {

package/test/framework/WebSocket.test.js

@@ -0,0 +1,100 @@
+const {WebSocketServer} = require('../../framework/src/WebSocket.js')
+
+describe('WebSocketServer', () => {
+  let server
+
+  beforeEach(() => {
+    server = new WebSocketServer()
+  })
+
+  describe('route', () => {
+    it('should register a route', () => {
+      const handler = jest.fn()
+      server.route('/chat', handler)
+      expect(server.getRoute('/chat')).toBe(handler)
+    })
+
+    it('should return null for unregistered route', () => {
+      expect(server.getRoute('/unknown')).toBeNull()
+    })
+
+    it('should match parameterized routes', () => {
+      const handler = jest.fn()
+      server.route('/room/{id}', handler)
+
+      const result = server.getRoute('/room/123')
+      expect(result).toBeDefined()
+      expect(result.handler).toBe(handler)
+      expect(result.params).toEqual({id: '123'})
+    })
+
+    it('should match multiple parameters', () => {
+      const handler = jest.fn()
+      server.route('/chat/{room}/user/{userId}', handler)
+
+      const result = server.getRoute('/chat/general/user/42')
+      expect(result.params).toEqual({room: 'general', userId: '42'})
+    })
+  })
+
+  describe('rooms', () => {
+    it('should join and leave rooms', () => {
+      server.joinRoom('client1', 'room1')
+      server.joinRoom('client2', 'room1')
+
+      server.leaveRoom('client1', 'room1')
+      server.leaveRoom('client2', 'room1')
+    })
+  })
+
+  describe('broadcast', () => {
+    it('should have broadcast method', () => {
+      expect(typeof server.broadcast).toBe('function')
+    })
+  })
+
+  describe('clients', () => {
+    it('should track client count', () => {
+      expect(server.clientCount).toBe(0)
+    })
+  })
+
+  describe('cleanup on disconnect', () => {
+    it('should be handled by Route.setWs wrapper', () => {
+      expect(true).toBe(true)
+    })
+  })
+})
+
+describe('Route WebSocket Integration', () => {
+  const Route = require('../../framework/src/Route.js')
+
+  beforeEach(() => {
+    global.Odac = {
+      Route: new Route()
+    }
+  })
+
+  it('should support ws() method', () => {
+    expect(typeof Odac.Route.ws).toBe('function')
+  })
+
+  it('should support auth.ws() method', () => {
+    expect(typeof Odac.Route.auth.ws).toBe('function')
+  })
+
+  it('should support middleware with ws()', () => {
+    const chain = Odac.Route.use('test-middleware')
+    expect(typeof chain.ws).toBe('function')
+  })
+
+  it('should support middleware with auth.ws()', () => {
+    const chain = Odac.Route.use('test-middleware')
+    expect(typeof chain.auth.ws).toBe('function')
+  })
+
+  it('should support auth.use() with ws()', () => {
+    const chain = Odac.Route.auth.use('test-middleware')
+    expect(typeof chain.ws).toBe('function')
+  })
+})

package/test/framework/middleware.test.js

@@ -0,0 +1,85 @@
+const Route = require('../../framework/src/Route.js')
+
+describe('Middleware System', () => {
+  let route
+
+  beforeEach(() => {
+    route = new Route()
+    global.Odac = {Route: {buff: 'test'}}
+    global.__dir = __dirname
+  })
+
+  test('use() should return MiddlewareChain', () => {
+    const chain = route.use('auth', 'logger')
+    expect(chain).not.toBe(route)
+    expect(chain._middlewares).toEqual(['auth', 'logger'])
+  })
+
+  test('use() should support chaining with more middlewares', () => {
+    const chain = route.use('auth').use('logger')
+    expect(chain._middlewares).toEqual(['auth', 'logger'])
+  })
+
+  test('page() should return this for chaining', () => {
+    const result = route.page('/', 'index')
+    expect(result).toBe(route)
+  })
+
+  test('post() should return this for chaining', () => {
+    const result = route.post('/api', 'api')
+    expect(result).toBe(route)
+  })
+
+  test('get() should return this for chaining', () => {
+    const result = route.get('/api', 'api')
+    expect(result).toBe(route)
+  })
+
+  test('auth.use() should return MiddlewareChain', () => {
+    const chain = route.auth.use('admin')
+    expect(chain).not.toBe(route)
+    expect(chain._middlewares).toEqual(['admin'])
+  })
+
+  test('chaining should work: use().page().page()', () => {
+    route
+      .use('auth')
+      .page('/profile', () => {})
+      .page('/settings', () => {})
+    expect(route.routes.test.page['/profile'].middlewares).toEqual(['auth'])
+    expect(route.routes.test.page['/settings'].middlewares).toEqual(['auth'])
+  })
+
+  test('chaining should work: auth.use().page()', () => {
+    route.auth.use('admin').page('/admin', () => {})
+    expect(route.routes.test.page['/admin'].middlewares).toEqual(['admin'])
+  })
+
+  test('middlewares should be attached to routes', () => {
+    route
+      .use('auth')
+      .page('/profile', () => {})
+      .page('/settings', () => {})
+    expect(route.routes.test.page['/profile'].middlewares).toEqual(['auth'])
+    expect(route.routes.test.page['/settings'].middlewares).toEqual(['auth'])
+  })
+
+  test('routes without use() should have no middlewares', () => {
+    route.use('auth').page('/profile', () => {})
+    route.page('/public', () => {})
+    expect(route.routes.test.page['/profile'].middlewares).toEqual(['auth'])
+    expect(route.routes.test.page['/public'].middlewares).toBeUndefined()
+  })
+
+  test('multiple middlewares should be attached', () => {
+    route.use('cors', 'rateLimit').post('/api/upload', () => {})
+    expect(route.routes.test.post['/api/upload'].middlewares).toEqual(['cors', 'rateLimit'])
+  })
+
+  test('separate use() chains should be independent', () => {
+    route.use('auth').page('/profile', () => {})
+    route.use('cors').page('/api', () => {})
+    expect(route.routes.test.page['/profile'].middlewares).toEqual(['auth'])
+    expect(route.routes.test.page['/api'].middlewares).toEqual(['cors'])
+  })
+})

package/test/server/Api.test.js

@@ -16,8 +16,8 @@ describe('Api', () => {
     setupGlobalMocks()
 
     // Set up the Log mock before requiring Api
-    const {mockCandy} = require('./__mocks__/globalCandy')
-    mockCandy.setMock('core', 'Log', {
+    const {mockOdac} = require('./__mocks__/globalOdac')
+    mockOdac.setMock('core', 'Log', {
       init: jest.fn().mockReturnValue({
         log: mockLog,
         error: mockError
@@ -52,12 +52,12 @@ describe('Api', () => {
   describe('initialization', () => {
     it('should initialize api config if not exists', () => {
       // Clear the api config
-      global.Candy.core('Config').config.api = undefined
+      global.Odac.core('Config').config.api = undefined
 
       Api.init()
 
-      expect(global.Candy.core('Config').config.api).toBeDefined()
-      expect(global.Candy.core('Config').config.api.auth).toBeDefined()
+      expect(global.Odac.core('Config').config.api).toBeDefined()
+      expect(global.Odac.core('Config').config.api.auth).toBeDefined()
     })
 
     it('should create TCP server and set up handlers', () => {
@@ -300,7 +300,7 @@ describe('Api', () => {
       }
 
       const payload = JSON.stringify({
-        auth: global.Candy.core('Config').config.api.auth,
+        auth: global.Odac.core('Config').config.api.auth,
         action: 'invalid.action',
         data: []
       })
@@ -318,7 +318,7 @@ describe('Api', () => {
       }
 
       const payload = JSON.stringify({
-        auth: global.Candy.core('Config').config.api.auth,
+        auth: global.Odac.core('Config').config.api.auth,
         data: []
       })
 
@@ -335,11 +335,11 @@ describe('Api', () => {
       }
 
       // Mock the Mail service
-      const mockMailService = global.Candy.server('Mail')
+      const mockMailService = global.Odac.server('Mail')
       mockMailService.create.mockResolvedValue(Api.result(true, 'Account created'))
 
       const payload = JSON.stringify({
-        auth: global.Candy.core('Config').config.api.auth,
+        auth: global.Odac.core('Config').config.api.auth,
         action: 'mail.create',
         data: ['test@example.com', 'password123']
       })
@@ -357,11 +357,11 @@ describe('Api', () => {
         return
       }
 
-      const mockServiceService = global.Candy.server('Service')
+      const mockServiceService = global.Odac.server('Service')
       mockServiceService.start.mockResolvedValue(Api.result(true, 'Service started'))
 
       const payload = JSON.stringify({
-        auth: global.Candy.core('Config').config.api.auth,
+        auth: global.Odac.core('Config').config.api.auth,
         action: 'service.start',
         data: ['my-service.js']
       })
@@ -379,11 +379,11 @@ describe('Api', () => {
         return
       }
 
-      const mockServerService = global.Candy.server('Server')
+      const mockServerService = global.Odac.server('Server')
       mockServerService.stop.mockResolvedValue(Api.result(true, 'Server stopped'))
 
       const payload = JSON.stringify({
-        auth: global.Candy.core('Config').config.api.auth,
+        auth: global.Odac.core('Config').config.api.auth,
         action: 'server.stop',
         data: []
       })
@@ -401,11 +401,11 @@ describe('Api', () => {
         return
       }
 
-      const mockMailService = global.Candy.server('Mail')
+      const mockMailService = global.Odac.server('Mail')
       mockMailService.create.mockRejectedValue(new Error('Database connection failed'))
 
       const payload = JSON.stringify({
-        auth: global.Candy.core('Config').config.api.auth,
+        auth: global.Odac.core('Config').config.api.auth,
         action: 'mail.create',
         data: ['test@example.com', 'password123']
       })
@@ -423,11 +423,11 @@ describe('Api', () => {
         return
       }
 
-      const mockMailService = global.Candy.server('Mail')
+      const mockMailService = global.Odac.server('Mail')
       mockMailService.list.mockResolvedValue(Api.result(true, []))
 
       const payload = JSON.stringify({
-        auth: global.Candy.core('Config').config.api.auth,
+        auth: global.Odac.core('Config').config.api.auth,
         action: 'mail.list'
         // No data parameter
       })
@@ -445,14 +445,14 @@ describe('Api', () => {
         return
       }
 
-      const mockMailService = global.Candy.server('Mail')
+      const mockMailService = global.Odac.server('Mail')
       mockMailService.delete.mockResolvedValue(Api.result(true, 'Deleted'))
       mockMailService.password.mockResolvedValue(Api.result(true, 'Password changed'))
       mockMailService.send.mockResolvedValue(Api.result(true, 'Email sent'))
 
       // Test mail.delete
       let payload = JSON.stringify({
-        auth: global.Candy.core('Config').config.api.auth,
+        auth: global.Odac.core('Config').config.api.auth,
         action: 'mail.delete',
         data: ['test@example.com']
       })
@@ -462,7 +462,7 @@ describe('Api', () => {
 
       // Test mail.password
       payload = JSON.stringify({
-        auth: global.Candy.core('Config').config.api.auth,
+        auth: global.Odac.core('Config').config.api.auth,
         action: 'mail.password',
         data: ['test@example.com', 'newpassword']
       })
@@ -472,7 +472,7 @@ describe('Api', () => {
 
       // Test mail.send
       payload = JSON.stringify({
-        auth: global.Candy.core('Config').config.api.auth,
+        auth: global.Odac.core('Config').config.api.auth,
         action: 'mail.send',
         data: ['test@example.com', 'Subject', 'Body']
       })
@@ -487,14 +487,14 @@ describe('Api', () => {
         return
       }
 
-      const mockSubdomainService = global.Candy.server('Subdomain')
+      const mockSubdomainService = global.Odac.server('Subdomain')
       mockSubdomainService.create.mockResolvedValue(Api.result(true, 'Created'))
       mockSubdomainService.delete.mockResolvedValue(Api.result(true, 'Deleted'))
       mockSubdomainService.list.mockResolvedValue(Api.result(true, ['www', 'api']))
 
       // Test subdomain.create
       let payload = JSON.stringify({
-        auth: global.Candy.core('Config').config.api.auth,
+        auth: global.Odac.core('Config').config.api.auth,
         action: 'subdomain.create',
         data: ['api.example.com']
       })
@@ -504,7 +504,7 @@ describe('Api', () => {
 
       // Test subdomain.delete
       payload = JSON.stringify({
-        auth: global.Candy.core('Config').config.api.auth,
+        auth: global.Odac.core('Config').config.api.auth,
         action: 'subdomain.delete',
         data: ['api.example.com']
       })
@@ -514,7 +514,7 @@ describe('Api', () => {
 
       // Test subdomain.list
       payload = JSON.stringify({
-        auth: global.Candy.core('Config').config.api.auth,
+        auth: global.Odac.core('Config').config.api.auth,
         action: 'subdomain.list',
         data: ['example.com']
       })
@@ -529,14 +529,14 @@ describe('Api', () => {
         return
       }
 
-      const mockWebService = global.Candy.server('Web')
+      const mockWebService = global.Odac.server('Web')
       mockWebService.create.mockResolvedValue(Api.result(true, 'Created'))
       mockWebService.delete.mockResolvedValue(Api.result(true, 'Deleted'))
       mockWebService.list.mockResolvedValue(Api.result(true, ['example.com']))
 
       // Test web.create
       let payload = JSON.stringify({
-        auth: global.Candy.core('Config').config.api.auth,
+        auth: global.Odac.core('Config').config.api.auth,
         action: 'web.create',
         data: ['example.com']
       })
@@ -546,7 +546,7 @@ describe('Api', () => {
 
       // Test web.delete
       payload = JSON.stringify({
-        auth: global.Candy.core('Config').config.api.auth,
+        auth: global.Odac.core('Config').config.api.auth,
         action: 'web.delete',
         data: ['example.com']
       })
@@ -556,7 +556,7 @@ describe('Api', () => {
 
       // Test web.list
       payload = JSON.stringify({
-        auth: global.Candy.core('Config').config.api.auth,
+        auth: global.Odac.core('Config').config.api.auth,
         action: 'web.list',
         data: []
       })
@@ -571,11 +571,11 @@ describe('Api', () => {
         return
       }
 
-      const mockSSLService = global.Candy.server('SSL')
+      const mockSSLService = global.Odac.server('SSL')
       mockSSLService.renew.mockResolvedValue(Api.result(true, 'SSL renewed'))
 
       const payload = JSON.stringify({
-        auth: global.Candy.core('Config').config.api.auth,
+        auth: global.Odac.core('Config').config.api.auth,
         action: 'ssl.renew',
         data: ['example.com']
       })