odac 0.9.0 → 1.0.0

package/docs/backend/03-config/01-database-connection.md

@@ -15,7 +15,7 @@ When you add a `mysql` object to your `config.json`, the system will automatical
 }
 ```
 
-Once this is configured, you can directly use `Candy.Mysql` commands to run queries.
+Once this is configured, you can directly use `Odac.Mysql` commands to run queries.
 
 ### Using Environment Variables
 

package/docs/backend/03-config/02-static-route-mapping-optional.md

@@ -4,16 +4,16 @@ Normally, all publicly served files should be in your `public` folder. However,
 
 ```json
 "route": {
-  "/assets/js/candy.js": "${candy}/framework/web/candy.js",
+  "/assets/js/odac.js": "${odac}/framework/web/odac.js",
   "/css/main.css": "/path/to/your/project/assets/css/main.css"
 }
 ```
 
-When a user visits a URL that matches a key in the `route` object, CandyPack will serve the corresponding file from your filesystem.
+When a user visits a URL that matches a key in the `route` object, Odac will serve the corresponding file from your filesystem.
 
-#### Using the `${candy}` Variable
+#### Using the `${odac}` Variable
 
-The special variable `${candy}` is a shortcut that points to the root directory where CandyPack is installed. This is helpful for linking to files that are part of the framework itself.
+The special variable `${odac}` is a shortcut that points to the root directory where Odac is installed. This is helpful for linking to files that are part of the framework itself.
 
 #### Absolute Paths
 

package/docs/backend/03-config/04-environment-variables.md

@@ -1,6 +1,6 @@
 ## 🌍 Environment Variables
 
-CandyPack supports environment variables through `.env` files, making it easy to manage sensitive data and environment-specific settings.
+Odac supports environment variables through `.env` files, making it easy to manage sensitive data and environment-specific settings.
 
 ### Creating a .env File
 
@@ -65,13 +65,13 @@ Reference environment variables using `${VARIABLE_NAME}` syntax:
 
 You can access environment variables in your controllers in three ways:
 
-#### 1. Using Candy.env() (Recommended)
+#### 1. Using Odac.env() (Recommended)
 
 ```javascript
 module.exports = function() {
-  const apiKey = Candy.env('API_KEY')
-  const debug = Candy.env('DEBUG', 'false')
-  const port = Candy.env('PORT', '3000')
+  const apiKey = Odac.env('API_KEY')
+  const debug = Odac.env('DEBUG', 'false')
+  const port = Odac.env('PORT', '3000')
   
   if (debug === 'true') {
     console.log('Debug mode enabled')
@@ -91,12 +91,12 @@ module.exports = function() {
 }
 ```
 
-#### 3. From Candy.Config (if defined in config.json)
+#### 3. From Odac.Config (if defined in config.json)
 
 ```javascript
 module.exports = function() {
-  const dbHost = Candy.Config.mysql.host
-  const apiKey = Candy.Config.api.stripe.key
+  const dbHost = Odac.Config.mysql.host
+  const apiKey = Odac.Config.api.stripe.key
 }
 ```
 
@@ -107,15 +107,15 @@ module.exports = function() {
 ```javascript
 // controller/home.js
 module.exports = function() {
-  const betaEnabled = Candy.env('FEATURE_BETA', 'false') === 'true'
-  const maintenance = Candy.env('MAINTENANCE_MODE', 'false') === 'true'
+  const betaEnabled = Odac.env('FEATURE_BETA', 'false') === 'true'
+  const maintenance = Odac.env('MAINTENANCE_MODE', 'false') === 'true'
   
   if (maintenance) {
-    return Candy.abort(503)
+    return Odac.abort(503)
   }
   
-  Candy.set('betaEnabled', betaEnabled)
-  return Candy.View.render('home')
+  Odac.set('betaEnabled', betaEnabled)
+  return Odac.View.render('home')
 }
 ```
 
@@ -124,8 +124,8 @@ module.exports = function() {
 ```javascript
 // controller/payment.js
 module.exports = async function() {
-  const stripeKey = Candy.env('STRIPE_SECRET_KEY')
-  const webhookSecret = Candy.env('STRIPE_WEBHOOK_SECRET')
+  const stripeKey = Odac.env('STRIPE_SECRET_KEY')
+  const webhookSecret = Odac.env('STRIPE_WEBHOOK_SECRET')
   
   const stripe = require('stripe')(stripeKey)
   
@@ -138,16 +138,16 @@ module.exports = async function() {
 ```javascript
 // controller/contact.js
 module.exports = async function() {
-  const mail = Candy.Mail()
+  const mail = Odac.Mail()
   
-  mail.from(Candy.env('MAIL_FROM', 'noreply@example.com'))
-  mail.to(Candy.request('email'))
+  mail.from(Odac.env('MAIL_FROM', 'noreply@example.com'))
+  mail.to(Odac.request('email'))
   mail.subject('Thank you for contacting us')
   mail.html('<h1>We received your message!</h1>')
   
   await mail.send()
   
-  return Candy.return({ success: true })
+  return Odac.return({ success: true })
 }
 ```
 
@@ -224,4 +224,4 @@ MAIL_FROM='noreply@example.com'
 - Changes to `.env` require restarting the application
 - The `.env` file is **optional** - you can use direct values in `config.json` if preferred
 - Variables defined in `.env` are available throughout your entire application
-- If a variable is not found, `Candy.env()` returns the default value or `undefined`
+- If a variable is not found, `Odac.env()` returns the default value or `undefined`

package/docs/backend/03-config/05-early-hints.md

@@ -17,7 +17,7 @@ You don't need to do anything - it just works!
 
 ### Automatic Resource Detection
 
-When your application starts, CandyPack scans your `view/` and `skeleton/` directories and builds a manifest of critical resources:
+When your application starts, Odac scans your `view/` and `skeleton/` directories and builds a manifest of critical resources:
 
 ```html
 <!-- skeleton/main.html -->
@@ -139,7 +139,7 @@ If you want to prevent specific resources from being preloaded, use the `defer`
 
 The `defer` attribute works consistently for both CSS and JavaScript:
 - **For JS**: Browser's native defer behavior (execute after DOM is ready)
-- **For CSS**: CandyPack-specific (exclude from Early Hints, but still loads normally)
+- **For CSS**: Odac-specific (exclude from Early Hints, but still loads normally)
 
 This is useful for:
 - Non-critical styles (animations, print styles)
@@ -199,9 +199,9 @@ At startup, the framework builds an in-memory manifest:
 
 ### Proxy Integration
 
-CandyPack's architecture uses a proxy layer. Early Hints are:
+Odac's architecture uses a proxy layer. Early Hints are:
 1. Generated in the framework
-2. Sent via `X-Candy-Early-Hints` header to proxy
+2. Sent via `X-Odac-Early-Hints` header to proxy
 3. Forwarded to client as `103 Early Hints` by proxy
 
 This ensures Early Hints work correctly in the multi-domain hosting environment.

package/docs/backend/04-routing/01-basic-page-routes.md

@@ -8,17 +8,17 @@ This is the most common method. It maps a URL path to a controller that is expec
 
 ```javascript
 // When a user visits yoursite.com/
-Candy.Route.page('/', 'index');
+Odac.Route.page('/', 'index');
 
 // When a user visits yoursite.com/contact
-Candy.Route.page('/contact', 'contact-form');
+Odac.Route.page('/contact', 'contact-form');
 ```
 
-**Page Identifier:** The controller filename becomes the page identifier in the frontend. For example, `'contact-form'` becomes accessible as `Candy.page()` returning `"contact-form"`. This allows you to run page-specific JavaScript:
+**Page Identifier:** The controller filename becomes the page identifier in the frontend. For example, `'contact-form'` becomes accessible as `Odac.page()` returning `"contact-form"`. This allows you to run page-specific JavaScript:
 
 ```javascript
 // Frontend
-Candy.action({
+Odac.action({
   page: {
     'contact-form': function() {
       console.log('Contact form page loaded')

package/docs/backend/04-routing/02-controller-less-view-routes.md

@@ -6,7 +6,7 @@ For simple pages that don't require complex logic in a controller, you can rende
 This defines a page and immediately tells it which view components to render.
 
 ```javascript
-Candy.Route.page("/users", {
+Odac.Route.page("/users", {
     skeleton: "dashboard",
     header: "dashboard.main",
     sidebar: "dashboard.main",
@@ -14,13 +14,13 @@ Candy.Route.page("/users", {
     content: "users"
 });
 ```
-This example tells CandyPack to render the `/users` page by assembling a view from multiple parts, likely using a main `dashboard` skeleton and filling it with different content blocks.
+This example tells Odac to render the `/users` page by assembling a view from multiple parts, likely using a main `dashboard` skeleton and filling it with different content blocks.
 
-**Page Identifier:** When using view objects, the page identifier (accessible via `Candy.page()` in frontend) is automatically set to the `content` or `all` value. In this example, the page identifier would be `"users"`, allowing you to run page-specific JavaScript:
+**Page Identifier:** When using view objects, the page identifier (accessible via `Odac.page()` in frontend) is automatically set to the `content` or `all` value. In this example, the page identifier would be `"users"`, allowing you to run page-specific JavaScript:
 
 ```javascript
 // Frontend
-Candy.action({
+Odac.action({
   page: {
     users: function() {
       console.log('Users page loaded')
@@ -34,7 +34,7 @@ Similar to `page()`, but requires authentication. Only authenticated users can a
 
 ```javascript
 // Only authenticated users can see the dashboard
-Candy.Route.auth.page('/', {
+Odac.Route.auth.page('/', {
     skeleton: 'main', 
     content: 'dashboard'
 });

package/docs/backend/04-routing/03-api-and-data-routes.md

@@ -3,12 +3,12 @@
 #### `get(path, controller, options)`
 Defines a route that responds to `GET` requests. This is ideal for API endpoints that return data (like JSON).
 
--   `options`: By default, CandyPack protects routes from CSRF attacks by checking for a token. For a public API or stateless endpoint, you must disable this by passing `{ token: false }`. If you don't, the server will expect a token and will not return a response if one isn't provided.
+-   `options`: By default, Odac protects routes from CSRF attacks by checking for a token. For a public API or stateless endpoint, you must disable this by passing `{ token: false }`. If you don't, the server will expect a token and will not return a response if one isn't provided.
 
 ```javascript
 // An API endpoint at GET /api/users/123
 // We disable the token check as this is a public API.
-Candy.Route.get('/api/users/{id}', 'api/users.get', { token: false });
+Odac.Route.get('/api/users/{id}', 'api/users.get', { token: false });
 ```
 
 #### `post(path, controller, options)`
@@ -16,5 +16,5 @@ Defines a route that responds to `POST` requests, typically used for form submis
 
 ```javascript
 // A form that posts data to /login
-Candy.Route.post('/login', 'auth.login');
+Odac.Route.post('/login', 'auth.login');
 ```

package/docs/backend/04-routing/04-authentication-aware-routes.md

@@ -7,7 +7,7 @@ Defines a page route that requires authentication.
 
 ```javascript
 // Only authenticated users can access the dashboard
-Candy.Route.auth.page('/dashboard', 'dashboard.index');
+Odac.Route.auth.page('/dashboard', 'dashboard.index');
 ```
 
 #### `auth.page(path, viewConfig)`
@@ -15,7 +15,7 @@ Defines a controller-less page route that requires authentication.
 
 ```javascript
 // Only authenticated users can see this view
-Candy.Route.auth.page('/profile', {
+Odac.Route.auth.page('/profile', {
   skeleton: 'main',
   head: 'profile.head',
   content: 'profile',
@@ -28,7 +28,7 @@ Defines a GET route that requires authentication.
 
 ```javascript
 // API endpoint for authenticated users only
-Candy.Route.auth.get('/api/user/profile', 'api.user.profile');
+Odac.Route.auth.get('/api/user/profile', 'api.user.profile');
 ```
 
 #### `auth.post(path, controller, options)`
@@ -36,7 +36,7 @@ Defines a POST route that requires authentication.
 
 ```javascript
 // Only authenticated users can update their profile
-Candy.Route.auth.post('/api/user/update', 'api.user.update');
+Odac.Route.auth.post('/api/user/update', 'api.user.update');
 ```
 
 #### CSRF Token Protection
@@ -44,5 +44,5 @@ By default, all POST and GET routes have CSRF token protection enabled. You can
 
 ```javascript
 // Disable CSRF token check for this route
-Candy.Route.auth.post('/api/webhook', 'api.webhook', {token: false});
+Odac.Route.auth.post('/api/webhook', 'api.webhook', {token: false});
 ```

package/docs/backend/04-routing/05-advanced-routing.md

@@ -6,9 +6,9 @@ This is the powerful base method that all other routing methods use internally.
 -   `type`: A string defining the route type (e.g., `page`, `post`, `#page` for authenticated pages, etc.).
 
 ```javascript
-// This is equivalent to Candy.Route.post('/register', 'auth.register')
-Candy.Route.set('post', '/register', 'auth.register');
+// This is equivalent to Odac.Route.post('/register', 'auth.register')
+Odac.Route.set('post', '/register', 'auth.register');
 
 // This creates an authenticated page route
-Candy.Route.set('#page', '/account', 'account.settings');
+Odac.Route.set('#page', '/account', 'account.settings');
 ```

package/docs/backend/04-routing/06-error-pages.md

@@ -1,6 +1,6 @@
 ## 🚨 Error Pages
 
-CandyPack framework provides built-in error handling with customizable error pages for different HTTP status codes. You can define custom error pages to provide a better user experience when things go wrong.
+Odac framework provides built-in error handling with customizable error pages for different HTTP status codes. You can define custom error pages to provide a better user experience when things go wrong.
 
 #### `error(statusCode, controller)`
 Maps HTTP error status codes to custom controller handlers. This allows you to create branded error pages instead of showing generic browser error messages.
@@ -10,13 +10,13 @@ Maps HTTP error status codes to custom controller handlers. This allows you to c
 
 ```javascript
 // Custom 404 Not Found page
-Candy.Route.error(404, 'errors/not-found');
+Odac.Route.error(404, 'errors/not-found');
 
 // Custom 500 Internal Server Error page
-Candy.Route.error(500, 'errors/server-error');
+Odac.Route.error(500, 'errors/server-error');
 
 // Custom 403 Forbidden page
-Candy.Route.error(403, 'errors/forbidden');
+Odac.Route.error(403, 'errors/forbidden');
 ```
 
 #### Common Error Status Codes
@@ -34,8 +34,8 @@ Create error controllers in your `controller/errors/` directory:
 ```javascript
 // controller/errors/not-found.js
 module.exports = function() {
-    Candy.response.status(404);
-    return Candy.view('errors/404', {
+    Odac.response.status(404);
+    return Odac.view('errors/404', {
         title: 'Page Not Found',
         message: 'The page you are looking for could not be found.'
     });
@@ -45,8 +45,8 @@ module.exports = function() {
 ```javascript
 // controller/errors/server-error.js
 module.exports = function() {
-    Candy.response.status(500);
-    return Candy.view('errors/500', {
+    Odac.response.status(500);
+    return Odac.view('errors/500', {
         title: 'Server Error',
         message: 'Something went wrong on our end. Please try again later.'
     });
@@ -74,26 +74,26 @@ Create corresponding view templates in your `view/errors/` directory:
 
 #### Default Error Handling
 
-If no custom error page is defined, CandyPack will fall back to its built-in error responses. It's recommended to at least define custom 404 and 500 error pages for a professional user experience.
+If no custom error page is defined, Odac will fall back to its built-in error responses. It's recommended to at least define custom 404 and 500 error pages for a professional user experience.
 
 #### Error Context
 
-Error controllers receive the same Candy context as regular controllers, allowing you to:
+Error controllers receive the same Odac context as regular controllers, allowing you to:
 
-- Access request information (`Candy.request`)
-- Use database connections (`Candy.db`)
-- Render views with data (`Candy.view`)
-- Redirect users (`Candy.redirect`)
+- Access request information (`Odac.request`)
+- Use database connections (`Odac.db`)
+- Render views with data (`Odac.view`)
+- Redirect users (`Odac.redirect`)
 - Log error details for debugging
 
 ```javascript
 // controller/errors/server-error.js
 module.exports = function() {
     // Log the error for debugging
-    console.error('Server error occurred:', Candy.request.url);
+    console.error('Server error occurred:', Odac.request.url);
     
-    Candy.response.status(500);
-    return Candy.view('errors/500', {
+    Odac.response.status(500);
+    return Odac.view('errors/500', {
         title: 'Oops! Something went wrong',
         supportEmail: 'support@yoursite.com'
     });

package/docs/backend/04-routing/07-cron-jobs.md

@@ -1,17 +1,17 @@
 # Cron Jobs
 
-The CandyPack framework provides a built-in cron system for running automated tasks. This system checks every minute and executes jobs based on specified conditions.
+The Odac framework provides a built-in cron system for running automated tasks. This system checks every minute and executes jobs based on specified conditions.
 
 ## Basic Usage
 
-Use the `Candy.Route.cron()` method to define cron jobs:
+Use the `Odac.Route.cron()` method to define cron jobs:
 
 ```javascript
 // With controller file
-Candy.Route.cron('backup').everyDay(1) // Runs every day
+Odac.Route.cron('backup').everyDay(1) // Runs every day
 
 // With direct function
-Candy.Route.cron(() => {
+Odac.Route.cron(() => {
   console.log('Task executed!')
 }).everyHour(2) // Runs every 2 hours
 ```
@@ -37,7 +37,7 @@ module.exports = () => {
 }
 
 // Usage
-Candy.Route.cron('admin.cleanup').everyDay(1)
+Odac.Route.cron('admin.cleanup').everyDay(1)
 ```
 
 ## Direct Function Usage
@@ -46,10 +46,10 @@ You can also define cron jobs with inline functions:
 
 ```javascript
 // Simple inline function
-Candy.Route.cron(() => console.log('Simple task running')).everyMinute(5)
+Odac.Route.cron(() => console.log('Simple task running')).everyMinute(5)
 
 // Async function
-Candy.Route.cron(async () => {
+Odac.Route.cron(async () => {
   const data = await fetchSomeData()
   console.log('Async task completed', data)
 }).everyHour(1)
@@ -60,7 +60,7 @@ const cleanupTask = (directory) => {
   // Cleanup logic...
 }
 
-Candy.Route.cron(() => cleanupTask('/tmp')).everyDay(1)
+Odac.Route.cron(() => cleanupTask('/tmp')).everyDay(1)
 ```
 
 ## Time Conditions
@@ -68,7 +68,7 @@ Candy.Route.cron(() => cleanupTask('/tmp')).everyDay(1)
 ### Specific Time Values
 
 ```javascript
-Candy.Route.cron('task')
+Odac.Route.cron('task')
 
 // Minute (0-59)
 .minute(30) // At 30th minute
@@ -95,7 +95,7 @@ Candy.Route.cron('task')
 ### Periodic Execution
 
 ```javascript
-Candy.Route.cron('periodic')
+Odac.Route.cron('periodic')
 
 // Every N minutes
 .everyMinute(5) // Every 5 minutes
@@ -122,18 +122,18 @@ You can combine multiple conditions:
 
 ```javascript
 // Every day at 14:30
-Candy.Route.cron('daily-report')
+Odac.Route.cron('daily-report')
   .hour(14)
   .minute(30)
 
 // Mondays at 09:00
-Candy.Route.cron('weekly-task')
+Odac.Route.cron('weekly-task')
   .weekDay(1)
   .hour(9)
   .minute(0)
 
 // First day of every month at midnight
-Candy.Route.cron('monthly-cleanup')
+Odac.Route.cron('monthly-cleanup')
   .day(1)
   .hour(0)
   .minute(0)