odac 1.0.1 → 1.2.0

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,86 @@
+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 = {}
+      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()
+    })
+
+    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 = {end: jest.fn(), write: jest.fn()}
+      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')
+    })
+
+    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', () => {

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

@@ -1,4 +1,4 @@
-const Route = require('../../framework/src/Route')
+const Route = require('../src/Route')
 
 describe('Route', () => {
   let route

package/test/{framework/View → View}/EarlyHints.test.js

@@ -1,4 +1,4 @@
-const EarlyHints = require('../../../framework/src/View/EarlyHints')
+const EarlyHints = require('../../src/View/EarlyHints')
 
 describe('EarlyHints', () => {
   let earlyHints

package/test/{framework/WebSocket.test.js → WebSocket.test.js}

@@ -1,4 +1,4 @@
-const {WebSocketServer} = require('../../framework/src/WebSocket.js')
+const {WebSocketServer} = require('../src/WebSocket.js')
 
 describe('WebSocketServer', () => {
   let server
@@ -67,7 +67,7 @@ describe('WebSocketServer', () => {
 })
 
 describe('Route WebSocket Integration', () => {
-  const Route = require('../../framework/src/Route.js')
+  const Route = require('../src/Route.js')
 
   beforeEach(() => {
     global.Odac = {

package/test/scripts/check-coverage.js

@@ -17,7 +17,7 @@ function getStagedFiles() {
     return output
       .split('\n')
       .filter(file => file.endsWith('.js'))
-      .filter(file => file.startsWith('core/') || file.startsWith('server/'))
+      .filter(file => file.startsWith('src/') || file.startsWith('client/'))
       .filter(file => !file.includes('.test.js') && !file.includes('.spec.js'))
   } catch (err) {
     console.error('Error getting staged files:', err.message)
@@ -34,7 +34,7 @@ function checkTestFiles(changedFiles) {
     if (!fs.existsSync(file)) continue
 
     // Determine test file path
-    const testFile = file.replace(/^(core|server)\//, 'test/$1/').replace(/\.js$/, '.test.js')
+    const testFile = file.replace(/^(src|client)\//, 'test/').replace(/\.js$/, '.test.js')
 
     if (!fs.existsSync(testFile)) {
       missingTests.push({
@@ -60,7 +60,7 @@ function runTestsForFiles(files) {
     // Create a pattern to match test files for changed source files
     const testPatterns = files
       .map(file => {
-        const testFile = file.replace(/^(core|server)\//, 'test/$1/').replace(/\.js$/, '.test.js')
+        const testFile = file.replace(/^(src|client)\//, 'test/').replace(/\.js$/, '.test.js')
         return testFile
       })
       .filter(testFile => fs.existsSync(testFile))
@@ -98,7 +98,7 @@ function main() {
   const changedFiles = getStagedFiles()
 
   if (changedFiles.length === 0) {
-    console.log('✓ No core or server files changed\n')
+    console.log('✓ No src or client files changed\n')
     process.exit(0)
   }
 

package/docs/backend/08-database/01-database-connection.md

@@ -1,99 +0,0 @@
-## 🔌 Database Connection
-
-Odac automatically connects to your MySQL database when you provide the configuration.
-
-### Configuration
-
-Add your database credentials to `config.json`:
-
-```json
-{
-  "database": {
-    "host": "localhost",
-    "user": "your_username",
-    "password": "your_password",
-    "database": "your_database_name"
-  }
-}
-```
-
-### Multiple Databases
-
-You can configure multiple database connections:
-
-```json
-{
-  "database": {
-    "default": {
-      "host": "localhost",
-      "user": "user1",
-      "password": "pass1",
-      "database": "main_db"
-    },
-    "analytics": {
-      "host": "analytics.example.com",
-      "user": "user2",
-      "password": "pass2",
-      "database": "analytics_db"
-    }
-  }
-}
-```
-
-Access different databases:
-
-```javascript
-// Default database
-const users = await Odac.Mysql.table('users').get()
-
-// Specific database
-const stats = await Odac.Mysql.database('analytics').table('stats').get()
-```
-
-### Environment Variables
-
-For security, use environment variables for sensitive data:
-
-**.env file:**
-```
-DB_HOST=localhost
-DB_USER=myuser
-DB_PASSWORD=mypassword
-DB_NAME=mydatabase
-```
-
-**config.json:**
-```json
-{
-  "database": {
-    "host": "${DB_HOST}",
-    "user": "${DB_USER}",
-    "password": "${DB_PASSWORD}",
-    "database": "${DB_NAME}"
-  }
-}
-```
-
-### Connection Options
-
-Available configuration options:
-
-- `host` - Database server hostname (default: `localhost`)
-- `user` - Database username
-- `password` - Database password
-- `database` - Database name
-- `type` - Database type (currently only `mysql` is supported)
-
-### Automatic Connection
-
-The connection is established automatically when your application starts. You don't need to write any connection code - just use `Odac.Mysql` in your controllers.
-
-```javascript
-module.exports = async function (Odac) {
-  // Connection is already established
-  const users = await Odac.Mysql.table('users').get()
-  
-  Odac.set('users', users)
-  Odac.View.set({ skeleton: 'main', content: 'users' })
-}
-```