odac 1.1.0 → 1.3.0

package/src/WebSocket.js

@@ -1,7 +1,10 @@
 const nodeCrypto = require('crypto')
 
 const WS_GUID = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11'
-const MAX_PAYLOAD_LENGTH = 10 * 1024 * 1024
+const DEFAULT_MAX_PAYLOAD = 10 * 1024 * 1024
+const DEFAULT_RATE_LIMIT_MAX = 50
+const DEFAULT_RATE_LIMIT_WINDOW = 1000
+
 const OPCODE = {
   CONTINUATION: 0x0,
   TEXT: 0x1,
@@ -18,13 +21,29 @@ class WebSocketClient {
   #server
   #id
   #rooms = new Set()
+  #maxPayload
+  #rateLimitMax
+  #rateLimitWindow
+  #messageCount = 0
+  #rateLimitTimer
   data = {}
 
-  constructor(socket, server, id) {
+  constructor(socket, server, id, options = {}) {
     this.#socket = socket
     this.#socket.pause()
     this.#server = server
     this.#id = id
+    this.#maxPayload = options.maxPayload || DEFAULT_MAX_PAYLOAD
+
+    this.#rateLimitMax = options.rateLimit?.max ?? DEFAULT_RATE_LIMIT_MAX
+    this.#rateLimitWindow = options.rateLimit?.window ?? DEFAULT_RATE_LIMIT_WINDOW
+
+    if (this.#rateLimitMax > 0) {
+      this.#rateLimitTimer = setInterval(() => {
+        this.#messageCount = 0
+      }, this.#rateLimitWindow)
+    }
+
     this.#setupListeners()
   }
 
@@ -93,7 +112,7 @@ class WebSocketClient {
       offset = 10
     }
 
-    if (payloadLength > MAX_PAYLOAD_LENGTH) {
+    if (payloadLength > this.#maxPayload) {
       this.close(1009, 'Payload too large')
       return null
     }
@@ -125,6 +144,14 @@ class WebSocketClient {
   }
 
   #handleFrame(frame) {
+    if (this.#rateLimitMax > 0) {
+      this.#messageCount++
+      if (this.#messageCount > this.#rateLimitMax) {
+        this.close(1008, 'Rate limit exceeded')
+        return
+      }
+    }
+
     switch (frame.opcode) {
       case OPCODE.TEXT:
         this.#handleMessage(frame.payload.toString('utf8'))
@@ -158,6 +185,8 @@ class WebSocketClient {
     if (this.#closed) return
     this.#closed = true
 
+    if (this.#rateLimitTimer) clearInterval(this.#rateLimitTimer)
+
     this.#socket.removeAllListeners()
 
     for (const room of this.#rooms) {
@@ -169,8 +198,7 @@ class WebSocketClient {
   }
 
   #sendFrame(opcode, data) {
-    if (this.#closed) return
-
+    if (this.#closed && opcode !== OPCODE.CLOSE) return
     const payload = Buffer.isBuffer(data) ? data : Buffer.from(data)
     const length = payload.length
 
@@ -240,6 +268,8 @@ class WebSocketClient {
     if (this.#closed) return
     this.#closed = true
 
+    if (this.#rateLimitTimer) clearInterval(this.#rateLimitTimer)
+
     const reasonBuffer = Buffer.from(reason)
     const payload = Buffer.alloc(2 + reasonBuffer.length)
     payload.writeUInt16BE(code, 0)
@@ -287,14 +317,14 @@ class WebSocketServer {
   #rooms = new Map()
   #routes = new Map()
 
-  route(path, handler) {
-    this.#routes.set(path, handler)
+  route(path, handler, options = {}) {
+    this.#routes.set(path, {handler, options})
   }
 
   getRoute(path) {
     if (this.#routes.has(path)) return this.#routes.get(path)
 
-    for (const [pattern, handler] of this.#routes) {
+    for (const [pattern, config] of this.#routes) {
       if (!pattern.includes('{')) continue
       const regex = new RegExp('^' + pattern.replace(/\{[^}]+\}/g, '([^/]+)') + '$')
       const match = path.match(regex)
@@ -304,7 +334,11 @@ class WebSocketServer {
         paramNames.forEach((name, i) => {
           params[name.slice(1, -1)] = match[i + 1]
         })
-        return {handler, params}
+        return {
+          handler: config.handler,
+          options: config.options,
+          params
+        }
       }
     }
     return null
@@ -320,8 +354,7 @@ class WebSocketServer {
       return
     }
 
-    const handler = typeof routeInfo === 'function' ? routeInfo : routeInfo.handler
-    const params = routeInfo.params || {}
+    const {handler, params = {}, options = {}} = routeInfo
 
     const key = req.headers['sec-websocket-key']
     if (!key) {
@@ -353,7 +386,7 @@ class WebSocketServer {
     if (head && head.length > 0) socket.unshift(head)
 
     const clientId = nodeCrypto.randomUUID()
-    const client = new WebSocketClient(socket, this, clientId)
+    const client = new WebSocketClient(socket, this, clientId, options)
     this.#clients.set(clientId, client)
 
     if (params) {

package/template/package.json

@@ -3,7 +3,9 @@
   "version": "1.0.0",
   "description": "Website for {{domain_original}}",
   "scripts": {
-    "dev": "odac dev"
+    "dev": "odac dev",
+    "build": "odac build",
+    "start": "odac start"
   },
   "dependencies": {
     "odac": "*"

package/template/view/content/home.html

@@ -60,9 +60,9 @@
 
       <div class="structure-item">
         <div class="structure-icon">⚙️</div>
-        <h3 class="structure-title">config.json</h3>
+        <h3 class="structure-title">odac.json</h3>
         <p class="structure-description">Configuration file for database, routes, and other settings.</p>
-        <code class="structure-path">config.json</code>
+        <code class="structure-path">odac.json</code>
       </div>
     </div>
   </div>
@@ -156,7 +156,7 @@
         <div class="feature-icon">🗄️</div>
         <div class="feature-content">
           <h3>Database Ready</h3>
-          <p>MySQL and SQLite support built-in. Configure in <code>config.json</code></p>
+          <p>MySQL and SQLite support built-in. Configure in <code>odac.json</code></p>
         </div>
       </div>
 

package/template/view/head/main.html

@@ -1,5 +1,5 @@
 <meta charset="UTF-8" />
 <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-<title>Odac</title>
+<title>ODAC</title>
 <meta name="description" content="A next-generation server and framework toolkit for modern web development" />
-<link rel="stylesheet" href="/assets/css/style.css" />
+<link rel="stylesheet" href="/assets/css/app.css" />

package/test/Client.test.js

@@ -0,0 +1,168 @@
+describe('Client (odac.js)', () => {
+  let mockXhr
+
+  beforeEach(() => {
+    jest.resetModules()
+
+    mockXhr = {
+      open: jest.fn(),
+      setRequestHeader: jest.fn(),
+      send: jest.fn(),
+      getResponseHeader: jest.fn(),
+      status: 200,
+      responseText: '{}',
+      response: '{}',
+      onload: null,
+      onerror: null
+    }
+
+    const mockDocument = {
+      getElementById: jest.fn(),
+      querySelectorAll: jest.fn(() => []),
+      querySelector: jest.fn(),
+      addEventListener: jest.fn(),
+      removeEventListener: jest.fn(),
+      dispatchEvent: jest.fn(),
+      documentElement: {dataset: {}},
+      cookie: '',
+      readyState: 'complete',
+      createElement: jest.fn(() => ({
+        setAttribute: jest.fn(),
+        style: {},
+        appendChild: jest.fn(),
+        parentNode: {insertBefore: jest.fn()}
+      }))
+    }
+
+    const mockWindow = {
+      location: {
+        protocol: 'http:',
+        host: 'localhost',
+        href: 'http://localhost/'
+      },
+      history: {
+        pushState: jest.fn()
+      },
+      scrollTo: jest.fn(),
+      addEventListener: jest.fn(),
+      XMLHttpRequest: jest.fn(() => mockXhr),
+      localStorage: {
+        getItem: jest.fn(),
+        setItem: jest.fn(),
+        removeItem: jest.fn()
+      },
+      CustomEvent: jest.fn((name, detail) => ({name, detail})),
+      setTimeout: jest.fn(),
+      clearTimeout: jest.fn(),
+      requestAnimationFrame: jest.fn(cb => cb(Date.now())),
+      WebSocket: jest.fn(() => ({
+        send: jest.fn(),
+        close: jest.fn(),
+        readyState: 1 // OPEN
+      })),
+      FormData: jest.fn()
+    }
+
+    mockWindow.window = mockWindow
+    mockWindow.document = mockDocument
+    mockWindow.WebSocket.OPEN = 1
+    mockWindow.WebSocket.CLOSED = 3
+
+    global.window = mockWindow
+    global.document = mockDocument
+    global.location = mockWindow.location
+    global.XMLHttpRequest = mockWindow.XMLHttpRequest
+    global.localStorage = mockWindow.localStorage
+    global.CustomEvent = mockWindow.CustomEvent
+    global.WebSocket = mockWindow.WebSocket
+    global.setTimeout = mockWindow.setTimeout
+    global.clearTimeout = mockWindow.clearTimeout
+    global.requestAnimationFrame = mockWindow.requestAnimationFrame
+    global.FormData = mockWindow.FormData
+
+    delete require.cache[require.resolve('../client/odac.js')]
+    require('../client/odac.js')
+  })
+
+  afterEach(() => {
+    delete global.window
+    delete global.document
+    delete global.location
+    delete global.XMLHttpRequest
+    delete global.localStorage
+    delete global.CustomEvent
+    delete global.WebSocket
+    delete global.setTimeout
+    delete global.clearTimeout
+    delete global.requestAnimationFrame
+    delete global.FormData
+    delete global.Odac
+  })
+
+  test('Odac should be initialized on window', () => {
+    expect(window.Odac).toBeDefined()
+  })
+
+  describe('data()', () => {
+    test('should retrieve data from odac-data script tag', () => {
+      const mockData = {user: 'emre'}
+      document.getElementById.mockReturnValue({
+        textContent: JSON.stringify(mockData)
+      })
+
+      const result = window.Odac.data()
+      expect(result).toEqual(mockData)
+      expect(document.getElementById).toHaveBeenCalledWith('odac-data')
+    })
+
+    test('should return specific key from data', () => {
+      const mockData = {user: 'emre', role: 'admin'}
+      document.getElementById.mockReturnValue({
+        textContent: JSON.stringify(mockData)
+      })
+
+      expect(window.Odac.data('user')).toBe('emre')
+      expect(window.Odac.data('role')).toBe('admin')
+    })
+  })
+
+  describe('storage()', () => {
+    test('should get item from localStorage', () => {
+      localStorage.getItem.mockReturnValue('val')
+      expect(window.Odac.storage('key')).toBe('val')
+      expect(localStorage.getItem).toHaveBeenCalledWith('key')
+    })
+
+    test('should set item in localStorage', () => {
+      window.Odac.storage('key', 'val')
+      expect(localStorage.setItem).toHaveBeenCalledWith('key', 'val')
+    })
+  })
+
+  describe('token()', () => {
+    test('should fetch token via sync XHR if hash is empty', () => {
+      mockXhr.response = JSON.stringify({token: 'new-token'})
+      document.cookie = 'odac_client=abc'
+
+      const token = window.Odac.token()
+
+      expect(window.XMLHttpRequest).toHaveBeenCalled()
+      expect(token).toBe('new-token')
+    })
+  })
+
+  describe('OdacWebSocket', () => {
+    test('should connect to WebSocket and handle events', () => {
+      const ws = window.Odac.ws('/test-ws', {token: false})
+      expect(window.WebSocket).toHaveBeenCalled()
+
+      const openHandler = jest.fn()
+      ws.on('open', openHandler)
+
+      const socketInstance = WebSocket.mock.results[0].value
+      socketInstance.onopen()
+
+      expect(openHandler).toHaveBeenCalled()
+    })
+  })
+})

package/test/Config.test.js

@@ -0,0 +1,112 @@
+const fs = require('fs')
+const os = require('os')
+
+const Config = require('../src/Config')
+
+jest.mock('fs')
+jest.mock('os')
+
+describe('Config', () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+    // Reset global.__dir which is used in Config.js
+    global.__dir = '/mock/project'
+
+    // Reset Config properties to defaults before each test
+    Config.system = undefined
+    Config.encrypt.key = 'odac'
+  })
+
+  describe('init', () => {
+    it('should load system config from home directory', () => {
+      os.homedir.mockReturnValue('/home/user')
+      fs.readFileSync.mockImplementation(path => {
+        if (path === '/home/user/.odac/config.json') {
+          return JSON.stringify({deviceId: '123'})
+        }
+        return '{}'
+      })
+      fs.existsSync.mockReturnValue(false)
+
+      Config.init()
+
+      expect(Config.system).toEqual({deviceId: '123'})
+      expect(fs.readFileSync).toHaveBeenCalledWith('/home/user/.odac/config.json')
+    })
+
+    it('should load project config and merge it', () => {
+      os.homedir.mockReturnValue('/home/user')
+      fs.existsSync.mockImplementation(path => {
+        if (path === '/mock/project/odac.json') return true
+        return false
+      })
+      fs.readFileSync.mockImplementation(path => {
+        if (path === '/mock/project/odac.json') {
+          return JSON.stringify({encrypt: {key: 'secret'}})
+        }
+        return '{}'
+      })
+
+      Config.init()
+
+      // The key gets hashed in init(), so it won't be 'secret' anymore
+      expect(Config.encrypt.key).not.toBe('secret')
+      expect(Config.encrypt.key).toBeInstanceOf(Buffer)
+    })
+
+    it('should interpolate variables in config', () => {
+      process.env.TEST_VAR = 'env_value'
+      os.homedir.mockReturnValue('/home/user')
+      fs.existsSync.mockReturnValue(true)
+      fs.readFileSync.mockReturnValue(
+        JSON.stringify({
+          custom: 'value-${TEST_VAR}'
+        })
+      )
+
+      Config.init()
+
+      expect(Config.custom).toBe('value-env_value')
+    })
+  })
+
+  describe('_interpolate', () => {
+    it('should replace ${VAR} with environment variables', () => {
+      process.env.FOO = 'bar'
+      const result = Config._interpolate('hello-${FOO}')
+      expect(result).toBe('hello-bar')
+    })
+
+    it('should replace ${odac} with client path', () => {
+      // __dirname in Config.js is /.../src, so it replaces /src with /client
+      const result = Config._interpolate('path-${odac}')
+      expect(result).toMatch(/\/client$/)
+    })
+
+    it('should handle nested objects and arrays', () => {
+      process.env.VAR = 'x'
+      const obj = {
+        a: ['${VAR}'],
+        b: {c: '${VAR}'}
+      }
+      const result = Config._interpolate(obj)
+      expect(result).toEqual({
+        a: ['x'],
+        b: {c: 'x'}
+      })
+    })
+  })
+
+  describe('_deepMerge', () => {
+    it('should merge objects deeply', () => {
+      const target = {a: {b: 1}, c: 2}
+      const source = {a: {d: 3}, e: 4}
+      Config._deepMerge(target, source)
+      expect(target).toEqual({
+        a: {b: 1, d: 3},
+        c: 2,
+        e: 4
+      })
+    })
+  })
+})

package/test/Lang.test.js

@@ -0,0 +1,92 @@
+const fs = require('fs')
+const Lang = require('../src/Lang')
+
+jest.mock('fs')
+
+describe('Lang', () => {
+  let mockOdac
+  let lang
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+    global.__dir = '/mock/project'
+
+    mockOdac = {
+      Config: {lang: {default: 'en'}},
+      Var: jest.fn(val => ({
+        is: jest.fn(type => type === 'alpha' && /^[a-zA-Z]+$/.test(val))
+      })),
+      Request: {
+        header: jest.fn()
+      }
+    }
+
+    // Default fs mock behaviors
+    fs.existsSync.mockReturnValue(false)
+    fs.mkdirSync.mockImplementation(() => {})
+    fs.writeFileSync.mockImplementation(() => {})
+    fs.readFileSync.mockImplementation(() => {
+      throw new Error('ENOENT')
+    })
+
+    lang = new Lang(mockOdac)
+  })
+
+  describe('constructor and set', () => {
+    it('should default to en when no config or header', () => {
+      lang = new Lang(mockOdac)
+      // Private #lang is not accessible, but we can check where it tries to save
+      lang.get('test')
+      expect(fs.writeFileSync).toHaveBeenCalledWith(expect.stringContaining('/en.json'), expect.any(String))
+    })
+
+    it('should use lang from header if available', () => {
+      mockOdac.Request.header.mockReturnValue('tr-TR')
+      lang = new Lang(mockOdac)
+      lang.get('test')
+      expect(fs.writeFileSync).toHaveBeenCalledWith(expect.stringContaining('/tr.json'), expect.any(String))
+    })
+
+    it('should use explicit lang in set()', () => {
+      lang = new Lang(mockOdac)
+      lang.set('fr')
+      lang.get('test')
+      expect(fs.writeFileSync).toHaveBeenCalledWith(expect.stringContaining('/fr.json'), expect.any(String))
+    })
+  })
+
+  describe('get', () => {
+    it('should return matching string and support placeholders', () => {
+      // Mock loading tr.json
+      fs.existsSync.mockImplementation(path => path.includes('/tr.json'))
+      fs.readFileSync.mockReturnValue(
+        JSON.stringify({
+          welcome: 'Merhaba %s!'
+        })
+      )
+
+      lang.set('tr')
+      expect(lang.get('welcome', 'Emre')).toBe('Merhaba Emre!')
+    })
+
+    it('should support numbered placeholders', () => {
+      fs.existsSync.mockImplementation(path => path.includes('/en.json'))
+      fs.readFileSync.mockReturnValue(
+        JSON.stringify({
+          order: 'First: %s1, Second: %s2'
+        })
+      )
+
+      lang.set('en')
+      expect(lang.get('order', 'A', 'B')).toBe('First: A, Second: B')
+    })
+
+    it('should auto-save new keys', () => {
+      lang.set('en')
+      const result = lang.get('new_key')
+
+      expect(result).toBe('new_key')
+      expect(fs.writeFileSync).toHaveBeenCalledWith(expect.stringContaining('/en.json'), expect.stringContaining('"new_key": "new_key"'))
+    })
+  })
+})

package/test/Odac.test.js

@@ -0,0 +1,88 @@
+const Odac = require('../src/Odac')
+
+// Mock all dependencies
+jest.mock('../src/Storage', () => ({init: jest.fn()}))
+jest.mock('../src/Env', () => ({init: jest.fn(), get: jest.fn()}))
+jest.mock('../src/Config', () => ({
+  init: jest.fn(),
+  request: {timeout: 10000},
+  lang: {default: 'en'}
+}))
+jest.mock('../src/Database', () => ({init: jest.fn()}))
+jest.mock('../src/Ipc', () => ({init: jest.fn(), subscribe: jest.fn(), unsubscribe: jest.fn()}))
+jest.mock('../src/Route', () => {
+  return jest.fn().mockImplementation(() => ({
+    init: jest.fn(),
+    routes: {
+      www: {}
+    }
+  }))
+})
+jest.mock('../src/Server', () => ({init: jest.fn()}))
+
+describe('Odac', () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+    global.__dir = '/mock/project'
+  })
+
+  describe('init', () => {
+    it('should initialize all components and set global.Odac', async () => {
+      await Odac.init()
+      expect(global.Odac).toBeDefined()
+      expect(global.Odac.Storage).toBeDefined()
+      expect(global.Odac.Config).toBeDefined()
+      expect(global.Odac.Env).toBeDefined()
+      expect(global.Odac.Database).toBeDefined()
+      expect(global.Odac.Ipc).toBeDefined()
+      expect(global.Odac.Route).toBeDefined()
+      expect(global.Odac.Server).toBeDefined()
+      expect(typeof global.__).toBe('function')
+    })
+  })
+
+  describe('instance', () => {
+    it('should create a context object without req/res', () => {
+      const ctx = Odac.instance('id-123')
+      expect(ctx.Config).toBeDefined()
+      expect(ctx.Database).toBeDefined()
+      expect(ctx.Ipc).toBeDefined()
+      expect(ctx.Request).toBeUndefined()
+    })
+
+    it('should create a context object with req/res', () => {
+      const mockReq = {url: '/', method: 'GET', headers: {host: 'example.com'}, connection: {remoteAddress: '127.0.0.1'}, on: jest.fn()}
+      const mockRes = {writeHead: jest.fn(), end: jest.fn(), finished: false}
+      const ctx = Odac.instance('id-123', mockReq, mockRes)
+      expect(ctx.Request).toBeDefined()
+      expect(ctx.Auth).toBeDefined()
+      expect(ctx.Token).toBeDefined()
+      expect(ctx.Lang).toBeDefined()
+      expect(ctx.View).toBeDefined()
+      ctx.cleanup()
+    })
+
+    it('should provide helper methods on the context', () => {
+      const mockReq = {url: '/', method: 'GET', headers: {host: 'example.com'}, connection: {remoteAddress: '127.0.0.1'}, on: jest.fn()}
+      const mockRes = {writeHead: jest.fn(), end: jest.fn(), write: jest.fn(), finished: false}
+      const ctx = Odac.instance('id-123', mockReq, mockRes)
+
+      expect(typeof ctx.env).toBe('function')
+      expect(typeof ctx.return).toBe('function')
+      expect(typeof ctx.write).toBe('function')
+      ctx.cleanup()
+    })
+
+    it('should handle Ipc subscription through Proxy', async () => {
+      const ctx = Odac.instance('id-123')
+      const callback = jest.fn()
+      const IpcSingleton = require('../src/Ipc')
+      IpcSingleton.subscribe.mockResolvedValue('sub-id')
+
+      await ctx.Ipc.subscribe('test-channel', callback)
+
+      expect(IpcSingleton.subscribe).toHaveBeenCalledWith('test-channel', callback)
+      expect(ctx._ipcSubs).toHaveLength(1)
+    })
+  })
+})

package/test/{framework/middleware.test.js → Route/Middleware.test.js}

@@ -1,4 +1,4 @@
-const Route = require('../../framework/src/Route.js')
+const Route = require('../../src/Route.js')
 
 describe('Middleware System', () => {
   let route
@@ -52,7 +52,7 @@ describe('Middleware System', () => {
 
   test('chaining should work: auth.use().page()', () => {
     route.auth.use('admin').page('/admin', () => {})
-    expect(route.routes.test.page['/admin'].middlewares).toEqual(['admin'])
+    expect(route.routes.test['#page']['/admin'].middlewares).toEqual(['admin'])
   })
 
   test('middlewares should be attached to routes', () => {