odac 0.9.0 → 1.0.0

package/docs/backend/13-utilities/{01-candy-var.md → 01-odac-var.md}

@@ -1,16 +1,16 @@
-## 🔧 Candy.Var - String Manipulation & Validation
+## 🔧 Odac.Var - String Manipulation & Validation
 
-`Candy.Var` is a powerful utility class for string manipulation, validation, encryption, and formatting. It provides a chainable, fluent interface for common string operations.
+`Odac.Var` is a powerful utility class for string manipulation, validation, encryption, and formatting. It provides a chainable, fluent interface for common string operations.
 
 ### Basic Usage
 
 ```javascript
 // Create a Var instance
-const result = Candy.Var('hello world').slug()
+const result = Odac.Var('hello world').slug()
 // Returns: 'hello-world'
 
 // Chain multiple operations
-const email = Candy.Var('  USER@EXAMPLE.COM  ').trim().toLowerCase()
+const email = Odac.Var('  USER@EXAMPLE.COM  ').trim().toLowerCase()
 ```
 
 ### String Validation
@@ -21,23 +21,23 @@ Check if a string matches specific patterns:
 
 ```javascript
 // Email validation
-Candy.Var('user@example.com').is('email')  // true
-Candy.Var('invalid-email').is('email')     // false
+Odac.Var('user@example.com').is('email')  // true
+Odac.Var('invalid-email').is('email')     // false
 
 // Numeric validation
-Candy.Var('12345').is('numeric')           // true
-Candy.Var('abc123').is('numeric')          // false
+Odac.Var('12345').is('numeric')           // true
+Odac.Var('abc123').is('numeric')          // false
 
 // Multiple conditions (AND logic)
-Candy.Var('abc123').is('alphanumeric')     // true
+Odac.Var('abc123').is('alphanumeric')     // true
 ```
 
 #### isAny() - Multiple Validation (OR logic)
 
 ```javascript
 // Check if value matches ANY of the conditions
-Candy.Var('user@example.com').isAny('email', 'domain')  // true
-Candy.Var('example.com').isAny('email', 'domain')       // true
+Odac.Var('user@example.com').isAny('email', 'domain')  // true
+Odac.Var('example.com').isAny('email', 'domain')       // true
 ```
 
 #### Available Validation Types
@@ -67,11 +67,11 @@ Candy.Var('example.com').isAny('email', 'domain')       // true
 
 ```javascript
 // Controller validation
-module.exports = async function(Candy) {
-  const email = Candy.Request.post('email')
+module.exports = async function(Odac) {
+  const email = Odac.Request.post('email')
   
-  if (!Candy.Var(email).is('email')) {
-    return Candy.return({
+  if (!Odac.Var(email).is('email')) {
+    return Odac.return({
       success: false,
       message: 'Invalid email address'
     })
@@ -87,40 +87,40 @@ module.exports = async function(Candy) {
 
 ```javascript
 // Single value
-Candy.Var('hello world').contains('world')  // true
-Candy.Var('hello world').contains('foo')    // false
+Odac.Var('hello world').contains('world')  // true
+Odac.Var('hello world').contains('foo')    // false
 
 // Multiple values (AND logic - must contain all)
-Candy.Var('hello world').contains('hello', 'world')  // true
-Candy.Var('hello world').contains('hello', 'foo')    // false
+Odac.Var('hello world').contains('hello', 'world')  // true
+Odac.Var('hello world').contains('hello', 'foo')    // false
 ```
 
 #### containsAny() - Check if string contains any value
 
 ```javascript
 // Check if contains ANY of the values (OR logic)
-Candy.Var('hello world').containsAny('foo', 'world')  // true
-Candy.Var('hello world').containsAny('foo', 'bar')    // false
+Odac.Var('hello world').containsAny('foo', 'world')  // true
+Odac.Var('hello world').containsAny('foo', 'bar')    // false
 ```
 
 #### isBegin() - Check if string starts with value
 
 ```javascript
-Candy.Var('hello world').isBegin('hello')  // true
-Candy.Var('hello world').isBegin('world')  // false
+Odac.Var('hello world').isBegin('hello')  // true
+Odac.Var('hello world').isBegin('world')  // false
 
 // Multiple options
-Candy.Var('https://example.com').isBegin('http://', 'https://')  // true
+Odac.Var('https://example.com').isBegin('http://', 'https://')  // true
 ```
 
 #### isEnd() - Check if string ends with value
 
 ```javascript
-Candy.Var('hello world').isEnd('world')  // true
-Candy.Var('hello world').isEnd('hello')  // false
+Odac.Var('hello world').isEnd('world')  // true
+Odac.Var('hello world').isEnd('hello')  // false
 
 // Multiple options
-Candy.Var('image.jpg').isEnd('.jpg', '.png', '.gif')  // true
+Odac.Var('image.jpg').isEnd('.jpg', '.png', '.gif')  // true
 ```
 
 ### String Manipulation
@@ -129,47 +129,47 @@ Candy.Var('image.jpg').isEnd('.jpg', '.png', '.gif')  // true
 
 ```javascript
 // Simple replacement
-Candy.Var('hello world').replace('world', 'universe')
+Odac.Var('hello world').replace('world', 'universe')
 // Returns: 'hello universe'
 
 // Multiple replacements with object
-Candy.Var('Hello {{name}}, welcome to {{site}}').replace({
+Odac.Var('Hello {{name}}, welcome to {{site}}').replace({
   '{{name}}': 'John',
-  '{{site}}': 'CandyPack'
+  '{{site}}': 'Odac'
 })
-// Returns: 'Hello John, welcome to CandyPack'
+// Returns: 'Hello John, welcome to Odac'
 
 // Works with arrays/objects recursively
 const data = {
   title: 'Welcome {{name}}',
   message: 'Hello {{name}}'
 }
-Candy.Var(data).replace({'{{name}}': 'John'})
+Odac.Var(data).replace({'{{name}}': 'John'})
 // Returns: { title: 'Welcome John', message: 'Hello John' }
 ```
 
 #### clear() - Remove specific strings
 
 ```javascript
-Candy.Var('hello-world-test').clear('-')
+Odac.Var('hello-world-test').clear('-')
 // Returns: 'helloworldtest'
 
 // Remove multiple strings
-Candy.Var('a1b2c3').clear('1', '2', '3')
+Odac.Var('a1b2c3').clear('1', '2', '3')
 // Returns: 'abc'
 ```
 
 #### slug() - Create URL-friendly slug
 
 ```javascript
-Candy.Var('Hello World!').slug()
+Odac.Var('Hello World!').slug()
 // Returns: 'hello-world'
 
-Candy.Var('Product Name 2024').slug()
+Odac.Var('Product Name 2024').slug()
 // Returns: 'product-name-2024'
 
 // Custom separator
-Candy.Var('Hello World').slug('_')
+Odac.Var('Hello World').slug('_')
 // Returns: 'hello_world'
 ```
 
@@ -177,17 +177,17 @@ Candy.Var('Hello World').slug('_')
 
 ```javascript
 // ? = single character, * = rest of string
-Candy.Var('1234567890').format('(???) ???-????')
+Odac.Var('1234567890').format('(???) ???-????')
 // Returns: '(123) 456-7890'
 
-Candy.Var('TR1234567890').format('?? *')
+Odac.Var('TR1234567890').format('?? *')
 // Returns: 'TR 1234567890'
 ```
 
 #### html() - Escape HTML
 
 ```javascript
-Candy.Var('<script>alert("xss")</script>').html()
+Odac.Var('<script>alert("xss")</script>').html()
 // Returns: '&lt;script&gt;alert("xss")&lt;/script&gt;'
 ```
 
@@ -197,46 +197,46 @@ Candy.Var('<script>alert("xss")</script>').html()
 
 ```javascript
 // Hash a password
-const hashedPassword = Candy.Var('mypassword').hash()
+const hashedPassword = Odac.Var('mypassword').hash()
 // Returns: '$2b$10$...' (BCrypt hash)
 
 // Custom salt rounds
-const hashedPassword = Candy.Var('mypassword').hash(12)
+const hashedPassword = Odac.Var('mypassword').hash(12)
 ```
 
 #### hashCheck() - Verify BCrypt hash
 
 ```javascript
 const hashedPassword = '$2b$10$...'
-const isValid = Candy.Var(hashedPassword).hashCheck('mypassword')
+const isValid = Odac.Var(hashedPassword).hashCheck('mypassword')
 // Returns: true or false
 ```
 
 #### md5() - MD5 hash
 
 ```javascript
-Candy.Var('hello').md5()
+Odac.Var('hello').md5()
 // Returns: '5d41402abc4b2a76b9719d911017c592'
 ```
 
 #### encrypt() - AES-256 encryption
 
 ```javascript
-// Uses key from Candy.Config.encrypt.key
-const encrypted = Candy.Var('secret data').encrypt()
+// Uses key from Odac.Config.encrypt.key
+const encrypted = Odac.Var('secret data').encrypt()
 
 // Custom encryption key
-const encrypted = Candy.Var('secret data').encrypt('my-32-character-encryption-key')
+const encrypted = Odac.Var('secret data').encrypt('my-32-character-encryption-key')
 ```
 
 #### decrypt() - AES-256 decryption
 
 ```javascript
-// Uses key from Candy.Config.encrypt.key
-const decrypted = Candy.Var(encryptedData).decrypt()
+// Uses key from Odac.Config.encrypt.key
+const decrypted = Odac.Var(encryptedData).decrypt()
 
 // Custom decryption key
-const decrypted = Candy.Var(encryptedData).decrypt('my-32-character-encryption-key')
+const decrypted = Odac.Var(encryptedData).decrypt('my-32-character-encryption-key')
 ```
 
 ### Date Formatting
@@ -246,16 +246,16 @@ const decrypted = Candy.Var(encryptedData).decrypt('my-32-character-encryption-k
 ```javascript
 const timestamp = '2024-03-15 14:30:45'
 
-Candy.Var(timestamp).date('Y-m-d')
+Odac.Var(timestamp).date('Y-m-d')
 // Returns: '2024-03-15'
 
-Candy.Var(timestamp).date('d/m/Y')
+Odac.Var(timestamp).date('d/m/Y')
 // Returns: '15/03/2024'
 
-Candy.Var(timestamp).date('H:i:s')
+Odac.Var(timestamp).date('H:i:s')
 // Returns: '14:30:45'
 
-Candy.Var(timestamp).date('Y-m-d H:i')
+Odac.Var(timestamp).date('Y-m-d H:i')
 // Returns: '2024-03-15 14:30'
 ```
 
@@ -274,10 +274,10 @@ Candy.Var(timestamp).date('Y-m-d H:i')
 
 ```javascript
 // Save content to file
-Candy.Var('Hello World').save('/path/to/file.txt')
+Odac.Var('Hello World').save('/path/to/file.txt')
 
 // Automatically creates directories if needed
-Candy.Var(jsonData).save('/path/to/nested/dir/data.json')
+Odac.Var(jsonData).save('/path/to/nested/dir/data.json')
 ```
 
 ### Practical Examples
@@ -285,117 +285,117 @@ Candy.Var(jsonData).save('/path/to/nested/dir/data.json')
 #### User Registration with Validation
 
 ```javascript
-module.exports = async function(Candy) {
-  const email = Candy.Request.post('email')
-  const password = Candy.Request.post('password')
-  const username = Candy.Request.post('username')
+module.exports = async function(Odac) {
+  const email = Odac.Request.post('email')
+  const password = Odac.Request.post('password')
+  const username = Odac.Request.post('username')
   
   // Validate email
-  if (!Candy.Var(email).is('email')) {
-    return Candy.return({
+  if (!Odac.Var(email).is('email')) {
+    return Odac.return({
       success: false,
       message: 'Invalid email address'
     })
   }
   
   // Validate username (alphanumeric only)
-  if (!Candy.Var(username).is('alphanumeric')) {
-    return Candy.return({
+  if (!Odac.Var(username).is('alphanumeric')) {
+    return Odac.return({
       success: false,
       message: 'Username must be alphanumeric'
     })
   }
   
   // Hash password
-  const hashedPassword = Candy.Var(password).hash()
+  const hashedPassword = Odac.Var(password).hash()
   
   // Create slug for profile URL
-  const profileSlug = Candy.Var(username).slug()
+  const profileSlug = Odac.Var(username).slug()
   
   // Save user
-  await Candy.Mysql.table('users').insert({
+  await Odac.Mysql.table('users').insert({
     email: email,
     username: username,
     password: hashedPassword,
     slug: profileSlug
   })
   
-  return Candy.return({success: true})
+  return Odac.return({success: true})
 }
 ```
 
 #### Login with Password Verification
 
 ```javascript
-module.exports = async function(Candy) {
-  const email = Candy.Request.post('email')
-  const password = Candy.Request.post('password')
+module.exports = async function(Odac) {
+  const email = Odac.Request.post('email')
+  const password = Odac.Request.post('password')
   
   // Find user
-  const user = await Candy.Mysql.table('users')
+  const user = await Odac.Mysql.table('users')
     .where('email', email)
     .first()
   
   if (!user) {
-    return Candy.return({
+    return Odac.return({
       success: false,
       message: 'User not found'
     })
   }
   
   // Verify password
-  const isValid = Candy.Var(user.password).hashCheck(password)
+  const isValid = Odac.Var(user.password).hashCheck(password)
   
   if (!isValid) {
-    return Candy.return({
+    return Odac.return({
       success: false,
       message: 'Invalid password'
     })
   }
   
   // Login successful
-  Candy.Auth.login(user.id)
-  return Candy.return({success: true})
+  Odac.Auth.login(user.id)
+  return Odac.return({success: true})
 }
 ```
 
 #### URL Slug Generation
 
 ```javascript
-module.exports = async function(Candy) {
-  const title = Candy.Request.post('title')
+module.exports = async function(Odac) {
+  const title = Odac.Request.post('title')
   
   // Create URL-friendly slug
-  const slug = Candy.Var(title).slug()
+  const slug = Odac.Var(title).slug()
   
   // Check if slug exists
-  const exists = await Candy.Mysql.table('posts')
+  const exists = await Odac.Mysql.table('posts')
     .where('slug', slug)
     .first()
   
   if (exists) {
     // Add timestamp to make unique
     const uniqueSlug = `${slug}-${Date.now()}`
-    await Candy.Mysql.table('posts').insert({
+    await Odac.Mysql.table('posts').insert({
       title: title,
       slug: uniqueSlug
     })
   } else {
-    await Candy.Mysql.table('posts').insert({
+    await Odac.Mysql.table('posts').insert({
       title: title,
       slug: slug
     })
   }
   
-  return Candy.return({success: true})
+  return Odac.return({success: true})
 }
 ```
 
 #### Template Variable Replacement
 
 ```javascript
-module.exports = async function(Candy) {
-  const user = await Candy.Auth.user()
+module.exports = async function(Odac) {
+  const user = await Odac.Auth.user()
   
   // Email template
   const template = `
@@ -409,45 +409,45 @@ module.exports = async function(Candy) {
   `
   
   // Replace variables
-  const emailContent = Candy.Var(template).replace({
+  const emailContent = Odac.Var(template).replace({
     '{{name}}': user.name,
     '{{email}}': user.email,
     '{{url}}': 'https://example.com/dashboard',
-    '{{site}}': 'CandyPack'
+    '{{site}}': 'Odac'
   })
   
   // Send email
-  await Candy.Mail.send({
+  await Odac.Mail.send({
     to: user.email,
     subject: 'Account Verified',
     body: emailContent
   })
   
-  return Candy.return({success: true})
+  return Odac.return({success: true})
 }
 ```
 
 #### Phone Number Formatting
 
 ```javascript
-module.exports = async function(Candy) {
-  const phone = Candy.Request.post('phone')
+module.exports = async function(Odac) {
+  const phone = Odac.Request.post('phone')
   
   // Remove all non-numeric characters
-  const cleanPhone = Candy.Var(phone).clear('-', ' ', '(', ')', '+')
+  const cleanPhone = Odac.Var(phone).clear('-', ' ', '(', ')', '+')
   
   // Validate it's numeric
-  if (!Candy.Var(cleanPhone).is('numeric')) {
-    return Candy.return({
+  if (!Odac.Var(cleanPhone).is('numeric')) {
+    return Odac.return({
       success: false,
       message: 'Invalid phone number'
     })
   }
   
   // Format for display
-  const formattedPhone = Candy.Var(cleanPhone).format('(???) ???-????')
+  const formattedPhone = Odac.Var(cleanPhone).format('(???) ???-????')
   
-  return Candy.return({
+  return Odac.return({
     success: true,
     phone: formattedPhone
   })
@@ -457,31 +457,31 @@ module.exports = async function(Candy) {
 #### Data Encryption for Storage
 
 ```javascript
-module.exports = async function(Candy) {
-  const creditCard = Candy.Request.post('credit_card')
+module.exports = async function(Odac) {
+  const creditCard = Odac.Request.post('credit_card')
   
   // Encrypt sensitive data
-  const encryptedCard = Candy.Var(creditCard).encrypt()
+  const encryptedCard = Odac.Var(creditCard).encrypt()
   
   // Save encrypted data
-  await Candy.Mysql.table('payments').insert({
-    user_id: Candy.Auth.id(),
+  await Odac.Mysql.table('payments').insert({
+    user_id: Odac.Auth.id(),
     card: encryptedCard
   })
   
-  return Candy.return({success: true})
+  return Odac.return({success: true})
 }
 
 // Later, to retrieve and decrypt
-module.exports = async function(Candy) {
-  const payment = await Candy.Mysql.table('payments')
-    .where('user_id', Candy.Auth.id())
+module.exports = async function(Odac) {
+  const payment = await Odac.Mysql.table('payments')
+    .where('user_id', Odac.Auth.id())
     .first()
   
   // Decrypt data
-  const creditCard = Candy.Var(payment.card).decrypt()
+  const creditCard = Odac.Var(payment.card).decrypt()
   
-  return Candy.return({
+  return Odac.return({
     card: creditCard
   })
 }
@@ -498,7 +498,7 @@ module.exports = async function(Candy) {
 
 ### Notes
 
-- `Candy.Var()` returns the processed string value, not a Var instance (except for chaining)
+- `Odac.Var()` returns the processed string value, not a Var instance (except for chaining)
 - Encryption uses AES-256-CBC with a fixed IV
 - BCrypt hashing is one-way and cannot be decrypted
 - Date formatting works with any valid JavaScript date string