odac 0.9.0 → 1.0.0

package/docs/backend/05-forms/02-automatic-database-insert.md

@@ -5,13 +5,13 @@ Forms can automatically insert data into your database without writing any contr
 ## Basic Usage
 
 ```html
-<candy:form table="waitlist">
-  <candy:field name="email" type="email" label="Email">
-    <candy:validate rule="required|email|unique"/>
-  </candy:field>
+<odac:form table="waitlist">
+  <odac:field name="email" type="email" label="Email">
+    <odac:validate rule="required|email|unique"/>
+  </odac:field>
   
-  <candy:submit text="Join"/>
-</candy:form>
+  <odac:submit text="Join"/>
+</odac:form>
 ```
 
 That's it! The form will automatically:
@@ -44,21 +44,21 @@ CREATE TABLE `waitlist` (
 <div class="waitlist-page">
   <h1>Join Our Waitlist</h1>
   
-  <candy:form table="waitlist" redirect="/" success="Thank you for joining!">
-    <candy:field name="email" type="email" label="Email" placeholder="your@email.com">
-      <candy:validate rule="required|email|unique" message="Please enter a valid email"/>
-    </candy:field>
+  <odac:form table="waitlist" redirect="/" success="Thank you for joining!">
+    <odac:field name="email" type="email" label="Email" placeholder="your@email.com">
+      <odac:validate rule="required|email|unique" message="Please enter a valid email"/>
+    </odac:field>
     
-    <candy:field name="name" type="text" label="Name" placeholder="Your name">
-      <candy:validate rule="required|minlen:2" message="Name is required"/>
-    </candy:field>
+    <odac:field name="name" type="text" label="Name" placeholder="Your name">
+      <odac:validate rule="required|minlen:2" message="Name is required"/>
+    </odac:field>
     
-    <candy:set name="created_at" compute="now"/>
-    <candy:set name="ip" compute="ip"/>
-    <candy:set name="user_agent" compute="user_agent"/>
+    <odac:set name="created_at" compute="now"/>
+    <odac:set name="ip" compute="ip"/>
+    <odac:set name="user_agent" compute="user_agent"/>
     
-    <candy:submit text="Join Waitlist" loading="Joining..." class="btn btn-primary"/>
-  </candy:form>
+    <odac:submit text="Join Waitlist" loading="Joining..." class="btn btn-primary"/>
+  </odac:form>
 </div>
 ```
 
@@ -66,10 +66,10 @@ CREATE TABLE `waitlist` (
 
 **controller/waitlist.js**
 ```javascript
-module.exports = Candy => {
-  Candy.View.skeleton('default')
-  Candy.View.set({content: 'waitlist'})
-  Candy.View.print()
+module.exports = Odac => {
+  Odac.View.skeleton('default')
+  Odac.View.set({content: 'waitlist'})
+  Odac.View.print()
 }
 ```
 
@@ -77,7 +77,7 @@ module.exports = Candy => {
 
 **route/www.js**
 ```javascript
-Candy.Route.page('/waitlist', 'waitlist')
+Odac.Route.page('/waitlist', 'waitlist')
 ```
 
 Done! No form submission handler needed.
@@ -88,21 +88,21 @@ Done! No form submission handler needed.
 Database table name where data will be inserted.
 
 ```html
-<candy:form table="newsletter_subscribers">
+<odac:form table="newsletter_subscribers">
 ```
 
 ### `redirect` (optional)
 URL to redirect after successful submission.
 
 ```html
-<candy:form table="waitlist" redirect="/thank-you">
+<odac:form table="waitlist" redirect="/thank-you">
 ```
 
 ### `success` (optional)
 Custom success message to display.
 
 ```html
-<candy:form table="waitlist" success="Welcome! We'll notify you soon.">
+<odac:form table="waitlist" success="Welcome! We'll notify you soon.">
 ```
 
 ## Unique Validation
@@ -110,9 +110,9 @@ Custom success message to display.
 Use `unique` rule to prevent duplicate entries:
 
 ```html
-<candy:field name="email" type="email">
-  <candy:validate rule="required|email|unique" message="This email is already registered"/>
-</candy:field>
+<odac:field name="email" type="email">
+  <odac:validate rule="required|email|unique" message="This email is already registered"/>
+</odac:field>
 ```
 
 The system will:
@@ -122,13 +122,13 @@ The system will:
 
 ## Auto-Set Values
 
-Use `<candy:set>` to automatically populate fields:
+Use `<odac:set>` to automatically populate fields:
 
 ```html
-<candy:set name="created_at" compute="now"/>
-<candy:set name="ip" compute="ip"/>
-<candy:set name="user_agent" compute="user_agent"/>
-<candy:set name="status" value="pending"/>
+<odac:set name="created_at" compute="now"/>
+<odac:set name="ip" compute="ip"/>
+<odac:set name="user_agent" compute="user_agent"/>
+<odac:set name="status" value="pending"/>
 ```
 
 ### Compute Types
@@ -144,9 +144,9 @@ Use `<candy:set>` to automatically populate fields:
 ### Static Values
 
 ```html
-<candy:set name="status" value="pending"/>
-<candy:set name="source" value="website"/>
-<candy:set name="plan" value="free"/>
+<odac:set name="status" value="pending"/>
+<odac:set name="source" value="website"/>
+<odac:set name="plan" value="free"/>
 ```
 
 ### Conditional Set
@@ -154,7 +154,7 @@ Use `<candy:set>` to automatically populate fields:
 Only set if field is empty:
 
 ```html
-<candy:set name="country" value="US" if-empty/>
+<odac:set name="country" value="US" if-empty/>
 ```
 
 ## Use Cases
@@ -162,58 +162,58 @@ Only set if field is empty:
 ### Newsletter Signup
 
 ```html
-<candy:form table="newsletter" success="Thanks for subscribing!">
-  <candy:field name="email" type="email">
-    <candy:validate rule="required|email|unique"/>
-  </candy:field>
+<odac:form table="newsletter" success="Thanks for subscribing!">
+  <odac:field name="email" type="email">
+    <odac:validate rule="required|email|unique"/>
+  </odac:field>
   
-  <candy:set name="subscribed_at" compute="now"/>
-  <candy:set name="status" value="active"/>
+  <odac:set name="subscribed_at" compute="now"/>
+  <odac:set name="status" value="active"/>
   
-  <candy:submit text="Subscribe"/>
-</candy:form>
+  <odac:submit text="Subscribe"/>
+</odac:form>
 ```
 
 ### Feedback Form
 
 ```html
-<candy:form table="feedback" redirect="/" success="Thank you for your feedback!">
-  <candy:field name="rating" type="number" label="Rating (1-5)">
-    <candy:validate rule="required|min:1|max:5"/>
-  </candy:field>
+<odac:form table="feedback" redirect="/" success="Thank you for your feedback!">
+  <odac:field name="rating" type="number" label="Rating (1-5)">
+    <odac:validate rule="required|min:1|max:5"/>
+  </odac:field>
   
-  <candy:field name="comment" type="textarea" label="Comment">
-    <candy:validate rule="required|minlen:10"/>
-  </candy:field>
+  <odac:field name="comment" type="textarea" label="Comment">
+    <odac:validate rule="required|minlen:10"/>
+  </odac:field>
   
-  <candy:set name="created_at" compute="now"/>
-  <candy:set name="ip" compute="ip"/>
+  <odac:set name="created_at" compute="now"/>
+  <odac:set name="ip" compute="ip"/>
   
-  <candy:submit text="Submit Feedback"/>
-</candy:form>
+  <odac:submit text="Submit Feedback"/>
+</odac:form>
 ```
 
 ### Beta Access Request
 
 ```html
-<candy:form table="beta_requests" success="You're on the list!">
-  <candy:field name="email" type="email">
-    <candy:validate rule="required|email|unique"/>
-  </candy:field>
+<odac:form table="beta_requests" success="You're on the list!">
+  <odac:field name="email" type="email">
+    <odac:validate rule="required|email|unique"/>
+  </odac:field>
   
-  <candy:field name="company" type="text">
-    <candy:validate rule="required"/>
-  </candy:field>
+  <odac:field name="company" type="text">
+    <odac:validate rule="required"/>
+  </odac:field>
   
-  <candy:field name="use_case" type="textarea">
-    <candy:validate rule="required|minlen:20"/>
-  </candy:field>
+  <odac:field name="use_case" type="textarea">
+    <odac:validate rule="required|minlen:20"/>
+  </odac:field>
   
-  <candy:set name="requested_at" compute="now"/>
-  <candy:set name="status" value="pending"/>
+  <odac:set name="requested_at" compute="now"/>
+  <odac:set name="status" value="pending"/>
   
-  <candy:submit text="Request Access"/>
-</candy:form>
+  <odac:submit text="Request Access"/>
+</odac:form>
 ```
 
 ## Error Handling
@@ -255,37 +255,37 @@ Automatic DB insert includes all security features:
 
 ## Combining with Custom Logic
 
-You can add custom logic by specifying a custom `action` attribute. When you do this, the form data is validated and prepared, but the automatic DB insert is skipped. Instead, your controller receives the validated data via `Candy.formData`:
+You can add custom logic by specifying a custom `action` attribute. When you do this, the form data is validated and prepared, but the automatic DB insert is skipped. Instead, your controller receives the validated data via `Odac.formData`:
 
 ```javascript
 // In your view:
-// <candy:form action="/contact/submit" table="contacts">
+// <odac:form action="/contact/submit" table="contacts">
 
 // In your controller:
-Candy.Route.post('/contact/submit', async Candy => {
-  // Candy.formData contains validated form data
-  // Candy.formConfig contains form configuration
+Odac.Route.post('/contact/submit', async Odac => {
+  // Odac.formData contains validated form data
+  // Odac.formConfig contains form configuration
   
   // Perform custom logic (send email, call API, etc.)
-  await sendEmail(Candy.formData.email, 'Thank you!')
+  await sendEmail(Odac.formData.email, 'Thank you!')
   
   // Manually insert to database if needed
-  await Candy.Mysql.query('INSERT INTO contacts SET ?', Candy.formData)
+  await Odac.Mysql.query('INSERT INTO contacts SET ?', Odac.formData)
   
-  return Candy.return({
+  return Odac.return({
     result: {success: true, message: 'Message sent!'}
   })
 })
-  const data = Candy.formData
+  const data = Odac.formData
   
   // Send welcome email
-  Candy.Mail()
+  Odac.Mail()
     .to(data.email)
     .subject('Welcome!')
     .send('Thanks for joining!')
   
   // Return custom response
-  return Candy.return({
+  return Odac.return({
     result: {
       success: true,
       message: 'Check your email!'

package/docs/backend/06-request-and-response/01-the-request-object-what-is-the-user-asking-for.md

@@ -1,18 +1,18 @@
 ## 📥 The Request Object
 
-The `Candy.Request` object contains information about the user's incoming request.
+The `Odac.Request` object contains information about the user's incoming request.
 
 ### Getting Request Parameters
 
-#### Using Candy.request() (Recommended)
+#### Using Odac.request() (Recommended)
 
-The easiest way to get request parameters is using `Candy.request()`:
+The easiest way to get request parameters is using `Odac.request()`:
 
 ```javascript
-module.exports = async function (Candy) {
+module.exports = async function (Odac) {
   // Get parameter from GET or POST automatically
-  const userName = await Candy.request('name')
-  const userId = await Candy.request('id')
+  const userName = await Odac.request('name')
+  const userId = await Odac.request('id')
   
   return `Hello ${userName}!`
 }
@@ -21,12 +21,12 @@ module.exports = async function (Candy) {
 **Specify Method (Optional):**
 
 ```javascript
-module.exports = async function (Candy) {
+module.exports = async function (Odac) {
   // Get from GET parameters only
-  const searchQuery = await Candy.request('q', 'GET')
+  const searchQuery = await Odac.request('q', 'GET')
   
   // Get from POST parameters only
-  const formName = await Candy.request('name', 'POST')
+  const formName = await Odac.request('name', 'POST')
   
   return `Searching for: ${searchQuery}`
 }
@@ -37,12 +37,12 @@ module.exports = async function (Candy) {
 You can also access request data directly:
 
 ```javascript
-module.exports = function (Candy) {
+module.exports = function (Odac) {
   // GET parameters (URL query string like ?id=123)
-  const userId = Candy.Request.get('id')
+  const userId = Odac.Request.get('id')
   
   // POST parameters (form data)
-  const userName = Candy.Request.post('name')
+  const userName = Odac.Request.post('name')
   
   return `User: ${userName}`
 }
@@ -50,18 +50,18 @@ module.exports = function (Candy) {
 
 ### Request Properties
 
-*   `Candy.Request.method` - HTTP method ('GET', 'POST', etc.)
-*   `Candy.Request.url` - Full URL the user visited
-*   `Candy.Request.host` - Website's hostname
-*   `Candy.Request.ip` - User's IP address
-*   `Candy.Request.ssl` - Whether connection is SSL/HTTPS
+*   `Odac.Request.method` - HTTP method ('GET', 'POST', etc.)
+*   `Odac.Request.url` - Full URL the user visited
+*   `Odac.Request.host` - Website's hostname
+*   `Odac.Request.ip` - User's IP address
+*   `Odac.Request.ssl` - Whether connection is SSL/HTTPS
 
 ### Request Headers
 
 ```javascript
-module.exports = function (Candy) {
-  const userAgent = Candy.Request.header('user-agent')
-  const contentType = Candy.Request.header('content-type')
+module.exports = function (Odac) {
+  const userAgent = Odac.Request.header('user-agent')
+  const contentType = Odac.Request.header('content-type')
   
   return `Browser: ${userAgent}`
 }
@@ -70,25 +70,25 @@ module.exports = function (Candy) {
 ### Complete Example
 
 ```javascript
-module.exports = async function (Candy) {
+module.exports = async function (Odac) {
   // Get request parameters
-  const productId = await Candy.request('id')
-  const quantity = await Candy.request('quantity') || 1
+  const productId = await Odac.request('id')
+  const quantity = await Odac.request('quantity') || 1
   
   // Check request method
-  if (Candy.Request.method === 'POST') {
+  if (Odac.Request.method === 'POST') {
     // Handle form submission
     const result = await processOrder(productId, quantity)
     return { success: true, orderId: result.id }
   }
   
   // Show product page
-  Candy.set({
+  Odac.set({
     productId: productId,
     quantity: quantity
   })
   
-  Candy.View.set({
+  Odac.View.set({
     skeleton: 'main',
     content: 'product.detail'
   })

package/docs/backend/06-request-and-response/02-sending-a-response-replying-to-the-user.md

@@ -4,37 +4,37 @@ Once you've processed the request, it's time to send something back. You've got
 
 #### The Simple Way: Just Return It!
 
-For many cases, you can just `return` a value from your controller. CandyPack is smart enough to figure out what to do.
+For many cases, you can just `return` a value from your controller. Odac is smart enough to figure out what to do.
 
 ```javascript
 // Return some HTML
-module.exports = function (Candy) {
+module.exports = function (Odac) {
   return '<h1>Welcome to the site!</h1>';
 }
 
 // Return some JSON for an API
-module.exports = function (Candy) {
+module.exports = function (Odac) {
   return { status: 'success', message: 'Your data was saved!' };
 }
 ```
 
 #### The Helper Functions: More Control
 
-Need a bit more control? The `Candy` object has your back.
+Need a bit more control? The `Odac` object has your back.
 
-*   `Candy.return(data)`: Does the same thing as a direct return, but you can call it from anywhere in your function. It stops everything and sends the response immediately.
-*   `Candy.direct(url)`: Need to send the user to a different page? This function performs a redirect, telling the user's browser to go to a new URL.
+*   `Odac.return(data)`: Does the same thing as a direct return, but you can call it from anywhere in your function. It stops everything and sends the response immediately.
+*   `Odac.direct(url)`: Need to send the user to a different page? This function performs a redirect, telling the user's browser to go to a new URL.
 
 **Example:**
 ```javascript
-module.exports = function (Candy) {
+module.exports = function (Odac) {
   // If the user isn't logged in...
-  if (!Candy.Auth.isLogin()) {
+  if (!Odac.Auth.isLogin()) {
     // ...send them to the login page!
-    return Candy.direct('/login');
+    return Odac.direct('/login');
   }
 
   // Otherwise, give them their data.
-  Candy.return({ data: 'here is your secret stuff' });
+  Odac.return({ data: 'here is your secret stuff' });
 }
 ```

package/docs/backend/07-views/01-the-view-directory.md

@@ -1,6 +1,6 @@
 ## 📁 View System Overview
 
-CandyPack's view system creates dynamic HTML pages by combining skeleton (layout) and view (content) files. This system provides a modular structure by keeping page layout and content separate.
+Odac's view system creates dynamic HTML pages by combining skeleton (layout) and view (content) files. This system provides a modular structure by keeping page layout and content separate.
 
 ### Directory Structure
 

package/docs/backend/07-views/02-rendering-a-view.md

@@ -1,14 +1,14 @@
 ## 🎨 Rendering Views
 
-In CandyPack, you use the `Candy.View` object to render views. There are two main approaches:
+In Odac, you use the `Odac.View` object to render views. There are two main approaches:
 
 ### 1. Combining Skeleton and View Parts
 
 The most common usage is to select a skeleton and place view parts into it.
 
 ```javascript
-module.exports = function (Candy) {
-  Candy.View
+module.exports = function (Odac) {
+  Odac.View
     .skeleton('main')           // Use skeleton/main.html
     .set('header', 'main')      // Place view/header/main.html into {{ HEADER }}
     .set('content', 'home')     // Place view/content/home.html into {{ CONTENT }}
@@ -21,8 +21,8 @@ module.exports = function (Candy) {
 You can set all view parts at once:
 
 ```javascript
-module.exports = function (Candy) {
-  Candy.View.set({
+module.exports = function (Odac) {
+  Odac.View.set({
     skeleton: 'main',
     header: 'main',
     content: 'home',
@@ -36,7 +36,7 @@ module.exports = function (Candy) {
 View files can be organized in subdirectories. You can access them using dot notation:
 
 ```javascript
-Candy.View.set({
+Odac.View.set({
   skeleton: 'dashboard',
   header: 'dashboard.main',      // view/header/dashboard/main.html
   sidebar: 'dashboard.menu',     // view/sidebar/dashboard/menu.html
@@ -50,7 +50,7 @@ You can render views directly from route files without using a controller:
 
 ```javascript
 // route/www.js
-Candy.Route.page('/about').view({
+Odac.Route.page('/about').view({
   skeleton: 'main',
   header: 'main',
   content: 'about',
@@ -63,7 +63,7 @@ Candy.Route.page('/about').view({
 If you're using the same directory structure for all placeholders, you can use the `all()` method:
 
 ```javascript
-Candy.View
+Odac.View
   .skeleton('main')
   .all('home')  // view/home/header.html, view/home/content.html, view/home/footer.html
 ```
@@ -108,27 +108,27 @@ Create a separate view part for the `<head>` section:
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>{{ Candy.pageTitle }}</title>
-    <meta name="description" content="{{ Candy.pageDescription }}">
+    <title>{{ Odac.pageTitle }}</title>
+    <meta name="description" content="{{ Odac.pageDescription }}">
     <link rel="stylesheet" href="/assets/css/style.css">
 </head>
 ```
 
 **Controller:**
 ```javascript
-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()
   
   // Set dynamic title and description
-  Candy.pageTitle = product ? `${product.name} - My Store` : 'Product Not Found'
-  Candy.pageDescription = product ? product.short_description : ''
+  Odac.pageTitle = product ? `${product.name} - My Store` : 'Product Not Found'
+  Odac.pageDescription = product ? product.short_description : ''
   
-  Candy.product = product
+  Odac.product = product
   
-  Candy.View.set({
+  Odac.View.set({
     skeleton: 'main',
     head: 'main',        // Include dynamic head
     header: 'main',
@@ -159,11 +159,11 @@ Include the title tag in your content view:
 
 **Content View (view/content/product.html):**
 ```html
-<title>{{ Candy.product.name }} - My Store</title>
+<title>{{ Odac.product.name }} - My Store</title>
 
 <div class="product">
-    <h1>{{ Candy.product.name }}</h1>
-    <p>{{ Candy.product.description }}</p>
+    <h1>{{ Odac.product.name }}</h1>
+    <p>{{ Odac.product.description }}</p>
 </div>
 ```
 
@@ -175,5 +175,5 @@ Include the title tag in your content view:
 - Skeleton files should be in the `skeleton/` directory, view files in the `view/` directory
 - Placeholders for view parts are written in uppercase: `{{ HEADER }}`, `{{ CONTENT }}`, etc.
 - View part names are specified in lowercase: `header`, `content`, etc.
-- Variables in skeleton/views are accessed via `Candy` object: `{{ Candy.variableName }}`
-- You don't need to use `return` from the controller, `Candy.View.set()` automatically initiates the rendering process
+- Variables in skeleton/views are accessed via `Odac` object: `{{ Odac.variableName }}`
+- You don't need to use `return` from the controller, `Odac.View.set()` automatically initiates the rendering process