odac 0.9.0

package/docs/server/07-mail/01-create-a-mail-account.md

@@ -0,0 +1,23 @@
+## ✉️ Create a Mail Account
+This command allows you to create a new email account.
+
+### Interactive Usage
+```bash
+candy mail create
+```
+You will be prompted to enter the new email address and a password for the account.
+
+### Single-Line Usage with Prefixes
+```bash
+# Specify email and password directly
+candy mail create -e user@example.com -p mypassword
+
+# Or use long form prefixes
+candy mail create --email user@example.com --password mypassword
+```
+
+### Available Prefixes
+- `-e`, `--email`: Email address for the new account
+- `-p`, `--password`: Password for the new account
+
+**Note:** When using the `-p` prefix, you won't be prompted to confirm the password. In interactive mode, you'll need to enter the password twice for confirmation.

package/docs/server/07-mail/02-delete-a-mail-account.md

@@ -0,0 +1,20 @@
+## 🗑️ Delete a Mail Account
+This command removes an existing email account.
+
+### Interactive Usage
+```bash
+candy mail delete
+```
+You will be prompted to enter the email address you wish to delete.
+
+### Single-Line Usage with Prefixes
+```bash
+# Specify email directly
+candy mail delete -e user@example.com
+
+# Or use long form prefix
+candy mail delete --email user@example.com
+```
+
+### Available Prefixes
+- `-e`, `--email`: Email address to delete

package/docs/server/07-mail/03-list-mail-accounts.md

@@ -0,0 +1,20 @@
+## 📋 List Mail Accounts
+This command lists all email accounts associated with a specific domain.
+
+### Interactive Usage
+```bash
+candy mail list
+```
+You will be prompted to enter the domain name (e.g., `example.com`) to see all its email accounts.
+
+### Single-Line Usage with Prefixes
+```bash
+# Specify domain directly
+candy mail list -d example.com
+
+# Or use long form prefix
+candy mail list --domain example.com
+```
+
+### Available Prefixes
+- `-d`, `--domain`: Domain name to list email accounts for

package/docs/server/07-mail/04-change-account-password.md

@@ -0,0 +1,23 @@
+## 🔑 Change Account Password
+This command allows you to change the password for an existing email account.
+
+### Interactive Usage
+```bash
+candy mail password
+```
+You will be prompted to enter the email address and the new password.
+
+### Single-Line Usage with Prefixes
+```bash
+# Specify email and new password directly
+candy mail password -e user@example.com -p newpassword
+
+# Or use long form prefixes
+candy mail password --email user@example.com --password newpassword
+```
+
+### Available Prefixes
+- `-e`, `--email`: Email address to change password for
+- `-p`, `--password`: New password for the account
+
+**Note:** When using the `-p` prefix, you won't be prompted to confirm the password. In interactive mode, you'll need to enter the password twice for confirmation.

package/eslint.config.mjs

@@ -0,0 +1,120 @@
+import js from '@eslint/js'
+import globals from 'globals'
+import {defineConfig} from 'eslint/config'
+import prettierPlugin from 'eslint-plugin-prettier'
+import prettierConfig from 'eslint-config-prettier'
+
+export default defineConfig([
+  {
+    files: ['core/**/*.js', 'watchdog/**/*.js', 'server/**/*.js', 'cli/**/*.js'],
+    ignores: ['server/src/Candy.js'],
+    languageOptions: {
+      globals: {
+        ...globals.node,
+        Candy: 'readonly',
+        __: 'readonly'
+      },
+      sourceType: 'script'
+    },
+    plugins: {
+      js,
+      prettier: prettierPlugin
+    },
+    rules: {
+      ...js.configs.recommended.rules,
+      ...prettierConfig.rules,
+      'prettier/prettier': 'error'
+    }
+  },
+  {
+    files: ['server/src/Candy.js'],
+    languageOptions: {
+      globals: {
+        ...globals.node,
+        log: 'readonly',
+        __: 'readonly'
+      },
+      sourceType: 'script'
+    },
+    plugins: {
+      js,
+      prettier: prettierPlugin
+    },
+    rules: {
+      ...js.configs.recommended.rules,
+      ...prettierConfig.rules,
+      'prettier/prettier': 'error'
+    }
+  },
+  {
+    files: ['framework/**/*.js'],
+    ignores: ['framework/web/**/*.js'],
+    languageOptions: {
+      globals: {
+        ...globals.node,
+        Candy: 'readonly',
+        __dir: 'readonly'
+      },
+      sourceType: 'script'
+    },
+    plugins: {
+      js,
+      prettier: prettierPlugin
+    },
+    rules: {
+      ...js.configs.recommended.rules,
+      ...prettierConfig.rules,
+      'prettier/prettier': 'error'
+    }
+  },
+  {
+    files: ['framework/web/**/*.js'],
+    languageOptions: {
+      globals: {...globals.browser},
+      sourceType: 'module'
+    },
+    plugins: {js},
+    rules: {
+      ...js.configs.recommended.rules
+    }
+  },
+  {
+    files: ['web/**/*.js'],
+    ignores: ['web/public/**/*.js'],
+    languageOptions: {
+      globals: {
+        ...globals.node,
+        Candy: 'readonly'
+      },
+      sourceType: 'script'
+    },
+    plugins: {
+      js,
+      prettier: prettierPlugin
+    },
+    rules: {
+      ...js.configs.recommended.rules,
+      ...prettierConfig.rules,
+      'prettier/prettier': 'error'
+    }
+  },
+  {
+    files: ['web/public/**/*.js'],
+    languageOptions: {
+      globals: {
+        ...globals.browser,
+        Candy: 'readonly'
+      },
+      sourceType: 'script'
+    },
+    plugins: {
+      js,
+      prettier: prettierPlugin
+    },
+    rules: {
+      ...js.configs.recommended.rules,
+      ...prettierConfig.rules,
+      'prettier/prettier': 'error'
+    }
+  }
+])

package/framework/index.js

@@ -0,0 +1,4 @@
+'use strict'
+
+global.__dir = process.cwd()
+require('./src/Candy.js').init()

package/framework/src/Auth.js

@@ -0,0 +1,309 @@
+class Auth {
+  #request = null
+  #table = null
+  #user = null
+
+  constructor(request) {
+    this.#request = request
+  }
+
+  #validateInput(where) {
+    if (!where || typeof where !== 'object') return false
+    for (const key in where) {
+      const value = where[key]
+      if (value instanceof Promise) continue
+      if (typeof value !== 'string' && typeof value !== 'number') return false
+    }
+    return true
+  }
+
+  async check(where) {
+    if (!Candy.Config.auth) Candy.Config.auth = {}
+    this.#table = Candy.Config.auth.table || 'users'
+    if (!this.#table) return false
+    if (where) {
+      if (!this.#validateInput(where)) return false
+      let sql = Candy.Mysql.table(this.#table)
+      if (!sql) {
+        console.error('CandyPack Auth Error: MySQL connection not configured. Please add database configuration to your config.json')
+        return false
+      }
+      for (let key in where) sql = sql.orWhere(key, where[key] instanceof Promise ? await where[key] : where[key])
+      if (!sql.rows()) return false
+      let get = await sql.get()
+      let equal = false
+      for (var user of get) {
+        equal = Object.keys(where).length > 0
+        for (let key of Object.keys(where)) {
+          if (where[key] instanceof Promise) where[key] = await where[key]
+          if (!user[key]) equal = false
+          if (user[key] === where[key]) equal = equal && true
+          else if (Candy.Var(user[key]).is('bcrypt')) equal = equal && Candy.Var(user[key]).hashCheck(where[key])
+          else if (Candy.Var(user[key]).is('md5')) equal = equal && Candy.Var(where[key]).md5() === user[key]
+        }
+        if (equal) break
+      }
+      if (!equal) return false
+      return user
+    } else if (this.#user) {
+      return true
+    } else {
+      let check_table = await Candy.Mysql.run('SHOW TABLES LIKE ?', [this.#table])
+      if (check_table.length == 0) return false
+      let candy_x = this.#request.cookie('candy_x')
+      let candy_y = this.#request.cookie('candy_y')
+      let browser = this.#request.header('user-agent')
+      if (!candy_x || !candy_y || !browser) return false
+      const tokenTable = Candy.Config.auth.token || 'candy_auth'
+      const primaryKey = Candy.Config.auth.key || 'id'
+      let sql_token = await Candy.Mysql.table(tokenTable).where(['token_x', candy_x], ['browser', browser]).get()
+      if (sql_token.length !== 1) return false
+      if (!Candy.Var(sql_token[0].token_y).hashCheck(candy_y)) return false
+
+      const maxAge = Candy.Config.auth?.maxAge || 30 * 24 * 60 * 60 * 1000
+      const updateAge = Candy.Config.auth?.updateAge || 24 * 60 * 60 * 1000
+      const now = Date.now()
+      const lastActive = new Date(sql_token[0].active).getTime()
+      const inactiveAge = now - lastActive
+
+      if (inactiveAge > maxAge) {
+        await Candy.Mysql.table(tokenTable).where('id', sql_token[0].id).delete()
+        return false
+      }
+
+      this.#user = await Candy.Mysql.table(this.#table).where(primaryKey, sql_token[0].user).first()
+
+      if (inactiveAge > updateAge) {
+        Candy.Mysql.table(tokenTable)
+          .where('id', sql_token[0].id)
+          .set({active: new Date()})
+          .catch(() => {})
+      }
+
+      return true
+    }
+  }
+
+  async login(where) {
+    this.#user = null
+    let user = await this.check(where)
+    if (!user) return false
+    if (!Candy.Config.auth) Candy.Config.auth = {}
+    let key = Candy.Config.auth.key || 'id'
+    let token = Candy.Config.auth.token || 'candy_auth'
+    const mysql = require('mysql2')
+    const safeTokenTable = mysql.escapeId(token)
+    let check_table = await Candy.Mysql.run('SHOW TABLES LIKE ?', [token])
+    if (check_table === false) {
+      console.error('CandyPack Auth Error: MySQL connection not configured. Please add database configuration to your config.json')
+      return false
+    }
+    if (check_table.length == 0)
+      await Candy.Mysql.run(
+        `CREATE TABLE ${safeTokenTable} (id INT NOT NULL AUTO_INCREMENT, user INT NOT NULL, token_x VARCHAR(255) NOT NULL, token_y VARCHAR(255) NOT NULL, browser VARCHAR(255) NOT NULL, ip VARCHAR(255) NOT NULL, \`date\` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP, \`active\` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP, PRIMARY KEY (id))`
+      )
+
+    this.#cleanupExpiredTokens(token)
+
+    let token_y = Candy.Var(Math.random().toString() + Date.now().toString() + this.#request.id + this.#request.ip).md5()
+    let cookie = {
+      user: user[key],
+      token_x: Candy.Var(Math.random().toString() + Date.now().toString()).md5(),
+      token_y: Candy.Var(token_y).hash(),
+      browser: this.#request.header('user-agent'),
+      ip: this.#request.ip
+    }
+    this.#request.cookie('candy_x', cookie.token_x, {
+      httpOnly: true,
+      secure: true,
+      sameSite: 'Strict'
+    })
+    this.#request.cookie('candy_y', token_y, {httpOnly: true, secure: true, sameSite: 'Strict'})
+    let mysqlTable = Candy.Mysql.table(token)
+    if (!mysqlTable) {
+      console.error('CandyPack Auth Error: MySQL connection not configured. Please add database configuration to your config.json')
+      return false
+    }
+    let sql = await mysqlTable.insert(cookie)
+    return sql !== false
+  }
+
+  async #cleanupExpiredTokens(tokenTable) {
+    const maxAge = Candy.Config.auth?.maxAge || 30 * 24 * 60 * 60 * 1000
+    const cutoffDate = new Date(Date.now() - maxAge)
+
+    Candy.Mysql.table(tokenTable)
+      .where('active', '<', cutoffDate)
+      .delete()
+      .catch(() => {})
+  }
+
+  async register(data, options = {}) {
+    if (!Candy.Config.auth) {
+      Candy.Config.auth = {}
+    }
+
+    this.#table = Candy.Config.auth.table || 'users'
+    const primaryKey = Candy.Config.auth.key || 'id'
+    const passwordField = options.passwordField || 'password'
+    const uniqueFields = options.uniqueFields || ['email']
+
+    const checkTable = await Candy.Mysql.run('SHOW TABLES LIKE ?', [this.#table])
+    if (checkTable === false) {
+      console.error('CandyPack Auth Error: MySQL connection not configured. Please add database configuration to your config.json')
+      return {success: false, error: 'Database connection not configured'}
+    }
+    if (checkTable.length === 0) {
+      await this.#createUserTable(this.#table, primaryKey, passwordField, uniqueFields, data)
+    }
+
+    if (!data || typeof data !== 'object') {
+      return {success: false, error: 'Invalid data provided'}
+    }
+
+    if (data[passwordField] && !Candy.Var(data[passwordField]).is('bcrypt')) {
+      data[passwordField] = Candy.Var(data[passwordField]).hash()
+    }
+
+    for (const field of uniqueFields) {
+      if (data[field]) {
+        const mysqlTable = Candy.Mysql.table(this.#table)
+        if (!mysqlTable) {
+          console.error('CandyPack Auth Error: MySQL connection not configured. Please add database configuration to your config.json')
+          return {success: false, error: 'Database connection not configured'}
+        }
+        const existing = await mysqlTable.where(field, data[field]).first()
+        if (existing) {
+          return {success: false, error: `${field} already exists`, field}
+        }
+      }
+    }
+
+    try {
+      const mysqlTable = Candy.Mysql.table(this.#table)
+      if (!mysqlTable) {
+        console.error('CandyPack Auth Error: MySQL connection not configured. Please add database configuration to your config.json')
+        return {success: false, error: 'Database connection not configured'}
+      }
+      const insertResult = await mysqlTable.insert(data)
+      if (insertResult === false) {
+        console.error('CandyPack Auth Error: Failed to insert user into database - query failed')
+        console.error('Data attempted to insert:', {...data, [passwordField]: '[REDACTED]'})
+        return {success: false, error: 'Failed to create user'}
+      }
+      if (!insertResult.affected || insertResult.affected === 0) {
+        console.error('CandyPack Auth Error: Insert query succeeded but no rows were affected')
+        console.error('Insert result:', insertResult)
+        console.error('Data attempted to insert:', {...data, [passwordField]: '[REDACTED]'})
+        return {success: false, error: 'Failed to create user'}
+      }
+
+      const userId = insertResult.id
+      const newUser = await Candy.Mysql.table(this.#table).where(primaryKey, userId).first()
+
+      if (!newUser) {
+        return {success: false, error: 'User created but could not be retrieved'}
+      }
+
+      delete newUser[passwordField]
+
+      if (options.autoLogin !== false) {
+        const loginData = {}
+        loginData[primaryKey] = userId
+        const loginSuccess = await this.login(loginData)
+
+        if (!loginSuccess) {
+          return {success: true, user: newUser, autoLogin: false, message: 'User created but auto-login failed'}
+        }
+      }
+
+      return {success: true, user: newUser}
+    } catch (error) {
+      console.error('CandyPack Auth Error: Registration failed with exception')
+      console.error('Error:', error.message)
+      console.error('Stack:', error.stack)
+      return {success: false, error: error.message || 'Registration failed'}
+    }
+  }
+
+  async logout() {
+    if (!this.#user) return false
+
+    if (!Candy.Config.auth) Candy.Config.auth = {}
+    const token = Candy.Config.auth.token || 'user_tokens'
+    const candyX = this.#request.cookie('candy_x')
+    const browser = this.#request.header('user-agent')
+
+    if (candyX && browser) {
+      const mysqlTable = Candy.Mysql.table(token)
+      if (mysqlTable) {
+        await mysqlTable.where(['token_x', candyX], ['browser', browser]).delete()
+      }
+    }
+
+    this.#request.cookie('candy_x', '', {maxAge: -1})
+    this.#request.cookie('candy_y', '', {maxAge: -1})
+
+    this.#user = null
+    return true
+  }
+
+  async #createUserTable(tableName, primaryKey, passwordField, uniqueFields, sampleData) {
+    const mysql = require('mysql2')
+    const columns = []
+
+    const safePrimaryKey = mysql.escapeId(primaryKey)
+    columns.push(`${safePrimaryKey} INT NOT NULL AUTO_INCREMENT`)
+
+    for (const field of uniqueFields) {
+      if (field !== primaryKey) {
+        const safeField = mysql.escapeId(field)
+        columns.push(`${safeField} VARCHAR(255) NOT NULL UNIQUE`)
+      }
+    }
+
+    if (!uniqueFields.includes(passwordField) && passwordField !== primaryKey) {
+      const safePasswordField = mysql.escapeId(passwordField)
+      columns.push(`${safePasswordField} VARCHAR(255) NOT NULL`)
+    }
+
+    for (const key in sampleData) {
+      if (key === primaryKey || uniqueFields.includes(key) || key === passwordField) continue
+
+      const value = sampleData[key]
+      let columnType = 'VARCHAR(255)'
+
+      if (typeof value === 'number') {
+        if (Number.isInteger(value)) {
+          columnType = value > 2147483647 ? 'BIGINT' : 'INT'
+        } else {
+          columnType = 'DECIMAL(10,2)'
+        }
+      } else if (typeof value === 'boolean') {
+        columnType = 'TINYINT(1)'
+      } else if (value && value.length > 255) {
+        columnType = 'TEXT'
+      }
+
+      const safeKey = mysql.escapeId(key)
+      columns.push(`${safeKey} ${columnType} NULL`)
+    }
+
+    columns.push(`${mysql.escapeId('created_at')} TIMESTAMP DEFAULT CURRENT_TIMESTAMP`)
+    columns.push(`${mysql.escapeId('updated_at')} TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP`)
+    columns.push(`PRIMARY KEY (${safePrimaryKey})`)
+
+    const safeTableName = mysql.escapeId(tableName)
+    const sql = `CREATE TABLE ${safeTableName} (${columns.join(', ')}) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci`
+
+    await Candy.Mysql.run(sql)
+  }
+
+  user(col) {
+    if (!this.#user) return false
+    if (col === null) return this.#user
+    else return this.#user[col]
+  }
+}
+
+module.exports = Auth

package/framework/src/Candy.js

@@ -0,0 +1,81 @@
+module.exports = {
+  init: async function () {
+    global.Candy = this.instance()
+    await global.Candy.Env.init()
+    await global.Candy.Config.init()
+    await global.Candy.Mysql.init()
+    await global.Candy.Route.init()
+    await global.Candy.Server.init()
+    global.Candy.instance = this.instance
+    global.__ = value => {
+      return value
+    }
+  },
+
+  instance(id, req, res) {
+    let _candy = {}
+
+    _candy.Config = require('./Config.js')
+    _candy.Env = require('./Env.js')
+    _candy.Mail = (...args) => new (require('./Mail.js'))(...args)
+    _candy.Mysql = require('./Mysql.js')
+    _candy.Route = global.Candy?.Route ?? new (require('./Route.js'))()
+    _candy.Server = require('./Server.js')
+    _candy.Var = (...args) => new (require('./Var.js'))(...args)
+
+    if (req && res) {
+      _candy.Request = new (require('./Request.js'))(id, req, res, _candy)
+      _candy.Auth = new (require('./Auth.js'))(_candy.Request)
+      _candy.Token = new (require('./Token.js'))(_candy.Request)
+      _candy.Lang = new (require('./Lang.js'))(_candy)
+      _candy.View = new (require('./View.js'))(_candy)
+
+      if (global.Candy?.Route?.class) {
+        for (const name in global.Candy.Route.class) {
+          const Module = global.Candy.Route.class[name].module
+          _candy[name] = typeof Module === 'function' ? new Module(_candy) : Module
+        }
+      }
+
+      _candy.__ = function (...args) {
+        return _candy.Lang.get(...args)
+      }
+      _candy.abort = function (code) {
+        return _candy.Request.abort(code)
+      }
+      _candy.cookie = function (key, value, options) {
+        return _candy.Request.cookie(key, value, options)
+      }
+      _candy.direct = function (url) {
+        return _candy.Request.redirect(url)
+      }
+      _candy.env = function (key, defaultValue) {
+        return _candy.Env.get(key, defaultValue)
+      }
+      _candy.return = function (data) {
+        return _candy.Request.end(data)
+      }
+      _candy.request = function (key) {
+        return _candy.Request.request(key)
+      }
+      _candy.set = function (key, value) {
+        return _candy.Request.set(key, value)
+      }
+      _candy.token = function (hash) {
+        return hash ? _candy.Token.check(hash) : _candy.Token.generate()
+      }
+      _candy.validator = function () {
+        return new (require('./Validator.js'))(_candy.Request)
+      }
+      _candy.write = function (value) {
+        return _candy.Request.write(value)
+      }
+      _candy.stream = function (input) {
+        _candy.Request.clearTimeout()
+        return new (require('./Stream'))(_candy.Request.req, _candy.Request.res, input)
+      }
+    }
+
+    return _candy
+  }
+}

package/framework/src/Config.js

@@ -0,0 +1,79 @@
+const nodeCrypto = require('crypto')
+const fs = require('fs')
+const os = require('os')
+
+module.exports = {
+  auth: {
+    key: 'id',
+    token: 'candy_auth'
+  },
+  request: {
+    timeout: 10000
+  },
+  encrypt: {
+    key: 'candy'
+  },
+  earlyHints: {
+    enabled: true,
+    auto: true,
+    maxResources: 5
+  },
+
+  init: function () {
+    try {
+      this.system = JSON.parse(fs.readFileSync(os.homedir() + '/.candypack/config.json'))
+    } catch {
+      this.system = {}
+    }
+
+    if (fs.existsSync(__dir + '/config.json')) {
+      let config = {}
+      try {
+        config = JSON.parse(fs.readFileSync(__dir + '/config.json'))
+        config = this._interpolate(config)
+      } catch (err) {
+        console.error('Error reading config file:', __dir + '/config.json', err.message)
+      }
+      this._deepMerge(this, config)
+    }
+    this.encrypt.key = nodeCrypto.createHash('md5').update(this.encrypt.key).digest('hex')
+  },
+
+  _interpolate: function (obj) {
+    if (typeof obj === 'string') {
+      return obj.replace(/\$\{(\w+)\}/g, (_, key) => {
+        // Special variables
+        if (key === 'candy') {
+          return __dirname.replace(/\/framework\/src$/, '')
+        }
+        // Environment variables
+        return process.env[key] || ''
+      })
+    }
+    if (Array.isArray(obj)) {
+      return obj.map(item => this._interpolate(item))
+    }
+    if (obj && typeof obj === 'object') {
+      const result = {}
+      for (const key of Object.keys(obj)) {
+        result[key] = this._interpolate(obj[key])
+      }
+      return result
+    }
+    return obj
+  },
+
+  _deepMerge: function (target, source) {
+    for (const key of Object.keys(source)) {
+      if (source[key] && typeof source[key] === 'object' && !Array.isArray(source[key])) {
+        // Ensure target[key] is also an object before recursive merge
+        if (!target[key] || typeof target[key] !== 'object' || Array.isArray(target[key])) {
+          target[key] = {}
+        }
+        this._deepMerge(target[key], source[key])
+      } else {
+        target[key] = source[key]
+      }
+    }
+  }
+}