odac 0.9.0 → 1.0.0

package/{framework/web/candy.js → client/odac.js}

@@ -1,4 +1,4 @@
-class candy {
+class Odac {
   actions = {}
   #data = null
   fn = {}
@@ -52,7 +52,7 @@ class candy {
         }
 
         document.dispatchEvent(
-          new CustomEvent('candy:ajaxSuccess', {
+          new CustomEvent('odac:ajaxSuccess', {
             detail: {response: responseData, status: xhr.statusText, xhr, requestUrl: url}
           })
         )
@@ -245,14 +245,14 @@ class candy {
   }
 
   client() {
-    if (!document.cookie.includes('candy_client=')) return null
-    return document.cookie.split('candy_client=')[1].split(';')[0]
+    if (!document.cookie.includes('odac_client=')) return null
+    return document.cookie.split('odac_client=')[1].split(';')[0]
   }
 
   data() {
     if (this.#data) return this.#data
-    if (!document.cookie.includes('candy_data=')) return null
-    return JSON.parse(unescape(document.cookie.split('candy_data=')[1].split(';')[0]))
+    if (!document.cookie.includes('odac_data=')) return null
+    return JSON.parse(unescape(document.cookie.split('odac_data=')[1].split(';')[0]))
   }
 
   form(obj, callback) {
@@ -284,11 +284,11 @@ class candy {
 
         const customMessage = input.getAttribute(`data-error-${errorType}`)
         if (customMessage) {
-          let errorSpan = formElement.querySelector(`[candy-form-error="${input.name}"]`)
+          let errorSpan = formElement.querySelector(`[odac-form-error="${input.name}"]`)
 
           if (!errorSpan) {
             errorSpan = document.createElement('span')
-            errorSpan.setAttribute('candy-form-error', input.name)
+            errorSpan.setAttribute('odac-form-error', input.name)
 
             if ((input.type === 'checkbox' || input.type === 'radio') && input.id) {
               const label = formElement.querySelector(`label[for="${input.id}"]`)
@@ -309,7 +309,7 @@ class candy {
 
       for (const input of inputs) {
         input.style.borderColor = ''
-        const errorSpan = formElement.querySelector(`[candy-form-error="${input.name}"]`)
+        const errorSpan = formElement.querySelector(`[odac-form-error="${input.name}"]`)
         if (errorSpan) {
           errorSpan.style.display = 'none'
           errorSpan.textContent = ''
@@ -355,13 +355,13 @@ class candy {
 
       let actions = this.actions
       if (
-        actions.candy &&
-        actions.candy.form &&
-        actions.candy.form.input &&
-        actions.candy.form.input.class &&
-        actions.candy.form.input.class.invalid
+        actions.odac &&
+        actions.odac.form &&
+        actions.odac.form.input &&
+        actions.odac.form.input.class &&
+        actions.odac.form.input.class.invalid
       ) {
-        const invalidClass = actions.candy.form.input.class.invalid
+        const invalidClass = actions.odac.form.input.class.invalid
         formElement
           .querySelectorAll(`select.${invalidClass},input.${invalidClass},textarea.${invalidClass}`)
           .forEach(el => el.classList.remove(invalidClass))
@@ -369,10 +369,10 @@ class candy {
 
       if (obj.messages !== false) {
         if (obj.messages == undefined || obj.messages == true || obj.messages.includes('error')) {
-          formElement.querySelectorAll('*[candy-form-error]').forEach(el => (el.style.display = 'none'))
+          formElement.querySelectorAll('*[odac-form-error]').forEach(el => (el.style.display = 'none'))
         }
         if (obj.messages == undefined || obj.messages == true || obj.messages.includes('success')) {
-          formElement.querySelectorAll('*[candy-form-success]').forEach(el => (el.style.display = 'none'))
+          formElement.querySelectorAll('*[odac-form-success]').forEach(el => (el.style.display = 'none'))
         }
       }
 
@@ -414,17 +414,20 @@ class candy {
           if (!data.result) return false
           if (obj.messages == undefined || obj.messages) {
             if (data.result.success && (obj.messages == undefined || obj.messages.includes('success') || obj.messages == true)) {
-              const successEl = formElement.querySelector('*[candy-form-success]')
+              const successEl = formElement.querySelector('*[odac-form-success]')
               if (successEl) {
                 successEl.innerHTML = data.result.message
                 this.#fadeIn(successEl)
               } else {
-                formElement.insertAdjacentHTML('beforeend', `<span candy-form-success="${obj.form}">${data.result.message}</span>`)
+                const span = document.createElement('span')
+                span.setAttribute('odac-form-success', obj.form)
+                span.textContent = data.result.message
+                formElement.appendChild(span)
               }
             } else if (!data.result.success && data.errors) {
               Object.entries(data.errors).forEach(([name, message]) => {
                 if (message) {
-                  let errorEl = formElement.querySelector(`[candy-form-error="${name}"]`)
+                  let errorEl = formElement.querySelector(`[odac-form-error="${name}"]`)
                   if (errorEl) {
                     errorEl.textContent = message
                     errorEl.style.cssText = 'display:block;color:#dc3545;font-size:0.875rem;margin-top:0.25rem'
@@ -432,7 +435,7 @@ class candy {
                     const inputEl = formElement.querySelector(`*[name="${name}"]`)
                     if (inputEl) {
                       errorEl = document.createElement('span')
-                      errorEl.setAttribute('candy-form-error', name)
+                      errorEl.setAttribute('odac-form-error', name)
                       errorEl.textContent = message
                       errorEl.style.cssText = 'display:block;color:#dc3545;font-size:0.875rem;margin-top:0.25rem'
 
@@ -446,9 +449,9 @@ class candy {
                       } else {
                         inputEl.parentNode.insertBefore(errorEl, inputEl.nextSibling)
                       }
-                    } else if (name === '_candy_form') {
+                    } else if (name === '_odac_form') {
                       errorEl = document.createElement('div')
-                      errorEl.setAttribute('candy-form-error', name)
+                      errorEl.setAttribute('odac-form-error', name)
                       errorEl.textContent = message
                       errorEl.style.cssText =
                         'display:block;color:#dc3545;background-color:#f8d7da;border:1px solid #f5c2c7;border-radius:0.375rem;padding:0.75rem 1rem;margin-bottom:1rem;font-size:0.875rem'
@@ -465,7 +468,7 @@ class candy {
                     'focus',
                     function handler() {
                       inputEl.style.borderColor = ''
-                      const errorEl = formElement.querySelector(`[candy-form-error="${name}"]`)
+                      const errorEl = formElement.querySelector(`[odac-form-error="${name}"]`)
                       if (errorEl) {
                         errorEl.style.display = 'none'
                         errorEl.textContent = ''
@@ -500,7 +503,7 @@ class candy {
           return xhr
         },
         error: () => {
-          console.error('CandyJS:', 'Somethings went wrong...', '\nForm: ' + obj.form + '\nRequest: ' + formElement.getAttribute('action'))
+          console.error('Odac:', 'Somethings went wrong...', '\nForm: ' + obj.form + '\nRequest: ' + formElement.getAttribute('action'))
         },
         complete: () => {
           const submitButtons = formElement.querySelectorAll('button[type="submit"], input[type="submit"]')
@@ -541,12 +544,12 @@ class candy {
 
   token() {
     if (!this.#token.listener) {
-      document.addEventListener('candy:ajaxSuccess', event => {
+      document.addEventListener('odac:ajaxSuccess', event => {
         const {detail} = event
         const {xhr, requestUrl} = detail
         if (requestUrl.includes('://')) return false
         try {
-          const token = xhr.getResponseHeader('X-Candy-Token')
+          const token = xhr.getResponseHeader('X-Odac-Token')
           if (token) this.#token.hash.push(token)
           if (this.#token.hash.length > 2) this.#token.hash.shift()
         } catch (e) {
@@ -558,8 +561,8 @@ class candy {
     if (!this.#token.hash.length) {
       var req = new XMLHttpRequest()
       req.open('GET', '/', false)
-      req.setRequestHeader('X-Candy', 'token')
-      req.setRequestHeader('X-Candy-Client', this.client())
+      req.setRequestHeader('X-Odac', 'token')
+      req.setRequestHeader('X-Odac-Client', this.client())
       req.send(null)
       var req_data = JSON.parse(req.response)
       if (req_data.token) this.#token.hash.push(req_data.token)
@@ -570,7 +573,7 @@ class candy {
       this.#ajax({
         url: '/',
         type: 'GET',
-        headers: {'X-Candy': 'token', 'X-Candy-Client': this.client()},
+        headers: {'X-Odac': 'token', 'X-Odac-Client': this.client()},
         success: data => {
           var result = JSON.parse(JSON.stringify(data))
           if (result.token) this.#token.hash.push(result.token)
@@ -622,7 +625,7 @@ class candy {
         window.history.pushState(null, document.title, finalUrl)
       }
 
-      const newPage = ajaxXhr.getResponseHeader('X-Candy-Page')
+      const newPage = ajaxXhr.getResponseHeader('X-Odac-Page')
       if (newPage !== null) {
         this.#page = newPage
         document.documentElement.dataset.candyPage = newPage
@@ -668,9 +671,9 @@ class candy {
       url: url,
       type: 'GET',
       headers: {
-        'X-Candy': 'ajaxload',
-        'X-Candy-Load': Object.keys(this.#loader.elements).join(','),
-        'X-Candy-Skeleton': currentSkeleton || ''
+        'X-Odac': 'ajaxload',
+        'X-Odac-Load': Object.keys(this.#loader.elements).join(','),
+        'X-Odac-Skeleton': currentSkeleton || ''
       },
       dataType: 'json',
       success: (data, status, xhr) => {
@@ -799,16 +802,279 @@ class candy {
       }
     }
   }
+
+  ws(path, options = {}) {
+    const {autoReconnect = true, reconnectDelay = 3000, maxReconnectAttempts = 10, shared = false, token = true} = options
+
+    if (shared && typeof SharedWorker !== 'undefined') {
+      return this.#createSharedWebSocket(path, {autoReconnect, reconnectDelay, maxReconnectAttempts, token})
+    }
+
+    let socket = null
+    let reconnectTimer = null
+    let reconnectAttempts = 0
+    let isClosed = false
+    const handlers = {}
+
+    const emit = (event, ...args) => {
+      if (handlers[event]) {
+        handlers[event].forEach(fn => fn(...args))
+      }
+    }
+
+    const connect = () => {
+      if (isClosed) return
+
+      const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:'
+      const wsUrl = `${protocol}//${window.location.host}${path}`
+
+      const protocols = []
+      if (token) {
+        const csrfToken = this.token()
+        if (csrfToken) {
+          protocols.push(`odac-token-${csrfToken}`)
+        }
+      }
+
+      socket = protocols.length > 0 ? new WebSocket(wsUrl, protocols) : new WebSocket(wsUrl)
+
+      socket.onopen = () => {
+        reconnectAttempts = 0
+        emit('open')
+      }
+
+      socket.onmessage = e => {
+        try {
+          const data = JSON.parse(e.data)
+          emit('message', data)
+        } catch {
+          emit('message', e.data)
+        }
+      }
+
+      socket.onclose = e => {
+        emit('close', e)
+
+        if (autoReconnect && !isClosed && reconnectAttempts < maxReconnectAttempts) {
+          reconnectAttempts++
+          reconnectTimer = setTimeout(connect, reconnectDelay)
+        }
+      }
+
+      socket.onerror = e => {
+        emit('error', e)
+      }
+    }
+
+    connect()
+
+    return {
+      on: (event, handler) => {
+        if (!handlers[event]) handlers[event] = []
+        handlers[event].push(handler)
+        return this
+      },
+      off: (event, handler) => {
+        if (!handlers[event]) return
+        if (handler) {
+          handlers[event] = handlers[event].filter(h => h !== handler)
+        } else {
+          delete handlers[event]
+        }
+        return this
+      },
+      send: data => {
+        if (socket && socket.readyState === WebSocket.OPEN) {
+          socket.send(typeof data === 'object' ? JSON.stringify(data) : data)
+        }
+        return this
+      },
+      close: () => {
+        isClosed = true
+        if (reconnectTimer) clearTimeout(reconnectTimer)
+        if (socket) socket.close()
+      },
+      get state() {
+        return socket ? socket.readyState : WebSocket.CLOSED
+      },
+      get connected() {
+        return socket && socket.readyState === WebSocket.OPEN
+      }
+    }
+  }
+
+  #createSharedWebSocket(path, options) {
+    const workerUrl = this.#createWorkerBlob()
+    const worker = new SharedWorker(workerUrl, `odac-ws-${path}`)
+    const handlers = {}
+    let isConnected = false
+
+    const emit = (event, ...args) => {
+      if (handlers[event]) {
+        handlers[event].forEach(fn => fn(...args))
+      }
+    }
+
+    worker.port.onmessage = e => {
+      const {type, data} = e.data
+
+      switch (type) {
+        case 'open':
+          isConnected = true
+          emit('open')
+          break
+        case 'message':
+          emit('message', data)
+          break
+        case 'close':
+          isConnected = false
+          emit('close', data)
+          break
+        case 'error':
+          emit('error', data)
+          break
+      }
+    }
+
+    worker.port.start()
+
+    const token = options.token ? this.token() : null
+
+    worker.port.postMessage({
+      type: 'connect',
+      path,
+      host: window.location.host,
+      protocol: window.location.protocol === 'https:' ? 'wss:' : 'ws:',
+      token,
+      options
+    })
+
+    return {
+      on: (event, handler) => {
+        if (!handlers[event]) handlers[event] = []
+        handlers[event].push(handler)
+        return this
+      },
+      off: (event, handler) => {
+        if (!handlers[event]) return
+        if (handler) {
+          handlers[event] = handlers[event].filter(h => h !== handler)
+        } else {
+          delete handlers[event]
+        }
+        return this
+      },
+      send: data => {
+        worker.port.postMessage({
+          type: 'send',
+          data: typeof data === 'object' ? JSON.stringify(data) : data
+        })
+        return this
+      },
+      close: () => {
+        worker.port.postMessage({type: 'close'})
+        worker.port.close()
+      },
+      get connected() {
+        return isConnected
+      }
+    }
+  }
+
+  #createWorkerBlob() {
+    const workerCode = `
+      let socket = null
+      let reconnectTimer = null
+      let reconnectAttempts = 0
+      let options = {}
+      let protocols = []
+      const ports = new Set()
+
+      function broadcast(type, data) {
+        ports.forEach(port => {
+          port.postMessage({type, data})
+        })
+      }
+
+      function connect(wsUrl, protocols) {
+        if (socket && socket.readyState !== WebSocket.CLOSED) return
+
+        socket = protocols && protocols.length > 0 ? new WebSocket(wsUrl, protocols) : new WebSocket(wsUrl)
+
+        socket.onopen = () => {
+          reconnectAttempts = 0
+          broadcast('open')
+        }
+
+        socket.onmessage = e => {
+          try {
+            const data = JSON.parse(e.data)
+            broadcast('message', data)
+          } catch {
+            broadcast('message', e.data)
+          }
+        }
+
+        socket.onclose = e => {
+          broadcast('close', e)
+
+          if (options.autoReconnect && reconnectAttempts < options.maxReconnectAttempts) {
+            reconnectAttempts++
+            reconnectTimer = setTimeout(() => connect(wsUrl, protocols), options.reconnectDelay)
+          }
+        }
+
+        socket.onerror = e => {
+          broadcast('error', e)
+        }
+      }
+
+      self.onconnect = e => {
+        const port = e.ports[0]
+        ports.add(port)
+
+        port.onmessage = event => {
+          const {type, path, host, protocol, token, options: opts, data} = event.data
+
+          switch (type) {
+            case 'connect':
+              options = opts
+              const wsUrl = protocol + '//' + host + path
+              protocols = token ? ['odac-token-' + token] : []
+              connect(wsUrl, protocols)
+              break
+            case 'send':
+              if (socket && socket.readyState === WebSocket.OPEN) {
+                socket.send(data)
+              }
+              break
+            case 'close':
+              ports.delete(port)
+              if (ports.size === 0 && socket) {
+                socket.close()
+                socket = null
+              }
+              break
+          }
+        }
+
+        port.start()
+      }
+    `
+
+    const blob = new Blob([workerCode], {type: 'application/javascript'})
+    return URL.createObjectURL(blob)
+  }
 }
 
-window.Candy = new candy()
+window.Odac = new Odac()
 
-// Auto-initialize navigation from data-candy-navigate attribute
+// Auto-initialize navigation from data-odac-navigate attribute
 ;(function initAutoNavigate() {
   const init = () => {
-    const contentEl = document.querySelector('[data-candy-navigate="content"]')
+    const contentEl = document.querySelector('[data-odac-navigate="content"]')
     if (contentEl) {
-      window.Candy.loader('a[href^="/"]:not([data-navigate="false"]):not(.no-navigate)', {content: '[data-candy-navigate="content"]'}, null)
+      window.Odac.loader('a[href^="/"]:not([data-navigate="false"]):not(.no-navigate)', {content: '[data-odac-navigate="content"]'}, null)
     }
   }
 
@@ -823,16 +1089,16 @@ document.addEventListener('DOMContentLoaded', () => {
   const formTypes = ['register', 'login']
 
   formTypes.forEach(type => {
-    const forms = document.querySelectorAll(`form.candy-${type}-form[data-candy-${type}]`)
+    const forms = document.querySelectorAll(`form.odac-${type}-form[data-odac-${type}]`)
     forms.forEach(form => {
-      const token = form.getAttribute(`data-candy-${type}`)
-      window.Candy.form({form: `form[data-candy-${type}="${token}"]`})
+      const token = form.getAttribute(`data-odac-${type}`)
+      window.Odac.form({form: `form[data-odac-${type}="${token}"]`})
     })
   })
 
-  const customForms = document.querySelectorAll('form.candy-custom-form[data-candy-form]')
+  const customForms = document.querySelectorAll('form.odac-custom-form[data-odac-form]')
   customForms.forEach(form => {
-    const token = form.getAttribute('data-candy-form')
-    window.Candy.form({form: `form[data-candy-form="${token}"]`})
+    const token = form.getAttribute('data-odac-form')
+    window.Odac.form({form: `form[data-odac-form="${token}"]`})
   })
 })

package/docs/backend/01-overview/{01-whats-in-the-candy-box.md → 01-whats-in-the-odac-box.md}

@@ -1,9 +1,11 @@
-## 🧰 What's in the `Candy` box?
+## 🧰 What's in the `Odac` box?
 
-Your `Candy` assistant comes with a bunch of handy services:
+Your `Odac` assistant comes with a bunch of handy services:
 
 *   `Request`: All the details about the user's incoming request.
 *   `View`: A tool to render your beautiful HTML pages.
 *   `Auth`: Your friendly security guard for managing the current user's login.
 *   `Token`: Helps protect the user's forms from nasty CSRF attacks.
 *   `Lang`: A helper for translating your app into the user's language.
+*   `setInterval()` / `setTimeout()`: Memory-safe timers with automatic cleanup.
+*   `stream()`: Create streaming responses (Server-Sent Events).

package/docs/backend/01-overview/02-super-handy-helper-functions.md

@@ -1,9 +1,37 @@
 ## ✨ Super-Handy Helper Functions
 
-On top of that, `Candy` has some quick-and-easy helper functions:
+On top of that, `Odac` has some quick-and-easy helper functions:
 
 *   `return(data)`: Quickly send a response back to the user and you're done.
 *   `direct(url)`: Need to send the user to another page? This is your tool.
 *   `cookie(key, value)`: Leave a little cookie in the user's browser.
 *   `env(key, defaultValue)`: Access environment variables with an optional default value.
 *   `validator()`: A powerful tool to check the user's submitted data.
+*   `setInterval(callback, delay)`: Schedule repeating tasks with automatic cleanup.
+*   `setTimeout(callback, delay)`: Schedule one-time tasks with automatic cleanup.
+*   `clearInterval(id)`: Manually clear an interval.
+*   `clearTimeout(id)`: Manually clear a timeout.
+
+### Memory-Safe Timers
+
+Odac provides memory-safe timer functions that automatically clean up when the request ends:
+
+```javascript
+module.exports = async (Odac) => {
+  // ✅ Automatically cleaned up when request ends
+  Odac.setInterval(() => {
+    console.log('This will stop when the request ends')
+  }, 1000)
+  
+  // ❌ NOT automatically cleaned up - causes memory leaks
+  setInterval(() => {
+    console.log('This keeps running forever!')
+  }, 1000)
+}
+```
+
+**Why use Odac timers?**
+- Prevents memory leaks
+- No orphaned intervals after request ends
+- Especially important for streaming/SSE endpoints
+- Automatic cleanup on connection close

package/docs/backend/01-overview/03-development-server.md

@@ -1,6 +1,6 @@
 ## 🚀 Development Server
 
-CandyPack provides a built-in development server that allows you to test your website locally without running the full CandyPack server infrastructure.
+Odac provides a built-in development server that allows you to test your website locally without running the full Odac server infrastructure.
 
 ### Quick Start
 
@@ -10,8 +10,8 @@ Navigate to your website directory and run one of these commands:
 # Using npm script
 npm start
 
-# Using CandyPack directly
-candypack framework run
+# Using Odac directly
+odac framework run
 ```
 
 Both commands will start a local development server on port `1071` by default, and your website will be accessible at `http://127.0.0.1:1071`.
@@ -24,8 +24,8 @@ You can specify a custom port by adding it as an argument:
 # Using npm script with custom port
 npm start 8080
 
-# Using CandyPack directly with custom port
-candypack framework run 8080
+# Using Odac directly with custom port
+odac framework run 8080
 ```
 
 This will start the server on your specified port (e.g., `http://127.0.0.1:8080`).
@@ -41,13 +41,13 @@ The development server (`npm start`) is designed for:
 
 **Important**: The development server does NOT provide DNS, SSL, or other production services.
 
-For production deployment with full CandyPack server features, create your website using:
+For production deployment with full Odac server features, create your website using:
 
 ```bash
-candy web create
+odac web create
 ```
 
-This registers your website with the CandyPack server and provides:
+This registers your website with the Odac server and provides:
 
 - **Automatic SSL** certificate management
 - **DNS handling** for your domain
@@ -57,12 +57,12 @@ This registers your website with the CandyPack server and provides:
 
 ### Package.json Scripts
 
-When you create a new website, CandyPack automatically generates a `package.json` with these useful scripts:
+When you create a new website, Odac automatically generates a `package.json` with these useful scripts:
 
 ```json
 {
   "scripts": {
-    "start": "candy framework run",
+    "start": "odac framework run",
     "test": "echo \"Error: no test specified\" && exit 1"
   }
 }
@@ -76,4 +76,4 @@ When you create a new website, CandyPack automatically generates a `package.json
 - The development server automatically detects changes in your code
 - Use `Ctrl+C` to stop the development server
 - The server will show helpful error messages in the console
-- All CandyPack framework features are available in development mode
+- All Odac framework features are available in development mode

package/docs/backend/02-structure/01-typical-project-layout.md

@@ -4,7 +4,7 @@ Let's take a look at a typical project layout:
 
 -   `project_root/`
     -   `config.json`: This is where you'll keep your app's secrets and settings, like database passwords or API keys.
-    -   `index.js`: The starting pistol for your web application! This file kicks off the CandyPack framework.
+    -   `index.js`: The starting pistol for your web application! This file kicks off the Odac framework.
     -   `package.json`: Contains project metadata and npm scripts for development. Automatically generated when creating a new website.
     -   `public/`: All files placed in this folder are directly accessible from the outside. This is the perfect place for your images, stylesheets, and client-side JavaScript.
     -   `route/`: This folder holds all your route definitions. The filename of the route file corresponds to the subdomain it serves.
@@ -27,13 +27,13 @@ npm start
 npm start 8080
 ```
 
-You can also use CandyPack commands directly:
+You can also use Odac commands directly:
 
 ```bash
 # Development server (local testing only)
-candypack framework run [port]
+odac framework run [port]
 ```
 
-**Note**: For production websites with DNS and SSL, use `candy web create` to register with CandyPack server.
+**Note**: For production websites with DNS and SSL, use `odac web create` to register with Odac server.
 
 Following this structure helps keep your code's responsibilities separate. Your routing logic lives in one place, your app logic in another, and your presentation files in a third. It's a recipe for success!

package/docs/backend/03-config/00-configuration-overview.md

@@ -1,6 +1,6 @@
 ## ⚙️ Configuration Overview
 
-CandyPack uses a simple and flexible configuration system based on `config.json` and optional `.env` files. You can choose the approach that best fits your needs.
+Odac uses a simple and flexible configuration system based on `config.json` and optional `.env` files. You can choose the approach that best fits your needs.
 
 ### Configuration Files
 
@@ -87,12 +87,12 @@ Combine both methods - use direct values for non-sensitive data and environment
 You can access configuration values in three ways:
 
 ```javascript
-// 1. From Candy.Config (recommended for structured config)
-const dbHost = Candy.Config.mysql.host
+// 1. From Odac.Config (recommended for structured config)
+const dbHost = Odac.Config.mysql.host
 
-// 2. Using Candy.env() helper
-const apiKey = Candy.env('API_KEY')
-const debug = Candy.env('DEBUG', 'false')
+// 2. Using Odac.env() helper
+const apiKey = Odac.env('API_KEY')
+const debug = Odac.env('DEBUG', 'false')
 
 // 3. Direct process.env access
 const nodeEnv = process.env.NODE_ENV