odac 0.9.0 → 1.0.0

package/docs/backend/09-validation/01-the-validator-service.md

@@ -1,13 +1,13 @@
 ## ✅ The `Validator` Service
 
-The Validator service provides a fluent, chainable API for validating user input. It's automatically available in your controllers through `Candy.Validator`.
+The Validator service provides a fluent, chainable API for validating user input. It's automatically available in your controllers through `Odac.Validator`.
 
 #### Basic Usage
 
 The validator uses a method-chaining pattern:
 
 ```javascript
-const validator = Candy.Validator
+const validator = Odac.Validator
 validator.post('email').check('required|email').message('Valid email required')
 validator.post('password').check('required|minlen:8').message('Password must be at least 8 characters')
 
@@ -82,8 +82,8 @@ Use `!` prefix to invert any rule: `!required`, `!email`, etc.
 #### Example: User Registration
 
 ```javascript
-module.exports = async function (Candy) {
-  const validator = Candy.Validator
+module.exports = async function (Odac) {
+  const validator = Odac.Validator
 
   validator.post('username').check('required|username|minlen:4|maxlen:20').message('Username must be 4-20 alphanumeric characters')
   validator.post('email').check('required|email').message('Valid email address required')
@@ -101,8 +101,8 @@ module.exports = async function (Candy) {
 #### Example: Login with Brute Force Protection
 
 ```javascript
-module.exports = async function (Candy) {
-  const validator = Candy.Validator
+module.exports = async function (Odac) {
+  const validator = Odac.Validator
 
   validator.post('email').check('required|email').message('Email required')
   validator.post('password').check('required').message('Password required')
@@ -119,8 +119,8 @@ module.exports = async function (Candy) {
 #### Example: Custom Variable Validation
 
 ```javascript
-module.exports = async function (Candy) {
-  const validator = Candy.Validator
+module.exports = async function (Odac) {
+  const validator = Odac.Validator
   const customValue = calculateSomething()
 
   validator.var('calculated_value', customValue).check('numeric|min:100|max:1000').message('Value must be between 100 and 1000')
@@ -138,8 +138,8 @@ module.exports = async function (Candy) {
 You can chain multiple `check()` calls for the same field, each with its own specific error message. The validator will return the first error it encounters:
 
 ```javascript
-module.exports = async function (Candy) {
-  const validator = Candy.Validator
+module.exports = async function (Odac) {
+  const validator = Odac.Validator
 
   validator
     .post('password')
@@ -160,8 +160,8 @@ module.exports = async function (Candy) {
 #### Example: Complex Form Validation
 
 ```javascript
-module.exports = async function (Candy) {
-  const validator = Candy.Validator
+module.exports = async function (Odac) {
+  const validator = Odac.Validator
 
   validator
     .post('username')
@@ -203,8 +203,8 @@ module.exports = async function (Candy) {
 #### Example: Date Range Validation
 
 ```javascript
-module.exports = async function (Candy) {
-  const validator = Candy.Validator
+module.exports = async function (Odac) {
+  const validator = Odac.Validator
 
   validator
     .post('start_date')
@@ -229,10 +229,10 @@ module.exports = async function (Candy) {
 #### Example: Conditional Validation with Custom Variables
 
 ```javascript
-module.exports = async function (Candy) {
-  const validator = Candy.Validator
-  const userRole = Candy.Auth.user('role')
-  const userCredits = Candy.Auth.user('credits') || 0
+module.exports = async function (Odac) {
+  const validator = Odac.Validator
+  const userRole = Odac.Auth.user('role')
+  const userCredits = Odac.Auth.user('credits') || 0
 
   validator.post('title').check('required').message('Title is required')
   validator.post('content').check('required').message('Content is required')
@@ -263,8 +263,8 @@ module.exports = async function (Candy) {
 #### Example: User Authentication Validation
 
 ```javascript
-module.exports = async function (Candy) {
-  const validator = Candy.Validator
+module.exports = async function (Odac) {
+  const validator = Odac.Validator
 
   validator
     .post('current_password')
@@ -290,9 +290,9 @@ module.exports = async function (Candy) {
 You can use boolean values directly in `check()` for custom validation logic:
 
 ```javascript
-module.exports = async function (Candy) {
-  const validator = Candy.Validator
-  const userId = await Candy.request('user_id')
+module.exports = async function (Odac) {
+  const validator = Odac.Validator
+  const userId = await Odac.request('user_id')
   
   const isOwner = await checkIfUserOwnsResource(userId)
   const hasPermission = await checkUserPermission('edit')
@@ -323,8 +323,8 @@ module.exports = async function (Candy) {
 #### Example: Chained Validation (Single Statement)
 
 ```javascript
-module.exports = async function (Candy) {
-  return await Candy.Validator
+module.exports = async function (Odac) {
+  return await Odac.Validator
     .post('email').check('required').message('Email required').check('email').message('Invalid email')
     .post('password').check('required').message('Password required').check('minlen:8').message('Min 8 chars')
     .post('age').check('required').message('Age required').check('numeric').message('Must be number').check('min:18').message('Must be 18+')
@@ -335,8 +335,8 @@ module.exports = async function (Candy) {
 #### Example: Admin-Only Action with User Check
 
 ```javascript
-module.exports = async function (Candy) {
-  const validator = Candy.Validator
+module.exports = async function (Odac) {
+  const validator = Odac.Validator
 
   validator
     .var('auth_check', null)
@@ -359,39 +359,39 @@ module.exports = async function (Candy) {
 
 #### Frontend Integration
 
-When using `Candy.form()` on the frontend, validation errors are automatically displayed:
+When using `Odac.form()` on the frontend, validation errors are automatically displayed:
 
 **Automatic Error Display:**
-- Each field's error message appears below the input with attribute `[candy-form-error="fieldname"]`
-- Invalid inputs get the `_candy_error` CSS class automatically
+- Each field's error message appears below the input with attribute `[odac-form-error="fieldname"]`
+- Invalid inputs get the `_odac_error` CSS class automatically
 - Errors fade out when the user focuses on the input
 
 **Success Messages:**
-- Success messages appear in elements with `[candy-form-success]` attribute
+- Success messages appear in elements with `[odac-form-success]` attribute
 - Automatically fades in when validation passes
 
 **Auto-Redirect:**
-- If you pass a URL as the second parameter to `Candy.form()`, successful submissions automatically redirect:
+- If you pass a URL as the second parameter to `Odac.form()`, successful submissions automatically redirect:
   ```javascript
-  Candy.form('myForm', '/dashboard') // Redirects to /dashboard on success
+  Odac.form('myForm', '/dashboard') // Redirects to /dashboard on success
   ```
 
 **Example HTML:**
 ```html
-<form candy-form="register" action="/api/register" method="POST">
+<form odac-form="register" action="/api/register" method="POST">
   <input type="email" name="email" placeholder="Email">
-  <span candy-form-error="email"></span>
+  <span odac-form-error="email"></span>
   
   <input type="password" name="password" placeholder="Password">
-  <span candy-form-error="password"></span>
+  <span odac-form-error="password"></span>
   
   <button type="submit">Register</button>
   
-  <span candy-form-success></span>
+  <span odac-form-success></span>
 </form>
 
 <script>
-  Candy.form('register', '/dashboard') // Auto-redirect on success
+  Odac.form('register', '/dashboard') // Auto-redirect on success
 </script>
 ```
 

package/docs/backend/10-authentication/01-user-logins-with-authjs.md

@@ -1,10 +1,10 @@
 ## 🔐 User Logins with `Auth.js`
 
-The `Candy.Auth` service is your bouncer, managing who gets in and who stays out. It handles user login sessions for you.
+The `Odac.Auth` service is your bouncer, managing who gets in and who stays out. It handles user login sessions for you.
 
 #### Letting a User In
 
-`Candy.Auth.login(userId, userData)`
+`Odac.Auth.login(userId, userData)`
 
 *   `userId`: A unique ID for the user (like their database ID).
 *   `userData`: An object with any user info you want to remember, like their username or role.
@@ -13,41 +13,41 @@ When you call this, `Auth` creates a secure session for the user.
 
 #### Checking the Guest List
 
-*   `Candy.Auth.isLogin()`: Is the current user logged in? Returns `true` or `false`.
-*   `Candy.Auth.getId()`: Gets the ID of the logged-in user.
-*   `Candy.Auth.get('some-key')`: Grabs a specific piece of info from the `userData` you stored.
+*   `Odac.Auth.isLogin()`: Is the current user logged in? Returns `true` or `false`.
+*   `Odac.Auth.getId()`: Gets the ID of the logged-in user.
+*   `Odac.Auth.get('some-key')`: Grabs a specific piece of info from the `userData` you stored.
 
 #### Showing a User Out
 
-*   `Candy.Auth.logout()`: Ends the user's session and logs them out.
+*   `Odac.Auth.logout()`: Ends the user's session and logs them out.
 
 #### Example: A Login Flow
 ```javascript
 // Controller for your login form
-module.exports = async function (Candy) {
-    const { username, password } = Candy.Request.post;
+module.exports = async function (Odac) {
+    const { username, password } = Odac.Request.post;
 
     // IMPORTANT: You need to write your own code to find the user in your database!
     const user = await yourDatabase.findUser(username, password);
 
     if (user) {
         // User is valid! Log them in.
-        Candy.Auth.login(user.id, { username: user.username });
-        return Candy.direct('/dashboard'); // Send them to their dashboard
+        Odac.Auth.login(user.id, { username: user.username });
+        return Odac.direct('/dashboard'); // Send them to their dashboard
     } else {
         // Bad credentials, send them back to the login page
-        return Candy.direct('/login?error=1');
+        return Odac.direct('/login?error=1');
     }
 }
 
 // A protected dashboard page
-module.exports = function (Candy) {
+module.exports = function (Odac) {
     // If they're not logged in, kick them back to the login page.
-    if (!Candy.Auth.isLogin()) {
-        return Candy.direct('/login');
+    if (!Odac.Auth.isLogin()) {
+        return Odac.direct('/login');
     }
 
-    const username = Candy.Auth.get('username');
+    const username = Odac.Auth.get('username');
     return `Welcome back, ${username}!`;
 }
 ```

package/docs/backend/10-authentication/02-foiling-villains-with-csrf-protection.md

@@ -1,6 +1,6 @@
 ## 🛡️ Foiling Villains with CSRF Protection
 
-Cross-Site Request Forgery (CSRF) is a scary-sounding attack where a bad guy tries to trick your users into submitting forms they didn't mean to. The `Candy.Token` service is your shield against this!
+Cross-Site Request Forgery (CSRF) is a scary-sounding attack where a bad guy tries to trick your users into submitting forms they didn't mean to. The `Odac.Token` service is your shield against this!
 
 #### How it Works
 
@@ -13,8 +13,8 @@ If they don't match, it's a trap!
 
 #### Generating and Checking Tokens
 
-*   `Candy.Token.get()`: Creates a new secret token.
-*   `Candy.Token.check(theToken)`: Checks if `theToken` is valid.
+*   `Odac.Token.get()`: Creates a new secret token.
+*   `Odac.Token.check(theToken)`: Checks if `theToken` is valid.
 
 #### Example: Securing a Form
 
@@ -31,22 +31,22 @@ If they don't match, it's a trap!
 
 **2. Your controller that shows the form:**
 ```javascript
-module.exports = function (Candy) {
+module.exports = function (Odac) {
     // Get a token and pass it to the view
-    const token = Candy.Token.get();
-    return Candy.View.render('your_form_view', { csrfToken: token });
+    const token = Odac.Token.get();
+    return Odac.View.render('your_form_view', { csrfToken: token });
 }
 ```
 
 **3. Your controller that handles the form submission:**
 ```javascript
-module.exports = function (Candy) {
-    const submittedToken = Candy.Request.post.csrf_token;
+module.exports = function (Odac) {
+    const submittedToken = Odac.Request.post.csrf_token;
 
     // Check the token!
-    if (!Candy.Token.check(submittedToken)) {
+    if (!Odac.Token.check(submittedToken)) {
         // If it's bad, stop right here.
-        return Candy.return('Invalid CSRF Token!').status(403);
+        return Odac.return('Invalid CSRF Token!').status(403);
     }
 
     // If we get here, the token was good!

package/docs/backend/10-authentication/03-register.md

@@ -1,12 +1,12 @@
 # User Registration
 
-The `Candy.Auth.register()` method provides a secure and user-friendly way to create new user accounts with automatic password hashing, duplicate checking, and optional auto-login.
+The `Odac.Auth.register()` method provides a secure and user-friendly way to create new user accounts with automatic password hashing, duplicate checking, and optional auto-login.
 
 ## Basic Usage
 
 ```javascript
-module.exports = async function (Candy) {
-  const result = await Candy.Auth.register({
+module.exports = async function (Odac) {
+  const result = await Odac.Auth.register({
     email: 'user@example.com',
     username: 'johndoe',
     password: 'securePassword123',
@@ -24,7 +24,7 @@ module.exports = async function (Candy) {
 ## Advanced Options
 
 ```javascript
-const result = await Candy.Auth.register(
+const result = await Odac.Auth.register(
   {
     email: 'user@example.com',
     username: 'johndoe',
@@ -77,8 +77,8 @@ const result = await Candy.Auth.register(
 ## Example Controller
 
 ```javascript
-module.exports = async function (Candy) {
-  const validator = Candy.Validator
+module.exports = async function (Odac) {
+  const validator = Odac.Validator
 
   // Validate input
   validator.post('email').check('required|email').message('A valid email is required')
@@ -90,20 +90,20 @@ module.exports = async function (Candy) {
   }
 
   // Get validated data
-  const email = await Candy.request('email')
-  const username = await Candy.request('username')
-  const password = await Candy.request('password')
-  const name = await Candy.request('name')
+  const email = await Odac.request('email')
+  const username = await Odac.request('username')
+  const password = await Odac.request('password')
+  const name = await Odac.request('name')
   
   // Register user
-  const result = await Candy.Auth.register(
+  const result = await Odac.Auth.register(
     {email, username, password, name},
     {uniqueFields: ['email', 'username']}
   )
   
   if (result.success) {
     // User is now registered and logged in
-    return Candy.direct('/dashboard')
+    return Odac.direct('/dashboard')
   } else {
     // Show error message
     return {error: result.error}