odac 0.9.0 → 1.0.0

package/docs/backend/07-views/03-template-syntax.md

@@ -1,8 +1,8 @@
 ## 🔧 Template Syntax Overview
 
-CandyPack uses a powerful template engine to create dynamic content in view files. The engine provides a clean, HTML-like syntax for displaying variables, conditionals, loops, translations, and more.
+Odac uses a powerful template engine to create dynamic content in view files. The engine provides a clean, HTML-like syntax for displaying variables, conditionals, loops, translations, and more.
 
-> **Note:** CandyPack also supports legacy syntax (`{{ }}`, `{!! !!}`, `{{-- --}}`) for backward compatibility, but the new `<candy>` tag syntax is recommended for all new projects.
+> **Note:** Odac also supports legacy syntax (`{{ }}`, `{!! !!}`, `{{-- --}}`) for backward compatibility, but the new `<odac>` tag syntax is recommended for all new projects.
 
 ### Quick Reference
 
@@ -10,17 +10,17 @@ This page provides a quick overview of all available template features. For deta
 
 ### Variables (Controller Data)
 
-Display data passed from controllers using `Candy.set()`:
+Display data passed from controllers using `Odac.set()`:
 
 ```html
 <!-- HTML-safe output -->
-<candy var="username" />
+<odac var="username" />
 
 <!-- Raw HTML output -->
-<candy var="htmlContent" raw />
+<odac var="htmlContent" raw />
 
 <!-- String literals -->
-<candy>Hello World</candy>
+<odac>Hello World</odac>
 ```
 
 **[→ Learn more about Variables](./03-variables.md)**
@@ -32,11 +32,11 @@ Access URL query parameters directly:
 ```html
 <!-- Get query parameter from URL -->
 <!-- URL: /search?q=laptop -->
-<candy get="q" />
+<odac get="q" />
 <!-- Output: laptop -->
 ```
 
-**Note:** `<candy get>` is for URL parameters. For controller data, use `<candy var>`.
+**Note:** `<odac get>` is for URL parameters. For controller data, use `<odac var>`.
 
 **[→ Learn more about Request Data](./04-request-data.md)**
 
@@ -46,13 +46,13 @@ Create multi-language applications:
 
 ```html
 <!-- Basic translation -->
-<candy translate>Welcome</candy>
+<odac translate>Welcome</odac>
 
 <!-- With placeholders -->
-<candy translate>Hello <candy var="user.name" /></candy>
+<odac translate>Hello <odac var="user.name" /></odac>
 
 <!-- With HTML preserved -->
-<candy translate raw>Click <a href="/help">here</a></candy>
+<odac translate raw>Click <a href="/help">here</a></odac>
 ```
 
 **[→ Learn more about Translations](./07-translations.md)**
@@ -62,12 +62,12 @@ Create multi-language applications:
 Two types of comments for different purposes:
 
 ```html
-<!--candy Backend comment (not rendered) -->
+<!--odac Backend comment (not rendered) -->
 
-<!--candy
+<!--odac
   Multi-line backend comment
   Won't appear in output
-candy-->
+odac-->
 
 <!-- Regular HTML comment (rendered) -->
 ```
@@ -79,13 +79,13 @@ candy-->
 Show or hide content based on conditions:
 
 ```html
-<candy:if condition="user.isAdmin">
+<odac:if condition="user.isAdmin">
   <p>Admin panel</p>
-<candy:elseif condition="user.isModerator">
+<odac:elseif condition="user.isModerator">
   <p>Moderator panel</p>
-<candy:else>
+<odac:else>
   <p>User panel</p>
-</candy:if>
+</odac:if>
 ```
 
 **[→ Learn more about Conditionals](./05-conditionals.md)**
@@ -96,18 +96,18 @@ Iterate over arrays and objects:
 
 ```html
 <!-- For loop -->
-<candy:for in="users" key="index" value="user">
-  <div><candy var="user.name" /></div>
-</candy:for>
+<odac:for in="users" key="index" value="user">
+  <div><odac var="user.name" /></div>
+</odac:for>
 
 <!-- While loop -->
-<candy:while condition="counter < 10">
-  <p><candy var="counter" /></p>
-</candy:while>
+<odac:while condition="counter < 10">
+  <p><odac var="counter" /></p>
+</odac:while>
 
 <!-- Loop control -->
-<candy:break />
-<candy:continue />
+<odac:break />
+<odac:continue />
 ```
 
 **[→ Learn more about Loops](./06-loops.md)**
@@ -117,54 +117,54 @@ Iterate over arrays and objects:
 Execute JavaScript on the server during template rendering:
 
 ```html
-<script:candy>
+<script:odac>
   // Runs on SERVER before HTML is sent
   let total = 0;
   for (let item of cart) {
     total += item.price * item.quantity;
   }
-</script:candy>
+</script:odac>
 
-<p>Total: $<candy var="total" /></p>
+<p>Total: $<odac var="total" /></p>
 ```
 
 **[→ Learn more about Backend JavaScript](./08-backend-javascript.md)**
 
-### Accessing the Candy Object
+### Accessing the Odac Object
 
-Full access to the Candy object in templates:
+Full access to the Odac object in templates:
 
 ```html
-<candy:if condition="Candy.Auth.check()">
-  <p>User: <candy var="Candy.Auth.user().name" /></p>
-</candy:if>
+<odac:if condition="Odac.Auth.check()">
+  <p>User: <odac var="Odac.Auth.user().name" /></p>
+</odac:if>
 
-<p>URL: <candy var="Candy.Request.url" /></p>
+<p>URL: <odac var="Odac.Request.url" /></p>
 ```
 
 ### Complete Syntax Reference
 
 | Feature | Syntax | Documentation |
 |---------|--------|---------------|
-| Variable (Controller) | `<candy var="x" />` | [Variables](./03-variables.md) |
-| Raw HTML | `<candy var="x" raw />` | [Variables](./03-variables.md) |
-| String | `<candy>text</candy>` | [Variables](./03-variables.md) |
-| Query Parameter | `<candy get="key" />` | [Request Data](./04-request-data.md) |
-| Translation | `<candy translate>key</candy>` | [Translations](./07-translations.md) |
-| Translation Raw | `<candy translate raw>key</candy>` | [Translations](./07-translations.md) |
-| If | `<candy:if condition="x">` | [Conditionals](./05-conditionals.md) |
-| Elseif | `<candy:elseif condition="x">` | [Conditionals](./05-conditionals.md) |
-| Else | `<candy:else>` | [Conditionals](./05-conditionals.md) |
-| For | `<candy:for in="x" value="item">` | [Loops](./06-loops.md) |
-| While | `<candy:while condition="x">` | [Loops](./06-loops.md) |
-| Break | `<candy:break />` | [Loops](./06-loops.md) |
-| Continue | `<candy:continue />` | [Loops](./06-loops.md) |
-| JavaScript | `<script:candy>...</script:candy>` | [Backend JavaScript](./08-backend-javascript.md) |
-| Comment | `<!--candy ... candy-->` | [Comments](./09-comments.md) |
+| Variable (Controller) | `<odac var="x" />` | [Variables](./03-variables.md) |
+| Raw HTML | `<odac var="x" raw />` | [Variables](./03-variables.md) |
+| String | `<odac>text</odac>` | [Variables](./03-variables.md) |
+| Query Parameter | `<odac get="key" />` | [Request Data](./04-request-data.md) |
+| Translation | `<odac translate>key</odac>` | [Translations](./07-translations.md) |
+| Translation Raw | `<odac translate raw>key</odac>` | [Translations](./07-translations.md) |
+| If | `<odac:if condition="x">` | [Conditionals](./05-conditionals.md) |
+| Elseif | `<odac:elseif condition="x">` | [Conditionals](./05-conditionals.md) |
+| Else | `<odac:else>` | [Conditionals](./05-conditionals.md) |
+| For | `<odac:for in="x" value="item">` | [Loops](./06-loops.md) |
+| While | `<odac:while condition="x">` | [Loops](./06-loops.md) |
+| Break | `<odac:break />` | [Loops](./06-loops.md) |
+| Continue | `<odac:continue />` | [Loops](./06-loops.md) |
+| JavaScript | `<script:odac>...</script:odac>` | [Backend JavaScript](./08-backend-javascript.md) |
+| Comment | `<!--odac ... odac-->` | [Comments](./09-comments.md) |
 
 ### Legacy Syntax
 
-CandyPack also supports legacy syntax for backward compatibility:
+Odac also supports legacy syntax for backward compatibility:
 
 ```html
 <!-- Variable output -->
@@ -177,5 +177,5 @@ CandyPack also supports legacy syntax for backward compatibility:
 {{-- This is a comment --}}
 ```
 
-**Note:** The new `<candy>` tag syntax is recommended for all new projects.
+**Note:** The new `<odac>` tag syntax is recommended for all new projects.
 

package/docs/backend/07-views/03-variables.md

@@ -1,19 +1,19 @@
 ## 📦 Variables in Views
 
-Variables allow you to display dynamic data in your templates. Data is passed from controllers to views using `Candy.set()` and displayed using the `<candy var>` tag.
+Variables allow you to display dynamic data in your templates. Data is passed from controllers to views using `Odac.set()` and displayed using the `<odac var>` tag.
 
 ### Passing Data from Controller
 
-Use `Candy.set()` in your controller to pass data to views:
+Use `Odac.set()` in your controller to pass data to views:
 
 ```javascript
 // Controller: controller/profile.js
-module.exports = async function(Candy) {
+module.exports = async function(Odac) {
   // Set single variable
-  Candy.set('username', 'John Doe')
+  Odac.set('username', 'John Doe')
   
   // Set multiple variables at once
-  Candy.set({
+  Odac.set({
     user: {
       name: 'John Doe',
       email: 'john@example.com',
@@ -22,7 +22,7 @@ module.exports = async function(Candy) {
     pageTitle: 'User Profile'
   })
   
-  Candy.View.skeleton('main').set('content', 'profile')
+  Odac.View.skeleton('main').set('content', 'profile')
 }
 ```
 
@@ -31,9 +31,9 @@ module.exports = async function(Candy) {
 #### HTML-Safe Output (Recommended)
 
 ```html
-<candy var="username" />
-<candy var="user.email" />
-<candy var="product.price" />
+<odac var="username" />
+<odac var="user.email" />
+<odac var="product.price" />
 ```
 
 This automatically:
@@ -43,12 +43,12 @@ This automatically:
 **Example:**
 ```javascript
 // Controller
-Candy.set('message', 'Hello\nWorld')
+Odac.set('message', 'Hello\nWorld')
 ```
 
 ```html
 <!-- View -->
-<candy var="message" />
+<odac var="message" />
 <!-- Output: Hello<br>World -->
 ```
 
@@ -57,8 +57,8 @@ Candy.set('message', 'Hello\nWorld')
 When you need to display HTML content without escaping:
 
 ```html
-<candy var="htmlContent" raw />
-<candy var="user.bio" raw />
+<odac var="htmlContent" raw />
+<odac var="user.bio" raw />
 ```
 
 **Security Warning:** Only use `raw` with trusted content. Never use it with user-generated content to prevent XSS attacks.
@@ -66,12 +66,12 @@ When you need to display HTML content without escaping:
 **Example:**
 ```javascript
 // Controller
-Candy.set('content', '<strong>Bold text</strong>')
+Odac.set('content', '<strong>Bold text</strong>')
 ```
 
 ```html
 <!-- View -->
-<candy var="content" raw />
+<odac var="content" raw />
 <!-- Output: <strong>Bold text</strong> -->
 ```
 
@@ -81,7 +81,7 @@ You can access nested object properties using dot notation:
 
 ```javascript
 // Controller
-Candy.set('user', {
+Odac.set('user', {
   name: 'John',
   profile: {
     email: 'john@example.com',
@@ -94,9 +94,9 @@ Candy.set('user', {
 
 ```html
 <!-- View -->
-<p>Name: <candy var="user.name" /></p>
-<p>Email: <candy var="user.profile.email" /></p>
-<p>City: <candy var="user.profile.address.city" /></p>
+<p>Name: <odac var="user.name" /></p>
+<p>Email: <odac var="user.profile.email" /></p>
+<p>City: <odac var="user.profile.address.city" /></p>
 ```
 
 ### String Literals
@@ -104,32 +104,32 @@ Candy.set('user', {
 Display static text directly:
 
 ```html
-<candy>Hello World</candy>
-<candy>Welcome to our site</candy>
+<odac>Hello World</odac>
+<odac>Welcome to our site</odac>
 ```
 
 This is useful when you want consistent syntax throughout your templates.
 
-### Accessing the Candy Object
+### Accessing the Odac Object
 
-You have full access to the `Candy` object within templates:
+You have full access to the `Odac` object within templates:
 
 ```html
 <!-- Authentication -->
-<candy:if condition="Candy.Auth.check()">
-  <p>User ID: <candy var="Candy.Auth.user().id" /></p>
-  <p>Email: <candy var="Candy.Auth.user().email" /></p>
-</candy:if>
+<odac:if condition="Odac.Auth.check()">
+  <p>User ID: <odac var="Odac.Auth.user().id" /></p>
+  <p>Email: <odac var="Odac.Auth.user().email" /></p>
+</odac:if>
 
 <!-- Request Information -->
-<p>Method: <candy var="Candy.Request.method" /></p>
-<p>URL: <candy var="Candy.Request.url" /></p>
-<p>IP: <candy var="Candy.Request.ip" /></p>
+<p>Method: <odac var="Odac.Request.method" /></p>
+<p>URL: <odac var="Odac.Request.url" /></p>
+<p>IP: <odac var="Odac.Request.ip" /></p>
 
 <!-- Configuration -->
-<candy:if condition="Candy.Config.debug">
+<odac:if condition="Odac.Config.debug">
   <div class="debug-info">Debug mode enabled</div>
-</candy:if>
+</odac:if>
 ```
 
 ### Practical Examples
@@ -138,37 +138,37 @@ You have full access to the `Candy` object within templates:
 
 ```javascript
 // Controller: controller/profile.js
-module.exports = async function(Candy) {
+module.exports = async function(Odac) {
   // Fetch user from database
-  const userId = Candy.Request.get('id')
-  const user = await Candy.Mysql.table('users')
+  const userId = Odac.Request.get('id')
+  const user = await Odac.Mysql.table('users')
     .where('id', userId)
     .first()
   
   // Pass to view
-  Candy.set('user', {
+  Odac.set('user', {
     name: user.name,
     email: user.email,
     bio: user.bio,
     isVerified: user.verified
   })
   
-  Candy.View.skeleton('main').set('content', 'profile')
+  Odac.View.skeleton('main').set('content', 'profile')
 }
 ```
 
 ```html
 <!-- View: view/content/profile.html -->
 <div class="profile-card">
-  <h2><candy var="user.name" /></h2>
-  <p><candy var="user.email" /></p>
+  <h2><odac var="user.name" /></h2>
+  <p><odac var="user.email" /></p>
   
-  <candy:if condition="user.isVerified">
+  <odac:if condition="user.isVerified">
     <span class="badge">✓ Verified</span>
-  </candy:if>
+  </odac:if>
   
   <div class="bio">
-    <candy var="user.bio" raw />
+    <odac var="user.bio" raw />
   </div>
 </div>
 ```
@@ -177,9 +177,9 @@ module.exports = async function(Candy) {
 
 ```javascript
 // Controller: controller/product.js
-module.exports = async function(Candy) {
-  const productId = Candy.Request.get('id')
-  const product = await Candy.Mysql.table('products')
+module.exports = async function(Odac) {
+  const productId = Odac.Request.get('id')
+  const product = await Odac.Mysql.table('products')
     .where('id', productId)
     .first()
   
@@ -187,31 +187,31 @@ module.exports = async function(Candy) {
   const hasDiscount = product.discount > 0
   const finalPrice = product.price * (1 - product.discount / 100)
   
-  Candy.set({
+  Odac.set({
     product: product,
     hasDiscount: hasDiscount,
     finalPrice: finalPrice
   })
   
-  Candy.View.skeleton('main').set('content', 'product')
+  Odac.View.skeleton('main').set('content', 'product')
 }
 ```
 
 ```html
 <!-- View: view/content/product.html -->
 <div class="product">
-  <h1><candy var="product.name" /></h1>
+  <h1><odac var="product.name" /></h1>
   
-  <candy:if condition="hasDiscount">
-    <p class="original-price">$<candy var="product.price" /></p>
-    <p class="final-price">$<candy var="finalPrice" /></p>
-    <span class="discount">-<candy var="product.discount" />%</span>
-  <candy:else>
-    <p class="price">$<candy var="product.price" /></p>
-  </candy:if>
+  <odac:if condition="hasDiscount">
+    <p class="original-price">$<odac var="product.price" /></p>
+    <p class="final-price">$<odac var="finalPrice" /></p>
+    <span class="discount">-<odac var="product.discount" />%</span>
+  <odac:else>
+    <p class="price">$<odac var="product.price" /></p>
+  </odac:if>
   
   <div class="description">
-    <candy var="product.description" />
+    <odac var="product.description" />
   </div>
 </div>
 ```
@@ -220,38 +220,38 @@ module.exports = async function(Candy) {
 
 ```javascript
 // Controller: controller/products.js
-module.exports = async function(Candy) {
-  const products = await Candy.Mysql.table('products')
+module.exports = async function(Odac) {
+  const products = await Odac.Mysql.table('products')
     .where('active', true)
     .get()
   
-  Candy.set({
+  Odac.set({
     products: products,
     totalProducts: products.length
   })
   
-  Candy.View.skeleton('main').set('content', 'products')
+  Odac.View.skeleton('main').set('content', 'products')
 }
 ```
 
 ```html
 <!-- View: view/content/products.html -->
-<h1>Products (<candy var="totalProducts" />)</h1>
+<h1>Products (<odac var="totalProducts" />)</h1>
 
 <div class="products-grid">
-  <candy:for in="products" value="product">
+  <odac:for in="products" value="product">
     <div class="product-card">
-      <h3><candy var="product.name" /></h3>
-      <p>$<candy var="product.price" /></p>
+      <h3><odac var="product.name" /></h3>
+      <p>$<odac var="product.price" /></p>
     </div>
-  </candy:for>
+  </odac:for>
 </div>
 ```
 
 ### Best Practices
 
-1. **Always use Candy.set()**: Pass all data through `Candy.set()` for consistency
-2. **Set data before rendering**: All `Candy.set()` calls should come before `Candy.View.set()`
+1. **Always use Odac.set()**: Pass all data through `Odac.set()` for consistency
+2. **Set data before rendering**: All `Odac.set()` calls should come before `Odac.View.set()`
 3. **Compute in controller**: Do calculations in the controller, not in views
 4. **Use descriptive names**: `pageTitle`, `userProfile` instead of `title`, `data`
 5. **Group related data**: Use objects to organize related data
@@ -259,10 +259,10 @@ module.exports = async function(Candy) {
 **Good:**
 ```javascript
 // Controller
-const user = await Candy.Mysql.table('users').first()
+const user = await Odac.Mysql.table('users').first()
 const isAdmin = user.role === 'admin'
 
-Candy.set({
+Odac.set({
   user: user,
   isAdmin: isAdmin
 })
@@ -271,9 +271,9 @@ Candy.set({
 **Avoid:**
 ```html
 <!-- Don't do complex logic in views -->
-<candy:if condition="user.role === 'admin' && user.verified && !user.banned">
+<odac:if condition="user.role === 'admin' && user.verified && !user.banned">
   ...
-</candy:if>
+</odac:if>
 ```
 
 ### Error Handling
@@ -282,38 +282,38 @@ Always handle cases where data might not exist:
 
 ```javascript
 // Controller
-module.exports = async function(Candy) {
-  const productId = Candy.Request.get('id')
-  const product = await Candy.Mysql.table('products')
+module.exports = async function(Odac) {
+  const productId = Odac.Request.get('id')
+  const product = await Odac.Mysql.table('products')
     .where('id', productId)
     .first()
   
   if (!product) {
-    Candy.set('error', 'Product not found')
+    Odac.set('error', 'Product not found')
   } else {
-    Candy.set('product', product)
+    Odac.set('product', product)
   }
   
-  Candy.View.skeleton('main').set('content', 'product')
+  Odac.View.skeleton('main').set('content', 'product')
 }
 ```
 
 ```html
 <!-- View -->
-<candy:if condition="error">
+<odac:if condition="error">
   <div class="alert alert-danger">
-    <candy var="error" />
+    <odac var="error" />
   </div>
-<candy:else>
+<odac:else>
   <div class="product">
-    <h1><candy var="product.name" /></h1>
+    <h1><odac var="product.name" /></h1>
   </div>
-</candy:if>
+</odac:if>
 ```
 
 ### Legacy Syntax (Backward Compatibility)
 
-CandyPack also supports legacy syntax:
+Odac also supports legacy syntax:
 
 ```html
 <!-- HTML-safe output -->
@@ -325,4 +325,4 @@ CandyPack also supports legacy syntax:
 {!! user.bio !!}
 ```
 
-**Note:** The new `<candy>` tag syntax is recommended for all new projects as it provides better IDE support and readability.
+**Note:** The new `<odac>` tag syntax is recommended for all new projects as it provides better IDE support and readability.